modelcontextprotocol/php-sdk
Watch
1
0
Fork
You've already forked php-sdk
 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

[Schema][Server] Add top-level title to Tool (#288)

Browse source 
* feat(schema): add top-level title to Tool

Mirror PR #278's Prompt change for Tool:

- Add optional ?string $title to Mcp\Schema\Tool between $name
  and $inputSchema. fromArray() now reads $data['title'];
  jsonSerialize() emits 'title' right after 'name'. The
  @phpstan-type ToolData gains title?: string.
- Add ?string $title to the #[McpTool] attribute between $name
  and $description.
- Note ToolAnnotations::$title as deprecated-for-display in
  favor of Tool::$title per MCP spec 2025-06-18 (PHPDoc only,
  field retained for BC).

Phase 1 of plan 01--tool-title-spec-compliance. Later phases
update Discoverer, Builder::addTool(), ArrayLoader, and the
conformance fixture to match the new signature.

* feat(server): thread title through discovery

- Discoverer::processMethod() now propagates McpTool::$title
  into every discovered Tool via named arguments.
- Builder::addTool() accepts ?string $title between $name and
  $description. [BC Break] positional callers passing the old
  $description as 3rd positional argument must switch to named
  arguments, matching the precedent set for addPrompt() in
  0.5.0.
- tests/Conformance/server.php migrated to named-argument form
  for every addTool() call.

Phase 2 of plan 01--tool-title-spec-compliance.

* feat(loader): forward title in ArrayLoader

ArrayLoader now reads 'title' from each tool config entry and
passes it into the Tool constructor, completing the wiring
from Builder::addTool() through array-driven registration.

The $tools @param array-shape typedef gains title: ?string
between name and description.

Phase 3 of plan 01--tool-title-spec-compliance.

* test(schema): cover Tool.title end-to-end

- New tests/Unit/Schema/ToolTest.php: constructor round-trip,
  jsonSerialize key-order when title set vs null, fromArray
  tolerance.
- New tests/Unit/Capability/Discovery/DiscovererToolTitleTest
  plus a TitleFixture class verifying McpTool(title: ...)
  propagates through discovery into the registered Tool.
- New tests/Unit/Capability/Registry/Loader/ArrayLoader...
  test verifying array-driven title propagation.
- Extend McpToolTest for title named-arg and default-null.
- Extend BuilderTest with addTool(title: 't') propagation.
- Update tests/Unit/.../RegistryTest, CallToolHandlerTest,
  ListToolsHandlerTest and examples/.../server.php
  new Tool(...) call sites to pass title (named args) so
  they match the new constructor signature.
- CHANGELOG 0.6.0 section: feature bullet + [BC Break]
  note for addTool() signature, mirroring 0.5.0 Prompt
  entries.
- docs/server-builder.md: addTool() row and prose now
  list title? between name and description.

Phase 4 of plan 01--tool-title-spec-compliance. All 730
phpunit tests pass; remaining phpstan warnings are
pre-existing and unrelated to Tool.title.

* refactor(schema): make Tool.title non-BC-breaking

Move `title` to the end of the Tool, Builder::addTool, and McpTool
attribute constructors with a default of null. This preserves
positional-argument compatibility and removes the need for
`title: null` boilerplate at call sites. JSON serialization order
(name, title, inputSchema, ...) is unchanged.

Also tighten the new tests: parameterize ToolTest with data
providers, fold the Discoverer title fixture into the existing
DiscoverableToolHandler, and drop the reflection-heavy Builder
test that overlapped with ArrayLoaderToolTitleTest.

* fix: move title after name

---------

Co-authored-by: DDEV User <nobody@example.com>
This commit is contained in:
Mateu Aguiló Bosch 2026-04-26 15:37:40 +02:00 • committed by GitHub
commit fb2c8c2ee4
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
22 changed files with 262 additions and 42 deletions
Download patch file Download diff file Expand all files Collapse all files

4
CHANGELOG.md
View file

@ -14,6 +14,10 @@ All notable changes to `mcp/sdk` will be documented in this file.
* Add OAuth 2.0 Dynamic Client Registration middleware (RFC 7591)
* Add optional `title` field to `Prompt` and `McpPrompt` for MCP spec compliance
* [BC Break] `Builder::addPrompt()` signature changed — `$title` parameter added between `$name` and `$description`. Callers using positional arguments for `$description` must switch to named arguments.
* Add optional `title` field to `Tool` and `McpTool` for MCP spec compliance
* [BC Break] `Tool::__construct()` signature changed — `$title` parameter added between `$name` and `$inputSchema`. Callers using positional arguments must switch to named arguments or pass `null` for `$title`.
* [BC Break] `McpTool` attribute signature changed — `$title` parameter added between `$name` and `$description`. Callers using positional arguments for `$description` must switch to named arguments.
* [BC Break] `Builder::addTool()` signature changed — `$title` parameter added between `$name` and `$description`. Callers using positional arguments for `$description` must switch to named arguments.
0.4.0
-----

3
docs/server-builder.md
View file

@ -278,6 +278,7 @@ $server = Server::builder()
- `handler` (callable|string): The tool handler
- `name` (string|null): Optional tool name
- `title` (string|null): Optional human-readable title for display in UI
- `description` (string|null): Optional tool description
- `annotations` (ToolAnnotations|null): Optional annotations for the tool
- `inputSchema` (array|null): Optional input schema for the tool
@ -578,7 +579,7 @@ $server = Server::builder()
| `addRequestHandlers()` | handlers | Prepend multiple custom request handlers |
| `addNotificationHandler()` | handler | Prepend a single custom notification handler |
| `addNotificationHandlers()` | handlers | Prepend multiple custom notification handlers |
| `addTool()` | handler, name?, description?, annotations?, inputSchema? | Register tool |
| `addTool()` | handler, name?, title?, description?, annotations?, inputSchema?, ... | Register tool |
| `addResource()` | handler, uri, name?, description?, mimeType?, size?, annotations? | Register resource |
| `addResourceTemplate()` | handler, uriTemplate, name?, description?, mimeType?, annotations? | Register resource template |
| `addPrompt()` | handler, name?, description? | Register prompt |

2
docs/server-client-communication.md
View file

@ -24,7 +24,7 @@ use Mcp\Server\RequestContext;
class MyService
{
#[McpTool('my_tool', 'My Tool Description')]
#[McpTool(name: 'my_tool', description: 'My Tool Description')]
public function myTool(RequestContext $context): string
{
$context->getClientGateway()->log(...);

2
examples/server/client-communication/ClientAwareService.php
View file

@ -28,7 +28,7 @@ final class ClientAwareService
/**
* @return array{incident: string, recommended_actions: string, model: string}
*/
#[McpTool('coordinate_incident_response', 'Coordinate an incident response with logging, progress, and sampling.')]
#[McpTool(name: 'coordinate_incident_response', description: 'Coordinate an incident response with logging, progress, and sampling.')]
public function coordinateIncident(RequestContext $context, string $incidentTitle): array
{
$clientGateway = $context->getClientGateway();

2
examples/server/custom-method-handlers/server.php
View file

@ -25,6 +25,7 @@ logger()->info('Starting MCP Custom Method Handlers Server...');
$toolDefinitions = [
'say_hello' => new Tool(
name: 'say_hello',
title: null,
inputSchema: [
'type' => 'object',
'properties' => [
@ -37,6 +38,7 @@ $toolDefinitions = [
),
'sum' => new Tool(
name: 'sum',
title: null,
inputSchema: [
'type' => 'object',
'properties' => [

6
examples/server/elicitation/ElicitationHandlers.php
View file

@ -45,7 +45,7 @@ final class ElicitationHandlers
*
* @return array{status: string, message: string, booking?: array{party_size: int, date: string, dietary: string}}
*/
#[McpTool('book_restaurant', 'Book a restaurant reservation, collecting details via elicitation.')]
#[McpTool(name: 'book_restaurant', description: 'Book a restaurant reservation, collecting details via elicitation.')]
public function bookRestaurant(RequestContext $context, string $restaurantName): array
{
if (!$context->getClientGateway()->supportsElicitation()) {
@ -156,7 +156,7 @@ final class ElicitationHandlers
*
* @return array{status: string, message: string}
*/
#[McpTool('confirm_action', 'Request user confirmation before proceeding with an action.')]
#[McpTool(name: 'confirm_action', description: 'Request user confirmation before proceeding with an action.')]
public function confirmAction(RequestContext $context, string $actionDescription): array
{
if (!$context->getClientGateway()->supportsElicitation()) {
@ -224,7 +224,7 @@ final class ElicitationHandlers
*
* @return array{status: string, message: string, feedback?: array{rating: string, comments: string}}
*/
#[McpTool('collect_feedback', 'Collect user feedback via elicitation form.')]
#[McpTool(name: 'collect_feedback', description: 'Collect user feedback via elicitation form.')]
public function collectFeedback(RequestContext $context, string $topic): array
{
if (!$context->getClientGateway()->supportsElicitation()) {

2
src/Capability/Attribute/McpTool.php
View file

@ -22,6 +22,7 @@ class McpTool
{
/**
* @param string|null $name The name of the tool (defaults to the method name)
* @param string|null $title Optional human-readable title for display in UI
* @param string|null $description The description of the tool (defaults to the DocBlock/inferred)
* @param ToolAnnotations|null $annotations Optional annotations describing tool behavior
* @param ?Icon[] $icons Optional list of icon URLs representing the tool
@ -30,6 +31,7 @@ class McpTool
*/
public function __construct(
public ?string $name = null,
public ?string $title = null,
public ?string $description = null,
public ?ToolAnnotations $annotations = null,
public ?array $icons = null,

15
src/Capability/Discovery/Discoverer.php
View file

@ -231,13 +231,14 @@ final class Discoverer implements DiscovererInterface
$inputSchema = $this->schemaGenerator->generate($method);
$outputSchema = $this->schemaGenerator->generateOutputSchema($method);
$tool = new Tool(
$name,
$inputSchema,
$description,
$instance->annotations,
$instance->icons,
$instance->meta,
$outputSchema,
name: $name,
title: $instance->title,
inputSchema: $inputSchema,
description: $description,
annotations: $instance->annotations,
icons: $instance->icons,
meta: $instance->meta,
outputSchema: $outputSchema,
);
$tools[$name] = new ToolReference($tool, [$className, $methodName], false);
++$discoveredCount['tools'];

2
src/Capability/Registry/Loader/ArrayLoader.php
View file

@ -45,6 +45,7 @@ final class ArrayLoader implements LoaderInterface
* @param array{
* handler: Handler,
* name: ?string,
* title: ?string,
* description: ?string,
* annotations: ?ToolAnnotations,
* icons: ?Icon[],
@ -115,6 +116,7 @@ final class ArrayLoader implements LoaderInterface
$tool = new Tool(
name: $name,
title: $data['title'] ?? null,
inputSchema: $inputSchema,
description: $description,
annotations: $data['annotations'] ?? null,

30
src/Schema/Tool.php
View file

@ -33,6 +33,7 @@ use Mcp\Exception\InvalidArgumentException;
* }
* @phpstan-type ToolData array{
* name: string,
* title?: string,
* inputSchema: ToolInputSchema,
* description?: string|null,
* annotations?: ToolAnnotationsData,
@ -47,10 +48,11 @@ class Tool implements \JsonSerializable
{
/**
* @param string $name the name of the tool
* @param ?string $title Optional human-readable title for display in UI
* @param ToolInputSchema $inputSchema a JSON Schema object (as a PHP array) defining the expected 'arguments' for the tool
* @param ?string $description A human-readable description of the tool.
* This can be used by clients to improve the LLM's understanding of
* available tools. It can be thought of like a "hint" to the model.
* @param ToolInputSchema $inputSchema a JSON Schema object (as a PHP array) defining the expected 'arguments' for the tool
* @param ?ToolAnnotations $annotations optional additional tool information
* @param ?Icon[] $icons optional icons representing the tool
* @param ?array<string, mixed> $meta Optional metadata
@ -58,6 +60,7 @@ class Tool implements \JsonSerializable
*/
public function __construct(
public readonly string $name,
public readonly ?string $title,
public readonly array $inputSchema,
public readonly ?string $description,
public readonly ?ToolAnnotations $annotations,
@ -95,19 +98,21 @@ class Tool implements \JsonSerializable
}
return new self(
$data['name'],
$inputSchema,
isset($data['description']) && \is_string($data['description']) ? $data['description'] : null,
isset($data['annotations']) && \is_array($data['annotations']) ? ToolAnnotations::fromArray($data['annotations']) : null,
isset($data['icons']) && \is_array($data['icons']) ? array_map(Icon::fromArray(...), $data['icons']) : null,
isset($data['_meta']) && \is_array($data['_meta']) ? $data['_meta'] : null,
$outputSchema,
name: $data['name'],
title: isset($data['title']) && \is_string($data['title']) ? $data['title'] : null,
inputSchema: $inputSchema,
description: isset($data['description']) && \is_string($data['description']) ? $data['description'] : null,
annotations: isset($data['annotations']) && \is_array($data['annotations']) ? ToolAnnotations::fromArray($data['annotations']) : null,
icons: isset($data['icons']) && \is_array($data['icons']) ? array_map(Icon::fromArray(...), $data['icons']) : null,
meta: isset($data['_meta']) && \is_array($data['_meta']) ? $data['_meta'] : null,
outputSchema: $outputSchema,
);
}
/**
* @return array{
* name: string,
* title?: string,
* inputSchema: ToolInputSchema,
* description?: string,
* annotations?: ToolAnnotations,
@ -118,10 +123,11 @@ class Tool implements \JsonSerializable
*/
public function jsonSerialize(): array
{
$data = [
'name' => $this->name,
'inputSchema' => $this->inputSchema,
];
$data = ['name' => $this->name];
if (null !== $this->title) {
$data['title'] = $this->title;
}
$data['inputSchema'] = $this->inputSchema;
if (null !== $this->description) {
$data['description'] = $this->description;
}

2
src/Schema/ToolAnnotations.php
View file

@ -28,7 +28,7 @@ namespace Mcp\Schema;
class ToolAnnotations implements \JsonSerializable
{
/**
* @param ?string $title a human-readable title for the tool
* @param ?string $title a human-readable title for the tool — deprecated for display in favor of `Mcp\Schema\Tool::$title` per MCP spec revision 2025-06-18; retained for backward compatibility
* @param ?bool $readOnlyHint if true, the tool does not modify its environment
* @param ?bool $destructiveHint If true, the tool may perform destructive updates to its environment. If false, the tool performs only additive updates.
* @param ?bool $idempotentHint If true, calling the tool repeatedly with the same arguments will have no additional effect on the its environment. (This property is meaningful only when `readOnlyHint == false`)

4
src/Server/Builder.php
View file

@ -99,6 +99,7 @@ final class Builder
* @var array{
* handler: Handler,
* name: ?string,
* title: ?string,
* description: ?string,
* annotations: ?ToolAnnotations,
* icons: ?Icon[],
@ -373,6 +374,7 @@ final class Builder
* Manually registers a tool handler.
*
* @param Handler $handler
* @param ?string $title Optional human-readable title for display in UI
* @param array<string, mixed>|null $inputSchema
* @param ?Icon[] $icons
* @param array<string, mixed>|null $meta
@ -381,6 +383,7 @@ final class Builder
public function addTool(
callable|array|string $handler,
?string $name = null,
?string $title = null,
?string $description = null,
?ToolAnnotations $annotations = null,
?array $inputSchema = null,
@ -391,6 +394,7 @@ final class Builder
$this->tools[] = compact(
'handler',
'name',
'title',
'description',
'annotations',
'inputSchema',

24
tests/Conformance/server.php
View file

@ -40,18 +40,18 @@ $server = Server::builder()
->setSession(new FileSessionStore(__DIR__.'/sessions'))
->setLogger($logger)
// Tools
->addTool(static fn () => 'This is a simple text response for testing.', 'test_simple_text', 'Tests simple text content response')
->addTool(static fn () => new ImageContent(Elements::TEST_IMAGE_BASE64, 'image/png'), 'test_image_content', 'Tests image content response')
->addTool(static fn () => new AudioContent(Elements::TEST_AUDIO_BASE64, 'audio/wav'), 'test_audio_content', 'Tests audio content response')
->addTool(static fn () => EmbeddedResource::fromText('test://embedded-resource', 'This is an embedded resource content.'), 'test_embedded_resource', 'Tests embedded resource content response')
->addTool([Elements::class, 'toolMultipleTypes'], 'test_multiple_content_types', 'Tests response with multiple content types')
->addTool([Elements::class, 'toolWithLogging'], 'test_tool_with_logging', 'Tests tool that emits log messages')
->addTool([Elements::class, 'toolWithProgress'], 'test_tool_with_progress', 'Tests tool that reports progress notifications')
->addTool([Elements::class, 'toolWithSampling'], 'test_sampling', 'Tests server-initiated sampling')
->addTool(static fn () => CallToolResult::error([new TextContent('This tool intentionally returns an error for testing')]), 'test_error_handling', 'Tests error response handling')
->addTool([Elements::class, 'toolWithElicitation'], 'test_elicitation', 'Tests server-initiated elicitation')
->addTool([Elements::class, 'toolWithElicitationDefaults'], 'test_elicitation_sep1034_defaults', 'Tests elicitation with default values')
->addTool([Elements::class, 'toolWithElicitationEnums'], 'test_elicitation_sep1330_enums', 'Tests elicitation with enum schemas')
->addTool(static fn () => 'This is a simple text response for testing.', name: 'test_simple_text', description: 'Tests simple text content response')
->addTool(static fn () => new ImageContent(Elements::TEST_IMAGE_BASE64, 'image/png'), name: 'test_image_content', description: 'Tests image content response')
->addTool(static fn () => new AudioContent(Elements::TEST_AUDIO_BASE64, 'audio/wav'), name: 'test_audio_content', description: 'Tests audio content response')
->addTool(static fn () => EmbeddedResource::fromText('test://embedded-resource', 'This is an embedded resource content.'), name: 'test_embedded_resource', description: 'Tests embedded resource content response')
->addTool([Elements::class, 'toolMultipleTypes'], name: 'test_multiple_content_types', description: 'Tests response with multiple content types')
->addTool([Elements::class, 'toolWithLogging'], name: 'test_tool_with_logging', description: 'Tests tool that emits log messages')
->addTool([Elements::class, 'toolWithProgress'], name: 'test_tool_with_progress', description: 'Tests tool that reports progress notifications')
->addTool([Elements::class, 'toolWithSampling'], name: 'test_sampling', description: 'Tests server-initiated sampling')
->addTool(static fn () => CallToolResult::error([new TextContent('This tool intentionally returns an error for testing')]), name: 'test_error_handling', description: 'Tests error response handling')
->addTool([Elements::class, 'toolWithElicitation'], name: 'test_elicitation', description: 'Tests server-initiated elicitation')
->addTool([Elements::class, 'toolWithElicitationDefaults'], name: 'test_elicitation_sep1034_defaults', description: 'Tests elicitation with default values')
->addTool([Elements::class, 'toolWithElicitationEnums'], name: 'test_elicitation_sep1330_enums', description: 'Tests elicitation with enum schemas')
// Resources
->addResource(static fn () => 'This is the content of the static text resource.', 'test://static-text', 'static-text', 'A static text resource for testing')
->addResource(static fn () => fopen('data://image/png;base64,'.Elements::TEST_IMAGE_BASE64, 'r'), 'test://static-binary', 'static-binary', 'A static binary resource (image) for testing')

15
tests/Unit/Capability/Attribute/McpToolTest.php
View file

@ -52,6 +52,21 @@ class McpToolTest extends TestCase
$this->assertNull($attribute->outputSchema);
}
public function testInstantiatesWithTitle(): void
{
$attribute = new McpTool(name: 'n', title: 'T');
$this->assertSame('n', $attribute->name);
$this->assertSame('T', $attribute->title);
}
public function testDefaultTitleIsNull(): void
{
$attribute = new McpTool();
$this->assertNull($attribute->title);
}
public function testInstantiatesWithOutputSchema(): void
{
// Arrange

33
tests/Unit/Capability/Discovery/DiscovererToolTitleTest.php Normal file
View file

@ -0,0 +1,33 @@
<?php
/*
* This file is part of the official PHP MCP SDK.
*
* A collaboration between Symfony and the PHP Foundation.
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Mcp\Tests\Unit\Capability\Discovery;
use Mcp\Capability\Discovery\Discoverer;
use Mcp\Capability\Registry\ToolReference;
use PHPUnit\Framework\TestCase;
class DiscovererToolTitleTest extends TestCase
{
public function testDiscoveryPropagatesMcpToolTitleToToolTitle(): void
{
$discoverer = new Discoverer();
$discovery = $discoverer->discover(__DIR__, ['Fixtures']);
$tools = $discovery->getTools();
$this->assertArrayHasKey('greet_user', $tools);
$toolRef = $tools['greet_user'];
$this->assertInstanceOf(ToolReference::class, $toolRef);
$this->assertSame('Greet User', $toolRef->tool->title);
}
}

2
tests/Unit/Capability/Discovery/Fixtures/DiscoverableToolHandler.php
View file

@ -24,7 +24,7 @@ class DiscoverableToolHandler
*
* @return string the greeting
*/
#[McpTool(name: 'greet_user', description: 'Greets a user by name.')]
#[McpTool(name: 'greet_user', description: 'Greets a user by name.', title: 'Greet User')]
public function greet(string $name): string
{
return "Hello, {$name}!";

48
tests/Unit/Capability/Registry/Loader/ArrayLoaderToolTitleTest.php Normal file
View file

@ -0,0 +1,48 @@
<?php
/*
* This file is part of the official PHP MCP SDK.
*
* A collaboration between Symfony and the PHP Foundation.
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Mcp\Tests\Unit\Capability\Registry\Loader;
use Mcp\Capability\Registry;
use Mcp\Capability\Registry\Loader\ArrayLoader;
use PHPUnit\Framework\TestCase;
class ArrayLoaderToolTitleTest extends TestCase
{
public function testLoadPropagatesToolTitleToRegisteredTool(): void
{
$tools = [
[
'handler' => static fn (): string => 'ok',
'name' => 'weather_lookup',
'title' => 'Weather Lookup',
'description' => null,
'annotations' => null,
'inputSchema' => [
'type' => 'object',
'properties' => new \stdClass(),
'required' => null,
],
'icons' => null,
'meta' => null,
'outputSchema' => null,
],
];
$loader = new ArrayLoader($tools);
$registry = new Registry();
$loader->load($registry);
$toolRef = $registry->getTool('weather_lookup');
$this->assertSame('Weather Lookup', $toolRef->tool->title);
}
}

1
tests/Unit/Capability/RegistryTest.php
View file

@ -615,6 +615,7 @@ class RegistryTest extends TestCase
{
return new Tool(
name: $name,
title: null,
inputSchema: [
'type' => 'object',
'properties' => [

100
tests/Unit/Schema/ToolTest.php Normal file
View file

@ -0,0 +1,100 @@
<?php
/*
* This file is part of the official PHP MCP SDK.
*
* A collaboration between Symfony and the PHP Foundation.
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Mcp\Tests\Unit\Schema;
use Mcp\Schema\Tool;
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\TestCase;
class ToolTest extends TestCase
{
/**
* @return array{type: 'object', properties: array<string, mixed>, required: string[]|null}
*/
private static function validInputSchema(): array
{
return [
'type' => 'object',
'properties' => ['q' => ['type' => 'string']],
'required' => null,
];
}
private static function makeTool(?string $title, ?string $description = null): Tool
{
return new Tool(
name: 'x',
inputSchema: self::validInputSchema(),
description: $description,
annotations: null,
title: $title,
);
}
/**
* @return iterable<string, array{?string, list<string>}>
*/
public static function serializationKeyOrderProvider(): iterable
{
yield 'with title' => ['Friendly Title', ['name', 'title', 'inputSchema']];
yield 'without title' => [null, ['name', 'inputSchema']];
}
/**
* @param list<string> $expectedKeys
*/
#[DataProvider('serializationKeyOrderProvider')]
public function testSerializationPlacesTitleBetweenNameAndInputSchema(?string $title, array $expectedKeys): void
{
$serialized = self::makeTool($title)->jsonSerialize();
$this->assertSame($expectedKeys, array_keys($serialized));
if (null !== $title) {
$this->assertSame($title, $serialized['title']);
} else {
$this->assertArrayNotHasKey('title', $serialized);
}
}
/**
* @return iterable<string, array{array<string, mixed>, ?string}>
*/
public static function fromArrayTitleProvider(): iterable
{
yield 'title present' => [['title' => 'Friendly Title'], 'Friendly Title'];
yield 'title missing' => [[], null];
}
/**
* @param array<string, mixed> $extra
*/
#[DataProvider('fromArrayTitleProvider')]
public function testFromArrayReadsTitle(array $extra, ?string $expectedTitle): void
{
$tool = Tool::fromArray(['name' => 'x', 'inputSchema' => self::validInputSchema()] + $extra);
$this->assertSame($expectedTitle, $tool->title);
}
public function testRoundTripPreservesTitle(): void
{
$original = self::makeTool('Friendly Title', 'desc');
/** @var array{name: string, title?: string, inputSchema: array{type: 'object', properties: array<string, mixed>, required: string[]|null}, description?: string|null} $serialized */
$serialized = $original->jsonSerialize();
$restored = Tool::fromArray($serialized);
$this->assertSame('Friendly Title', $restored->title);
$this->assertSame($original->name, $restored->name);
$this->assertSame($original->description, $restored->description);
}
}

2
tests/Unit/Server/BuilderTest.php
View file

@ -71,7 +71,7 @@ final class BuilderTest extends TestCase
$server = Server::builder()
->setServerInfo('test', '1.0.0')
->setReferenceHandler($referenceHandler)
->addTool(static fn (): string => 'original', 'test_tool', 'A test tool')
->addTool(static fn (): string => 'original', name: 'test_tool', description: 'A test tool')
->build();
$result = $this->callTool($server, 'test_tool');

Some files were not shown because too many files have changed in this diff Show more