claude-code-rust 0.9.0 → 0.11.0

package/agent-sdk/dist/bridge.js

@@ -4,14 +4,16 @@ import { dirname, join } from "node:path";
 import readline from "node:readline";
 import { pathToFileURL } from "node:url";
 import { getSessionMessages, listSessions, renameSession, } from "@anthropic-ai/claude-agent-sdk";
-import { parseCommandEnvelope, toPermissionMode } from "./bridge/commands.js";
-import { writeEvent, failConnection, slashError, emitSessionUpdate, emitSessionsList, currentSessionListOptions, setSessionListingDir, } from "./bridge/events.js";
-import { textFromPrompt } from "./bridge/message_handlers.js";
-import { sessions, sessionById, createSession, closeAllSessions, handleElicitationResponse, handlePermissionResponse, handleQuestionResponse, } from "./bridge/session_lifecycle.js";
+import { buildModeState, markModeUnavailableForSession, parseCommandEnvelope, permissionModeFailureLooksUnsupported, refreshSupportedModesForSession, toPermissionMode, } from "./bridge/commands.js";
+import { writeEvent, failConnection, slashError, emitRuntimeReloadCompleted, emitRuntimeReloadFailed, emitSessionUpdate, emitSessionsList, currentSessionListOptions, setSessionListingDir, } from "./bridge/events.js";
+import { contentFromPrompt } from "./bridge/message_handlers.js";
+import { sessions, sessionById, createSession, closeAllSessions, handleElicitationResponse, handlePermissionResponse, handleQuestionResponse, emitCurrentModelUpdate, refreshCurrentModel, shouldInvalidateResolvedRuntimeModel, } from "./bridge/session_lifecycle.js";
 import { mapSessionMessagesToUpdates } from "./bridge/history.js";
+import { emitAvailableAgentsIfChanged, mapAvailableAgents } from "./bridge/agents.js";
 import { MCP_STALE_STATUS_REVALIDATION_COOLDOWN_MS, handleMcpAuthenticateCommand, handleMcpClearAuthCommand, handleMcpOauthCallbackUrlCommand, handleMcpReconnectCommand, handleMcpSetServersCommand, handleMcpStatusCommand, handleMcpToggleCommand, staleMcpAuthCandidates, } from "./bridge/mcp.js";
+import { bridgeLogger, LOG_TARGETS, logBridgeCommandReceived } from "./bridge/logger.js";
 // Re-exports: all symbols that tests and external consumers import from bridge.js.
-export { AsyncQueue, logPermissionDebug } from "./bridge/shared.js";
+export { AsyncQueue } from "./bridge/shared.js";
 export { asRecordOrNull } from "./bridge/shared.js";
 export { CACHE_SPLIT_POLICY, previewKilobyteLabel } from "./bridge/cache_policy.js";
 export { buildToolResultFields, createToolCall, normalizeToolKind, normalizeToolResultText, unwrapToolUseResult, } from "./bridge/tooling.js";
@@ -20,10 +22,10 @@ export { parseCommandEnvelope } from "./bridge/commands.js";
 export { buildSessionListOptions } from "./bridge/events.js";
 export { permissionOptionsFromSuggestions, permissionResultFromOutcome, } from "./bridge/permissions.js";
 export { mapSessionMessagesToUpdates, mapSdkSessions, } from "./bridge/history.js";
-export { handleTaskSystemMessage } from "./bridge/message_handlers.js";
+export { handleSdkMessage, handleTaskSystemMessage } from "./bridge/message_handlers.js";
 export { mapAvailableAgents } from "./bridge/agents.js";
-export { buildQueryOptions, mapAvailableModels } from "./bridge/session_lifecycle.js";
-export { parseFastModeState, parseRateLimitStatus, buildRateLimitUpdate, } from "./bridge/state_parsing.js";
+export { attachRequestUserDialogInterceptor, buildQueryOptions, mapAvailableModels, } from "./bridge/session_lifecycle.js";
+export { parseFastModeState, parseRateLimitStatus, parseRuntimeSessionState, parseApiRetryError, buildRateLimitUpdate, buildApiRetryUpdate, normalizeSettingsParseError, normalizeSettingsParseErrors, } from "./bridge/state_parsing.js";
 export { MCP_STALE_STATUS_REVALIDATION_COOLDOWN_MS, staleMcpAuthCandidates };
 export function buildSessionMutationOptions(cwd) {
     return cwd ? { dir: cwd } : undefined;
@@ -41,7 +43,7 @@ export async function generatePersistedSessionTitle(query, description) {
     }
     return title;
 }
