@nexrall/code-core 1.4.13 → 1.4.15

package/dist/agent/loop.d.ts

@@ -102,4 +102,17 @@ export declare function compactMessagesForResume(messages: Message[], opts: {
     onNotice?: (text: string) => void;
 }): Promise<boolean>;
 export declare function runAgentLoop(initialMessages: Message[], options: AgentLoopOptions): Promise<Message[]>;
+/**
+ * Cut a history back to the last point the API will accept as a resumable
+ * prefix, WITHOUT mutating the input.
+ *
+ * Anthropic rejects a conversation whose final assistant turn contains
+ * `tool_use` blocks that never got a matching `tool_result`. The main loop
+ * always appends in complete pairs so it can't produce that shape, but a crash
+ * in the middle of executing a tool round can: the assistant turn was already
+ * pushed, the tool_result carrier never was. Dropping that dangling assistant
+ * turn costs one model response and makes the rest of the (often very long)
+ * history resumable, instead of throwing all of it away.
+ */
+export declare function trimToResumableBoundary(messages: Message[]): Message[];
 //# sourceMappingURL=loop.d.ts.map

package/dist/agent/loop.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loop.d.ts","sourceRoot":"","sources":["../../src/agent/loop.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EAMP,gBAAgB,EAChB,UAAU,EACX,MAAM,UAAU,CAAC;AAwKlB,wBAAgB,oBAAoB,CAClC,WAAW,EAAE,MAAM,GAAG,SAAS,EAC/B,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACnC,MAAM,CAWR;AA+TD,+EAA+E;AAC/E,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,MAAM,CAM7D;AAsBD,iFAAiF;AACjF,eAAO,MAAM,gBAAgB,aAA+G,CAAC;AAC7I,gGAAgG;AAChG,eAAO,MAAM,aAAa,QAA2J,CAAC;AAEtL;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAK5E;AAUD;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,MAAM,CAwBxD;AAoBD,MAAM,WAAW,cAAc;IAC7B,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC3D,aAAa,EAAE,KAAK,CAAC;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAClE,qFAAqF;IACrF,aAAa,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACvD;;;;OAIG;IACH,KAAK,EAAE,MAAM,CAAC;CACf;AAED,wBAAgB,YAAY,IAAI,cAAc,CAE7C;AAED,kFAAkF;AAClF,wBAAgB,YAAY,CAC1B,MAAM,EAAE,cAAc,EACtB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EAC1C,EAAE,EAAE,OAAO,EACX,MAAM,CAAC,EAAE,MAAM,EACf,QAAQ,CAAC,EAAE,MAAM,GAChB,IAAI,CAoDN;AAED,kFAAkF;AAClF,wBAAgB,aAAa,CAAC,MAAM,EAAE,cAAc,GAAG,MAAM,CA6B5D;AAmBD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,eAAe,SAAI,GAAG,MAAM,CAgCpF;AA8JD,gFAAgF;AAChF,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,MAAM,CAE/D;AAED;;;;;;;;;GASG;AACH,wBAAsB,wBAAwB,CAC5C,QAAQ,EAAE,OAAO,EAAE,EACnB,IAAI,EAAE;IACJ,KAAK,CAAC,EAAE,OAAO,GAAG,KAAK,GAAG,OAAO,CAAC;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,GAAG,CAAC,EAAE,UAAU,CAAC;IACjB,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CACnC,GACA,OAAO,CAAC,OAAO,CAAC,CAqElB;AAID,wBAAsB,YAAY,CAChC,eAAe,EAAE,OAAO,EAAE,EAC1B,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,OAAO,EAAE,CAAC,CA2oBpB"}
+{"version":3,"file":"loop.d.ts","sourceRoot":"","sources":["../../src/agent/loop.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EAMP,gBAAgB,EAChB,UAAU,EACX,MAAM,UAAU,CAAC;AAyKlB,wBAAgB,oBAAoB,CAClC,WAAW,EAAE,MAAM,GAAG,SAAS,EAC/B,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACnC,MAAM,CAWR;AA+UD,+EAA+E;AAC/E,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,MAAM,CAM7D;AAsBD,iFAAiF;AACjF,eAAO,MAAM,gBAAgB,aAA+G,CAAC;AAC7I,gGAAgG;AAChG,eAAO,MAAM,aAAa,QAA2J,CAAC;AAEtL;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAK5E;AAUD;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,MAAM,CAwBxD;AAoBD,MAAM,WAAW,cAAc;IAC7B,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC3D,aAAa,EAAE,KAAK,CAAC;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAClE,qFAAqF;IACrF,aAAa,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACvD;;;;OAIG;IACH,KAAK,EAAE,MAAM,CAAC;CACf;AAED,wBAAgB,YAAY,IAAI,cAAc,CAE7C;AAED,kFAAkF;AAClF,wBAAgB,YAAY,CAC1B,MAAM,EAAE,cAAc,EACtB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EAC1C,EAAE,EAAE,OAAO,EACX,MAAM,CAAC,EAAE,MAAM,EACf,QAAQ,CAAC,EAAE,MAAM,GAChB,IAAI,CAoDN;AAED,kFAAkF;AAClF,wBAAgB,aAAa,CAAC,MAAM,EAAE,cAAc,GAAG,MAAM,CA6B5D;AAmBD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,eAAe,SAAI,GAAG,MAAM,CAgCpF;AAsKD,gFAAgF;AAChF,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,MAAM,CAE/D;AAED;;;;;;;;;GASG;AACH,wBAAsB,wBAAwB,CAC5C,QAAQ,EAAE,OAAO,EAAE,EACnB,IAAI,EAAE;IACJ,KAAK,CAAC,EAAE,OAAO,GAAG,KAAK,GAAG,OAAO,CAAC;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,GAAG,CAAC,EAAE,UAAU,CAAC;IACjB,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CACnC,GACA,OAAO,CAAC,OAAO,CAAC,CAqElB;AAID,wBAAsB,YAAY,CAChC,eAAe,EAAE,OAAO,EAAE,EAC1B,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,OAAO,EAAE,CAAC,CA+sBpB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,CAqCtE"}

package/dist/agent/loop.js

@@ -45,6 +45,8 @@ exports.pruneOldToolResults = pruneOldToolResults;
 exports.estimateTokensRough = estimateTokensRough;
 exports.compactMessagesForResume = compactMessagesForResume;
 exports.runAgentLoop = runAgentLoop;
+exports.trimToResumableBoundary = trimToResumableBoundary;
+const types_1 = require("../types");
 const client_1 = require("../api/client");
 const executor_1 = require("../tools/executor");
 const agentTypes_1 = require("./agentTypes");
@@ -366,6 +368,22 @@ async function runSubTask(input, options, agentTypes) {
             nexrallMd: subNexrallMd,
             requestPermission: gatedPermission,
             onText: () => { }, // sub-agent text is returned as the tool result, not streamed live
+            // Forwarded DELIBERATELY, and it must be a real handler rather than a no-op.
+            //
+            // A sub-agent streams no text (onText above is a no-op) but it DOES stream thinking
+            // through the parent's UI (see onThinking/onThinkingDelta below), and thinking sets
+            // `emittedToCaller`. So a sub-agent stream that dies after reasoning genuinely has
+            // rendered output to discard — a no-op here would let the restart proceed and then
+            // re-stream that reasoning on top of the copy still on screen, the exact duplication
+            // the opt-in exists to prevent.
+            //
+            // Forwarding is safe because the parent's own output is already closed by this
+            // point: dispatching the `task` tool goes through options.onToolUse, which finalizes
+            // the parent's bubble (VS Code) / flushes the renderer (CLI) before the sub-agent
+            // starts. The only live, discardable element at restart time is the sub-agent's own
+            // thinking block. Completed tool rows are left alone — those are real side effects
+            // that actually happened.
+            onStreamRestart: (reason, chars) => options.onStreamRestart?.(reason, chars),
             // Forward tool events with isSubTask=true so the UI can render a badge
             // instead of prepending "[sub-task]" to the tool name (which caused double-prefix
             // when the name was already labelled, and mixed display concerns into the data layer).
@@ -802,6 +820,11 @@ async function autoCompactMessages(messages, options, ledger) {
             env: options.env,
             clientType: options.clientType,
             abortSignal: options.abortSignal,
+            // The summariser renders NOTHING (onEvent below is a no-op) and its result is
+            // read only from the returned message, so a restart has nothing to roll back —
+            // always safe. Worth enabling: a blip here used to abandon compaction entirely,
+            // which then let the very next turn hit the context wall it was meant to prevent.
+            allowRestartAfterRender: true,
         }, () => { });
         summary = reply.content
             .filter((b) => b.type === 'text')
@@ -858,6 +881,9 @@ async function maybeCompactMemory(scope, options) {
                 env: options.env,
                 clientType: options.clientType,
                 abortSignal: options.abortSignal,
+                // Same as the transcript summariser: no rendered output, result read only from
+                // the returned message, so restarting on a blip is always safe.
+                allowRestartAfterRender: true,
             }, () => { });
             return reply.content
                 .filter((b) => b.type === 'text')
