claude-code-rust 0.7.1 → 0.8.0

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

@@ -63,10 +63,15 @@ export function parseAskUserQuestionPrompts(inputData) {
             }
             const label = typeof optionRecord.label === "string" ? optionRecord.label.trim() : "";
             const description = typeof optionRecord.description === "string" ? optionRecord.description.trim() : "";
+            const preview = typeof optionRecord.preview === "string" ? optionRecord.preview.trim() : "";
             if (!label) {
                 continue;
             }
-            options.push({ label, description });
+            options.push({
+                label,
+                description,
+                ...(preview.length > 0 ? { preview } : {}),
+            });
         }
         if (options.length < 2) {
             continue;
@@ -78,38 +83,74 @@ export function parseAskUserQuestionPrompts(inputData) {
 function askUserQuestionOptions(prompt) {
     return prompt.options.map((option, index) => ({
         option_id: `question_${index}`,
-        name: option.label,
+        label: option.label,
         description: option.description,
-        kind: QUESTION_CHOICE_KIND,
+        ...(option.preview ? { preview: option.preview } : {}),
     }));
 }
+function askUserQuestionPromptRawInput(prompt, index, total) {
+    return {
+        prompt: {
+            question: prompt.question,
+            header: prompt.header,
+            multi_select: prompt.multiSelect,
+            options: prompt.options.map((option, optionIndex) => ({
+                option_id: `question_${optionIndex}`,
+                label: option.label,
+                description: option.description,
+                ...(option.preview ? { preview: option.preview } : {}),
+            })),
+        },
+        question_index: index,
+        total_questions: total,
+    };
+}
 function askUserQuestionPromptToolCall(base, prompt, index, total) {
     return {
         ...base,
         title: prompt.question,
-        raw_input: {
-            questions: [
-                {
-                    question: prompt.question,
-                    header: prompt.header,
-                    multiSelect: prompt.multiSelect,
-                    options: prompt.options,
-                },
-            ],
-            question_index: index,
-            total_questions: total,
+        raw_input: askUserQuestionPromptRawInput(prompt, index, total),
+    };
+}
+function buildQuestionRequest(promptToolCall, prompt, index, total) {
+    return {
+        tool_call: promptToolCall,
+        prompt: {
+            question: prompt.question,
+            header: prompt.header,
+            multi_select: prompt.multiSelect,
+            options: askUserQuestionOptions(prompt),
         },
+        question_index: index,
+        total_questions: total,
     };
 }
 function askUserQuestionTranscript(answers) {
     return answers.map((entry) => `${entry.header}: ${entry.answer}\n  ${entry.question}`).join("\n");
 }
-export async function requestAskUserQuestionAnswers(session, toolUseId, toolName, inputData, baseToolCall) {
+function deriveAnnotation(selectedOptions, annotation) {
+    const preview = annotation?.preview?.trim().length
+        ? annotation.preview
+        : selectedOptions
+            .map((option) => option.preview?.trim() ?? "")
+            .filter((previewText) => previewText.length > 0)
+            .join("\n\n");
+    const notes = annotation?.notes?.trim().length ? annotation.notes.trim() : undefined;
+    if (!preview && !notes) {
+        return undefined;
+    }
+    return {
+        ...(preview ? { preview } : {}),
+        ...(notes ? { notes } : {}),
+    };
+}
+export async function requestAskUserQuestionAnswers(session, toolUseId, inputData, baseToolCall) {
     const prompts = parseAskUserQuestionPrompts(inputData);
     if (prompts.length === 0) {
         return { behavior: "allow", updatedInput: inputData, toolUseID: toolUseId };
     }
     const answers = {};
+    const annotations = {};
     const transcript = [];
     for (const [index, prompt] of prompts.entries()) {
         const promptToolCall = askUserQuestionPromptToolCall(baseToolCall, prompt, index, prompts.length);
@@ -128,29 +169,32 @@ export async function requestAskUserQuestionAnswers(session, toolUseId, toolName
             tracked.status = "in_progress";
             tracked.raw_input = promptToolCall.raw_input;
         }
-        const request = {
-            tool_call: promptToolCall,
-            options: askUserQuestionOptions(prompt),
-        };
+        const request = buildQuestionRequest(promptToolCall, prompt, index, prompts.length);
         const outcome = await new Promise((resolve) => {
-            session.pendingPermissions.set(toolUseId, {
+            session.pendingQuestions.set(toolUseId, {
                 onOutcome: resolve,
-                toolName,
+                toolName: ASK_USER_QUESTION_TOOL_NAME,
                 inputData,
             });
-            writeEvent({ event: "permission_request", session_id: session.sessionId, request });
+            writeEvent({ event: "question_request", session_id: session.sessionId, request });
         });
-        if (outcome.outcome !== "selected") {
+        if (outcome.outcome !== "answered") {
             setToolCallStatus(session, toolUseId, "failed", "Question cancelled");
             return { behavior: "deny", message: "Question cancelled", toolUseID: toolUseId };
         }
-        const selected = request.options.find((option) => option.option_id === outcome.option_id);
-        if (!selected) {
+        const selectedOptions = request.prompt.options.filter((option) => outcome.selected_option_ids.includes(option.option_id));
+        if (selectedOptions.length === 0 ||
+            (!prompt.multiSelect && selectedOptions.length !== 1)) {
             setToolCallStatus(session, toolUseId, "failed", "Question answer was invalid");
             return { behavior: "deny", message: "Question answer was invalid", toolUseID: toolUseId };
         }
-        answers[prompt.question] = selected.name;
-        transcript.push({ header: prompt.header, question: prompt.question, answer: selected.name });
+        const answer = selectedOptions.map((option) => option.label).join(", ");
+        answers[prompt.question] = answer;
+        const annotation = deriveAnnotation(selectedOptions, outcome.annotation);
+        if (annotation) {
+            annotations[prompt.question] = annotation;
+        }
+        transcript.push({ header: prompt.header, question: prompt.question, answer });
         const summary = askUserQuestionTranscript(transcript);
         const progressFields = {
             status: index + 1 >= prompts.length ? "completed" : "in_progress",
@@ -169,7 +213,11 @@ export async function requestAskUserQuestionAnswers(session, toolUseId, toolName
     }
     return {
         behavior: "allow",
-        updatedInput: { ...inputData, answers },
+        updatedInput: {
+            ...inputData,
+            answers,
+            ...(Object.keys(annotations).length > 0 ? { annotations } : {}),
+        },
         toolUseID: toolUseId,
     };
 }

package/agent-sdk/dist/bridge.js

@@ -1,12 +1,15 @@
 import { createRequire } from "node:module";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
 import readline from "node:readline";
 import { pathToFileURL } from "node:url";
-import { getSessionMessages, listSessions, } from "@anthropic-ai/claude-agent-sdk";
+import { getSessionMessages, listSessions, renameSession, } from "@anthropic-ai/claude-agent-sdk";
 import { parseCommandEnvelope, toPermissionMode } from "./bridge/commands.js";
-import { writeEvent, failConnection, slashError, emitSessionUpdate, emitSessionsList, } from "./bridge/events.js";
+import { writeEvent, failConnection, slashError, emitSessionUpdate, emitSessionsList, currentSessionListOptions, setSessionListingDir, } from "./bridge/events.js";
 import { textFromPrompt } from "./bridge/message_handlers.js";
-import { sessions, sessionById, createSession, closeAllSessions, handlePermissionResponse, } from "./bridge/session_lifecycle.js";
+import { sessions, sessionById, createSession, closeAllSessions, handleElicitationResponse, handlePermissionResponse, handleQuestionResponse, } from "./bridge/session_lifecycle.js";
 import { mapSessionMessagesToUpdates } from "./bridge/history.js";
+import { MCP_STALE_STATUS_REVALIDATION_COOLDOWN_MS, handleMcpAuthenticateCommand, handleMcpClearAuthCommand, handleMcpOauthCallbackUrlCommand, handleMcpReconnectCommand, handleMcpSetServersCommand, handleMcpStatusCommand, handleMcpToggleCommand, staleMcpAuthCandidates, } from "./bridge/mcp.js";
 // Re-exports: all symbols that tests and external consumers import from bridge.js.
 export { AsyncQueue, logPermissionDebug } from "./bridge/shared.js";
 export { asRecordOrNull } from "./bridge/shared.js";
@@ -14,16 +17,37 @@ export { CACHE_SPLIT_POLICY, previewKilobyteLabel } from "./bridge/cache_policy.
 export { buildToolResultFields, createToolCall, normalizeToolKind, normalizeToolResultText, unwrapToolUseResult, } from "./bridge/tooling.js";
 export { looksLikeAuthRequired } from "./bridge/auth.js";
 export { parseCommandEnvelope } from "./bridge/commands.js";
+export { buildSessionListOptions } from "./bridge/events.js";
 export { permissionOptionsFromSuggestions, permissionResultFromOutcome, } from "./bridge/permissions.js";
 export { mapSessionMessagesToUpdates, mapSdkSessions, } from "./bridge/history.js";
+export { handleTaskSystemMessage } from "./bridge/message_handlers.js";
 export { mapAvailableAgents } from "./bridge/agents.js";
-export { buildQueryOptions } from "./bridge/session_lifecycle.js";
+export { buildQueryOptions, mapAvailableModels } from "./bridge/session_lifecycle.js";
 export { parseFastModeState, parseRateLimitStatus, buildRateLimitUpdate, } from "./bridge/state_parsing.js";
-const EXPECTED_AGENT_SDK_VERSION = "0.2.63";
+export { MCP_STALE_STATUS_REVALIDATION_COOLDOWN_MS, staleMcpAuthCandidates };
+export function buildSessionMutationOptions(cwd) {
+    return cwd ? { dir: cwd } : undefined;
+}
+export function canGenerateSessionTitle(query) {
+    return typeof query.generateSessionTitle === "function";
+}
+export async function generatePersistedSessionTitle(query, description) {
+    if (!canGenerateSessionTitle(query)) {
+        throw new Error("SDK query does not support generateSessionTitle");
+    }
+    const title = await query.generateSessionTitle(description, { persist: true });
+    if (typeof title !== "string" || title.trim().length === 0) {
+        throw new Error("SDK did not return a generated session title");
+    }
+    return title;
+}
+const EXPECTED_AGENT_SDK_VERSION = "0.2.74";
 const require = createRequire(import.meta.url);
 export function resolveInstalledAgentSdkVersion() {
     try {
-        const pkg = require("@anthropic-ai/claude-agent-sdk/package.json");
+        const entryPath = require.resolve("@anthropic-ai/claude-agent-sdk");
+        const packageJsonPath = join(dirname(entryPath), "package.json");
+        const pkg = JSON.parse(readFileSync(packageJsonPath, "utf8"));
         return typeof pkg.version === "string" ? pkg.version : undefined;
     }
     catch {
@@ -54,6 +78,7 @@ async function handleCommand(command, requestId) {
                 failConnection(sdkVersionError, requestId);
                 return;
             }
+            setSessionListingDir(command.cwd);
             writeEvent({
                 event: "initialized",
                 result: {
@@ -77,6 +102,7 @@ async function handleCommand(command, requestId) {
             await emitSessionsList(requestId);
             return;
         case "create_session":
+            setSessionListingDir(command.cwd);
             await createSession({
                 cwd: command.cwd,
                 resume: command.resume,
@@ -87,12 +113,13 @@ async function handleCommand(command, requestId) {
             return;
         case "resume_session": {
             try {
-                const sdkSessions = await listSessions();
+                const sdkSessions = await listSessions(currentSessionListOptions());
                 const matched = sdkSessions.find((entry) => entry.sessionId === command.session_id);
                 if (!matched) {
                     slashError(command.session_id, `unknown session: ${command.session_id}`, requestId);
                     return;
                 }
+                setSessionListingDir(matched.cwd ?? process.cwd());
                 const historyMessages = await getSessionMessages(command.session_id, matched.cwd ? { dir: matched.cwd } : undefined);
                 const resumeUpdates = mapSessionMessagesToUpdates(historyMessages);
                 const staleSessions = Array.from(sessions.values());
@@ -115,6 +142,7 @@ async function handleCommand(command, requestId) {
         }
         case "new_session":
             await closeAllSessions();
+            setSessionListingDir(command.cwd);
             await createSession({
                 cwd: command.cwd,
                 launchSettings: command.launch_settings,
@@ -186,9 +214,132 @@ async function handleCommand(command, requestId) {
             });
             return;
         }
+        case "generate_session_title": {
+            const session = sessionById(command.session_id);
+            if (!session) {
+                slashError(command.session_id, `unknown session: ${command.session_id}`, requestId);
+                return;
+            }
+            try {
+                await 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);
+            }
+            return;
+        }
+        case "rename_session": {
+            const session = sessionById(command.session_id);
+            if (!session) {
+                slashError(command.session_id, `unknown session: ${command.session_id}`, requestId);
+                return;
+            }
+            try {
+                await renameSession(command.session_id, command.title, 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);
+            }
+            return;
+        }
+        case "get_status_snapshot": {
+            const session = sessionById(command.session_id);
+            if (!session) {
+                slashError(command.session_id, `unknown session: ${command.session_id}`, requestId);
+                return;
+            }
+            const account = await session.query.accountInfo();
+            writeEvent({
+                event: "status_snapshot",
+                session_id: session.sessionId,
+                account: {
+                    email: account.email,
+                    organization: account.organization,
+                    subscription_type: account.subscriptionType,
+                    token_source: account.tokenSource,
+                    api_key_source: account.apiKeySource,
+                },
+            }, requestId);
+            return;
+        }
+        case "mcp_status": {
+            const session = sessionById(command.session_id);
+            if (!session) {
+                slashError(command.session_id, `unknown session: ${command.session_id}`, requestId);
+                return;
+            }
+            await handleMcpStatusCommand(session, requestId);
+            return;
+        }
+        case "mcp_reconnect": {
+            const session = sessionById(command.session_id);
+            if (!session) {
+                slashError(command.session_id, `unknown session: ${command.session_id}`, requestId);
+                return;
+            }
+            await handleMcpReconnectCommand(session, command, requestId);
+            return;
+        }
+        case "mcp_toggle": {
+            const session = sessionById(command.session_id);
+            if (!session) {
+                slashError(command.session_id, `unknown session: ${command.session_id}`, requestId);
+                return;
+            }
+            await handleMcpToggleCommand(session, command, requestId);
+            return;
+        }
+        case "mcp_set_servers": {
+            const session = sessionById(command.session_id);
+            if (!session) {
+                slashError(command.session_id, `unknown session: ${command.session_id}`, requestId);
+                return;
+            }
+            await handleMcpSetServersCommand(session, command, requestId);
+            return;
+        }
+        case "mcp_authenticate": {
+            const session = sessionById(command.session_id);
+            if (!session) {
+                slashError(command.session_id, `unknown session: ${command.session_id}`, requestId);
+                return;
+            }
+            await handleMcpAuthenticateCommand(session, command, requestId);
+            return;
+        }
+        case "mcp_clear_auth": {
+            const session = sessionById(command.session_id);
+            if (!session) {
+                slashError(command.session_id, `unknown session: ${command.session_id}`, requestId);
+                return;
+            }
+            await handleMcpClearAuthCommand(session, command, requestId);
+            return;
+        }
+        case "mcp_oauth_callback_url": {
+            const session = sessionById(command.session_id);
+            if (!session) {
+                slashError(command.session_id, `unknown session: ${command.session_id}`, requestId);
+                return;
+            }
+            await handleMcpOauthCallbackUrlCommand(session, command, requestId);
+            return;
+        }
         case "permission_response":
             handlePermissionResponse(command);
             return;
+        case "question_response":
+            handleQuestionResponse(command);
+            return;
+        case "elicitation_response":
+            handleElicitationResponse(command);
+            return;
         case "shutdown":
             await closeAllSessions();
             process.exit(0);