claude-code-rust 0.12.0 → 0.12.2

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

@@ -5,15 +5,21 @@ import { query, } from "@anthropic-ai/claude-agent-sdk";
 import { bridgeLogger, LOG_TARGETS, logSdkStderrLine } from "./logger.js";
 import { AsyncQueue } from "./shared.js";
 import { permissionOptionsFromSuggestions, permissionResultFromOutcome, } from "./permissions.js";
-import { failConnection, emitSessionUpdate, emitConnectEvent, emitPermissionRequestEvent, emitElicitationRequestEvent, } from "./events.js";
+import { failConnection, emitSessionUpdate, emitConnectEvent, emitPermissionRequestEvent, emitElicitationRequestEvent, emitUserDialogRequestEvent, } from "./events.js";
 import { ensureToolCallVisible, setToolCallStatus, } from "./tool_calls.js";
 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 { mapAvailableModels, resolveCurrentModel, currentModelsEqual, } from "./model_metadata.js";
+import { shouldEmitStartupAuthRequiredForAccount } from "./account_metadata.js";
+export { mapAvailableModels, resolveCurrentModel } from "./model_metadata.js";
+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";
 function permissionDisplayFromCanUseOptions(options) {
     const title = typeof options.title === "string" ? options.title.trim() : "";
     const displayName = typeof options.displayName === "string" ? options.displayName.trim() : "";
@@ -27,20 +33,8 @@ function permissionDisplayFromCanUseOptions(options) {
         ...(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 OPUS_MODEL_ALIAS = "opus";
 const DEFAULT_PERMISSION_MODE = "default";
 function isSdkElicitationContentValue(value) {
     return (typeof value === "string" ||
@@ -60,6 +54,48 @@ function normalizeSdkElicitationContent(content) {
     }
     return Object.keys(normalized).length > 0 ? normalized : undefined;
 }
+const REFUSAL_FALLBACK_DIALOG_KIND = "refusal_fallback_prompt";
+function optionalString(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function optionalStringArray(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const entries = value.filter((entry) => typeof entry === "string");
+    return entries.length > 0 ? entries : undefined;
+}
+/**
+ * Normalize the camelCase `refusal_fallback_prompt` payload built by the CLI
+ * into the snake-case host wire shape. The dialog descriptor requires
+ * `originalModel`/`fallbackModel`; the rest are optional metadata.
+ */
+function normalizeRefusalFallbackPayload(payload) {
+    return {
+        original_model: typeof payload.originalModel === "string" ? payload.originalModel : "",
+        fallback_model: typeof payload.fallbackModel === "string" ? payload.fallbackModel : "",
+        ...(optionalString(payload.apiRefusalCategory) !== undefined
+            ? { api_refusal_category: optionalString(payload.apiRefusalCategory) }
+            : {}),
+        ...(optionalString(payload.guidanceText) !== undefined
+            ? { guidance_text: optionalString(payload.guidanceText) }
+            : {}),
+        ...(optionalStringArray(payload.retractedMessageUuids) !== undefined
+            ? { retracted_message_uuids: optionalStringArray(payload.retractedMessageUuids) }
+            : {}),
+    };
+}
+/**
+ * Build the selectable options the host renders, mirroring the labels the CLI
+ * itself produces (`function Wg$`). `cancelled` is the Esc/decline default and
+ * is not a listed option.
+ */
+function buildRefusalFallbackOptions(payload) {
+    return [
+        { option_id: "retry_fallback", label: `Switch to ${payload.fallback_model}` },
+        { option_id: "edit_prompt", label: `Edit prompt and retry with ${payload.original_model}` },
+    ];
+}
 function settingsObjectFromLaunchSettings(launchSettings) {
     return launchSettings.settings;
 }
@@ -93,77 +129,6 @@ 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();
@@ -176,6 +141,10 @@ export async function closeSession(session) {
         pending.onOutcome({ outcome: "cancelled" });
     }
     session.pendingQuestions.clear();
+    for (const pending of session.pendingUserDialogs.values()) {
+        pending.resolve("cancelled");
+    }
+    session.pendingUserDialogs.clear();
     for (const pending of session.pendingElicitations.values()) {
         pending.resolve({ action: "cancel" });
     }
@@ -305,7 +274,6 @@ export async function createSession(params) {
                 sessionIdForLogs,
             }),
         });
-        attachRequestUserDialogInterceptor(queryHandle, sessionIdForLogs);
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
@@ -343,9 +311,13 @@ export async function createSession(params) {
         connectEvent: params.connectEvent,
         connectRequestId: params.requestId,
         toolCalls: new Map(),
+        tasksById: new Map(),
+        taskOrder: [],
         taskToolUseIds: new Map(),
+        taskIdsByToolUseId: new Map(),
         pendingPermissions: new Map(),
         pendingQuestions: new Map(),
+        pendingUserDialogs: new Map(),
         pendingElicitations: new Map(),
         mcpStatusRevalidatedAt: new Map(),
         hiddenToolUseIds: new Set(),
@@ -430,16 +402,7 @@ export async function createSession(params) {
             emitAuthRequired(session);
         }
         emitFastModeUpdateIfChanged(session, result.fast_mode_state);
-        const commands = Array.isArray(result.commands)
-            ? result.commands.map((command) => ({
-                name: command.name,
-                description: command.description ?? "",
-                input_hint: command.argumentHint ?? undefined,
-            }))
-            : [];
-        if (commands.length > 0) {
-            emitSessionUpdate(session.sessionId, { type: "available_commands_update", commands });
-        }
+        updateAvailableCommands(session, "session_result_commands", mapSdkSlashCommands(result.commands));
         emitAvailableAgentsIfChanged(session, mapAvailableAgents(result.agents));
         refreshAvailableAgents(session);
     })
@@ -555,7 +518,7 @@ function permissionModeFromSettingsValue(rawMode) {
 function initialSessionModel(launchSettings) {
     const settings = settingsObjectFromLaunchSettings(launchSettings);
     const model = typeof settings?.model === "string" ? settings.model.trim() : "";
-    return model || OPUS_MODEL_ALIAS;
+    return model || STARTUP_FALLBACK_MODEL_ALIAS;
 }
 function startupModelOption(launchSettings) {
     const settings = settingsObjectFromLaunchSettings(launchSettings);
@@ -721,40 +684,92 @@ export function buildQueryOptions(params) {
                 });
             });
         },
