claude-code-rust 0.14.1 → 0.14.2

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") {

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

@@ -65,6 +65,7 @@ function commandSessionId(command) {
         case "cancel_turn":
         case "set_model":
         case "set_mode":
+        case "set_fast_mode":
         case "generate_session_title":
         case "rename_session":
         case "permission_response":
@@ -103,6 +104,7 @@ function commandToolCallId(command) {
         case "cancel_turn":
         case "set_model":
         case "set_mode":
+        case "set_fast_mode":
         case "generate_session_title":
         case "rename_session":
         case "new_session":