grok-dev 1.0.0-rc2 → 1.0.0-rc3

package/.cursor/rules/project-overview.mdc

@@ -37,7 +37,7 @@ src/
 ├── utils/
 │   ├── settings.ts   # User and project settings
 │   ├── git-root.ts   # Resolve git repository root for AGENTS.md discovery
-│   └── instructions.ts # AGENTS.md (ecosystem) + .grok/GROK.md
+│   └── instructions.ts # AGENTS.md (ecosystem) custom instructions
 └── types/
     └── index.ts      # Shared TypeScript types
 ```
@@ -48,7 +48,7 @@ src/
 - **Bash-only tools**: The agent uses bash for everything (file editing, searching, git, builds, etc.).
 - **X Search & Web Search**: Integrated via the xAI Responses API for real-time information.
 - **Settings hierarchy**: Environment variables → User-level (`~/.grok/user-settings.json`) → Project-level (`.grok/settings.json`).
-- **Custom instructions**: `~/.grok/AGENTS.md`, then `AGENTS.override.md` / `AGENTS.md` per directory from git root through the workspace cwd (Codex-style merge), then `.grok/GROK.md` or `~/.grok/GROK.md` last.
+- **Custom instructions**: `~/.grok/AGENTS.md`, then `AGENTS.override.md` / `AGENTS.md` per directory from git root through the workspace cwd (Codex-style merge).
 - **ESM only**: The project uses `"type": "module"` — all imports use `.js` extensions for compiled output.
 
 ## Latest Grok Models

package/README.md

@@ -46,6 +46,7 @@ grok -d /path/to/your/repo
 grok --prompt "run the test suite and summarize failures"
 grok -p "show me package.json" --directory /path/to/project
 grok --prompt "refactor X" --max-tool-rounds 30
+grok --prompt "summarize the repo state" --format json
 ```
 
 **Continue a saved session:**
@@ -57,6 +58,15 @@ grok -s <session-id>
 
 Works in interactive mode too—same flag.
 
