claude-code-rust 0.9.0 → 0.11.0

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

@@ -2,20 +2,82 @@ import { randomUUID } from "node:crypto";
 import { spawn as spawnChild } from "node:child_process";
 import fs from "node:fs";
 import { query, } from "@anthropic-ai/claude-agent-sdk";
-import { AsyncQueue, logPermissionDebug } from "./shared.js";
-import { formatPermissionUpdates, permissionOptionsFromSuggestions, permissionResultFromOutcome, } from "./permissions.js";
-import { writeEvent, failConnection, emitSessionUpdate, emitConnectEvent, } from "./events.js";
+import { bridgeLogger, LOG_TARGETS, logSdkStderrLine } from "./logger.js";
+import { AsyncQueue } from "./shared.js";
+import { permissionOptionsFromSuggestions, permissionResultFromOutcome, } from "./permissions.js";
+import { failConnection, emitSessionUpdate, emitConnectEvent, emitPermissionRequestEvent, emitElicitationRequestEvent, } from "./events.js";
 import { ensureToolCallVisible, setToolCallStatus, } from "./tool_calls.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 { emitAuthRequired, emitFastModeUpdateIfChanged } from "./error_classification.js";
+function permissionDisplayFromCanUseOptions(options) {
+    const title = typeof options.title === "string" ? options.title.trim() : "";
+    const displayName = typeof options.displayName === "string" ? options.displayName.trim() : "";
+    const description = typeof options.description === "string" ? options.description.trim() : "";
+    if (!title && !displayName && !description) {
+        return undefined;
+    }
+    return {
+        ...(title ? { title } : {}),
+        ...(displayName ? { display_name: displayName } : {}),
+        ...(description ? { description } : {}),
+    };
+}
+const requestUserDialogInterceptorInstalled = Symbol("requestUserDialogInterceptorInstalled");
 export const sessions = new Map();
+function nonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+export function shouldEmitStartupAuthRequiredForAccount(account) {
+    const provider = account.apiProvider;
+    if (nonEmptyString(provider) && provider !== "firstParty") {
+        return false;
+    }
+    return !nonEmptyString(account.email) && !nonEmptyString(account.apiKeySource);
+}
 const DEFAULT_SETTING_SOURCES = ["user", "project", "local"];
 const DEFAULT_MODEL_NAME = "default";
 const DEFAULT_PERMISSION_MODE = "default";
+function isSdkElicitationContentValue(value) {
+    return (typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean" ||
+        (Array.isArray(value) && value.every((entry) => typeof entry === "string")));
+}
+function normalizeSdkElicitationContent(content) {
+    if (!content) {
+        return undefined;
+    }
+    const normalized = {};
+    for (const [key, value] of Object.entries(content)) {
+        if (isSdkElicitationContentValue(value)) {
+            normalized[key] = value;
+        }
+    }
+    return Object.keys(normalized).length > 0 ? normalized : undefined;
+}
 function settingsObjectFromLaunchSettings(launchSettings) {
     return launchSettings.settings;
 }
+function normalizedSettingsFromLaunchSettings(launchSettings) {
+    const settings = settingsObjectFromLaunchSettings(launchSettings);
+    if (!settings) {
+        return undefined;
+    }
+    const sandbox = settings.sandbox && typeof settings.sandbox === "object" && !Array.isArray(settings.sandbox)
+        ? settings.sandbox
+        : undefined;
+    if (sandbox?.enabled === true && sandbox.failIfUnavailable === undefined) {
+        return {
+            ...settings,
+            sandbox: {
+                ...sandbox,
+                failIfUnavailable: false,
+            },
+        };
+    }
+    return settings;
+}
 export function sessionById(sessionId) {
     return sessions.get(sessionId) ?? null;
 }
@@ -27,6 +89,77 @@ export function updateSessionId(session, newSessionId) {
     session.sessionId = newSessionId;
     sessions.set(newSessionId, session);
 }