+        // The SDK "fails closed" and never emits a dialog kind unless it is declared
+        // here. We declare the one refusal-related kind we render: when the API
+        // returns a hard `stop_reason: "refusal"` and a fallback model is configured,
+        // the CLI emits `request_user_dialog` and the host renders the chooser below.
+        supportedDialogKinds: [REFUSAL_FALLBACK_DIALOG_KIND],
+        // Host policy for `request_user_dialog` control requests. Unknown kinds are
+        // logged and answered `{ behavior: "cancelled" }` (the spec-required answer
+        // for unrecognized kinds). For `refusal_fallback_prompt`, we surface an
+        // interactive chooser in the TUI and route the user's decision back to the
+        // CLI as `{ behavior: "completed", result: <choice> }` (or cancelled on
+        // decline/abort/teardown).
+        onUserDialog: async (request, options) => {
+            if (request.dialogKind !== REFUSAL_FALLBACK_DIALOG_KIND) {
+                bridgeLogger.warn({
+                    target: LOG_TARGETS.APP_SESSION,
+                    eventName: "user_dialog_received",
+                    message: "request_user_dialog received for unknown kind; cancelled",
+                    outcome: "cancelled",
+                    sessionId: params.sessionIdForLogs(),
+                    ...(typeof request.toolUseID === "string" ? { toolCallId: request.toolUseID } : {}),
+                    fields: { dialog_kind: request.dialogKind },
+                });
+                return { behavior: "cancelled" };
+            }
+            const payload = normalizeRefusalFallbackPayload(request.payload);
+            const requestId = randomUUID();
+            const dialogRequest = {
+                request_id: requestId,
+                dialog_kind: REFUSAL_FALLBACK_DIALOG_KIND,
+                payload,
+                options: buildRefusalFallbackOptions(payload),
+            };
+            bridgeLogger.info({
+                target: LOG_TARGETS.APP_SESSION,
+                eventName: "user_dialog_received",
+                message: "request_user_dialog received; awaiting host decision",
+                outcome: "start",
+                sessionId: params.sessionIdForLogs(),
+                requestId,
+                ...(typeof request.toolUseID === "string" ? { toolCallId: request.toolUseID } : {}),
+                fields: {
+                    dialog_kind: request.dialogKind,
+                    original_model: payload.original_model,
+                    fallback_model: payload.fallback_model,
+                },
+            });
+            const choice = await new Promise((resolve) => {
+                const currentSession = sessions.get(params.sessionIdForLogs());
+                if (!currentSession) {
+                    bridgeLogger.warn({
+                        target: LOG_TARGETS.APP_SESSION,
+                        eventName: "user_dialog_request_dropped",
+                        message: "user dialog request dropped without an active session",
+                        outcome: "dropped",
+                        sessionId: params.sessionIdForLogs(),
+                        requestId,
+                        fields: { reason: "unknown_session" },
+                    });
+                    resolve("cancelled");
+                    return;
+                }
+                let settled = false;
+                const settle = (value) => {
+                    if (settled) {
+                        return;
+                    }
+                    settled = true;
+                    currentSession.pendingUserDialogs.delete(requestId);
+                    options.signal.removeEventListener("abort", onAbort);
+                    resolve(value);
+                };
+                const onAbort = () => settle("cancelled");
+                if (options.signal.aborted) {
+                    settle("cancelled");
+                    return;
+                }
+                options.signal.addEventListener("abort", onAbort);
+                currentSession.pendingUserDialogs.set(requestId, { resolve: settle });
+                emitUserDialogRequestEvent(params.sessionIdForLogs(), dialogRequest);
+            });
+            return choice === "cancelled"
+                ? { behavior: "cancelled" }
+                : { behavior: "completed", result: choice };
+        },
     };
 }
