claude-code-rust 0.12.3 → 0.13.0

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

@@ -19,7 +19,7 @@ export { shouldEmitStartupAuthRequiredForAccount } from "./account_metadata.js";
 const BRIDGE_RUNTIME_PROCESS_NAME = process.platform === "win32" ? "claude-rs-bridge-node.exe" : "claude-rs-bridge-node";
 const BRIDGE_RUNTIME_GUARD_PROMPT = `Do not terminate the Claude Rust bridge runtime process \`${BRIDGE_RUNTIME_PROCESS_NAME}\`; ` +
     "when cleaning up development servers, only stop processes by explicit PIDs you started in this session.";
-const STARTUP_FALLBACK_MODEL_ALIAS = "opus";
+const STARTUP_FALLBACK_MODEL_ALIAS = "fable";
 function permissionDisplayFromCanUseOptions(options) {
     const title = typeof options.title === "string" ? options.title.trim() : "";
     const displayName = typeof options.displayName === "string" ? options.displayName.trim() : "";
@@ -162,6 +162,23 @@ export async function closeSessionWithLogging(session, options = {}) {
         fields: { reason: options.reason ?? "unspecified" },
     });
 }
+export async function closeSessionsBeforeRegister(replacementSession, staleSessions, requestId) {
+    if (!staleSessions || staleSessions.length === 0) {
+        return;
+    }
+    for (const stale of staleSessions) {
+        if (stale === replacementSession) {
+            continue;
+        }
+        if (sessions.get(stale.sessionId) === stale) {
+            sessions.delete(stale.sessionId);
+        }
+        await closeSessionWithLogging(stale, {
+            reason: "stale_before_register",
+            requestId,
+        });
+    }
+}
 export async function closeAllSessions(options = {}) {
     const active = Array.from(sessions.values());
     sessions.clear();
@@ -187,6 +204,7 @@ export async function createSession(params) {
     const supportsBypassPermissionsMode = startupPermissionModeOptions(params.launchSettings).allowDangerouslySkipPermissions === true;
     const historyUpdateCount = params.resumeUpdates?.length ?? 0;
     const staleSessionCount = params.sessionsToCloseAfterConnect?.length ?? 0;
+    const staleSessionBeforeRegisterCount = params.sessionsToCloseBeforeRegister?.length ?? 0;
     let session;
     const sessionIdForLogs = () => session?.sessionId ?? provisionalSessionId;
     const canUseTool = async (toolName, inputData, options) => {
@@ -253,8 +271,10 @@ export async function createSession(params) {
             cwd: params.cwd,
             connect_event: params.connectEvent,
             resume_requested: params.resume !== undefined,
+            resume_session_at: params.resumeSessionAt ?? "<none>",
             history_update_count: historyUpdateCount,
             stale_session_count: staleSessionCount,
+            stale_session_before_register_count: staleSessionBeforeRegisterCount,
         },
     });
     try {
@@ -263,6 +283,7 @@ export async function createSession(params) {
             options: buildQueryOptions({
                 cwd: params.cwd,
                 resume: params.resume,
+                resumeSessionAt: params.resumeSessionAt,
                 launchSettings: params.launchSettings,
                 provisionalSessionId,
                 input,
@@ -287,6 +308,7 @@ export async function createSession(params) {
             fields: {
                 cwd: params.cwd,
                 resume_requested: params.resume !== undefined,
+                resume_session_at: params.resumeSessionAt ?? "<none>",
                 error_message: message,
             },
         });
@@ -319,12 +341,17 @@ export async function createSession(params) {
         pendingQuestions: new Map(),
         pendingUserDialogs: new Map(),
         pendingElicitations: new Map(),
+        informationalDedupKeys: new Set(),
         mcpStatusRevalidatedAt: new Map(),
         hiddenToolUseIds: new Set(),
         authHintSent: false,
         ...(params.resumeUpdates && params.resumeUpdates.length > 0
             ? { resumeUpdates: params.resumeUpdates }
             : {}),
+        ...(params.restoredInput !== undefined ? { restoredInput: params.restoredInput } : {}),
+        ...(params.pendingRewindResult !== undefined
+            ? { pendingRewindResult: params.pendingRewindResult }
+            : {}),
         ...(params.sessionsToCloseAfterConnect
             ? { sessionsToCloseAfterConnect: params.sessionsToCloseAfterConnect }
             : {}),
@@ -332,6 +359,7 @@ export async function createSession(params) {
     refreshCurrentModel(session);
     const { refreshSupportedModesForSession } = await import("./commands.js");
     refreshSupportedModesForSession(session);
+    await closeSessionsBeforeRegister(session, params.sessionsToCloseBeforeRegister, params.requestId);
     sessions.set(provisionalSessionId, session);
     bridgeLogger.info({
         target: LOG_TARGETS.APP_SESSION,
@@ -344,6 +372,7 @@ export async function createSession(params) {
             cwd: session.cwd,
             connect_event: session.connectEvent,
             resume_requested: params.resume !== undefined,
+            resume_session_at: params.resumeSessionAt ?? "<none>",
         },
     });
     bridgeLogger.info({
@@ -430,6 +459,11 @@ export async function createSession(params) {
                 const { handleSdkMessage } = await import("./message_handlers.js");
                 handleSdkMessage(session, message);
             }
+            {
+                // Lazy import to break circular dependency at module-evaluation time.
+                const { flushPendingWorkerShutdown } = await import("./message_handlers.js");
+                flushPendingWorkerShutdown(session);
+            }
             if (!session.connected) {
                 bridgeLogger.error({
                     target: LOG_TARGETS.APP_SESSION,
@@ -456,6 +490,7 @@ export async function createSession(params) {
             failConnection(`agent stream failed: ${message}`, params.requestId);
         }
     })();
+    return session;
 }
 function logSdkProcessSpawnStarted(options, includeArgsPreview) {
     bridgeLogger.info({
@@ -565,11 +600,13 @@ export function buildQueryOptions(params) {
     const systemPrompt = systemPromptFromLaunchSettings(params.launchSettings);
     const modelOption = startupModelOption(params.launchSettings);
     const permissionModeOptions = startupPermissionModeOptions(params.launchSettings);
+    const shouldPassCanUseTool = permissionModeOptions.permissionMode !== "bypassPermissions";
     const settings = normalizedSettingsFromLaunchSettings(params.launchSettings);
     return {
         cwd: params.cwd,
         includePartialMessages: true,
         promptSuggestions: true,
+        enableFileCheckpointing: true,
         executable: "node",
         ...(params.resume ? {} : { sessionId: params.provisionalSessionId }),
         ...(settings ? { settings } : {}),
@@ -621,7 +658,8 @@ export function buildQueryOptions(params) {
         // --setting-sources argument.
         settingSources: DEFAULT_SETTING_SOURCES,
         resume: params.resume,
-        canUseTool: params.canUseTool,
+        ...(params.resumeSessionAt ? { resumeSessionAt: params.resumeSessionAt } : {}),
+        ...(shouldPassCanUseTool ? { canUseTool: params.canUseTool } : {}),
         onElicitation: async (request) => {
             const requestId = randomUUID();
             const mode = request.mode === "form" || request.mode === "url"

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

@@ -62,6 +62,9 @@ export function buildRateLimitUpdate(rateLimitInfo) {
         type: "rate_limit_update",
         status,
     };
+    if (info.errorCode === "credits_required") {
+        update.error_code = "credits_required";
+    }
     const resetsAt = numberField(info, "resetsAt");
     if (resetsAt !== undefined) {
         update.resets_at = resetsAt;
@@ -94,6 +97,12 @@ export function buildRateLimitUpdate(rateLimitInfo) {
     if (surpassedThreshold !== undefined) {
         update.surpassed_threshold = surpassedThreshold;
     }
+    if (typeof info.canUserPurchaseCredits === "boolean") {
+        update.can_user_purchase_credits = info.canUserPurchaseCredits;
+    }
+    if (typeof info.hasChargeableSavedPaymentMethod === "boolean") {
+        update.has_chargeable_saved_payment_method = info.hasChargeableSavedPaymentMethod;
+    }
     return update;
 }
 export function buildApiRetryUpdate(message) {

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

@@ -23,6 +23,8 @@ const WORKFLOW_TOOL_NAME = "Workflow";
 const PROJECTS_TOOL_NAME = "Projects";
 const ARTIFACT_TOOL_NAME = "Artifact";
 const SHOW_ONBOARDING_ROLE_PICKER_TOOL_NAME = "ShowOnboardingRolePicker";
+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"]);
 function isCronToolName(name) {
     return CRON_TOOL_NAMES.has(name);
@@ -53,6 +55,9 @@ function isAgentLikeToolName(name) {
 export function isShellToolName(name) {
     return name === "Bash" || name === "PowerShell";
 }
+function isMcpResourceReadToolName(name) {
+    return name === READ_MCP_RESOURCE_TOOL_NAME || name === READ_MCP_RESOURCE_DIR_TOOL_NAME;
+}
 function agentInputTitle(name, input) {
     if (!isAgentLikeToolName(name)) {
         return undefined;
@@ -143,7 +148,8 @@ export function normalizeToolKind(name) {
     }
     switch (name) {
         case "Read":
-        case "ReadMcpResource":
+        case READ_MCP_RESOURCE_TOOL_NAME:
+        case READ_MCP_RESOURCE_DIR_TOOL_NAME:
             return "read";
         case "Write":
         case "Edit":
@@ -268,14 +274,14 @@ export function toolTitle(name, input, context = {}) {
     if ((name === "Read" || name === "Write" || name === "Edit") && typeof input.file_path === "string") {
         return `${name} ${input.file_path}`;
     }
-    if (name === "ReadMcpResource") {
+    if (isMcpResourceReadToolName(name)) {
         const uri = typeof input.uri === "string" ? input.uri : "";
         const server = typeof input.server === "string" ? input.server : "";
         if (server && uri) {
-            return `ReadMcpResource ${server} ${uri}`;
+            return `${name} ${server} ${uri}`;
         }
         if (uri) {
-            return `ReadMcpResource ${uri}`;
+            return `${name} ${uri}`;
         }
     }
     return name;
@@ -440,6 +446,37 @@ function mcpResourceContentFromResult(rawResult, rawContent) {
     }
     return [];
 }
+function mcpResourceDirTextFromResult(toolName, rawResult, rawContent) {
+    if (toolName !== READ_MCP_RESOURCE_DIR_TOOL_NAME) {
+        return undefined;
+    }
+    for (const candidate of collectResultCandidates(rawResult, rawContent)) {
+        if (!Array.isArray(candidate.resources)) {
+            continue;
+        }
+        const lines = [];
+        for (const entry of candidate.resources) {
+            const record = asRecordOrNull(entry);
+            if (!record) {
+                continue;
+            }
+            const name = nonEmptyString(record.name);
+            const uri = nonEmptyString(record.uri);
+            if (!name || !uri) {
+                continue;
+            }
+            const mimeType = nonEmptyString(record.mimeType);
+            const suffix = mimeType
+                ? mimeType === "inode/directory"
+                    ? " (directory)"
+                    : ` (${mimeType})`
+                : "";
+            lines.push(`${name} - ${uri}${suffix}`);
+        }
+        return lines.length > 0 ? lines.join("\n") : "No resources found.";
+    }
+    return undefined;
+}
 function extractToolOutputMetadata(toolName, rawResult, rawContent) {
     const candidates = collectResultCandidates(rawResult, rawContent);
     const metadata = {};
@@ -1604,8 +1641,8 @@ function enterPlanModeStructuredOutputHandled(toolName, rawResult, rawContent) {
     }
     return false;
 }
-function readMcpResourceErrorText(toolName, rawResult, rawContent) {
-    if (toolName !== "ReadMcpResource") {
+function mcpResourceReadErrorText(toolName, rawResult, rawContent) {
+    if (!isMcpResourceReadToolName(toolName)) {
         return undefined;
     }
     for (const candidate of collectResultCandidates(rawResult, rawContent)) {
@@ -1675,13 +1712,23 @@ export function buildToolResultFields(isError, rawContent, base, rawResult, _con
     if (agentTitle) {
         fields.title = agentTitle;
     }
-    const readMcpResourceError = readMcpResourceErrorText(toolName, rawResult, rawContent);
+    const readMcpResourceError = mcpResourceReadErrorText(toolName, rawResult, rawContent);
     if (readMcpResourceError) {
         fields.status = "failed";
         fields.raw_output = readMcpResourceError;
         fields.content = [{ type: "content", content: { type: "text", text: readMcpResourceError } }];
         return fields;
     }
+    const readMcpResourceDirOutput = !isError
+        ? mcpResourceDirTextFromResult(toolName, rawResult, rawContent)
+        : undefined;
+    if (readMcpResourceDirOutput !== undefined) {
+        fields.raw_output = readMcpResourceDirOutput;
+        fields.content = [
+            { type: "content", content: { type: "text", text: readMcpResourceDirOutput } },
+        ];
+        return fields;
+    }
     const searchOutput = !isError ? searchResultText(toolName, rawResult, rawContent) : undefined;
     if (searchOutput !== undefined) {
         fields.raw_output = searchOutput;
@@ -1826,7 +1873,7 @@ export function buildToolResultFields(isError, rawContent, base, rawResult, _con
             return fields;
         }
     }
-    if (!isError && toolName === "ReadMcpResource") {
+    if (!isError && toolName === READ_MCP_RESOURCE_TOOL_NAME) {
         const structuredResourceContent = mcpResourceContentFromResult(rawResult, rawContent);
         if (structuredResourceContent.length > 0) {
             fields.content = structuredResourceContent;

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

@@ -142,6 +142,32 @@ function buildQuestionRequest(promptToolCall, prompt, index, total) {
 function askUserQuestionTranscript(answers) {
     return answers.map((entry) => `${entry.header}: ${entry.answer}\n  ${entry.question}`).join("\n");
 }
+function askUserQuestionCompletedRawInput(prompts, answers, annotations, questionResults) {
+    return {
+        questions: prompts.map((prompt) => ({
+            question: prompt.question,
+            header: prompt.header,
+            multiSelect: prompt.multiSelect,
+            options: prompt.options.map((option) => ({
+                label: option.label,
+                description: option.description,
+                ...(option.preview ? { preview: option.preview } : {}),
+            })),
+        })),
+        answers,
+        ...(Object.keys(annotations).length > 0 ? { annotations: questionAnnotationsJson(annotations) } : {}),
+        question_results: questionResults,
+    };
+}
+function questionAnnotationsJson(annotations) {
+    return Object.fromEntries(Object.entries(annotations).map(([question, annotation]) => [
+        question,
+        {
+            ...(annotation.preview ? { preview: annotation.preview } : {}),
+            ...(annotation.notes ? { notes: annotation.notes } : {}),
+        },
+    ]));
+}
 function deriveAnnotation(selectedOptions, annotation) {
     const preview = annotation?.preview?.trim().length
         ? annotation.preview
@@ -166,6 +192,7 @@ export async function requestAskUserQuestionAnswers(session, toolUseId, inputDat
     const answers = {};
     const annotations = {};
     const transcript = [];
+    const questionResults = [];
     for (const [index, prompt] of prompts.entries()) {
         const promptToolCall = askUserQuestionPromptToolCall(baseToolCall, prompt, index, prompts.length);
         const fields = {
@@ -214,11 +241,35 @@ export async function requestAskUserQuestionAnswers(session, toolUseId, inputDat
             annotations[prompt.question] = annotation;
         }
         transcript.push({ header: prompt.header, question: prompt.question, answer });
+        questionResults.push({
+            question: prompt.question,
+            header: prompt.header,
+            question_index: index,
+            total_questions: prompts.length,
+            selected_options: selectedOptions.map((option) => ({
+                option_id: option.option_id,
+                label: option.label,
+                ...(option.description ? { description: option.description } : {}),
+                ...(option.preview ? { preview: option.preview } : {}),
+            })),
+            ...(annotation
+                ? {
+                    annotation: {
+                        ...(annotation.preview ? { preview: annotation.preview } : {}),
+                        ...(annotation.notes ? { notes: annotation.notes } : {}),
+                    },
+                }
+                : {}),
+        });
         const summary = askUserQuestionTranscript(transcript);
+        const completed = index + 1 >= prompts.length;
         const progressFields = {
-            status: index + 1 >= prompts.length ? "completed" : "in_progress",
+            status: completed ? "completed" : "in_progress",
             raw_output: summary,
             content: [{ type: "content", content: { type: "text", text: summary } }],
+            ...(completed
+                ? { raw_input: askUserQuestionCompletedRawInput(prompts, answers, annotations, questionResults) }
+                : {}),
         };
         emitToolCallUpdate(session, toolUseId, progressFields, "summary");
     }