+function isRequestUserDialogControlRequest(value) {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    const record = value;
+    const request = record.request;
+    if (!request || typeof request !== "object") {
+        return false;
+    }
+    const inner = request;
+    const payload = inner.payload;
+    return (typeof record.request_id === "string" &&
+        inner.subtype === "request_user_dialog" &&
+        typeof inner.dialog_kind === "string" &&
+        Boolean(payload && typeof payload === "object" && !Array.isArray(payload)));
+}
+export function attachRequestUserDialogInterceptor(query, sessionIdForLogs) {
+    const internalQuery = query;
+    if (internalQuery[requestUserDialogInterceptorInstalled]) {
+        return true;
+    }
+    if (typeof internalQuery.processControlRequest !== "function") {
+        bridgeLogger.warn({
+            target: LOG_TARGETS.APP_SESSION,
+            eventName: "request_user_dialog_interceptor_unavailable",
+            message: "request_user_dialog interceptor could not be installed",
+            outcome: "failure",
+            sessionId: sessionIdForLogs(),
+        });
+        return false;
+    }
+    const originalProcessControlRequest = internalQuery.processControlRequest.bind(query);
+    internalQuery.processControlRequest = async (request, signal) => {
+        // SDK 0.2.104 also added cancel_async_message and seed_read_state control
+        // requests. Keep those delegated to the SDK internals: claude-rs does not
+        // own the SDK async-message queue or read-state cache, so TUI-level commands
+        // for them would add unsupported host behavior without user-visible value.
+        if (isRequestUserDialogControlRequest(request)) {
+            bridgeLogger.warn({
+                target: LOG_TARGETS.APP_SESSION,
+                eventName: "request_user_dialog_received",
+                message: "request_user_dialog control request received",
+                outcome: "failure",
+                sessionId: sessionIdForLogs(),
+                requestId: request.request_id,
+                ...(typeof request.request.tool_use_id === "string"
+                    ? { toolCallId: request.request.tool_use_id }
+                    : {}),
+                fields: {
+                    dialog_kind: request.request.dialog_kind,
+                    raw_payload: request.request.payload,
+                    raw_request: request.request,
+                },
+            });
+            // TODO(request_user_dialog): Revisit this when a real claude-rs host flow needs it.
+            // For now we only log the full control request and reject it explicitly because
+            // normal TUI sessions do not appear to exercise these dialog kinds.
+            throw new Error(`request_user_dialog is not supported by claude-rs yet (dialog_kind: ${request.request.dialog_kind})`);
+        }
+        return await originalProcessControlRequest(request, signal);
+    };
+    internalQuery[requestUserDialogInterceptorInstalled] = true;
+    bridgeLogger.info({
+        target: LOG_TARGETS.APP_SESSION,
+        eventName: "request_user_dialog_interceptor_installed",
+        message: "request_user_dialog interceptor installed",
+        outcome: "success",
+        sessionId: sessionIdForLogs(),
+    });
+    return true;
+}
 export async function closeSession(session) {
     session.input.close();
     session.query.close();
@@ -44,34 +177,77 @@ export async function closeSession(session) {
     }
     session.pendingElicitations.clear();
 }
