refactor: susun semula struktur folder — Laravel source ke src/

vendor/laravel/mcp/src/Response.php

@@ -0,0 +1,186 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Laravel\Mcp;
+
+use Illuminate\Filesystem\FilesystemAdapter;
+use Illuminate\Support\Facades\Storage;
+use Illuminate\Support\Traits\Conditionable;
+use Illuminate\Support\Traits\Macroable;
+use InvalidArgumentException;
+use JsonException;
+use Laravel\Mcp\Enums\Role;
+use Laravel\Mcp\Server\Content\Audio;
+use Laravel\Mcp\Server\Content\Blob;
+use Laravel\Mcp\Server\Content\Image;
+use Laravel\Mcp\Server\Content\Notification;
+use Laravel\Mcp\Server\Content\Text;
+use Laravel\Mcp\Server\Contracts\Content;
+use League\Flysystem\UnableToReadFile;
+
+class Response
+{
+    use Conditionable;
+    use Macroable;
+
+    protected function __construct(
+        protected Content $content,
+        protected Role $role = Role::User,
+        protected bool $isError = false,
+    ) {
+        //
+    }
+
+    /**
+     * @param  array<string, mixed>  $params
+     */
+    public static function notification(string $method, array $params = []): static
+    {
+        return new static(new Notification($method, $params));
+    }
+
+    public static function text(string $text): static
+    {
+        return new static(new Text($text));
+    }
+
+    public static function html(string $path): static
+    {
+        $path = str_starts_with($path, '/') || preg_match('/^[a-zA-Z]:[\\\\\\/]/', $path) ? $path : resource_path($path);
+
+        if (! file_exists($path)) {
+            throw new InvalidArgumentException("File not found at path [{$path}].");
+        }
+
+        return static::text((string) file_get_contents($path));
+    }
+
+    /**
+     * @param  array<string, mixed>  $data
+     * @param  array<string, mixed>  $mergeData
+     */
+    public static function view(string $view, array $data = [], array $mergeData = []): static
+    {
+        return static::text(view($view, $data, $mergeData)->render());
+    }
+
+    /**
+     * @internal
+     *
+     * @throws JsonException
+     */
+    public static function json(mixed $content): static
+    {
+        return static::text(json_encode($content, JSON_THROW_ON_ERROR | JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE));
+    }
+
+    public static function blob(string $content): static
+    {
+        return new static(new Blob($content));
+    }
+
+    /**
+     * @param  array<string, mixed>  $response
+     */
+    public static function structured(array $response): ResponseFactory
+    {
+        if ($response === []) {
+            throw new InvalidArgumentException('Structured content cannot be empty.');
+        }
+
+        try {
+            $json = json_encode($response, JSON_THROW_ON_ERROR | JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE);
+        } catch (JsonException $jsonException) {
+            throw new InvalidArgumentException("Invalid structured content: {$jsonException->getMessage()}", 0, $jsonException);
+        }
+
+        $content = Response::text($json);
+
+        return (new ResponseFactory($content))->withStructuredContent($response);
+    }
+
+    public static function error(string $text): static
+    {
+        return new static(new Text($text), isError: true);
+    }
+
+    public function content(): Content
+    {
+        return $this->content;
+    }
+
+    /**
+     * @param  Response|array<int, Response>  $responses
+     */
+    public static function make(Response|array $responses): ResponseFactory
+    {
+        return new ResponseFactory($responses);
+    }
+
+    /**
+     * @param  array<string, mixed>|string  $meta
+     */
+    public function withMeta(array|string $meta, mixed $value = null): static
+    {
+        $this->content->setMeta($meta, $value);
+
+        return $this;
+    }
+
+    public static function audio(string $data, string $mimeType = 'audio/wav'): static
+    {
+        return new static(new Audio($data, $mimeType));
+    }
+
+    public static function image(string $data, string $mimeType = 'image/png'): static
+    {
+        return new static(new Image($data, $mimeType));
+    }
+
+    public static function fromStorage(string $path, ?string $disk = null, ?string $mimeType = null): static
+    {
+        /** @var FilesystemAdapter $storage */
+        $storage = Storage::disk($disk);
+
+        try {
+            $data = $storage->get($path);
+        } catch (UnableToReadFile $unableToReadFile) {
+            throw new InvalidArgumentException("File not found at path [{$path}].", 0, $unableToReadFile);
+        }
+
+        if ($data === null) {
+            throw new InvalidArgumentException("File not found at path [{$path}].");
+        }
+
+        $mimeType ??= $storage->mimeType($path) ?: throw new InvalidArgumentException(
+            "Unable to determine MIME type for [{$path}].",
+        );
+
+        return match (true) {
+            str_starts_with($mimeType, 'image/') => static::image($data, $mimeType),
+            str_starts_with($mimeType, 'audio/') => static::audio($data, $mimeType),
+            default => throw new InvalidArgumentException("Unsupported MIME type [{$mimeType}] for [{$path}]."),
+        };
+    }
+
+    public function asAssistant(): static
+    {
+        return new static($this->content, Role::Assistant, $this->isError);
+    }
+
+    public function isNotification(): bool
+    {
+        return $this->content instanceof Notification;
+    }
+
+    public function isError(): bool
+    {
+        return $this->isError;
+    }
+
+    public function role(): Role
+    {
+        return $this->role;
+    }
+}