@nexrall/code-core 1.4.7 → 1.4.9

package/dist/agent/loop.d.ts

@@ -71,8 +71,17 @@ export declare function ledgerSummary(ledger: ProgressLedger): string;
  * serialised body schema-clean while remaining idempotent across repeat calls.
  *
  * Returns the number of bytes reclaimed (0 if nothing was prunable).
+ *
+ * `minReclaimBytes` (default 0): if the TOTAL prunable amount is below this, the
+ * function makes NO changes and returns 0. This is a cache-safety gate — pruning
+ * even one old block changes the request prefix and invalidates the message-level
+ * prompt cache, so a tiny prune would bust the cache (re-write at 1.25×) for
+ * almost no size win. Measuring first, then applying only if worthwhile, keeps
+ * the "don't bust cache for a trivial gain" contract truly atomic (the old code
+ * mutated first and let the caller decide, which had already invalidated the
+ * cache by the time the caller declined).
  */
-export declare function pruneOldToolResults(messages: Message[]): number;
+export declare function pruneOldToolResults(messages: Message[], minReclaimBytes?: number): number;
 /** Rough token estimate for a resumed transcript — no API round-trip needed. */
 export declare function estimateTokensRough(messages: Message[]): number;
 /**

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;AAsKlB,wBAAgB,oBAAoB,CAClC,WAAW,EAAE,MAAM,GAAG,SAAS,EAC/B,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACnC,MAAM,CAWR;AA8RD,+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;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,MAAM,CAmB/D;AA+GD,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,CA2DlB;AAID,wBAAsB,YAAY,CAChC,eAAe,EAAE,OAAO,EAAE,EAC1B,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,OAAO,EAAE,CAAC,CAulBpB"}
+{"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;AAsKlB,wBAAgB,oBAAoB,CAClC,WAAW,EAAE,MAAM,GAAG,SAAS,EAC/B,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACnC,MAAM,CAWR;AA4TD,+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;AAsHD,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,CAumBpB"}

package/dist/agent/loop.js

@@ -416,7 +416,37 @@ const MODEL_CONTEXT_TOKENS = {
     pro: 1000000,
     ultra: 1000000,
 };
-const AUTO_COMPACT_THRESHOLD = 0.8; // compact when prompt > 80% of the window
+// ── Compaction thresholds (cost control) ─────────────────────────────────────
+// Two independent triggers, deliberately at DIFFERENT levels:
+//
+//   • PRUNE threshold (cheap, lossy-but-structure-preserving, NO model call):
+//     fires EARLY. Every turn a large history is resent, cache-read alone
+//     (0.10× input) is still billed on the whole prefix — on a 700K-token
+//     session that is real money accruing per turn long before the 1M wall.
+//     Anthropic's own server-side compaction defaults its trigger to 150K
+//     input tokens (docs: compact_20260112 default trigger 150000). We mirror
+//     that intent: start shedding already-consumed tool_result bulk at ~35% of
+//     a 1M window (~350K tokens) so the per-turn cache-read bill stops growing,
+//     WITHOUT paying for a summariser model call and WITHOUT dropping any turn
+//     (pruneOldToolResults keeps every tool_use/tool_result pair intact).
+//
+//   • SUMMARISE threshold (expensive: a real model call, lossy: drops whole
+//     turns): stays LATE, because summarise-of-summarise is the main cause of an
+//     agent "forgetting" earlier work. Only when cheap pruning can't keep the
+//     prompt under this line do we fall through to summarisation.
+//
+// Both are overridable via env for power users / tests.
+function envFraction(name, fallback) {
+    const v = Number(process.env[name]);
+    return Number.isFinite(v) && v > 0 && v < 1 ? v : fallback;
+}
+// Prune early (~35% of window), summarise late (~80% of window).
+const AUTO_PRUNE_THRESHOLD = envFraction('NEXRALL_PRUNE_THRESHOLD', 0.35);
+const AUTO_COMPACT_THRESHOLD = envFraction('NEXRALL_COMPACT_THRESHOLD', 0.8); // summarise when prompt > 80% of the window
+// Only bother pruning if it reclaims a meaningful amount — a tiny prune busts
+// the message-level prompt cache (the pruned prefix changes) for little gain,
+// so we require at least this many bytes reclaimed before accepting a prune.
+const PRUNE_MIN_RECLAIM_BYTES = 256 * 1024; // 256 KB
 const COMPACT_KEEP_MIN = 6; // always keep at least the last N messages verbatim
 // Byte-level safety net, independent of the token estimate.
 //
@@ -675,12 +705,23 @@ const PRUNE_MARKER_TAIL = ' pruned to conserve context. Re-run the tool if you n
  * serialised body schema-clean while remaining idempotent across repeat calls.
  *
  * Returns the number of bytes reclaimed (0 if nothing was prunable).
+ *
+ * `minReclaimBytes` (default 0): if the TOTAL prunable amount is below this, the
+ * function makes NO changes and returns 0. This is a cache-safety gate — pruning
+ * even one old block changes the request prefix and invalidates the message-level
+ * prompt cache, so a tiny prune would bust the cache (re-write at 1.25×) for
+ * almost no size win. Measuring first, then applying only if worthwhile, keeps
+ * the "don't bust cache for a trivial gain" contract truly atomic (the old code
+ * mutated first and let the caller decide, which had already invalidated the
+ * cache by the time the caller declined).
  */
