Introduce LoopTools for tool and toolkit singleton registration.

Author: fsmonter

src/Loop.php

@@ -4,7 +4,6 @@
 
 use Illuminate\Support\Collection;
 use Illuminate\Support\Facades\Auth;
-use Kirschbaum\Loop\Collections\ToolCollection;
 use Kirschbaum\Loop\Contracts\Tool;
 use Kirschbaum\Loop\Contracts\Toolkit;
 use Prism\Prism\Enums\Provider;
@@ -16,16 +15,9 @@
 
 class Loop
 {
-    protected ToolCollection $tools;
-
     protected string $context = '';
 
-    protected bool $hasBeenResolved = false;
-
-    public function __construct()
-    {
-        $this->tools = new ToolCollection;
-    }
+    public function __construct(protected LoopTools $loopTools) {}
 
     public function setup(): void {}
 
@@ -38,26 +30,14 @@ public function context(string $context): static
 
     public function tool(Tool $tool): static
     {
-        $this->tools->push($tool);
-
-        $this->storeRegistration(function (Loop $loop) use ($tool) {
-            $loop->tools->push($tool);
-        });
+        $this->loopTools->registerTool($tool);
 
         return $this;
     }
 
     public function toolkit(Toolkit $toolkit): static
     {
-        foreach ($toolkit->getTools() as $tool) {
-            $this->tools->push($tool);
-        }
-
-        $this->storeRegistration(function (Loop $loop) use ($toolkit) {
-            foreach ($toolkit->getTools() as $tool) {
-                $loop->tools->push($tool);
-            }
-        });
+        $this->loopTools->registerToolkit($toolkit);
 
         return $this;
     }
@@ -109,39 +89,22 @@ public function ask(string $question, Collection $messages): Response
             ->asText();
     }
 
+    /**
+     * @return Collection<array-key, PrismTool>
+     */
     public function getPrismTools(): Collection
     {
-        return $this->tools
+        return $this->loopTools
+            ->getTools()
             ->toBase()
             ->map(fn (Tool $tool) => $tool->build());
     }
 
     public function getPrismTool(string $name): PrismTool
     {
-        return $this->tools->getTool($name)->build();
-    }
-
-    /**
-     * Store a registration callback for replay in new instances.
-     */
-    protected function storeRegistration(callable $callback): void
-    {
-        if (! app()->bound('loop.registrations')) {
-            app()->instance('loop.registrations', []);
-        }
-
-        $registrations = app('loop.registrations');
-        $registrations[] = $callback;
-        app()->instance('loop.registrations', $registrations);
-    }
-
-    public function markAsResolved(): void
-    {
-        $this->hasBeenResolved = true;
-    }
-
-    public function hasBeenResolved(): bool
-    {
-        return $this->hasBeenResolved;
+        return $this->loopTools
+            ->getTools()
+            ->getTool($name)
+            ->build();
     }
 }

src/LoopServiceProvider.php