+**Structured headless output:**
+
+```bash
+grok --prompt "summarize the repo state" --format json
+```
+
+`--format json` emits newline-delimited `StreamChunk` objects instead of the
+default human-readable text stream.
+
 **List Grok models and pricing hints:**
 
 ```bash
@@ -136,13 +146,12 @@ Treat the bot token like a password.
 ## Instructions & project brain
 
 - **`AGENTS.md`** — merged from git root down to your cwd (Codex-style; see repo docs). **`AGENTS.override.md`** wins per directory when present.
-- **`.grok/GROK.md`** or **`~/.grok/GROK.md`** — Grok-only rules, applied last.
 
 ---
 
-## MCP & project settings
+## Project settings
 
-Project file: **`.grok/settings.json`** — e.g. current model, **`mcpServers`** for stdio/http/sse MCP servers. Manage interactively with **`/mcps`** in the TUI.
+Project file: **`.grok/settings.json`** — e.g. the current model for this project.
 
 ---
 

package/dist/agent/agent.d.ts

@@ -1,8 +1,44 @@
-import type { AgentMode, ChatEntry, SessionInfo, SessionSnapshot, StreamChunk, SubagentStatus, TaskRequest, ToolResult } from "../types/index";
+import type { AgentMode, ChatEntry, SessionInfo, SessionSnapshot, StreamChunk, SubagentStatus, TaskRequest, ToolCall, ToolResult } from "../types/index";
 interface AgentOptions {
     persistSession?: boolean;
     session?: string;
 }
+type ProcessMessageFinishReason = "stop" | "length" | "content-filter" | "tool-calls" | "error" | "other";
+export interface ProcessMessageUsage {
+    inputTokens?: number;
+    outputTokens?: number;
+    totalTokens?: number;
+}
+export interface ProcessMessageStepStart {
+    stepNumber: number;
+    timestamp: number;
+}
+export interface ProcessMessageStepFinish {
+    stepNumber: number;
+    timestamp: number;
+    finishReason: ProcessMessageFinishReason;
+    usage: ProcessMessageUsage;
+}
+export interface ProcessMessageToolStart {
+    toolCall: ToolCall;
+    timestamp: number;
+}
+export interface ProcessMessageToolFinish {
+    toolCall: ToolCall;
+    toolResult: ToolResult;
+    timestamp: number;
+}
+export interface ProcessMessageError {
+    message: string;
+    timestamp: number;
+}
+export interface ProcessMessageObserver {
+    onStepStart?(info: ProcessMessageStepStart): void;
+    onStepFinish?(info: ProcessMessageStepFinish): void;
+    onToolStart?(info: ProcessMessageToolStart): void;
+    onToolFinish?(info: ProcessMessageToolFinish): void;
+    onError?(info: ProcessMessageError): void;
+}
 export declare class Agent {
     private provider;
     private apiKey;
@@ -13,7 +49,7 @@ export declare class Agent {
     private workspace;
     private session;
     private messages;
-    private recordedTokens;
+    private messageSeqs;
     private abortController;
     private maxToolRounds;
     private mode;
@@ -56,7 +92,10 @@ export declare class Agent {
     private runDelegation;
     private readDelegation;
     private listDelegations;
-    processMessage(userMessage: string): AsyncGenerator<StreamChunk, void, unknown>;
+    private getCompactionSettings;
+    private compactForContext;
+    private appendCompletedTurn;
+    processMessage(userMessage: string, observer?: ProcessMessageObserver): AsyncGenerator<StreamChunk, void, unknown>;
     private requireProvider;
 }
 export {};

package/dist/agent/agent.js

@@ -1,12 +1,14 @@
 import { stepCountIs, streamText } from "ai";
 import { createProvider, generateTitle as genTitle } from "../grok/client";
+import { getModelInfo } from "../grok/models";
 import { createTools } from "../grok/tools";
 import { buildMcpToolSet } from "../mcp/runtime";
-import { appendMessages, appendSystemMessage, buildChatEntries, getSessionTotalTokens, loadTranscript, recordUsageEvent, SessionStore, } from "../storage/index";
+import { appendCompaction, appendMessages, appendSystemMessage, buildChatEntries, getNextMessageSequence, getSessionTotalTokens, loadTranscript, loadTranscriptState, recordUsageEvent, SessionStore, } from "../storage/index";
 import { BashTool } from "../tools/bash";
 import { loadCustomInstructions } from "../utils/instructions";
 import { loadMcpServers } from "../utils/settings";
 import { discoverSkills, formatSkillsForPrompt } from "../utils/skills";
+import { createCompactionSummaryMessage, DEFAULT_KEEP_RECENT_TOKENS, DEFAULT_RESERVE_TOKENS, estimateConversationTokens, generateCompactionSummary, prepareCompaction, relaxCompactionSettings, shouldCompactContext, } from "./compaction";
 import { DelegationManager } from "./delegations";
 const MAX_TOOL_ROUNDS = 400;
 const ENVIRONMENT = `ENVIRONMENT:
@@ -156,7 +158,7 @@ export class Agent {
     workspace = null;
     session = null;
     messages = [];
-    recordedTokens = 0;
+    messageSeqs = [];
     abortController = null;
     maxToolRounds;
     mode = "agent";
@@ -180,8 +182,9 @@ export class Agent {
             this.workspace = this.sessionStore.getWorkspace();
             this.session = this.sessionStore.openSession(options.session, this.modelId, this.mode, this.bash.getCwd());
             this.mode = this.session.mode;
-            this.messages = loadTranscript(this.session.id);
-            this.recordedTokens = getSessionTotalTokens(this.session.id);
+            const transcript = loadTranscriptState(this.session.id);
+            this.messages = transcript.messages;
+            this.messageSeqs = transcript.seqs;
             this.sessionStore.setModel(this.session.id, this.modelId);
         }
     }