-export function mapAvailableModels(models) {
-    if (!Array.isArray(models)) {
-        return [];
-    }
-    return models
-        .filter((entry) => {
-        return (typeof entry?.value === "string" &&
-            entry.value.trim().length > 0 &&
-            typeof entry.displayName === "string" &&
-            entry.displayName.trim().length > 0);
-    })
-        .map((entry) => ({
-        id: entry.value,
-        display_name: entry.displayName,
-        supports_effort: entry.supportsEffort === true,
-        supported_effort_levels: Array.isArray(entry.supportedEffortLevels)
-            ? entry.supportedEffortLevels.filter((level) => level === "low" || level === "medium" || level === "high")
-            : [],
-        ...(typeof entry.supportsAdaptiveThinking === "boolean"
-            ? { supports_adaptive_thinking: entry.supportsAdaptiveThinking }
-            : {}),
-        ...(typeof entry.supportsFastMode === "boolean"
-            ? { supports_fast_mode: entry.supportsFastMode }
-            : {}),
-        ...(typeof entry.supportsAutoMode === "boolean"
-            ? { supports_auto_mode: entry.supportsAutoMode }
-            : {}),
-        ...(typeof entry.description === "string" && entry.description.trim().length > 0
-            ? { description: entry.description }
-            : {}),
-    }));
-}
 export function handlePermissionResponse(command) {
     bridgeLogger.info({
         target: LOG_TARGETS.BRIDGE_PERMISSION,
@@ -908,6 +923,60 @@ export function handleQuestionResponse(command) {
     });
     resolver.onOutcome(command.outcome);
 }
+export function handleUserDialogResponse(command) {
+    bridgeLogger.info({
+        target: LOG_TARGETS.BRIDGE_PERMISSION,
+        eventName: "user_dialog_response_received",
+        message: "user dialog response received",
+        outcome: "success",
+        sessionId: command.session_id,
+        requestId: command.request_id,
+        fields: {
+            response_kind: command.outcome.outcome,
+            selected_option: command.outcome.outcome === "selected" ? command.outcome.option_id : "cancelled",
+        },
+    });
+    const session = sessionById(command.session_id);
+    if (!session) {
+        bridgeLogger.warn({
+            target: LOG_TARGETS.BRIDGE_PERMISSION,
+            eventName: "user_dialog_response_dropped",
+            message: "user dialog response dropped for unknown session",
+            outcome: "dropped",
+            sessionId: command.session_id,
+            requestId: command.request_id,
+            fields: { reason: "unknown_session" },
+        });
+        return;
+    }
+    const pending = session.pendingUserDialogs.get(command.request_id);
+    if (!pending) {
+        // Idempotent: a late or duplicate response for an already-resolved request
+        // (e.g. the dialog was cancelled on abort/teardown first) is a no-op.
+        bridgeLogger.warn({
+            target: LOG_TARGETS.BRIDGE_PERMISSION,
+            eventName: "user_dialog_response_dropped",
+            message: "user dialog response dropped without a pending request",
+            outcome: "dropped",
+            sessionId: command.session_id,
+            requestId: command.request_id,
+            fields: { reason: "missing_pending_request" },
+        });
+        return;
+    }
+    session.pendingUserDialogs.delete(command.request_id);
+    const choice = command.outcome.outcome === "selected" ? command.outcome.option_id : "cancelled";
+    bridgeLogger.info({
+        target: LOG_TARGETS.BRIDGE_PERMISSION,
+        eventName: "user_dialog_response_applied",
+        message: "user dialog response applied",
+        outcome: "success",
+        sessionId: command.session_id,
+        requestId: command.request_id,
+        fields: { choice },
+    });
+    pending.resolve(choice);
+}
 export function handleElicitationResponse(command) {
     bridgeLogger.info({
         target: LOG_TARGETS.BRIDGE_PERMISSION,
@@ -968,208 +1037,10 @@ export function handleElicitationResponse(command) {
         } : {}),
     });
 }
