claude-code-rust 0.12.1 → 0.12.2

package/agent-sdk/dist/bridge.js

@@ -7,10 +7,12 @@ import { getSessionMessages, listSessions, renameSession, } from "@anthropic-ai/
 import { buildModeState, markModeUnavailableForSession, parseCommandEnvelope, permissionModeFailureLooksUnsupported, refreshSupportedModesForSession, toPermissionMode, } from "./bridge/commands.js";
 import { writeEvent, failConnection, slashError, emitRuntimeReloadCompleted, emitRuntimeReloadFailed, emitSessionUpdate, emitSessionsList, currentSessionListOptions, setSessionListingDir, } from "./bridge/events.js";
 import { contentFromPrompt } from "./bridge/message_handlers.js";
-import { sessions, sessionById, createSession, closeAllSessions, handleElicitationResponse, handlePermissionResponse, handleQuestionResponse, emitCurrentModelUpdate, refreshCurrentModel, shouldInvalidateResolvedRuntimeModel, } from "./bridge/session_lifecycle.js";
+import { sessions, sessionById, createSession, closeAllSessions, handleElicitationResponse, handlePermissionResponse, handleQuestionResponse, handleUserDialogResponse, emitCurrentModelUpdate, refreshCurrentModel, shouldInvalidateResolvedRuntimeModel, } from "./bridge/session_lifecycle.js";
 import { mapSessionMessagesToUpdates } from "./bridge/history.js";
 import { emitAvailableAgentsIfChanged, mapAvailableAgents } from "./bridge/agents.js";
-import { MCP_STALE_STATUS_REVALIDATION_COOLDOWN_MS, handleMcpAuthenticateCommand, handleMcpClearAuthCommand, handleMcpOauthCallbackUrlCommand, handleMcpReconnectCommand, handleMcpSetServersCommand, handleMcpStatusCommand, handleMcpToggleCommand, staleMcpAuthCandidates, } from "./bridge/mcp.js";
+import { mapSdkSlashCommands, updateAvailableCommands } from "./bridge/available_commands.js";
+import { mapSdkAccountInfo } from "./bridge/account_metadata.js";
+import { MCP_STALE_STATUS_REVALIDATION_COOLDOWN_MS, emitReconciledMcpSnapshotFromStatuses, handleMcpAuthenticateCommand, handleMcpClearAuthCommand, handleMcpOauthCallbackUrlCommand, handleMcpReconnectCommand, handleMcpSetServersCommand, handleMcpStatusCommand, handleMcpToggleCommand, staleMcpAuthCandidates, } from "./bridge/mcp.js";
 import { bridgeLogger, LOG_TARGETS, logBridgeCommandReceived } from "./bridge/logger.js";
 // Re-exports: all symbols that tests and external consumers import from bridge.js.
 export { AsyncQueue } from "./bridge/shared.js";