-const EXPECTED_AGENT_SDK_VERSION = "0.2.74";
+const EXPECTED_AGENT_SDK_VERSION = "0.2.104";
 const require = createRequire(import.meta.url);
 export function resolveInstalledAgentSdkVersion() {
     try {
@@ -67,14 +69,34 @@ export function agentSdkVersionCompatibilityError() {
         `found ${installed}.`);
 }
 async function handleCommand(command, requestId) {
+    logBridgeCommandReceived(command, requestId);
     const sdkVersionError = agentSdkVersionCompatibilityError();
     if (sdkVersionError && command.command !== "initialize" && command.command !== "shutdown") {
+        bridgeLogger.error({
+            target: LOG_TARGETS.BRIDGE_LIFECYCLE,
+            eventName: "bridge_command_rejected",
+            message: "bridge command rejected due to unsupported SDK version",
+            outcome: "failure",
+            ...(requestId ? { requestId } : {}),
+            fields: {
+                bridge_command: command.command,
+                error_message: sdkVersionError,
+            },
+        });
         failConnection(sdkVersionError, requestId);
         return;
     }
     switch (command.command) {
         case "initialize":
             if (sdkVersionError) {
+                bridgeLogger.error({
+                    target: LOG_TARGETS.BRIDGE_LIFECYCLE,
+                    eventName: "bridge_initialize_failed",
+                    message: "bridge initialization failed due to unsupported SDK version",
+                    outcome: "failure",
+                    ...(requestId ? { requestId } : {}),
+                    fields: { error_message: sdkVersionError },
+                });
                 failConnection(sdkVersionError, requestId);
                 return;
             }
@@ -92,7 +114,7 @@ async function handleCommand(command, requestId) {
                         },
                     ],
                     capabilities: {
-                        prompt_image: false,
+                        prompt_image: true,
                         prompt_embedded_context: true,
                         supports_session_listing: true,
                         supports_resume_session: true,
@@ -102,6 +124,17 @@ async function handleCommand(command, requestId) {
             await emitSessionsList(requestId);
             return;
         case "create_session":
+            bridgeLogger.info({
+                target: LOG_TARGETS.APP_SESSION,
+                eventName: "session_create_requested",
+                message: "session creation requested",
+                outcome: "start",
+                ...(requestId ? { requestId } : {}),
+                fields: {
+                    cwd: command.cwd,
+                    resume_requested: command.resume !== undefined,
+                },
+            });
             setSessionListingDir(command.cwd);
             await createSession({
                 cwd: command.cwd,
@@ -112,10 +145,27 @@ async function handleCommand(command, requestId) {
             });
             return;
         case "resume_session": {
+            bridgeLogger.info({
+                target: LOG_TARGETS.APP_SESSION,
+                eventName: "session_resume_requested",
+                message: "session resume requested",
+                outcome: "start",
+                ...(requestId ? { requestId } : {}),
+                sessionId: command.session_id,
+            });
             try {
                 const sdkSessions = await listSessions(currentSessionListOptions());
                 const matched = sdkSessions.find((entry) => entry.sessionId === command.session_id);
                 if (!matched) {
+                    bridgeLogger.warn({
+                        target: LOG_TARGETS.APP_SESSION,
+                        eventName: "session_resume_lookup_failed",
+                        message: "session resume requested for an unknown session",
+                        outcome: "failure",
+                        ...(requestId ? { requestId } : {}),
+                        sessionId: command.session_id,
+                        fields: { reason: "unknown_session" },
+                    });
                     slashError(command.session_id, `unknown session: ${command.session_id}`, requestId);
                     return;
                 }
@@ -124,6 +174,18 @@ async function handleCommand(command, requestId) {
                 const resumeUpdates = mapSessionMessagesToUpdates(historyMessages);
                 const staleSessions = Array.from(sessions.values());
                 const hadActiveSession = staleSessions.length > 0;
+                bridgeLogger.info({
+                    target: LOG_TARGETS.APP_SESSION,
+                    eventName: "session_resume_history_loaded",
+                    message: "session resume history loaded",
+                    outcome: "success",
+                    ...(requestId ? { requestId } : {}),
+                    sessionId: command.session_id,
+                    fields: {
+                        history_update_count: resumeUpdates.length,
+                        stale_session_count: staleSessions.length,
+                    },
+                });
                 await createSession({
                     cwd: matched.cwd ?? process.cwd(),
                     resume: command.session_id,
@@ -136,12 +198,29 @@ async function handleCommand(command, requestId) {
             }
             catch (error) {
                 const message = error instanceof Error ? error.message : String(error);
+                bridgeLogger.error({
+                    target: LOG_TARGETS.APP_SESSION,
+                    eventName: "session_resume_failed",
+                    message: "session resume failed",
+                    outcome: "failure",
+                    ...(requestId ? { requestId } : {}),
+                    sessionId: command.session_id,
+                    fields: { error_message: message },
+                });
                 slashError(command.session_id, `failed to resume session: ${message}`, requestId);
             }
             return;
         }
         case "new_session":
-            await closeAllSessions();
+            bridgeLogger.info({
+                target: LOG_TARGETS.APP_SESSION,
+                eventName: "session_new_requested",
+                message: "replacement session requested",
+                outcome: "start",
+                ...(requestId ? { requestId } : {}),
+                fields: { cwd: command.cwd },
+            });
+            await closeAllSessions({ reason: "new_session_requested", requestId });
             setSessionListingDir(command.cwd);
             await createSession({
                 cwd: command.cwd,
@@ -156,19 +235,20 @@ async function handleCommand(command, requestId) {
                 slashError(command.session_id, `unknown session: ${command.session_id}`, requestId);
                 return;
             }
-            const text = textFromPrompt(command);
-            if (!text.trim()) {
+            const content = contentFromPrompt(command);
+            if (content.length === 0) {
                 return;
             }
-            session.input.enqueue({
+            const message = {
                 type: "user",
                 session_id: session.sessionId,
                 parent_tool_use_id: null,
                 message: {
                     role: "user",
-                    content: [{ type: "text", text }],
+                    content,
                 },
-            });
+            };
+            session.input.enqueue(message);
             return;
         }
         case "cancel_turn": {
@@ -186,13 +266,80 @@ async function handleCommand(command, requestId) {
                 slashError(command.session_id, `unknown session: ${command.session_id}`, requestId);
                 return;
             }
-            await session.query.setModel(command.model);
-            session.model = command.model;
-            emitSessionUpdate(session.sessionId, {
-                type: "config_option_update",
-                option_id: "model",
-                value: command.model,
+            bridgeLogger.info({
+                target: LOG_TARGETS.APP_SESSION,
+                eventName: "set_model_started",
+                message: "set model started",
+                outcome: "start",
+                sessionId: session.sessionId,
+                requestId,
+                fields: {
+                    requested_model: command.model,
+                    previous_requested_model: session.requestedModelId,
+                    previous_session_model: session.model,
+                    previous_resolved_runtime_model: session.resolvedRuntimeModelId,
+                    previous_current_model: session.currentModel?.resolved_id,
+                },
             });
+            try {
+                const previousRequestedModel = session.requestedModelId;
+                const previousSessionModel = session.model;
+                await session.query.setModel(command.model);
+                session.requestedModelId = command.model;
+                session.model = command.model;
+                const invalidatedResolvedRuntimeModel = shouldInvalidateResolvedRuntimeModel(previousRequestedModel, previousSessionModel, command.model);
+                if (invalidatedResolvedRuntimeModel) {
+                    session.resolvedRuntimeModelId = undefined;
+                }
+                const changed = refreshCurrentModel(session, true);
+                const forcedCurrentModelUpdate = !changed && emitCurrentModelUpdate(session);
+                bridgeLogger.info({
+                    target: LOG_TARGETS.APP_SESSION,
+                    eventName: "set_model_succeeded",
+                    message: "set model completed",
+                    outcome: "success",
+                    sessionId: session.sessionId,
+                    requestId,
+                    fields: {
+                        requested_model: command.model,
+                        session_model_after: session.model,
+                        resolved_runtime_model_after: session.resolvedRuntimeModelId,
+                        current_model_after: session.currentModel?.resolved_id,
+                        current_model_display_short: session.currentModel?.display_name_short,
+                        current_model_display_long: session.currentModel?.display_name_long,
+                        current_model_update_emitted: changed || forcedCurrentModelUpdate,
+                        current_model_update_forced: forcedCurrentModelUpdate,
+                        resolved_runtime_model_invalidated: invalidatedResolvedRuntimeModel,
+                    },
+                });
+                refreshSupportedModesForSession(session);
+                if (session.mode) {
+                    emitSessionUpdate(session.sessionId, {
+                        type: "mode_state_update",
+                        mode: buildModeState(session, session.mode),
+                    });
+                }
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                bridgeLogger.warn({
+                    target: LOG_TARGETS.APP_SESSION,
+                    eventName: "set_model_failed",
+                    message: "set model failed",
+                    outcome: "failure",
+                    sessionId: session.sessionId,
+                    requestId,
+                    fields: {
+                        requested_model: command.model,
+                        error_message: message,
+                        previous_requested_model: session.requestedModelId,
+                        previous_session_model: session.model,
+                        previous_resolved_runtime_model: session.resolvedRuntimeModelId,
+                        previous_current_model: session.currentModel?.resolved_id,
+                    },
+                });
+                slashError(command.session_id, `failed to set model: ${message}`, requestId);
+            }
             return;
         }
         case "set_mode": {
@@ -206,12 +353,28 @@ async function handleCommand(command, requestId) {
                 slashError(command.session_id, `unsupported mode: ${command.mode}`, requestId);
                 return;
             }
-            await session.query.setPermissionMode(mode);
-            session.mode = mode;
-            emitSessionUpdate(session.sessionId, {
-                type: "current_mode_update",
-                current_mode_id: mode,
-            });
+            try {
+                await session.query.setPermissionMode(mode);
+                session.mode = mode;
+                refreshSupportedModesForSession(session);
+                emitSessionUpdate(session.sessionId, {
+                    type: "current_mode_update",
+                    current_mode_id: mode,
+                });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                if (permissionModeFailureLooksUnsupported(mode, message)) {
+                    const changed = markModeUnavailableForSession(session, mode);
+                    if (changed && session.mode) {
+                        emitSessionUpdate(session.sessionId, {
+                            type: "mode_state_update",
+                            mode: buildModeState(session, session.mode),
+                        });
+                    }
+                }
+                slashError(command.session_id, `failed to set mode to ${mode}: ${message}`, requestId);
+            }
             return;
         }
         case "generate_session_title": {
@@ -254,18 +417,144 @@ async function handleCommand(command, requestId) {
                 slashError(command.session_id, `unknown session: ${command.session_id}`, requestId);
                 return;
             }
-            const account = await session.query.accountInfo();
-            writeEvent({
-                event: "status_snapshot",
-                session_id: session.sessionId,
-                account: {
-                    email: account.email,
-                    organization: account.organization,
-                    subscription_type: account.subscriptionType,
-                    token_source: account.tokenSource,
-                    api_key_source: account.apiKeySource,
-                },
-            }, requestId);
+            try {
+                const account = await session.query.accountInfo();
+                bridgeLogger.info({
+                    target: LOG_TARGETS.APP_AUTH,
+                    eventName: "status_snapshot_emitted",
+                    message: "status snapshot emitted",
+                    outcome: "success",
+                    ...(requestId ? { requestId } : {}),
+                    sessionId: session.sessionId,
+                    fields: {
+                        has_email: typeof account.email === "string" && account.email.trim().length > 0,
+                        has_organization: account.organization !== undefined,
+                        subscription_type: account.subscriptionType,
+                        token_source: account.tokenSource,
+                        api_key_source: account.apiKeySource,
+                        api_provider: account.apiProvider,
+                    },
+                });
+                writeEvent({
+                    event: "status_snapshot",
+                    session_id: session.sessionId,
+                    account: {
+                        email: account.email,
+                        organization: account.organization,
+                        subscription_type: account.subscriptionType,
+                        token_source: account.tokenSource,
+                        api_key_source: account.apiKeySource,
+                        api_provider: account.apiProvider,
+                    },
+                }, requestId);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                bridgeLogger.warn({
+                    target: LOG_TARGETS.APP_AUTH,
+                    eventName: "status_snapshot_failed",
+                    message: "failed to build status snapshot",
+                    outcome: "failure",
+                    ...(requestId ? { requestId } : {}),
+                    sessionId: session.sessionId,
+                    fields: { error_message: message },
+                });
+                throw error;
+            }
+            return;
+        }
+        case "get_context_usage": {
+            const session = sessionById(command.session_id);
+            if (!session) {
+                slashError(command.session_id, `unknown session: ${command.session_id}`, requestId);
+                return;
+            }
+            try {
+                const usage = await session.query.getContextUsage();
+                if (typeof usage.model === "string" && usage.model.trim().length > 0) {
+                    session.resolvedRuntimeModelId = usage.model.trim();
+                    refreshCurrentModel(session, true);
+                }
+                const rawPercentage = typeof usage.percentage === "number" ? usage.percentage : undefined;
+                const normalizedPercentage = rawPercentage === undefined || !Number.isFinite(rawPercentage)
+                    ? undefined
+                    : Math.max(0, Math.min(100, Math.round(rawPercentage)));
+                bridgeLogger.debug({
+                    target: LOG_TARGETS.APP_SESSION,
+                    eventName: "context_usage_succeeded",
+                    message: "session context usage received from SDK",
+                    outcome: "success",
+                    ...(requestId ? { requestId } : {}),
+                    sessionId: session.sessionId,
+                    fields: {
+                        raw_percentage: rawPercentage,
+                        normalized_percentage: normalizedPercentage,
+                        total_tokens: typeof usage.totalTokens === "number" ? usage.totalTokens : undefined,
+                        max_tokens: typeof usage.maxTokens === "number" ? usage.maxTokens : undefined,
+                        raw_max_tokens: typeof usage.rawMaxTokens === "number" ? usage.rawMaxTokens : undefined,
+                        model: typeof usage.model === "string" ? usage.model : undefined,
+                    },
+                });
+                writeEvent({
+                    event: "context_usage",
+                    session_id: session.sessionId,
+                    ...(normalizedPercentage !== undefined ? { percentage: normalizedPercentage } : {}),
+                }, requestId);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                bridgeLogger.warn({
+                    target: LOG_TARGETS.APP_SESSION,
+                    eventName: "context_usage_failed",
+                    message: "failed to get session context usage",
+                    outcome: "failure",
+                    ...(requestId ? { requestId } : {}),
+                    sessionId: session.sessionId,
+                    fields: { error_message: message },
+                });
+                writeEvent({
+                    event: "context_usage",
+                    session_id: session.sessionId,
+                }, requestId);
+            }
+            return;
+        }
+        case "reload_plugins": {
+            const session = sessionById(command.session_id);
+            if (!session) {
+                slashError(command.session_id, `unknown session: ${command.session_id}`, requestId);
+                return;
+            }
+            try {
+                const result = await session.query.reloadPlugins();
+                const commands = Array.isArray(result.commands)
+                    ? result.commands.map((entry) => ({
+                        name: entry.name,
+                        description: entry.description ?? "",
+                        input_hint: entry.argumentHint ?? undefined,
+                    }))
+                    : [];
+                emitSessionUpdate(session.sessionId, {
+                    type: "available_commands_update",
+                    commands,
+                });
+                emitAvailableAgentsIfChanged(session, mapAvailableAgents(result.agents));
+                await handleMcpStatusCommand(session, requestId);
+                emitRuntimeReloadCompleted(session.sessionId, requestId);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                bridgeLogger.warn({
+                    target: LOG_TARGETS.APP_SESSION,
+                    eventName: "reload_plugins_failed",
+                    message: "failed to reload session plugins",
+                    outcome: "failure",
+                    ...(requestId ? { requestId } : {}),
+                    sessionId: session.sessionId,
+                    fields: { error_message: message },
+                });
+                emitRuntimeReloadFailed(session.sessionId, message, requestId);
+            }
             return;
         }
         case "mcp_status": {
@@ -341,13 +630,46 @@ async function handleCommand(command, requestId) {
             handleElicitationResponse(command);
             return;
         case "shutdown":
-            await closeAllSessions();
+            bridgeLogger.info({
+                target: LOG_TARGETS.BRIDGE_LIFECYCLE,
+                eventName: "bridge_shutdown_requested",
+                message: "bridge shutdown requested",
+                outcome: "start",
+                ...(requestId ? { requestId } : {}),
+            });
+            await closeAllSessions({ reason: "bridge_shutdown_requested", requestId });
+            bridgeLogger.info({
+                target: LOG_TARGETS.BRIDGE_LIFECYCLE,
+                eventName: "bridge_shutdown_completed",
+                message: "bridge shutdown completed",
+                outcome: "success",
+                ...(requestId ? { requestId } : {}),
+            });
             process.exit(0);
+            return;
         default:
+            bridgeLogger.error({
+                target: LOG_TARGETS.BRIDGE_PROTOCOL,
+                eventName: "bridge_command_rejected",
+                message: "received unsupported bridge command",
+                outcome: "failure",
+                ...(requestId ? { requestId } : {}),
+                fields: {
+                    bridge_command: command.command ?? "unknown",
+                    reason: "unsupported_command",
+                },
+            });
             failConnection(`unhandled command: ${command.command ?? "unknown"}`, requestId);
     }
 }
 function main() {
+    bridgeLogger.info({
+        target: LOG_TARGETS.BRIDGE_LIFECYCLE,
+        eventName: "bridge_process_started",
+        message: "bridge process started",
+        outcome: "start",
+        fields: { pid: process.pid },
+    });
     const rl = readline.createInterface({
         input: process.stdin,
         crlfDelay: Number.POSITIVE_INFINITY,
@@ -363,6 +685,18 @@ function main() {
             }
             catch (error) {
                 const message = error instanceof Error ? error.message : String(error);
+                bridgeLogger.error({
+                    target: LOG_TARGETS.BRIDGE_PROTOCOL,
+                    eventName: "bridge_command_decode_failed",
+                    message: "failed to decode bridge command envelope",
+                    outcome: "failure",
+                    sizeBytes: Buffer.byteLength(line),
+                    fields: {
+                        preview: line.slice(0, 240),
+                        preview_chars: Math.min(line.length, 240),
+                        error_message: message,
+                    },
+                });
                 failConnection(`invalid command envelope: ${message}`);
                 return;
             }
@@ -371,12 +705,42 @@ function main() {
             }
             catch (error) {
                 const message = error instanceof Error ? error.message : String(error);
+                bridgeLogger.error({
+                    target: LOG_TARGETS.BRIDGE_PROTOCOL,
+                    eventName: "bridge_command_failed",
+                    message: "bridge command handler failed",
+                    outcome: "failure",
+                    ...(parsed.requestId ? { requestId: parsed.requestId } : {}),
+                    ...(parsed.command.command === "create_session" || parsed.command.command === "new_session"
+                        ? {}
+                        : "session_id" in parsed.command
+                            ? { sessionId: parsed.command.session_id }
+                            : {}),
+                    fields: {
+                        bridge_command: parsed.command.command,
+                        error_message: message,
+                    },
+                });
                 failConnection(`bridge command failed (${parsed.command.command}): ${message}`, parsed.requestId);
             }
         })();
     });
     rl.on("close", () => {
-        void closeAllSessions().finally(() => process.exit(0));
+        bridgeLogger.info({
+            target: LOG_TARGETS.BRIDGE_LIFECYCLE,
+            eventName: "bridge_input_closed",
+            message: "bridge stdin closed",
+            outcome: "success",
+        });
+        void closeAllSessions({ reason: "bridge_stdin_closed" }).finally(() => {
+            bridgeLogger.info({
+                target: LOG_TARGETS.BRIDGE_LIFECYCLE,
+                eventName: "bridge_shutdown_completed",
+                message: "bridge shutdown completed after stdin close",
+                outcome: "success",
+            });
+            process.exit(0);
+        });
     });
 }
 if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {