claude-code-rust 0.14.0 → 0.14.2

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

@@ -0,0 +1,269 @@
+import { buildModeState, markModeUnavailableForSession, permissionModeFailureLooksUnsupported, refreshSupportedModesForSession, toPermissionMode, } from "./commands.js";
+import { dispatchCancelTurnCommand } from "./command_dispatch.js";
+import { emitFastModeUpdate } from "./error_classification.js";
+import { emitSessionUpdate, slashError } from "./events.js";
+import { bridgeLogger, LOG_TARGETS } from "./logger.js";
+import { emitCurrentModelUpdate, refreshCurrentModel, sessionById, shouldInvalidateResolvedRuntimeModel, } from "./session_lifecycle.js";
+export async function handleSessionControlCommand(command, requestId, deps) {
+    switch (command.command) {
+        case "prompt":
+            handlePrompt(command, requestId, deps);
+            return;
+        case "cancel_turn":
+            await dispatchCancelTurnCommand(command, { requestId, sessionById, slashError });
+            return;
+        case "set_model":
+            await setModel(command, requestId);
+            return;
+        case "set_mode":
+            await setMode(command, requestId);
+            return;
+        case "set_effort":
+            await setEffort(command, requestId, deps);
+            return;
+        case "set_agent":
+            await setAgent(command, requestId, deps);
+            return;
+        case "set_fast_mode":
+            await setFastMode(command, requestId, deps);
+            return;
+        case "reload_plugins":
+            await reloadPlugins(command, requestId, deps);
+    }
+}
+function handlePrompt(command, requestId, deps) {
+    const session = requireSession(command.session_id, requestId);
+    if (!session) {
+        return;
+    }
+    const message = deps.buildPromptUserMessage(command, session.sessionId);
+    if (message) {
+        session.input.enqueue(message);
+    }
+}
+async function setModel(command, requestId) {
+    const session = requireSession(command.session_id, requestId);
+    if (!session) {
+        return;
+    }
+    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);
+    }
+}
+async function setMode(command, requestId) {
+    const session = requireSession(command.session_id, requestId);
+    if (!session) {
+        return;
+    }
+    const mode = toPermissionMode(command.mode);
+    if (!mode) {
+        slashError(command.session_id, `unsupported mode: ${command.mode}`, requestId);
+        return;
+    }
+    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);
+    }
+}
+async function setEffort(command, requestId, deps) {
+    const session = requireSession(command.session_id, requestId);
+    if (!session) {
+        return;
+    }
+    try {
+        await deps.applySessionEffort(session.query, command.effort);
+        deps.emitEffortConfigOptionUpdate(session.sessionId, command.effort);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        slashError(command.session_id, `failed to set effort: ${message}`, requestId);
+    }
+}
+async function setAgent(command, requestId, deps) {
+    const session = requireSession(command.session_id, requestId);
+    if (!session) {
+        return;
+    }
+    try {
+        await deps.applySessionAgent(session.query, command.agent);
+        deps.emitAgentConfigOptionUpdate(session.sessionId, command.agent);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        slashError(command.session_id, `failed to set agent: ${message}`, requestId);
+    }
+}
+async function setFastMode(command, requestId, deps) {
+    const session = requireSession(command.session_id, requestId);
+    if (!session) {
+        return;
+    }
+    bridgeLogger.info({
+        target: LOG_TARGETS.APP_SESSION,
+        eventName: "set_fast_mode_started",
+        message: "set fast mode started",
+        outcome: "start",
+        sessionId: session.sessionId,
+        requestId,
+        fields: {
+            requested_enabled: command.enabled,
+            previous_state: session.fastModeState,
+        },
+    });
+    try {
+        const snapshot = await deps.applySessionFastMode(session.query, command.enabled);
+        const state = snapshot.state;
+        session.fastModeState = state;
+        session.fastModeDisabledReason = snapshot.disabled_reason;
+        emitFastModeUpdate(session);
+        const reportedEnabled = state !== "off";
+        if (reportedEnabled !== command.enabled) {
+            bridgeLogger.warn({
+                target: LOG_TARGETS.APP_SESSION,
+                eventName: "set_fast_mode_mismatch",
+                message: "SDK reported a fast-mode state that did not match the request",
+                outcome: "failure",
+                sessionId: session.sessionId,
+                requestId,
+                fields: {
+                    requested_enabled: command.enabled,
+                    reported_state: state,
+                },
+            });
+            const action = command.enabled ? "enable" : "disable";
+            slashError(command.session_id, `failed to ${action} fast mode: SDK reported state ${state}`, requestId);
+            return;
+        }
+        bridgeLogger.info({
+            target: LOG_TARGETS.APP_SESSION,
+            eventName: "set_fast_mode_succeeded",
+            message: "set fast mode completed",
+            outcome: "success",
+            sessionId: session.sessionId,
+            requestId,
+            fields: {
+                requested_enabled: command.enabled,
+                reported_state: state,
+            },
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        bridgeLogger.warn({
+            target: LOG_TARGETS.APP_SESSION,
+            eventName: "set_fast_mode_failed",
+            message: "set fast mode failed",
+            outcome: "failure",
+            sessionId: session.sessionId,
+            requestId,
+            fields: {
+                requested_enabled: command.enabled,
+                previous_state: session.fastModeState,
+                error_message: message,
+            },
+        });
+        slashError(command.session_id, `failed to set fast mode: ${message}`, requestId);
+    }
+}
+async function reloadPlugins(command, requestId, deps) {
+    const session = requireSession(command.session_id, requestId);
+    if (session) {
+        await deps.handleReloadPluginsCommand(session, requestId);
+    }
+}
+function requireSession(sessionId, requestId) {
+    const session = sessionById(sessionId);
+    if (!session) {
+        slashError(sessionId, `unknown session: ${sessionId}`, requestId);
+    }
+    return session;
+}

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

@@ -0,0 +1,203 @@
+import { getSessionMessages, renameSession, } from "@anthropic-ai/claude-agent-sdk";
+import { mapSdkAccountInfo } from "./account_metadata.js";
+import { emitSessionsList, setSessionListingDir, slashError, writeEvent, } from "./events.js";
+import { bridgeLogger, LOG_TARGETS } from "./logger.js";
+import { refreshCurrentModel, sessionById, } from "./session_lifecycle.js";
+export async function handleSessionDataCommand(command, requestId, deps) {
+    switch (command.command) {
+        case "generate_session_title":
+            await generateTitle(command, requestId, deps);
+            return;
+        case "rename_session":
+            await rename(command, requestId, deps);
+            return;
+        case "get_status_snapshot":
+            await getStatusSnapshot(command, requestId);
+            return;
+        case "get_context_usage":
+            await getContextUsage(command, requestId);
+            return;
+        case "get_rewind_targets":
+            await getRewindTargets(command, requestId, deps);
+            return;
+        case "rewind":
+            await deps.handleRewind(command, requestId);
+    }
+}
+async function generateTitle(command, requestId, deps) {
+    const session = requireSession(command.session_id, requestId);
+    if (!session) {
+        return;
+    }
+    try {
+        await deps.generatePersistedSessionTitle(session.query, command.description);
+        setSessionListingDir(session.cwd);
+        await emitSessionsList(requestId);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        slashError(command.session_id, `failed to generate session title: ${message}`, requestId);
+    }
+}
+async function rename(command, requestId, deps) {
+    const session = requireSession(command.session_id, requestId);
+    if (!session) {
+        return;
+    }
+    try {
+        await renameSession(command.session_id, command.title, deps.buildSessionMutationOptions(session.cwd));
+        setSessionListingDir(session.cwd);
+        await emitSessionsList(requestId);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        slashError(command.session_id, `failed to rename session: ${message}`, requestId);
+    }
+}
+async function getStatusSnapshot(command, requestId) {
+    const session = requireSession(command.session_id, requestId);
+    if (!session) {
+        return;
+    }
+    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: mapSdkAccountInfo(account),
+        }, 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;
+    }
+}
+async function getContextUsage(command, requestId) {
+    const session = requireSession(command.session_id, requestId);
+    if (!session) {
+        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);
+    }
+}
+async function getRewindTargets(command, requestId, deps) {
+    const session = requireSession(command.session_id, requestId);
+    if (!session) {
+        return;
+    }
+    try {
+        const historyMessages = await getSessionMessages(command.session_id, {
+            dir: session.cwd,
+            includeSystemMessages: true,
+        });
+        const targets = deps.rewindTargetsFromSessionMessages(historyMessages);
+        bridgeLogger.info({
+            target: LOG_TARGETS.APP_SESSION,
+            eventName: "rewind_targets_loaded",
+            message: "rewind targets loaded from session history",
+            outcome: "success",
+            ...(requestId ? { requestId } : {}),
+            sessionId: session.sessionId,
+            fields: {
+                history_message_count: historyMessages.length,
+                target_count: targets.length,
+            },
+        });
+        writeEvent({
+            event: "rewind_targets",
+            session_id: session.sessionId,
+            targets,
+        }, requestId);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        bridgeLogger.warn({
+            target: LOG_TARGETS.APP_SESSION,
+            eventName: "rewind_targets_failed",
+            message: "failed to load rewind targets",
+            outcome: "failure",
+            ...(requestId ? { requestId } : {}),
+            sessionId: session.sessionId,
+            fields: { error_message: message },
+        });
+        slashError(command.session_id, `failed to load rewind targets: ${message}`, requestId);
+    }
+}
+function requireSession(sessionId, requestId) {
+    const session = sessionById(sessionId);
+    if (!session) {
+        slashError(sessionId, `unknown session: ${sessionId}`, requestId);
+    }
+    return session;
+}

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

@@ -266,6 +266,12 @@ export function parseCommandEnvelope(line) {
                     session_id: expectString(raw, "session_id", "set_agent"),
                     agent: expectNonEmptyStringOrNull(raw, "agent", "set_agent"),
                 };
+            case "set_fast_mode":
+                return {
+                    command: "set_fast_mode",
+                    session_id: expectString(raw, "session_id", "set_fast_mode"),
+                    enabled: expectBoolean(raw, "enabled", "set_fast_mode"),
+                };
             case "generate_session_title":
                 return {
                     command: "generate_session_title",

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

@@ -1,7 +1,7 @@
 import { looksLikeAuthRequired } from "./auth.js";
 import { writeEvent } from "./events.js";
 import { emitSessionUpdate } from "./events.js";
-import { parseFastModeState } from "./state_parsing.js";
+import { parseFastModeDisabledReason, parseFastModeState } from "./state_parsing.js";
 export function emitAuthRequired(session, detail) {
     if (session.authHintSent) {
         return;
@@ -58,11 +58,28 @@ export function classifyTurnErrorKind(subtype, errors, assistantError) {
     }
     return "other";
 }
-export function emitFastModeUpdateIfChanged(session, value) {
-    const next = parseFastModeState(value);
-    if (!next || next === session.fastModeState) {
-        return;
+export function setFastModeSnapshotIfChanged(session, stateValue, disabledReasonValue) {
+    const nextState = parseFastModeState(stateValue) ?? session.fastModeState;
+    const nextDisabledReason = parseFastModeDisabledReason(disabledReasonValue);
+    if (nextState === session.fastModeState &&
+        nextDisabledReason === session.fastModeDisabledReason) {
+        return false;
+    }
+    session.fastModeState = nextState;
+    session.fastModeDisabledReason = nextDisabledReason;
+    return true;
+}
+export function emitFastModeUpdate(session) {
+    emitSessionUpdate(session.sessionId, {
+        type: "fast_mode_update",
+        fast_mode_state: session.fastModeState,
+        ...(session.fastModeDisabledReason
+            ? { fast_mode_disabled_reason: session.fastModeDisabledReason }
+            : {}),
+    });
+}
+export function emitFastModeUpdateIfChanged(session, stateValue, disabledReasonValue) {
+    if (setFastModeSnapshotIfChanged(session, stateValue, disabledReasonValue)) {
+        emitFastModeUpdate(session);
     }
-    session.fastModeState = next;
-    emitSessionUpdate(session.sessionId, { type: "fast_mode_update", fast_mode_state: next });
 }

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

@@ -1,10 +1,30 @@
 import { listSessions } from "@anthropic-ai/claude-agent-sdk";
+import { writeSync } from "node:fs";
 import { buildModeState } from "./commands.js";
 import { mapSdkSessions } from "./history.js";
 import { bridgeLogger, LOG_TARGETS, logBridgeEventSent } from "./logger.js";
-import { resolveCurrentModel } from "./session_lifecycle.js";
+import { detachSessionForClose, resolveCurrentModel, trackSessionCloseTask, } from "./session_lifecycle.js";
 const SESSION_LIST_LIMIT = 50;
 let sessionListingDir;
+function writeProtocolEventToStdout(line) {
+    const payload = Buffer.from(line);
+    let offset = 0;
+    while (offset < payload.length) {
+        const written = writeSync(process.stdout.fd, payload, offset, payload.length - offset);
+        if (written <= 0) {
+            throw new Error("bridge stdout write made no progress");
+        }
+        offset += written;
+    }
+}
+let protocolEventWriter = writeProtocolEventToStdout;
+export function replaceProtocolEventWriter(writer) {
+    const previous = protocolEventWriter;
+    protocolEventWriter = writer;
+    return () => {
+        protocolEventWriter = previous;
+    };
+}
 export function buildSessionListOptions(dir, limit = SESSION_LIST_LIMIT) {
     return dir
         ? { dir, includeProgrammatic: true, includeWorktrees: true, limit }
@@ -23,7 +43,7 @@ export function writeEvent(event, requestId) {
     };
     const serialized = JSON.stringify(envelope);
     logBridgeEventSent(event, requestId, Buffer.byteLength(serialized) + 1);
-    process.stdout.write(`${serialized}\n`);
+    protocolEventWriter(`${serialized}\n`);
 }
 export function failConnection(message, requestId) {
     writeEvent({ event: "connection_failed", message }, requestId);
@@ -112,7 +132,7 @@ export function emitElicitationRequestEvent(sessionId, request) {
     });
     writeEvent({ event: "elicitation_request", session_id: sessionId, request });
 }
-function buildConnectBridgeEvent(session, eventName) {
+export function buildConnectBridgeEvent(session, eventName) {
     const historyUpdates = session.resumeUpdates;
     return eventName === "session_replaced"
         ? {
@@ -122,6 +142,10 @@ function buildConnectBridgeEvent(session, eventName) {
             current_model: session.currentModel ?? resolveCurrentModel(session),
             available_models: session.availableModels,
             mode: session.mode ? buildModeState(session, session.mode) : null,
+            fast_mode_state: session.fastModeState,
+            ...(session.fastModeDisabledReason
+                ? { fast_mode_disabled_reason: session.fastModeDisabledReason }
+                : {}),
             ...(historyUpdates && historyUpdates.length > 0 ? { history_updates: historyUpdates } : {}),
             ...(session.restoredInput !== undefined ? { restored_input: session.restoredInput } : {}),
         }
@@ -132,6 +156,10 @@ function buildConnectBridgeEvent(session, eventName) {
             current_model: session.currentModel ?? resolveCurrentModel(session),
             available_models: session.availableModels,
             mode: session.mode ? buildModeState(session, session.mode) : null,
+            fast_mode_state: session.fastModeState,
+            ...(session.fastModeDisabledReason
+                ? { fast_mode_disabled_reason: session.fastModeDisabledReason }
+                : {}),
             ...(historyUpdates && historyUpdates.length > 0 ? { history_updates: historyUpdates } : {}),
         };
 }
@@ -152,6 +180,14 @@ function logConnectEventEmission(session, eventName, requestId) {
     });
 }
 export function emitConnectEvent(session) {
+    const staleSessions = session.sessionsToCloseAfterConnect;
+    if (staleSessions) {
+        for (const stale of staleSessions) {
+            if (stale !== session) {
+                detachSessionForClose(stale);
+            }
+        }
+    }
     const bridgeEvent = buildConnectBridgeEvent(session, session.connectEvent);
     logConnectEventEmission(session, session.connectEvent, session.connectRequestId);
     writeEvent(bridgeEvent, session.connectRequestId);
@@ -164,26 +200,23 @@ export function emitConnectEvent(session) {
     session.authHintSent = false;
     session.resumeUpdates = undefined;
     session.restoredInput = undefined;
-    const staleSessions = session.sessionsToCloseAfterConnect;
     session.sessionsToCloseAfterConnect = undefined;
     if (!staleSessions || staleSessions.length === 0) {
         refreshSessionsList();
         return;
     }
-    void (async () => {
+    const closeTask = (async () => {
         // Lazy import to break circular dependency at module-evaluation time.
-        const { sessions, closeSessionWithLogging } = await import("./session_lifecycle.js");
+        const { closeSessionWithLogging } = await import("./session_lifecycle.js");
         for (const stale of staleSessions) {
             if (stale === session) {
                 continue;
             }
-            if (sessions.get(stale.sessionId) === stale) {
-                sessions.delete(stale.sessionId);
-            }
             await closeSessionWithLogging(stale, { reason: "stale_after_connect" });
         }
         refreshSessionsList();
     })();
+    trackSessionCloseTask(closeTask);
 }
 export function emitSessionReplacedEvent(session, requestId) {
     const bridgeEvent = buildConnectBridgeEvent(session, "session_replaced");

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

@@ -1,5 +1,5 @@
 import { asRecordOrNull } from "./shared.js";
-import { TOOL_RESULT_TYPES, buildToolResultFields, createToolCall, isToolSearchToolName, isToolSearchToolResultType, isToolUseBlockType, } from "./tooling.js";
+import { applyToolNonExecutionMetadata, TOOL_RESULT_TYPES, buildToolResultFields, createToolCall, isToolSearchToolName, isToolSearchToolResultType, isToolUseBlockType, parseToolNonExecutionMetadata, } from "./tooling.js";
 function nonEmptyTrimmed(value) {
     if (typeof value !== "string") {
         return undefined;
@@ -197,7 +197,7 @@ function pushResumeToolUse(updates, toolCalls, hiddenToolUseIds, block, parentTo
     toolCalls.set(toolUseId, toolCall);
     updates.push({ type: "tool_call", tool_call: toolCall });
 }
-function pushResumeToolResult(updates, toolCalls, hiddenToolUseIds, block, sourceMessageUuid) {
+function pushResumeToolResult(updates, toolCalls, hiddenToolUseIds, block, nonExecutionByToolUseId, sourceMessageUuid) {
     const toolUseId = typeof block.tool_use_id === "string" ? block.tool_use_id : "";
     if (!toolUseId) {
         return;
@@ -210,6 +210,7 @@ function pushResumeToolResult(updates, toolCalls, hiddenToolUseIds, block, sourc
     const isError = Boolean(block.is_error);
     const base = toolCalls.get(toolUseId);
     const fields = buildToolResultFields(isError, block.content, base, block);
+    applyToolNonExecutionMetadata(fields, nonExecutionByToolUseId.get(toolUseId));
     updates.push({
         type: "tool_call_update",
         tool_call_update: {
@@ -294,6 +295,9 @@ export function mapSessionMessagesToUpdates(messages) {
                     ? message.parent_tool_use_id
                     : null;
             const content = Array.isArray(message.content) ? message.content : [];
+            const nonExecutionByToolUseId = parseToolNonExecutionMetadata(Object.hasOwn(entry, "tool_result_meta")
+                ? entry.tool_result_meta
+                : message.tool_result_meta);
             for (const item of content) {
                 const block = asRecordOrNull(item);
                 if (!block) {
@@ -312,7 +316,7 @@ export function mapSessionMessagesToUpdates(messages) {
                     continue;
                 }
                 if (TOOL_RESULT_TYPES.has(blockType)) {
-                    pushResumeToolResult(updates, toolCalls, hiddenToolUseIds, block, sourceMessageUuid);
+                    pushResumeToolResult(updates, toolCalls, hiddenToolUseIds, block, nonExecutionByToolUseId, sourceMessageUuid);
                     continue;
                 }
                 if (blockType === "image") {