@getpaseo/server 0.1.97 → 0.1.98

package/dist/server/server/agent/providers/claude/agent.js

@@ -9,13 +9,14 @@ import { getClaudeModelsWithSettings, normalizeClaudeRuntimeModelId } from "./mo
 import { parsePartialJsonObject } from "./partial-json.js";
 import { ClaudeSidechainTracker } from "./sidechain-tracker.js";
 import { buildClaudeFeatures, claudeModelSupportsFastMode } from "./feature-definitions.js";
-import { buildBinaryDiagnosticRows, formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, toDiagnosticErrorMessage, } from "../diagnostic-utils.js";
+import { buildBinaryDiagnosticRows, buildCommandResolutionDiagnosticRows, formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, toDiagnosticErrorMessage, } from "../diagnostic-utils.js";
 import { appendOrReplaceGrowingAssistantMessage, runProviderTurn } from "../provider-runner.js";
 import { renderPromptAttachmentAsText } from "../../prompt-attachments.js";
 import { claudeQuery } from "./query.js";
 import { realClaudeRewindSdk, revertClaudeConversation, revertClaudeFiles } from "./rewind.js";
 import { normalizeProviderReplayTimestamp } from "../../provider-history-timestamps.js";
 import { claudeProjectDirSync } from "./project-dir.js";
+import { SETTING_APPLIES_NEXT_TURN_NOTICE } from "../../provider-notices.js";
 import { getAgentStreamEventTurnId, } from "../../agent-sdk-types.js";
 import { importSessionFromPersistence } from "../../provider-session-import.js";
 import { checkProviderLaunchAvailable, createProviderEnv, createProviderEnvSpec, resolveProviderLaunch, } from "../../provider-launch-config.js";
@@ -228,6 +229,9 @@ function isClaudeThinkingEffort(value) {
         value === "xhigh" ||
         value === "max");
 }
+function isClaudeThinkingOption(value) {
+    return value === "ultracode" || isClaudeThinkingEffort(value);
+}
 const MAX_RECENT_STDERR_CHARS = 4000;
 const STDERR_FLUSH_WAIT_MS = 150;
 const STDERR_FLUSH_POLL_INTERVAL_MS = 10;
