claude-code-rust 0.14.0 → 0.14.2

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

@@ -11,7 +11,7 @@ import { isToolSearchToolName } from "./tooling.js";
 import { requestExitPlanModeApproval, requestAskUserQuestionAnswers, EXIT_PLAN_MODE_TOOL_NAME, ASK_USER_QUESTION_TOOL_NAME, } from "./user_interaction.js";
 import { mapAvailableAgents, emitAvailableAgentsIfChanged, refreshAvailableAgents } from "./agents.js";
 import { mapSdkSlashCommands, updateAvailableCommands, } from "./available_commands.js";
-import { emitAuthRequired, emitFastModeUpdateIfChanged } from "./error_classification.js";
+import { emitAuthRequired, emitFastModeUpdate, setFastModeSnapshotIfChanged, } from "./error_classification.js";
 import { mapAvailableModels, resolveCurrentModel, currentModelsEqual, } from "./model_metadata.js";
 import { shouldEmitStartupAuthRequiredForAccount } from "./account_metadata.js";
 export { mapAvailableModels, resolveCurrentModel } from "./model_metadata.js";
@@ -34,6 +34,7 @@ function permissionDisplayFromCanUseOptions(options) {
     };
 }
 export const sessions = new Map();
+const pendingSessionCloseTasks = new Set();
 const DEFAULT_SETTING_SOURCES = ["user", "project", "local"];
 const DEFAULT_PERMISSION_MODE = "default";
 function isSdkElicitationContentValue(value) {
@@ -100,23 +101,28 @@ function settingsObjectFromLaunchSettings(launchSettings) {
     return launchSettings.settings;
 }
 function normalizedSettingsFromLaunchSettings(launchSettings) {
-    const settings = settingsObjectFromLaunchSettings(launchSettings);
-    if (!settings) {
-        return undefined;
-    }
+    const settings = settingsObjectFromLaunchSettings(launchSettings) ?? {};
+    // SendFeedback queues a local draft that can only be reviewed, edited, and
+    // discarded through the native /feedback surface. Agent SDK command
+    // snapshots do not expose that command to this host, so enabling drafts
+    // would create content that claude-rs cannot safely let the user approve.
+    const hostSettings = {
+        ...settings,
+        feedbackDrafts: "off",
+    };
     const sandbox = settings.sandbox && typeof settings.sandbox === "object" && !Array.isArray(settings.sandbox)
         ? settings.sandbox
         : undefined;
     if (sandbox?.enabled === true && sandbox.failIfUnavailable === undefined) {
         return {
-            ...settings,
+            ...hostSettings,
             sandbox: {
                 ...sandbox,
                 failIfUnavailable: false,
             },
         };
     }
-    return settings;
+    return hostSettings;
 }
 export function sessionById(sessionId) {
     return sessions.get(sessionId) ?? null;
@@ -129,7 +135,44 @@ export function updateSessionId(session, newSessionId) {
     session.sessionId = newSessionId;
     sessions.set(newSessionId, session);
 }
+export function beginSessionClose(session) {
+    session.closing = true;
+    for (const monitor of session.mcpAuthMonitors.values()) {
+        monitor.controller.abort();
+    }
+}
+export function detachSessionForClose(session) {
+    beginSessionClose(session);
+    if (sessions.get(session.sessionId) === session) {
+        sessions.delete(session.sessionId);
+    }
+}
+export function trackSessionCloseTask(task) {
+    const ownedTask = task.catch((error) => {
+        bridgeLogger.error({
+            target: LOG_TARGETS.APP_SESSION,
+            eventName: "session_close_task_failed",
+            message: "background session cleanup failed",
+            outcome: "failure",
+            fields: {
+                error_message: error instanceof Error ? error.message : String(error),
+            },
+        });
+    });
+    pendingSessionCloseTasks.add(ownedTask);
+    void ownedTask.then(() => {
+        pendingSessionCloseTasks.delete(ownedTask);
+    });
+}
+async function waitForPendingSessionCloseTasks() {
+    while (pendingSessionCloseTasks.size > 0) {
+        await Promise.all(Array.from(pendingSessionCloseTasks));
+    }
+}
 export async function closeSession(session) {
+    beginSessionClose(session);
+    const mcpAuthMonitors = Array.from(session.mcpAuthMonitors.values());
+    session.mcpAuthMonitors.clear();
     session.input.close();
     session.query.close();
     for (const pending of session.pendingPermissions.values()) {
@@ -149,6 +192,11 @@ export async function closeSession(session) {
         pending.resolve({ action: "cancel" });
     }
     session.pendingElicitations.clear();
+    await Promise.all([
+        session.initializationTask,
+        session.queryConsumerTask,
+        ...mcpAuthMonitors.map((monitor) => monitor.task),
+    ].filter((task) => task !== undefined));
 }
 export async function closeSessionWithLogging(session, options = {}) {
     await closeSession(session);
@@ -186,6 +234,7 @@ export async function closeAllSessions(options = {}) {
         reason: options.reason ?? "bulk_close",
         requestId: options.requestId,
     })));
+    await waitForPendingSessionCloseTasks();
     bridgeLogger.info({
         target: LOG_TARGETS.APP_SESSION,
         eventName: "all_sessions_closed",
@@ -330,6 +379,7 @@ export async function createSession(params) {
         query: queryHandle,
         input,
         connected: false,
+        closing: false,
         connectEvent: params.connectEvent,
         connectRequestId: params.requestId,
         toolCalls: new Map(),
@@ -342,7 +392,9 @@ export async function createSession(params) {
         pendingUserDialogs: new Map(),
         pendingElicitations: new Map(),
         informationalDedupKeys: new Set(),
+        knownConnectedMcpServers: new Set(),
         mcpStatusRevalidatedAt: new Map(),
+        mcpAuthMonitors: new Map(),
         hiddenToolUseIds: new Set(),
         authHintSent: false,
         ...(params.resumeUpdates && params.resumeUpdates.length > 0
@@ -391,7 +443,7 @@ export async function createSession(params) {
     // In stream-input mode the SDK may defer init until input arrives.
     // Trigger initialization explicitly so the Rust UI can receive `connected`
     // before the first user prompt.
-    void session.query
+    session.initializationTask = session.query
         .initializationResult()
         .then(async (result) => {
         bridgeLogger.info({
@@ -411,6 +463,7 @@ export async function createSession(params) {
         const currentModelChanged = refreshCurrentModel(session);
         const { buildModeState, refreshSupportedModesForSession } = await import("./commands.js");
         refreshSupportedModesForSession(session);
+        const fastModeChanged = setFastModeSnapshotIfChanged(session, result.fast_mode_state, result.fast_mode_disabled_reason);
         if (!session.connected) {
             emitConnectEvent(session);
         }
@@ -424,13 +477,15 @@ export async function createSession(params) {
                     mode: buildModeState(session, session.mode),
                 });
             }
+            if (fastModeChanged) {
+                emitFastModeUpdate(session);
+            }
         }
         // Proactively detect missing auth from account info so the UI can
         // show the login hint immediately, without waiting for the first prompt.
         if (shouldEmitStartupAuthRequiredForAccount(result.account)) {
             emitAuthRequired(session);
         }
-        emitFastModeUpdateIfChanged(session, result.fast_mode_state);
         updateAvailableCommands(session, "session_result_commands", mapSdkSlashCommands(result.commands));
         emitAvailableAgentsIfChanged(session, mapAvailableAgents(result.agents));
         refreshAvailableAgents(session);
@@ -452,7 +507,7 @@ export async function createSession(params) {
         failConnection(`agent initialization failed: ${message}`, session.connectRequestId);
         session.connectRequestId = undefined;
     });
-    void (async () => {
+    session.queryConsumerTask = (async () => {
         try {
             for await (const message of session.query) {
                 // Lazy import to break circular dependency at module-evaluation time.
@@ -612,9 +667,13 @@ export function buildQueryOptions(params) {
         includePartialMessages: true,
         promptSuggestions: true,
         enableFileCheckpointing: true,
+        // ProposeSkills reports only a proposal count and expects a native review
+        // surface. Keep it out of this host until claude-rs can display the actual
+        // proposal input and accept/reject it without losing content.
+        disallowedTools: ["ProposeSkills"],
         executable: "bun",
         ...(params.resume ? {} : { sessionId: params.provisionalSessionId }),
-        ...(settings ? { settings } : {}),
+        settings,
         ...modelOption,
         ...permissionModeOptions,
         toolConfig: { askUserQuestion: { previewFormat: "markdown" } },

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

@@ -15,12 +15,47 @@ function nonNegativeNumberField(record, ...keys) {
     }
     return value;
 }
+function nonNegativeIntegerField(record, ...keys) {
+    const value = numberField(record, ...keys);
+    return value !== undefined && value >= 0 && Number.isInteger(value) ? value : undefined;
+}
+export function buildSubagentRetryUpdate(message) {
+    const retry = asRecordOrNull(message.subagent_retry);
+    if (!retry) {
+        return null;
+    }
+    const attempt = nonNegativeIntegerField(retry, "attempt");
+    const maxRetries = nonNegativeIntegerField(retry, "max_retries", "maxRetries");
+    const retryDelayMs = nonNegativeIntegerField(retry, "retry_delay_ms", "retryDelayMs");
+    if (attempt === undefined || maxRetries === undefined || retryDelayMs === undefined) {
+        return null;
+    }
+    const agentId = typeof retry.agent_id === "string" ? retry.agent_id.trim() : "";
+    const errorCategory = typeof retry.error_category === "string" ? retry.error_category.trim() : "";
+    const errorStatus = nonNegativeIntegerField(retry, "error_status", "errorStatus");
+    return {
+        state: "waiting",
+        ...(agentId ? { agent_id: agentId } : {}),
+        attempt,
+        max_retries: maxRetries,
+        retry_delay_ms: retryDelayMs,
+        ...(errorStatus !== undefined ? { error_status: errorStatus } : {}),
+        ...(errorCategory ? { error_category: errorCategory } : {}),
+    };
+}
 export function parseFastModeState(value) {
     if (value === "off" || value === "cooldown" || value === "on") {
         return value;
     }
     return null;
 }
+export function parseFastModeDisabledReason(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const reason = value.trim();
+    return reason.length > 0 ? reason : undefined;
+}
 export function parseRateLimitStatus(value) {
     if (value === "allowed" || value === "allowed_warning" || value === "rejected") {
         return value;

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

@@ -3,7 +3,7 @@ import { bridgeLogger, LOG_TARGETS } from "./logger.js";
 import { asRecordOrNull } from "./shared.js";
 import { applyTaskToolResult } from "./tasks.js";
 import { activeTaskIdForToolUse, linkTaskToolUse, unlinkTaskToolUse } from "./task_links.js";
-import { backgroundToolLaunchTaskIdFromResult, buildToolResultFields, createToolCall, } from "./tooling.js";
+import { applyToolNonExecutionMetadata, backgroundToolLaunchTaskIdFromResult, buildToolResultFields, createToolCall, } from "./tooling.js";
 const TOOL_SUMMARY_TOOL_NAMES = new Set(["Agent", "Task", "WebSearch", "WebFetch", "ExitPlanMode"]);
 const TASK_LIFECYCLE_TOOL_NAMES = new Set(["Agent", "Task", "Monitor", "Workflow"]);
 function jsonSize(value) {
@@ -112,10 +112,14 @@ function mergeTaskMetadata(current, update) {
     if (update === undefined) {
         return current;
     }
-    return {
+    const merged = {
         ...(current ?? {}),
         ...update,
     };
+    if (update.subagent_retry?.state === "clear") {
+        delete merged.subagent_retry;
+    }
+    return merged;
 }
 function applyFieldsToBase(base, fields) {
     if (fields.title !== undefined) {
@@ -237,6 +241,16 @@ function taskTitleContext(session, name, input) {
 }
 export function emitToolCallUpdate(session, toolUseId, fields, updateKind, sourceMessageUuid) {
     const base = session.toolCalls.get(toolUseId);
+    const nextStatus = fields.status ?? base?.status;
+    const terminal = nextStatus === "completed" || nextStatus === "failed" || nextStatus === "killed";
+    const hasActiveRetry = base?.task_metadata?.subagent_retry?.state === "waiting" ||
+        fields.task_metadata?.subagent_retry?.state === "waiting";
+    if (terminal && hasActiveRetry) {
+        fields.task_metadata = {
+            ...(fields.task_metadata ?? {}),
+            subagent_retry: { state: "clear" },
+        };
+    }
     logToolCallUpdateEmitted(session.sessionId, toolUseId, fields, base, updateKind);
     emitSessionUpdate(session.sessionId, {
         type: "tool_call_update",
@@ -294,18 +308,19 @@ export function ensureToolCallVisible(session, toolUseId, toolName, input, paren
     emitInitialToolCall(session, toolCall);
     return toolCall;
 }
-export function emitToolResultUpdate(session, toolUseId, isError, rawContent, rawResult = rawContent, sourceMessageUuid) {
+export function emitToolResultUpdate(session, toolUseId, isError, rawContent, rawResult = rawContent, sourceMessageUuid, nonExecutionMetadata) {
     const base = session.toolCalls.get(toolUseId);
     const baseToolName = toolNameFromMeta(base?.meta) ?? "";
     const fields = buildToolResultFields(isError, rawContent, base, rawResult, taskTitleContext(session, baseToolName, asRecordOrNull(base?.raw_input) ?? {}));
-    if (!isError) {
+    applyToolNonExecutionMetadata(fields, nonExecutionMetadata);
+    if (!isError && !nonExecutionMetadata) {
         const taskId = backgroundToolLaunchTaskIdFromResult(baseToolName, rawResult, rawContent);
         if (taskId) {
             linkTaskToolUse(session, taskId, toolUseId);
         }
     }
     emitToolCallUpdate(session, toolUseId, fields, "result", sourceMessageUuid);
-    applyTaskToolResult(session, toolUseId, isError, rawContent, rawResult);
+    applyTaskToolResult(session, toolUseId, isError || nonExecutionMetadata !== undefined, rawContent, rawResult);
     if (baseToolName === "Agent" || baseToolName === "Task") {
         const taskId = activeTaskIdForToolUse(session, toolUseId);
         if (taskId) {
@@ -324,19 +339,39 @@ export function finalizeOpenToolCalls(session, status) {
         emitToolCallUpdate(session, toolUseId, { status }, "finalize");
     }
 }
-export function emitToolProgressUpdate(session, toolUseId, toolName) {
-    const existing = session.toolCalls.get(toolUseId);
+export function emitToolProgressUpdate(session, toolUseId, toolName, progress = {}) {
+    let existing = session.toolCalls.get(toolUseId);
     if (!existing) {
         emitToolCall(session, toolUseId, toolName, {});
-        return;
+        existing = session.toolCalls.get(toolUseId);
     }
-    if (existing.status === "in_progress" ||
+    if (!existing ||
         existing.status === "completed" ||
         existing.status === "failed" ||
         existing.status === "killed") {
         return;
     }
-    emitToolCallUpdate(session, toolUseId, { status: "in_progress" }, "progress");
+    const taskMetadata = {};
+    if (progress.subagentRetry?.state === "waiting") {
+        taskMetadata.subagent_retry = progress.subagentRetry;
+    }
+    else if (progress.subagentRetry?.state === "clear" &&
+        existing.task_metadata?.subagent_retry?.state === "waiting") {
+        taskMetadata.subagent_retry = progress.subagentRetry;
+    }
+    if (progress.subagentType && progress.subagentType !== existing.task_metadata?.subagent_type) {
+        taskMetadata.subagent_type = progress.subagentType;
+    }
+    const fields = {};
+    if (existing.status !== "in_progress") {
+        fields.status = "in_progress";
+    }
+    if (Object.keys(taskMetadata).length > 0) {
+        fields.task_metadata = taskMetadata;
+    }
+    if (Object.keys(fields).length > 0) {
+        emitToolCallUpdate(session, toolUseId, fields, "progress");
+    }
 }
 export function emitToolSummaryUpdate(session, toolUseId, summary) {
     const base = session.toolCalls.get(toolUseId);

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

@@ -482,9 +482,19 @@ function extractToolOutputMetadata(toolName, rawResult, rawContent) {
     if (toolName === "Bash") {
         for (const candidate of candidates) {
             const hasAssistantAutoBackgrounded = typeof candidate.assistantAutoBackgrounded === "boolean";
-            if (hasAssistantAutoBackgrounded) {
+            const timedOutAfterMs = nonNegativeInteger(candidate.timedOutAfterMs);
+            const backgroundCwdHint = nonEmptyString(candidate.backgroundCwdHint);
+            if (hasAssistantAutoBackgrounded || timedOutAfterMs !== undefined || backgroundCwdHint) {
                 const bashMetadata = {};
-                bashMetadata.assistant_auto_backgrounded = candidate.assistantAutoBackgrounded;
+                if (hasAssistantAutoBackgrounded) {
+                    bashMetadata.assistant_auto_backgrounded = candidate.assistantAutoBackgrounded;
+                }
+                if (timedOutAfterMs !== undefined) {
+                    bashMetadata.timed_out_after_ms = timedOutAfterMs;
+                }
+                if (backgroundCwdHint) {
+                    bashMetadata.background_cwd_hint = backgroundCwdHint;
+                }
                 metadata.bash = bashMetadata;
                 break;
             }
@@ -493,9 +503,11 @@ function extractToolOutputMetadata(toolName, rawResult, rawContent) {
     if (toolName === "Agent" || toolName === "Task") {
         for (const candidate of candidates) {
             const resolvedModel = nonEmptyString(candidate.resolvedModel);
-            if (resolvedModel) {
+            const modelsUsed = orderedNonEmptyStrings(candidate.modelsUsed);
+            if (resolvedModel || modelsUsed) {
                 const agentMetadata = {
-                    resolved_model: resolvedModel,
+                    ...(resolvedModel ? { resolved_model: resolvedModel } : {}),
+                    ...(modelsUsed ? { models_used: modelsUsed } : {}),
                 };
                 metadata.agent = agentMetadata;
                 break;
@@ -516,7 +528,59 @@ function extractToolOutputMetadata(toolName, rawResult, rawContent) {
             }
         }
     }
-    return metadata.bash || metadata.agent || metadata.web_fetch ? metadata : undefined;
+    if (toolName === "Skill") {
+        for (const candidate of candidates) {
+            if (candidate.background === true) {
+                metadata.skill = { background: true };
+                break;
+            }
+        }
+    }
+    return metadata.bash || metadata.agent || metadata.web_fetch || metadata.skill
+        ? metadata
+        : undefined;
+}
+export function parseToolNonExecutionMetadata(value) {
+    const byToolUseId = new Map();
+    if (!Array.isArray(value)) {
+        return byToolUseId;
+    }
+    for (const entry of value) {
+        const record = asRecordOrNull(entry);
+        const id = nonEmptyString(record?.id);
+        const kind = nonEmptyString(record?.non_execution_kind);
+        if (!id || !kind || byToolUseId.has(id)) {
+            continue;
+        }
+        const userFeedback = nonEmptyString(record?.user_feedback);
+        byToolUseId.set(id, {
+            kind,
+            ...(userFeedback ? { user_feedback: userFeedback } : {}),
+        });
+    }
+    return byToolUseId;
+}
+export function applyToolNonExecutionMetadata(fields, metadata) {
+    if (!metadata) {
+        return;
+    }
+    fields.output_metadata = {
+        ...(fields.output_metadata ?? {}),
+        non_execution: metadata,
+    };
+    switch (metadata.kind) {
+        case "user-rejected":
+        case "permission-rule":
+        case "automode-unavailable":
+        case "automode-parsing-error":
+        case "automode-blocked":
+            fields.status = "failed";
+            break;
+        case "cancelled":
+        case "interrupted":
+            fields.status = "killed";
+            break;
+    }
 }
 export function extractText(value) {
     if (typeof value === "string") {
@@ -736,6 +800,10 @@ function shellBackgroundMessage(record) {
     if (!backgroundTaskId) {
         return "";
     }
+    const timedOutAfterMs = nonNegativeInteger(record.timedOutAfterMs);
+    if (timedOutAfterMs !== undefined) {
+        return `Command was auto-backgrounded after ${timedOutAfterMs.toLocaleString("en-US")} ms with ID: ${backgroundTaskId}.`;
+    }
     if (record.assistantAutoBackgrounded === true) {
         return `Command was auto-backgrounded by assistant mode with ID: ${backgroundTaskId}.`;
     }
@@ -812,6 +880,9 @@ function recordNumber(record, key) {
     const value = record[key];
     return typeof value === "number" && Number.isFinite(value) ? value : undefined;
 }
+function recordNonNegativeInteger(record, key) {
+    return nonNegativeInteger(record[key]);
+}
 function recordString(record, key) {
     const value = record[key];
     return typeof value === "string" ? value : undefined;
@@ -857,8 +928,13 @@ function globResultText(record) {
 function grepResultText(record) {
     const filenames = searchFilenames(record);
     const content = recordString(record, "content") ?? "";
-    const numFiles = recordNumber(record, "numFiles") ?? filenames.length;
-    const numLines = recordNumber(record, "numLines");
+    const hasVisibleMatches = content.trim().length > 0 || filenames.length > 0;
+    const totalFiles = recordNonNegativeInteger(record, "totalFiles");
+    const legacyNumFiles = recordNonNegativeInteger(record, "numFiles");
+    const numFiles = totalFiles ??
+        (legacyNumFiles !== 0 || !hasVisibleMatches ? legacyNumFiles : undefined) ??
+        (filenames.length > 0 ? filenames.length : undefined);
+    const numLines = recordNonNegativeInteger(record, "totalLines") ?? recordNonNegativeInteger(record, "numLines");
     const numMatches = recordNumber(record, "numMatches");
     const appliedLimit = recordNumber(record, "appliedLimit");
     const appliedOffset = recordNumber(record, "appliedOffset");
@@ -878,7 +954,9 @@ function grepResultText(record) {
         lines.push("No matches found");
     }
     const summaryParts = [];
-    summaryParts.push(`${numFiles} ${pluralize(numFiles, "file")}`);
+    if (numFiles !== undefined) {
+        summaryParts.push(`${numFiles} ${pluralize(numFiles, "file")}`);
+    }
     if (numMatches !== undefined) {
         summaryParts.push(`${numMatches} ${pluralize(numMatches, "match", "matches")}`);
     }
@@ -937,6 +1015,26 @@ function pushBooleanField(lines, label, value) {
 function nonEmptyString(value) {
     return typeof value === "string" && value.trim() ? value.trim() : undefined;
 }
+function nonNegativeInteger(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0
+        ? Math.trunc(value)
+        : undefined;
+}
+function orderedNonEmptyStrings(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const seen = new Set();
+    const values = [];
+    for (const item of value) {
+        const normalized = nonEmptyString(item);
+        if (normalized && !seen.has(normalized)) {
+            seen.add(normalized);
+            values.push(normalized);
+        }
+    }
+    return values.length > 0 ? values : undefined;
+}
 const CRON_MONTH_NAMES = [
     "January",
     "February",