claude-code-rust 0.10.0 → 0.11.0

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

@@ -10,13 +10,74 @@ import { ensureToolCallVisible, setToolCallStatus, } from "./tool_calls.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 { emitAuthRequired, emitFastModeUpdateIfChanged } from "./error_classification.js";
+function permissionDisplayFromCanUseOptions(options) {
+    const title = typeof options.title === "string" ? options.title.trim() : "";
+    const displayName = typeof options.displayName === "string" ? options.displayName.trim() : "";
+    const description = typeof options.description === "string" ? options.description.trim() : "";
+    if (!title && !displayName && !description) {
+        return undefined;
+    }
+    return {
+        ...(title ? { title } : {}),
+        ...(displayName ? { display_name: displayName } : {}),
+        ...(description ? { description } : {}),
+    };
+}
+const requestUserDialogInterceptorInstalled = Symbol("requestUserDialogInterceptorInstalled");
 export const sessions = new Map();
+function nonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+export function shouldEmitStartupAuthRequiredForAccount(account) {
+    const provider = account.apiProvider;
+    if (nonEmptyString(provider) && provider !== "firstParty") {
+        return false;
+    }
+    return !nonEmptyString(account.email) && !nonEmptyString(account.apiKeySource);
+}
 const DEFAULT_SETTING_SOURCES = ["user", "project", "local"];
 const DEFAULT_MODEL_NAME = "default";
 const DEFAULT_PERMISSION_MODE = "default";
+function isSdkElicitationContentValue(value) {
+    return (typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean" ||
+        (Array.isArray(value) && value.every((entry) => typeof entry === "string")));
+}
+function normalizeSdkElicitationContent(content) {
+    if (!content) {
+        return undefined;
+    }
+    const normalized = {};
+    for (const [key, value] of Object.entries(content)) {
+        if (isSdkElicitationContentValue(value)) {
+            normalized[key] = value;
+        }
+    }
+    return Object.keys(normalized).length > 0 ? normalized : undefined;
+}
 function settingsObjectFromLaunchSettings(launchSettings) {
     return launchSettings.settings;
 }
+function normalizedSettingsFromLaunchSettings(launchSettings) {
+    const settings = settingsObjectFromLaunchSettings(launchSettings);
+    if (!settings) {
+        return undefined;
+    }
+    const sandbox = settings.sandbox && typeof settings.sandbox === "object" && !Array.isArray(settings.sandbox)
+        ? settings.sandbox
+        : undefined;
+    if (sandbox?.enabled === true && sandbox.failIfUnavailable === undefined) {
+        return {
+            ...settings,
+            sandbox: {
+                ...sandbox,
+                failIfUnavailable: false,
+            },
+        };
+    }
+    return settings;
+}
 export function sessionById(sessionId) {
     return sessions.get(sessionId) ?? null;
 }
@@ -28,6 +89,77 @@ export function updateSessionId(session, newSessionId) {
     session.sessionId = newSessionId;
     sessions.set(newSessionId, session);
 }
