@agentconnect.md/daemon 1.0.0-rc.23 → 1.0.0-rc.231

package/dist/bridge-DXIVgEzf.js

@@ -0,0 +1,726 @@
+import { t as DAEMON_VERSION } from "./version-DGaRXjBK.js";
+import { A as ListToolsRequestSchema, G as safeParse, K as decodeFrames, L as SUPPORTED_PROTOCOL_VERSIONS, M as LoggingLevelSchema, N as McpError, R as SetLevelRequestSchema, S as InitializedNotificationSchema, U as getObjectShape, W as isZ4Schema, _ as EmptyResultSchema, a as AjvJsonSchemaValidator, b as InitializeRequestSchema, c as CallToolRequestSchema, f as CreateMessageResultSchema, g as ElicitResultSchema, i as assertToolsCallTaskCapability, k as ListRootsResultSchema, l as CallToolResultSchema, m as CreateTaskResultSchema, n as serializeMessage, o as Protocol, p as CreateMessageResultWithToolsSchema, q as encodeFrame, r as assertClientRequestTaskCapability, s as mergeCapabilities, t as ReadBuffer, v as ErrorCode, w as LATEST_PROTOCOL_VERSION } from "./stdio-CwrB9yrX.js";
+import process$1 from "node:process";
+import net from "node:net";
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.29.0_zod@4.4.3/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/server.js
+/**
+* Experimental server task features for MCP SDK.
+* WARNING: These APIs are experimental and may change without notice.
+*
+* @experimental
+*/
+/**
+* Experimental task features for low-level MCP servers.
+*
+* Access via `server.experimental.tasks`:
+* ```typescript
+* const stream = server.experimental.tasks.requestStream(request, schema, options);
+* ```
+*
+* For high-level server usage with task-based tools, use `McpServer.experimental.tasks` instead.
+*
+* @experimental
+*/
+var ExperimentalServerTasks = class {
+	constructor(_server) {
+		this._server = _server;
+	}
+	/**
+	* Sends a request and returns an AsyncGenerator that yields response messages.
+	* The generator is guaranteed to end with either a 'result' or 'error' message.
+	*
+	* This method provides streaming access to request processing, allowing you to
+	* observe intermediate task status updates for task-augmented requests.
+	*
+	* @param request - The request to send
+	* @param resultSchema - Zod schema for validating the result
+	* @param options - Optional request options (timeout, signal, task creation params, etc.)
+	* @returns AsyncGenerator that yields ResponseMessage objects
+	*
+	* @experimental
+	*/
+	requestStream(request, resultSchema, options) {
+		return this._server.requestStream(request, resultSchema, options);
+	}
+	/**
+	* Sends a sampling request and returns an AsyncGenerator that yields response messages.
+	* The generator is guaranteed to end with either a 'result' or 'error' message.
+	*
+	* For task-augmented requests, yields 'taskCreated' and 'taskStatus' messages
+	* before the final result.
+	*
+	* @example
+	* ```typescript
+	* const stream = server.experimental.tasks.createMessageStream({
+	*     messages: [{ role: 'user', content: { type: 'text', text: 'Hello' } }],
+	*     maxTokens: 100
+	* }, {
+	*     onprogress: (progress) => {
+	*         // Handle streaming tokens via progress notifications
+	*         console.log('Progress:', progress.message);
+	*     }
+	* });
+	*
+	* for await (const message of stream) {
+	*     switch (message.type) {
+	*         case 'taskCreated':
+	*             console.log('Task created:', message.task.taskId);
+	*             break;
+	*         case 'taskStatus':
+	*             console.log('Task status:', message.task.status);
+	*             break;
+	*         case 'result':
+	*             console.log('Final result:', message.result);
+	*             break;
+	*         case 'error':
+	*             console.error('Error:', message.error);
+	*             break;
+	*     }
+	* }
+	* ```
+	*
+	* @param params - The sampling request parameters
+	* @param options - Optional request options (timeout, signal, task creation params, onprogress, etc.)
+	* @returns AsyncGenerator that yields ResponseMessage objects
+	*
+	* @experimental
+	*/
+	createMessageStream(params, options) {
+		const clientCapabilities = this._server.getClientCapabilities();
+		if ((params.tools || params.toolChoice) && !clientCapabilities?.sampling?.tools) throw new Error("Client does not support sampling tools capability.");
+		if (params.messages.length > 0) {
+			const lastMessage = params.messages[params.messages.length - 1];
+			const lastContent = Array.isArray(lastMessage.content) ? lastMessage.content : [lastMessage.content];
+			const hasToolResults = lastContent.some((c) => c.type === "tool_result");
+			const previousMessage = params.messages.length > 1 ? params.messages[params.messages.length - 2] : void 0;
+			const previousContent = previousMessage ? Array.isArray(previousMessage.content) ? previousMessage.content : [previousMessage.content] : [];
+			const hasPreviousToolUse = previousContent.some((c) => c.type === "tool_use");
+			if (hasToolResults) {
+				if (lastContent.some((c) => c.type !== "tool_result")) throw new Error("The last message must contain only tool_result content if any is present");
+				if (!hasPreviousToolUse) throw new Error("tool_result blocks are not matching any tool_use from the previous message");
+			}
+			if (hasPreviousToolUse) {
+				const toolUseIds = new Set(previousContent.filter((c) => c.type === "tool_use").map((c) => c.id));
+				const toolResultIds = new Set(lastContent.filter((c) => c.type === "tool_result").map((c) => c.toolUseId));
+				if (toolUseIds.size !== toolResultIds.size || ![...toolUseIds].every((id) => toolResultIds.has(id))) throw new Error("ids of tool_result blocks and tool_use blocks from previous message do not match");
+			}
+		}
+		return this.requestStream({
+			method: "sampling/createMessage",
+			params
+		}, CreateMessageResultSchema, options);
+	}
+	/**
+	* Sends an elicitation request and returns an AsyncGenerator that yields response messages.
+	* The generator is guaranteed to end with either a 'result' or 'error' message.
+	*
+	* For task-augmented requests (especially URL-based elicitation), yields 'taskCreated'
+	* and 'taskStatus' messages before the final result.
+	*
+	* @example
+	* ```typescript
+	* const stream = server.experimental.tasks.elicitInputStream({
+	*     mode: 'url',
+	*     message: 'Please authenticate',
+	*     elicitationId: 'auth-123',
+	*     url: 'https://example.com/auth'
+	* }, {
+	*     task: { ttl: 300000 } // Task-augmented for long-running auth flow
+	* });
+	*
+	* for await (const message of stream) {
+	*     switch (message.type) {
+	*         case 'taskCreated':
+	*             console.log('Task created:', message.task.taskId);
+	*             break;
+	*         case 'taskStatus':
+	*             console.log('Task status:', message.task.status);
+	*             break;
+	*         case 'result':
+	*             console.log('User action:', message.result.action);
+	*             break;
+	*         case 'error':
+	*             console.error('Error:', message.error);
+	*             break;
+	*     }
+	* }
+	* ```
+	*
+	* @param params - The elicitation request parameters
+	* @param options - Optional request options (timeout, signal, task creation params, etc.)
+	* @returns AsyncGenerator that yields ResponseMessage objects
+	*
+	* @experimental
+	*/
+	elicitInputStream(params, options) {
+		const clientCapabilities = this._server.getClientCapabilities();
+		const mode = params.mode ?? "form";
+		switch (mode) {
+			case "url":
+				if (!clientCapabilities?.elicitation?.url) throw new Error("Client does not support url elicitation.");
+				break;
+			case "form":
+				if (!clientCapabilities?.elicitation?.form) throw new Error("Client does not support form elicitation.");
+				break;
+		}
+		const normalizedParams = mode === "form" && params.mode === void 0 ? {
+			...params,
+			mode: "form"
+		} : params;
+		return this.requestStream({
+			method: "elicitation/create",
+			params: normalizedParams
+		}, ElicitResultSchema, options);
+	}
+	/**
+	* Gets the current status of a task.
+	*
+	* @param taskId - The task identifier
+	* @param options - Optional request options
+	* @returns The task status
+	*
+	* @experimental
+	*/
+	async getTask(taskId, options) {
+		return this._server.getTask({ taskId }, options);
+	}
+	/**
+	* Retrieves the result of a completed task.
+	*
+	* @param taskId - The task identifier
+	* @param resultSchema - Zod schema for validating the result
+	* @param options - Optional request options
+	* @returns The task result
+	*
+	* @experimental
+	*/
+	async getTaskResult(taskId, resultSchema, options) {
+		return this._server.getTaskResult({ taskId }, resultSchema, options);
+	}
+	/**
+	* Lists tasks with optional pagination.
+	*
+	* @param cursor - Optional pagination cursor
+	* @param options - Optional request options
+	* @returns List of tasks with optional next cursor
+	*
+	* @experimental
+	*/
+	async listTasks(cursor, options) {
+		return this._server.listTasks(cursor ? { cursor } : void 0, options);
+	}
+	/**
+	* Cancels a running task.
+	*
+	* @param taskId - The task identifier
+	* @param options - Optional request options
+	*
+	* @experimental
+	*/
+	async cancelTask(taskId, options) {
+		return this._server.cancelTask({ taskId }, options);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.29.0_zod@4.4.3/node_modules/@modelcontextprotocol/sdk/dist/esm/server/index.js
+/**
+* An MCP server on top of a pluggable transport.
+*
+* This server will automatically respond to the initialization flow as initiated from the client.
+*
+* To use with custom types, extend the base Request/Notification/Result types and pass them as type parameters:
+*
+* ```typescript
+* // Custom schemas
+* const CustomRequestSchema = RequestSchema.extend({...})
+* const CustomNotificationSchema = NotificationSchema.extend({...})
+* const CustomResultSchema = ResultSchema.extend({...})
+*
+* // Type aliases
+* type CustomRequest = z.infer<typeof CustomRequestSchema>
+* type CustomNotification = z.infer<typeof CustomNotificationSchema>
+* type CustomResult = z.infer<typeof CustomResultSchema>
+*
+* // Create typed server
+* const server = new Server<CustomRequest, CustomNotification, CustomResult>({
+*   name: "CustomServer",
+*   version: "1.0.0"
+* })
+* ```
+* @deprecated Use `McpServer` instead for the high-level API. Only use `Server` for advanced use cases.
+*/
+var Server = class extends Protocol {
+	/**
+	* Initializes this server with the given name and version information.
+	*/
+	constructor(_serverInfo, options) {
+		super(options);
+		this._serverInfo = _serverInfo;
+		this._loggingLevels = /* @__PURE__ */ new Map();
+		this.LOG_LEVEL_SEVERITY = new Map(LoggingLevelSchema.options.map((level, index) => [level, index]));
+		this.isMessageIgnored = (level, sessionId) => {
+			const currentLevel = this._loggingLevels.get(sessionId);
+			return currentLevel ? this.LOG_LEVEL_SEVERITY.get(level) < this.LOG_LEVEL_SEVERITY.get(currentLevel) : false;
+		};
+		this._capabilities = options?.capabilities ?? {};
+		this._instructions = options?.instructions;
+		this._jsonSchemaValidator = options?.jsonSchemaValidator ?? new AjvJsonSchemaValidator();
+		this.setRequestHandler(InitializeRequestSchema, (request) => this._oninitialize(request));
+		this.setNotificationHandler(InitializedNotificationSchema, () => this.oninitialized?.());
+		if (this._capabilities.logging) this.setRequestHandler(SetLevelRequestSchema, async (request, extra) => {
+			const transportSessionId = extra.sessionId || extra.requestInfo?.headers["mcp-session-id"] || void 0;
+			const { level } = request.params;
+			const parseResult = LoggingLevelSchema.safeParse(level);
+			if (parseResult.success) this._loggingLevels.set(transportSessionId, parseResult.data);
+			return {};
+		});
+	}
+	/**
+	* Access experimental features.
+	*
+	* WARNING: These APIs are experimental and may change without notice.
+	*
+	* @experimental
+	*/
+	get experimental() {
+		if (!this._experimental) this._experimental = { tasks: new ExperimentalServerTasks(this) };
+		return this._experimental;
+	}
+	/**
+	* Registers new capabilities. This can only be called before connecting to a transport.
+	*
+	* The new capabilities will be merged with any existing capabilities previously given (e.g., at initialization).
+	*/
+	registerCapabilities(capabilities) {
+		if (this.transport) throw new Error("Cannot register capabilities after connecting to transport");
+		this._capabilities = mergeCapabilities(this._capabilities, capabilities);
+	}
+	/**
+	* Override request handler registration to enforce server-side validation for tools/call.
+	*/
+	setRequestHandler(requestSchema, handler) {
+		const methodSchema = getObjectShape(requestSchema)?.method;
+		if (!methodSchema) throw new Error("Schema is missing a method literal");
+		let methodValue;
+		if (isZ4Schema(methodSchema)) {
+			const v4Schema = methodSchema;
+			methodValue = (v4Schema._zod?.def)?.value ?? v4Schema.value;
+		} else {
+			const v3Schema = methodSchema;
+			methodValue = v3Schema._def?.value ?? v3Schema.value;
+		}
+		if (typeof methodValue !== "string") throw new Error("Schema method literal must be a string");
+		if (methodValue === "tools/call") {
+			const wrappedHandler = async (request, extra) => {
+				const validatedRequest = safeParse(CallToolRequestSchema, request);
+				if (!validatedRequest.success) {
+					const errorMessage = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
+					throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call request: ${errorMessage}`);
+				}
+				const { params } = validatedRequest.data;
+				const result = await Promise.resolve(handler(request, extra));
+				if (params.task) {
+					const taskValidationResult = safeParse(CreateTaskResultSchema, result);
+					if (!taskValidationResult.success) {
+						const errorMessage = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error);
+						throw new McpError(ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage}`);
+					}
+					return taskValidationResult.data;
+				}
+				const validationResult = safeParse(CallToolResultSchema, result);
+				if (!validationResult.success) {
+					const errorMessage = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
+					throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call result: ${errorMessage}`);
+				}
+				return validationResult.data;
+			};
+			return super.setRequestHandler(requestSchema, wrappedHandler);
+		}
+		return super.setRequestHandler(requestSchema, handler);
+	}
+	assertCapabilityForMethod(method) {
+		switch (method) {
+			case "sampling/createMessage":
+				if (!this._clientCapabilities?.sampling) throw new Error(`Client does not support sampling (required for ${method})`);
+				break;
+			case "elicitation/create":
+				if (!this._clientCapabilities?.elicitation) throw new Error(`Client does not support elicitation (required for ${method})`);
+				break;
+			case "roots/list":
+				if (!this._clientCapabilities?.roots) throw new Error(`Client does not support listing roots (required for ${method})`);
+				break;
+			case "ping": break;
+		}
+	}
+	assertNotificationCapability(method) {
+		switch (method) {
+			case "notifications/message":
+				if (!this._capabilities.logging) throw new Error(`Server does not support logging (required for ${method})`);
+				break;
+			case "notifications/resources/updated":
+			case "notifications/resources/list_changed":
+				if (!this._capabilities.resources) throw new Error(`Server does not support notifying about resources (required for ${method})`);
+				break;
+			case "notifications/tools/list_changed":
+				if (!this._capabilities.tools) throw new Error(`Server does not support notifying of tool list changes (required for ${method})`);
+				break;
+			case "notifications/prompts/list_changed":
+				if (!this._capabilities.prompts) throw new Error(`Server does not support notifying of prompt list changes (required for ${method})`);
+				break;
+			case "notifications/elicitation/complete":
+				if (!this._clientCapabilities?.elicitation?.url) throw new Error(`Client does not support URL elicitation (required for ${method})`);
+				break;
+			case "notifications/cancelled": break;
+			case "notifications/progress": break;
+		}
+	}
+	assertRequestHandlerCapability(method) {
+		if (!this._capabilities) return;
+		switch (method) {
+			case "completion/complete":
+				if (!this._capabilities.completions) throw new Error(`Server does not support completions (required for ${method})`);
+				break;
+			case "logging/setLevel":
+				if (!this._capabilities.logging) throw new Error(`Server does not support logging (required for ${method})`);
+				break;
+			case "prompts/get":
+			case "prompts/list":
+				if (!this._capabilities.prompts) throw new Error(`Server does not support prompts (required for ${method})`);
+				break;
+			case "resources/list":
+			case "resources/templates/list":
+			case "resources/read":
+				if (!this._capabilities.resources) throw new Error(`Server does not support resources (required for ${method})`);
+				break;
+			case "tools/call":
+			case "tools/list":
+				if (!this._capabilities.tools) throw new Error(`Server does not support tools (required for ${method})`);
+				break;
+			case "tasks/get":
+			case "tasks/list":
+			case "tasks/result":
+			case "tasks/cancel":
+				if (!this._capabilities.tasks) throw new Error(`Server does not support tasks capability (required for ${method})`);
+				break;
+			case "ping":
+			case "initialize": break;
+		}
+	}
+	assertTaskCapability(method) {
+		assertClientRequestTaskCapability(this._clientCapabilities?.tasks?.requests, method, "Client");
+	}
+	assertTaskHandlerCapability(method) {
+		if (!this._capabilities) return;
+		assertToolsCallTaskCapability(this._capabilities.tasks?.requests, method, "Server");
+	}
+	async _oninitialize(request) {
+		const requestedVersion = request.params.protocolVersion;
+		this._clientCapabilities = request.params.capabilities;
+		this._clientVersion = request.params.clientInfo;
+		return {
+			protocolVersion: SUPPORTED_PROTOCOL_VERSIONS.includes(requestedVersion) ? requestedVersion : LATEST_PROTOCOL_VERSION,
+			capabilities: this.getCapabilities(),
+			serverInfo: this._serverInfo,
+			...this._instructions && { instructions: this._instructions }
+		};
+	}
+	/**
+	* After initialization has completed, this will be populated with the client's reported capabilities.
+	*/
+	getClientCapabilities() {
+		return this._clientCapabilities;
+	}
+	/**
+	* After initialization has completed, this will be populated with information about the client's name and version.
+	*/
+	getClientVersion() {
+		return this._clientVersion;
+	}
+	getCapabilities() {
+		return this._capabilities;
+	}
+	async ping() {
+		return this.request({ method: "ping" }, EmptyResultSchema);
+	}
+	async createMessage(params, options) {
+		if (params.tools || params.toolChoice) {
+			if (!this._clientCapabilities?.sampling?.tools) throw new Error("Client does not support sampling tools capability.");
+		}
+		if (params.messages.length > 0) {
+			const lastMessage = params.messages[params.messages.length - 1];
+			const lastContent = Array.isArray(lastMessage.content) ? lastMessage.content : [lastMessage.content];
+			const hasToolResults = lastContent.some((c) => c.type === "tool_result");
+			const previousMessage = params.messages.length > 1 ? params.messages[params.messages.length - 2] : void 0;
+			const previousContent = previousMessage ? Array.isArray(previousMessage.content) ? previousMessage.content : [previousMessage.content] : [];
+			const hasPreviousToolUse = previousContent.some((c) => c.type === "tool_use");
+			if (hasToolResults) {
+				if (lastContent.some((c) => c.type !== "tool_result")) throw new Error("The last message must contain only tool_result content if any is present");
+				if (!hasPreviousToolUse) throw new Error("tool_result blocks are not matching any tool_use from the previous message");
+			}
+			if (hasPreviousToolUse) {
+				const toolUseIds = new Set(previousContent.filter((c) => c.type === "tool_use").map((c) => c.id));
+				const toolResultIds = new Set(lastContent.filter((c) => c.type === "tool_result").map((c) => c.toolUseId));
+				if (toolUseIds.size !== toolResultIds.size || ![...toolUseIds].every((id) => toolResultIds.has(id))) throw new Error("ids of tool_result blocks and tool_use blocks from previous message do not match");
+			}
+		}
+		if (params.tools) return this.request({
+			method: "sampling/createMessage",
+			params
+		}, CreateMessageResultWithToolsSchema, options);
+		return this.request({
+			method: "sampling/createMessage",
+			params
+		}, CreateMessageResultSchema, options);
+	}
+	/**
+	* Creates an elicitation request for the given parameters.
+	* For backwards compatibility, `mode` may be omitted for form requests and will default to `'form'`.
+	* @param params The parameters for the elicitation request.
+	* @param options Optional request options.
+	* @returns The result of the elicitation request.
+	*/
+	async elicitInput(params, options) {
+		switch (params.mode ?? "form") {
+			case "url": {
+				if (!this._clientCapabilities?.elicitation?.url) throw new Error("Client does not support url elicitation.");
+				const urlParams = params;
+				return this.request({
+					method: "elicitation/create",
+					params: urlParams
+				}, ElicitResultSchema, options);
+			}
+			case "form": {
+				if (!this._clientCapabilities?.elicitation?.form) throw new Error("Client does not support form elicitation.");
+				const formParams = params.mode === "form" ? params : {
+					...params,
+					mode: "form"
+				};
+				const result = await this.request({
+					method: "elicitation/create",
+					params: formParams
+				}, ElicitResultSchema, options);
+				if (result.action === "accept" && result.content && formParams.requestedSchema) try {
+					const validationResult = this._jsonSchemaValidator.getValidator(formParams.requestedSchema)(result.content);
+					if (!validationResult.valid) throw new McpError(ErrorCode.InvalidParams, `Elicitation response content does not match requested schema: ${validationResult.errorMessage}`);
+				} catch (error) {
+					if (error instanceof McpError) throw error;
+					throw new McpError(ErrorCode.InternalError, `Error validating elicitation response: ${error instanceof Error ? error.message : String(error)}`);
+				}
+				return result;
+			}
+		}
+	}
+	/**
+	* Creates a reusable callback that, when invoked, will send a `notifications/elicitation/complete`
+	* notification for the specified elicitation ID.
+	*
+	* @param elicitationId The ID of the elicitation to mark as complete.
+	* @param options Optional notification options. Useful when the completion notification should be related to a prior request.
+	* @returns A function that emits the completion notification when awaited.
+	*/
+	createElicitationCompletionNotifier(elicitationId, options) {
+		if (!this._clientCapabilities?.elicitation?.url) throw new Error("Client does not support URL elicitation (required for notifications/elicitation/complete)");
+		return () => this.notification({
+			method: "notifications/elicitation/complete",
+			params: { elicitationId }
+		}, options);
+	}
+	async listRoots(params, options) {
+		return this.request({
+			method: "roots/list",
+			params
+		}, ListRootsResultSchema, options);
+	}
+	/**
+	* Sends a logging message to the client, if connected.
+	* Note: You only need to send the parameters object, not the entire JSON RPC message
+	* @see LoggingMessageNotification
+	* @param params
+	* @param sessionId optional for stateless and backward compatibility
+	*/
+	async sendLoggingMessage(params, sessionId) {
+		if (this._capabilities.logging) {
+			if (!this.isMessageIgnored(params.level, sessionId)) return this.notification({
+				method: "notifications/message",
+				params
+			});
+		}
+	}
+	async sendResourceUpdated(params) {
+		return this.notification({
+			method: "notifications/resources/updated",
+			params
+		});
+	}
+	async sendResourceListChanged() {
+		return this.notification({ method: "notifications/resources/list_changed" });
+	}
+	async sendToolListChanged() {
+		return this.notification({ method: "notifications/tools/list_changed" });
+	}
+	async sendPromptListChanged() {
+		return this.notification({ method: "notifications/prompts/list_changed" });
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.29.0_zod@4.4.3/node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
+/**
+* Server transport for stdio: this communicates with an MCP client by reading from the current process' stdin and writing to stdout.
+*
+* This transport is only available in Node.js environments.
+*/
+var StdioServerTransport = class {
+	constructor(_stdin = process$1.stdin, _stdout = process$1.stdout) {
+		this._stdin = _stdin;
+		this._stdout = _stdout;
+		this._readBuffer = new ReadBuffer();
+		this._started = false;
+		this._ondata = (chunk) => {
+			this._readBuffer.append(chunk);
+			this.processReadBuffer();
+		};
+		this._onerror = (error) => {
+			this.onerror?.(error);
+		};
+	}
+	/**
+	* Starts listening for messages on stdin.
+	*/
+	async start() {
+		if (this._started) throw new Error("StdioServerTransport already started! If using Server class, note that connect() calls start() automatically.");
+		this._started = true;
+		this._stdin.on("data", this._ondata);
+		this._stdin.on("error", this._onerror);
+	}
+	processReadBuffer() {
+		while (true) try {
+			const message = this._readBuffer.readMessage();
+			if (message === null) break;
+			this.onmessage?.(message);
+		} catch (error) {
+			this.onerror?.(error);
+		}
+	}
+	async close() {
+		this._stdin.off("data", this._ondata);
+		this._stdin.off("error", this._onerror);
+		if (this._stdin.listenerCount("data") === 0) this._stdin.pause();
+		this._readBuffer.clear();
+		this.onclose?.();
+	}
+	send(message) {
+		return new Promise((resolve) => {
+			const json = serializeMessage(message);
+			if (this._stdout.write(json)) resolve();
+			else this._stdout.once("drain", resolve);
+		});
+	}
+};
+//#endregion
+//#region src/mcp/bridge.ts
+/**
+* IPC client half of the bridge: a persistent UDS connection to the daemon's
+* control server. Requests are correlated by an incrementing id; an `ok:false`
+* response rejects with the daemon's error message.
+*/
+var IpcClient = class {
+	token;
+	socket;
+	nextId = 1;
+	pending = /* @__PURE__ */ new Map();
+	buf = "";
+	ready;
+	constructor(endpoint, token) {
+		this.token = token;
+		this.socket = net.connect(endpoint);
+		this.socket.setEncoding("utf8");
+		this.ready = new Promise((resolve, reject) => {
+			this.socket.once("connect", resolve);
+			this.socket.once("error", reject);
+		});
+		this.socket.on("data", (chunk) => {
+			this.buf += chunk;
+			const { messages, rest } = decodeFrames(this.buf);
+			this.buf = rest;
+			for (const res of messages) {
+				const p = this.pending.get(res.id);
+				if (!p) continue;
+				this.pending.delete(res.id);
+				if (res.ok) p.resolve(res.result);
+				else p.reject(new Error(res.error ?? "tool call failed"));
+			}
+		});
+		this.socket.on("close", () => {
+			for (const p of this.pending.values()) p.reject(/* @__PURE__ */ new Error("daemon connection closed"));
+			this.pending.clear();
+		});
+	}
+	async request(call) {
+		await this.ready;
+		const id = this.nextId++;
+		return new Promise((resolve, reject) => {
+			this.pending.set(id, {
+				resolve,
+				reject
+			});
+			this.socket.write(encodeFrame({
+				id,
+				token: this.token,
+				...call
+			}));
+		});
+	}
+};
+/**
+* Entry point for `agentconnect mcp-bridge`: a stdio MCP server that relays
+* `tools/list` and `tools/call` to the running daemon over its control socket.
+* The agent harness spawns this per session; the daemon does the real work.
+*/
+async function runBridge() {
+	const endpoint = process.env.AC_MCP_ENDPOINT;
+	const token = process.env.AC_MCP_TOKEN;
+	if (!endpoint || !token) {
+		process.stderr.write("mcp-bridge: AC_MCP_ENDPOINT and AC_MCP_TOKEN must be set\n");
+		process.exit(2);
+	}
+	const ipc = new IpcClient(endpoint, token);
+	let tools;
+	try {
+		tools = (await ipc.request({ op: "listTools" })).tools;
+	} catch (err) {
+		process.stderr.write(`mcp-bridge: could not reach daemon: ${err.message}\n`);
+		process.exit(1);
+	}
+	const server = new Server({
+		name: "agentconnect",
+		version: DAEMON_VERSION
+	}, { capabilities: { tools: {} } });
+	server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools }));
+	server.setRequestHandler(CallToolRequestSchema, async (req) => {
+		try {
+			const result = await ipc.request({
+				op: "callTool",
+				name: req.params.name,
+				args: req.params.arguments ?? {}
+			});
+			if (result && typeof result === "object" && Array.isArray(result.mcpContent)) return { content: result.mcpContent };
+			return { content: [{
+				type: "text",
+				text: typeof result === "string" ? result : JSON.stringify(result, null, 2)
+			}] };
+		} catch (err) {
+			return {
+				content: [{
+					type: "text",
+					text: err.message
+				}],
+				isError: true
+			};
+		}
+	});
+	await server.connect(new StdioServerTransport());
+}
+//#endregion
+export { runBridge };
+
+//# sourceMappingURL=bridge-DXIVgEzf.js.map