@@ -1010,6 +1036,11 @@ async function runAgentLoop(initialMessages, options) {
     // iteration backstop, so we can tell the user what happened rather than
     // silently returning a half-done task.
     let completedCleanly = false;
+    // Tool rounds actually completed in this call. Counted explicitly rather than derived
+    // from `messages.length` because auto-compaction splices the history SHORTER mid-run:
+    // a long session that compacted and then lost its connection would show a negative
+    // length delta and be judged "no progress", discarding the work it most needs to keep.
+    let completedRounds = 0;
     let stalledOut = false; // tripped the runaway guard (all-failed rounds)
     let consecutiveErrorRounds = 0; // rounds where every tool call errored
     let budget = maxIterations; // extended by auto-continue, capped at hardCap
@@ -1110,8 +1141,6 @@ async function runAgentLoop(initialMessages, options) {
             if (!autoContinue && iteration === budget - 5 && budget > 5) {
                 options.onText(`\n⚠️ Approaching the ${budget}-step limit (step ${iteration + 1}). Please wrap up and summarise what has been done.\n`);
             }
-            // Collect tool_use blocks emitted during this stream
-            const pendingToolUse = [];
             // Build SSE event handler
             const onEvent = (event) => {
                 switch (event.type) {
@@ -1128,21 +1157,33 @@ async function runAgentLoop(initialMessages, options) {
                         options.onThinkingProgress?.(event.tokens);
                         break;
                     case 'tool_use':
-                        // Collect tool use blocks — they may arrive incrementally
-                        // We use message_complete to finalize them, so just track here
-                        pendingToolUse.push({
-                            type: 'tool_use',
-                            id: event.id,
-                            name: event.name,
-                            input: event.input,
-                        });
+                        // Nothing to do here. Streamed tool_use events are a PREVIEW only (their
+                        // `input` can still be partial JSON mid-stream); the blocks actually
+                        // executed are read from the completed message's content at the end of
+                        // this iteration. An accumulator here used to exist but was never read —
+                        // keeping it invited the assumption that dispatch happens from the stream,
+                        // which would break the restart guarantee below.
                         break;
                     case 'usage':
-                        lastPromptTokens =
-                            (event.usage.input_tokens ?? 0) +
-                                (event.usage.cache_creation_input_tokens ?? 0) +
-                                (event.usage.cache_read_input_tokens ?? 0);
-                        options.onUsage(event.usage);
+                        // A `partial` report belongs to an attempt that was cut short and restarted.
+                        // Its token counts are real spend (already billed upstream) and are forwarded
+                        // so a cost display stays honest — but they must NOT drive `lastPromptTokens`,
+                        // which feeds the auto-compaction trigger: a truncated attempt understates the
+                        // prompt size, and letting it overwrite a correct reading would suppress a
+                        // compaction the next turn actually needs.
+                        if (!event.partial) {
+                            // A `replayed` report DOES update this: it describes the real, complete turn
+                            // (served from the backend's idempotency cache after a dropped connection),
+                            // so its prompt size is accurate and needed for the compaction decision.
+                            // Only `partial` — a truncated attempt — must be excluded.
+                            lastPromptTokens =
+                                (event.usage.input_tokens ?? 0) +
+                                    (event.usage.cache_creation_input_tokens ?? 0) +
+                                    (event.usage.cache_read_input_tokens ?? 0);
+                        }
+                        // Both flags mean "do not add these tokens to a running cost total": `partial`
+                        // was a discarded attempt, `replayed` was already counted when first billed.
+                        options.onUsage(event.usage, event.partial === true || event.replayed === true);
                         break;
                     case 'message_complete':
                         // The complete message is returned from streamChat, we handle it below
@@ -1153,11 +1194,29 @@ async function runAgentLoop(initialMessages, options) {
                     case 'retry_resolved':
                         options.onRetryResolved?.();
                         break;
+                    case 'stream_restart':
+                        // The attempt that died had already rendered text/thinking; the replacement
+                        // attempt re-sends the turn in full, so the caller must drop that partial
+                        // render or it shows up twice.
+                        //
+                        // Nothing else needs undoing, and that is a property of the code below, not
+                        // an assumption: tools are dispatched from `assistantMessage.content` AFTER
+                        // streamChat() returns, and a restarted attempt threw instead of returning.
+                        // So no tool ran, no file changed, no checkpoint or hook fired.
+                        options.onStreamRestart?.(event.reason, event.discardedChars);
+                        break;
                     case 'balance_status':
                         options.onBalanceStatus?.(event.balance, event.zero);
                         break;
                     case 'done':
+                        break;
                     case 'error':
+                        // Reaching the loop means the stream did NOT reject on this — i.e. the turn's
+                        // message had already been delivered and the error arrived late (typically the
+                        // backend's post-turn billing write failing). The answer stands, so this must
+                        // not fail the turn, but it must not vanish either: route it to the system-
+                        // notice channel so it is visible and logged rather than silently swallowed.
+                        options.onNotice?.(`⚠️ ${event.message}`);
                         break;
                 }
             };
@@ -1176,6 +1235,11 @@ async function runAgentLoop(initialMessages, options) {
                     extraTools: options.mcpManager?.getAnthropicTools(),
                     agents: agentsCatalogue || undefined,
                     skills: skillsCatalogue || undefined,
+                    // Only allow a post-render restart when the caller actually implements the
+                    // rollback. Without a handler the partial output can't be un-rendered, so we
+                    // keep the old conservative behaviour (fail the turn) rather than duplicate
+                    // text on screen.
+                    allowRestartAfterRender: !!options.onStreamRestart,
                 }, onEvent);
             }
             catch (err) {
@@ -1192,7 +1256,14 @@ async function runAgentLoop(initialMessages, options) {
                     break;
                 }
                 runSimpleHooks(hooks.OnError, options.workDir);
-                throw new Error(`Stream failed: ${err.message}`);
+                // Carry the work already done in this turn out with the error. The loop
+                // owns a COPY of the caller's history, so a plain throw would strand every
+                // completed tool round inside this function and the caller would fall back
+                // to a history containing only the original user message — the user pays
+                // for N minutes of agent work and then has to start over because
+                // "continue" remembers none of it. `messages` always ends on a complete
+                // assistant→tool_result pair here, so it is valid to resend as-is.
+                throw new types_1.AgentTurnError(`Stream failed: ${err.message}`, trimToResumableBoundary(messages), completedRounds, err);
             }
             if (options.abortSignal?.aborted)
                 break;
@@ -1524,6 +1595,9 @@ async function runAgentLoop(initialMessages, options) {
                 content: toolResultContent,
             };
             messages.push(toolResultMessage);
+            // A complete assistant→tool_result pair just landed: the history is valid to
+            // resend from here, so this is exactly one unit of salvageable progress.
+            completedRounds++;
             // Incremental persistence hook: history is valid here (ends on a
             // tool_result user turn). Let the caller checkpoint progress so a crash
             // mid-run loses only the in-flight step, not the whole session.
@@ -1564,9 +1638,69 @@ async function runAgentLoop(initialMessages, options) {
             }
         }
     }
