{

private const RETRY_BASE_DELAY_MS = 100;

private ?TransportInterface $transport = null;

public function __construct(

private readonly Protocol $protocol,

private readonly Configuration $config,

private readonly LoggerInterface $logger = new NullLogger(),

) {

}

/**

public static function builder(): Builder

{

return new Builder();

}

/**

public function connect(TransportInterface $transport): void

{

$this->transport = $transport;

$this->protocol->connect($transport, $this->config);

$maxAttempts = $this->config->maxRetries + 1;

for ($attempt = 1; $attempt <= $maxAttempts; ++$attempt) {

try {

$transport->connect();

$this->logger->info('Client connected and initialized', ['attempt' => $attempt]);

return;

} catch (ExceptionInterface $e) {

// initialize() flags the session before sending the initialized

// notification, so a failure in between leaves the flag set.

$this->protocol->getState()->setInitialized(false);

$transport->close();

// Anything else, like a malformed initialize result, is not

// transient and would fail every retry the same way.

if (!$e instanceof ConnectionException) {

throw new ConnectionException('Initialization failed: '.$e->getMessage(), 0, $e);

}

if ($attempt === $maxAttempts) {

throw $e;

}

$this->logger->warning('Connection attempt failed, retrying', [

'attempt' => $attempt,

'max_attempts' => $maxAttempts,

'exception' => $e,

]);

usleep($attempt * self::RETRY_BASE_DELAY_MS * 1000);

}

}

}

/**

public function isConnected(): bool

{

return null !== $this->transport && $this->protocol->getState()->isInitialized();

}

/**

public function getServerInfo(): ?Implementation

{

return $this->protocol->getState()->getServerInfo();

}

/**

public function getInstructions(): ?string

{

return $this->protocol->getState()->getInstructions();

}

/**

public function getServerCapabilities(): ?ServerCapabilities

{

return $this->protocol->getState()->getServerCapabilities();

}

/**

public function getProtocolVersion(): ?ProtocolVersion

{

return $this->protocol->getState()->getProtocolVersion();

}

/**

public function ping(): void

{

$request = $this->protocol->isModern() ? new DiscoverRequest() : new PingRequest();

$this->sendRequest($request);

}

/**

public function listTools(?string $cursor = null): ListToolsResult

{

$request = new ListToolsRequest($cursor);

$response = $this->sendRequest($request);

$result = $response->result;

// Filtered before parsing, because parsing is where a malformed

// `x-mcp-header` annotation throws. One broken definition must cost the

// caller that tool, not the whole listing (SEP-2243).

if (\is_array($result['tools'] ?? null)) {

$result['tools'] = $this->protocol->getToolCatalog()->record($result['tools']);

}

return ListToolsResult::fromArray($result);

}

/**

public function callTool(string $name, array $arguments = [], ?callable $onProgress = null, ?CancellationTokenInterface $cancellation = null, ?float $timeoutSeconds = null): CallToolResult

{

if ($cancellation?->isCancellationRequested()) {

throw new RequestCancelledException('The client cancelled the request.');

}

if (null !== $timeoutSeconds && (!is_finite($timeoutSeconds) || $timeoutSeconds <= 0)) {

throw new InvalidArgumentException('The per-call timeout must be a finite positive number of seconds.');

}

$catalog = $this->protocol->getToolCatalog();

// A tool the listing showed to be malformed is refused here rather than

// sent: the client cannot produce the headers its annotations demand,

// so the call could only go out misdescribed (SEP-2243).

if ($catalog->isRejected($name)) {

throw new RuntimeException(\sprintf('Refusing to call tool "%s": its "x-mcp-header" annotations are invalid (%s).', $name, $catalog->reasonFor($name)));

}

$request = new CallToolRequest($name, $arguments);

$response = $this->sendRequest($request, $onProgress, $cancellation, $timeoutSeconds);

return CallToolResult::fromArray($response->result);

}

/**

public function listResources(?string $cursor = null): ListResourcesResult

{

$request = new ListResourcesRequest($cursor);

$response = $this->sendRequest($request);

return ListResourcesResult::fromArray($response->result);

}

/**

public function listResourceTemplates(?string $cursor = null): ListResourceTemplatesResult

{

$request = new ListResourceTemplatesRequest($cursor);

$response = $this->sendRequest($request);

return ListResourceTemplatesResult::fromArray($response->result);

}

/**

public function readResource(string $uri, ?callable $onProgress = null): ReadResourceResult

{

if ('' === $uri) {

throw new InvalidArgumentException('Resource URI must not be empty.');

}

$request = new ReadResourceRequest($uri);

$response = $this->sendRequest($request, $onProgress);

return ReadResourceResult::fromArray($response->result);

}

/**

public function listPrompts(?string $cursor = null): ListPromptsResult

{

$request = new ListPromptsRequest($cursor);

$response = $this->sendRequest($request);

return ListPromptsResult::fromArray($response->result);

}

/**

public function getPrompt(string $name, array $arguments = [], ?callable $onProgress = null): GetPromptResult

{

$request = new GetPromptRequest($name, $arguments);

$response = $this->sendRequest($request, $onProgress);

return GetPromptResult::fromArray($response->result);

}

/**

public function complete(PromptReference|ResourceReference $ref, array $argument): CompletionCompleteResult

{

$request = new CompletionCompleteRequest($ref, $argument);

$response = $this->sendRequest($request);

return CompletionCompleteResult::fromArray($response->result);

}

/**

public function setLoggingLevel(LoggingLevel $level): void

{

if (!$this->isConnected()) {

throw new ConnectionException('Client is not connected. Call connect() first.');

}

if ($this->protocol->isModern()) {

$this->protocol->setLogLevel($level);

return;

}

$request = new SetLogLevelRequest($level);

$this->sendRequest($request);

}

/**

public function sendRootsListChanged(): void

{

if (true !== $this->config->capabilities->rootsListChanged) {

throw new RuntimeException('Cannot send a "roots/list_changed" notification without advertising the "roots.listChanged" capability. Build the client with new ClientCapabilities(roots: true, rootsListChanged: true).');

}

if (!$this->isConnected()) {

throw new ConnectionException('Client is not connected. Call connect() first.');

}

if ($this->protocol->isModern()) {

$this->logger->debug('Not sending "notifications/roots/list_changed": the connection is on the modern era, which removed roots.');

return;

}

$this->protocol->sendNotification(new RootsListChangedNotification());

}

/**

private function sendRequest(Request $request, ?callable $onProgress = null, ?CancellationTokenInterface $cancellation = null, ?float $timeoutSeconds = null): Response

{

$transport = $this->transport;

if (null === $transport || !$this->protocol->getState()->isInitialized()) {

throw new ConnectionException('Client is not connected. Call connect() first.');

}

$withProgress = null !== $onProgress;

$fiber = new \Fiber(fn () => $this->protocol->request($request, $this->config->requestTimeout, $withProgress, $cancellation, $timeoutSeconds ?? $this->config->requestTimeout));

$this->protocol->setProgressCallback($onProgress);

try {

$response = $transport->runRequest($fiber);

} finally {

$this->protocol->setProgressCallback(null);

}

if ($response instanceof Error) {

throw RequestException::fromError($response);

}

return $response;

}

/**

public function disconnect(): void

{

if (null !== $this->transport) {

$this->transport->close();

$this->transport = null;

$this->logger->info('Client disconnected');

}

}