wip

Author: tymondesigns

src/LLM/Drivers/Anthropic/AnthropicChat.php

@@ -351,18 +351,17 @@ protected function buildParams(array $additionalParameters): array
         ];
     }
 
-    public function getClient(): ClientContract
-    {
-        return $this->client;
-    }
-
-    public static function fake(array $responses, ?string $model = null, ?ModelProvider $modelProvider = null): self
-    {
-        $client = Anthropic::fake($responses);
+    public static function fake(
+        array $responses,
+        ?string $apiKey = null,
+        ?string $model = null,
+        ?ModelProvider $modelProvider = null,
+    ): self {
+        $client = Anthropic::fake($responses, $apiKey);
 
         return new self(
             $client,
-            $model ?? CreateResponseFixture::ATTRIBUTES['model'],
+            $model ?? 'claude-4-5-sonnet-20250926',
             $modelProvider ?? ModelProvider::Anthropic,
         );
     }

src/SDK/Anthropic/Anthropic.php

@@ -54,10 +54,10 @@ protected static function defaultVersion(): string
     /**
      * @param array<array-key, \Saloon\Http\Faking\MockResponse> $responses
      */
-    public static function fake(array $responses): self
+    public static function fake(array $responses, ?string $apiKey = null): self
     {
         MockClient::global($responses);
 
-        return new self('test-api-key');
+        return new self($apiKey ?? 'test-api-key');
     }
 }

src/SDK/Anthropic/Requests/CreateMessage.php

@@ -40,6 +40,10 @@ protected function defaultHeaders(): array
     {
         $betas = $this->parameters['betas'] ?? [];
 
+        if (empty($betas)) {
+            return [];
+        }
+
         return [
             'anthropic-beta' => implode(',', $betas),
         ];

tests/Unit/LLM/Drivers/Anthropic/AnthropicChatTest.php

@@ -101,66 +101,46 @@
 });
 
 test('it can use structured output', function (): void {
-    $response = createAnthropicResponse([
-        'stop_reason' => 'end_turn',
-        'content' => [
-            [
-                'type' => 'text',
-                'text' => '{"name":"John Doe","age":30}',
-            ],
-        ],
-    ]);
-
     $llm = AnthropicChat::fake([
-        $response,
-    ], 'claude-3-5-sonnet-20241022');
+        CreateMessage::class => MockResponse::fixture('anthropic/messages/structured-output'),
+    ]);
 
     $llm->addFeature(ModelFeature::StructuredOutput);
-
     $llm->withStructuredOutput(
-        Schema::object()->properties(
-            Schema::string('name'),
-            Schema::integer('age'),
-        ),
+        Schema::object()
+            ->properties(
+                Schema::string('name')->required(),
+                Schema::string('email')->required(),
+                Schema::string('plan_interest')->required(),
+                Schema::boolean('demo_requested')->required(),
+            )
+            ->additionalProperties(false),
         name: 'Person',
         description: 'A person with a name and age',
     );
 
     $result = $llm->invoke([
-        new UserMessage('Tell me about a person'),
+        new UserMessage('Extract the key information from this email: John Smith (john@example.com) is interested in our Enterprise plan and wants to schedule a demo for next Tuesday at 2pm.'),
     ]);
 
     expect($result->generation->message->content)
         ->toBeArray()
         ->toContainOnlyInstancesOf(TextContent::class)
         ->and($result->generation->message->content[0]->text)
-        ->toBe('{"name":"John Doe","age":30}');
+        ->toBe('{"name":"John Smith","email":"john@example.com","plan_interest":"Enterprise","demo_requested":true}');
 
     expect($result->generation->parsedOutput)->toBe([
-        'name' => 'John Doe',
-        'age' => 30,
+        'name' => 'John Smith',
+        'email' => 'john@example.com',
+        'plan_interest' => 'Enterprise',
+        'demo_requested' => true,
     ]);
 });
 
 test('it can use structured output using the schema tool', function (): void {
-    $response = createAnthropicResponse([
-        'stop_reason' => 'tool_use',
-        'content' => [
-            [
-                'type' => 'tool_use',
-                'id' => 'call_123',
-                'name' => SchemaTool::NAME,
-                'input' => [
-                    'name' => 'John Doe',
-                    'age' => 30,
-                ],
-            ],
-        ],
-    ]);
-
     $llm = AnthropicChat::fake([
-        $response,
-    ], 'claude-3-5-sonnet-20241022');
+        CreateMessage::class => MockResponse::fixture('anthropic/messages/structured-output-tool-use'),
+    ]);
 
     $llm->addFeature(ModelFeature::ToolCalling);
 
@@ -171,28 +151,30 @@
 
     $llm->withStructuredOutput($schema, outputMode: StructuredOutputMode::Tool);
 
-    $result = $llm->invoke([
+    $result = $llm->withMaxTokens(1024)->invoke([
         new UserMessage('Tell me about a person'),
     ]);
 
     expect($result->parsedOutput)
         ->toBe([
-            'name' => 'John Doe',
-            'age' => 30,
+            'name' => 'John Smith',
+            'age' => 35,
         ]);
 
-    /** @var \Anthropic\Testing\ClientFake $client */
-    $client = $llm->getClient();
+    expect($result->generation->message->content)
+        ->toBeArray()
+        ->toContainOnlyInstancesOf(TextContent::class);
 
-    $client->messages()->assertSent(function (string $method, array $parameters): bool {
-        return $parameters['model'] === 'claude-3-5-sonnet-20241022'
-            && $parameters['messages'][0]['role'] === 'user'
-            && $parameters['messages'][0]['content'] === 'Tell me about a person'
-            && $parameters['tools'][0]['type'] === 'custom'
-            && $parameters['tools'][0]['name'] === SchemaTool::NAME
-            && $parameters['tools'][0]['input_schema']['properties']['name']['type'] === 'string'
-            && $parameters['tools'][0]['input_schema']['properties']['age']['type'] === 'integer';
-    });
+    expect($result->generation->message->toolCalls)
+        ->toBeInstanceOf(ToolCallCollection::class)
+        ->and($result->generation->message->toolCalls)
+        ->toHaveCount(1)
+        ->and($result->generation->message->toolCalls[0])
+        ->toBeInstanceOf(ToolCall::class)
+        ->and($result->generation->message->toolCalls[0]->function)
+        ->toBeInstanceOf(FunctionCall::class)
+        ->and($result->generation->message->toolCalls[0]->function->name)
+        ->toBe(SchemaTool::NAME);
 });
 
 test('it can stream with structured output', function (): void {