+    catch (err) {
+        // Every other failure path (a tool executor blowing up, a hook throwing, an
+        // out-of-memory in a large read) gets the same treatment as a dead stream:
+        // the turn's completed work leaves with the error instead of dying inside
+        // this function's private copy of the history. Already-tagged errors pass
+        // straight through so we don't double-wrap and lose the original message.
+        if (err instanceof types_1.AgentTurnError)
+            throw err;
+        if (options.abortSignal?.aborted || err.name === 'AbortError')
+            throw err;
+        throw new types_1.AgentTurnError(err?.message || 'The turn ended unexpectedly', trimToResumableBoundary(messages), completedRounds, err);
+    }
     finally {
         runSimpleHooks(hooks.OnStop, options.workDir);
     }
     return messages;
 }
+/**
+ * Cut a history back to the last point the API will accept as a resumable
+ * prefix, WITHOUT mutating the input.
+ *
+ * Anthropic rejects a conversation whose final assistant turn contains
+ * `tool_use` blocks that never got a matching `tool_result`. The main loop
+ * always appends in complete pairs so it can't produce that shape, but a crash
+ * in the middle of executing a tool round can: the assistant turn was already
+ * pushed, the tool_result carrier never was. Dropping that dangling assistant
+ * turn costs one model response and makes the rest of the (often very long)
+ * history resumable, instead of throwing all of it away.
+ */
+function trimToResumableBoundary(messages) {
+    // A trailing assistant turn is unresumable if it invoked ANY tool whose result is
+    // missing. That includes server-side invocations (`server_tool_use`, produced by
+    // web search / tool search), which carry a DIFFERENT block type than a client tool
+    // call: matching only 'tool_use' would let a dangling web-search turn through, and
+    // it would 400 on resend exactly like a dangling client call. `chooseFinalContent`
+    // in api/client.ts deliberately preserves these blocks verbatim, so they really do
+    // reach this function.
+    const isUnansweredInvocation = (m) => {
+        if (m?.role !== 'assistant' || !Array.isArray(m.content))
+            return false;
+        const blocks = m.content;
+        // A client tool_use is answered by a tool_result in the NEXT (user) message, which
+        // by definition doesn't exist if this is the last turn — so any of them is dangling.
+        if (blocks.some((b) => b?.type === 'tool_use'))
+            return true;
+        // Server-side invocations are different: Anthropic pairs each `server_tool_use` with
+        // its `*_tool_result` inside this SAME message, so a completed search turn is
+        // perfectly resumable and must not be discarded.
+        //
+        // Pair by id rather than asking "is there any result block at all". A turn cut off
+        // after two searches where only the first returned would otherwise look complete and
+        // 400 on resend — exactly the mid-turn-death case this helper exists for. Matching on
+        // the `_tool_result` suffix also covers result types beyond web/tool search
+        // (code_execution, mcp) without needing to enumerate them.
+        const answeredIds = new Set(blocks.filter((b) => /_tool_result$/.test(b?.type ?? '')).map((b) => b?.tool_use_id));
+        return blocks.some((b) => b?.type === 'server_tool_use' && !answeredIds.has(b?.id));
+    };
+    // Loop rather than a single check: this is an exported helper that accepts any
+    // history, not only the strictly-paired ones the agent loop builds, so consecutive
+    // dangling assistant turns must all be removed for the result to be resendable.
+    let end = messages.length;
+    while (end > 0 && isUnansweredInvocation(messages[end - 1]))
+        end--;
+    return end === messages.length ? messages : messages.slice(0, end);
+}
 //# sourceMappingURL=loop.js.map

