agents 0.30.1 → 0.31.0

package/dist/mcp/index.js

@@ -1,8 +1,8 @@
 import { getAgentByName } from "../agent-routing.js";
 import "../types.js";
-import { i as getCurrentAgent, t as Agent } from "../src-DfLzdwlK.js";
-import { c as RPCServerTransport, i as normalizeServerId, l as RPC_DO_PREFIX, n as MCP_SERVER_ID_MAX_LENGTH, s as RPCClientTransport, u as isDurableObjectNamespace } from "../client-BnYbNT3z.js";
-import { n as getMcpAuthContext, r as runWithAuthContext, t as createStatelessMcpHandler } from "../handler-stateless-Bly_nSH3.js";
+import { i as getCurrentAgent, t as Agent } from "../src-BGolXG_H.js";
+import { c as RPCClientTransport, i as normalizeServerId, l as RPC_DO_PREFIX, n as MCP_SERVER_ID_MAX_LENGTH, u as isDurableObjectNamespace } from "../client-DMWujQJ1.js";
+import { n as getMcpAuthContext, r as runWithAuthContext, t as createStatelessMcpHandler } from "../handler-stateless-B5hU3dxK.js";
 import { SSEClientTransport, StreamableHTTPClientTransport } from "@modelcontextprotocol/client";
 import { ElicitRequestSchema, InitializeRequestSchema, JSONRPCMessageSchema, SUPPORTED_PROTOCOL_VERSIONS, isInitializeRequest, isJSONRPCErrorResponse, isJSONRPCNotification, isJSONRPCRequest, isJSONRPCResultResponse } from "@modelcontextprotocol/sdk/types.js";
 import { McpServer, Server } from "@modelcontextprotocol/server";
@@ -986,6 +986,183 @@ DurableObjectEventStore.SEQ_PAD = 16;
 DurableObjectEventStore.DELETE_CHUNK = 128;
 DurableObjectEventStore.REPLAY_LIMIT = 1e3;
 //#endregion