-export async function closeAllSessions() {
+export async function closeSessionWithLogging(session, options = {}) {
+    await closeSession(session);
+    bridgeLogger.info({
+        target: LOG_TARGETS.APP_SESSION,
+        eventName: "session_closed",
+        message: "session closed",
+        outcome: "success",
+        sessionId: session.sessionId,
+        ...(options.requestId ? { requestId: options.requestId } : {}),
+        fields: { reason: options.reason ?? "unspecified" },
+    });
+}
+export async function closeAllSessions(options = {}) {
     const active = Array.from(sessions.values());
     sessions.clear();
-    await Promise.all(active.map((session) => closeSession(session)));
+    await Promise.all(active.map((session) => closeSessionWithLogging(session, {
+        reason: options.reason ?? "bulk_close",
+        requestId: options.requestId,
+    })));
+    bridgeLogger.info({
+        target: LOG_TARGETS.APP_SESSION,
+        eventName: "all_sessions_closed",
+        message: "all sessions closed",
+        outcome: "success",
+        ...(options.requestId ? { requestId: options.requestId } : {}),
+        count: active.length,
+        fields: { reason: options.reason ?? "bulk_close" },
+    });
 }
 export async function createSession(params) {
     const input = new AsyncQueue();
     const provisionalSessionId = params.resume ?? randomUUID();
     const initialModel = initialSessionModel(params.launchSettings);
     const initialMode = initialSessionMode(params.launchSettings);
+    const supportsBypassPermissionsMode = startupPermissionModeOptions(params.launchSettings).allowDangerouslySkipPermissions === true;
+    const historyUpdateCount = params.resumeUpdates?.length ?? 0;
+    const staleSessionCount = params.sessionsToCloseAfterConnect?.length ?? 0;
     let session;
+    const sessionIdForLogs = () => session?.sessionId ?? provisionalSessionId;
     const canUseTool = async (toolName, inputData, options) => {
         const toolUseId = options.toolUseID;
         if (toolName === EXIT_PLAN_MODE_TOOL_NAME) {
             const existing = ensureToolCallVisible(session, toolUseId, toolName, inputData);
             return await requestExitPlanModeApproval(session, toolUseId, inputData, existing);
         }
-        logPermissionDebug(`request tool_use_id=${toolUseId} tool=${toolName} blocked_path=${options.blockedPath ?? "<none>"} ` +
-            `decision_reason=${options.decisionReason ?? "<none>"} suggestions=${formatPermissionUpdates(options.suggestions)}`);
         const existing = ensureToolCallVisible(session, toolUseId, toolName, inputData);
         if (toolName === ASK_USER_QUESTION_TOOL_NAME) {
             return await requestAskUserQuestionAnswers(session, toolUseId, inputData, existing);
         }
+        const display = permissionDisplayFromCanUseOptions(options);
         const request = {
             tool_call: existing,
             options: permissionOptionsFromSuggestions(options.suggestions),
+            ...(display ? { display } : {}),
         };
-        writeEvent({ event: "permission_request", session_id: session.sessionId, request });
+        bridgeLogger.info({
+            target: LOG_TARGETS.BRIDGE_PERMISSION,
+            eventName: "permission_request_created",
+            message: "permission request created",
+            outcome: "start",
+            sessionId: session.sessionId,
+            toolCallId: toolUseId,
+            count: request.options.length,
+            fields: {
+                tool_name: toolName,
+                agent_id: options.agentID,
+                blocked_path: options.blockedPath ?? "<none>",
+                decision_reason: options.decisionReason ?? "<none>",
+            },
+        });
+        emitPermissionRequestEvent(session.sessionId, request);
         return await new Promise((resolve) => {
             session.pendingPermissions.set(toolUseId, {
                 resolve,
@@ -89,6 +265,21 @@ export async function createSession(params) {
         throw new Error(`CLAUDE_CODE_EXECUTABLE does not exist: ${claudeCodeExecutable}`);
     }
     let queryHandle;
+    bridgeLogger.info({
+        target: LOG_TARGETS.APP_SESSION,
+        eventName: "session_create_started",
+        message: "session creation started",
+        outcome: "start",
+        ...(params.requestId ? { requestId: params.requestId } : {}),
+        sessionId: provisionalSessionId,
+        fields: {
+            cwd: params.cwd,
+            connect_event: params.connectEvent,
+            resume_requested: params.resume !== undefined,
+            history_update_count: historyUpdateCount,
+            stale_session_count: staleSessionCount,
+        },
+    });
     try {
         queryHandle = query({
             prompt: input,
@@ -103,12 +294,26 @@ export async function createSession(params) {
                 sdkDebugFile,
                 enableSdkDebug,
                 enableSpawnDebug,
-                sessionIdForLogs: () => session.sessionId,
+                sessionIdForLogs,
             }),
         });
+        attachRequestUserDialogInterceptor(queryHandle, sessionIdForLogs);
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
+        bridgeLogger.error({
+            target: LOG_TARGETS.APP_SESSION,
+            eventName: "session_query_failed",
+            message: "session query creation failed",
+            outcome: "failure",
+            ...(params.requestId ? { requestId: params.requestId } : {}),
+            sessionId: provisionalSessionId,
+            fields: {
+                cwd: params.cwd,
+                resume_requested: params.resume !== undefined,
+                error_message: message,
+            },
+        });
         throw new Error(`query() failed: node_executable=${process.execPath}; cwd=${params.cwd}; ` +
             `resume=${params.resume ?? "<none>"}; ` +
             `CLAUDE_CODE_EXECUTABLE=${claudeCodeExecutable ?? "<unset>"}; error=${message}`);
@@ -117,8 +322,12 @@ export async function createSession(params) {
         sessionId: provisionalSessionId,
         cwd: params.cwd,
         model: initialModel,
+        ...(initialModel ? { requestedModelId: initialModel } : {}),
         availableModels: [],
         mode: initialMode,
+        supportedModeIds: [],
+        runtimeUnavailableModeIds: [],
+        supportsBypassPermissionsMode,
         fastModeState: "off",
         query: queryHandle,
         input,
@@ -139,23 +348,76 @@ export async function createSession(params) {
             ? { sessionsToCloseAfterConnect: params.sessionsToCloseAfterConnect }
             : {}),
     };
+    refreshCurrentModel(session);
+    const { refreshSupportedModesForSession } = await import("./commands.js");
+    refreshSupportedModesForSession(session);
     sessions.set(provisionalSessionId, session);
+    bridgeLogger.info({
+        target: LOG_TARGETS.APP_SESSION,
+        eventName: "session_query_started",
+        message: "session query started",
+        outcome: "success",
+        ...(params.requestId ? { requestId: params.requestId } : {}),
+        sessionId: session.sessionId,
+        fields: {
+            cwd: session.cwd,
+            connect_event: session.connectEvent,
+            resume_requested: params.resume !== undefined,
+        },
+    });
+    bridgeLogger.info({
+        target: LOG_TARGETS.APP_SESSION,
+        eventName: "session_create_registered",
+        message: "session registered in bridge state",
+        outcome: "success",
+        ...(params.requestId ? { requestId: params.requestId } : {}),
+        sessionId: session.sessionId,
+        count: sessions.size,
+        fields: {
+            active_session_count: sessions.size,
+            connect_event: session.connectEvent,
+        },
+    });
     // 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
         .initializationResult()
-        .then((result) => {
+        .then(async (result) => {
+        bridgeLogger.info({
+            target: LOG_TARGETS.APP_SESSION,
+            eventName: "session_initialization_completed",
+            message: "session initialization completed",
+            outcome: "success",
+            ...(session.connectRequestId ? { requestId: session.connectRequestId } : {}),
+            sessionId: session.sessionId,
+            fields: {
+                available_model_count: Array.isArray(result.models) ? result.models.length : 0,
+                connect_event: session.connectEvent,
+                history_update_count: session.resumeUpdates?.length ?? 0,
+            },
+        });
         session.availableModels = mapAvailableModels(result.models);
+        const currentModelChanged = refreshCurrentModel(session);
+        const { buildModeState, refreshSupportedModesForSession } = await import("./commands.js");
+        refreshSupportedModesForSession(session);
         if (!session.connected) {
             emitConnectEvent(session);
         }
+        else {
+            if (currentModelChanged) {
+                emitCurrentModelUpdate(session);
+            }
+            if (session.mode) {
+                emitSessionUpdate(session.sessionId, {
+                    type: "mode_state_update",
+                    mode: buildModeState(session, session.mode),
+                });
+            }
+        }
         // Proactively detect missing auth from account info so the UI can
         // show the login hint immediately, without waiting for the first prompt.
-        const acct = result.account;
-        const hasCredentials = (typeof acct.email === "string" && acct.email.trim().length > 0) ||
-            (typeof acct.apiKeySource === "string" && acct.apiKeySource.trim().length > 0);
-        if (!hasCredentials) {
+        if (shouldEmitStartupAuthRequiredForAccount(result.account)) {
             emitAuthRequired(session);
         }
         emitFastModeUpdateIfChanged(session, result.fast_mode_state);
@@ -177,6 +439,15 @@ export async function createSession(params) {
             return;
         }
         const message = error instanceof Error ? error.message : String(error);
+        bridgeLogger.error({
+            target: LOG_TARGETS.APP_SESSION,
+            eventName: "session_initialization_failed",
+            message: "session initialization failed before connect",
+            outcome: "failure",
+            ...(session.connectRequestId ? { requestId: session.connectRequestId } : {}),
+            sessionId: session.sessionId,
+            fields: { error_message: message },
+        });
         failConnection(`agent initialization failed: ${message}`, session.connectRequestId);
         session.connectRequestId = undefined;
     });
@@ -188,21 +459,81 @@ export async function createSession(params) {
                 handleSdkMessage(session, message);
             }
             if (!session.connected) {
+                bridgeLogger.error({
+                    target: LOG_TARGETS.APP_SESSION,
+                    eventName: "session_stream_ended_before_connect",
+                    message: "session stream ended before connect",
+                    outcome: "failure",
+                    ...(params.requestId ? { requestId: params.requestId } : {}),
+                    sessionId: session.sessionId,
+                });
                 failConnection("agent stream ended before session initialization", params.requestId);
             }
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
+            bridgeLogger.error({
+                target: LOG_TARGETS.APP_SESSION,
+                eventName: "session_stream_failed_before_connect",
+                message: "session stream failed before connect",
+                outcome: "failure",
+                ...(params.requestId ? { requestId: params.requestId } : {}),
+                sessionId: session.sessionId,
+                fields: { error_message: message },
+            });
             failConnection(`agent stream failed: ${message}`, params.requestId);
         }
     })();
 }
+function logSdkProcessSpawnStarted(options, includeArgsPreview) {
+    bridgeLogger.info({
+        target: LOG_TARGETS.BRIDGE_SDK,
+        eventName: "sdk_spawn_started",
+        message: "spawning Claude Code process",
+        outcome: "start",
+        fields: {
+            command: options.command,
+            cwd: options.cwd ?? "<none>",
+            arg_count: options.args.length,
+            ...(includeArgsPreview ? { args_preview: options.args.slice(0, 5) } : {}),
+        },
+    });
+}
+function logSdkProcessSpawned(sessionId, child, cwd) {
+    bridgeLogger.info({
+        target: LOG_TARGETS.BRIDGE_SDK,
+        eventName: "sdk_spawned",
+        message: "Claude Code process spawned",
+        outcome: "success",
+        ...(sessionId ? { sessionId } : {}),
+        fields: {
+            cwd: cwd ?? "<none>",
+            pid: child.pid ?? "<none>",
+        },
+    });
+}
+function logSdkProcessExit(sessionId, code, signal) {
+    const exitedCleanly = code === 0 && signal === null;
+    const logger = exitedCleanly ? bridgeLogger.info : bridgeLogger.warn;
+    logger({
+        target: LOG_TARGETS.BRIDGE_SDK,
+        eventName: "sdk_process_exited",
+        message: "Claude Code process exited",
+        outcome: exitedCleanly ? "success" : "failure",
+        ...(sessionId ? { sessionId } : {}),
+        fields: {
+            exit_code: code ?? "<none>",
+            exit_signal: signal ?? "<none>",
+        },
+    });
+}
 function permissionModeFromSettingsValue(rawMode) {
     if (typeof rawMode !== "string") {
         return undefined;
     }
     switch (rawMode) {
         case "default":
+        case "auto":
         case "acceptEdits":
         case "bypassPermissions":
         case "plan":
@@ -261,12 +592,14 @@ export function buildQueryOptions(params) {
     const systemPrompt = systemPromptFromLaunchSettings(params.launchSettings);
     const modelOption = startupModelOption(params.launchSettings);
     const permissionModeOptions = startupPermissionModeOptions(params.launchSettings);
+    const settings = normalizedSettingsFromLaunchSettings(params.launchSettings);
     return {
         cwd: params.cwd,
         includePartialMessages: true,
+        promptSuggestions: true,
         executable: "node",
         ...(params.resume ? {} : { sessionId: params.provisionalSessionId }),
-        ...(params.launchSettings.settings ? { settings: params.launchSettings.settings } : {}),
+        ...(settings ? { settings } : {}),
         ...modelOption,
         ...permissionModeOptions,
         toolConfig: { askUserQuestion: { previewFormat: "markdown" } },
@@ -281,28 +614,37 @@ export function buildQueryOptions(params) {
         ...(params.sdkDebugFile ? { debugFile: params.sdkDebugFile } : {}),
         stderr: (line) => {
             if (line.trim().length > 0) {
-                console.error(`[sdk stderr] ${line}`);
+                logSdkStderrLine(line);
             }
         },
-        ...(params.enableSpawnDebug
-            ? {
-                spawnClaudeCodeProcess: (options) => {
-                    console.error(`[sdk spawn] command=${options.command} args=${JSON.stringify(options.args)} cwd=${options.cwd ?? "<none>"}`);
-                    const child = spawnChild(options.command, options.args, {
-                        cwd: options.cwd,
-                        env: options.env,
-                        signal: options.signal,
-                        stdio: ["pipe", "pipe", "pipe"],
-                        windowsHide: true,
-                    });
-                    child.on("error", (error) => {
-                        console.error(`[sdk spawn error] code=${error.code ?? "<none>"} message=${error.message}`);
-                    });
-                    return child;
-                },
-            }
-            : {}),
-        // Match claude-agent-acp defaults to avoid emitting an empty
+        spawnClaudeCodeProcess: (options) => {
+            logSdkProcessSpawnStarted(options, params.enableSpawnDebug);
+            const child = spawnChild(options.command, options.args, {
+                cwd: options.cwd,
+                env: options.env,
+                signal: options.signal,
+                stdio: ["pipe", "pipe", "pipe"],
+                windowsHide: true,
+            });
+            logSdkProcessSpawned(params.sessionIdForLogs() || undefined, child, options.cwd);
+            child.on("error", (error) => {
+                const sessionId = params.sessionIdForLogs();
+                bridgeLogger.error({
+                    target: LOG_TARGETS.BRIDGE_SDK,
+                    eventName: "sdk_spawn_failed",
+                    message: "Claude Code process spawn failed",
+                    outcome: "failure",
+                    ...(sessionId ? { sessionId } : {}),
+                    errorCode: error.code ?? "<none>",
+                    fields: { error_message: error.message },
+                });
+            });
+            child.on("exit", (code, signal) => {
+                logSdkProcessExit(params.sessionIdForLogs() || undefined, code, signal);
+            });
+            return child;
+        },
+        // Match the Claude Code CLI defaults to avoid emitting an empty
         // --setting-sources argument.
         settingSources: DEFAULT_SETTING_SOURCES,
         resume: params.resume,
@@ -333,14 +675,32 @@ export function buildQueryOptions(params) {
                     ? { requested_schema: request.requestedSchema }
                     : {}),
             };
-            writeEvent({
-                event: "elicitation_request",
-                session_id: params.sessionIdForLogs(),
-                request: normalized,
+            bridgeLogger.info({
+                target: LOG_TARGETS.BRIDGE_PERMISSION,
+                eventName: "elicitation_request_created",
+                message: "elicitation request created",
+                outcome: "start",
+                sessionId: params.sessionIdForLogs(),
+                requestId,
+                fields: {
+                    server_name: normalized.server_name,
+                    mode: normalized.mode,
+                    has_url: normalized.url !== undefined,
+                },
             });
+            emitElicitationRequestEvent(params.sessionIdForLogs(), normalized);
             return await new Promise((resolve) => {
                 const currentSession = sessions.get(params.sessionIdForLogs());
                 if (!currentSession) {
+                    bridgeLogger.warn({
+                        target: LOG_TARGETS.BRIDGE_PERMISSION,
+                        eventName: "elicitation_request_dropped",
+                        message: "elicitation request dropped without an active session",
+                        outcome: "dropped",
+                        sessionId: params.sessionIdForLogs(),
+                        requestId,
+                        fields: { reason: "unknown_session" },
+                    });
                     resolve({ action: "cancel" });
                     return;
                 }
@@ -386,29 +746,76 @@ export function mapAvailableModels(models) {
     }));
 }
 export function handlePermissionResponse(command) {
+    bridgeLogger.info({
+        target: LOG_TARGETS.BRIDGE_PERMISSION,
+        eventName: "permission_response_received",
+        message: "permission response received",
+        outcome: "success",
+        sessionId: command.session_id,
+        toolCallId: command.tool_call_id,
+        fields: {
+            response_kind: command.outcome.outcome,
+            selected_option: command.outcome.outcome === "selected" ? command.outcome.option_id : "cancelled",
+        },
+    });
     const session = sessionById(command.session_id);
     if (!session) {
-        logPermissionDebug(`response dropped: unknown session session_id=${command.session_id} tool_call_id=${command.tool_call_id}`);
+        bridgeLogger.warn({
+            target: LOG_TARGETS.BRIDGE_PERMISSION,
+            eventName: "permission_response_dropped",
+            message: "permission response dropped for unknown session",
+            outcome: "dropped",
+            sessionId: command.session_id,
+            toolCallId: command.tool_call_id,
+            fields: { reason: "unknown_session" },
+        });
         return;
     }
     const resolver = session.pendingPermissions.get(command.tool_call_id);
     if (!resolver) {
-        logPermissionDebug(`response dropped: no pending resolver session_id=${command.session_id} tool_call_id=${command.tool_call_id}`);
+        bridgeLogger.warn({
+            target: LOG_TARGETS.BRIDGE_PERMISSION,
+            eventName: "permission_response_dropped",
+            message: "permission response dropped without a pending resolver",
+            outcome: "dropped",
+            sessionId: command.session_id,
+            toolCallId: command.tool_call_id,
+            fields: { reason: "missing_pending_resolver" },
+        });
         return;
     }
     session.pendingPermissions.delete(command.tool_call_id);
     const outcome = command.outcome;
     if (resolver.onOutcome) {
+        bridgeLogger.info({
+            target: LOG_TARGETS.BRIDGE_PERMISSION,
+            eventName: "permission_response_applied",
+            message: "permission response applied to outcome callback",
+            outcome: "success",
+            sessionId: command.session_id,
+            toolCallId: command.tool_call_id,
+            fields: {
+                tool_name: resolver.toolName,
+                response_kind: outcome.outcome,
+                selected_option: outcome.outcome === "selected" ? outcome.option_id : "cancelled",
+            },
+        });
         resolver.onOutcome(outcome);
         return;
     }
     if (!resolver.resolve) {
-        logPermissionDebug(`response dropped: resolver missing callback session_id=${command.session_id} tool_call_id=${command.tool_call_id}`);
+        bridgeLogger.warn({
+            target: LOG_TARGETS.BRIDGE_PERMISSION,
+            eventName: "permission_response_dropped",
+            message: "permission response dropped because resolver callback was missing",
+            outcome: "dropped",
+            sessionId: command.session_id,
+            toolCallId: command.tool_call_id,
+            fields: { reason: "missing_resolver_callback" },
+        });
         return;
     }
     const selectedOption = outcome.outcome === "selected" ? outcome.option_id : "cancelled";
-    logPermissionDebug(`response session_id=${command.session_id} tool_call_id=${command.tool_call_id} tool=${resolver.toolName} ` +
-        `selected=${selectedOption} suggestions=${formatPermissionUpdates(resolver.suggestions)}`);
     if (outcome.outcome === "selected" &&
         (outcome.option_id === "allow_once" ||
             outcome.option_id === "allow_session" ||
@@ -422,45 +829,354 @@ export function handlePermissionResponse(command) {
         setToolCallStatus(session, command.tool_call_id, "failed", "Permission cancelled");
     }
     const permissionResult = permissionResultFromOutcome(outcome, command.tool_call_id, resolver.inputData, resolver.suggestions, resolver.toolName);
-    if (permissionResult.behavior === "allow") {
-        logPermissionDebug(`result tool_call_id=${command.tool_call_id} behavior=allow updated_permissions=` +
-            `${formatPermissionUpdates(permissionResult.updatedPermissions)}`);
-    }
-    else {
-        logPermissionDebug(`result tool_call_id=${command.tool_call_id} behavior=deny message=${permissionResult.message}`);
-    }
+    bridgeLogger.info({
+        target: LOG_TARGETS.BRIDGE_PERMISSION,
+        eventName: "permission_response_applied",
+        message: "permission response applied",
+        outcome: "success",
+        sessionId: command.session_id,
+        toolCallId: command.tool_call_id,
+        fields: {
+            tool_name: resolver.toolName,
+            response_kind: outcome.outcome,
+            selected_option: selectedOption,
+            behavior: permissionResult.behavior,
+        },
+    });
     resolver.resolve(permissionResult);
 }
 export function handleQuestionResponse(command) {
+    bridgeLogger.info({
+        target: LOG_TARGETS.BRIDGE_PERMISSION,
+        eventName: "question_response_received",
+        message: "question response received",
+        outcome: "success",
+        sessionId: command.session_id,
+        toolCallId: command.tool_call_id,
+        fields: { response_kind: command.outcome.outcome },
+    });
     const session = sessionById(command.session_id);
     if (!session) {
-        logPermissionDebug(`question response dropped: unknown session session_id=${command.session_id} tool_call_id=${command.tool_call_id}`);
+        bridgeLogger.warn({
+            target: LOG_TARGETS.BRIDGE_PERMISSION,
+            eventName: "question_response_dropped",
+            message: "question response dropped for unknown session",
+            outcome: "dropped",
+            sessionId: command.session_id,
+            toolCallId: command.tool_call_id,
+            fields: { reason: "unknown_session" },
+        });
         return;
     }
     const resolver = session.pendingQuestions.get(command.tool_call_id);
     if (!resolver) {
-        logPermissionDebug(`question response dropped: no pending resolver session_id=${command.session_id} tool_call_id=${command.tool_call_id}`);
+        bridgeLogger.warn({
+            target: LOG_TARGETS.BRIDGE_PERMISSION,
+            eventName: "question_response_dropped",
+            message: "question response dropped without a pending resolver",
+            outcome: "dropped",
+            sessionId: command.session_id,
+            toolCallId: command.tool_call_id,
+            fields: { reason: "missing_pending_resolver" },
+        });
         return;
     }
     session.pendingQuestions.delete(command.tool_call_id);
+    bridgeLogger.info({
+        target: LOG_TARGETS.BRIDGE_PERMISSION,
+        eventName: "question_response_applied",
+        message: "question response applied",
+        outcome: "success",
+        sessionId: command.session_id,
+        toolCallId: command.tool_call_id,
+        fields: {
+            tool_name: resolver.toolName,
+            response_kind: command.outcome.outcome,
+            selected_option_count: command.outcome.outcome === "answered" ? command.outcome.selected_option_ids.length : 0,
+            has_annotation: command.outcome.outcome === "answered" && command.outcome.annotation !== undefined,
+        },
+    });
     resolver.onOutcome(command.outcome);
 }
 export function handleElicitationResponse(command) {
+    bridgeLogger.info({
+        target: LOG_TARGETS.BRIDGE_PERMISSION,
+        eventName: "elicitation_response_received",
+        message: "elicitation response received",
+        outcome: "success",
+        sessionId: command.session_id,
+        requestId: command.elicitation_request_id,
+        fields: {
+            action: command.action,
+            has_content: command.content !== undefined,
+        },
+    });
     const session = sessionById(command.session_id);
     if (!session) {
-        console.error(`[sdk warn] elicitation response dropped: unknown session ` +
-            `session_id=${command.session_id} request_id=${command.elicitation_request_id}`);
+        bridgeLogger.warn({
+            target: LOG_TARGETS.BRIDGE_PERMISSION,
+            eventName: "elicitation_response_dropped",
+            message: "elicitation response dropped for unknown session",
+            outcome: "dropped",
+            sessionId: command.session_id,
+            requestId: command.elicitation_request_id,
+            fields: { reason: "unknown_session" },
+        });
         return;
     }
     const pending = session.pendingElicitations.get(command.elicitation_request_id);
     if (!pending) {
-        console.error(`[sdk warn] elicitation response dropped: no pending request ` +
-            `session_id=${command.session_id} request_id=${command.elicitation_request_id}`);
+        bridgeLogger.warn({
+            target: LOG_TARGETS.BRIDGE_PERMISSION,
+            eventName: "elicitation_response_dropped",
+            message: "elicitation response dropped without pending request",
+            outcome: "dropped",
+            sessionId: command.session_id,
+            requestId: command.elicitation_request_id,
+            fields: { reason: "missing_pending_request" },
+        });
         return;
     }
     session.pendingElicitations.delete(command.elicitation_request_id);
+    bridgeLogger.info({
+        target: LOG_TARGETS.BRIDGE_PERMISSION,
+        eventName: "elicitation_response_applied",
+        message: "elicitation response applied",
+        outcome: "success",
+        sessionId: command.session_id,
+        requestId: command.elicitation_request_id,
+        fields: {
+            action: command.action,
+            server_name: pending.serverName,
+            has_content: command.content !== undefined,
+        },
+    });
     pending.resolve({
         action: command.action,
-        ...(command.content ? { content: command.content } : {}),
+        ...(normalizeSdkElicitationContent(command.content) ? {
+            content: normalizeSdkElicitationContent(command.content),
+        } : {}),
+    });
+}
+function normalizeModelKey(id) {
+    const original = id.trim();
+    if (!original || original === DEFAULT_MODEL_NAME) {
+        return { original, family: "default", versionParts: [], variantParts: [] };
+    }
+    const lower = original.toLowerCase();
+    const contextMatch = lower.match(/\[([^\]]+)\]$/);
+    const contextSuffix = contextMatch?.[1];
+    const withoutContext = contextMatch ? lower.slice(0, contextMatch.index) : lower;
+    const withoutPrefix = withoutContext.startsWith("claude-")
+        ? withoutContext.slice("claude-".length)
+        : withoutContext;
+    const parts = withoutPrefix.split("-").filter((part) => part.length > 0);
+    const familyPart = parts[0] ?? "";
+    const family = familyPart === "opus" || familyPart === "sonnet" || familyPart === "haiku"
+        ? familyPart
+        : "unknown";
+    const versionParts = family === "unknown"
+        ? []
+        : parts
+            .slice(1)
+            .filter((part) => /^\d+$/.test(part))
+            .map((part) => Number.parseInt(part, 10))
+            .filter((part) => Number.isFinite(part));
+    const variantParts = family === "unknown"
+        ? []
+        : parts
+            .slice(1)
+            .filter((part) => !/^\d+$/.test(part));
+    return {
+        original,
+        family,
+        versionParts,
+        variantParts,
+        ...(contextSuffix ? { contextSuffix } : {}),
+    };
+}
+function modelKeysAreCompatible(leftId, rightId) {
+    const left = normalizeModelKey(leftId);
+    const right = normalizeModelKey(rightId);
+    if (left.family === "default" || right.family === "default") {
+        return false;
+    }
+    if (left.family === "unknown" || right.family === "unknown") {
+        return left.original.toLowerCase() === right.original.toLowerCase();
+    }
+    if (left.family !== right.family) {
+        return false;
+    }
+    if (left.variantParts.join(".") !== right.variantParts.join(".")) {
+        return false;
+    }
+    if (left.versionParts.length === 0 || right.versionParts.length === 0) {
+        return true;
+    }
+    return left.versionParts.join(".") === right.versionParts.join(".");
+}
+function sameContextSuffix(leftId, rightId) {
+    const left = normalizeModelKey(leftId);
+    const right = normalizeModelKey(rightId);
+    return (left.contextSuffix?.toLowerCase() ?? "") === (right.contextSuffix?.toLowerCase() ?? "");
+}
+function sameFamilyAndVersion(leftId, rightId) {
+    const left = normalizeModelKey(leftId);
+    const right = normalizeModelKey(rightId);
+    if (left.family === "default" || right.family === "default") {
+        return false;
+    }
+    if (left.family === "unknown" || right.family === "unknown") {
+        return left.original.toLowerCase() === right.original.toLowerCase();
+    }
+    if (left.family !== right.family) {
+        return false;
+    }
+    if (left.versionParts.length === 0 || right.versionParts.length === 0) {
+        return left.versionParts.length === right.versionParts.length;
+    }
+    return left.versionParts.join(".") === right.versionParts.join(".");
+}
+function hasVariantSiblingConflict(availableModels, candidateId, resolvedId) {
+    if (sameContextSuffix(candidateId, resolvedId)) {
+        return false;
+    }
+    const resolvedContext = normalizeModelKey(resolvedId).contextSuffix?.toLowerCase() ?? "";
+    if (!resolvedContext) {
+        return false;
+    }
+    return availableModels.some((entry) => {
+        if (entry.id === candidateId) {
+            return false;
+        }
+        if (!sameFamilyAndVersion(entry.id, resolvedId)) {
+            return false;
+        }
+        const entryContext = normalizeModelKey(entry.id).contextSuffix?.toLowerCase() ?? "";
+        return entryContext === resolvedContext;
+    });
+}
+function humanizeModelId(id) {
+    const normalized = normalizeModelKey(id);
+    if (normalized.family === "default") {
+        return "Default";
+    }
+    if (normalized.family === "unknown") {
+        return id;
+    }
+    const familyLabel = normalized.family === "opus"
+        ? "Opus"
+        : normalized.family === "sonnet"
+            ? "Sonnet"
+            : "Haiku";
+    const versionLabel = normalized.versionParts.length > 0 ? ` ${normalized.versionParts.join(".")}` : "";
+    const contextLabel = normalized.contextSuffix?.toLowerCase() === "1m"
+        ? " [1M]"
+        : normalized.contextSuffix
+            ? ` [${normalized.contextSuffix}]`
+            : "";
+    return `${familyLabel}${versionLabel}${contextLabel}`;
+}
+function shortDisplayNameForModelId(id) {
+    const normalized = normalizeModelKey(id);
+    if (normalized.family === "default") {
+        return "Default";
+    }
+    if (normalized.family === "unknown") {
+        return id;
+    }
+    const familyLabel = normalized.family === "opus"
+        ? "Opus"
+        : normalized.family === "sonnet"
+            ? "Sonnet"
+            : "Haiku";
+    const contextLabel = normalized.contextSuffix?.toLowerCase() === "1m"
+        ? " [1M]"
+        : normalized.contextSuffix
+            ? ` [${normalized.contextSuffix}]`
+            : "";
+    return `${familyLabel}${contextLabel}`;
+}
+function currentModelIsAuthoritative(resolvedId, requestedId) {
+    const resolved = resolvedId.trim();
+    if (!resolved || resolved === DEFAULT_MODEL_NAME || resolved === "Connecting...") {
+        return Boolean(requestedId?.trim() && requestedId.trim() !== DEFAULT_MODEL_NAME);
+    }
+    return true;
+}
+function resolveCatalogModel(availableModels, resolvedId, requestedId) {
+    const exactResolved = availableModels.find((entry) => entry.id === resolvedId);
+    if (exactResolved) {
+        return exactResolved;
+    }
+    if (requestedId) {
+        const exactRequested = availableModels.find((entry) => entry.id === requestedId);
+        if (exactRequested &&
+            modelKeysAreCompatible(exactRequested.id, resolvedId) &&
+            !hasVariantSiblingConflict(availableModels, exactRequested.id, resolvedId)) {
+            return exactRequested;
+        }
+    }
+    const compatible = availableModels.filter((entry) => modelKeysAreCompatible(entry.id, resolvedId) &&
+        !hasVariantSiblingConflict(availableModels, entry.id, resolvedId));
+    return compatible.length === 1 ? compatible[0] : undefined;
+}
+export function resolveCurrentModel(session) {
+    const requestedId = session.requestedModelId?.trim() || undefined;
+    const resolvedId = session.resolvedRuntimeModelId?.trim() ||
+        session.model.trim() ||
+        requestedId ||
+        DEFAULT_MODEL_NAME;
+    const catalogModel = resolveCatalogModel(session.availableModels, resolvedId, requestedId);
+    const runtimeDisplayId = resolvedId || requestedId || DEFAULT_MODEL_NAME;
+    const displayNameShort = shortDisplayNameForModelId(runtimeDisplayId);
+    const displayNameLong = humanizeModelId(runtimeDisplayId);
+    const currentModel = {
+        resolved_id: resolvedId,
+        display_name_short: displayNameShort,
+        display_name_long: displayNameLong,
+        supports_effort: catalogModel?.supports_effort === true,
+        supported_effort_levels: catalogModel?.supported_effort_levels ?? [],
+        is_authoritative: currentModelIsAuthoritative(resolvedId, requestedId),
+        ...(requestedId ? { requested_id: requestedId } : {}),
+        ...(catalogModel ? { catalog_id: catalogModel.id } : {}),
+        ...(catalogModel?.supports_fast_mode !== undefined
+            ? { supports_fast_mode: catalogModel.supports_fast_mode }
+            : {}),
+        ...(catalogModel?.supports_auto_mode !== undefined
+            ? { supports_auto_mode: catalogModel.supports_auto_mode }
+            : {}),
+        ...(catalogModel?.supports_adaptive_thinking !== undefined
+            ? { supports_adaptive_thinking: catalogModel.supports_adaptive_thinking }
+            : {}),
+    };
+    return currentModel;
+}
+export function shouldInvalidateResolvedRuntimeModel(previousRequestedId, previousSessionModel, nextRequestedId) {
+    const previousRequested = previousRequestedId?.trim() || previousSessionModel.trim();
+    return previousRequested !== nextRequestedId.trim();
+}
+function currentModelsEqual(left, right) {
+    return JSON.stringify(left) === JSON.stringify(right);
+}
+export function emitCurrentModelUpdate(session) {
+    if (!session.connected || !session.currentModel) {
+        return false;
+    }
+    emitSessionUpdate(session.sessionId, {
+        type: "current_model_update",
+        current_model: session.currentModel,
     });
+    return true;
+}
+export function refreshCurrentModel(session, emitUpdate = false) {
+    const nextModel = resolveCurrentModel(session);
+    if (currentModelsEqual(session.currentModel, nextModel)) {
+        return false;
+    }
+    session.currentModel = nextModel;
+    if (emitUpdate) {
+        emitCurrentModelUpdate(session);
+    }
+    return true;
 }