package/dist/api/client.d.ts

@@ -1,5 +1,5 @@
 import type { Message, SSEEvent, AuthConfig, EnvContext, EditorContext } from '../types';
-export declare const API_BASE = "https://api.nexrall.com";
+export declare const API_BASE: string;
 /**
  * Decide the final assistant `content` array to store in history for a completed
  * turn. Pure + exported so it can be unit-tested without a live SSE stream.
@@ -44,8 +44,38 @@ export interface StreamChatOptions {
     agents?: string;
     /** Catalogue of auto-invokable skills (description only) — injected into the system prompt so the model can call use_skill when relevant. */
     skills?: string;
+    /**
+     * Opt in to restarting a turn that died AFTER partial output was rendered.
+     *
+     * Historically any transport failure past the first token was fatal: retrying
+     * would have re-streamed text the user could already see, duplicating it. That
+     * rule is correct but it protects almost nothing in practice — a long turn emits
+     * a thinking delta within seconds, so the retry machinery was effectively dead
+     * code exactly when it mattered most (deep into an expensive agentic run).
+     *
+     * When the caller can UNDO its rendered output for the current turn, it sets
+     * this and handles the `stream_restart` event by discarding that output. Then a
+     * mid-render disconnect becomes recoverable instead of turn-fatal. This is safe
+     * for side effects: tool calls are dispatched by the agent loop only after
+     * `message_complete`, and a restart by definition means that never arrived — so
+     * no tool ran and nothing but rendered characters is rolled back.
+     */
+    allowRestartAfterRender?: boolean;
 }
 export declare function streamChat(messages: Message[], options: StreamChatOptions, onEvent: (e: SSEEvent) => void): Promise<Message>;
