adds work in progress

Author: nunomaduro

src/BoostServiceProvider.php

@@ -14,7 +14,7 @@
 use Illuminate\View\Compilers\BladeCompiler;
 use Laravel\Boost\Mcp\Boost;
 use Laravel\Boost\Middleware\InjectBoost;
-use Laravel\Mcp\Server\Facades\Mcp;
+use Laravel\Mcp\Facades\Mcp;
 use Laravel\Roster\Roster;
 
 class BoostServiceProvider extends ServiceProvider

src/Console/ExecuteToolCommand.php

@@ -6,7 +6,8 @@
 
 use Illuminate\Console\Command;
 use Laravel\Boost\Mcp\ToolRegistry;
-use Laravel\Mcp\Server\Tools\ToolResult;
+use Laravel\Mcp\Request;
+use Laravel\Mcp\Response;
 
 class ExecuteToolCommand extends Command
 {
@@ -39,17 +40,25 @@ public function handle(): int
         try {
             // Execute the tool
             $tool = app($toolClass);
-            $result = $tool->handle($arguments ?? []);
+
+            $request = new Request($arguments ?? []);
+            $response = $tool->handle($request);
 
             // Output the result as JSON for the parent process
-            echo json_encode($result->toArray());
+            echo json_encode([
+                'isError' => $response->isError(),
+                'content' => (string) $response->content(),
+            ]);
 
             return 0;
 
         } catch (\Throwable $e) {
             // Output error result
-            $errorResult = ToolResult::error("Tool execution failed (E_THROWABLE): {$e->getMessage()}");
-            $this->error(json_encode($errorResult->toArray()));
+            $errorResult = Response::error("Tool execution failed (E_THROWABLE): {$e->getMessage()}");
+            $this->error(json_encode([
+                'isError' => true,
+                'content' => (string) $errorResult->content(),
+            ]));
 
             return 1;
         }

src/Mcp/Boost.php

@@ -10,106 +10,138 @@
 
 class Boost extends Server
 {
-    public string $serverName = 'Laravel Boost';
+    /**
+     * The MCP server's name.
+     */
+    protected string $name = 'Laravel Boost';
 
-    public string $serverVersion = '0.0.1';
+    /**
+     * The MCP server's version.
+     */
+    protected string $version = '0.0.1';
 
-    public string $instructions = 'Laravel ecosystem MCP server offering database schema access, Artisan commands, error logs, Tinker execution, semantic documentation search and more. Boost helps with code generation.';
+    /**
+     * The MCP server's instructions for the LLM.
+     */
+    protected string $instructions = 'Laravel ecosystem MCP server offering database schema access, Artisan commands, error logs, Tinker execution, semantic documentation search and more. Boost helps with code generation.';
 
-    public int $defaultPaginationLength = 50;
+    /**
+     * The tools registered with this MCP server.
+     *
+     * @var array<int, class-string<\Laravel\Mcp\Server\Tool>>
+     */
+    protected array $tools = [];
 
     /**
-     * @var string[]
+     * The resources registered with this MCP server.
+     *
+     * @var array<int, class-string<\Laravel\Mcp\Server\Resource>>
      */
-    public array $resources = [
+    protected array $resources = [
         ApplicationInfo::class,
     ];
 
+    /**
+     * The prompts registered with this MCP server.
+     *
+     * @var array<int, class-string<\Laravel\Mcp\Server\Prompt>>
+     */
+    protected array $prompts = [];
+
     public function boot(): void
     {
-        $this->discoverTools();
-        $this->discoverResources();
-        $this->discoverPrompts();
+        collect($this->discoverTools())->each(fn (string $tool) => $this->tools[] = $tool);
+        collect($this->discoverResources())->each(fn (string $resource) => $this->resources[] = $resource);
+        collect($this->discoverPrompts())->each(fn (string $prompt) => $this->prompts[] = $prompt);
 
         // Override the tools/call method to use our ToolExecutor
         $this->methods['tools/call'] = CallToolWithExecutor::class;
     }
 
     /**
-     * @return array<string>
+     * @return array<int, class-string<\Laravel\Mcp\Server\Tool>>
      */
     protected function discoverTools(): array
     {
+        $tools = [];
+
         $excludedTools = config('boost.mcp.tools.exclude', []);
         $toolDir = new \DirectoryIterator(__DIR__.DIRECTORY_SEPARATOR.'Tools');
+
         foreach ($toolDir as $toolFile) {
             if ($toolFile->isFile() && $toolFile->getExtension() === 'php') {
                 $fqdn = 'Laravel\\Boost\\Mcp\\Tools\\'.$toolFile->getBasename('.php');
                 if (class_exists($fqdn) && ! in_array($fqdn, $excludedTools, true)) {
-                    $this->addTool($fqdn);
+                    $tools[] = $fqdn;
                 }
             }
         }
 
         $extraTools = config('boost.mcp.tools.include', []);
         foreach ($extraTools as $toolClass) {
             if (class_exists($toolClass)) {
-                $this->addTool($toolClass);
+                $tools[] = $toolClass;
             }
         }
 
-        return $this->registeredTools;
+        return $tools;
     }
 
     /**
-     * @return array<string>
+     * @return array<int, class-string<\Laravel\Mcp\Server\Resource>>
      */
     protected function discoverResources(): array
     {
+        $resources = [];
+
         $excludedResources = config('boost.mcp.resources.exclude', []);
         $resourceDir = new \DirectoryIterator(__DIR__.DIRECTORY_SEPARATOR.'Resources');
+
         foreach ($resourceDir as $resourceFile) {
             if ($resourceFile->isFile() && $resourceFile->getExtension() === 'php') {
-                $fqdn = 'Laravel\\Boost\\Mcp\\Resources\\'.$resourceFile;
-                if (class_exists($fqdn) && ! in_array($fqdn, $excludedResources, true)) {
-                    $this->addResource($fqdn);
+                $fqdn = 'Laravel\\Boost\\Mcp\\Resources\\'.$resourceFile->getBasename('.php');
+                if (class_exists($fqdn) && ! in_array($fqdn, $excludedResources, true) && $fqdn !== ApplicationInfo::class) {
+                    $resources[] = $fqdn;
                 }
             }
         }
 
         $extraResources = config('boost.mcp.resources.include', []);
         foreach ($extraResources as $resourceClass) {
             if (class_exists($resourceClass)) {
-                $this->addResource($resourceClass);
+                $resources[] = $resourceClass;
             }
         }
 
-        return $this->registeredResources;
+        return $resources;
     }
 
     /**
-     * @return array<string>
+     * @return array<int, class-string<\Laravel\Mcp\Server\Prompt>>
      */
     protected function discoverPrompts(): array
     {
+        $prompts = [];
+
         $excludedPrompts = config('boost.mcp.prompts.exclude', []);
         $promptDir = new \DirectoryIterator(__DIR__.DIRECTORY_SEPARATOR.'Prompts');
+
         foreach ($promptDir as $promptFile) {
             if ($promptFile->isFile() && $promptFile->getExtension() === 'php') {
-                $fqdn = 'Laravel\\Boost\\Mcp\\Prompts\\'.$promptFile;
+                $fqdn = 'Laravel\\Boost\\Mcp\\Prompts\\'.$promptFile->getBasename('.php');
                 if (class_exists($fqdn) && ! in_array($fqdn, $excludedPrompts, true)) {
-                    $this->addPrompt($fqdn);
+                    $prompts[] = $fqdn;
                 }
             }
         }
 
         $extraPrompts = config('boost.mcp.prompts.include', []);
         foreach ($extraPrompts as $promptClass) {
             if (class_exists($promptClass)) {
-                $this->addResource($promptClass);
+                $prompts[] = $promptClass;
             }
         }
 
-        return $this->registeredPrompts;
+        return $prompts;
     }
 }

src/Mcp/Methods/CallToolWithExecutor.php

@@ -4,57 +4,54 @@
 
 namespace Laravel\Boost\Mcp\Methods;
 
-use Illuminate\Support\ItemNotFoundException;
 use Laravel\Boost\Mcp\ToolExecutor;
-use Laravel\Mcp\Server\Contracts\Methods\Method;
+use Laravel\Mcp\Server\Contracts\Errable;
+use Laravel\Mcp\Server\Contracts\Method;
+use Laravel\Mcp\Server\Exceptions\JsonRpcException;
+use Laravel\Mcp\Server\Methods\Concerns\InteractsWithResponses;
 use Laravel\Mcp\Server\ServerContext;
-use Laravel\Mcp\Server\Tools\ToolResult;
 use Laravel\Mcp\Server\Transport\JsonRpcRequest;
 use Laravel\Mcp\Server\Transport\JsonRpcResponse;
-use Throwable;
 
-class CallToolWithExecutor implements Method
+class CallToolWithExecutor implements Method, Errable
 {
+    use InteractsWithResponses;
+
     /**
      * Handle the JSON-RPC tool/call request with process isolation.
-     *
-     * @param JsonRpcRequest $request
-     * @param ServerContext $context
-     * @return JsonRpcResponse
      */
     public function handle(JsonRpcRequest $request, ServerContext $context): JsonRpcResponse
     {
-        try {
-            $tool = $context->tools()->firstOrFail(fn ($tool) => $tool->name() === $request->params['name']);
-        } catch (ItemNotFoundException) {
-            return JsonRpcResponse::create(
-                $request->id,
-                ToolResult::error('Tool not found')
-            );
-        } catch (Throwable $e) {
-            return JsonRpcResponse::create(
+        if (is_null($request->get('name'))) {
+            throw new JsonRpcException(
+                'Missing [name] parameter.',
+                -32602,
                 $request->id,
-                ToolResult::error('Error finding tool: '.$e->getMessage())
             );
         }
 
-        try {
-            $executor = app(ToolExecutor::class);
-
-            $arguments = [];
-            if (isset($request->params['arguments']) && is_array($request->params['arguments'])) {
-                $arguments = $request->params['arguments'];
-            }
-
-            $result = $executor->execute(get_class($tool), $arguments);
+        $tool = $context
+            ->tools($request->toRequest())
+            ->first(
+                fn ($tool): bool => $tool->name() === $request->params['name'],
+                fn () => throw new JsonRpcException(
+                    "Tool [{$request->params['name']}] not found.",
+                    -32602,
+                    $request->id,
+                ));
+
+        $executor = app(ToolExecutor::class);
+
+        $arguments = [];
+        if (isset($request->params['arguments']) && is_array($request->params['arguments'])) {
+            $arguments = $request->params['arguments'];
+        }
 
-            return JsonRpcResponse::create($request->id, $result);
+        $response = $executor->execute(get_class($tool), $arguments);
 
-        } catch (Throwable $e) {
-            return JsonRpcResponse::create(
-                $request->id,
-                ToolResult::error('Tool execution error: '.$e->getMessage())
-            );
-        }
+        return $this->toJsonRpcResponse($request, $response, fn ($responses) => [
+            'content' => $responses->map(fn ($response) => $response->content()->toTool($tool))->all(),
+            'isError' => $responses->contains(fn ($response) => $response->isError()),
+        ]);
     }
 }

src/Mcp/Resources/ApplicationInfo.php

@@ -6,6 +6,8 @@
 
 use Laravel\Boost\Mcp\ToolExecutor;
 use Laravel\Boost\Mcp\Tools\ApplicationInfo as ApplicationInfoTool;
+use Laravel\Mcp\Request;
+use Laravel\Mcp\Response;
 use Laravel\Mcp\Server\Resource;
 
 class ApplicationInfo extends Resource
@@ -14,35 +16,38 @@ public function __construct(protected ToolExecutor $toolExecutor)
     {
     }
 
-    public function description(): string
+    /**
+     * The resource's description.
+     */
+    protected string $description = 'Comprehensive application information including PHP version, Laravel version, database engine, all installed packages with their versions, and all Eloquent models in the application.';
+
+    /**
+     * The resource's URI.
+     */
+    protected string $uri = 'file://instructions/application-info.md';
+
+    /**
+     * The resource's MIME type.
+     */
+    protected string $mimeType = 'text/markdown';
+
+    /**
+     * Handle the resource request.
+     */
+    public function handle(Request $request): Response
     {
-        return 'Comprehensive application information including PHP version, Laravel version, database engine, all installed packages with their versions, and all Eloquent models in the application.';
-    }
-
-    public function uri(): string
-    {
-        return 'file://instructions/application-info.md';
-    }
-
-    public function mimeType(): string
-    {
-        return 'text/markdown';
-    }
-
-    public function read(): string
-    {
-        $result = $this->toolExecutor->execute(ApplicationInfoTool::class);
+        $response = $this->toolExecutor->execute(ApplicationInfoTool::class);
 
-        if ($result->isError) {
-            return 'Error fetching application information: '.$result->toArray()['content'][0]['text'];
+        if ($response->isError()) {
+            return $response; // Return the error response directly
         }
 
-        $data = json_decode($result->toArray()['content'][0]['text'], true);
+        $data = json_decode((string) $response->content(), true);
 
         if (! $data) {
-            return 'Error parsing application information';
+            return Response::error('Error parsing application information');
         }
 
-        return json_encode($data, JSON_PRETTY_PRINT);
+        return Response::json($data);
     }
 }