claude-code-rust 0.14.1 → 0.14.3

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) {
@@ -134,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()) {
@@ -154,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);
@@ -191,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",
@@ -335,6 +379,7 @@ export async function createSession(params) {
         query: queryHandle,
         input,
         connected: false,
+        closing: false,
         connectEvent: params.connectEvent,
         connectRequestId: params.requestId,
         toolCalls: new Map(),
@@ -347,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
@@ -396,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({
@@ -416,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);
         }
@@ -429,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);
@@ -457,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.

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

@@ -15,7 +15,7 @@ function nonNegativeNumberField(record, ...keys) {
     }
     return value;
 }
-function nonNegativeIntegerField(record, ...keys) {
+export function nonNegativeIntegerField(record, ...keys) {
     const value = numberField(record, ...keys);
     return value !== undefined && value >= 0 && Number.isInteger(value) ? value : undefined;
 }
@@ -49,6 +49,13 @@ export function parseFastModeState(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) {
@@ -308,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) {
@@ -338,14 +339,15 @@ export function finalizeOpenToolCalls(session, status) {
         emitToolCallUpdate(session, toolUseId, { status }, "finalize");
     }
 }
-export function emitToolProgressUpdate(session, toolUseId, toolName, progress = {}) {
-    let existing = session.toolCalls.get(toolUseId);
+/**
+ * Apply advisory progress only to a tool created by an authoritative tool-use event.
+ */
+export function emitToolProgressUpdate(session, toolUseId, progress = {}) {
+    const existing = session.toolCalls.get(toolUseId);
     if (!existing) {
-        emitToolCall(session, toolUseId, toolName, {});
-        existing = session.toolCalls.get(toolUseId);
+        return;
     }
-    if (!existing ||
-        existing.status === "completed" ||
+    if (existing.status === "completed" ||
         existing.status === "failed" ||
         existing.status === "killed") {
         return;

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

@@ -23,6 +23,19 @@ const WORKFLOW_TOOL_NAME = "Workflow";
 const PROJECTS_TOOL_NAME = "Projects";
 const ARTIFACT_TOOL_NAME = "Artifact";
 const SHOW_ONBOARDING_ROLE_PICKER_TOOL_NAME = "ShowOnboardingRolePicker";
+const SKILL_TOOL_NAME = "Skill";
+const SKILL_WORD_OVERRIDES = {
+    api: "API",
+    ci: "CI",
+    cli: "CLI",
+    gh: "GH",
+    github: "GitHub",
+    mcp: "MCP",
+    pdf: "PDF",
+    sdk: "SDK",
+    ui: "UI",
+    ux: "UX",
+};
 const READ_MCP_RESOURCE_TOOL_NAME = "ReadMcpResource";
 const READ_MCP_RESOURCE_DIR_TOOL_NAME = "ReadMcpResourceDir";
 const SEARCH_OUTPUT_MODES = new Set(["content", "files_with_matches", "count"]);
@@ -183,6 +196,7 @@ export function normalizeToolKind(name) {
         case "Projects":
         case "Artifact":
         case "ShowOnboardingRolePicker":
+        case SKILL_TOOL_NAME:
             return "other";
         case "Task":
         case "Agent":
@@ -194,6 +208,34 @@ export function normalizeToolKind(name) {
             return "think";
     }
 }
+function skillDisplayName(rawName) {
+    const trimmed = rawName.trim();
+    const segments = trimmed.split(":");
+    if (segments.length > 2 ||
+        segments.some((segment) => !segment || !/^[a-zA-Z0-9]+(?:[-_][a-zA-Z0-9]+)*$/.test(segment))) {
+        return trimmed;
+    }
+    const displaySegments = segments.map((segment) => segment
+        .split(/[-_]/)
+        .map((word) => skillDisplayWord(word))
+        .join(" "));
+    if (displaySegments.length === 2 &&
+        displaySegments[0].toLowerCase() === displaySegments[1].toLowerCase()) {
+        return displaySegments[1];
+    }
+    return displaySegments.join(" / ");
+}
+function skillDisplayWord(word) {
+    const override = SKILL_WORD_OVERRIDES[word.toLowerCase()];
+    if (override) {
+        return override;
+    }
+    if (/^[A-Z0-9]+$/.test(word) ||
+        (/[a-z]/.test(word) && /[A-Z]/.test(word) && !/^[A-Z][a-z0-9]*$/.test(word))) {
+        return word;
+    }
+    return `${word.charAt(0).toUpperCase()}${word.slice(1).toLowerCase()}`;
+}
 export function toolTitle(name, input, context = {}) {
     const agentTitle = agentInputTitle(name, input);
     if (agentTitle) {
@@ -263,6 +305,12 @@ export function toolTitle(name, input, context = {}) {
     if (name === SHOW_ONBOARDING_ROLE_PICKER_TOOL_NAME) {
         return SHOW_ONBOARDING_ROLE_PICKER_TOOL_NAME;
     }
+    if (name === SKILL_TOOL_NAME) {
+        const skillName = nonEmptyString(input.skill);
+        return skillName
+            ? `${SKILL_TOOL_NAME}: ${skillDisplayName(skillName)}`
+            : SKILL_TOOL_NAME;
+    }
     if (name === "EnterWorktree") {
         const worktreeName = typeof input.name === "string" ? input.name.trim() : "";
         return worktreeName || "EnterWorktree";
@@ -369,6 +417,17 @@ function resultRecordCandidates(rawResult, rawContent) {
     pushNestedRecords(rawContent);
     return candidates;
 }
+function imageReadResultText(rawResult, rawContent, rawInput) {
+    const isImage = resultRecordCandidates(rawResult, rawContent).some((candidate) => candidate.type === "image");
+    if (!isImage) {
+        return undefined;
+    }
+    const input = asRecordOrNull(rawInput);
+    const filePath = typeof input?.file_path === "string" ? input.file_path.trim() : "";
+    const normalizedPath = filePath.replaceAll("\\", "/");
+    const fileName = normalizedPath.slice(normalizedPath.lastIndexOf("/") + 1);
+    return fileName ? `Viewed Image ${fileName}` : "Viewed Image";
+}
 function parseJsonCandidate(value) {
     const text = typeof value === "string" ? value : extractText(value);
     const trimmed = text.trim();
@@ -528,7 +587,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") {
@@ -1541,6 +1652,51 @@ function collectResultCandidates(rawResult, rawContent) {
     }
     return candidates;
 }
+function parseSkillResult(toolName, rawResult, rawContent) {
+    if (toolName !== SKILL_TOOL_NAME) {
+        return undefined;
+    }
+    for (const candidate of collectResultCandidates(rawResult, rawContent)) {
+        const commandName = nonEmptyString(candidate.commandName);
+        if (!commandName || typeof candidate.success !== "boolean") {
+            continue;
+        }
+        if (candidate.status === "forked") {
+            const agentId = nonEmptyString(candidate.agentId);
+            if (!agentId || typeof candidate.result !== "string") {
+                continue;
+            }
+            if (candidate.background !== undefined && typeof candidate.background !== "boolean") {
+                continue;
+            }
+            return {
+                success: candidate.success,
+                commandName,
+                status: "forked",
+                agentId,
+                result: candidate.result,
+                ...(typeof candidate.background === "boolean"
+                    ? { background: candidate.background }
+                    : {}),
+            };
+        }
+        if (candidate.status === undefined || candidate.status === "inline") {
+            const allowedToolsValid = candidate.allowedTools === undefined ||
+                (Array.isArray(candidate.allowedTools) &&
+                    candidate.allowedTools.every((tool) => typeof tool === "string"));
+            const modelValid = candidate.model === undefined || typeof candidate.model === "string";
+            if (!allowedToolsValid || !modelValid) {
+                continue;
+            }
+            return {
+                success: candidate.success,
+                commandName,
+                status: "inline",
+            };
+        }
+    }
+    return undefined;
+}
 function monitorResultFields(toolName, rawResult, rawContent) {
     if (toolName !== MONITOR_TOOL_NAME) {
         return undefined;
@@ -1745,6 +1901,32 @@ export function buildToolResultFields(isError, rawContent, base, rawResult, _con
     if (outputMetadata) {
         fields.output_metadata = outputMetadata;
     }
+    const skillResult = !isError ? parseSkillResult(toolName, rawResult, rawContent) : undefined;
+    if (skillResult) {
+        fields.title = `${SKILL_TOOL_NAME}: ${skillDisplayName(skillResult.commandName)}`;
+        if (!skillResult.success) {
+            fields.status = "failed";
+        }
+        else if (skillResult.status === "inline") {
+            return fields;
+        }
+        else {
+            const output = skillResult.result.trim();
+            if (output) {
+                fields.raw_output = output;
+                fields.content = [{ type: "content", content: { type: "text", text: output } }];
+            }
+            return fields;
+        }
+    }
+    const imageReadText = !isError && toolName === "Read"
+        ? imageReadResultText(rawResult, rawContent, base?.raw_input)
+        : undefined;
+    if (imageReadText !== undefined) {
+        fields.raw_output = imageReadText;
+        fields.content = [{ type: "content", content: { type: "text", text: imageReadText } }];
+        return fields;
+    }
     const fileUnchangedText = !isError && toolName === "Read" ? fileUnchangedResultText(rawResult, rawContent) : "";
     if (fileUnchangedText) {
         fields.raw_output = fileUnchangedText;