effect-agent 0.1.0-beta.85 → 0.1.0-beta.87

package/dist/capabilities/McpClient.mjs

@@ -0,0 +1,506 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { n as utf8ByteLength } from "../utf8-DchGZRBd.mjs";
+import { ToolExecutionClass } from "../engine/DurableStep.mjs";
+import { McpConnectionError, McpConnector, McpServerIdentity, McpToolOutputSchema } from "./Mcp.mjs";
+import { Tool, Toolkit } from "effect/unstable/ai";
+import { Cause, Context, Effect, Layer, Option, Predicate, Queue, Schema, Scope, Stream } from "effect";
+import * as McpSchema from "effect/unstable/ai/McpSchema";
+import * as McpProtocol from "effect/unstable/ai/McpProtocol";
+import { Headers, HttpClient, HttpClientRequest } from "effect/unstable/http";
+import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
+import { RpcClient, RpcClientError, RpcSerialization } from "effect/unstable/rpc";
+//#region src/capabilities/McpClient.ts
+var McpClient_exports = /* @__PURE__ */ __exportAll({
+	McpClientProtocolVersion: () => McpClientProtocolVersion,
+	McpHttpTransport: () => McpHttpTransport,
+	McpStdioTransport: () => McpStdioTransport,
+	McpToolCallFailed: () => McpToolCallFailed,
+	McpToolResult: () => McpToolResult,
+	defaultMcpClientInfo: () => defaultMcpClientInfo,
+	layer: () => layer
+});
+/** Largest single JSON-RPC message a transport accepts from a server by default. */
+const DEFAULT_MAX_MESSAGE_BYTES = 4194304;
+/** Bounded `tools/list` pagination: a server cannot keep a client walking cursors forever. */
+const MAX_TOOL_LIST_PAGES = 64;
+const MCP_SESSION_ID_HEADER = "mcp-session-id";
+const MCP_PROTOCOL_VERSION_HEADER = "mcp-protocol-version";
+const JSON_RPC_METHOD_NOT_FOUND = -32601;
+/**
+* The protocol revisions this client negotiates, as implemented by Effect AI's
+* native MCP protocol adapters. The newest revision is offered first; a server
+* answering with any other listed revision is accepted, anything else fails.
+*/
+const McpClientProtocolVersion = Schema.Literals([
+	McpProtocol.v2025_11_25.protocolVersion,
+	McpProtocol.v2025_06_18.protocolVersion,
+	McpProtocol.v2025_03_26.protocolVersion,
+	McpProtocol.v2024_11_05.protocolVersion
+]);
+const OFFERED_PROTOCOL_VERSION = McpProtocol.v2025_11_25.protocolVersion;
+/** Identity this client presents to servers during `initialize`. */
+const defaultMcpClientInfo = McpSchema.Implementation.make({
+	name: "effect-agent",
+	version: "1.0.0"
+});
+/**
+* The model-visible result of a remote MCP tool call: the server's content
+* blocks and, when the tool declares an `outputSchema`, its structured result.
+* A result with `isError` never becomes this value; it fails the Tool Call.
+*/
+var McpToolResult = class extends Schema.Class("@effect-agent/capabilities/McpToolResult")({
+	content: Schema.Array(McpSchema.ContentBlock),
+	structuredContent: Schema.optionalKey(Schema.Json)
+}) {};
+/**
+* Typed failure of one remote MCP tool call. `tool-error` carries the server's
+* error content; the other reasons describe why no trustworthy result exists.
+* None of them claims the remote effect did not happen.
+*/
+var McpToolCallFailed = class extends Schema.TaggedError()("McpToolCallFailed", {
+	serverId: Schema.NonEmptyString,
+	tool: Schema.NonEmptyString,
+	reason: Schema.Literals([
+		"tool-error",
+		"invalid-arguments",
+		"protocol-error",
+		"transport"
+	]),
+	message: Schema.String,
+	content: Schema.optionalKey(Schema.Array(McpSchema.ContentBlock))
+}) {};
+const isNotificationTag = (tag) => tag.startsWith("notifications/");
+const isRpcClientError = Schema.is(RpcClientError.RpcClientError);
+const protocolDefect = (message, cause) => new RpcClientError.RpcClientError({ reason: new RpcClientError.RpcClientDefect({
+	message,
+	cause
+}) });
+const InitializeProtocolVersion = Schema.Struct({ protocolVersion: Schema.String });
+const decodeInitializeProtocolVersion = Schema.decodeUnknownOption(InitializeProtocolVersion);
+const ServerRequest = Schema.Struct({
+	_tag: Schema.Literal("Request"),
+	tag: Schema.String
+});
+const isServerRequest = Schema.is(ServerRequest);
+const isJsonRpcRequest = (message) => isServerRequest(message);
+/** JSON-RPC error a client returns for a server-initiated request it does not serve. */
+const declineServerRequest = (request) => ({
+	_tag: "Exit",
+	requestId: request.id,
+	exit: {
+		_tag: "Failure",
+		cause: [{
+			_tag: "Fail",
+			error: {
+				code: JSON_RPC_METHOD_NOT_FOUND,
+				message: `Client does not serve ${request.tag}`
+			}
+		}]
+	}
+});
+/**
+* Routes one decoded JSON-RPC message. Responses reach the RPC client; server
+* notifications are logged; server requests (sampling, elicitation, roots)
+* are declined fail-closed through `respond` because this client serves none.
+*/
+const routeMessage = (message, options) => {
+	if (isJsonRpcRequest(message)) {
+		if (message.isNotification === true) return Effect.logDebug("Ignoring MCP server notification").pipe(Effect.annotateLogs({ method: message.tag }));
+		return options.respond(declineServerRequest(message));
+	}
+	if (Predicate.hasProperty(message, "_tag") && message._tag === "Exit") options.onExit(message);
+	return options.writeResponse(options.clientId, message);
+};
+/** Reads a response body as text while refusing bodies above `maxBytes`. */
+const readBoundedText = Effect.fn("McpHttpTransport.readBoundedText")(function* (response, maxBytes) {
+	const declared = Number(response.headers["content-length"]);
+	if (Number.isFinite(declared) && declared > maxBytes) return yield* protocolDefect(`MCP response of ${declared} bytes exceeds the ${maxBytes} byte message bound`);
+	const chunks = [];
+	let received = 0;
+	yield* response.stream.pipe(Stream.decodeText(), Stream.runForEach((chunk) => {
+		received += utf8ByteLength(chunk);
+		if (received > maxBytes) return Effect.fail(protocolDefect(`MCP response exceeds the ${maxBytes} byte message bound`));
+		chunks.push(chunk);
+		return Effect.void;
+	}), Effect.mapError((error) => isRpcClientError(error) ? error : protocolDefect("Could not read the MCP HTTP response", error)));
+	return chunks.join("");
+});
+/**
+* Delivers the `data` of each `text/event-stream` event as it arrives. Only
+* `data` fields carry JSON-RPC messages; `event`, `id`, `retry`, and comment
+* lines are ignored because this client never resumes a stream, so a server
+* retry directive neither ends the stream nor fails the request. At most
+* `maxBytes` of an unterminated event stays buffered.
+*/
+const consumeEventStream = Effect.fn("McpHttpTransport.consumeEventStream")(function* (response, maxBytes, deliver) {
+	let buffer = "";
+	let pendingBytes = 0;
+	const dispatchEvent = (block) => {
+		const data = block.split(/\r?\n/).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).replace(/^ /, "")).join("\n");
+		return data.length === 0 ? Effect.void : deliver(data);
+	};
+	const drain = (final) => Effect.suspend(() => {
+		const blocks = [];
+		while (true) {
+			const match = /\r?\n\r?\n/.exec(buffer);
+			if (match === null) break;
+			blocks.push(buffer.slice(0, match.index));
+			buffer = buffer.slice(match.index + match[0].length);
+		}
+		if (final && buffer.length > 0) {
+			blocks.push(buffer);
+			buffer = "";
+		}
+		pendingBytes = utf8ByteLength(buffer);
+		return Effect.forEach(blocks, dispatchEvent, { discard: true });
+	});
+	yield* response.stream.pipe(Stream.decodeText(), Stream.runForEach((chunk) => {
+		buffer += chunk;
+		pendingBytes += utf8ByteLength(chunk);
+		if (pendingBytes > maxBytes) return Effect.fail(protocolDefect(`MCP event stream buffered more than ${maxBytes} bytes`));
+		return drain(false);
+	}), Effect.mapError((error) => isRpcClientError(error) ? error : protocolDefect("Could not read the MCP event stream", error)));
+	yield* drain(true);
+});
+const makeHttpProtocol = Effect.fn("McpHttpTransport.protocol")(function* (options) {
+	const client = yield* HttpClient.HttpClient;
+	const serialization = RpcSerialization.jsonRpc();
+	const parser = serialization.makeUnsafe();
+	const maxMessageBytes = options.maxMessageBytes ?? DEFAULT_MAX_MESSAGE_BYTES;
+	const configuredHeaders = Headers.fromInput(options.headers);
+	const url = options.url;
+	let sessionId;
+	let protocolVersion;
+	let initializeRequestId;
+	/** Request ids whose JSON-RPC response has been delivered. */
+	const answered = /* @__PURE__ */ new Set();
+	const transportHeaders = () => Headers.merge(configuredHeaders, Headers.fromInput({
+		accept: "application/json, text/event-stream",
+		...sessionId === void 0 ? {} : { [MCP_SESSION_ID_HEADER]: sessionId },
+		...protocolVersion === void 0 ? {} : { [MCP_PROTOCOL_VERSION_HEADER]: protocolVersion }
+	}));
+	const post = (body) => client.execute(HttpClientRequest.post(url).pipe(HttpClientRequest.setHeaders(transportHeaders()), HttpClientRequest.bodyText(body, "application/json"))).pipe(Effect.mapError((error) => protocolDefect(`MCP HTTP request to ${options.serverId} failed`, error)));
+	yield* Effect.addFinalizer(() => sessionId === void 0 ? Effect.void : client.execute(HttpClientRequest.delete(url).pipe(HttpClientRequest.setHeaders(transportHeaders()))).pipe(Effect.ignore));
+	return yield* RpcClient.Protocol.make((writeResponse) => Effect.sync(() => {
+		const encode = (message) => Effect.suspend(() => {
+			const encoded = parser.encode(message);
+			return typeof encoded === "string" ? Effect.succeed(encoded) : Effect.fail(protocolDefect("Could not encode an MCP JSON-RPC message"));
+		});
+		const deliver = (clientId, data) => Effect.suspend(() => {
+			let messages;
+			try {
+				messages = parser.decode(data);
+			} catch (cause) {
+				return writeResponse(clientId, {
+					_tag: "ClientProtocolError",
+					error: protocolDefect("Could not decode an MCP JSON-RPC message", cause)
+				});
+			}
+			return Effect.forEach(messages, (message) => routeMessage(message, {
+				clientId,
+				writeResponse,
+				respond: (response) => encode(response).pipe(Effect.flatMap(post), Effect.ignore),
+				onExit: (exit) => {
+					answered.add(exit.requestId);
+					if (exit.requestId !== initializeRequestId || exit.exit._tag !== "Success") return;
+					const decoded = decodeInitializeProtocolVersion(exit.exit.value);
+					if (Option.isSome(decoded)) protocolVersion = decoded.value.protocolVersion;
+				}
+			}), { discard: true });
+		});
+		/**
+		* Posts one message and delivers whatever the server answers. A request
+		* whose HTTP exchange completes without a JSON-RPC response for its id
+		* (for example a `202`, an `id: null` error, or a stream that ends
+		* early) fails that request instead of leaving its caller waiting.
+		*/
+		const dispatch = Effect.fn("McpHttpTransport.dispatch")(function* (clientId, message, requestId) {
+			const response = yield* post(yield* encode(message));
+			const responseSession = response.headers[MCP_SESSION_ID_HEADER];
+			if (responseSession !== void 0) sessionId = responseSession;
+			if (response.status < 200 || response.status >= 300) return yield* protocolDefect(`MCP server ${options.serverId} answered HTTP ${response.status}`);
+			const contentType = response.headers["content-type"] ?? "";
+			if (response.status !== 202 && response.status !== 204) {
+				if (contentType.startsWith("text/event-stream")) yield* consumeEventStream(response, maxMessageBytes, (data) => deliver(clientId, data));
+				else {
+					const text = yield* readBoundedText(response, maxMessageBytes);
+					if (text.length > 0) yield* deliver(clientId, text);
+				}
+			}
+			if (requestId !== void 0 && !answered.has(requestId)) yield* writeResponse(clientId, {
+				_tag: "Exit",
+				requestId,
+				exit: {
+					_tag: "Failure",
+					cause: [{
+						_tag: "Die",
+						defect: `MCP server ${options.serverId} closed the HTTP exchange without answering request ${String(requestId)}`
+					}]
+				}
+			});
+			answered.delete(requestId ?? "");
+		});
+		const send = (clientId, request) => {
+			switch (request._tag) {
+				case "Request":
+					if (isNotificationTag(request.tag)) return dispatch(clientId, {
+						...request,
+						isNotification: true
+					});
+					if (request.tag === "initialize") initializeRequestId = request.id;
+					return dispatch(clientId, request, request.id);
+				case "Interrupt": return dispatch(clientId, {
+					_tag: "Request",
+					id: request.requestId,
+					tag: "notifications/cancelled",
+					payload: { requestId: request.requestId },
+					headers: [],
+					isNotification: true
+				});
+				case "Ack":
+				case "Ping":
+				case "Eof": return Effect.void;
+			}
+		};
+		return {
+			send,
+			supportsAck: false,
+			supportsTransferables: false,
+			codecFor: serialization.codecFor
+		};
+	}));
+});
+const makeStdioProtocol = Effect.fn("McpStdioTransport.protocol")(function* (options) {
+	const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+	const maxMessageBytes = options.maxMessageBytes ?? DEFAULT_MAX_MESSAGE_BYTES;
+	const serialization = RpcSerialization.ndJsonRpc({ maxBufferSize: maxMessageBytes });
+	const parser = serialization.makeUnsafe();
+	const handle = yield* spawner.spawn(ChildProcess.make(options.command, [...options.args ?? []], {
+		...options.cwd === void 0 ? {} : { cwd: options.cwd },
+		...options.env === void 0 ? {} : {
+			env: options.env,
+			extendEnv: true
+		}
+	})).pipe(Effect.mapError((cause) => McpConnectionError.make({
+		serverId: options.serverId,
+		message: `Could not start the MCP server process for ${options.serverId}`,
+		cause
+	})));
+	const outbound = yield* Queue.unbounded();
+	let closed;
+	const closedWith = (message, cause) => closed ??= protocolDefect(message, cause);
+	yield* Stream.fromQueue(outbound).pipe(Stream.encodeText, Stream.run(handle.stdin), Effect.matchCauseEffect({
+		onSuccess: () => Effect.sync(() => closedWith(`MCP server process ${options.serverId} closed stdin`)),
+		onFailure: (cause) => Cause.hasInterruptsOnly(cause) ? Effect.void : Effect.sync(() => closedWith(`Writing to MCP server process ${options.serverId} failed`, Cause.squash(cause)))
+	}), Effect.forkScoped);
+	yield* handle.stderr.pipe(Stream.decodeText(), Stream.splitLines, Stream.runForEach((line) => Effect.logDebug(line)), Effect.ignore, Effect.annotateLogs({
+		mcpServerId: options.serverId,
+		stream: "stderr"
+	}), Effect.forkScoped);
+	return yield* RpcClient.Protocol.make(Effect.fnUntraced(function* (writeResponse, clientIds) {
+		const broadcast = (error) => Effect.forEach(clientIds, (clientId) => writeResponse(clientId, {
+			_tag: "ClientProtocolError",
+			error
+		}), { discard: true });
+		const deliver = (chunk) => Effect.suspend(() => {
+			let messages;
+			try {
+				messages = parser.decode(chunk);
+			} catch (cause) {
+				return broadcast(protocolDefect("Could not decode an MCP stdio frame", cause));
+			}
+			return Effect.forEach(messages, (message) => Effect.forEach(clientIds, (clientId) => routeMessage(message, {
+				clientId,
+				writeResponse,
+				respond: (response) => enqueue(response).pipe(Effect.ignore),
+				onExit: () => {}
+			}), { discard: true }), { discard: true });
+		});
+		const enqueue = (message) => Effect.suspend(() => {
+			if (closed !== void 0) return Effect.fail(closed);
+			const encoded = parser.encode(message);
+			if (typeof encoded !== "string") return Effect.fail(protocolDefect("Could not encode an MCP JSON-RPC message"));
+			return Queue.offer(outbound, encoded).pipe(Effect.asVoid);
+		});
+		yield* handle.stdout.pipe(Stream.runForEach(deliver), Effect.matchCauseEffect({
+			onSuccess: () => broadcast(closedWith(`MCP server process ${options.serverId} closed stdout`)),
+			onFailure: (cause) => Cause.hasInterruptsOnly(cause) ? Effect.void : broadcast(closedWith(`Reading MCP server process ${options.serverId} failed`, Cause.squash(cause)))
+		}), Effect.forkScoped);
+		const send = (_clientId, request) => {
+			switch (request._tag) {
+				case "Request": return enqueue(isNotificationTag(request.tag) ? {
+					...request,
+					isNotification: true
+				} : request);
+				case "Interrupt": return enqueue({
+					_tag: "Request",
+					id: request.requestId,
+					tag: "notifications/cancelled",
+					payload: { requestId: request.requestId },
+					headers: [],
+					isNotification: true
+				});
+				case "Ack":
+				case "Ping":
+				case "Eof": return Effect.void;
+			}
+		};
+		return {
+			send,
+			supportsAck: false,
+			supportsTransferables: false,
+			codecFor: serialization.codecFor
+		};
+	}));
+});
+/** Streamable HTTP transport for one remote MCP server; requires `HttpClient`. */
+const McpHttpTransport = { make: (options) => ({
+	serverId: options.serverId,
+	trustToolAnnotations: options.trustToolAnnotations ?? false,
+	protocol: makeHttpProtocol(options)
+}) };
+/** stdio transport for one local MCP server process; requires `ChildProcessSpawner`. */
+const McpStdioTransport = { make: (options) => ({
+	serverId: options.serverId,
+	trustToolAnnotations: options.trustToolAnnotations ?? false,
+	protocol: makeStdioProtocol(options)
+}) };
+const executionClassFor = (annotations) => {
+	if (annotations === void 0) return "uncertain";
+	if (annotations.readOnlyHint) return "readonly";
+	if (annotations.idempotentHint && !annotations.destructiveHint) return "idempotent";
+	return "uncertain";
+};
+const makeMcpTool = (tool, trustToolAnnotations) => {
+	let dynamic = Tool.dynamic(tool.name, {
+		...tool.description === void 0 ? {} : { description: tool.description },
+		parameters: tool.inputSchema,
+		success: McpToolResult,
+		failure: McpToolCallFailed,
+		failureMode: "return"
+	});
+	const title = tool.title ?? tool.annotations?.title;
+	if (title !== void 0) dynamic = dynamic.annotate(Tool.Title, title);
+	dynamic = dynamic.annotate(McpToolOutputSchema, Option.fromNullishOr(tool.outputSchema));
+	if (tool.annotations !== void 0) dynamic = dynamic.annotate(Tool.Readonly, tool.annotations.readOnlyHint).annotate(Tool.Destructive, tool.annotations.destructiveHint).annotate(Tool.Idempotent, tool.annotations.idempotentHint).annotate(Tool.OpenWorld, tool.annotations.openWorldHint);
+	if (trustToolAnnotations) dynamic = dynamic.annotate(ToolExecutionClass, executionClassFor(tool.annotations));
+	return dynamic;
+};
+const ToolArguments = Schema.Record(Schema.String, Schema.Json);
+const decodeToolArguments = Schema.decodeUnknownEffect(ToolArguments);
+const errorText = (content) => content.flatMap((block) => block.type === "text" ? [block.text] : []).join("\n").slice(0, 4096);
+const describeDefect = (defect) => (Predicate.hasProperty(defect, "message") && Predicate.isString(defect.message) ? defect.message : String(defect)).slice(0, 4096);
+const connectionError = (serverId, message) => (cause) => McpConnectionError.make({
+	serverId,
+	message,
+	cause
+});
+/**
+* Keeps every non-interrupt outcome of one protocol step typed: expected
+* failures and defects (such as an undecodable server reply) both become the
+* connection error, so a misbehaving server cannot crash the connector.
+*/
+const failClosed = (serverId, message) => (self) => self.pipe(Effect.mapError(connectionError(serverId, message)), Effect.catchDefect((defect) => Effect.fail(connectionError(serverId, message)(defect))));
+const connectServer = Effect.fn("McpClient.connect")(function* (transport, request, clientInfo) {
+	const serverId = transport.serverId;
+	const protocol = yield* transport.protocol;
+	const client = yield* RpcClient.make(McpSchema.ClientRpcs, {
+		spanPrefix: "McpClient",
+		spanAttributes: { "mcp.server_id": serverId }
+	}).pipe(Effect.provideService(RpcClient.Protocol, protocol));
+	const initialized = yield* client.initialize({
+		protocolVersion: OFFERED_PROTOCOL_VERSION,
+		capabilities: McpSchema.ClientCapabilities.make({}),
+		clientInfo
+	}).pipe(failClosed(serverId, `MCP initialize with ${serverId} failed`));
+	const negotiated = yield* Schema.decodeUnknownEffect(McpClientProtocolVersion)(initialized.protocolVersion).pipe(Effect.mapError(connectionError(serverId, `MCP server ${serverId} negotiated unsupported protocol version '${initialized.protocolVersion}'`)));
+	yield* Effect.annotateCurrentSpan({ "mcp.protocol_version": negotiated });
+	yield* client["notifications/initialized"](void 0, { discard: true }).pipe(failClosed(serverId, `Could not acknowledge MCP initialization with ${serverId}`));
+	const tools = [];
+	let cursor;
+	let pages = 0;
+	do {
+		const page = yield* client["tools/list"](cursor === void 0 ? void 0 : McpSchema.PaginatedRequestMeta.make({ cursor })).pipe(failClosed(serverId, `MCP tools/list with ${serverId} failed`));
+		tools.push(...page.tools);
+		cursor = page.nextCursor;
+		pages += 1;
+		if (tools.length > request.maxToolCount) break;
+		if (cursor !== void 0 && pages >= MAX_TOOL_LIST_PAGES) return yield* McpConnectionError.make({
+			serverId,
+			message: `MCP server ${serverId} paginated tools/list beyond ${MAX_TOOL_LIST_PAGES} pages`
+		});
+	} while (cursor !== void 0);
+	const callTool = Effect.fn("McpClient.callTool")(function* (name, params) {
+		const args = yield* decodeToolArguments(params ?? {}).pipe(Effect.mapError((cause) => McpToolCallFailed.make({
+			serverId,
+			tool: name,
+			reason: "invalid-arguments",
+			message: `MCP tool arguments must be a JSON object: ${cause.message}`
+		})));
+		const result = yield* client["tools/call"]({
+			name,
+			arguments: args
+		}).pipe(Effect.mapError((error) => McpToolCallFailed.make({
+			serverId,
+			tool: name,
+			reason: isRpcClientError(error) ? "transport" : "protocol-error",
+			message: error.message
+		})), Effect.catchDefect((defect) => Effect.fail(McpToolCallFailed.make({
+			serverId,
+			tool: name,
+			reason: "protocol-error",
+			message: describeDefect(defect)
+		}))));
+		if (result.isError === true) return yield* McpToolCallFailed.make({
+			serverId,
+			tool: name,
+			reason: "tool-error",
+			message: errorText(result.content),
+			content: result.content
+		});
+		return McpToolResult.make({
+			content: result.content,
+			...result.structuredContent === void 0 ? {} : { structuredContent: result.structuredContent }
+		});
+	});
+	const toolkit = yield* Effect.try({
+		try: () => Toolkit.make(...tools.map((tool) => makeMcpTool(tool, transport.trustToolAnnotations))),
+		catch: connectionError(serverId, `MCP server ${serverId} advertised tools that cannot form a Toolkit`)
+	});
+	const handlers = toolkit.toLayer(Object.fromEntries(tools.map((tool) => [tool.name, (params) => callTool(tool.name, params)])));
+	return {
+		identity: McpServerIdentity.make({
+			serverId,
+			implementation: initialized.serverInfo
+		}),
+		capabilities: initialized.capabilities,
+		tools,
+		toolkit,
+		handlers
+	};
+});
+const makeConnectorLayer = (transports, options) => Layer.effect(McpConnector)(Effect.gen(function* () {
+	const services = yield* Effect.context();
+	const byServerId = new Map(transports.map((transport) => [transport.serverId, transport]));
+	const clientInfo = options?.clientInfo ?? defaultMcpClientInfo;
+	return McpConnector.of({ connect: (request) => {
+		const transport = byServerId.get(request.serverId);
+		if (transport === void 0) return Effect.fail(McpConnectionError.make({
+			serverId: request.serverId,
+			message: `No MCP transport is configured for server '${request.serverId}'`
+		}));
+		return connectServer(transport, request, clientInfo).pipe(Effect.updateContext((caller) => Context.merge(Context.merge(caller, services), Context.pick(Scope.Scope)(caller))));
+	} });
+}));
+/**
+* `McpConnector` over real transports. Each `connect` acquires the transport
+* in the caller's Scope, negotiates a protocol revision, lists tools within the
+* request bounds, and returns dynamic Effect AI Tools plus the handler Layer
+* that forwards their calls. The Layer requires the union of every
+* transport's platform services.
+*/
+const layer = (transports, options) => makeConnectorLayer(transports, options);
+//#endregion
+export { McpClientProtocolVersion, McpHttpTransport, McpStdioTransport, McpToolCallFailed, McpToolResult, defaultMcpClientInfo, layer, McpClient_exports as t };
+
+//# sourceMappingURL=McpClient.mjs.map

