claude-code-rust 0.14.1 → 0.14.2

package/agent-sdk/dist/bridge/mcp.js

@@ -1,8 +1,9 @@
 import { emitMcpOperationError, slashError, writeEvent } from "./events.js";
 import { bridgeLogger, LOG_TARGETS } from "./logger.js";
 import { bridgeMcpServersToSdk, mapMcpServerStatus, summarizeMcpServersForDiagnostics, } from "./mcp_metadata.js";
+import { authenticateMcpServer, clearMcpServerAuth, detectMcpAuthCapabilities, submitMcpOAuthCallbackUrl, } from "./mcp_auth_adapter.js";
+import { runMcpAuthMonitor, } from "./mcp_monitor.js";
 export const MCP_STALE_STATUS_REVALIDATION_COOLDOWN_MS = 30_000;
-const knownConnectedMcpServers = new Set();
 function logMcpSuccess(eventName, message, sessionId, requestId, fields) {
     bridgeLogger.info({
         target: LOG_TARGETS.BRIDGE_MCP,
@@ -28,9 +29,6 @@ function logMcpFailure(eventName, message, sessionId, errorMessage, requestId, f
         },
     });
 }
-function queryWithMcpAuth(session) {
-    return session.query;
-}
 function mapMcpSetServersResult(result) {
     if (!result || typeof result !== "object" || Array.isArray(result)) {
         return { added: [], removed: [], errors: {} };
@@ -47,41 +45,6 @@ function mapMcpSetServersResult(result) {
         : {};
     return { added, removed, errors };
 }
-async function callMcpAuthMethod(session, methodName, args) {
-    const query = queryWithMcpAuth(session);
-    switch (methodName) {
-        case "mcpAuthenticate":
-            if (typeof query.mcpAuthenticate !== "function") {
-                throw new Error("installed SDK does not support mcpAuthenticate");
-            }
-            return await query.mcpAuthenticate(args[0] ?? "");
-        case "mcpClearAuth":
-            if (typeof query.mcpClearAuth !== "function") {
-                throw new Error("installed SDK does not support mcpClearAuth");
-            }
-            return await query.mcpClearAuth(args[0] ?? "");
-        case "mcpSubmitOAuthCallbackUrl":
-            if (typeof query.mcpSubmitOAuthCallbackUrl !== "function") {
-                throw new Error("installed SDK does not support mcpSubmitOAuthCallbackUrl");
-            }
-            return await query.mcpSubmitOAuthCallbackUrl(args[0] ?? "", args[1] ?? "");
-    }
-}
-function extractMcpAuthRedirect(serverName, value) {
-    if (!value || typeof value !== "object") {
-        return null;
-    }
-    const authUrl = Reflect.get(value, "authUrl");
-    if (typeof authUrl !== "string" || authUrl.trim().length === 0) {
-        return null;
-    }
-    const requiresUserAction = Reflect.get(value, "requiresUserAction");
-    return {
-        server_name: serverName,
-        auth_url: authUrl,
-        requires_user_action: requiresUserAction === true,
-    };
-}
 function emitMcpCommandError(sessionId, operation, message, requestId, serverName) {
     emitMcpOperationError(sessionId, {
         ...(serverName ? { server_name: serverName } : {}),
@@ -90,9 +53,10 @@ function emitMcpCommandError(sessionId, operation, message, requestId, serverNam
     }, requestId);
 }
 export async function emitMcpSnapshotEvent(session, requestId, source = "mcp_status") {
-    const servers = await session.query.mcpServerStatus();
-    let mapped = servers.map(mapMcpServerStatus);
-    mapped = await reconcileSuspiciousMcpStatuses(session, mapped);
+    const mapped = await loadReconciledMcpStatuses(session);
+    if (!mapped) {
+        return [];
+    }
     return emitMcpSnapshotFromMappedStatuses(session, mapped, source, requestId);
 }
 export function emitMcpSnapshotFromStatuses(session, servers, source, requestId) {
@@ -104,7 +68,7 @@ export async function emitReconciledMcpSnapshotFromStatuses(session, servers, so
     return emitMcpSnapshotFromMappedStatuses(session, mapped, source, requestId);
 }
 function emitMcpSnapshotFromMappedStatuses(session, mapped, source, requestId) {
-    rememberKnownConnectedMcpServers(mapped);
+    rememberKnownConnectedMcpServers(session, mapped);
     logMcpSuccess("mcp_snapshot_emitted", "MCP snapshot emitted", session.sessionId, requestId, {
         source,
         server_count: mapped.length,
@@ -115,6 +79,7 @@ function emitMcpSnapshotFromMappedStatuses(session, mapped, source, requestId) {
         session_id: session.sessionId,
         source,
         servers: mapped,
+        auth_capabilities: detectMcpAuthCapabilities(session.query),
     }, requestId);
     return mapped;
 }
@@ -132,23 +97,33 @@ export function staleMcpAuthCandidates(servers, knownConnectedServerNames, lastR
     })
         .map((server) => server.name);
 }
-function rememberKnownConnectedMcpServers(servers) {
+function rememberKnownConnectedMcpServers(session, servers) {
     for (const server of servers) {
         if (server.status === "connected") {
-            knownConnectedMcpServers.add(server.name);
+            session.knownConnectedMcpServers.add(server.name);
         }
     }
 }
-function forgetKnownConnectedMcpServer(serverName) {
-    knownConnectedMcpServers.delete(serverName);
+function forgetKnownConnectedMcpServer(session, serverName) {
+    session.knownConnectedMcpServers.delete(serverName);
 }
-async function reconcileSuspiciousMcpStatuses(session, servers) {
-    const candidates = staleMcpAuthCandidates(servers, knownConnectedMcpServers, session.mcpStatusRevalidatedAt);
+async function loadReconciledMcpStatuses(session, isActive = () => true) {
+    const servers = await session.query.mcpServerStatus();
+    if (!isActive()) {
+        return undefined;
+    }
+    return await reconcileSuspiciousMcpStatuses(session, servers.map(mapMcpServerStatus), isActive);
+}
+async function reconcileSuspiciousMcpStatuses(session, servers, isActive = () => true) {
+    const candidates = staleMcpAuthCandidates(servers, session.knownConnectedMcpServers, session.mcpStatusRevalidatedAt);
     if (candidates.length === 0) {
         return servers;
     }
     const now = Date.now();
     for (const serverName of candidates) {
+        if (!isActive()) {
+            return undefined;
+        }
         session.mcpStatusRevalidatedAt.set(serverName, now);
         bridgeLogger.info({
             target: LOG_TARGETS.BRIDGE_MCP,
@@ -165,8 +140,14 @@ async function reconcileSuspiciousMcpStatuses(session, servers) {
         });
         try {
             await session.query.reconnectMcpServer(serverName);
+            if (!isActive()) {
+                return undefined;
+            }
         }
         catch (error) {
+            if (!isActive()) {
+                return undefined;
+            }
             const message = error instanceof Error ? error.message : String(error);
             bridgeLogger.warn({
                 target: LOG_TARGETS.BRIDGE_MCP,
@@ -182,35 +163,67 @@ async function reconcileSuspiciousMcpStatuses(session, servers) {
             });
         }
     }
-    return (await session.query.mcpServerStatus()).map(mapMcpServerStatus);
+    const refreshed = await session.query.mcpServerStatus();
+    return isActive() ? refreshed.map(mapMcpServerStatus) : undefined;
 }
 function shouldKeepMonitoringMcpAuth(server) {
     return server?.status === "needs-auth" || server?.status === "pending";
 }
-function scheduleMcpAuthSnapshotMonitor(session, serverName, attempt = 0) {
-    const maxAttempts = 180;
-    const delayMs = 1000;
-    setTimeout(() => {
-        void monitorMcpAuthSnapshot(session, serverName, attempt + 1, maxAttempts, delayMs);
-    }, delayMs);
+function logMcpAuthMonitorExhausted(session, serverName, result) {
+    bridgeLogger.warn({
+        target: LOG_TARGETS.BRIDGE_MCP,
+        eventName: "mcp_auth_monitor_exhausted",
+        message: "MCP authentication status monitor exhausted",
+        outcome: "failure",
+        sessionId: session.sessionId,
+        count: result.attempts,
+        fields: {
+            server_name: serverName,
+            attempts: result.attempts,
+            reason: result.reason,
+            ...(result.lastError ? { error_message: result.lastError } : {}),
+        },
+    });
 }
-async function monitorMcpAuthSnapshot(session, serverName, attempt, maxAttempts, delayMs) {
-    try {
-        const servers = await emitMcpSnapshotEvent(session);
-        const server = servers.find((candidate) => candidate.name === serverName);
-        if (attempt < maxAttempts && shouldKeepMonitoringMcpAuth(server)) {
-            setTimeout(() => {
-                void monitorMcpAuthSnapshot(session, serverName, attempt + 1, maxAttempts, delayMs);
-            }, delayMs);
-        }
+export function startMcpAuthSnapshotMonitor(session, serverName, timing = {}) {
+    if (session.closing) {
+        return Promise.resolve({ outcome: "cancelled", attempts: 0 });
     }
-    catch {
-        if (attempt < maxAttempts) {
-            setTimeout(() => {
-                void monitorMcpAuthSnapshot(session, serverName, attempt + 1, maxAttempts, delayMs);
-            }, delayMs);
-        }
+    const existing = session.mcpAuthMonitors.get(serverName);
+    if (existing) {
+        return existing.task;
     }
+    const controller = new AbortController();
+    let monitor;
+    const isActive = () => !session.closing &&
+        !controller.signal.aborted &&
+        session.mcpAuthMonitors.get(serverName) === monitor;
+    const task = runMcpAuthMonitor({
+        ...timing,
+        signal: controller.signal,
+        poll: async () => {
+            const servers = await loadReconciledMcpStatuses(session, isActive);
+            if (!isActive() || !servers) {
+                return "complete";
+            }
+            emitMcpSnapshotFromMappedStatuses(session, servers, "mcp_status");
+            const server = servers.find((candidate) => candidate.name === serverName);
+            return shouldKeepMonitoringMcpAuth(server) ? "continue" : "complete";
+        },
+    }).then((result) => {
+        if (result.outcome === "exhausted") {
+            logMcpAuthMonitorExhausted(session, serverName, result);
+        }
+        return result;
+    });
+    monitor = { controller, task };
+    session.mcpAuthMonitors.set(serverName, monitor);
+    void task.then(() => {
+        if (session.mcpAuthMonitors.get(serverName) === monitor) {
+            session.mcpAuthMonitors.delete(serverName);
+        }
+    });
+    return task;
 }
 export async function handleMcpStatusCommand(session, requestId, source = "mcp_status") {
     try {
@@ -224,6 +237,7 @@ export async function handleMcpStatusCommand(session, requestId, source = "mcp_s
             session_id: session.sessionId,
             source,
             servers: [],
+            auth_capabilities: detectMcpAuthCapabilities(session.query),
             error: message,
         }, requestId);
     }
@@ -277,8 +291,7 @@ export async function handleMcpSetServersCommand(session, command, requestId) {
 }
 export async function handleMcpAuthenticateCommand(session, command, requestId) {
     try {
-        const result = await callMcpAuthMethod(session, "mcpAuthenticate", [command.server_name]);
-        const redirect = extractMcpAuthRedirect(command.server_name, result);
+        const redirect = await authenticateMcpServer(session.query, command.server_name);
         if (redirect) {
             logMcpSuccess("mcp_auth_redirect_emitted", "MCP auth redirect emitted", command.session_id, requestId, { server_name: command.server_name, requires_user_action: redirect.requires_user_action });
             writeEvent({
@@ -290,7 +303,7 @@ export async function handleMcpAuthenticateCommand(session, command, requestId)
         else {
             logMcpSuccess("mcp_authenticate_completed", "MCP authentication command completed", command.session_id, requestId, { server_name: command.server_name });
         }
-        scheduleMcpAuthSnapshotMonitor(session, command.server_name);
+        startMcpAuthSnapshotMonitor(session, command.server_name);
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
@@ -300,8 +313,8 @@ export async function handleMcpAuthenticateCommand(session, command, requestId)
 }
 export async function handleMcpClearAuthCommand(session, command, requestId) {
     try {
-        await callMcpAuthMethod(session, "mcpClearAuth", [command.server_name]);
-        forgetKnownConnectedMcpServer(command.server_name);
+        await clearMcpServerAuth(session.query, command.server_name);
+        forgetKnownConnectedMcpServer(session, command.server_name);
         session.mcpStatusRevalidatedAt.delete(command.server_name);
         logMcpSuccess("mcp_clear_auth_completed", "MCP auth cleared", command.session_id, requestId, {
             server_name: command.server_name,
@@ -315,10 +328,7 @@ export async function handleMcpClearAuthCommand(session, command, requestId) {
 }
 export async function handleMcpOauthCallbackUrlCommand(session, command, requestId) {
     try {
-        await callMcpAuthMethod(session, "mcpSubmitOAuthCallbackUrl", [
-            command.server_name,
-            command.callback_url,
-        ]);
+        await submitMcpOAuthCallbackUrl(session.query, command.server_name, command.callback_url);
         logMcpSuccess("mcp_oauth_callback_completed", "MCP OAuth callback URL submitted", command.session_id, requestId, {
             server_name: command.server_name,
             callback_url_chars: command.callback_url.length,

package/agent-sdk/dist/bridge/mcp_auth_adapter.js

@@ -0,0 +1,67 @@
+const MCP_AUTH_METHODS = {
+    authenticate: "mcpAuthenticate",
+    clear_auth: "mcpClearAuth",
+    submit_oauth_callback_url: "mcpSubmitOAuthCallbackUrl",
+};
+function runtimeMethod(query, methodName) {
+    if ((!query || typeof query !== "object") && typeof query !== "function") {
+        return undefined;
+    }
+    const method = Reflect.get(query, methodName);
+    return typeof method === "function" ? method : undefined;
+}
+function requiredRuntimeMethod(query, methodName) {
+    const method = runtimeMethod(query, methodName);
+    if (!method) {
+        throw new Error(`installed SDK does not support ${methodName}`);
+    }
+    return method;
+}
+async function invokeRuntimeMethod(query, methodName, args) {
+    const method = requiredRuntimeMethod(query, methodName);
+    return await Reflect.apply(method, query, args);
+}
+export function detectMcpAuthCapabilities(query) {
+    return {
+        authenticate: runtimeMethod(query, MCP_AUTH_METHODS.authenticate) !== undefined,
+        clear_auth: runtimeMethod(query, MCP_AUTH_METHODS.clear_auth) !== undefined,
+        submit_oauth_callback_url: runtimeMethod(query, MCP_AUTH_METHODS.submit_oauth_callback_url) !== undefined,
+    };
+}
+function parseMcpAuthRedirect(serverName, value) {
+    if (value === undefined || value === null) {
+        return null;
+    }
+    if (typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("installed SDK returned an invalid mcpAuthenticate response");
+    }
+    const authUrl = Reflect.get(value, "authUrl");
+    if (authUrl === undefined || authUrl === null) {
+        return null;
+    }
+    if (typeof authUrl !== "string" || authUrl.trim().length === 0) {
+        throw new Error("installed SDK returned an invalid mcpAuthenticate authUrl");
+    }
+    const requiresUserAction = Reflect.get(value, "requiresUserAction");
+    if (requiresUserAction !== undefined && typeof requiresUserAction !== "boolean") {
+        throw new Error("installed SDK returned an invalid mcpAuthenticate requiresUserAction");
+    }
+    return {
+        server_name: serverName,
+        auth_url: authUrl,
+        requires_user_action: requiresUserAction === true,
+    };
+}
+export async function authenticateMcpServer(query, serverName) {
+    const result = await invokeRuntimeMethod(query, MCP_AUTH_METHODS.authenticate, [serverName]);
+    return parseMcpAuthRedirect(serverName, result);
+}
+export async function clearMcpServerAuth(query, serverName) {
+    await invokeRuntimeMethod(query, MCP_AUTH_METHODS.clear_auth, [serverName]);
+}
+export async function submitMcpOAuthCallbackUrl(query, serverName, callbackUrl) {
+    await invokeRuntimeMethod(query, MCP_AUTH_METHODS.submit_oauth_callback_url, [
+        serverName,
+        callbackUrl,
+    ]);
+}

package/agent-sdk/dist/bridge/mcp_monitor.js

@@ -0,0 +1,59 @@
+import { setTimeout as delay } from "node:timers/promises";
+const DEFAULT_MAX_ATTEMPTS = 24;
+const DEFAULT_INITIAL_DELAY_MS = 1_000;
+const DEFAULT_MAX_DELAY_MS = 10_000;
+async function abortableDelay(delayMs, signal) {
+    await delay(delayMs, undefined, { signal, ref: false });
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export async function runMcpAuthMonitor({ signal, poll, maxAttempts = DEFAULT_MAX_ATTEMPTS, initialDelayMs = DEFAULT_INITIAL_DELAY_MS, maxDelayMs = DEFAULT_MAX_DELAY_MS, sleep = abortableDelay, }) {
+    let nextDelayMs = initialDelayMs;
+    let lastError;
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        try {
+            await sleep(nextDelayMs, signal);
+        }
+        catch (error) {
+            if (signal.aborted) {
+                return { outcome: "cancelled", attempts: attempt - 1 };
+            }
+            lastError = errorMessage(error);
+            if (attempt === maxAttempts) {
+                return { outcome: "exhausted", attempts: attempt, reason: "error", lastError };
+            }
+            nextDelayMs = Math.min(nextDelayMs * 2, maxDelayMs);
+            continue;
+        }
+        if (signal.aborted) {
+            return { outcome: "cancelled", attempts: attempt - 1 };
+        }
+        try {
+            const result = await poll();
+            if (signal.aborted) {
+                return { outcome: "cancelled", attempts: attempt };
+            }
+            if (result === "complete") {
+                return { outcome: "completed", attempts: attempt };
+            }
+            lastError = undefined;
+        }
+        catch (error) {
+            if (signal.aborted) {
+                return { outcome: "cancelled", attempts: attempt };
+            }
+            lastError = errorMessage(error);
+        }
+        if (attempt === maxAttempts) {
+            return {
+                outcome: "exhausted",
+                attempts: attempt,
+                reason: lastError ? "error" : "status",
+                ...(lastError ? { lastError } : {}),
+            };
+        }
+        nextDelayMs = Math.min(nextDelayMs * 2, maxDelayMs);
+    }
+    return { outcome: "exhausted", attempts: 0, reason: "status" };
+}

package/agent-sdk/dist/bridge/message_handlers.js

@@ -1,11 +1,11 @@
 import { asRecordOrNull } from "./shared.js";
 import { toPermissionMode, buildModeState, refreshSupportedModesForSession } from "./commands.js";
 import { writeEvent, emitSessionUpdate, emitConnectEvent, emitSessionReplacedEvent, } from "./events.js";
-import { TOOL_RESULT_TYPES, isToolSearchToolName, isToolSearchToolResultType, unwrapToolUseResult, } from "./tooling.js";
+import { TOOL_RESULT_TYPES, isToolSearchToolName, isToolSearchToolResultType, unwrapToolUseResult, parseToolNonExecutionMetadata, } from "./tooling.js";
 import { emitToolCall, emitToolCallUpdate, emitToolResultUpdate, finalizeOpenToolCalls, emitToolProgressUpdate, emitToolSummaryUpdate, ensureToolCallVisible, resolveTaskToolUseId, defersTaskNotificationCompletion, toolAcceptsTaskLifecycle, taskProgressText, taskUpdatedFields, } from "./tool_calls.js";
 import { applyBackgroundTasksChanged, applyTaskLifecycleState } from "./tasks.js";
 import { linkTaskToolUse, unlinkTaskToolUse } from "./task_links.js";
-import { emitAuthRequired, classifyTurnErrorKind, emitFastModeUpdateIfChanged } from "./error_classification.js";
+import { emitAuthRequired, classifyTurnErrorKind, emitFastModeUpdate, emitFastModeUpdateIfChanged, setFastModeSnapshotIfChanged, } from "./error_classification.js";
 import { mapAvailableAgentsFromNames, emitAvailableAgentsIfChanged, refreshAvailableAgents } from "./agents.js";
 import { mapInitSlashCommands, mapSdkSlashCommands, updateAvailableCommands, } from "./available_commands.js";
 import { buildApiRetryUpdate, buildRateLimitUpdate, buildSubagentRetryUpdate, normalizeSettingsParseErrors, numberField, parseApiRetryError, parseRuntimeSessionState, } from "./state_parsing.js";
@@ -744,6 +744,7 @@ export function handleUserToolResultBlocks(session, message) {
         return false;
     }
     const content = Array.isArray(messageObject.content) ? messageObject.content : [];
+    const nonExecutionByToolUseId = parseToolNonExecutionMetadata(message.tool_result_meta);
     let handled = false;
     for (const block of content) {
         if (!block || typeof block !== "object") {
@@ -766,13 +767,13 @@ export function handleUserToolResultBlocks(session, message) {
                 parentToolUseId,
                 sourceMessageUuid: sourceMessageUuid(message),
             });
-            emitToolResultUpdate(session, toolUseId, Boolean(blockRecord.is_error), blockRecord.content, messageToolUseResult(message) ?? blockRecord, sourceMessageUuid(message));
+            emitToolResultUpdate(session, toolUseId, Boolean(blockRecord.is_error), blockRecord.content, messageToolUseResult(message) ?? blockRecord, sourceMessageUuid(message), nonExecutionByToolUseId.get(toolUseId));
         }
     }
     return handled;
 }
 export function handleResultMessage(session, message) {
-    emitFastModeUpdateIfChanged(session, message.fast_mode_state);
+    emitFastModeUpdateIfChanged(session, message.fast_mode_state, message.fast_mode_disabled_reason);
     const terminalReason = terminalReasonFromValue(message.terminal_reason);
     const subtype = typeof message.subtype === "string" ? message.subtype : "";
     if (subtype === "success") {
@@ -979,7 +980,7 @@ export function handleSdkMessage(session, message) {
                 session.mode = incomingMode;
             }
             refreshSupportedModesForSession(session);
-            emitFastModeUpdateIfChanged(session, msg.fast_mode_state);
+            const fastModeChanged = setFastModeSnapshotIfChanged(session, msg.fast_mode_state, msg.fast_mode_disabled_reason);
             if (!session.connected) {
                 emitConnectEvent(session);
             }
@@ -996,6 +997,9 @@ export function handleSdkMessage(session, message) {
                         mode: buildModeState(session, incomingMode),
                     });
                 }
+                if (fastModeChanged) {
+                    emitFastModeUpdate(session);
+                }
             }
             if (Array.isArray(msg.slash_commands)) {
                 updateAvailableCommands(session, "init_slash_commands", mapInitSlashCommands(msg.slash_commands));
@@ -1040,7 +1044,7 @@ export function handleSdkMessage(session, message) {
             else if (msg.status === null) {
                 emitSessionUpdate(session.sessionId, { type: "session_status_update", status: "idle" });
             }
-            emitFastModeUpdateIfChanged(session, msg.fast_mode_state);
+            emitFastModeUpdateIfChanged(session, msg.fast_mode_state, msg.fast_mode_disabled_reason);
             return;
         }
         if (subtype === "compact_boundary") {
@@ -1270,7 +1274,7 @@ export function handleSdkMessage(session, message) {
                 return;
             }
             const parsed = unwrapToolUseResult(rawToolUseResult);
-            emitToolResultUpdate(session, toolUseId, parsed.isError, parsed.content, rawToolUseResult, sourceMessageUuid(msg));
+            emitToolResultUpdate(session, toolUseId, parsed.isError, parsed.content, rawToolUseResult, sourceMessageUuid(msg), parseToolNonExecutionMetadata(msg.tool_result_meta).get(toolUseId));
         }
         return;
     }

package/agent-sdk/dist/bridge/session_lifecycle.js

@@ -11,7 +11,7 @@ import { isToolSearchToolName } from "./tooling.js";
 import { requestExitPlanModeApproval, requestAskUserQuestionAnswers, EXIT_PLAN_MODE_TOOL_NAME, ASK_USER_QUESTION_TOOL_NAME, } from "./user_interaction.js";
 import { mapAvailableAgents, emitAvailableAgentsIfChanged, refreshAvailableAgents } from "./agents.js";
 import { mapSdkSlashCommands, updateAvailableCommands, } from "./available_commands.js";
-import { emitAuthRequired, emitFastModeUpdateIfChanged } from "./error_classification.js";
+import { emitAuthRequired, emitFastModeUpdate, setFastModeSnapshotIfChanged, } from "./error_classification.js";
 import { mapAvailableModels, resolveCurrentModel, currentModelsEqual, } from "./model_metadata.js";
 import { shouldEmitStartupAuthRequiredForAccount } from "./account_metadata.js";
 export { mapAvailableModels, resolveCurrentModel } from "./model_metadata.js";
@@ -34,6 +34,7 @@ function permissionDisplayFromCanUseOptions(options) {
     };
 }
 export const sessions = new Map();
+const pendingSessionCloseTasks = new Set();
 const DEFAULT_SETTING_SOURCES = ["user", "project", "local"];
 const DEFAULT_PERMISSION_MODE = "default";
 function isSdkElicitationContentValue(value) {
@@ -134,7 +135,44 @@ export function updateSessionId(session, newSessionId) {
     session.sessionId = newSessionId;
     sessions.set(newSessionId, session);
 }
+export function beginSessionClose(session) {
+    session.closing = true;
+    for (const monitor of session.mcpAuthMonitors.values()) {
+        monitor.controller.abort();
+    }
+}
+export function detachSessionForClose(session) {
+    beginSessionClose(session);
+    if (sessions.get(session.sessionId) === session) {
+        sessions.delete(session.sessionId);
+    }
+}
+export function trackSessionCloseTask(task) {
+    const ownedTask = task.catch((error) => {
+        bridgeLogger.error({
+            target: LOG_TARGETS.APP_SESSION,
+            eventName: "session_close_task_failed",
+            message: "background session cleanup failed",
+            outcome: "failure",
+            fields: {
+                error_message: error instanceof Error ? error.message : String(error),
+            },
+        });
+    });
+    pendingSessionCloseTasks.add(ownedTask);
+    void ownedTask.then(() => {
+        pendingSessionCloseTasks.delete(ownedTask);
+    });
+}
+async function waitForPendingSessionCloseTasks() {
+    while (pendingSessionCloseTasks.size > 0) {
+        await Promise.all(Array.from(pendingSessionCloseTasks));
+    }
+}
 export async function closeSession(session) {
+    beginSessionClose(session);
+    const mcpAuthMonitors = Array.from(session.mcpAuthMonitors.values());
+    session.mcpAuthMonitors.clear();
     session.input.close();
     session.query.close();
     for (const pending of session.pendingPermissions.values()) {
@@ -154,6 +192,11 @@ export async function closeSession(session) {
         pending.resolve({ action: "cancel" });
     }
     session.pendingElicitations.clear();
+    await Promise.all([
+        session.initializationTask,
+        session.queryConsumerTask,
+        ...mcpAuthMonitors.map((monitor) => monitor.task),
+    ].filter((task) => task !== undefined));
 }
 export async function closeSessionWithLogging(session, options = {}) {
     await closeSession(session);
@@ -191,6 +234,7 @@ export async function closeAllSessions(options = {}) {
         reason: options.reason ?? "bulk_close",
         requestId: options.requestId,
     })));
+    await waitForPendingSessionCloseTasks();
     bridgeLogger.info({
         target: LOG_TARGETS.APP_SESSION,
         eventName: "all_sessions_closed",
@@ -335,6 +379,7 @@ export async function createSession(params) {
         query: queryHandle,
         input,
         connected: false,
+        closing: false,
         connectEvent: params.connectEvent,
         connectRequestId: params.requestId,
         toolCalls: new Map(),
@@ -347,7 +392,9 @@ export async function createSession(params) {
         pendingUserDialogs: new Map(),
         pendingElicitations: new Map(),
         informationalDedupKeys: new Set(),
+        knownConnectedMcpServers: new Set(),
         mcpStatusRevalidatedAt: new Map(),
+        mcpAuthMonitors: new Map(),
         hiddenToolUseIds: new Set(),
         authHintSent: false,
         ...(params.resumeUpdates && params.resumeUpdates.length > 0
@@ -396,7 +443,7 @@ export async function createSession(params) {
     // In stream-input mode the SDK may defer init until input arrives.
     // Trigger initialization explicitly so the Rust UI can receive `connected`
     // before the first user prompt.
-    void session.query
+    session.initializationTask = session.query
         .initializationResult()
         .then(async (result) => {
         bridgeLogger.info({
@@ -416,6 +463,7 @@ export async function createSession(params) {
         const currentModelChanged = refreshCurrentModel(session);
         const { buildModeState, refreshSupportedModesForSession } = await import("./commands.js");
         refreshSupportedModesForSession(session);
+        const fastModeChanged = setFastModeSnapshotIfChanged(session, result.fast_mode_state, result.fast_mode_disabled_reason);
         if (!session.connected) {
             emitConnectEvent(session);
         }
@@ -429,13 +477,15 @@ export async function createSession(params) {
                     mode: buildModeState(session, session.mode),
                 });
             }
+            if (fastModeChanged) {
+                emitFastModeUpdate(session);
+            }
         }
         // Proactively detect missing auth from account info so the UI can
         // show the login hint immediately, without waiting for the first prompt.
         if (shouldEmitStartupAuthRequiredForAccount(result.account)) {
             emitAuthRequired(session);
         }
-        emitFastModeUpdateIfChanged(session, result.fast_mode_state);
         updateAvailableCommands(session, "session_result_commands", mapSdkSlashCommands(result.commands));
         emitAvailableAgentsIfChanged(session, mapAvailableAgents(result.agents));
         refreshAvailableAgents(session);
@@ -457,7 +507,7 @@ export async function createSession(params) {
         failConnection(`agent initialization failed: ${message}`, session.connectRequestId);
         session.connectRequestId = undefined;
     });
-    void (async () => {
+    session.queryConsumerTask = (async () => {
         try {
             for await (const message of session.query) {
                 // Lazy import to break circular dependency at module-evaluation time.

package/agent-sdk/dist/bridge/state_parsing.js

@@ -49,6 +49,13 @@ export function parseFastModeState(value) {
     }
     return null;
 }
+export function parseFastModeDisabledReason(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const reason = value.trim();
+    return reason.length > 0 ? reason : undefined;
+}
 export function parseRateLimitStatus(value) {
     if (value === "allowed" || value === "allowed_warning" || value === "rejected") {
         return value;