@@ -20,11 +22,15 @@ export { buildToolResultFields, createToolCall, normalizeToolKind, normalizeTool
 export { looksLikeAuthRequired } from "./bridge/auth.js";
 export { parseCommandEnvelope } from "./bridge/commands.js";
 export { buildSessionListOptions } from "./bridge/events.js";
+export { mapInitSlashCommands, mapSdkSlashCommands, updateAvailableCommands, } from "./bridge/available_commands.js";
 export { permissionOptionsFromSuggestions, permissionResultFromOutcome, } from "./bridge/permissions.js";
 export { mapSessionMessagesToUpdates, mapSdkSessions, } from "./bridge/history.js";
 export { handleSdkMessage, handleTaskSystemMessage } from "./bridge/message_handlers.js";
 export { mapAvailableAgents } from "./bridge/agents.js";
-export { attachRequestUserDialogInterceptor, buildQueryOptions, mapAvailableModels, } from "./bridge/session_lifecycle.js";
+export { buildQueryOptions } from "./bridge/session_lifecycle.js";
+export { mapAvailableModels } from "./bridge/model_metadata.js";
+export { bridgeMcpConfigToSdk, mapMcpServerStatus, mapMcpServerStatusConfig, } from "./bridge/mcp_metadata.js";
+export { apiProviderIsExternal, isKnownApiProvider, mapSdkAccountInfo, shouldEmitStartupAuthRequiredForAccount, } from "./bridge/account_metadata.js";
 export { parseFastModeState, parseRateLimitStatus, parseRuntimeSessionState, parseApiRetryError, buildRateLimitUpdate, buildApiRetryUpdate, normalizeSettingsParseError, normalizeSettingsParseErrors, } from "./bridge/state_parsing.js";
 export { MCP_STALE_STATUS_REVALIDATION_COOLDOWN_MS, staleMcpAuthCandidates };
 export function buildSessionMutationOptions(cwd) {
@@ -43,7 +49,30 @@ export async function generatePersistedSessionTitle(query, description) {
     }
     return title;
 }
-const EXPECTED_AGENT_SDK_VERSION = "0.3.146";
+export async function applySessionEffort(query, effort) {
+    const settings = { effortLevel: effort };
+    // applyFlagSettings controls live session settings; SDK Settings typings model persisted effort levels.
+    await query.applyFlagSettings(settings);
+}
+export async function applySessionAgent(query, agent) {
+    const settings = { agent };
+    await query.applyFlagSettings(settings);
+}
+export function emitEffortConfigOptionUpdate(sessionId, effort) {
+    emitSessionUpdate(sessionId, {
+        type: "config_option_update",
+        option_id: "effortLevel",
+        value: effort,
+    });
+}
+export function emitAgentConfigOptionUpdate(sessionId, agent) {
+    emitSessionUpdate(sessionId, {
+        type: "config_option_update",
+        option_id: "agent",
+        value: agent,
+    });
+}
+const EXPECTED_AGENT_SDK_VERSION = "0.3.177";
 const require = createRequire(import.meta.url);
 export function resolveInstalledAgentSdkVersion() {
     try {
@@ -68,6 +97,28 @@ export function agentSdkVersionCompatibilityError() {
     return (`Unsupported @anthropic-ai/claude-agent-sdk version: expected ${EXPECTED_AGENT_SDK_VERSION}, ` +
         `found ${installed}.`);
 }
+export async function handleReloadPluginsCommand(session, requestId) {
+    try {
+        const result = await session.query.reloadPlugins();
+        updateAvailableCommands(session, "reload_plugins", mapSdkSlashCommands(result.commands));
+        emitAvailableAgentsIfChanged(session, mapAvailableAgents(result.agents));
+        await emitReconciledMcpSnapshotFromStatuses(session, result.mcpServers, "reload_plugins", requestId);
+        emitRuntimeReloadCompleted(session.sessionId, requestId);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        bridgeLogger.warn({
+            target: LOG_TARGETS.APP_SESSION,
+            eventName: "reload_plugins_failed",
+            message: "failed to reload session plugins",
+            outcome: "failure",
+            ...(requestId ? { requestId } : {}),
+            sessionId: session.sessionId,
+            fields: { error_message: message },
+        });
+        emitRuntimeReloadFailed(session.sessionId, message, requestId);
+    }
+}
 async function handleCommand(command, requestId) {
     logBridgeCommandReceived(command, requestId);
     const sdkVersionError = agentSdkVersionCompatibilityError();
@@ -170,7 +221,9 @@ async function handleCommand(command, requestId) {
                     return;
                 }
                 setSessionListingDir(matched.cwd ?? process.cwd());
-                const historyMessages = await getSessionMessages(command.session_id, matched.cwd ? { dir: matched.cwd } : undefined);
+                const historyMessages = await getSessionMessages(command.session_id, matched.cwd
+                    ? { dir: matched.cwd, includeSystemMessages: true }
+                    : { includeSystemMessages: true });
                 const resumeUpdates = mapSessionMessagesToUpdates(historyMessages);
                 const staleSessions = Array.from(sessions.values());
                 const hadActiveSession = staleSessions.length > 0;
@@ -377,6 +430,38 @@ async function handleCommand(command, requestId) {
             }
             return;
         }
+        case "set_effort": {
+            const session = sessionById(command.session_id);
+            if (!session) {
+                slashError(command.session_id, `unknown session: ${command.session_id}`, requestId);
+                return;
+            }
+            try {
+                await applySessionEffort(session.query, command.effort);
+                emitEffortConfigOptionUpdate(session.sessionId, command.effort);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                slashError(command.session_id, `failed to set effort: ${message}`, requestId);
+            }
+            return;
+        }
+        case "set_agent": {
+            const session = sessionById(command.session_id);
+            if (!session) {
+                slashError(command.session_id, `unknown session: ${command.session_id}`, requestId);
+                return;
+            }
+            try {
+                await applySessionAgent(session.query, command.agent);
+                emitAgentConfigOptionUpdate(session.sessionId, command.agent);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                slashError(command.session_id, `failed to set agent: ${message}`, requestId);
+            }
+            return;
+        }
         case "generate_session_title": {
             const session = sessionById(command.session_id);
             if (!session) {
@@ -438,14 +523,7 @@ async function handleCommand(command, requestId) {
                 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,
-                        api_provider: account.apiProvider,
-                    },
+                    account: mapSdkAccountInfo(account),
                 }, requestId);
             }
             catch (error) {
@@ -525,36 +603,7 @@ async function handleCommand(command, requestId) {
                 slashError(command.session_id, `unknown session: ${command.session_id}`, requestId);
                 return;
             }
-            try {
-                const result = await session.query.reloadPlugins();
-                const commands = Array.isArray(result.commands)
-                    ? result.commands.map((entry) => ({
-                        name: entry.name,
-                        description: entry.description ?? "",
-                        input_hint: entry.argumentHint ?? undefined,
-                    }))
-                    : [];
-                emitSessionUpdate(session.sessionId, {
-                    type: "available_commands_update",
-                    commands,
-                });
-                emitAvailableAgentsIfChanged(session, mapAvailableAgents(result.agents));
-                await handleMcpStatusCommand(session, requestId);
-                emitRuntimeReloadCompleted(session.sessionId, requestId);
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                bridgeLogger.warn({
-                    target: LOG_TARGETS.APP_SESSION,
-                    eventName: "reload_plugins_failed",
-                    message: "failed to reload session plugins",
-                    outcome: "failure",
-                    ...(requestId ? { requestId } : {}),
-                    sessionId: session.sessionId,
-                    fields: { error_message: message },
-                });
-                emitRuntimeReloadFailed(session.sessionId, message, requestId);
-            }
+            await handleReloadPluginsCommand(session, requestId);
             return;
         }
         case "mcp_status": {
@@ -626,6 +675,9 @@ async function handleCommand(command, requestId) {
         case "question_response":
             handleQuestionResponse(command);
             return;
+        case "user_dialog_response":
+            handleUserDialogResponse(command);
+            return;
         case "elicitation_response":
             handleElicitationResponse(command);
             return;