@@ -223,8 +226,7 @@ export class Agent {
     }
     getContextStats(contextWindow, inFlightText = "") {
         const system = buildSystemPrompt(this.bash.getCwd(), this.mode, this.planContext);
-        const estimatedTokens = estimateTokens(`${system}\n${JSON.stringify(this.messages)}\n${inFlightText}`);
-        const usedTokens = Math.min(contextWindow, Math.max(estimatedTokens, this.recordedTokens));
+        const usedTokens = Math.min(contextWindow, estimateConversationTokens(system, this.messages, inFlightText));
         const remainingTokens = Math.max(0, contextWindow - usedTokens);
         return {
             contextWindow,
@@ -257,14 +259,14 @@ export class Agent {
     startNewSession() {
         if (!this.sessionStore) {
             this.messages = [];
-            this.recordedTokens = 0;
+            this.messageSeqs = [];
             return null;
         }
         this.sessionStore = new SessionStore(this.bash.getCwd());
         this.workspace = this.sessionStore.getWorkspace();
         this.session = this.sessionStore.createSession(this.modelId, this.mode, this.bash.getCwd());
         this.messages = [];
-        this.recordedTokens = 0;
+        this.messageSeqs = [];
         return this.getSessionSnapshot();
     }
     getSessionInfo() {
@@ -307,15 +309,12 @@ export class Agent {
         const idx = this.messages.lastIndexOf(userMessage);
         if (idx >= 0) {
             this.messages.splice(idx, 1);
+            this.messageSeqs.splice(idx, 1);
         }
     }
     recordUsage(usage, source = "message", model = this.modelId) {
         if (!usage)
             return;
-        const total = usage.totalTokens ?? (usage.inputTokens ?? 0) + (usage.outputTokens ?? 0);
-        if (Number.isFinite(total) && total > 0) {
-            this.recordedTokens += total;
-        }
         if (this.session) {
             recordUsageEvent(this.session.id, source, model, usage);
         }
@@ -325,9 +324,11 @@ export class Agent {
             const notifications = await this.delegations.consumeNotifications();
             for (const notification of notifications) {
                 this.messages.push({ role: "system", content: notification.message });
+                let seq = null;
                 if (this.session) {
-                    appendSystemMessage(this.session.id, notification.message);
+                    seq = appendSystemMessage(this.session.id, notification.message);
                 }
+                this.messageSeqs.push(seq);
             }
             return notifications.map((notification) => notification.message);
         }
@@ -498,143 +499,234 @@ export class Agent {
             };
         }
     }
-    async *processMessage(userMessage) {
+    getCompactionSettings() {
+        return {
+            reserveTokens: Math.max(this.maxTokens, DEFAULT_RESERVE_TOKENS),
+            keepRecentTokens: DEFAULT_KEEP_RECENT_TOKENS,
+        };
+    }
+    async compactForContext(provider, system, contextWindow, signal, settings = this.getCompactionSettings(), force = false) {
+        if (!this.session)
+            return false;
+        const preparation = prepareCompaction(this.messages, system, settings);
+        if (!preparation)
+            return false;
+        if (!force && !shouldCompactContext(preparation.tokensBefore, contextWindow, settings)) {
+            return false;
+        }
+        const keptSeqs = this.messageSeqs.slice(preparation.firstKeptIndex);
+        const firstKeptSeq = keptSeqs.find((seq) => seq !== null) ?? getNextMessageSequence(this.session.id);
+        const summary = await generateCompactionSummary(provider, this.modelId, preparation, undefined, signal);
+        appendCompaction(this.session.id, firstKeptSeq, summary, preparation.tokensBefore);
+        this.messages = [createCompactionSummaryMessage(summary), ...preparation.keptMessages];
+        this.messageSeqs = [null, ...keptSeqs];
+        return true;
+    }
+    appendCompletedTurn(userMessage, newMessages) {
+        if (newMessages.length === 0)
+            return;
+        const userIndex = this.messages.lastIndexOf(userMessage);
+        if (!this.sessionStore || !this.session) {
+            if (userIndex >= 0 && this.messageSeqs[userIndex] == null) {
+                this.messageSeqs[userIndex] = null;
+            }
+            this.messages.push(...newMessages);
+            this.messageSeqs.push(...newMessages.map(() => null));
+            return;
+        }
+        const insertedSeqs = appendMessages(this.session.id, [userMessage, ...newMessages]);
+        if (userIndex >= 0) {
+            this.messageSeqs[userIndex] = insertedSeqs[0] ?? this.messageSeqs[userIndex];
+        }
+        this.messages.push(...newMessages);
+        this.messageSeqs.push(...insertedSeqs.slice(1));
+        this.sessionStore.touchSession(this.session.id, this.bash.getCwd());
+        this.session = this.sessionStore.getRequiredSession(this.session.id);
+    }
+    async *processMessage(userMessage, observer) {
         this.abortController = new AbortController();
         const signal = this.abortController.signal;
         this.emitSubagentStatus(null);
         await this.consumeBackgroundNotifications();
         const userModelMessage = { role: "user", content: userMessage };
         this.messages.push(userModelMessage);
-        let assistantText = "";
-        let streamOk = false;
-        let closeMcp;
+        this.messageSeqs.push(null);
+        const provider = this.requireProvider();
+        const system = buildSystemPrompt(this.bash.getCwd(), this.mode, this.planContext);
+        const modelInfo = getModelInfo(this.modelId);
+        this.planContext = null;
+        let attemptedOverflowRecovery = false;
         try {
-            const provider = this.requireProvider();
-            const baseTools = createTools(this.bash, provider, this.mode, {
-                runTask: (request, abortSignal) => this.runTask(request, combineAbortSignals(signal, abortSignal)),
-                runDelegation: (request, abortSignal) => this.runDelegation(request, combineAbortSignals(signal, abortSignal)),
-                readDelegation: (id) => this.readDelegation(id),
-                listDelegations: () => this.listDelegations(),
-            });
-            let tools = baseTools;
-            if (this.mode === "agent") {
-                const mcpBundle = await buildMcpToolSet(loadMcpServers());
-                closeMcp = mcpBundle.close;
-                tools = { ...baseTools, ...mcpBundle.tools };
-                if (mcpBundle.errors.length > 0) {
-                    yield { type: "content", content: `MCP unavailable: ${mcpBundle.errors.join(" | ")}\n\n` };
-                }
-            }
-            const system = buildSystemPrompt(this.bash.getCwd(), this.mode, this.planContext);
-            this.planContext = null;
-            const result = streamText({
-                model: provider(this.modelId),
-                system,
-                messages: this.messages,
-                tools,
-                stopWhen: stepCountIs(this.maxToolRounds),
-                maxRetries: 0,
-                abortSignal: signal,
-                temperature: 0.7,
-                maxOutputTokens: this.maxTokens,
-                onFinish: ({ totalUsage }) => {
-                    this.recordUsage(totalUsage, "message");
-                },
-            });
-            for await (const part of result.fullStream) {
-                if (signal.aborted) {
-                    yield { type: "content", content: "\n\n[Cancelled]" };
-                    break;
-                }
-                switch (part.type) {
-                    case "text-delta":
-                        assistantText += part.text;
-                        yield { type: "content", content: part.text };
-                        break;
-                    case "reasoning-delta":
-                        yield { type: "reasoning", content: part.text };
-                        break;
-                    case "tool-call": {
-                        const tc = toToolCall(part);
-                        yield { type: "tool_calls", toolCalls: [tc] };
-                        break;
+            while (true) {
+                let assistantText = "";
+                let streamOk = false;
+                let closeMcp;
+                let stepNumber = -1;
+                try {
+                    const settings = attemptedOverflowRecovery
+                        ? relaxCompactionSettings(this.getCompactionSettings())
+                        : this.getCompactionSettings();
+                    if (modelInfo) {
+                        await this.compactForContext(provider, system, modelInfo.contextWindow, signal, settings, attemptedOverflowRecovery);
                     }
-                    case "tool-result": {
-                        const tc = {
-                            id: part.toolCallId,
-                            type: "function",
-                            function: { name: part.toolName, arguments: JSON.stringify(part.input ?? {}) },
-                        };
-                        const tr = toToolResult(part.output);
-                        yield { type: "tool_result", toolCall: tc, toolResult: tr };
-                        break;
+                    const baseTools = createTools(this.bash, provider, this.mode, {
+                        runTask: (request, abortSignal) => this.runTask(request, combineAbortSignals(signal, abortSignal)),
+                        runDelegation: (request, abortSignal) => this.runDelegation(request, combineAbortSignals(signal, abortSignal)),
+                        readDelegation: (id) => this.readDelegation(id),
+                        listDelegations: () => this.listDelegations(),
+                    });
+                    let tools = baseTools;
+                    if (this.mode === "agent") {
+                        const mcpBundle = await buildMcpToolSet(loadMcpServers());
+                        closeMcp = mcpBundle.close;
+                        tools = { ...baseTools, ...mcpBundle.tools };
+                        if (mcpBundle.errors.length > 0) {
+                            yield { type: "content", content: `MCP unavailable: ${mcpBundle.errors.join(" | ")}\n\n` };
+                        }
                     }
-                    case "error":
-                        yield { type: "error", content: String(part.error) };
-                        break;
-                    case "abort":
-                        yield { type: "content", content: "\n\n[Cancelled]" };
-                        break;
-                }
-            }
-            if (signal.aborted) {
-                this.discardAbortedTurn(userModelMessage);
-                yield { type: "done" };
-                return;
-            }
-            try {
-                const response = await result.response;
-                if (!signal.aborted) {
-                    this.messages.push(...response.messages);
-                    if (this.sessionStore && this.session) {
-                        appendMessages(this.session.id, [userModelMessage, ...response.messages]);
-                        this.sessionStore.touchSession(this.session.id, this.bash.getCwd());
-                        this.session = this.sessionStore.getRequiredSession(this.session.id);
+                    const result = streamText({
+                        model: provider(this.modelId),
+                        system,
+                        messages: this.messages,
+                        tools,
+                        stopWhen: stepCountIs(this.maxToolRounds),
+                        maxRetries: 0,
+                        abortSignal: signal,
+                        temperature: 0.7,
+                        maxOutputTokens: this.maxTokens,
+                        experimental_onStepStart: (event) => {
+                            stepNumber = getStepNumber(event, stepNumber + 1);
+                            notifyObserver(observer?.onStepStart, {
+                                stepNumber,
+                                timestamp: Date.now(),
+                            });
+                        },
+                        onStepFinish: (event) => {
+                            const currentStep = getStepNumber(event, Math.max(stepNumber, 0));
+                            stepNumber = Math.max(stepNumber, currentStep);
+                            notifyObserver(observer?.onStepFinish, {
+                                stepNumber: currentStep,
+                                timestamp: Date.now(),
+                                finishReason: getFinishReason(event),
+                                usage: getUsage(event),
+                            });
+                        },
+                        onFinish: ({ totalUsage }) => {
+                            this.recordUsage(totalUsage, "message");
+                        },
+                    });
+                    for await (const part of result.fullStream) {
+                        if (signal.aborted) {
+                            yield { type: "content", content: "\n\n[Cancelled]" };
+                            break;
+                        }
+                        switch (part.type) {
+                            case "text-delta":
+                                assistantText += part.text;
+                                yield { type: "content", content: part.text };
+                                break;
+                            case "reasoning-delta":
+                                yield { type: "reasoning", content: part.text };
+                                break;
+                            case "tool-call": {
+                                const tc = toToolCall(part);
+                                notifyObserver(observer?.onToolStart, {
+                                    toolCall: tc,
+                                    timestamp: Date.now(),
+                                });
+                                yield { type: "tool_calls", toolCalls: [tc] };
+                                break;
+                            }
+                            case "tool-result": {
+                                const tc = {
+                                    id: part.toolCallId,
+                                    type: "function",
+                                    function: { name: part.toolName, arguments: JSON.stringify(part.input ?? {}) },
+                                };
+                                const tr = toToolResult(part.output);
+                                notifyObserver(observer?.onToolFinish, {
+                                    toolCall: tc,
+                                    toolResult: tr,
+                                    timestamp: Date.now(),
+                                });
+                                yield { type: "tool_result", toolCall: tc, toolResult: tr };
+                                break;
+                            }
+                            case "error": {
+                                const message = String(part.error);
+                                notifyObserver(observer?.onError, {
+                                    message,
+                                    timestamp: Date.now(),
+                                });
+                                yield { type: "error", content: message };
+                                break;
+                            }
+                            case "abort":
+                                yield { type: "content", content: "\n\n[Cancelled]" };
+                                break;
+                        }
+                    }
+                    if (signal.aborted) {
+                        this.discardAbortedTurn(userModelMessage);
+                        yield { type: "done" };
+                        return;
+                    }
+                    try {
+                        const response = await result.response;
+                        if (!signal.aborted) {
+                            this.appendCompletedTurn(userModelMessage, response.messages);
+                            streamOk = true;
+                        }
                     }
-                    streamOk = true;
+                    catch (responseError) {
+                        if (!attemptedOverflowRecovery &&
+                            !assistantText.trim() &&
+                            modelInfo &&
+                            isContextLimitError(responseError)) {
+                            attemptedOverflowRecovery = true;
+                            continue;
+                        }
+                    }
+                    if (signal.aborted) {
+                        this.discardAbortedTurn(userModelMessage);
+                        yield { type: "done" };
+                        return;
+                    }
+                    if (!streamOk && assistantText.trim()) {
+                        this.appendCompletedTurn(userModelMessage, [{ role: "assistant", content: assistantText }]);
+                    }
+                    yield { type: "done" };
+                    return;
                 }
-            }
-            catch {
-                // response promise can fail after stream errors — fall back to manual message
-            }
-            if (signal.aborted) {
-                this.discardAbortedTurn(userModelMessage);
-                yield { type: "done" };
-                return;
-            }
-            if (!streamOk && assistantText.trim()) {
-                const fallbackMessage = { role: "assistant", content: assistantText };
-                this.messages.push(fallbackMessage);
-                if (this.sessionStore && this.session) {
-                    appendMessages(this.session.id, [userModelMessage, fallbackMessage]);
-                    this.sessionStore.touchSession(this.session.id, this.bash.getCwd());
-                    this.session = this.sessionStore.getRequiredSession(this.session.id);
+                catch (err) {
+                    if (signal.aborted) {
+                        this.discardAbortedTurn(userModelMessage);
+                        yield { type: "content", content: "\n\n[Cancelled]" };
+                        yield { type: "done" };
+                        return;
+                    }
+                    if (!attemptedOverflowRecovery && !assistantText.trim() && modelInfo && isContextLimitError(err)) {
+                        attemptedOverflowRecovery = true;
+                        continue;
+                    }
+                    const msg = err instanceof Error ? err.message : String(err);
+                    notifyObserver(observer?.onError, {
+                        message: `Error: ${msg}`,
+                        timestamp: Date.now(),
+                    });
+                    yield { type: "error", content: `Error: ${msg}` };
+                    if (assistantText.trim()) {
+                        this.appendCompletedTurn(userModelMessage, [{ role: "assistant", content: assistantText }]);
+                    }
+                    yield { type: "done" };
+                    return;
                 }
-            }
-            yield { type: "done" };
-        }
-        catch (err) {
-            if (signal.aborted) {
-                this.discardAbortedTurn(userModelMessage);
-                yield { type: "content", content: "\n\n[Cancelled]" };
-            }
-            else {
-                const msg = err instanceof Error ? err.message : String(err);
-                yield { type: "error", content: `Error: ${msg}` };
-            }
-            if (!signal.aborted && assistantText.trim()) {
-                const fallbackMessage = { role: "assistant", content: assistantText };
-                this.messages.push(fallbackMessage);
-                if (this.sessionStore && this.session) {
-                    appendMessages(this.session.id, [userModelMessage, fallbackMessage]);
-                    this.sessionStore.touchSession(this.session.id, this.bash.getCwd());
-                    this.session = this.sessionStore.getRequiredSession(this.session.id);
+                finally {
+                    await closeMcp?.().catch(() => { });
                 }
             }
-            yield { type: "done" };
         }
         finally {
-            await closeMcp?.().catch(() => { });
             if (this.abortController?.signal === signal) {
                 this.abortController = null;
             }
@@ -657,6 +749,52 @@ function toToolCall(part) {
         },
     };
 }
+function notifyObserver(listener, payload) {
+    if (!listener) {
+        return;
+    }
+    try {
+        listener(payload);
+    }
+    catch {
+        // Observer failures should never break generation.
+    }
+}
+function getStepNumber(event, fallback) {
+    if (event && typeof event === "object" && "stepNumber" in event && typeof event.stepNumber === "number") {
+        return event.stepNumber;
+    }
+    return fallback;
+}
+function getFinishReason(event) {
+    if (event && typeof event === "object" && "finishReason" in event) {
+        switch (event.finishReason) {
+            case "stop":
+            case "length":
+            case "content-filter":
+            case "tool-calls":
+            case "error":
+            case "other":
+                return event.finishReason;
+        }
+    }
+    return "other";
+}
+function getUsage(event) {
+    if (!(event && typeof event === "object" && "usage" in event)) {
+        return {};
+    }
+    const usage = event.usage;
+    if (!usage || typeof usage !== "object") {
+        return {};
+    }
+    const u = usage;
+    return {
+        inputTokens: typeof u.inputTokens === "number" ? u.inputTokens : undefined,
+        outputTokens: typeof u.outputTokens === "number" ? u.outputTokens : undefined,
+        totalTokens: typeof u.totalTokens === "number" ? u.totalTokens : undefined,
+    };
+}
 function toToolResult(output) {
     if (output && typeof output === "object" && "success" in output) {
         const r = output;
@@ -704,9 +842,6 @@ function firstLine(text) {
 function truncate(text, max) {
     return text.length <= max ? text : `${text.slice(0, max - 1)}…`;
 }
-function estimateTokens(text) {
-    return Math.ceil(text.length / 4);
-}
 function combineAbortSignals(...signals) {
     const activeSignals = signals.filter((signal) => Boolean(signal));
     if (activeSignals.length === 0)
@@ -726,4 +861,8 @@ function combineAbortSignals(...signals) {
     }
     return controller.signal;
 }
+function isContextLimitError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return /(context|token|prompt).*(limit|length|large|window|overflow)|too many tokens|maximum context/i.test(message);
+}
 //# sourceMappingURL=agent.js.map