@zvada/agent-server 0.3.8 → 0.3.10

package/src/core/agents/codex-app-server/codex-app-server-agent.ts

@@ -1,3 +1,6 @@
+import { existsSync, realpathSync } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute, resolve } from "node:path";
 import type {
 	AgentCapabilities,
 	AgentInput,
@@ -5,20 +8,28 @@ import type {
 	PermissionToolCall,
 } from "../../../protocol/index.ts";
 import { AsyncQueue, codexReasoningEffort } from "../../../protocol/index.ts";
+import { SessionResumeError } from "../../utils/errors.ts";
 import type {
 	AgentExecuteOptions,
 	CancelResult,
 	PermissionRequestHandler,
 	RawAgentEvent,
 } from "../base.ts";
-import { BaseAgent } from "../base.ts";
 import { configFingerprint } from "../config-fingerprint.ts";
+import { snapshotMcpServers } from "../mcp-config.ts";
+import { SessionAgent } from "../session-agent.ts";
 import { SessionStore } from "../session-store.ts";
 import {
 	CodexAppServerClient,
 	type CodexAppServerClientOptions,
 	type CodexNotification,
 } from "./client.ts";
+import {
+	assertCodexMcpConfig,
+	assertCodexMcpReady,
+	codexMcpServers,
+	writeCodexMcpServers,
+} from "./mcp.ts";
 
 const CAPABILITIES: AgentCapabilities = {
 	multiTurn: true,
@@ -27,7 +38,7 @@ const CAPABILITIES: AgentCapabilities = {
 	modelSwitch: "in-session",
 	thinkingLevels: true,
 	images: true,
-	mcpServers: false,
+	mcpServers: true,
 	permissionRequests: true,
 };
 
@@ -41,6 +52,8 @@ export interface AppServerSession {
 	envFingerprint: string;
 	/** Native model connections retain the identity used at their first handshake. */
 	authFingerprint?: string;
+	/** Last native config write; readiness is checked separately before every prompt. */
+	mcpFingerprint?: string;
 	/** Credentials and permission broker belong only to the current execute. */
 	turn?: AppServerTurn;
 	idleTimer?: ReturnType<typeof setTimeout>;
@@ -213,10 +226,13 @@ export function appServerNotificationEndsTurn(notification: CodexNotification):
  * thread is created per logical session and reused for multi-turn; model/effort
  * are passed per `turn/start`. Resume uses `thread/resume` with the native id.
  */
-export class CodexAppServerAgent extends BaseAgent {
+export class CodexAppServerAgent extends SessionAgent {
 	readonly harness = "codex-app-server" as const;
 	readonly capabilities = CAPABILITIES;
 	private readonly sessions = new SessionStore<AppServerSession>();
+	private readonly invalidatedClients = new WeakSet<CodexAppServerClient>();
+	/** Home ownership outlives idle process eviction and failed preparation. */
+	private readonly mcpHomes = new Map<string, string>();
 	/** A cancel acknowledgement belongs to one invocation, even after it drains. */
 	private readonly turnInterruptState = new WeakMap<
 		AbortController,
@@ -230,6 +246,7 @@ export class CodexAppServerAgent extends BaseAgent {
 	private async resolveSession(
 		options: AgentExecuteOptions,
 		turn: AppServerTurn,
+		mcpServers: Record<string, unknown> | undefined,
 	): Promise<AppServerSession> {
 		const { signal } = turn;
 		signal.throwIfAborted();
@@ -240,9 +257,13 @@ export class CodexAppServerAgent extends BaseAgent {
 		// Codex caches an authenticated model WebSocket across turns. Login alone
 		// cannot switch its identity: restart on account/key changes and resume
 		// the same thread. Same-account token renewal can keep the process warm.
-		let resumeThreadId = options.resumeSessionId;
+		const resumeThreadId = options.resumeSessionId;
 		if (existing && !existing.client.closed) {
-			if (appServerSessionCompatible(existing, options) && existing.authFingerprint === identity) {
+			if (
+				appServerSessionCompatible(existing, options) &&
+				existing.authFingerprint === identity &&
+				!this.invalidatedClients.has(existing.client)
+			) {
 				this.sessions.clearIdle(existing);
 				existing.turn = turn;
 				const onAbort = () => existing.client.close();
@@ -258,15 +279,7 @@ export class CodexAppServerAgent extends BaseAgent {
 					signal.removeEventListener("abort", onAbort);
 				}
 			}
-			// Preserve context within the same cwd/env boundary (mirrors the
-			// claude-code restart policy); an explicit resumeSessionId always wins.
-			if (
-				resumeThreadId === undefined &&
-				existing.cwd === options.cwd &&
-				existing.envFingerprint === configFingerprint(options.env)
-			) {
-				resumeThreadId = existing.threadId;
-			}
+
 			this.sessions.close(options.sessionId);
 		}
 
@@ -301,6 +314,8 @@ export class CodexAppServerAgent extends BaseAgent {
 			signal.throwIfAborted();
 			await client.initialize();
 			await this.authenticate(session);
+			// Clear stale per-turn credentials before thread startup can use them.
+			await this.configureMcp(session, mcpServers);
 
 			const startParams: Record<string, unknown> = {
 				cwd: options.cwd,
@@ -313,24 +328,28 @@ export class CodexAppServerAgent extends BaseAgent {
 			if (options.systemPromptAppend)
 				startParams.developerInstructions = options.systemPromptAppend;
 
-			// A dead/unknown resume target falls back to a fresh thread. Auth was
-			// established above, outside this fallback, so a login failure cannot
-			// silently start a different conversation or use ambient credentials.
-			let threadId: string | undefined;
-			if (resumeThreadId) {
-				threadId = await client
-					.request("thread/resume", { threadId: resumeThreadId, ...startParams })
-					.then((r) => (r as { thread?: { id?: string } })?.thread?.id ?? resumeThreadId)
-					.catch(() => undefined);
-			}
-			signal.throwIfAborted();
-			if (!threadId) {
-				const result = (await client.request("thread/start", startParams)) as {
-					thread?: { id?: string };
-				};
-				threadId = result?.thread?.id;
-				if (!threadId) throw new Error("codex app-server thread/start returned no thread id");
+			const method = resumeThreadId ? "thread/resume" : "thread/start";
+			const result = (await client
+				.request(
+					method,
+					resumeThreadId ? { threadId: resumeThreadId, ...startParams } : startParams,
+				)
+				.catch((cause: unknown) => {
+					if (!resumeThreadId) throw cause;
+					throw new SessionResumeError(
+						resumeThreadId,
+						cause instanceof Error ? cause.message : String(cause),
+						{ cause },
+					);
+				})) as { thread?: { id?: string } };
+			const threadId = result?.thread?.id;
+			if (resumeThreadId && threadId !== resumeThreadId) {
+				throw new SessionResumeError(
+					resumeThreadId,
+					`Codex returned ${threadId ? `a different thread: ${threadId}` : "no thread id"}`,
+				);
 			}
+			if (!threadId) throw new Error("codex app-server thread/start returned no thread id");
 			signal.throwIfAborted();
 			session.threadId = threadId;
 			this.sessions.set(options.sessionId, session);
@@ -346,6 +365,45 @@ export class CodexAppServerAgent extends BaseAgent {
 		}
 	}
 
+	private managedMcpHome(options: AgentExecuteOptions, hasServers: boolean): boolean {
+		const home = options.env?.CODEX_HOME;
+		if (!home) {
+			if (hasServers)
+				throw new Error("Codex per-turn MCP requires a session-specific env.CODEX_HOME");
+			return false;
+		}
+		if (!isAbsolute(home)) throw new Error("Codex session CODEX_HOME must be an absolute path");
+		const shared = resolve(process.env.CODEX_HOME ?? `${homedir()}/.codex`);
+		if (resolve(home) === shared) {
+			throw new Error("Codex per-turn MCP cannot use the shared user CODEX_HOME");
+		}
+		const path = realpathSync(home);
+		if (existsSync(shared) && path === realpathSync(shared)) {
+			throw new Error("Codex per-turn MCP cannot use the shared user CODEX_HOME");
+		}
+		const owner = this.mcpHomes.get(path);
+		if (owner && owner !== options.sessionId) {
+			throw new Error("Codex CODEX_HOME is already owned by another session");
+		}
+		this.mcpHomes.set(path, options.sessionId);
+		return true;
+	}
+
+	private async configureMcp(
+		session: AppServerSession,
+		servers: Record<string, unknown> | undefined,
+	): Promise<void> {
+		if (servers === undefined) return;
+		const fingerprint = configFingerprint(servers);
+		const changed = session.mcpFingerprint !== fingerprint;
+		// A rejected write or changed project layer invalidates the cached identity.
+		session.mcpFingerprint = undefined;
+		if (changed) await writeCodexMcpServers(session.client, servers);
+		await assertCodexMcpConfig(session.client, session.cwd, servers);
+		if (changed) await session.client.request("config/mcpServer/reload", undefined);
+		session.mcpFingerprint = fingerprint;
+	}
+
 	private async authenticate(session: AppServerSession): Promise<void> {
 		session.turn?.signal.throwIfAborted();
 		const auth = session.turn?.auth;
@@ -430,11 +488,11 @@ export class CodexAppServerAgent extends BaseAgent {
 		});
 	}
 
-	async *execute(
+	protected override async *executeTurn(
 		input: AgentInput,
 		options: AgentExecuteOptions,
+		controller: AbortController,
 	): AsyncIterableIterator<RawAgentEvent> {
-		const controller = this.trackTurn(options.sessionId, options.signal);
 		const turn: AppServerTurn = {
 			permissionHandler: options.onPermissionRequest,
 			signal: controller.signal,
@@ -455,16 +513,36 @@ export class CodexAppServerAgent extends BaseAgent {
 		let turnEnded = false;
 		try {
 			controller.signal.throwIfAborted();
+			const requestedMcp = codexMcpServers(snapshotMcpServers(options.mcpServers));
+			const mcpServers = this.managedMcpHome(options, Object.keys(requestedMcp).length > 0)
+				? requestedMcp
+				: undefined;
 			if (this.agentOptions.resolveAuth) {
 				turn.auth = await this.agentOptions.resolveAuth(options.sessionId);
 			}
 			controller.signal.throwIfAborted();
-			session = await this.resolveSession(options, turn);
+			session = await this.resolveSession(options, turn, mcpServers);
 			options.onNativeSession?.(session.threadId, {
 				resumed: session.threadId === options.resumeSessionId,
 			});
 			const threadId = session.threadId;
 			const client = session.client;
+			const abortPreparation = () => client.close();
+			controller.signal.addEventListener("abort", abortPreparation, { once: true });
+			try {
+				controller.signal.throwIfAborted();
+				await this.configureMcp(session, mcpServers);
+				try {
+					await assertCodexMcpReady(client, threadId, Object.keys(mcpServers ?? {}));
+				} catch (error) {
+					// A later explicit turn must reload failed clients even if config is unchanged.
+					session.mcpFingerprint = undefined;
+					throw error;
+				}
+				controller.signal.throwIfAborted();
+			} finally {
+				controller.signal.removeEventListener("abort", abortPreparation);
+			}
 
 			let turnId: string | undefined;
 			const forceCancel = () => {
@@ -544,6 +622,10 @@ export class CodexAppServerAgent extends BaseAgent {
 			if (options.thinkingLevel) turnParams.effort = codexReasoningEffort(options.thinkingLevel);
 
 			if (controller.signal.aborted) throw new Error("turn aborted");
+			if (this.invalidatedClients.has(client)) {
+				client.close();
+				throw new Error("Codex process was invalidated before turn admission");
+			}
 			client.request("turn/start", turnParams).catch((err: unknown) => {
 				if (controller.signal.aborted) {
 					forceCancel();
@@ -563,7 +645,6 @@ export class CodexAppServerAgent extends BaseAgent {
 			clearStall();
 			if (cancelTimer) clearTimeout(cancelTimer);
 			for (const off of unsubscribe) off();
-			this.endTurn(options.sessionId, controller);
 			if (session?.turn === turn) {
 				session.turn = undefined;
 				if (!session.client.closed) {
@@ -593,13 +674,33 @@ export class CodexAppServerAgent extends BaseAgent {
 		return { confirmed, hadTurn: true };
 	}
 
+	/** Unchanged MCP config reloads retain dead remote connections after VM resume. */
+	invalidateMcpConnections(): void {
+		// Keep SessionAgent's conversation targets and runtime admission receipts.
+		// Transport recovery can signal this while a turn is running: let that
+		// turn finish, then use the existing strict thread/resume path.
+		const active = new Set(
+			[...this.sessions.values()]
+				.filter((session) => session.turn)
+				.map((session) => session.client),
+		);
+		for (const client of this.sessions.clients()) {
+			this.invalidatedClients.add(client);
+			if (!active.has(client)) client.close();
+		}
+	}
+
 	override async release(sessionId: string): Promise<void> {
 		await super.release(sessionId);
 		this.sessions.close(sessionId);
+		for (const [home, owner] of this.mcpHomes) {
+			if (owner === sessionId) this.mcpHomes.delete(home);
+		}
 	}
 
 	override async terminateAll(): Promise<void> {
 		await super.terminateAll();
 		this.sessions.closeAll();
+		this.mcpHomes.clear();
 	}
 }

package/src/core/agents/codex-app-server/mcp.ts

@@ -0,0 +1,139 @@
+import { AsyncQueue, type McpServerConfig } from "../../../protocol/index.ts";
+import { configFingerprint } from "../config-fingerprint.ts";
+import { assertMcpConnected, mcpConnectionErrors } from "../mcp-config.ts";
+import type { CodexAppServerClient } from "./client.ts";
+
+/** Codex supports stdio and Streamable HTTP, not the legacy SSE transport. */
+export function codexMcpServers(servers: Record<string, McpServerConfig>): Record<string, unknown> {
+	return Object.fromEntries(
+		Object.entries(servers).map(([name, server]) => {
+			if (name === "codex_apps") throw new Error("MCP server name codex_apps is reserved by Codex");
+			if (server.type === "sse") {
+				throw new Error(`Codex MCP server ${name}: legacy SSE is unsupported; use Streamable HTTP`);
+			}
+			return [
+				name,
+				server.type === "stdio"
+					? {
+							command: server.command,
+							...(server.args && { args: server.args }),
+							...(server.env && { env: server.env }),
+						}
+					: { url: server.url, ...(server.headers && { http_headers: server.headers }) },
+			];
+		}),
+	);
+}
+
+/** Only call against an explicitly isolated, engine-managed CODEX_HOME. */
+export async function writeCodexMcpServers(
+	client: CodexAppServerClient,
+	servers: Record<string, unknown>,
+): Promise<void> {
+	const result = (await client.request("config/batchWrite", {
+		edits: [{ keyPath: "mcp_servers", value: servers, mergeStrategy: "replace" }],
+		// Check project-layer overrides before any connection can use credentials.
+		reloadUserConfig: false,
+	})) as { status?: string; overriddenMetadata?: unknown };
+	if (result.status !== "ok" || result.overriddenMetadata) {
+		throw new Error(
+			"Codex MCP configuration was not applied; check higher-priority native settings",
+		);
+	}
+}
+
+function normalizedConfig(value: unknown): unknown {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+	const config = { ...(value as Record<string, unknown>) };
+	// Defaults materialized by config/read; preserve every non-default field.
+	if (config.environment_id === "local") config.environment_id = undefined;
+	if (config.enabled === true) config.enabled = undefined;
+	if (config.tool_timeout_sec === null) config.tool_timeout_sec = undefined;
+	if (typeof config.command === "string") {
+		config.args ??= [];
+		config.env ??= {};
+	} else if (typeof config.url === "string") {
+		config.http_headers ??= {};
+	}
+	return config;
+}
+
+/** User-layer write acknowledgements do not account for repository overrides. */
+export async function assertCodexMcpConfig(
+	client: CodexAppServerClient,
+	cwd: string,
+	servers: Record<string, unknown>,
+): Promise<void> {
+	if (!Object.keys(servers).length) return;
+	const result = (await client.request("config/read", { cwd })) as {
+		config?: { mcp_servers?: Record<string, unknown> };
+	};
+	for (const [name, server] of Object.entries(servers)) {
+		if (
+			configFingerprint(normalizedConfig(result.config?.mcp_servers?.[name])) !==
+			configFingerprint(normalizedConfig(server))
+		) {
+			throw new Error(`Codex MCP server ${name} is overridden by native settings`);
+		}
+	}
+}
+
+export async function assertCodexMcpReady(
+	client: CodexAppServerClient,
+	threadId: string,
+	required: string[],
+): Promise<void> {
+	if (!required.length) return;
+	// A status snapshot can arrive while startup is still in progress. Subscribe
+	// first so completion during the request cannot be lost. Native notifications
+	// trigger another authoritative read; no setup, model or tool is retried.
+	const updates = new AsyncQueue<void>();
+	const offStatus = client.onNotification(({ method, params }) => {
+		if (
+			method === "mcpServer/startupStatus/updated" &&
+			params.threadId === threadId &&
+			required.includes(String(params.name))
+		)
+			updates.push(undefined);
+	});
+	const offClose = client.onClose(() => updates.fail(new Error("Codex closed during MCP startup")));
+	const deadline = Date.now() + 30_000;
+	const timer = setTimeout(() => updates.fail(new Error("Codex MCP startup timed out")), 30_000);
+	try {
+		for (;;) {
+			const statuses: Array<{ name: string; status: string | null }> = [];
+			let cursor: string | null | undefined;
+			do {
+				const page = (await client.request(
+					"mcpServerStatus/list",
+					{ threadId, detail: "toolsAndAuthOnly", limit: 100, ...(cursor && { cursor }) },
+					Math.max(1, deadline - Date.now()),
+				)) as {
+					data?: Array<{ name: string; runtimeStatus: string | null }>;
+					nextCursor?: string | null;
+				};
+				if (!Array.isArray(page.data)) throw new Error("Codex returned no MCP readiness status");
+				statuses.push(
+					...page.data.map(({ name, runtimeStatus }) => ({ name, status: runtimeStatus })),
+				);
+				cursor = page.nextCursor;
+			} while (cursor);
+			const starting = required.filter(
+				(name) => statuses.find((entry) => entry.name === name)?.status === "starting",
+			);
+			assertMcpConnected(
+				mcpConnectionErrors(
+					required.filter((name) => !starting.includes(name)),
+					statuses,
+				),
+			);
+			if (!starting.length) return;
+			await updates.next();
+		}
+	} finally {
+		clearTimeout(timer);
+		offStatus();
+		offClose();
+		updates.end();
+	}
+}

package/src/core/agents/codex-sdk/codex-sdk-agent.ts

@@ -1,9 +1,10 @@
 import type { Codex, Thread, ThreadEvent, ThreadOptions } from "@openai/codex-sdk";
 import type { AgentCapabilities, AgentInput, PermissionMode } from "../../../protocol/index.ts";
-import { codexReasoningEffort, isCancellation } from "../../../protocol/index.ts";
+import { codexReasoningEffort } from "../../../protocol/index.ts";
+import { SessionResumeError } from "../../utils/errors.ts";
 import type { AgentExecuteOptions, RawAgentEvent } from "../base.ts";
-import { BaseAgent } from "../base.ts";
 import { configFingerprint } from "../config-fingerprint.ts";
+import { SessionAgent } from "../session-agent.ts";
 
 const CAPABILITIES: AgentCapabilities = {
 	multiTurn: true,
@@ -132,7 +133,7 @@ export interface CodexSdkAgentOptions {
  * `resumeThread(nativeId)`. Streams at item granularity — the adapter derives
  * text deltas by diffing successive item snapshots.
  */
-export class CodexSdkAgent extends BaseAgent {
+export class CodexSdkAgent extends SessionAgent {
 	readonly harness = "codex-sdk" as const;
 	readonly capabilities = CAPABILITIES;
 	private readonly threads = new Map<string, LiveThread>();
@@ -184,13 +185,7 @@ export class CodexSdkAgent extends BaseAgent {
 		const codex = await this.getCodex(options, codexPathOverride);
 		if (signal?.aborted) throw new Error("turn aborted");
 		const fingerprint = credentialsFingerprint(options);
-		// Preserve context within the same cwd/credential boundary (mirrors the
-		// claude-code restart policy); an explicit resumeSessionId always wins.
-		const resumeThreadId =
-			options.resumeSessionId ??
-			(existing && existing.cwd === options.cwd && existing.credentialsFingerprint === fingerprint
-				? existing.thread.id
-				: undefined);
+		const resumeThreadId = options.resumeSessionId;
 		const thread = resumeThreadId
 			? codex.resumeThread(resumeThreadId, threadOptions(options))
 			: codex.startThread(threadOptions(options));
@@ -209,59 +204,38 @@ export class CodexSdkAgent extends BaseAgent {
 		return live;
 	}
 
-	async *execute(
+	protected override async *executeTurn(
 		input: AgentInput,
 		options: AgentExecuteOptions,
+		controller: AbortController,
 	): AsyncIterableIterator<RawAgentEvent> {
-		const controller = this.trackTurn(options.sessionId, options.signal);
-		try {
-			for (let attempt = 0; attempt < 2; attempt++) {
-				if (controller.signal.aborted) throw new Error("turn aborted");
-				const attemptOptions = attempt === 0 ? options : { ...options, resumeSessionId: undefined };
-				const live = await this.resolveThread(attemptOptions, controller.signal);
-				if (controller.signal.aborted) throw new Error("turn aborted");
-				const resumeThreadId = live.thread.id;
-				let sawOutput = false;
-				let reported = false;
-				const reportSession = (id: string | null) => {
-					if (!reported && id) {
-						reported = true;
-						options.onNativeSession?.(id, { resumed: id === options.resumeSessionId });
-					}
-				};
-				try {
-					const { events } = await live.thread.runStreamed(toCodexInput(input), {
-						signal: controller.signal,
-					});
-					for await (const event of events as AsyncGenerator<ThreadEvent>) {
-						sawOutput = true;
-						reportSession(event.type === "thread.started" ? event.thread_id : live.thread.id);
-						yield event as RawAgentEvent;
-					}
-					reportSession(live.thread.id);
-					return;
-				} catch (error) {
-					// Only a proven missing rollout is safe to retry without its history.
-					// Temporary failures and cancellation must retain a valid native id.
-					const missingId =
-						error instanceof Error
-							? /no rollout found for thread id ([^\s]+)/.exec(error.message)?.[1]
-							: undefined;
-					if (
-						attempt !== 0 ||
-						!resumeThreadId ||
-						missingId !== resumeThreadId ||
-						sawOutput ||
-						controller.signal.aborted ||
-						isCancellation(error)
-					) {
-						throw error;
-					}
+		controller.signal.throwIfAborted();
+		const live = await this.resolveThread(options, controller.signal);
+		controller.signal.throwIfAborted();
+		let reported = false;
+		const { events } = await live.thread.runStreamed(toCodexInput(input), {
+			signal: controller.signal,
+		});
+		for await (const event of events as AsyncGenerator<ThreadEvent>) {
+			if (event.type === "thread.started") {
+				if (options.resumeSessionId && event.thread_id !== options.resumeSessionId) {
+					// The SDK mutates Thread.id before yielding this event. Discard
+					// that wrapper; the retained resume target remains unchanged.
 					if (this.threads.get(options.sessionId) === live) this.threads.delete(options.sessionId);
+					controller.abort();
+					throw new SessionResumeError(
+						options.resumeSessionId,
+						`Codex returned a different thread: ${event.thread_id}`,
+					);
+				}
+				if (!reported) {
+					reported = true;
+					options.onNativeSession?.(event.thread_id, {
+						resumed: Boolean(options.resumeSessionId),
+					});
 				}
 			}
-		} finally {
-			this.endTurn(options.sessionId, controller);
+			yield event as RawAgentEvent;
 		}
 	}
 

package/src/core/agents/mcp-config.ts

@@ -0,0 +1,31 @@
+import type { McpServerConfig } from "../../protocol/index.ts";
+
+/** A turn owns its wire configuration even when the caller reuses its objects. */
+export function snapshotMcpServers(
+	servers: Record<string, McpServerConfig> | undefined,
+): Record<string, McpServerConfig> {
+	return structuredClone(servers ?? {});
+}
+
+export function mcpConnectionErrors(
+	required: string[],
+	statuses: Array<{ name: string; status: string | null; error?: string }>,
+): Record<string, string> {
+	return Object.fromEntries(
+		required.flatMap((name) => {
+			const status = statuses.find((entry) => entry.name === name);
+			return status?.status === "connected"
+				? []
+				: [[name, status?.error ?? `server is ${status?.status ?? "missing"}`]];
+		}),
+	);
+}
+
+export function assertMcpConnected(errors: Record<string, string>): void {
+	const failed = Object.entries(errors);
+	if (failed.length) {
+		throw new Error(
+			`mcp servers failed to connect: ${failed.map(([name, error]) => `${name} (${error})`).join(", ")}`,
+		);
+	}
+}