+function isRequestUserDialogControlRequest(value) {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    const record = value;
+    const request = record.request;
+    if (!request || typeof request !== "object") {
+        return false;
+    }
+    const inner = request;
+    const payload = inner.payload;
+    return (typeof record.request_id === "string" &&
+        inner.subtype === "request_user_dialog" &&
+        typeof inner.dialog_kind === "string" &&
+        Boolean(payload && typeof payload === "object" && !Array.isArray(payload)));
+}
+export function attachRequestUserDialogInterceptor(query, sessionIdForLogs) {
+    const internalQuery = query;
+    if (internalQuery[requestUserDialogInterceptorInstalled]) {
+        return true;
+    }
+    if (typeof internalQuery.processControlRequest !== "function") {
+        bridgeLogger.warn({
+            target: LOG_TARGETS.APP_SESSION,
+            eventName: "request_user_dialog_interceptor_unavailable",
+            message: "request_user_dialog interceptor could not be installed",
+            outcome: "failure",
+            sessionId: sessionIdForLogs(),
+        });
+        return false;
+    }
+    const originalProcessControlRequest = internalQuery.processControlRequest.bind(query);
+    internalQuery.processControlRequest = async (request, signal) => {
+        // SDK 0.2.104 also added cancel_async_message and seed_read_state control
+        // requests. Keep those delegated to the SDK internals: claude-rs does not
+        // own the SDK async-message queue or read-state cache, so TUI-level commands
+        // for them would add unsupported host behavior without user-visible value.
+        if (isRequestUserDialogControlRequest(request)) {
+            bridgeLogger.warn({
+                target: LOG_TARGETS.APP_SESSION,
+                eventName: "request_user_dialog_received",
+                message: "request_user_dialog control request received",
+                outcome: "failure",
+                sessionId: sessionIdForLogs(),
+                requestId: request.request_id,
+                ...(typeof request.request.tool_use_id === "string"
+                    ? { toolCallId: request.request.tool_use_id }
+                    : {}),
+                fields: {
+                    dialog_kind: request.request.dialog_kind,
+                    raw_payload: request.request.payload,
+                    raw_request: request.request,
+                },
+            });
+            // TODO(request_user_dialog): Revisit this when a real claude-rs host flow needs it.
+            // For now we only log the full control request and reject it explicitly because
+            // normal TUI sessions do not appear to exercise these dialog kinds.
+            throw new Error(`request_user_dialog is not supported by claude-rs yet (dialog_kind: ${request.request.dialog_kind})`);
+        }
+        return await originalProcessControlRequest(request, signal);
+    };
+    internalQuery[requestUserDialogInterceptorInstalled] = true;
+    bridgeLogger.info({
+        target: LOG_TARGETS.APP_SESSION,
+        eventName: "request_user_dialog_interceptor_installed",
+        message: "request_user_dialog interceptor installed",
+        outcome: "success",
+        sessionId: sessionIdForLogs(),
+    });
+    return true;
+}
 export async function closeSession(session) {
     session.input.close();
     session.query.close();
@@ -79,6 +211,7 @@ export async function createSession(params) {
     const provisionalSessionId = params.resume ?? randomUUID();
     const initialModel = initialSessionModel(params.launchSettings);
     const initialMode = initialSessionMode(params.launchSettings);
+    const supportsBypassPermissionsMode = startupPermissionModeOptions(params.launchSettings).allowDangerouslySkipPermissions === true;
     const historyUpdateCount = params.resumeUpdates?.length ?? 0;
     const staleSessionCount = params.sessionsToCloseAfterConnect?.length ?? 0;
     let session;
@@ -93,9 +226,11 @@ export async function createSession(params) {
         if (toolName === ASK_USER_QUESTION_TOOL_NAME) {
             return await requestAskUserQuestionAnswers(session, toolUseId, inputData, existing);
         }
+        const display = permissionDisplayFromCanUseOptions(options);
         const request = {
             tool_call: existing,
             options: permissionOptionsFromSuggestions(options.suggestions),
+            ...(display ? { display } : {}),
         };
         bridgeLogger.info({
             target: LOG_TARGETS.BRIDGE_PERMISSION,
@@ -107,6 +242,7 @@ export async function createSession(params) {
             count: request.options.length,
             fields: {
                 tool_name: toolName,
+                agent_id: options.agentID,
                 blocked_path: options.blockedPath ?? "<none>",
                 decision_reason: options.decisionReason ?? "<none>",
             },
@@ -161,6 +297,7 @@ export async function createSession(params) {
                 sessionIdForLogs,
             }),
         });
+        attachRequestUserDialogInterceptor(queryHandle, sessionIdForLogs);
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
@@ -185,8 +322,12 @@ export async function createSession(params) {
         sessionId: provisionalSessionId,
         cwd: params.cwd,
         model: initialModel,
+        ...(initialModel ? { requestedModelId: initialModel } : {}),
         availableModels: [],
         mode: initialMode,
+        supportedModeIds: [],
+        runtimeUnavailableModeIds: [],
+        supportsBypassPermissionsMode,
         fastModeState: "off",
         query: queryHandle,
         input,
@@ -207,6 +348,9 @@ export async function createSession(params) {
             ? { sessionsToCloseAfterConnect: params.sessionsToCloseAfterConnect }
             : {}),
     };
+    refreshCurrentModel(session);
+    const { refreshSupportedModesForSession } = await import("./commands.js");
+    refreshSupportedModesForSession(session);
     sessions.set(provisionalSessionId, session);
     bridgeLogger.info({
         target: LOG_TARGETS.APP_SESSION,
@@ -239,7 +383,7 @@ export async function createSession(params) {
     // before the first user prompt.
     void session.query
         .initializationResult()
-        .then((result) => {
+        .then(async (result) => {
         bridgeLogger.info({
             target: LOG_TARGETS.APP_SESSION,
             eventName: "session_initialization_completed",
@@ -254,15 +398,26 @@ export async function createSession(params) {
             },
         });
         session.availableModels = mapAvailableModels(result.models);
+        const currentModelChanged = refreshCurrentModel(session);
+        const { buildModeState, refreshSupportedModesForSession } = await import("./commands.js");
+        refreshSupportedModesForSession(session);
         if (!session.connected) {
             emitConnectEvent(session);
         }
+        else {
+            if (currentModelChanged) {
+                emitCurrentModelUpdate(session);
+            }
+            if (session.mode) {
+                emitSessionUpdate(session.sessionId, {
+                    type: "mode_state_update",
+                    mode: buildModeState(session, session.mode),
+                });
+            }
+        }
         // Proactively detect missing auth from account info so the UI can
         // show the login hint immediately, without waiting for the first prompt.
-        const acct = result.account;
-        const hasCredentials = (typeof acct.email === "string" && acct.email.trim().length > 0) ||
-            (typeof acct.apiKeySource === "string" && acct.apiKeySource.trim().length > 0);
-        if (!hasCredentials) {
+        if (shouldEmitStartupAuthRequiredForAccount(result.account)) {
             emitAuthRequired(session);
         }
         emitFastModeUpdateIfChanged(session, result.fast_mode_state);
@@ -378,6 +533,7 @@ function permissionModeFromSettingsValue(rawMode) {
     }
     switch (rawMode) {
         case "default":
+        case "auto":
         case "acceptEdits":
         case "bypassPermissions":
         case "plan":
@@ -436,12 +592,14 @@ export function buildQueryOptions(params) {
     const systemPrompt = systemPromptFromLaunchSettings(params.launchSettings);
     const modelOption = startupModelOption(params.launchSettings);
     const permissionModeOptions = startupPermissionModeOptions(params.launchSettings);
+    const settings = normalizedSettingsFromLaunchSettings(params.launchSettings);
     return {
         cwd: params.cwd,
         includePartialMessages: true,
+        promptSuggestions: true,
         executable: "node",
         ...(params.resume ? {} : { sessionId: params.provisionalSessionId }),
-        ...(params.launchSettings.settings ? { settings: params.launchSettings.settings } : {}),
+        ...(settings ? { settings } : {}),
         ...modelOption,
         ...permissionModeOptions,
         toolConfig: { askUserQuestion: { previewFormat: "markdown" } },
@@ -795,6 +953,230 @@ export function handleElicitationResponse(command) {
     });
     pending.resolve({
         action: command.action,
-        ...(command.content ? { content: command.content } : {}),
+        ...(normalizeSdkElicitationContent(command.content) ? {
+            content: normalizeSdkElicitationContent(command.content),
+        } : {}),
     });
 }
+function normalizeModelKey(id) {
+    const original = id.trim();
+    if (!original || original === DEFAULT_MODEL_NAME) {
+        return { original, family: "default", versionParts: [], variantParts: [] };
+    }
+    const lower = original.toLowerCase();
+    const contextMatch = lower.match(/\[([^\]]+)\]$/);
+    const contextSuffix = contextMatch?.[1];
+    const withoutContext = contextMatch ? lower.slice(0, contextMatch.index) : lower;
+    const withoutPrefix = withoutContext.startsWith("claude-")
+        ? withoutContext.slice("claude-".length)
+        : withoutContext;
+    const parts = withoutPrefix.split("-").filter((part) => part.length > 0);
+    const familyPart = parts[0] ?? "";
+    const family = familyPart === "opus" || familyPart === "sonnet" || familyPart === "haiku"
+        ? familyPart
+        : "unknown";
+    const versionParts = family === "unknown"
+        ? []
+        : parts
+            .slice(1)
+            .filter((part) => /^\d+$/.test(part))
+            .map((part) => Number.parseInt(part, 10))
+            .filter((part) => Number.isFinite(part));
+    const variantParts = family === "unknown"
+        ? []
+        : parts
+            .slice(1)
+            .filter((part) => !/^\d+$/.test(part));
+    return {
+        original,
+        family,
+        versionParts,
+        variantParts,
+        ...(contextSuffix ? { contextSuffix } : {}),
+    };
+}
+function modelKeysAreCompatible(leftId, rightId) {
+    const left = normalizeModelKey(leftId);
+    const right = normalizeModelKey(rightId);
+    if (left.family === "default" || right.family === "default") {
+        return false;
+    }
+    if (left.family === "unknown" || right.family === "unknown") {
+        return left.original.toLowerCase() === right.original.toLowerCase();
+    }
+    if (left.family !== right.family) {
+        return false;
+    }
+    if (left.variantParts.join(".") !== right.variantParts.join(".")) {
+        return false;
+    }
+    if (left.versionParts.length === 0 || right.versionParts.length === 0) {
+        return true;
+    }
+    return left.versionParts.join(".") === right.versionParts.join(".");
+}
+function sameContextSuffix(leftId, rightId) {
+    const left = normalizeModelKey(leftId);
+    const right = normalizeModelKey(rightId);
+    return (left.contextSuffix?.toLowerCase() ?? "") === (right.contextSuffix?.toLowerCase() ?? "");
+}
+function sameFamilyAndVersion(leftId, rightId) {
+    const left = normalizeModelKey(leftId);
+    const right = normalizeModelKey(rightId);
+    if (left.family === "default" || right.family === "default") {
+        return false;
+    }
+    if (left.family === "unknown" || right.family === "unknown") {
+        return left.original.toLowerCase() === right.original.toLowerCase();
+    }
+    if (left.family !== right.family) {
+        return false;
+    }
+    if (left.versionParts.length === 0 || right.versionParts.length === 0) {
+        return left.versionParts.length === right.versionParts.length;
+    }
+    return left.versionParts.join(".") === right.versionParts.join(".");
+}
+function hasVariantSiblingConflict(availableModels, candidateId, resolvedId) {
+    if (sameContextSuffix(candidateId, resolvedId)) {
+        return false;
+    }
+    const resolvedContext = normalizeModelKey(resolvedId).contextSuffix?.toLowerCase() ?? "";
+    if (!resolvedContext) {
+        return false;
+    }
+    return availableModels.some((entry) => {
+        if (entry.id === candidateId) {
+            return false;
+        }
+        if (!sameFamilyAndVersion(entry.id, resolvedId)) {
+            return false;
+        }
+        const entryContext = normalizeModelKey(entry.id).contextSuffix?.toLowerCase() ?? "";
+        return entryContext === resolvedContext;
+    });
+}
+function humanizeModelId(id) {
+    const normalized = normalizeModelKey(id);
+    if (normalized.family === "default") {
+        return "Default";
+    }
+    if (normalized.family === "unknown") {
+        return id;
+    }
+    const familyLabel = normalized.family === "opus"
+        ? "Opus"
+        : normalized.family === "sonnet"
+            ? "Sonnet"
+            : "Haiku";
+    const versionLabel = normalized.versionParts.length > 0 ? ` ${normalized.versionParts.join(".")}` : "";
+    const contextLabel = normalized.contextSuffix?.toLowerCase() === "1m"
+        ? " [1M]"
+        : normalized.contextSuffix
+            ? ` [${normalized.contextSuffix}]`
+            : "";
+    return `${familyLabel}${versionLabel}${contextLabel}`;
+}
+function shortDisplayNameForModelId(id) {
+    const normalized = normalizeModelKey(id);
+    if (normalized.family === "default") {
+        return "Default";
+    }
+    if (normalized.family === "unknown") {
+        return id;
+    }
+    const familyLabel = normalized.family === "opus"
+        ? "Opus"
+        : normalized.family === "sonnet"
+            ? "Sonnet"
+            : "Haiku";
+    const contextLabel = normalized.contextSuffix?.toLowerCase() === "1m"
+        ? " [1M]"
+        : normalized.contextSuffix
+            ? ` [${normalized.contextSuffix}]`
+            : "";
+    return `${familyLabel}${contextLabel}`;
+}
+function currentModelIsAuthoritative(resolvedId, requestedId) {
+    const resolved = resolvedId.trim();
+    if (!resolved || resolved === DEFAULT_MODEL_NAME || resolved === "Connecting...") {
+        return Boolean(requestedId?.trim() && requestedId.trim() !== DEFAULT_MODEL_NAME);
+    }
+    return true;
+}
+function resolveCatalogModel(availableModels, resolvedId, requestedId) {
+    const exactResolved = availableModels.find((entry) => entry.id === resolvedId);
+    if (exactResolved) {
+        return exactResolved;
+    }
+    if (requestedId) {
+        const exactRequested = availableModels.find((entry) => entry.id === requestedId);
+        if (exactRequested &&
+            modelKeysAreCompatible(exactRequested.id, resolvedId) &&
+            !hasVariantSiblingConflict(availableModels, exactRequested.id, resolvedId)) {
+            return exactRequested;
+        }
+    }
+    const compatible = availableModels.filter((entry) => modelKeysAreCompatible(entry.id, resolvedId) &&
+        !hasVariantSiblingConflict(availableModels, entry.id, resolvedId));
+    return compatible.length === 1 ? compatible[0] : undefined;
+}
+export function resolveCurrentModel(session) {
+    const requestedId = session.requestedModelId?.trim() || undefined;
+    const resolvedId = session.resolvedRuntimeModelId?.trim() ||
+        session.model.trim() ||
+        requestedId ||
+        DEFAULT_MODEL_NAME;
+    const catalogModel = resolveCatalogModel(session.availableModels, resolvedId, requestedId);
+    const runtimeDisplayId = resolvedId || requestedId || DEFAULT_MODEL_NAME;
+    const displayNameShort = shortDisplayNameForModelId(runtimeDisplayId);
+    const displayNameLong = humanizeModelId(runtimeDisplayId);
+    const currentModel = {
+        resolved_id: resolvedId,
+        display_name_short: displayNameShort,
+        display_name_long: displayNameLong,
+        supports_effort: catalogModel?.supports_effort === true,
+        supported_effort_levels: catalogModel?.supported_effort_levels ?? [],
+        is_authoritative: currentModelIsAuthoritative(resolvedId, requestedId),
+        ...(requestedId ? { requested_id: requestedId } : {}),
+        ...(catalogModel ? { catalog_id: catalogModel.id } : {}),
+        ...(catalogModel?.supports_fast_mode !== undefined
+            ? { supports_fast_mode: catalogModel.supports_fast_mode }
+            : {}),
+        ...(catalogModel?.supports_auto_mode !== undefined
+            ? { supports_auto_mode: catalogModel.supports_auto_mode }
+            : {}),
+        ...(catalogModel?.supports_adaptive_thinking !== undefined
+            ? { supports_adaptive_thinking: catalogModel.supports_adaptive_thinking }
+            : {}),
+    };
+    return currentModel;
+}
+export function shouldInvalidateResolvedRuntimeModel(previousRequestedId, previousSessionModel, nextRequestedId) {
+    const previousRequested = previousRequestedId?.trim() || previousSessionModel.trim();
+    return previousRequested !== nextRequestedId.trim();
+}
+function currentModelsEqual(left, right) {
+    return JSON.stringify(left) === JSON.stringify(right);
+}
+export function emitCurrentModelUpdate(session) {
+    if (!session.connected || !session.currentModel) {
+        return false;
+    }
+    emitSessionUpdate(session.sessionId, {
+        type: "current_model_update",
+        current_model: session.currentModel,
+    });
+    return true;
+}
+export function refreshCurrentModel(session, emitUpdate = false) {
+    const nextModel = resolveCurrentModel(session);
+    if (currentModelsEqual(session.currentModel, nextModel)) {
+        return false;
+    }
+    session.currentModel = nextModel;
+    if (emitUpdate) {
+        emitCurrentModelUpdate(session);
+    }
+    return true;
+}

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

@@ -20,6 +20,25 @@ export function parseRateLimitStatus(value) {
     }
     return null;
 }
+export function parseRuntimeSessionState(value) {
+    if (value === "idle" || value === "running" || value === "requires_action") {
+        return value;
+    }
+    return null;
+}
+export function parseApiRetryError(value) {
+    switch (value) {
+        case "authentication_failed":
+        case "billing_error":
+        case "rate_limit":
+        case "invalid_request":
+        case "server_error":
+        case "max_output_tokens":
+            return value;
+        default:
+            return "unknown";
+    }
+}
 export function buildRateLimitUpdate(rateLimitInfo) {
     const info = asRecordOrNull(rateLimitInfo);
     if (!info) {
@@ -64,3 +83,45 @@ export function buildRateLimitUpdate(rateLimitInfo) {
     }
     return update;
 }
+export function buildApiRetryUpdate(message) {
+    const attempt = numberField(message, "attempt");
+    const maxRetries = numberField(message, "max_retries", "maxRetries");
+    const retryDelayMs = numberField(message, "retry_delay_ms", "retryDelayMs");
+    if (attempt === undefined || maxRetries === undefined || retryDelayMs === undefined) {
+        return null;
+    }
+    const rawStatus = message.error_status ?? message.errorStatus;
+    const errorStatus = typeof rawStatus === "number" && Number.isFinite(rawStatus) ? rawStatus : null;
+    return {
+        type: "api_retry_update",
+        attempt,
+        max_retries: maxRetries,
+        retry_delay_ms: retryDelayMs,
+        error_status: errorStatus,
+        error: parseApiRetryError(message.error),
+    };
+}
+export function normalizeSettingsParseError(value) {
+    const record = asRecordOrNull(value);
+    if (!record) {
+        return null;
+    }
+    const message = typeof record.message === "string" ? record.message.trim() : "";
+    if (!message) {
+        return null;
+    }
+    const path = typeof record.path === "string" ? record.path : "";
+    const file = typeof record.file === "string" && record.file.trim() ? record.file : undefined;
+    return {
+        ...(file ? { file } : {}),
+        path,
+        message,
+    };
+}
+export function normalizeSettingsParseErrors(value) {
+    const entries = Array.isArray(value) ? value : [value];
+    return entries.flatMap((entry) => {
+        const normalized = normalizeSettingsParseError(entry);
+        return normalized ? [normalized] : [];
+    });
+}