-function pruneOldToolResults(messages) {
+function pruneOldToolResults(messages, minReclaimBytes = 0) {
     const cutoff = messages.length - PRUNE_KEEP_RECENT;
     if (cutoff <= 1)
         return 0;
-    let reclaimed = 0;
+    // Collect prunable blocks + measure the total reclaim WITHOUT mutating yet.
+    const targets = [];
+    let total = 0;
     for (let i = 0; i < cutoff; i++) {
         const m = messages[i];
         if (!Array.isArray(m.content))
@@ -695,10 +736,19 @@ function pruneOldToolResults(messages) {
                 continue; // already small
             const head = text.slice(0, PRUNE_STUB_KEEP_CHARS);
             const omitted = text.length - head.length;
-            b.content = `${head}${PRUNE_MARKER}${omitted} chars of earlier tool output${PRUNE_MARKER_TAIL}`;
-            reclaimed += omitted;
+            targets.push({ block: b, head, omitted });
+            total += omitted;
         }
     }
+    // Cache-safety gate: not worth busting the prompt cache for a trivial reclaim.
+    if (total < minReclaimBytes)
+        return 0;
+    // Worthwhile — apply the stubs.
+    let reclaimed = 0;
+    for (const { block, head, omitted } of targets) {
+        block.content = `${head}${PRUNE_MARKER}${omitted} chars of earlier tool output${PRUNE_MARKER_TAIL}`;
+        reclaimed += omitted;
+    }
     return reclaimed;
 }
 /**
@@ -736,7 +786,14 @@ async function autoCompactMessages(messages, options, ledger) {
     let summary = '';
     try {
         const reply = await (0, client_1.streamChat)([{ role: 'user', content: [{ type: 'text', text: summaryPrompt }] }], {
-            model: options.model ?? 'turbo',
+            // COST: the summariser is a mechanical "bullet-point this transcript" task —
+            // its quality is indistinguishable across model tiers, so there is no reason
+            // to run it on the user's (possibly expensive) tier. Force 'turbo' (Sonnet 5):
+            // it is the cheapest 1M-context tier (in $2.0/1M vs Opus $2.5, Fable $3.0;
+            // out $15/1M vs $25 / $50), so this is always ≤ the user's cost, and its 1M
+            // window comfortably holds the transcript (capped at ~170K tokens by
+            // transcriptOf) even on the largest sessions.
+            model: 'turbo',
             mode: 'ask', // summariser must not call tools; ask-mode discourages action
             env: options.env,
             clientType: options.clientType,
@@ -818,13 +875,20 @@ async function compactMessagesForResume(messages, opts) {
     const contextWindow = MODEL_CONTEXT_TOKENS[opts.model ?? 'turbo'] ?? 1000000;
     let bodyBytes = estimateBodyBytes(messages);
     let tokenGuess = estimateTokensRough(messages);
-    const overThreshold = () => tokenGuess > contextWindow * AUTO_COMPACT_THRESHOLD || bodyBytes > MAX_BODY_BYTES;
-    if (!overThreshold())
+    // Prune fires at the EARLY threshold (mirrors the in-loop guard); summarisation
+    // only at the late one. On resume this matters most: a stored session is resent
+    // whole on the first turn, so shedding old tool_result bulk up front is exactly
+    // what stops that first message being billed at full size.
+    const overPruneThreshold = () => tokenGuess > contextWindow * AUTO_PRUNE_THRESHOLD || bodyBytes > MAX_BODY_BYTES;
+    const overCompactThreshold = () => tokenGuess > contextWindow * AUTO_COMPACT_THRESHOLD || bodyBytes > MAX_BODY_BYTES;
+    if (!overPruneThreshold())
         return false;
     let compacted = false;
-    // Cheap pass first — shrinks old tool_result blocks with no model call.
+    // Cheap pass first — shrinks old tool_result blocks with no model call. The
+    // reclaim floor is enforced atomically inside pruneOldToolResults (measures
+    // first, mutates only if worthwhile), so a declined prune leaves the cache intact.
     if (messages.length > PRUNE_KEEP_RECENT + 2) {
-        const reclaimed = pruneOldToolResults(messages);
+        const reclaimed = pruneOldToolResults(messages, PRUNE_MIN_RECLAIM_BYTES);
         if (reclaimed > 0) {
             bodyBytes = estimateBodyBytes(messages);
             tokenGuess = estimateTokensRough(messages);
@@ -832,11 +896,13 @@ async function compactMessagesForResume(messages, opts) {
             opts.onNotice?.(`\n\u267b\ufe0f Trimmed ~${(reclaimed / (1024 * 1024)).toFixed(1)}MB of older tool output before resuming this chat.\n`);
         }
     }
-    // If still over threshold, fall through to summarising compaction — same
-    // mechanism the in-loop guard uses, so this can safely loop (a single
-    // summarisation pass may still leave a very long session over threshold).
+    // If still over the LATE (summarise) threshold, fall through to summarising
+    // compaction — same mechanism the in-loop guard uses, so this can safely loop
+    // (a single summarisation pass may still leave a very long session over it).
+    // A session between the prune and summarise thresholds is left as-is after the
+    // cheap prune: no model call needed, prefix already shrunk.
     let guard = 0;
-    while (overThreshold() && messages.length > COMPACT_KEEP_MIN + 2 && guard < 5) {
+    while (overCompactThreshold() && messages.length > COMPACT_KEEP_MIN + 2 && guard < 5) {
         guard += 1;
         // No ledger at resume time — the ledger is per-run, in-memory, and would
         // have been created fresh anyway since this is a new process/run. The
@@ -931,27 +997,43 @@ async function runAgentLoop(initialMessages, options) {
         for (; iteration < budget; iteration++) {
             if (options.abortSignal?.aborted)
                 break;
-            // Auto-compact: summarise older history before the next stream so we never
-            // hit the context-window wall — or the backend body-size limit — mid-task.
-            // Runs at a turn boundary only. Two independent triggers:
-            //   1. TOKEN pressure — the last request's prompt crossed 80% of the window.
-            //   2. BYTE pressure  — the serialised body has grown past MAX_BODY_BYTES.
-            // The byte trigger is what catches tool-heavy runs whose body balloons past
-            // the server's 413 limit while the token count still looks fine (and it fires
-            // even on turn 0 of a resumed large session, where lastPromptTokens is 0).
+            // Auto-compact: keep the resent prompt small BEFORE the next stream so we
+            // never hit the context-window wall — or the backend body-size limit — and,
+            // just as importantly, so we stop paying cache-read on an ever-growing prefix
+            // every single turn on a long task. Runs at a turn boundary only.
+            //
+            // THREE nested triggers, cheapest/earliest first:
+            //   1. PRUNE pressure — prompt crossed AUTO_PRUNE_THRESHOLD (~35% of window)
+            //      OR the body crossed MAX_BODY_BYTES. Handled by the CHEAP, structure-
+            //      preserving prune (no model call, keeps every turn). This is the big
+            //      cost win: it fires ~2× earlier than summarisation used to, shedding
+            //      already-consumed tool_result bulk (read_file/bash/grep output the
+            //      model has long since acted on) so the per-turn cache-read bill stops
+            //      compounding well before the old 80% wall.
+            //   2. SUMMARISE pressure — prompt crossed AUTO_COMPACT_THRESHOLD (~80%) or
+            //      the body is STILL over MAX_BODY_BYTES after pruning. Only then do we
+            //      pay for a summariser call + drop whole turns (kept late on purpose:
+            //      summarise-of-summarise is what makes an agent "forget" earlier work).
+            // The byte trigger also fires even on turn 0 of a resumed large session,
+            // where lastPromptTokens is 0.
             let bodyBytes = estimateBodyBytes(messages);
+            const prunePressure = lastPromptTokens > contextWindow * AUTO_PRUNE_THRESHOLD;
             const tokenPressure = lastPromptTokens > contextWindow * AUTO_COMPACT_THRESHOLD;
             let bytePressure = bodyBytes > MAX_BODY_BYTES;
-            // Byte pressure first tries the CHEAP, structure-preserving prune (no model
-            // call, keeps every turn). Only if that isn't enough do we fall through to
-            // summarisation below. This keeps long runs coherent — summarise-of-summarise
-            // is the main cause of an agent "forgetting" what it did earlier.
-            if (autoCompact && !compacting && bytePressure && messages.length > PRUNE_KEEP_RECENT + 2) {
-                const reclaimed = pruneOldToolResults(messages);
+            // Cheap prune first — on token OR byte pressure. Require a meaningful reclaim
+            // (PRUNE_MIN_RECLAIM_BYTES): a tiny prune would bust the message-level prompt
+            // cache (the pruned prefix changes) for almost no benefit. pruneOldToolResults
+            // is idempotent, so once the old bulk is stubbed this simply no-ops until new
+            // large tool_results age past PRUNE_KEEP_RECENT.
+            if (autoCompact && !compacting && (prunePressure || bytePressure) && messages.length > PRUNE_KEEP_RECENT + 2) {
+                // The gate lives INSIDE pruneOldToolResults now (atomic: it measures the
+                // total first and mutates nothing if it's below the floor), so a declined
+                // prune never invalidates the prompt cache.
+                const reclaimed = pruneOldToolResults(messages, PRUNE_MIN_RECLAIM_BYTES);
                 if (reclaimed > 0) {
                     bodyBytes = estimateBodyBytes(messages);
                     bytePressure = bodyBytes > MAX_BODY_BYTES;
-                    options.onText(`\n\u267b\ufe0f Trimmed ~${(reclaimed / (1024 * 1024)).toFixed(1)}MB of older tool output to conserve context.\n`);
+                    options.onText(`\n\u267b\ufe0f Trimmed ~${(reclaimed / (1024 * 1024)).toFixed(1)}MB of already-processed tool output to keep this chat cheap to continue.\n`);
                 }
             }
             if (autoCompact && !compacting && (tokenPressure || bytePressure) && messages.length > COMPACT_KEEP_MIN + 2) {

package/dist/api/client.d.ts

@@ -1,5 +1,28 @@
 import type { Message, SSEEvent, AuthConfig, EnvContext, EditorContext } from '../types';
 export declare const API_BASE = "https://api.nexrall.com";
+/**
+ * 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.
+ *
+ * - `rebuilt`: the client's own reconstruction from streamed parts (text + tool_use,
+ *   in stream order). This is what we've always stored.
+ * - `rawContent`: Anthropic's authoritative content array for the turn (thinking
+ *   already stripped by the backend), when available.
+ *
+ * Rule: if the raw content contains ANY block beyond plain text / tool_use — i.e.
+ * server-side blocks like `server_tool_use`, `tool_search_tool_result` (with its
+ * nested `tool_reference`s) or `web_search_tool_result` — we MUST preserve the raw
+ * array verbatim so those blocks round-trip back to the API on the next request.
+ * Dropping them breaks the paired server_tool_use/result the API expects AND, for
+ * tool search, makes discovered (deferred) tools be forgotten → re-searched every
+ * turn. For an ordinary turn (only text/tool_use) we keep the rebuilt array so the
+ * common path is byte-identical to before (zero regression).
+ */
+export declare function chooseFinalContent<T extends {
+    type?: string;
+}>(rebuilt: T[], rawContent: Array<{
+    type?: string;
+}> | null | undefined): T[];
 export interface StreamChatOptions {
     model: string;
     env?: EnvContext;

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;AAiBlD,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;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,CA0alB;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":"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;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,CAgclB;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"}

package/dist/api/client.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.API_BASE = void 0;
+exports.chooseFinalContent = chooseFinalContent;
 exports.streamChat = streamChat;
 exports.getBalance = getBalance;
 exports.exchangeVscodeCode = exchangeVscodeCode;
@@ -14,6 +15,30 @@ const index_1 = require("../auth/index");
 // ─── Constants ────────────────────────────────────────────────────────────────
 exports.API_BASE = 'https://api.nexrall.com';
 // ─── Helpers ──────────────────────────────────────────────────────────────────
+/**
+ * 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.
+ *
+ * - `rebuilt`: the client's own reconstruction from streamed parts (text + tool_use,
+ *   in stream order). This is what we've always stored.
+ * - `rawContent`: Anthropic's authoritative content array for the turn (thinking
+ *   already stripped by the backend), when available.
+ *
+ * Rule: if the raw content contains ANY block beyond plain text / tool_use — i.e.
+ * server-side blocks like `server_tool_use`, `tool_search_tool_result` (with its
+ * nested `tool_reference`s) or `web_search_tool_result` — we MUST preserve the raw
+ * array verbatim so those blocks round-trip back to the API on the next request.
+ * Dropping them breaks the paired server_tool_use/result the API expects AND, for
+ * tool search, makes discovered (deferred) tools be forgotten → re-searched every
+ * turn. For an ordinary turn (only text/tool_use) we keep the rebuilt array so the
+ * common path is byte-identical to before (zero regression).
+ */
+function chooseFinalContent(rebuilt, rawContent) {
+    if (!Array.isArray(rawContent))
+        return rebuilt;
+    const hasServerSideBlocks = rawContent.some((b) => b && b.type !== 'text' && b.type !== 'tool_use');
+    return hasServerSideBlocks ? rawContent : rebuilt;
+}
 function authHeaders() {
     const token = (0, index_1.getToken)();
     if (!token) {
@@ -279,28 +304,47 @@ async function streamChat(messages, options, onEvent) {
                             break;
                         }
                         case 'message_complete': {
-                            // Build the complete assistant message from accumulated parts
+                            // Anthropic's stop_reason (and the full raw content array) travel inside
+                            // the nested `message` object the backend forwards verbatim (routes/code.js's
+                            // `sendEvent(res, {type:'message_complete', message})` — `message` is the raw
+                            // Anthropic SDK message with thinking already stripped, which always has
+                            // stop_reason). 'max_tokens' means the model's output was cut off mid-
+                            // generation — if the last content block is a tool_use, its `input` may be a
+                            // truncated JSON object that still happened to parse (e.g. a multi_edit whose
+                            // `edits` array lost its last, still-in-progress element, or came out empty/
+                            // missing entirely) without any error at all. The agent loop uses this to
+                            // refuse executing that block blindly instead of silently applying a partial edit.
+                            const nestedMessage = evt.message;
+                            const stopReason = typeof nestedMessage?.stop_reason === 'string' ? nestedMessage.stop_reason : null;
+                            // Build the complete assistant message from accumulated parts (the common
+                            // path: text + tool_use, in the client's own order).
                             const contentBlocks = [];
                             const fullText = textParts.join('');
                             if (fullText) {
                                 contentBlocks.push({ type: 'text', text: fullText });
                             }
                             contentBlocks.push(...toolUseBlocks);
-                            // Anthropic's stop_reason travels inside the nested `message` object the
-                            // backend forwards verbatim (routes/code.js's `sendEvent(res, {type:
-                            // 'message_complete', message})` — `message` is the raw Anthropic SDK
-                            // message, which always has stop_reason). 'max_tokens' means the model's
-                            // output was cut off mid-generation — if the last content block is a
-                            // tool_use, its `input` may be a truncated JSON object that still happened
-                            // to parse (e.g. a multi_edit whose `edits` array lost its last, still-
-                            // in-progress element, or came out empty/missing entirely) without any
-                            // error at all. The agent loop uses this to refuse executing that block
-                            // blindly instead of silently applying a partial edit.
-                            const nestedMessage = evt.message;
-                            const stopReason = typeof nestedMessage?.stop_reason === 'string' ? nestedMessage.stop_reason : null;
+                            // TOOL-SEARCH / SERVER-SIDE-BLOCK PRESERVATION.
+                            // The rebuild above keeps ONLY text + tool_use. That is lossy for any turn
+                            // that also contains server-side blocks — `server_tool_use`,
+                            // `tool_search_tool_result` (and its nested `tool_reference`s), or a
+                            // `web_search_tool_result`. Those blocks MUST round-trip back to the API
+                            // verbatim on the next request or (a) the API rejects the follow-up (it
+                            // expects the paired server_tool_use/result to be present) and (b) for tool
+                            // search specifically, the discovered (deferred) tools are FORGOTTEN, forcing
+                            // Claude to re-search every turn — the exact opposite of the token saving.
+                            //
+                            // Preserve server-side blocks (tool_search_tool_result / server_tool_use /
+                            // web_search_tool_result) verbatim when present; otherwise keep the rebuilt
+                            // array. See chooseFinalContent for the full rationale. Zero regression for
+                            // an ordinary text/tool_use turn.
+                            const rawContent = Array.isArray(nestedMessage?.content)
+                                ? nestedMessage.content
+                                : null;
+                            const finalContent = chooseFinalContent(contentBlocks, rawContent);
                             completedMessage = {
                                 role: 'assistant',
-                                content: contentBlocks,
+                                content: finalContent,
                                 stopReason,
                             };
                             onEvent({ type: 'message_complete', message: completedMessage });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nexrall/code-core",
-  "version": "1.4.7",
+  "version": "1.4.9",
   "description": "Core agent loop, tools, and extension primitives for Nexrall Code — embed an AI coding agent in any Node.js application.",
   "license": "MIT",
   "author": "Nexrall <support@nexrall.com> (https://nexrall.com)",