-const MAX_MODEL_VERSION_PARTS = 2;
-const RELEASE_BUILD_TOKEN = /^20\d{6}$/;
-function normalizeModelKey(id) {
-    const original = id.trim();
-    if (!original) {
-        return { original, family: "unknown", versionParts: [], variantParts: [], buildParts: [] };
-    }
-    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 = [];
-    const variantParts = [];
-    const buildParts = [];
-    if (family !== "unknown") {
-        for (const part of parts.slice(1)) {
-            if (/^\d+$/.test(part)) {
-                if (versionParts.length < MAX_MODEL_VERSION_PARTS) {
-                    const parsed = Number.parseInt(part, 10);
-                    if (Number.isFinite(parsed)) {
-                        versionParts.push(parsed);
-                    }
-                    continue;
-                }
-                if (RELEASE_BUILD_TOKEN.test(part)) {
-                    buildParts.push(part);
-                    continue;
-                }
-            }
-            variantParts.push(part);
-        }
-    }
-    return {
-        original,
-        family,
-        versionParts,
-        variantParts,
-        buildParts,
-        ...(contextSuffix ? { contextSuffix } : {}),
-    };
-}
-function modelKeysAreCompatible(leftId, rightId) {
-    const left = normalizeModelKey(leftId);
-    const right = normalizeModelKey(rightId);
-    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 === "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 === "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 === "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 currentModelIsAuthoritative(resolvedId, requestedId) {
-    const resolved = resolvedId.trim();
-    if (!resolved || resolved === "Connecting...") {
-        return Boolean(requestedId?.trim());
-    }
-    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 ||
-        OPUS_MODEL_ALIAS;
-    const catalogModel = resolveCatalogModel(session.availableModels, resolvedId, requestedId);
-    const runtimeDisplayId = resolvedId || requestedId || OPUS_MODEL_ALIAS;
-    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;

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

@@ -36,9 +36,12 @@ export function parseRuntimeSessionState(value) {
 export function parseApiRetryError(value) {
     switch (value) {
         case "authentication_failed":
+        case "oauth_org_not_allowed":
         case "billing_error":
         case "rate_limit":
+        case "overloaded":
         case "invalid_request":
+        case "model_not_found":
         case "server_error":
         case "max_output_tokens":
             return value;
@@ -81,7 +84,10 @@ export function buildRateLimitUpdate(rateLimitInfo) {
     if (typeof info.overageDisabledReason === "string" && info.overageDisabledReason.length > 0) {
         update.overage_disabled_reason = info.overageDisabledReason;
     }
-    if (typeof info.isUsingOverage === "boolean") {
+    if (typeof info.overageInUse === "boolean") {
+        update.is_using_overage = info.overageInUse;
+    }
+    else if (typeof info.isUsingOverage === "boolean") {
         update.is_using_overage = info.isUsingOverage;
     }
     const surpassedThreshold = numberField(info, "surpassedThreshold");

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

@@ -0,0 +1,34 @@
+export function linkTaskToolUse(session, taskId, toolUseId) {
+    if (!taskId || !toolUseId) {
+        return;
+    }
+    const previousToolUseId = session.taskToolUseIds.get(taskId);
+    if (previousToolUseId && previousToolUseId !== toolUseId) {
+        const reverseTaskId = session.taskIdsByToolUseId.get(previousToolUseId);
+        if (reverseTaskId === taskId) {
+            session.taskIdsByToolUseId.delete(previousToolUseId);
+        }
+    }
+    const previousTaskId = session.taskIdsByToolUseId.get(toolUseId);
+    if (previousTaskId && previousTaskId !== taskId) {
+        const forwardToolUseId = session.taskToolUseIds.get(previousTaskId);
+        if (forwardToolUseId === toolUseId) {
+            session.taskToolUseIds.delete(previousTaskId);
+        }
+    }
+    session.taskToolUseIds.set(taskId, toolUseId);
+    session.taskIdsByToolUseId.set(toolUseId, taskId);
+}
+export function unlinkTaskToolUse(session, taskId) {
+    if (!taskId) {
+        return;
+    }
+    const toolUseId = session.taskToolUseIds.get(taskId);
+    session.taskToolUseIds.delete(taskId);
+    if (toolUseId && session.taskIdsByToolUseId.get(toolUseId) === taskId) {
+        session.taskIdsByToolUseId.delete(toolUseId);
+    }
+}
+export function activeTaskIdForToolUse(session, toolUseId) {
+    return toolUseId ? session.taskIdsByToolUseId.get(toolUseId) : undefined;
+}