@@ -1099,6 +1103,9 @@ export class ClaudeAgentClient {
             }
             return {
                 diagnostic: formatProviderDiagnostic("Claude Code", [
+                    ...(await buildCommandResolutionDiagnosticRows(launch, {
+                        knownBinaryNames: ["claude"],
+                    })),
                     ...(await buildBinaryDiagnosticRows(launch, availability)),
                     ...(auth ? [{ label: "Auth", value: auth }] : []),
                     { label: "Models", value: modelsValue },
@@ -1180,21 +1187,21 @@ function extractContextWindowSize(modelUsage) {
     }
     return maxContextWindow;
 }
-function readUsageTotalTokens(usage) {
-    if (!usage || typeof usage !== "object") {
+function resolveInitialContextWindowSize(modelId) {
+    const normalized = typeof modelId === "string" ? modelId.trim().toLowerCase() : "";
+    if (!normalized) {
         return undefined;
     }
-    const totalTokens = usage.total_tokens;
-    if (typeof totalTokens !== "number" || !Number.isFinite(totalTokens) || totalTokens < 0) {
-        return undefined;
+    if (normalized.includes("[1m]") || normalized.includes("context-1m")) {
+        return 1000000;
     }
-    return totalTokens;
-}
-function readContextWindowUsedTokensFromTaskProgress(message) {
-    return readUsageTotalTokens(message.usage);
-}
-function readUsageFromTaskNotification(message) {
-    return readUsageTotalTokens(message.usage);
+    if (normalized.includes("claude-fable-5")) {
+        return 1000000;
+    }
+    if (/(?:^|[~/_-])(?:claude[-_ ]*)?(opus|sonnet|haiku)(?:$|[-_ ./])/.test(normalized)) {
+        return 200000;
+    }
+    return undefined;
 }
 function readStreamRequestInputTokens(event) {
     const messageUsage = toObjectRecord(toObjectRecord(event.message)?.usage);
@@ -1225,6 +1232,172 @@ function readStreamRequestOutputTokens(event) {
     }
     return outputTokens;
 }
+function readLastUsageIteration(usage) {
+    const iterations = toObjectRecord(usage)?.iterations;
+    if (!Array.isArray(iterations)) {
+        return undefined;
+    }
+    for (let index = iterations.length - 1; index >= 0; index -= 1) {
+        const candidate = toObjectRecord(iterations[index]);
+        if (candidate) {
+            return candidate;
+        }
+    }
+    return undefined;
+}
+function readUsageTokenTotal(usage) {
+    const usageWithCacheCreation = usage;
+    const inputTokens = typeof usage.input_tokens === "number" && Number.isFinite(usage.input_tokens)
+        ? usage.input_tokens
+        : 0;
+    const cacheCreationInputTokens = typeof usageWithCacheCreation.cache_creation_input_tokens === "number" &&
+        Number.isFinite(usageWithCacheCreation.cache_creation_input_tokens)
+        ? usageWithCacheCreation.cache_creation_input_tokens
+        : 0;
+    const cacheReadInputTokens = typeof usage.cache_read_input_tokens === "number" &&
+        Number.isFinite(usage.cache_read_input_tokens)
+        ? usage.cache_read_input_tokens
+        : 0;
+    const outputTokens = typeof usage.output_tokens === "number" && Number.isFinite(usage.output_tokens)
+        ? usage.output_tokens
+        : 0;
+    const total = inputTokens + cacheCreationInputTokens + cacheReadInputTokens + outputTokens;
+    return total > 0 ? total : undefined;
+}
+function readActiveUsageTokens(usage) {
+    const activeUsage = readLastUsageIteration(usage);
+    return activeUsage ? readUsageTokenTotal(activeUsage) : undefined;
+}
+function readLegacyResultUsageTokens(usage) {
+    const usageRecord = toObjectRecord(usage);
+    return usageRecord ? readUsageTokenTotal(usageRecord) : undefined;
+}
+function readCurrentContextUsage(value) {
+    const record = toObjectRecord(value);
+    if (!record) {
+        return undefined;
+    }
+    const totalTokens = record.totalTokens;
+    if (typeof totalTokens !== "number" || !Number.isFinite(totalTokens) || totalTokens < 0) {
+        return undefined;
+    }
+    const maxTokens = record.maxTokens;
+    return {
+        totalTokens,
+        ...(typeof maxTokens === "number" && Number.isFinite(maxTokens) && maxTokens > 0
+            ? { maxTokens }
+            : {}),
+    };
+}
+function isClaudeSubagentToolName(name) {
+    return name === "Task" || name === "Agent";
+}
+class ClaudeContextUsageState {
+    constructor(initialContextWindowMaxTokens) {
+        this.completedResultTurns = 0;
+        this.contextWindowMaxTokens = initialContextWindowMaxTokens;
+    }
+    beginTurn() {
+        this.streamRequestInputTokens = undefined;
+        this.streamRequestOutputTokens = undefined;
+    }
+    setInitialContextWindowMaxTokens(contextWindowMaxTokens) {
+        this.contextWindowMaxTokens = contextWindowMaxTokens;
+    }
+    recordModelUsage(modelUsage) {
+        const contextWindowMaxTokens = extractContextWindowSize(modelUsage);
+        if (contextWindowMaxTokens !== undefined) {
+            this.contextWindowMaxTokens = contextWindowMaxTokens;
+        }
+        return this.contextWindowMaxTokens;
+    }
+    recordCurrentContextUsage(usage) {
+        if (usage?.maxTokens !== undefined) {
+            this.contextWindowMaxTokens = usage.maxTokens;
+        }
+    }
+    buildStreamUsageEvent(event) {
+        const streamEvent = toObjectRecord(event);
+        if (!streamEvent) {
+            return null;
+        }
+        const eventType = readTrimmedString(streamEvent.type);
+        if (eventType === "message_start") {
+            const inputTokens = readStreamRequestInputTokens(streamEvent);
+            if (typeof inputTokens !== "number") {
+                return null;
+            }
+            this.streamRequestInputTokens = inputTokens;
+            this.streamRequestOutputTokens = 0;
+        }
+        else if (eventType === "message_delta") {
+            const outputTokens = readStreamRequestOutputTokens(streamEvent);
+            if (typeof outputTokens !== "number") {
+                return null;
+            }
+            this.streamRequestOutputTokens = outputTokens;
+        }
+        else {
+            return null;
+        }
+        const usedTokens = this.streamUsedTokens();
+        if (usedTokens === undefined) {
+            return null;
+        }
+        return this.createUsageUpdatedEvent(usedTokens);
+    }
+    buildResultUsage(message, modelUsage, currentContextUsage) {
+        try {
+            if (!message.usage) {
+                return undefined;
+            }
+            const usage = {
+                inputTokens: message.usage.input_tokens,
+                cachedInputTokens: message.usage.cache_read_input_tokens,
+                outputTokens: message.usage.output_tokens,
+                totalCostUsd: message.total_cost_usd,
+            };
+            const modelContextWindowMaxTokens = this.recordModelUsage(modelUsage ?? message.modelUsage);
+            this.recordCurrentContextUsage(currentContextUsage);
+            if (this.contextWindowMaxTokens !== undefined) {
+                usage.contextWindowMaxTokens = this.contextWindowMaxTokens;
+            }
+            else if (modelContextWindowMaxTokens !== undefined) {
+                usage.contextWindowMaxTokens = modelContextWindowMaxTokens;
+            }
+            const activeResultUsageTokens = readActiveUsageTokens(message.usage) ??
+                (this.completedResultTurns === 0 ? readLegacyResultUsageTokens(message.usage) : undefined);
+            const usedTokens = currentContextUsage?.totalTokens ?? this.streamUsedTokens() ?? activeResultUsageTokens;
+            if (usedTokens !== undefined) {
+                usage.contextWindowUsedTokens = usedTokens;
+            }
+            return usage;
+        }
+        finally {
+            this.completedResultTurns += 1;
+        }
+    }
+    streamUsedTokens() {
+        if (typeof this.streamRequestInputTokens !== "number" ||
+            typeof this.streamRequestOutputTokens !== "number") {
+            return undefined;
+        }
+        return this.streamRequestInputTokens + this.streamRequestOutputTokens;
+    }
+    createUsageUpdatedEvent(contextWindowUsedTokens) {
+        const usage = {
+            contextWindowUsedTokens,
+        };
+        if (this.contextWindowMaxTokens !== undefined) {
+            usage.contextWindowMaxTokens = this.contextWindowMaxTokens;
+        }
+        return {
+            type: "usage_updated",
+            provider: "claude",
+            usage,
+        };
+    }
+}
 class ClaudeAgentSession {
     constructor(config, options) {
         this.provider = "claude";
@@ -1344,6 +1517,7 @@ class ClaudeAgentSession {
         this.logger = options.logger.child({ agentId: this.agentId });
         this.queryFactory = options.queryFactory;
         this.resolveBinary = options.resolveBinary;
+        this.contextUsage = new ClaudeContextUsageState(resolveInitialContextWindowSize(this.config.model));
         const handle = options.handle;
         if (handle) {
             if (!handle.sessionId) {
@@ -1441,6 +1615,7 @@ class ClaudeAgentSession {
         this.activeForegroundTurnId = turnId;
         this.foregroundHasVisibleActivity = false;
         this.activeTurnHasAssistantText = false;
+        this.contextUsage.beginTurn();
         this.transitionTurnState("foreground", "foreground turn started");
         this.clearRecentStderr();
         let cancelIssued = false;
@@ -1550,6 +1725,7 @@ class ClaudeAgentSession {
         if (!claudeModelSupportsFastMode(this.config.model) && this.config.featureValues?.fast_mode) {
             await this.applyFastModeFeature(false, activeQuery);
         }
+        this.contextUsage.setInitialContextWindowMaxTokens(resolveInitialContextWindowSize(this.config.model));
         this.lastOptionsModel = normalizedModelId ?? this.lastOptionsModel;
         this.lastRuntimeModel = null;
         this.cachedRuntimeInfo = null;
@@ -1563,13 +1739,16 @@ class ClaudeAgentSession {
         if (!normalizedThinkingOptionId || normalizedThinkingOptionId === "default") {
             this.config.thinkingOptionId = undefined;
         }
-        else if (isClaudeThinkingEffort(normalizedThinkingOptionId)) {
+        else if (isClaudeThinkingOption(normalizedThinkingOptionId)) {
             this.config.thinkingOptionId = normalizedThinkingOptionId;
         }
         else {
             throw new Error(`Unknown thinking option: ${normalizedThinkingOptionId}`);
         }
         this.queryRestartNeeded = true;
+        if (this.activeForegroundTurnId || this.autonomousTurn) {
+            return SETTING_APPLIES_NEXT_TURN_NOTICE;
+        }
     }
     async setFeature(featureId, value) {
         if (featureId !== "fast_mode") {
@@ -2096,10 +2275,13 @@ class ClaudeAgentSession {
         const thinkingOptionId = this.config.thinkingOptionId && this.config.thinkingOptionId !== "default"
             ? this.config.thinkingOptionId
             : undefined;
+        if (thinkingOptionId === "ultracode") {
+            return { thinking: { type: "adaptive" }, effort: "xhigh", ultracode: true };
+        }
         if (thinkingOptionId && isClaudeThinkingEffort(thinkingOptionId)) {
-            return { thinking: { type: "adaptive" }, effort: thinkingOptionId };
+            return { thinking: { type: "adaptive" }, effort: thinkingOptionId, ultracode: false };
         }
-        return { thinking: undefined, effort: undefined };
+        return { thinking: undefined, effort: undefined, ultracode: false };
     }
     buildAppendedSystemPrompt() {
         return (composeSystemPromptParts(this.config.systemPrompt, this.config.daemonAppendSystemPrompt) ?? "");
@@ -2120,10 +2302,10 @@ class ClaudeAgentSession {
         });
     }
     async buildOptions() {
-        const { thinking, effort } = this.resolveThinkingConfig();
+        const { thinking, effort, ultracode } = this.resolveThinkingConfig();
         const appendedSystemPrompt = this.buildAppendedSystemPrompt();
         const extraClaudeOptions = this.config.extra?.claude;
-        const fastModeOptions = this.buildFastModeOptions(extraClaudeOptions);
+        const settingsOptions = this.buildSettingsOptions(extraClaudeOptions, { ultracode });
         const sdkEnv = this.buildSdkEnv(extraClaudeOptions);
         assertClaudeAutoModeEligible(this.currentMode, sdkEnv);
         const claudeBinary = await this.resolveBinary();
@@ -2172,7 +2354,7 @@ class ClaudeAgentSession {
             ...(thinking ? { thinking } : {}),
             ...(effort ? { effort } : {}),
             ...extraClaudeOptions,
-            ...fastModeOptions,
+            ...settingsOptions,
             ...(this.persistSession === undefined ? {} : { persistSession: this.persistSession }),
             env: sdkEnv,
         };
@@ -2194,12 +2376,17 @@ class ClaudeAgentSession {
         }
         return base;
     }
-    buildFastModeOptions(extraClaudeOptions) {
+    buildSettingsOptions(extraClaudeOptions, input) {
         const fastMode = this.resolveFastModeSetting();
-        if (fastMode === null) {
+        if (fastMode === null && !input.ultracode) {
             return {};
         }
-        return { settings: mergeClaudeSettings(extraClaudeOptions?.settings, { fastMode }) };
+        return {
+            settings: mergeClaudeSettings(extraClaudeOptions?.settings, {
+                ...(fastMode === null ? {} : { fastMode }),
+                ...(input.ultracode ? { ultracode: true } : {}),
+            }),
+        };
     }
     resolveFastModeSetting() {
         if (!claudeModelSupportsFastMode(this.config.model)) {
@@ -2413,6 +2600,7 @@ class ClaudeAgentSession {
             id: this.createTurnId("autonomous"),
         };
         this.activeTurnHasAssistantText = false;
+        this.contextUsage.beginTurn();
         this.notifySubscribers({ type: "turn_started", provider: "claude" });
         this.syncTurnState("autonomous turn started");
     }
@@ -2491,7 +2679,7 @@ class ClaudeAgentSession {
             if (await this.handleMissingResumedConversation(message, activeQuery)) {
                 return true;
             }
-            this.routeSdkMessageFromPump(message);
+            await this.routeSdkMessageFromPump(message, activeQuery);
             return false;
         };
         const drainActiveQuery = async () => {
@@ -2559,7 +2747,7 @@ class ClaudeAgentSession {
             message.type === "tool_progress" ||
             (message.type === "system" && message.subtype === "task_notification"));
     }
-    routeSdkMessageFromPump(message) {
+    async routeSdkMessageFromPump(message, activeQuery) {
         if (this.shouldSuppressStaleResult(message)) {
             return;
         }
@@ -2582,22 +2770,7 @@ class ClaudeAgentSession {
             identifiers,
             rawEvent: message,
         }, "provider.claude.parsed_event");
-        const messageEvents = this.translateMessageToEvents(message, {
-            suppressAssistantText: true,
-            suppressReasoning: true,
-        });
-        const assistantTimelineEvents = this.timelineAssembler
-            .consume({
-            message,
-            runId: turnId,
-            messageIdHint: identifiers.messageId,
-        })
-            .map((item) => ({
-            type: "timeline",
-            item,
-            provider: "claude",
-        }));
-        const events = [...messageEvents, ...assistantTimelineEvents];
+        const events = await this.buildPumpedMessageEvents(message, activeQuery, identifiers.messageId, turnId);
         if (events.length === 0) {
             return;
         }
@@ -2620,6 +2793,38 @@ class ClaudeAgentSession {
         }
         this.dispatchEvents(events);
     }
+    async buildPumpedMessageEvents(message, activeQuery, messageIdHint, turnId) {
+        const currentContextUsage = message.type === "result" && message.subtype === "success"
+            ? await this.queryCurrentContextUsage(activeQuery)
+            : undefined;
+        const messageEvents = this.translateMessageToEvents(message, {
+            suppressAssistantText: true,
+            suppressReasoning: true,
+            currentContextUsage,
+        });
+        const assistantTimelineEvents = this.timelineAssembler
+            .consume({
+            message,
+            runId: turnId,
+            messageIdHint,
+        })
+            .map((item) => ({
+            type: "timeline",
+            item,
+            provider: "claude",
+        }));
+        return [...messageEvents, ...assistantTimelineEvents];
+    }
+    async queryCurrentContextUsage(activeQuery) {
+        try {
+            const usage = await withTimeout(activeQuery.getContextUsage(), 3000, "timeout");
+            return readCurrentContextUsage(usage);
+        }
+        catch (error) {
+            this.logger.debug({ err: error }, "Claude context usage query failed");
+            return undefined;
+        }
+    }
     async handleMissingResumedConversation(message, activeQuery) {
         const staleResumeError = this.readMissingResumedConversationError(message);
         if (!staleResumeError) {
@@ -2710,7 +2915,9 @@ class ClaudeAgentSession {
                 this.appendStreamEventEvents(message, events, options);
                 break;
             case "result":
-                this.appendResultEvents(message, events);
+                this.appendResultEvents(message, events, {
+                    currentContextUsage: options?.currentContextUsage,
+                });
                 break;
             default:
                 break;
@@ -2783,22 +2990,18 @@ class ClaudeAgentSession {
             return;
         }
         if (message.subtype === "task_progress") {
-            this.lastContextWindowUsedTokens =
-                readContextWindowUsedTokensFromTaskProgress(message) ?? this.lastContextWindowUsedTokens;
-            if (typeof this.lastContextWindowUsedTokens === "number") {
-                events.push(this.createUsageUpdatedEvent(this.lastContextWindowUsedTokens));
-            }
+            return;
         }
     }
     appendTaskNotificationEvents(message, events) {
         // TODO: subagent timelines are best-effort. Subagent task_notifications
         // arrive without parent_tool_use_id but with tool_use_id pointing at the
-        // parent's Task call, so they slip past the sidechain router and pollute
+        // the parent's subagent tool call, so they slip past the sidechain router and pollute
         // the parent timeline. Drop them here; eventually thread them into the
-        // parent Task tool call's sub_agent log instead.
+        // parent tool call's sub_agent log instead.
         const taskUseId = message.tool_use_id;
         const cachedTool = taskUseId ? this.toolUseCache.get(taskUseId) : undefined;
-        if (cachedTool?.name === "Task") {
+        if (isClaudeSubagentToolName(cachedTool?.name)) {
             return;
         }
         const taskNotificationItem = mapTaskNotificationSystemRecordToToolCall(message);
@@ -2809,11 +3012,6 @@ class ClaudeAgentSession {
                 provider: "claude",
             });
         }
-        const usage = readUsageFromTaskNotification(message);
-        if (typeof usage === "number") {
-            this.lastContextWindowUsedTokens = usage;
-            events.push(this.createUsageUpdatedEvent(usage));
-        }
     }
     appendUserMessageEvents(message, events) {
         if (isSyntheticUserEntry(message)) {
@@ -2877,7 +3075,7 @@ class ClaudeAgentSession {
         }
     }
     appendStreamEventEvents(message, events, options) {
-        const usageUpdatedEvent = this.trackStreamEventUsage(message.event);
+        const usageUpdatedEvent = this.contextUsage.buildStreamUsageEvent(message.event);
         if (usageUpdatedEvent) {
             events.push(usageUpdatedEvent);
         }
@@ -2889,8 +3087,8 @@ class ClaudeAgentSession {
             events.push({ type: "timeline", item, provider: "claude" });
         }
     }
-    appendResultEvents(message, events) {
-        const usage = this.convertUsage(message, message.modelUsage);
+    appendResultEvents(message, events, options) {
+        const usage = this.convertUsage(message, message.modelUsage, options?.currentContextUsage);
         if (message.subtype === "success") {
             // Built-in slash commands (e.g. /voice, /usage, "Unknown command: …")
             // run client-side in the Claude CLI with no model turn — output_tokens
@@ -3034,92 +3232,8 @@ class ClaudeAgentSession {
         }
         return null;
     }
-    convertUsage(message, modelUsage) {
-        if (!message.usage) {
-            return undefined;
-        }
-        const usage = {
-            inputTokens: message.usage.input_tokens,
-            cachedInputTokens: message.usage.cache_read_input_tokens,
-            outputTokens: message.usage.output_tokens,
-            totalCostUsd: message.total_cost_usd,
-        };
-        const contextWindowMaxTokens = extractContextWindowSize(modelUsage ?? message.modelUsage);
-        if (contextWindowMaxTokens !== undefined) {
-            this.lastContextWindowMaxTokens = contextWindowMaxTokens;
-            usage.contextWindowMaxTokens = contextWindowMaxTokens;
-        }
-        else if (this.lastContextWindowMaxTokens !== undefined) {
-            usage.contextWindowMaxTokens = this.lastContextWindowMaxTokens;
-        }
-        if (typeof this.lastContextWindowUsedTokens === "number") {
-            // task_progress.total_tokens is the accurate context window fill level.
-            // Prefer it over result.usage which contains accumulated session totals.
-            usage.contextWindowUsedTokens = this.lastContextWindowUsedTokens;
-        }
-        else if (typeof this.lastStreamRequestInputTokens === "number" &&
-            typeof this.lastStreamRequestOutputTokens === "number") {
-            usage.contextWindowUsedTokens =
-                this.lastStreamRequestInputTokens + this.lastStreamRequestOutputTokens;
-        }
-        else if (message.usage) {
-            // Fallback: derive from result.usage when no task_progress has been
-            // received yet. These values are accumulated across all API calls, but
-            // for the first turn they equal the per-call values so the estimate is
-            // reasonable. Once a task_progress arrives it takes over permanently.
-            const usageWithCacheCreation = message.usage;
-            const derived = (message.usage.input_tokens ?? 0) +
-                (usageWithCacheCreation.cache_creation_input_tokens ?? 0) +
-                (message.usage.cache_read_input_tokens ?? 0) +
-                (message.usage.output_tokens ?? 0);
-            if (Number.isFinite(derived) && derived > 0) {
-                usage.contextWindowUsedTokens = derived;
-            }
-        }
-        return usage;
-    }
-    createUsageUpdatedEvent(contextWindowUsedTokens) {
-        const usage = {
-            contextWindowUsedTokens,
-        };
-        if (this.lastContextWindowMaxTokens !== undefined) {
-            usage.contextWindowMaxTokens = this.lastContextWindowMaxTokens;
-        }
-        return {
-            type: "usage_updated",
-            provider: "claude",
-            usage,
-        };
-    }
-    trackStreamEventUsage(event) {
-        const streamEvent = toObjectRecord(event);
-        if (!streamEvent) {
-            return null;
-        }
-        const eventType = readTrimmedString(streamEvent.type);
-        if (eventType === "message_start") {
-            const inputTokens = readStreamRequestInputTokens(streamEvent);
-            if (typeof inputTokens !== "number") {
-                return null;
-            }
-            this.lastStreamRequestInputTokens = inputTokens;
-            this.lastStreamRequestOutputTokens = 0;
-        }
-        else if (eventType === "message_delta") {
-            const outputTokens = readStreamRequestOutputTokens(streamEvent);
-            if (typeof outputTokens !== "number") {
-                return null;
-            }
-            this.lastStreamRequestOutputTokens = outputTokens;
-        }
-        else {
-            return null;
-        }
-        if (typeof this.lastStreamRequestInputTokens !== "number" ||
-            typeof this.lastStreamRequestOutputTokens !== "number") {
-            return null;
-        }
-        return this.createUsageUpdatedEvent(this.lastStreamRequestInputTokens + this.lastStreamRequestOutputTokens);
+    convertUsage(message, modelUsage, currentContextUsage) {
+        return this.contextUsage.buildResultUsage(message, modelUsage, currentContextUsage);
     }
     enqueueTimeline(item) {
         this.pushEvent({ type: "timeline", item, provider: "claude" });

package/dist/server/server/agent/providers/claude/models.js

@@ -14,20 +14,24 @@ const CLAUDE_OPUS_EXTENDED_THINKING_OPTIONS = [
     { id: "xhigh", label: "Extra High" },
     { id: "max", label: "Max" },
 ];
+const CLAUDE_ULTRACODE_THINKING_OPTIONS = [
+    ...CLAUDE_OPUS_EXTENDED_THINKING_OPTIONS,
+    { id: "ultracode", label: "Ultracode" },
+];
 const CLAUDE_MODELS = [
     {
         provider: "claude",
         id: "claude-fable-5",
         label: "Fable 5",
         description: "Fable 5 · Most powerful model",
-        thinkingOptions: [...CLAUDE_OPUS_EXTENDED_THINKING_OPTIONS],
+        thinkingOptions: [...CLAUDE_ULTRACODE_THINKING_OPTIONS],
     },
     {
         provider: "claude",
         id: "claude-opus-4-8[1m]",
         label: "Opus 4.8 1M",
         description: "Opus 4.8 with 1M context window",
-        thinkingOptions: [...CLAUDE_OPUS_EXTENDED_THINKING_OPTIONS],
+        thinkingOptions: [...CLAUDE_ULTRACODE_THINKING_OPTIONS],
     },
     {
         provider: "claude",
@@ -35,7 +39,7 @@ const CLAUDE_MODELS = [
         label: "Opus 4.8",
         description: "Opus 4.8 · Latest release",
         isDefault: true,
-        thinkingOptions: [...CLAUDE_OPUS_EXTENDED_THINKING_OPTIONS],
+        thinkingOptions: [...CLAUDE_ULTRACODE_THINKING_OPTIONS],
     },
     {
         provider: "claude",

package/dist/server/server/agent/providers/codex-app-server-agent.d.ts

@@ -1,4 +1,4 @@
-import { type AgentCapabilityFlags, type AgentClient, type AgentCreateSessionOptions, type AgentFeature, type AgentLaunchContext, type AgentMode, type AgentModelDefinition, type AgentPersistenceHandle, type AgentPermissionRequest, type AgentPermissionResponse, type AgentPermissionResult, type AgentPromptContentBlock, type AgentPromptInput, type AgentRunOptions, type AgentRunResult, type AgentRuntimeInfo, type AgentSession, type AgentSessionConfig, type AgentSlashCommand, type AgentStreamEvent, type AgentTimelineItem, type ToolCallTimelineItem, type AgentUsage, type ImportableProviderSession, type ImportProviderSessionContext, type ImportProviderSessionInput, type ListImportableSessionsOptions, type ListModelsOptions } from "../agent-sdk-types.js";
+import { type AgentCapabilityFlags, type AgentClient, type AgentCreateSessionOptions, type AgentFeature, type AgentLaunchContext, type AgentMode, type AgentModelDefinition, type AgentPersistenceHandle, type AgentPermissionRequest, type AgentPermissionResponse, type AgentPermissionResult, type AgentProviderNotice, type AgentPromptContentBlock, type AgentPromptInput, type AgentRunOptions, type AgentRunResult, type AgentRuntimeInfo, type AgentSession, type AgentSessionConfig, type AgentSlashCommand, type AgentStreamEvent, type AgentTimelineItem, type ToolCallTimelineItem, type AgentUsage, type ImportableProviderSession, type ImportProviderSessionContext, type ImportProviderSessionInput, type ListImportableSessionsOptions, type ListModelsOptions } from "../agent-sdk-types.js";
 import type { Logger } from "pino";
 import type { ChildProcessWithoutNullStreams } from "node:child_process";
 import { type ProviderRuntimeSettings } from "../provider-launch-config.js";
@@ -196,9 +196,9 @@ export declare class CodexAppServerAgentSession implements AgentSession {
     getRuntimeInfo(): Promise<AgentRuntimeInfo>;
     getAvailableModes(): Promise<AgentMode[]>;
     getCurrentMode(): Promise<string | null>;
-    setMode(modeId: string): Promise<void>;
+    setMode(modeId: string): Promise<void | AgentProviderNotice>;
     setModel(modelId: string | null): Promise<void>;
-    setThinkingOption(thinkingOptionId: string | null): Promise<void>;
+    setThinkingOption(thinkingOptionId: string | null): Promise<void | AgentProviderNotice>;
     setFeature(featureId: string, value: unknown): Promise<void>;
     getPendingPermissions(): AgentPermissionRequest[];
     respondToPermission(requestId: string, response: AgentPermissionResponse): Promise<AgentPermissionResult | void>;
@@ -297,6 +297,7 @@ export declare class CodexAppServerAgentClient implements AgentClient {
     importSession(input: ImportProviderSessionInput, context: ImportProviderSessionContext): Promise<import("../agent-sdk-types.js").ImportedProviderSession>;
     listModels(_options: ListModelsOptions): Promise<AgentModelDefinition[]>;
     archiveNativeSession(handle: AgentPersistenceHandle): Promise<void>;
+    unarchiveNativeSession(handle: AgentPersistenceHandle): Promise<void>;
     isAvailable(): Promise<boolean>;
     getDiagnostic(): Promise<{
         diagnostic: string;