package/dist/capabilities/McpClient.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"McpClient.mjs","names":[],"sources":["../../src/capabilities/McpClient.ts"],"sourcesContent":["import {\n  Cause,\n  Context,\n  Effect,\n  Layer,\n  Option,\n  Predicate,\n  Queue,\n  Schema,\n  Scope,\n  Stream,\n} from \"effect\";\nimport { Tool, Toolkit } from \"effect/unstable/ai\";\nimport * as McpProtocol from \"effect/unstable/ai/McpProtocol\";\nimport * as McpSchema from \"effect/unstable/ai/McpSchema\";\nimport {\n  Headers,\n  HttpClient,\n  HttpClientRequest,\n  type HttpClientResponse,\n} from \"effect/unstable/http\";\nimport { ChildProcess, ChildProcessSpawner } from \"effect/unstable/process\";\nimport { RpcClient, RpcClientError, type RpcMessage, RpcSerialization } from \"effect/unstable/rpc\";\n\nimport { utf8ByteLength } from \"../core/internal/utf8.ts\";\nimport { ToolExecutionClass, type ToolExecutionClassValue } from \"../engine/DurableStep.ts\";\nimport {\n  McpConnectionError,\n  McpConnector,\n  type McpConnectedServer,\n  type McpConnectionRequest,\n  McpServerIdentity,\n  McpToolOutputSchema,\n} from \"./Mcp.ts\";\n\n// ---------------------------------------------------------------------------\n// MCP client: native Effect AI MCP schemas and protocol adapters, the Effect\n// RPC client, and Effect HTTP / child-process services connect an Agent to a\n// remote MCP server. Discovered tools become dynamic Effect AI Tools whose\n// handlers forward `tools/call`; `connectMcp` still applies every discovery\n// bound before the Toolkit reaches Agent context.\n// ---------------------------------------------------------------------------\n\n/** Largest single JSON-RPC message a transport accepts from a server by default. */\nconst DEFAULT_MAX_MESSAGE_BYTES = 4 * 1024 * 1024;\n/** Bounded `tools/list` pagination: a server cannot keep a client walking cursors forever. */\nconst MAX_TOOL_LIST_PAGES = 64;\nconst MCP_SESSION_ID_HEADER = \"mcp-session-id\";\nconst MCP_PROTOCOL_VERSION_HEADER = \"mcp-protocol-version\";\nconst JSON_RPC_METHOD_NOT_FOUND = -32601;\n\n/**\n * The protocol revisions this client negotiates, as implemented by Effect AI's\n * native MCP protocol adapters. The newest revision is offered first; a server\n * answering with any other listed revision is accepted, anything else fails.\n */\nexport const McpClientProtocolVersion = Schema.Literals([\n  McpProtocol.v2025_11_25.protocolVersion,\n  McpProtocol.v2025_06_18.protocolVersion,\n  McpProtocol.v2025_03_26.protocolVersion,\n  McpProtocol.v2024_11_05.protocolVersion,\n]);\n\nexport type McpClientProtocolVersion = typeof McpClientProtocolVersion.Type;\n\nconst OFFERED_PROTOCOL_VERSION: McpClientProtocolVersion = McpProtocol.v2025_11_25.protocolVersion;\n\n/** Identity this client presents to servers during `initialize`. */\nexport const defaultMcpClientInfo = McpSchema.Implementation.make({\n  name: \"effect-agent\",\n  version: \"1.0.0\",\n});\n\n/**\n * The model-visible result of a remote MCP tool call: the server's content\n * blocks and, when the tool declares an `outputSchema`, its structured result.\n * A result with `isError` never becomes this value; it fails the Tool Call.\n */\nexport class McpToolResult extends Schema.Class<McpToolResult>(\n  \"@effect-agent/capabilities/McpToolResult\",\n)({\n  content: Schema.Array(McpSchema.ContentBlock),\n  structuredContent: Schema.optionalKey(Schema.Json),\n}) {}\n\n/**\n * Typed failure of one remote MCP tool call. `tool-error` carries the server's\n * error content; the other reasons describe why no trustworthy result exists.\n * None of them claims the remote effect did not happen.\n */\nexport class McpToolCallFailed extends Schema.TaggedError<McpToolCallFailed>()(\n  \"McpToolCallFailed\",\n  {\n    serverId: Schema.NonEmptyString,\n    tool: Schema.NonEmptyString,\n    reason: Schema.Literals([\"tool-error\", \"invalid-arguments\", \"protocol-error\", \"transport\"]),\n    message: Schema.String,\n    content: Schema.optionalKey(Schema.Array(McpSchema.ContentBlock)),\n  },\n) {}\n\n/**\n * One reachable MCP server. `protocol` acquires a JSON-RPC transport in the\n * caller's Scope; `R` names the platform services that transport needs so the\n * connector Layer keeps them in its requirements.\n */\nexport interface McpServerTransport<R = never> {\n  readonly serverId: string;\n  /**\n   * Whether the server's `readOnlyHint`, `idempotentHint`, and\n   * `destructiveHint` may set the framework execution class of its tools.\n   * Hints are server-declared and untrusted, so the default leaves every\n   * remote tool `uncertain`.\n   */\n  readonly trustToolAnnotations: boolean;\n  readonly protocol: Effect.Effect<\n    RpcClient.Protocol[\"Service\"],\n    McpConnectionError,\n    Scope.Scope | R\n  >;\n}\n\n/** Streamable HTTP server address. Header values may carry credentials the application owns. */\nexport interface McpHttpTransportOptions {\n  readonly serverId: string;\n  readonly url: string;\n  readonly headers?: Headers.Input | undefined;\n  /** Largest accepted response message. Defaults to 4 MiB. */\n  readonly maxMessageBytes?: number | undefined;\n  readonly trustToolAnnotations?: boolean | undefined;\n}\n\n/** A local MCP server process speaking newline-delimited JSON-RPC on stdio. */\nexport interface McpStdioTransportOptions {\n  readonly serverId: string;\n  readonly command: string;\n  readonly args?: ReadonlyArray<string> | undefined;\n  readonly cwd?: string | undefined;\n  readonly env?: Readonly<Record<string, string>> | undefined;\n  /** Largest accepted stdout frame. Defaults to 4 MiB. */\n  readonly maxMessageBytes?: number | undefined;\n  readonly trustToolAnnotations?: boolean | undefined;\n}\n\nconst isNotificationTag = (tag: string): boolean => tag.startsWith(\"notifications/\");\nconst isRpcClientError = Schema.is(RpcClientError.RpcClientError);\n\nconst protocolDefect = (message: string, cause?: unknown): RpcClientError.RpcClientError =>\n  new RpcClientError.RpcClientError({\n    reason: new RpcClientError.RpcClientDefect({ message, cause }),\n  });\n\nconst InitializeProtocolVersion = Schema.Struct({ protocolVersion: Schema.String });\nconst decodeInitializeProtocolVersion = Schema.decodeUnknownOption(InitializeProtocolVersion);\n\nconst ServerRequest = Schema.Struct({ _tag: Schema.Literal(\"Request\"), tag: Schema.String });\nconst isServerRequest = Schema.is(ServerRequest);\n\nconst isJsonRpcRequest = (message: unknown): message is RpcMessage.RequestEncoded =>\n  isServerRequest(message);\n\n/** JSON-RPC error a client returns for a server-initiated request it does not serve. */\nconst declineServerRequest = (\n  request: RpcMessage.RequestEncoded,\n): RpcMessage.ResponseExitEncoded => ({\n  _tag: \"Exit\",\n  requestId: request.id,\n  exit: {\n    _tag: \"Failure\",\n    cause: [\n      {\n        _tag: \"Fail\",\n        error: {\n          code: JSON_RPC_METHOD_NOT_FOUND,\n          message: `Client does not serve ${request.tag}`,\n        },\n      },\n    ],\n  },\n});\n\n/**\n * Routes one decoded JSON-RPC message. Responses reach the RPC client; server\n * notifications are logged; server requests (sampling, elicitation, roots)\n * are declined fail-closed through `respond` because this client serves none.\n */\nconst routeMessage = (\n  message: unknown,\n  options: {\n    readonly clientId: number;\n    readonly writeResponse: (\n      clientId: number,\n      response: RpcMessage.FromServerEncoded,\n    ) => Effect.Effect<void>;\n    readonly respond: (response: RpcMessage.ResponseExitEncoded) => Effect.Effect<void>;\n    readonly onExit: (exit: RpcMessage.ResponseExitEncoded) => void;\n  },\n): Effect.Effect<void> => {\n  if (isJsonRpcRequest(message)) {\n    if (message.isNotification === true) {\n      return Effect.logDebug(\"Ignoring MCP server notification\").pipe(\n        Effect.annotateLogs({ method: message.tag }),\n      );\n    }\n\n    return options.respond(declineServerRequest(message));\n  }\n  if (Predicate.hasProperty(message, \"_tag\") && message._tag === \"Exit\") {\n    options.onExit(message as RpcMessage.ResponseExitEncoded);\n  }\n\n  return options.writeResponse(options.clientId, message as RpcMessage.FromServerEncoded);\n};\n\n/** Reads a response body as text while refusing bodies above `maxBytes`. */\nconst readBoundedText = Effect.fn(\"McpHttpTransport.readBoundedText\")(function* (\n  response: HttpClientResponse.HttpClientResponse,\n  maxBytes: number,\n) {\n  const declared = Number(response.headers[\"content-length\"]);\n\n  if (Number.isFinite(declared) && declared > maxBytes) {\n    return yield* protocolDefect(\n      `MCP response of ${declared} bytes exceeds the ${maxBytes} byte message bound`,\n    );\n  }\n  const chunks: Array<string> = [];\n  let received = 0;\n\n  yield* response.stream.pipe(\n    Stream.decodeText(),\n    Stream.runForEach((chunk) => {\n      received += utf8ByteLength(chunk);\n      if (received > maxBytes) {\n        return Effect.fail(\n          protocolDefect(`MCP response exceeds the ${maxBytes} byte message bound`),\n        );\n      }\n      chunks.push(chunk);\n\n      return Effect.void;\n    }),\n    Effect.mapError((error) =>\n      isRpcClientError(error)\n        ? error\n        : protocolDefect(\"Could not read the MCP HTTP response\", error),\n    ),\n  );\n\n  return chunks.join(\"\");\n});\n\n/**\n * Delivers the `data` of each `text/event-stream` event as it arrives. Only\n * `data` fields carry JSON-RPC messages; `event`, `id`, `retry`, and comment\n * lines are ignored because this client never resumes a stream, so a server\n * retry directive neither ends the stream nor fails the request. At most\n * `maxBytes` of an unterminated event stays buffered.\n */\nconst consumeEventStream = Effect.fn(\"McpHttpTransport.consumeEventStream\")(function* (\n  response: HttpClientResponse.HttpClientResponse,\n  maxBytes: number,\n  deliver: (data: string) => Effect.Effect<void>,\n) {\n  let buffer = \"\";\n  let pendingBytes = 0;\n\n  const dispatchEvent = (block: string): Effect.Effect<void> => {\n    const data = block\n      .split(/\\r?\\n/)\n      .filter((line) => line.startsWith(\"data:\"))\n      .map((line) => line.slice(\"data:\".length).replace(/^ /, \"\"))\n      .join(\"\\n\");\n\n    return data.length === 0 ? Effect.void : deliver(data);\n  };\n\n  const drain = (final: boolean): Effect.Effect<void> =>\n    Effect.suspend(() => {\n      const blocks: Array<string> = [];\n\n      while (true) {\n        const match = /\\r?\\n\\r?\\n/.exec(buffer);\n\n        if (match === null) break;\n        blocks.push(buffer.slice(0, match.index));\n        buffer = buffer.slice(match.index + match[0].length);\n      }\n      if (final && buffer.length > 0) {\n        blocks.push(buffer);\n        buffer = \"\";\n      }\n      pendingBytes = utf8ByteLength(buffer);\n\n      return Effect.forEach(blocks, dispatchEvent, { discard: true });\n    });\n\n  yield* response.stream.pipe(\n    Stream.decodeText(),\n    Stream.runForEach((chunk) => {\n      buffer += chunk;\n      pendingBytes += utf8ByteLength(chunk);\n      if (pendingBytes > maxBytes) {\n        return Effect.fail(protocolDefect(`MCP event stream buffered more than ${maxBytes} bytes`));\n      }\n\n      return drain(false);\n    }),\n    Effect.mapError((error) =>\n      isRpcClientError(error)\n        ? error\n        : protocolDefect(\"Could not read the MCP event stream\", error),\n    ),\n  );\n  yield* drain(true);\n});\n\nconst makeHttpProtocol = Effect.fn(\"McpHttpTransport.protocol\")(function* (\n  options: McpHttpTransportOptions,\n) {\n  const client = yield* HttpClient.HttpClient;\n  const serialization = RpcSerialization.jsonRpc();\n  const parser = serialization.makeUnsafe();\n  const maxMessageBytes = options.maxMessageBytes ?? DEFAULT_MAX_MESSAGE_BYTES;\n  const configuredHeaders = Headers.fromInput(options.headers);\n  const url = options.url;\n  let sessionId: string | undefined;\n  let protocolVersion: string | undefined;\n  let initializeRequestId: string | number | undefined;\n  /** Request ids whose JSON-RPC response has been delivered. */\n  const answered = new Set<string | number>();\n\n  const transportHeaders = (): Headers.Headers =>\n    Headers.merge(\n      configuredHeaders,\n      Headers.fromInput({\n        accept: \"application/json, text/event-stream\",\n        ...(sessionId === undefined ? {} : { [MCP_SESSION_ID_HEADER]: sessionId }),\n        ...(protocolVersion === undefined\n          ? {}\n          : { [MCP_PROTOCOL_VERSION_HEADER]: protocolVersion }),\n      }),\n    );\n\n  const post = (body: string) =>\n    client\n      .execute(\n        HttpClientRequest.post(url).pipe(\n          HttpClientRequest.setHeaders(transportHeaders()),\n          HttpClientRequest.bodyText(body, \"application/json\"),\n        ),\n      )\n      .pipe(\n        Effect.mapError((error) =>\n          protocolDefect(`MCP HTTP request to ${options.serverId} failed`, error),\n        ),\n      );\n\n  // Ending the session is a courtesy to the server; the Scope owns the client.\n  yield* Effect.addFinalizer(() =>\n    sessionId === undefined\n      ? Effect.void\n      : client\n          .execute(\n            HttpClientRequest.delete(url).pipe(HttpClientRequest.setHeaders(transportHeaders())),\n          )\n          .pipe(Effect.ignore),\n  );\n\n  return yield* RpcClient.Protocol.make((writeResponse) =>\n    Effect.sync(() => {\n      const encode = (message: unknown): Effect.Effect<string, RpcClientError.RpcClientError> =>\n        Effect.suspend(() => {\n          const encoded = parser.encode(message);\n\n          return typeof encoded === \"string\"\n            ? Effect.succeed(encoded)\n            : Effect.fail(protocolDefect(\"Could not encode an MCP JSON-RPC message\"));\n        });\n\n      const deliver = (clientId: number, data: string): Effect.Effect<void> =>\n        Effect.suspend(() => {\n          let messages: ReadonlyArray<unknown>;\n\n          try {\n            messages = parser.decode(data);\n          } catch (cause) {\n            return writeResponse(clientId, {\n              _tag: \"ClientProtocolError\",\n              error: protocolDefect(\"Could not decode an MCP JSON-RPC message\", cause),\n            });\n          }\n\n          return Effect.forEach(\n            messages,\n            (message) =>\n              routeMessage(message, {\n                clientId,\n                writeResponse,\n                respond: (response) => encode(response).pipe(Effect.flatMap(post), Effect.ignore),\n                onExit: (exit) => {\n                  answered.add(exit.requestId);\n                  if (exit.requestId !== initializeRequestId || exit.exit._tag !== \"Success\") {\n                    return;\n                  }\n                  const decoded = decodeInitializeProtocolVersion(exit.exit.value);\n\n                  if (Option.isSome(decoded)) protocolVersion = decoded.value.protocolVersion;\n                },\n              }),\n            { discard: true },\n          );\n        });\n\n      /**\n       * Posts one message and delivers whatever the server answers. A request\n       * whose HTTP exchange completes without a JSON-RPC response for its id\n       * (for example a `202`, an `id: null` error, or a stream that ends\n       * early) fails that request instead of leaving its caller waiting.\n       */\n      const dispatch = Effect.fn(\"McpHttpTransport.dispatch\")(function* (\n        clientId: number,\n        message: unknown,\n        requestId?: string | number,\n      ) {\n        const response = yield* post(yield* encode(message));\n        const responseSession = response.headers[MCP_SESSION_ID_HEADER];\n\n        if (responseSession !== undefined) sessionId = responseSession;\n        if (response.status < 200 || response.status >= 300) {\n          return yield* protocolDefect(\n            `MCP server ${options.serverId} answered HTTP ${response.status}`,\n          );\n        }\n        const contentType = response.headers[\"content-type\"] ?? \"\";\n\n        if (response.status !== 202 && response.status !== 204) {\n          if (contentType.startsWith(\"text/event-stream\")) {\n            yield* consumeEventStream(response, maxMessageBytes, (data) => deliver(clientId, data));\n          } else {\n            const text = yield* readBoundedText(response, maxMessageBytes);\n\n            if (text.length > 0) yield* deliver(clientId, text);\n          }\n        }\n        if (requestId !== undefined && !answered.has(requestId)) {\n          yield* writeResponse(clientId, {\n            _tag: \"Exit\",\n            requestId,\n            exit: {\n              _tag: \"Failure\",\n              cause: [\n                {\n                  _tag: \"Die\",\n                  defect: `MCP server ${options.serverId} closed the HTTP exchange without answering request ${String(requestId)}`,\n                },\n              ],\n            },\n          });\n        }\n        answered.delete(requestId ?? \"\");\n      });\n\n      const send: RpcClient.Protocol[\"Service\"][\"send\"] = (clientId, request) => {\n        switch (request._tag) {\n          case \"Request\": {\n            if (isNotificationTag(request.tag)) {\n              return dispatch(clientId, { ...request, isNotification: true });\n            }\n            if (request.tag === \"initialize\") initializeRequestId = request.id;\n\n            return dispatch(clientId, request, request.id);\n          }\n          case \"Interrupt\": {\n            return dispatch(clientId, {\n              _tag: \"Request\",\n              id: request.requestId,\n              tag: \"notifications/cancelled\",\n              payload: { requestId: request.requestId },\n              headers: [],\n              isNotification: true,\n            } satisfies RpcMessage.RequestEncoded);\n          }\n          case \"Ack\":\n          case \"Ping\":\n          case \"Eof\": {\n            return Effect.void;\n          }\n        }\n      };\n\n      return {\n        send,\n        supportsAck: false,\n        supportsTransferables: false,\n        codecFor: serialization.codecFor,\n      };\n    }),\n  );\n});\n\nconst makeStdioProtocol = Effect.fn(\"McpStdioTransport.protocol\")(function* (\n  options: McpStdioTransportOptions,\n) {\n  const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;\n  const maxMessageBytes = options.maxMessageBytes ?? DEFAULT_MAX_MESSAGE_BYTES;\n  const serialization = RpcSerialization.ndJsonRpc({ maxBufferSize: maxMessageBytes });\n  const parser = serialization.makeUnsafe();\n\n  const handle = yield* spawner\n    .spawn(\n      ChildProcess.make(options.command, [...(options.args ?? [])], {\n        ...(options.cwd === undefined ? {} : { cwd: options.cwd }),\n        ...(options.env === undefined ? {} : { env: options.env, extendEnv: true }),\n      }),\n    )\n    .pipe(\n      Effect.mapError((cause) =>\n        McpConnectionError.make({\n          serverId: options.serverId,\n          message: `Could not start the MCP server process for ${options.serverId}`,\n          cause,\n        }),\n      ),\n    );\n\n  const outbound = yield* Queue.unbounded<string>();\n  // Once the process is gone every later send fails immediately instead of\n  // queueing behind a writer that no longer exists.\n  let closed: RpcClientError.RpcClientError | undefined;\n\n  const closedWith = (message: string, cause?: unknown): RpcClientError.RpcClientError =>\n    (closed ??= protocolDefect(message, cause));\n\n  yield* Stream.fromQueue(outbound).pipe(\n    Stream.encodeText,\n    Stream.run(handle.stdin),\n    Effect.matchCauseEffect({\n      onSuccess: () =>\n        Effect.sync(() => closedWith(`MCP server process ${options.serverId} closed stdin`)),\n      onFailure: (cause) =>\n        Cause.hasInterruptsOnly(cause)\n          ? Effect.void\n          : Effect.sync(() =>\n              closedWith(\n                `Writing to MCP server process ${options.serverId} failed`,\n                Cause.squash(cause),\n              ),\n            ),\n    }),\n    Effect.forkScoped,\n  );\n  yield* handle.stderr.pipe(\n    Stream.decodeText(),\n    Stream.splitLines,\n    Stream.runForEach((line) => Effect.logDebug(line)),\n    Effect.ignore,\n    Effect.annotateLogs({ mcpServerId: options.serverId, stream: \"stderr\" }),\n    Effect.forkScoped,\n  );\n\n  return yield* RpcClient.Protocol.make(\n    Effect.fnUntraced(function* (writeResponse, clientIds) {\n      const broadcast = (error: RpcClientError.RpcClientError) =>\n        Effect.forEach(\n          clientIds,\n          (clientId) => writeResponse(clientId, { _tag: \"ClientProtocolError\", error }),\n          { discard: true },\n        );\n\n      const deliver = (chunk: Uint8Array): Effect.Effect<void> =>\n        Effect.suspend(() => {\n          let messages: ReadonlyArray<unknown>;\n\n          try {\n            messages = parser.decode(chunk);\n          } catch (cause) {\n            return broadcast(protocolDefect(\"Could not decode an MCP stdio frame\", cause));\n          }\n\n          return Effect.forEach(\n            messages,\n            (message) =>\n              Effect.forEach(\n                clientIds,\n                (clientId) =>\n                  routeMessage(message, {\n                    clientId,\n                    writeResponse,\n                    respond: (response) => enqueue(response).pipe(Effect.ignore),\n                    onExit: () => {},\n                  }),\n                { discard: true },\n              ),\n            { discard: true },\n          );\n        });\n\n      const enqueue = (message: unknown): Effect.Effect<void, RpcClientError.RpcClientError> =>\n        Effect.suspend(() => {\n          if (closed !== undefined) return Effect.fail(closed);\n          const encoded = parser.encode(message);\n\n          if (typeof encoded !== \"string\") {\n            return Effect.fail(protocolDefect(\"Could not encode an MCP JSON-RPC message\"));\n          }\n\n          return Queue.offer(outbound, encoded).pipe(Effect.asVoid);\n        });\n\n      yield* handle.stdout.pipe(\n        Stream.runForEach(deliver),\n        Effect.matchCauseEffect({\n          onSuccess: () =>\n            broadcast(closedWith(`MCP server process ${options.serverId} closed stdout`)),\n          onFailure: (cause) =>\n            Cause.hasInterruptsOnly(cause)\n              ? Effect.void\n              : broadcast(\n                  closedWith(\n                    `Reading MCP server process ${options.serverId} failed`,\n                    Cause.squash(cause),\n                  ),\n                ),\n        }),\n        Effect.forkScoped,\n      );\n\n      const send: RpcClient.Protocol[\"Service\"][\"send\"] = (_clientId, request) => {\n        switch (request._tag) {\n          case \"Request\": {\n            return enqueue(\n              isNotificationTag(request.tag) ? { ...request, isNotification: true } : request,\n            );\n          }\n          case \"Interrupt\": {\n            return enqueue({\n              _tag: \"Request\",\n              id: request.requestId,\n              tag: \"notifications/cancelled\",\n              payload: { requestId: request.requestId },\n              headers: [],\n              isNotification: true,\n            } satisfies RpcMessage.RequestEncoded);\n          }\n          case \"Ack\":\n          case \"Ping\":\n          case \"Eof\": {\n            return Effect.void;\n          }\n        }\n      };\n\n      return {\n        send,\n        supportsAck: false,\n        supportsTransferables: false,\n        codecFor: serialization.codecFor,\n      };\n    }),\n  );\n});\n\n/** Streamable HTTP transport for one remote MCP server; requires `HttpClient`. */\nexport const McpHttpTransport = {\n  make: (options: McpHttpTransportOptions): McpServerTransport<HttpClient.HttpClient> => ({\n    serverId: options.serverId,\n    trustToolAnnotations: options.trustToolAnnotations ?? false,\n    protocol: makeHttpProtocol(options),\n  }),\n} as const;\n\n/** stdio transport for one local MCP server process; requires `ChildProcessSpawner`. */\nexport const McpStdioTransport = {\n  make: (\n    options: McpStdioTransportOptions,\n  ): McpServerTransport<ChildProcessSpawner.ChildProcessSpawner> => ({\n    serverId: options.serverId,\n    trustToolAnnotations: options.trustToolAnnotations ?? false,\n    protocol: makeStdioProtocol(options),\n  }),\n} as const;\n\n/**\n * Effect AI Tool derived from one discovered MCP tool. Its parameters are the\n * server's JSON Schema, so handlers receive `unknown` and the server validates\n * arguments; `Tool.getJsonSchema` still advertises the discovered schema. A\n * failed call returns `McpToolCallFailed` to the model as a failed tool result.\n */\nexport type McpTool = Tool.Tool<\n  string,\n  {\n    readonly parameters: typeof Schema.Unknown;\n    readonly success: typeof McpToolResult;\n    readonly failure: typeof McpToolCallFailed;\n    readonly failureMode: \"return\";\n  }\n>;\n\n/** Toolkit of discovered MCP tools; every member forwards `tools/call` to its server. */\nexport type McpToolkit = Toolkit.Toolkit<Record<string, McpTool>>;\n\nconst executionClassFor = (\n  annotations: McpSchema.ToolAnnotations | undefined,\n): ToolExecutionClassValue => {\n  if (annotations === undefined) return \"uncertain\";\n  if (annotations.readOnlyHint) return \"readonly\";\n  if (annotations.idempotentHint && !annotations.destructiveHint) return \"idempotent\";\n\n  return \"uncertain\";\n};\n\nconst makeMcpTool = (tool: McpSchema.Tool, trustToolAnnotations: boolean): McpTool => {\n  let dynamic: McpTool = Tool.dynamic(tool.name, {\n    ...(tool.description === undefined ? {} : { description: tool.description }),\n    parameters: tool.inputSchema,\n    success: McpToolResult,\n    failure: McpToolCallFailed,\n    // MCP reports tool errors inside results so the model can self-correct;\n    // `return` hands the typed failure to the model the same way.\n    failureMode: \"return\",\n  });\n\n  const title = tool.title ?? tool.annotations?.title;\n\n  if (title !== undefined) dynamic = dynamic.annotate(Tool.Title, title);\n  dynamic = dynamic.annotate(McpToolOutputSchema, Option.fromNullishOr(tool.outputSchema));\n  if (tool.annotations !== undefined) {\n    dynamic = dynamic\n      .annotate(Tool.Readonly, tool.annotations.readOnlyHint)\n      .annotate(Tool.Destructive, tool.annotations.destructiveHint)\n      .annotate(Tool.Idempotent, tool.annotations.idempotentHint)\n      .annotate(Tool.OpenWorld, tool.annotations.openWorldHint);\n  }\n  if (trustToolAnnotations) {\n    dynamic = dynamic.annotate(ToolExecutionClass, executionClassFor(tool.annotations));\n  }\n\n  return dynamic;\n};\n\nconst ToolArguments = Schema.Record(Schema.String, Schema.Json);\nconst decodeToolArguments = Schema.decodeUnknownEffect(ToolArguments);\n\nconst errorText = (content: ReadonlyArray<typeof McpSchema.ContentBlock.Type>): string =>\n  content\n    .flatMap((block) => (block.type === \"text\" ? [block.text] : []))\n    .join(\"\\n\")\n    .slice(0, 4 * 1024);\n\nconst describeDefect = (defect: unknown): string =>\n  (Predicate.hasProperty(defect, \"message\") && Predicate.isString(defect.message)\n    ? defect.message\n    : String(defect)\n  ).slice(0, 4 * 1024);\n\nconst connectionError = (serverId: string, message: string) => (cause: unknown) =>\n  McpConnectionError.make({ serverId, message, cause });\n\n/**\n * Keeps every non-interrupt outcome of one protocol step typed: expected\n * failures and defects (such as an undecodable server reply) both become the\n * connection error, so a misbehaving server cannot crash the connector.\n */\nconst failClosed =\n  (serverId: string, message: string) =>\n  <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, McpConnectionError, R> =>\n    self.pipe(\n      Effect.mapError(connectionError(serverId, message)),\n      Effect.catchDefect((defect) => Effect.fail(connectionError(serverId, message)(defect))),\n    );\n\nconst connectServer = Effect.fn(\"McpClient.connect\")(function* <R>(\n  transport: McpServerTransport<R>,\n  request: McpConnectionRequest,\n  clientInfo: McpSchema.Implementation,\n): Effect.fn.Return<McpConnectedServer, McpConnectionError, Scope.Scope | R> {\n  const serverId = transport.serverId;\n  const protocol = yield* transport.protocol;\n\n  const client = yield* RpcClient.make(McpSchema.ClientRpcs, {\n    spanPrefix: \"McpClient\",\n    spanAttributes: { \"mcp.server_id\": serverId },\n  }).pipe(Effect.provideService(RpcClient.Protocol, protocol));\n\n  const initialized = yield* client\n    .initialize({\n      protocolVersion: OFFERED_PROTOCOL_VERSION,\n      capabilities: McpSchema.ClientCapabilities.make({}),\n      clientInfo,\n    })\n    .pipe(failClosed(serverId, `MCP initialize with ${serverId} failed`));\n\n  const negotiated = yield* Schema.decodeUnknownEffect(McpClientProtocolVersion)(\n    initialized.protocolVersion,\n  ).pipe(\n    Effect.mapError(\n      connectionError(\n        serverId,\n        `MCP server ${serverId} negotiated unsupported protocol version '${initialized.protocolVersion}'`,\n      ),\n    ),\n  );\n\n  yield* Effect.annotateCurrentSpan({ \"mcp.protocol_version\": negotiated });\n  yield* client[\"notifications/initialized\"](undefined, { discard: true }).pipe(\n    failClosed(serverId, `Could not acknowledge MCP initialization with ${serverId}`),\n  );\n\n  const tools: Array<McpSchema.Tool> = [];\n  let cursor: string | undefined;\n  let pages = 0;\n\n  do {\n    const page = yield* client[\"tools/list\"](\n      cursor === undefined ? undefined : McpSchema.PaginatedRequestMeta.make({ cursor }),\n    ).pipe(failClosed(serverId, `MCP tools/list with ${serverId} failed`));\n\n    tools.push(...page.tools);\n    cursor = page.nextCursor;\n    pages += 1;\n    // `validateMcpDiscovery` rejects the count; stop paying for more pages.\n    if (tools.length > request.maxToolCount) break;\n    if (cursor !== undefined && pages >= MAX_TOOL_LIST_PAGES) {\n      return yield* McpConnectionError.make({\n        serverId,\n        message: `MCP server ${serverId} paginated tools/list beyond ${MAX_TOOL_LIST_PAGES} pages`,\n      });\n    }\n  } while (cursor !== undefined);\n\n  const callTool = Effect.fn(\"McpClient.callTool\")(function* (name: string, params: unknown) {\n    const args = yield* decodeToolArguments(params ?? {}).pipe(\n      Effect.mapError((cause) =>\n        McpToolCallFailed.make({\n          serverId,\n          tool: name,\n          reason: \"invalid-arguments\",\n          message: `MCP tool arguments must be a JSON object: ${cause.message}`,\n        }),\n      ),\n    );\n\n    const result = yield* client[\"tools/call\"]({ name, arguments: args }).pipe(\n      Effect.mapError((error) =>\n        McpToolCallFailed.make({\n          serverId,\n          tool: name,\n          reason: isRpcClientError(error) ? \"transport\" : \"protocol-error\",\n          message: error.message,\n        }),\n      ),\n      // A JSON-RPC error the MCP error union cannot decode (or any other\n      // malformed reply) surfaces as a defect from the RPC client. It is still\n      // the server's answer, so it reaches the model as a failed tool result\n      // rather than aborting the batch.\n      Effect.catchDefect((defect) =>\n        Effect.fail(\n          McpToolCallFailed.make({\n            serverId,\n            tool: name,\n            reason: \"protocol-error\",\n            message: describeDefect(defect),\n          }),\n        ),\n      ),\n    );\n\n    if (result.isError === true) {\n      return yield* McpToolCallFailed.make({\n        serverId,\n        tool: name,\n        reason: \"tool-error\",\n        message: errorText(result.content),\n        content: result.content,\n      });\n    }\n\n    return McpToolResult.make({\n      content: result.content,\n      ...(result.structuredContent === undefined\n        ? {}\n        : { structuredContent: result.structuredContent }),\n    });\n  });\n\n  const toolkit: McpToolkit = yield* Effect.try({\n    try: () =>\n      Toolkit.make(...tools.map((tool) => makeMcpTool(tool, transport.trustToolAnnotations))),\n    catch: connectionError(\n      serverId,\n      `MCP server ${serverId} advertised tools that cannot form a Toolkit`,\n    ),\n  });\n\n  const handlers = toolkit.toLayer(\n    Object.fromEntries(\n      tools.map((tool) => [tool.name, (params: unknown) => callTool(tool.name, params)] as const),\n    ),\n  );\n\n  return {\n    identity: McpServerIdentity.make({ serverId, implementation: initialized.serverInfo }),\n    capabilities: initialized.capabilities,\n    tools,\n    toolkit,\n    handlers,\n  } satisfies McpConnectedServer;\n});\n\n/** Platform services one transport needs, as declared by `McpServerTransport<R>`. */\nexport type McpTransportRequirements<Transport> =\n  Transport extends McpServerTransport<infer R> ? R : never;\n\nconst makeConnectorLayer = <R>(\n  transports: ReadonlyArray<McpServerTransport<R>>,\n  options: { readonly clientInfo?: McpSchema.Implementation | undefined } | undefined,\n): Layer.Layer<McpConnector, never, R> =>\n  Layer.effect(McpConnector)(\n    Effect.gen(function* () {\n      const services = yield* Effect.context<R>();\n      const byServerId = new Map(transports.map((transport) => [transport.serverId, transport]));\n      const clientInfo = options?.clientInfo ?? defaultMcpClientInfo;\n\n      return McpConnector.of({\n        connect: (request) => {\n          const transport = byServerId.get(request.serverId);\n\n          if (transport === undefined) {\n            return Effect.fail(\n              McpConnectionError.make({\n                serverId: request.serverId,\n                message: `No MCP transport is configured for server '${request.serverId}'`,\n              }),\n            );\n          }\n\n          // The Layer supplies the transport's platform services, but the\n          // connection must live and die with the caller's Scope, never the\n          // Layer's.\n          return connectServer(transport, request, clientInfo).pipe(\n            Effect.updateContext((caller: Context.Context<Scope.Scope>) =>\n              Context.merge(Context.merge(caller, services), Context.pick(Scope.Scope)(caller)),\n            ),\n          );\n        },\n      });\n    }),\n  );\n\n/**\n * `McpConnector` over real transports. Each `connect` acquires the transport\n * in the caller's Scope, negotiates a protocol revision, lists tools within the\n * request bounds, and returns dynamic Effect AI Tools plus the handler Layer\n * that forwards their calls. The Layer requires the union of every\n * transport's platform services.\n */\nexport const layer = <const Transports extends ReadonlyArray<McpServerTransport<unknown>>>(\n  transports: Transports,\n  options?: { readonly clientInfo?: McpSchema.Implementation | undefined },\n): Layer.Layer<McpConnector, never, McpTransportRequirements<Transports[number]>> =>\n  makeConnectorLayer(\n    // Type-level only: each element declares its own `R`, and the Layer\n    // requires their union. Nothing about the values changes.\n    transports as ReadonlyArray<McpServerTransport<McpTransportRequirements<Transports[number]>>>,\n    options,\n  );\n"],"mappings":"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"}