@@ -35,31 +35,17 @@ public function configurePackage(Package $package): void
 
     public function packageBooted(): void
     {
+        $this->app->singleton(LoopTools::class, function () {
+            return new LoopTools;
+        });
+
         $this->app->scoped(Loop::class, function ($app) {
-            $loop = new Loop;
+            $loop = new Loop($app->make(LoopTools::class));
             $loop->setup();
 
             return $loop;
         });
 
-        /**
-         * Set up container resolving hook to replay tool registrations for Octane compatibility
-         */
-        $this->app->resolving(Loop::class, function ($loop, $app) {
-            $loop->markAsResolved();
-
-            if ($app->bound('loop.registrations')) {
-                $registrations = $app->make('loop.registrations');
-                if (is_array($registrations)) {
-                    foreach ($registrations as $registration) {
-                        if (is_callable($registration)) {
-                            $registration($loop);
-                        }
-                    }
-                }
-            }
-        });
-
         $this->app->bind(SseService::class, function ($app) {
             return new SseService;
         });

src/LoopTools.php

@@ -0,0 +1,61 @@
+<?php
+
+namespace Kirschbaum\Loop;
+
+use Kirschbaum\Loop\Collections\ToolCollection;
+use Kirschbaum\Loop\Contracts\Tool;
+use Kirschbaum\Loop\Contracts\Toolkit;
+
+class LoopTools
+{
+    protected ToolCollection $tools;
+
+    /** @var array<int, Toolkit> */
+    protected array $toolkits = [];
+
+    public function __construct()
+    {
+        $this->tools = new ToolCollection;
+    }
+
+    public function registerTool(Tool $tool): void
+    {
+        $this->tools->push($tool);
+    }
+
+    public function registerToolkit(Toolkit $toolkit): void
+    {
+        $this->toolkits[] = $toolkit;
+
+        foreach ($toolkit->getTools() as $tool) {
+            $this->registerTool($tool);
+        }
+    }
+
+    /**
+     * Get all registered tools
+     */
+    public function getTools(): ToolCollection
+    {
+        return $this->tools;
+    }
+
+    /**
+     * Get all registered toolkits
+     *
+     * @return array<int, Toolkit>
+     */
+    public function getToolkits(): array
+    {
+        return $this->toolkits;
+    }
+
+    /**
+     * Clear all registrations
+     */
+    public function clear(): void
+    {
+        $this->tools = new ToolCollection;
+        $this->toolkits = [];
+    }
+}

tests/Feature/LoopToolsTest.php

@@ -0,0 +1,88 @@
+<?php
+
+declare(strict_types=1);
+
+use Kirschbaum\Loop\Facades\Loop as LoopFacade;
+use Kirschbaum\Loop\Loop;
+use Kirschbaum\Loop\LoopTools;
+use Kirschbaum\Loop\Toolkits\LaravelModelToolkit;
+use Kirschbaum\Loop\Tools\CustomTool;
+use Workbench\App\Models\User;
+
+beforeEach(function () {
+    LoopFacade::clearResolvedInstances();
+
+    app()->forgetInstance(Loop::class);
+
+    if (app()->bound(LoopTools::class)) {
+        app(LoopTools::class)->clear();
+    }
+});
+
+test('tools persist across loop instances', function () {
+    $tool = CustomTool::make('test_tool', 'A test tool')
+        ->using(fn () => 'Test tool response');
+
+    LoopFacade::tool($tool);
+
+    $loop1 = app(Loop::class);
+    $tools1 = $loop1->getPrismTools();
+
+    expect($tools1)
+        ->toHaveCount(1)
+        ->and($tools1->first()->name())
+        ->toEqual('test_tool');
+
+    app()->forgetInstance(Loop::class);
+
+    $loop2 = app(Loop::class);
+    $tools2 = $loop2->getPrismTools();
+
+    expect($tools2)
+        ->toHaveCount(1)
+        ->and($tools2->first()->name())
+        ->toEqual('test_tool');
+});
+
+test('toolkit registrations persist across loop instances', function () {
+    LoopFacade::toolkit(LaravelModelToolkit::make([User::class]));
+
+    $loop1 = app(Loop::class);
+    $tools1 = $loop1->getPrismTools();
+
+    expect($tools1->count())
+        ->toBeGreaterThan(0);
+
+    app()->forgetInstance(Loop::class);
+
+    $loop2 = app(Loop::class);
+    $tools2 = $loop2->getPrismTools();
+
+    expect($tools2->count())
+        ->toEqual($tools1->count());
+});
+
+test('multiple tool registrations persist', function () {
+    LoopFacade::tool(CustomTool::make('tool1', 'Tool 1')->using(fn () => 'Response 1'));
+    LoopFacade::tool(CustomTool::make('tool2', 'Tool 2')->using(fn () => 'Response 2'));
+
+    $loop1 = app(Loop::class);
+
+    expect($loop1->getPrismTools())
+        ->toHaveCount(2);
+
+    app()->forgetInstance(Loop::class);
+
+    $loop2 = app(Loop::class);
+
+    expect($loop2->getPrismTools())
+        ->toHaveCount(2);
+});
+
+test('loop tools registry is a singleton', function () {
+    $registry1 = app(LoopTools::class);
+    $registry2 = app(LoopTools::class);
+
+    expect($registry1)
+        ->toBe($registry2);
+});

tests/Feature/OctaneCompatibilityTest.php

@@ -1,13 +1,20 @@
 <?php
 
+declare(strict_types=1);
+
 use Kirschbaum\Loop\Facades\Loop as LoopFacade;
 use Kirschbaum\Loop\Loop;
+use Kirschbaum\Loop\LoopTools;
 use Kirschbaum\Loop\Toolkits\LaravelModelToolkit;
 use Workbench\App\Models\User;
 
 beforeEach(function () {
+    // Simulate Octane worker reset by clearing resolved instances and stored tools
     app()->forgetInstance(Loop::class);
-    app()->forgetInstance('loop.registrations');
+
+    if (app()->bound(LoopTools::class)) {
+        app(LoopTools::class)->clear();
+    }
 });
 
 test('toolkits persist after instance recreation', function () {
@@ -17,56 +24,40 @@
     $firstTools = $firstInstance->getPrismTools();
 
     expect($firstTools->count())
-        ->toBeGreaterThan(0, 'First instance should have tools from registered toolkit');
+        ->toBeGreaterThan(0);
 
-    app()->forgetInstance(Loop::class); // Simulates Octane instance recreation.
+    app()->forgetInstance(Loop::class); // Simulate Octane instance recreation.
 
     $secondInstance = app(Loop::class);
     $secondTools = $secondInstance->getPrismTools();
 
     expect($secondTools->count())
-        ->toBeGreaterThan(0, 'Second instance should have restored tools from registrations')
-        ->and($secondTools->count())
-        ->toEqual($firstTools->count(), 'Both instances should have the same number of tools');
+        ->toEqual($firstTools->count());
 });
 
 test('multiple toolkit registrations are preserved', function () {
     LoopFacade::toolkit(LaravelModelToolkit::make([User::class]));
     LoopFacade::toolkit(LaravelModelToolkit::make([User::class]));
 
     $firstInstance = app(Loop::class);
-    $firstTools = $firstInstance->getPrismTools();
-    $firstCount = $firstTools->count();
+    $firstCount = $firstInstance->getPrismTools()->count();
 
-    expect($firstCount)->toBeGreaterThan(0, 'Should have tools from multiple registrations');
+    expect($firstCount)
+        ->toBeGreaterThan(0);
 
     app()->forgetInstance(Loop::class);
 
     $secondInstance = app(Loop::class);
-    $secondTools = $secondInstance->getPrismTools();
+    $secondCount = $secondInstance->getPrismTools()->count();
 
-    expect($secondTools->count())->toEqual($firstCount, 'All toolkit registrations should be preserved');
+    expect($secondCount)
+        ->toEqual($firstCount);
 });
 
 test('empty registrations handle gracefully', function () {
     $instance = app(Loop::class);
     $tools = $instance->getPrismTools();
 
-    expect($tools->count())->toEqual(0, 'Should have no tools when nothing is registered');
-});
-
-test('registrations are stored correctly', function () {
-    LoopFacade::toolkit(LaravelModelToolkit::make([User::class]));
-
-    expect(app()->bound('loop.registrations'))->toBeTrue('Registrations should be stored in container');
-
-    $registrations = app('loop.registrations');
-    expect($registrations)
-        ->toBeArray('Registrations should be an array')
-        ->and(count($registrations))
-        ->toBeGreaterThan(0, 'Should have at least one registration');
-
-    foreach ($registrations as $registration) {
-        expect(is_callable($registration))->toBeTrue('Each registration should be callable');
-    }
+    expect($tools)
+        ->toHaveCount(0);
 });