+//#region src/mcp/rpc-server.ts
+function makeInvalidRequestError(id) {
+	return {
+		jsonrpc: "2.0",
+		id: id ?? null,
+		error: {
+			code: -32600,
+			message: "Invalid Request"
+		}
+	};
+}
+function validateBatch(batch) {
+	if (batch.length === 0) throw new Error("Invalid JSON-RPC batch: array must not be empty");
+}
+var RPCServerTransport = class {
+	constructor(options) {
+		this._started = false;
+		this._pendingRequests = /* @__PURE__ */ new Map();
+		this._pendingContinuations = [];
+		this._timeout = options?.timeout ?? 6e4;
+	}
+	setProtocolVersion(version) {
+		this._protocolVersion = version;
+	}
+	getProtocolVersion() {
+		return this._protocolVersion;
+	}
+	async start() {
+		if (this._started) throw new Error("Transport already started");
+		this._started = true;
+	}
+	async close() {
+		this._started = false;
+		this.onclose?.();
+		const error = /* @__PURE__ */ new Error("Transport closed");
+		for (const pending of this._pendingRequests.values()) {
+			clearTimeout(pending.timeoutId);
+			pending.reject(error);
+		}
+		this._pendingRequests.clear();
+		for (const pending of this._pendingContinuations) {
+			clearTimeout(pending.timeoutId);
+			pending.reject(error);
+		}
+		this._pendingContinuations = [];
+	}
+	_makeTimeout(onTimeout) {
+		return setTimeout(onTimeout, this._timeout);
+	}
+	_appendPending(pending, message) {
+		pending.messages.push(message);
+	}
+	_completePending(pending, message) {
+		pending.messages.push(message);
+		clearTimeout(pending.timeoutId);
+		const messages = pending.messages;
+		queueMicrotask(() => {
+			pending.resolve(messages.length === 1 ? messages[0] : messages);
+		});
+	}
+	_completeRequest(key, message) {
+		const pending = this._pendingRequests.get(key);
+		if (!pending) return false;
+		this._pendingRequests.delete(key);
+		this._completePending(pending, message);
+		return true;
+	}
+	_appendRequest(key, message) {
+		const pending = this._pendingRequests.get(key);
+		if (!pending) return false;
+		this._appendPending(pending, message);
+		return true;
+	}
+	_completeContinuation(message) {
+		const pending = this._pendingContinuations.shift();
+		if (!pending) return false;
+		this._completePending(pending, message);
+		return true;
+	}
+	_appendContinuation(message) {
+		const pending = this._pendingContinuations[0];
+		if (!pending) return false;
+		this._appendPending(pending, message);
+		return true;
+	}
+	async send(message, options) {
+		if (!this._started) throw new Error("Transport not started");
+		if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) {
+			const id = message.id;
+			if (id === void 0) {
+				this.onerror?.(/* @__PURE__ */ new Error(`RPC response missing id: ${JSON.stringify(message)}`));
+				return;
+			}
+			if (this._completeRequest(id.toString(), message)) return;
+			if (this._completeContinuation(message)) return;
+			this.onerror?.(/* @__PURE__ */ new Error(`No pending RPC request found for response: ${JSON.stringify(message)}`));
+			return;
+		}
+		const relatedRequestId = options?.relatedRequestId?.toString();
+		const expectsResponse = "id" in message;
+		if (relatedRequestId) {
+			if (expectsResponse) {
+				if (this._completeRequest(relatedRequestId, message)) return;
+			} else if (this._appendRequest(relatedRequestId, message)) return;
+		}
+		if (expectsResponse) {
+			if (this._completeContinuation(message)) return;
+		} else if (this._appendContinuation(message)) return;
+		this.onerror?.(/* @__PURE__ */ new Error(`No pending RPC request found for message: ${JSON.stringify(message)}`));
+	}
+	/**
+	* @internal Called by McpAgent.handleMcpMessage() — not for external use.
+	*
+	* Wait for the next unmatched send() call that expects a client response or
+	* completes a resumed tool call.
+	*
+	* Used after resolving an elicitation response: the original tool call has
+	* already returned the elicitation request to the RPC client, and the resumed
+	* tool handler will eventually send the final tool result. That final response
+	* has the original tool request id, so there is no active handle() waiter left
+	* for id-based routing; this continuation waiter receives it instead.
+	*/
+	async _awaitPendingResponse() {
+		if (!this._started) throw new Error("Transport not started");
+		return await new Promise((resolve, reject) => {
+			const pending = {
+				messages: [],
+				resolve,
+				reject,
+				timeoutId: this._makeTimeout(() => {
+					const index = this._pendingContinuations.indexOf(pending);
+					if (index !== -1) this._pendingContinuations.splice(index, 1);
+					reject(/* @__PURE__ */ new Error(`Request timeout: No response received within ${this._timeout}ms`));
+				})
+			};
+			this._pendingContinuations.push(pending);
+		});
+	}
+	async handle(message) {
+		if (!this._started) throw new Error("Transport not started");
+		if (Array.isArray(message)) {
+			validateBatch(message);
+			const flattened = (await Promise.all(message.map((msg) => this.handle(msg)))).flatMap((response) => {
+				if (response === void 0) return [];
+				return Array.isArray(response) ? response : [response];
+			});
+			return flattened.length === 0 ? void 0 : flattened;
+		}
+		try {
+			JSONRPCMessageSchema.parse(message);
+		} catch {
+			return makeInvalidRequestError(typeof message === "object" && message !== null && "id" in message ? message.id : null);
+		}
+		if (!("id" in message)) {
+			this.onmessage?.(message);
+			return;
+		}
+		const id = message.id?.toString();
+		if (!id) return makeInvalidRequestError(message.id);
+		if (this._pendingRequests.has(id)) throw new Error(`Duplicate pending RPC request id: ${id}`);
+		const responsePromise = new Promise((resolve, reject) => {
+			const pending = {
+				messages: [],
+				resolve,
+				reject,
+				timeoutId: this._makeTimeout(() => {
+					this._pendingRequests.delete(id);
+					reject(/* @__PURE__ */ new Error(`Request timeout: No response received within ${this._timeout}ms`));
+				})
+			};
+			this._pendingRequests.set(id, pending);
+		});
+		this.onmessage?.(message);
+		return await responsePromise;
+	}
+};
+//#endregion
 //#region src/mcp/client/transports.ts
 /**
 * Deprecated transport wrappers