{

/**

protected function clientBuilder(): ClientBuilder

{

return parent::clientBuilder()->setProtocolVersion(ProtocolVersion::V2025_11_25);

}

#[TestDox('the sampled completion reaches the tool that asked for it')]

public function testSampledCompletionReachesTheTool(): void

{

$client = $this->connect('sampling', $this->clientSampling());

$result = $client->callTool('summarize', ['text' => 'a long report']);

$this->assertInstanceOf(TextContent::class, $result->content[0]);

$this->assertSame('test-model said: a long report', $result->content[0]->text);

}

#[TestDox('the prompt the tool passed arrives at the client')]

public function testPromptReachesTheClient(): void

{

// The client stays in this process, so what it was asked can be

// collected by reference even though the tool asking runs in another.

/** @var \ArrayObject<int, CreateSamplingMessageRequest> $seen */

$seen = new \ArrayObject();

$client = $this->connect('sampling', $this->clientSampling($seen));

$client->callTool('summarize', ['text' => 'inspect me']);

$this->assertCount(1, $seen);

$request = $seen[0];

$this->assertInstanceOf(CreateSamplingMessageRequest::class, $request);

$this->assertInstanceOf(TextContent::class, $request->messages[0]->content);

$this->assertSame('inspect me', $request->messages[0]->content->text);

$this->assertSame(64, $request->maxTokens);

}

#[TestDox('a gateway parameter is injected, not published in the schema')]

public function testGatewayParameterIsInjectedNotPublished(): void

{

$client = $this->connect('sampling', $this->clientSampling());

$tool = null;

foreach ($client->listTools()->tools as $candidate) {

if ('summarize_via_gateway' === $candidate->name) {

$tool = $candidate;

}

}

$this->assertNotNull($tool);

$properties = $tool->inputSchema['properties'] ?? null;

$this->assertIsArray($properties);

$this->assertArrayNotHasKey('client', $properties);

$this->assertArrayHasKey('text', $properties);

$this->assertSame(['text'], $tool->inputSchema['required'] ?? null);

$result = $client->callTool('summarize_via_gateway', ['text' => 'a long report']);

$this->assertInstanceOf(TextContent::class, $result->content[0]);

$this->assertSame('test-model said: a long report', $result->content[0]->text);

}

#[TestDox('a client that cannot sample refuses instead of stalling the tool')]

public function testClientWithoutSamplingRefuses(): void

{

// The gateway has no supportsSampling() to consult, so the tool finds

// out by asking and the refusal surfaces as a ClientException.

$client = $this->connect('sampling');

$result = $client->callTool('summarize', ['text' => 'anything']);

$this->assertInstanceOf(TextContent::class, $result->content[0]);

$this->assertSame('Client does not handle "sampling/createMessage" requests.', $result->content[0]->text);

}

#[TestDox('a tool that samples tells a client on the modern era it cannot, rather than hanging')]

public function testSamplingIsUnavailableOnTheModernEra(): void

{

$client = $this->connect('sampling', $this->clientSampling()->setProtocolVersion(ProtocolVersion::V2026_07_28));

$this->assertSame(ProtocolVersion::V2026_07_28, $client->getProtocolVersion());

try {

$client->callTool('summarize', ['text' => 'hello']);

$this->fail('Sampling must not be sent from inside a request on 2026-07-28.');

} catch (RequestException $e) {

$this->assertStringContainsString('"sampling/createMessage"', $e->getMessage());

$this->assertStringContainsString('InputRequiredResult', $e->getMessage());

}

}

#[TestDox('a sampling ask the tool returns is answered on the modern era a default client settles on')]

public function testReturnedAskIsAnsweredOnTheModernEra(): void

{

$client = $this->connect('sampling', $this->clientSampling(on: parent::clientBuilder()));

$this->assertSame(ProtocolVersion::V2026_07_28, $client->getProtocolVersion());

$result = $client->callTool('summarize_by_asking', ['text' => 'a long report']);

$this->assertInstanceOf(TextContent::class, $result->content[0]);

$this->assertSame('test-model said: a long report', $result->content[0]->text);

}

/**

private function clientSampling(?\ArrayObject $seen = null, ?ClientBuilder $on = null): ClientBuilder

{

$callback = new class($seen ?? new \ArrayObject()) implements SamplingCallbackInterface {

/** @param \ArrayObject<int, CreateSamplingMessageRequest> $seen */

public function __construct(private readonly \ArrayObject $seen)

{

}

public function __invoke(CreateSamplingMessageRequest $request): CreateSamplingMessageResult

{

$this->seen[] = $request;

$prompt = $request->messages[0]->content;

\assert($prompt instanceof TextContent);

return new CreateSamplingMessageResult(Role::Assistant, new TextContent($prompt->text), 'test-model');

}

};

return ($on ?? $this->clientBuilder())

->setCapabilities(new ClientCapabilities(sampling: true))

->addRequestHandler(new SamplingRequestHandler($callback));

}