+/**
+ * Ask the server to stop generating a turn.
+ *
+ * This is REQUIRED for Stop to work, not an optimisation. A dropped socket used to abort
+ * the model; now it detaches and keeps generating so a network blip doesn't discard the
+ * turn (see the resume machinery above). Since a deliberate Stop looks identical to a
+ * blip from the server's side, it has to be signalled explicitly — otherwise the model
+ * would run to completion and bill in full after the user pressed Stop.
+ *
+ * Best-effort and never throws: Stop must feel instant, and the server's detach grace
+ * bounds the cost if this request never lands.
+ */
+export declare function cancelTurn(turnId: string): Promise<void>;
 export declare function getBalance(): Promise<number>;
 export declare function exchangeVscodeCode(code: string): Promise<AuthConfig>;
 export declare function login(email: string, password: string): Promise<AuthConfig>;

package/dist/api/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/api/client.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,UAAU,EAA8B,UAAU,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAKrH,eAAO,MAAM,QAAQ,4BAA4B,CAAC;AAIlD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,EAC5D,OAAO,EAAE,CAAC,EAAE,EACZ,UAAU,EAAE,KAAK,CAAC;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,GAAG,IAAI,GAAG,SAAS,GACtD,CAAC,EAAE,CAML;AAeD,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,UAAU,CAAC;IACjB,aAAa,CAAC,EAAE,aAAa,GAAG,IAAI,CAAC;IACrC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC;IACnC,oFAAoF;IACpF,UAAU,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,CAAC,CAAC;IACjG,6EAA6E;IAC7E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,6IAA6I;IAC7I,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AA0BD,wBAAsB,UAAU,CAC9B,QAAQ,EAAE,OAAO,EAAE,EACnB,OAAO,EAAE,iBAAiB,EAC1B,OAAO,EAAE,CAAC,CAAC,EAAE,QAAQ,KAAK,IAAI,GAC7B,OAAO,CAAC,OAAO,CAAC,CA4clB;AAID,wBAAsB,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC,CAalD;AAID,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAgB1E;AAID,wBAAsB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAkBhF"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/api/client.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,UAAU,EAA8B,UAAU,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAiErH,eAAO,MAAM,QAAQ,QAAmB,CAAC;AAIzC;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,EAC5D,OAAO,EAAE,CAAC,EAAE,EACZ,UAAU,EAAE,KAAK,CAAC;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,GAAG,IAAI,GAAG,SAAS,GACtD,CAAC,EAAE,CAeL;AAeD,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,UAAU,CAAC;IACjB,aAAa,CAAC,EAAE,aAAa,GAAG,IAAI,CAAC;IACrC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC;IACnC,oFAAoF;IACpF,UAAU,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,CAAC,CAAC;IACjG,6EAA6E;IAC7E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,6IAA6I;IAC7I,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;;;;;;;;;;;OAeG;IACH,uBAAuB,CAAC,EAAE,OAAO,CAAC;CACnC;AAiDD,wBAAsB,UAAU,CAC9B,QAAQ,EAAE,OAAO,EAAE,EACnB,OAAO,EAAE,iBAAiB,EAC1B,OAAO,EAAE,CAAC,CAAC,EAAE,QAAQ,KAAK,IAAI,GAC7B,OAAO,CAAC,OAAO,CAAC,CA05BlB;AAID;;;;;;;;;;;GAWG;AACH,wBAAsB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAU9D;AAID,wBAAsB,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC,CAalD;AAID,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAgB1E;AAID,wBAAsB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAkBhF"}