@getpaseo/server 0.1.97 → 0.1.99

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, formatProviderDiagnostic, formatProviderDiagnosticError, } 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;
@@ -1028,9 +1032,10 @@ export class ClaudeAgentClient {
             resolveBinary: this.resolveBinary,
         });
     }
-    async listModels(_options) {
+    async fetchCatalog(_options) {
         // Claude exposes a global catalog here; cwd/force are intentionally irrelevant.
-        return await getClaudeModelsWithSettings(this.logger, this.configDir);
+        const models = await getClaudeModelsWithSettings(this.logger, this.configDir);
+        return { models, modes: DEFAULT_MODES };
     }
     async listFeatures(config) {
         const claudeConfig = this.assertConfig(config);
@@ -1075,34 +1080,16 @@ export class ClaudeAgentClient {
                 defaultBinary: "claude",
             });
             const availability = await checkProviderLaunchAvailable(launch);
-            const available = availability.available;
-            const auth = available
+            const auth = availability.available
                 ? await resolveClaudeAuth(launch, availability, this.runtimeSettings)
                 : null;
-            let modelsValue = "Not checked";
-            let status = formatDiagnosticStatus(available);
-            if (available) {
-                try {
-                    const models = await this.listModels({
-                        cwd: os.homedir(),
-                        force: false,
-                    });
-                    modelsValue = String(models.length);
-                }
-                catch (error) {
-                    modelsValue = `Error - ${toDiagnosticErrorMessage(error)}`;
-                    status = formatDiagnosticStatus(available, {
-                        source: "model fetch",
-                        cause: error,
-                    });
-                }
-            }
             return {
                 diagnostic: formatProviderDiagnostic("Claude Code", [
+                    ...(await buildCommandResolutionDiagnosticRows(launch, {
+                        knownBinaryNames: ["claude"],
+                    })),
                     ...(await buildBinaryDiagnosticRows(launch, availability)),
                     ...(auth ? [{ label: "Auth", value: auth }] : []),
-                    { label: "Models", value: modelsValue },
-                    { label: "Status", value: status },
                 ]),
             };
         }
@@ -1180,21 +1167,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 +1212,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 +1497,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 +1595,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 +1705,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 +1719,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 +2255,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 +2282,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 +2334,7 @@ class ClaudeAgentSession {
             ...(thinking ? { thinking } : {}),
             ...(effort ? { effort } : {}),
             ...extraClaudeOptions,
-            ...fastModeOptions,
+            ...settingsOptions,
             ...(this.persistSession === undefined ? {} : { persistSession: this.persistSession }),
             env: sdkEnv,
         };
@@ -2194,12 +2356,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 +2580,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 +2659,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 +2727,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 +2750,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 +2773,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 +2895,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 +2970,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 +2992,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 +3055,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 +3067,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 +3212,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",