@agentconnect.md/daemon 1.0.0-rc.220 → 1.0.0-rc.222

package/dist/{bridge-DoUrmBw9.js → stdio-CwrB9yrX.js}

@@ -1,9 +1,37 @@
 import { o as __toESM, t as __commonJSMin } from "./rolldown-runtime-CE-6LUnI.js";
-import { t as DAEMON_VERSION } from "./version-DGaRXjBK.js";
-import { _ as union, a as custom, b as datetime, c as intersection, d as number, f as object, g as string, h as record, i as boolean, l as literal, m as preprocess, n as _null, o as discriminatedUnion, p as optional, r as array, t as _enum, u as looseObject, v as unknown, x as safeParse$1 } from "./schemas-DujcoO0q.js";
-import { n as encodeFrame, t as decodeFrames } from "./ipc-2Xbxe7uu.js";
-import process$1 from "node:process";
-import net from "node:net";
+import { S as datetime, _ as record, a as array, b as unknown, c as discriminatedUnion, d as literal, f as looseObject, g as preprocess, h as optional, m as object, n as _enum, o as boolean, p as number, r as _null, s as custom, u as intersection, v as string, w as safeParse$1, y as union } from "./schemas-CQkO9hC5.js";
+//#region src/mcp/ipc.ts
+/** Frame a message for the wire: compact JSON + a single trailing newline. */
+function encodeFrame(msg) {
+	return JSON.stringify(msg) + "\n";
+}
+/**
+* Split a buffer of newline-delimited frames into parsed objects plus the
+* trailing partial line. Callers keep `rest` and prepend it to the next chunk.
+*
+* Per-line tolerant: a malformed (non-JSON) line is skipped, not thrown — so one
+* bad frame can't crash a stream reader or discard the good frames batched
+* alongside it in the same chunk. `onError` lets callers log dropped lines.
+*/
+function decodeFrames(buf, onError) {
+	const parts = buf.split("\n");
+	const rest = parts.pop() ?? "";
+	const messages = [];
+	for (const line of parts) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		try {
+			messages.push(JSON.parse(trimmed));
+		} catch (err) {
+			onError?.(trimmed, err);
+		}
+	}
+	return {
+		messages,
+		rest
+	};
+}
+//#endregion
 //#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.29.0_zod@4.4.3/node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-compat.js
 function isZ4Schema(s) {
 	return !!s._zod;
@@ -528,6 +556,7 @@ const InitializedNotificationSchema = NotificationSchema.extend({
 	method: literal("notifications/initialized"),
 	params: NotificationsParamsSchema.optional()
 });
+const isInitializedNotification = (value) => InitializedNotificationSchema.safeParse(value).success;
 /**
 * A ping, issued by either the server or the client, to check that the other party is still alive. The receiver must promptly respond, or else may be disconnected.
 */
@@ -1256,7 +1285,11 @@ const ToolListChangedNotificationSchema = NotificationSchema.extend({
 	method: literal("notifications/tools/list_changed"),
 	params: NotificationsParamsSchema.optional()
 });
-object({
+/**
+* Base schema for list changed subscription options (without callback).
+* Used internally for Zod validation of autoRefresh and debounceMs.
+*/
+const ListChangedOptionsBaseSchema = object({
 	/**
 	* If true, the list will be refreshed automatically when a list changed notification is received.
 	* The callback will be called with the updated list.
@@ -9102,226 +9135,6 @@ var AjvJsonSchemaValidator = class {
 	}
 };
 //#endregion
-//#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/experimental/tasks/helpers.js
 /**
 * Experimental task capability assertion helpers.
@@ -9373,347 +9186,6 @@ function assertClientRequestTaskCapability(requests, method, entityName) {
 	}
 }
 //#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/shared/stdio.js
 /**
 * Buffers a continuous stdio stream into discrete JSON-RPC messages.
@@ -9741,164 +9213,6 @@ function serializeMessage(message) {
 	return JSON.stringify(message) + "\n";
 }
 //#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 };
+export { ListToolsRequestSchema as A, isInitializedNotification as B, JSONRPCMessageSchema as C, ListResourceTemplatesResultSchema as D, ListPromptsResultSchema as E, ReadResourceResultSchema as F, safeParse as G, isJSONRPCResultResponse as H, ResourceListChangedNotificationSchema as I, decodeFrames as K, SUPPORTED_PROTOCOL_VERSIONS as L, LoggingLevelSchema as M, McpError as N, ListResourcesResultSchema as O, PromptListChangedNotificationSchema as P, SetLevelRequestSchema as R, InitializedNotificationSchema as S, ListChangedOptionsBaseSchema as T, getObjectShape as U, isJSONRPCRequest as V, isZ4Schema as W, EmptyResultSchema as _, AjvJsonSchemaValidator as a, InitializeRequestSchema as b, CallToolRequestSchema as c, CreateMessageRequestSchema as d, CreateMessageResultSchema as f, ElicitResultSchema as g, ElicitRequestSchema as h, assertToolsCallTaskCapability as i, ListToolsResultSchema as j, ListRootsResultSchema as k, CallToolResultSchema as l, CreateTaskResultSchema as m, serializeMessage as n, Protocol as o, CreateMessageResultWithToolsSchema as p, encodeFrame as q, assertClientRequestTaskCapability as r, mergeCapabilities as s, ReadBuffer as t, CompleteResultSchema as u, ErrorCode as v, LATEST_PROTOCOL_VERSION as w, InitializeResultSchema as x, GetPromptResultSchema as y, ToolListChangedNotificationSchema as z };
 
-//# sourceMappingURL=bridge-DoUrmBw9.js.map
+//# sourceMappingURL=stdio-CwrB9yrX.js.map