billion-context 0.1.69 → 0.1.70-pr.459.276

package/README.md

@@ -65,7 +65,8 @@ The proxy runs in one of two modes, and **the mode decides who executes
 | **Summary carrier on the wire** | **the `compress` tool call** | **an `acp_summary` user message** |
 | System messages on the wire | always exactly 1 (client + prompt) | always exactly 1 (client + prompt) — summaries ride on user messages |
 | SGLang "single system" 400 (#377) | cannot happen | cannot happen (summaries are user messages, not system) |
-| Proxy-injected tools + nudge | none (agent owns compression) | the 4 context tools + nudge (when enabled) |
+| Proxy-injected `compress` tools | none — the agent registers the 4 ACP tools natively | the 4 context tools (when enabled) |
+| Proxy-injected nudge | **yes** — the agent has no nudge channel of its own, so the proxy-side nudge is the proactive compression trigger (preflight alone only fires at the hard limit; #451) | yes (when enabled) |
 
 **Why the carriers differ.** In plugin mode the agent owns compression: the
 `compress` call + result live in the agent's own history and are re-sent every

package/dist/index.js

@@ -50393,6 +50393,44 @@ function stripResponsesText(obj) {
   }
   return obj;
 }
+function stripOpenAIText(obj) {
+  if (!obj || typeof obj !== "object") return obj;
+  const o = obj;
+  const choices = o["choices"];
+  if (!Array.isArray(choices)) return obj;
+  o["choices"] = choices.map((c) => {
+    if (!c || typeof c !== "object") return c;
+    const choice = { ...c };
+    const msg = choice["message"];
+    if (!msg || typeof msg !== "object") return choice;
+    const message = { ...msg };
+    const content = message["content"];
+    if (typeof content === "string" && containsRenderTagText(content)) {
+      message["content"] = stripAcpTags(content);
+    } else if (Array.isArray(content)) {
+      message["content"] = stripParts(content);
+    }
+    choice["message"] = message;
+    return choice;
+  });
+  return obj;
+}
+function stripAnthropicText(obj) {
+  if (!obj || typeof obj !== "object") return obj;
+  const o = obj;
+  const content = o["content"];
+  if (!Array.isArray(content)) return obj;
+  o["content"] = content.map((blk) => {
+    if (blk && typeof blk === "object" && blk.type === "text" && typeof blk.text === "string") {
+      const b2 = blk;
+      if (containsRenderTagText(b2.text)) {
+        return { ...b2, text: stripAcpTags(b2.text) };
+      }
+    }
+    return blk;
+  });
+  return obj;
+}
 
 // src/stream.ts
 function executeAnthropicProxyTool(toolName, args, ctx) {
@@ -51584,6 +51622,20 @@ async function* runCompressLoop(upstream, ctx, requestBody, requestOptions, adap
             coreMessages.push(...hidden.messages);
           }
         }
+        if (ctx.refreshFolded && proxyResults.some((pr2) => pr2.name === "compress" && !pr2.result.includes("FAILED"))) {
+          try {
+            const refreshed = ctx.refreshFolded(coreMessages);
+            if (refreshed.length > 0) {
+              coreMessages.length = 0;
+              coreMessages.push(...refreshed);
+              ctx.session.stats.compressCreditTokens = 0;
+              ctx.log(`[acp-loop] round ${round}: re-request view refreshed to post-compress fold`);
+            }
+          } catch (err2) {
+            ctx.log(`[acp-loop] round ${round}: fold refresh failed (${String(err2)}); keeping pre-compress view`);
+            log("warn", `[acp-loop] fold refresh failed: ${String(err2)}`);
+          }
+        }
       }
       for (const tc of realToolCalls) {
         if (tc.passthrough) continue;
@@ -54165,33 +54217,111 @@ async function pipeThroughWithUsage(stream2, res, session, protocol) {
   const decoder = new TextDecoder("utf-8");
   let buf = "";
   const acc = {};
+  const stripText = protocol === "openai" || protocol === "anthropic";
+  const tagFilter = createTagEchoFilter((snippet) => {
+    log("warn", `[tag-echo] stripped model-emitted render tag (plugin passthrough): ${snippet.slice(0, 80).replace(/\n/g, " ")}`);
+  });
+  let lastChunkBase = null;
+  let lastChoiceIndex = 0;
+  let lastBlockIndex = 0;
+  const write = async (s3) => {
+    if (!res.write(Buffer.from(s3, "utf8"))) {
+      await new Promise((r) => res.once("drain", () => r()));
+    }
+  };
+  const flushTail = () => {
+    const tail = tagFilter.flush();
+    if (tail.length === 0) return "";
+    if (protocol === "openai") {
+      const base = lastChunkBase ? { ...lastChunkBase } : {};
+      delete base["usage"];
+      return `data: ${JSON.stringify({ ...base, choices: [{ index: lastChoiceIndex, delta: { content: tail }, finish_reason: null }] })}
+
+`;
+    }
+    return `event: content_block_delta
+data: ${JSON.stringify({ type: "content_block_delta", index: lastBlockIndex, delta: { type: "text_delta", text: tail } })}
+
+`;
+  };
   try {
     for (; ; ) {
       const { done, value } = await reader.read();
       if (done) break;
       if (value && value.length > 0) {
-        if (!res.write(Buffer.from(value))) {
-          await new Promise((r) => res.once("drain", () => r()));
-        }
         buf = normalizeSseLineEndings(buf + decoder.decode(value, { stream: true }));
         let idx;
         while ((idx = buf.indexOf("\n\n")) !== -1) {
           const rawEvent = buf.slice(0, idx);
           buf = buf.slice(idx + 2);
           const dataLines = rawEvent.split("\n").filter((l) => l.startsWith("data:"));
-          if (dataLines.length === 0) continue;
+          if (dataLines.length === 0) {
+            await write(rawEvent + "\n\n");
+            continue;
+          }
           const jsonStr = dataLines.map((l) => l.slice(5).replace(/^ /, "")).join("\n").trim();
-          if (!jsonStr || jsonStr === "[DONE]") continue;
+          if (!jsonStr || jsonStr === "[DONE]") {
+            await write(flushTail() + rawEvent + "\n\n");
+            continue;
+          }
+          let ev;
           try {
-            const ev = JSON.parse(jsonStr);
-            const sample = usageFromSseEvent(ev);
-            if (sample) mergeUsageSample(acc, sample);
+            ev = JSON.parse(jsonStr);
           } catch {
+            await write(rawEvent + "\n\n");
+            continue;
+          }
+          const sample = usageFromSseEvent(ev);
+          if (sample) mergeUsageSample(acc, sample);
+          if (!stripText) {
+            await write(rawEvent + "\n\n");
+            continue;
           }
+          let dirty = false;
+          let terminal = false;
+          if (protocol === "openai") {
+            const choices = ev["choices"];
+            if (Array.isArray(choices)) {
+              for (let i = 0; i < choices.length; i++) {
+                const choice = choices[i] ?? {};
+                const fr2 = choice["finish_reason"];
+                if (typeof fr2 === "string" && fr2 !== "null") terminal = true;
+                const delta = choice["delta"];
+                const content = delta?.["content"];
+                if (delta && typeof content === "string" && content.length > 0) {
+                  lastChunkBase = ev;
+                  lastChoiceIndex = i;
+                  if (!containsRenderTagText(content) && !tagFilter.pending()) continue;
+                  delta["content"] = tagFilter.push(content);
+                  dirty = true;
+                }
+              }
+            }
+          } else {
+            const t = ev["type"];
+            if (t === "message_delta" || t === "message_stop") terminal = true;
+            if (t === "content_block_delta") {
+              const delta = ev["delta"];
+              const text = delta?.["text"];
+              if (delta?.["type"] === "text_delta" && typeof text === "string" && text.length > 0) {
+                lastBlockIndex = typeof ev["index"] === "number" ? ev["index"] : 0;
+                if (containsRenderTagText(text) || tagFilter.pending()) {
+                  delta["text"] = tagFilter.push(text);
+                  dirty = true;
+                }
+              }
+            }
+          }
+          if (terminal) await write(flushTail());
+          await write(dirty ? rebuildEvent(rawEvent, ev) : rawEvent + "\n\n");
         }
       }
       if (res.destroyed || res.writableEnded) break;
     }
+    if (!res.destroyed && !res.writableEnded) {
+      const rest = flushTail();
+      if (rest.length > 0) await write(rest);
+    }
     if (acc.inputTokens !== void 0 || acc.outputTokens !== void 0 || acc.cachedTokens !== void 0) {
       applyUsageSample(session, acc, protocol);
       markDirty(session);
@@ -54339,11 +54469,12 @@ async function pipePluginJson(stream2, res, session, protocol) {
     }
   } catch {
   }
-  if (protocol === "responses") {
+  if (protocol !== void 0) {
     try {
       const json = JSON.parse(text);
       if (containsRenderTagText(text)) {
-        res.end(Buffer.from(JSON.stringify(stripResponsesText(json)), "utf8"));
+        const stripped = protocol === "responses" ? stripResponsesText(json) : protocol === "openai" ? stripOpenAIText(json) : stripAnthropicText(json);
+        res.end(Buffer.from(JSON.stringify(stripped), "utf8"));
         return;
       }
     } catch {
@@ -56584,7 +56715,7 @@ function diagTagSummary(messages, sessionId, strategy) {
   }
   return `[${sessionId}] processTurn: ${messages.length} msgs, renderTags=${strategy}, ${textTagged} text tagged, ${toolTagged} tool tagged (should be 0 with text-only)`;
 }
-function diagNudge(turn, sessionId, tokenCount, limit, model) {
+function diagNudge(turn, sessionId, tokenCount, limit, model, willInject) {
   const n = turn.nudge;
   if (!n) return `[${sessionId}] nudge: unavailable`;
   const b2 = n.breakdown ?? {};
@@ -56594,7 +56725,7 @@ function diagNudge(turn, sessionId, tokenCount, limit, model) {
   const interval = b2["nudgeGrowthTokens"] ?? 0;
   const pendingT1 = b2["pendingT1"] ?? 0;
   const ref = b2["growthReference"] ?? 0;
-  const inject = n.shouldInject ? `INJECT T${n.tier ?? "?"}` : "idle";
+  const inject = !n.shouldInject ? "idle" : willInject ? `INJECT T${n.tier ?? "?"}` : `ARMED-SUPPRESSED T${n.tier ?? "?"}`;
   const modelTag = model ? ` model=${model}` : "";
   return `[${sessionId}] nudge ${inject}: usage=${pct2} (${tokenCount}/${limit}), growth=${growth}/${floor} (ref=${ref}, interval=${interval}), pendingT1=${pendingT1}/${interval}${modelTag}, reason="${n.reason.slice(0, 120)}"`;
 }
@@ -56629,7 +56760,8 @@ function prepareAnthropic(parsed, req, opts, core, config, prompts, log2, sessio
       if (t) session.meta.title = t;
     }
     log2("info", diagTagSummary(turn.messages, sessionId, "text-only"));
-    log2("info", diagNudge(turn, sessionId, tokenCount, config.modelContextLimit, parsed.model));
+    const willInjectNudge = opts.compress.injectNudge && !!turn.nudge?.shouldInject;
+    log2("info", diagNudge(turn, sessionId, tokenCount, config.modelContextLimit, parsed.model, willInjectNudge));
     processedMessages = stripKernelSummaries(turn.messages, turn.state);
     reapOrphanBlocks(session, msgs, deactivateBlock);
     rebuiltMessages = coreToAnthropic(processedMessages, cacheControls);
@@ -56637,7 +56769,7 @@ function prepareAnthropic(parsed, req, opts, core, config, prompts, log2, sessio
     if (injectTools) {
       toolsOut = injectTool(parsed.tools);
     }
-    if (opts.compress.injectNudge && !pluginMode && turn.nudge?.shouldInject) {
+    if (willInjectNudge && turn.nudge) {
       try {
         const rendered = renderNudgeText(turn.nudge, prompts);
         if (rendered.text) {
@@ -56654,7 +56786,7 @@ function prepareAnthropic(parsed, req, opts, core, config, prompts, log2, sessio
   markDirty(session);
   const rebuilt = { ...parsed, messages: rebuiltMessages, system: systemOut, tools: toolsOut };
   delete rebuilt.prompt_cache_key;
-  return { body: JSON.stringify(rebuilt), session, processedMessages, originalMessages, anthropicSystem: parsed.system, protocol: "anthropic", stream: stream2, compressInjected: injectTools, pluginMode, nudge, prompts };
+  return { body: JSON.stringify(rebuilt), session, processedMessages, originalMessages, anthropicSystem: parsed.system, protocol: "anthropic", stream: stream2, compressInjected: injectTools, pluginMode, nudge, prompts, renderTags: "text-only" };
 }
 function prepareOpenai(parsed, req, opts, core, config, prompts, log2, session, pluginMode) {
   const sessionId = session.id;
@@ -56686,7 +56818,8 @@ function prepareOpenai(parsed, req, opts, core, config, prompts, log2, session,
       if (t) session.meta.title = t;
     }
     log2("info", diagTagSummary(turn.messages, sessionId, "text-only"));
-    log2("info", diagNudge(turn, sessionId, tokenCount, config.modelContextLimit, parsed.model));
+    const willInjectNudge = opts.compress.injectNudge && !!turn.nudge?.shouldInject && shouldInject;
+    log2("info", diagNudge(turn, sessionId, tokenCount, config.modelContextLimit, parsed.model, willInjectNudge));
     processedMessages = stripKernelSummaries(turn.messages, turn.state);
     reapOrphanBlocks(session, msgs, deactivateBlock);
     rebuiltMessages = systemToUser(coreToOpenai(processedMessages));
@@ -56697,7 +56830,7 @@ function prepareOpenai(parsed, req, opts, core, config, prompts, log2, session,
     if (injectTools) {
       toolsOut = injectOpenaiTool(parsed.tools);
     }
-    if (opts.compress.injectNudge && !pluginMode && turn.nudge?.shouldInject && shouldInject) {
+    if (willInjectNudge && turn.nudge) {
       try {
         const rendered = renderNudgeText(turn.nudge, prompts);
         if (rendered.text) {
@@ -56717,7 +56850,7 @@ function prepareOpenai(parsed, req, opts, core, config, prompts, log2, session,
   }
   snapshotMessages(session, originalMessages);
   markDirty(session);
-  return { body: JSON.stringify(rebuilt), session, processedMessages, originalMessages, protocol: "openai", stream: stream2, compressInjected: injectTools, pluginMode, nudge, prompts, openaiSystemText };
+  return { body: JSON.stringify(rebuilt), session, processedMessages, originalMessages, protocol: "openai", stream: stream2, compressInjected: injectTools, pluginMode, nudge, prompts, openaiSystemText, renderTags: "text-only" };
 }
 function prepareResponses(parsed, req, opts, core, config, prompts, log2, session, identity, pluginMode, upstreamOrigin) {
   const sessionId = session.id;
@@ -56755,6 +56888,7 @@ function prepareResponses(parsed, req, opts, core, config, prompts, log2, sessio
   const injectTools = shouldInject && !pluginMode;
   const isCompactionTrigger = hasCompactionTrigger(parsed.input);
   const responsesTextProtocol = FORCE_TEXT_PROTOCOL || resolveCompressProtocol(opts.routes, upstreamOrigin) === "marker";
+  const renderTags = process.env.ACP_RENDER_NONE || isCompactionTrigger ? "none" : "text-only";
   try {
     const projection = responsesToCore(parsed);
     responsesProjection = projection;
@@ -56764,7 +56898,7 @@ function prepareResponses(parsed, req, opts, core, config, prompts, log2, sessio
       log2("info", `[${sessionId}] input items: ${Array.isArray(parsed.input) ? parsed.input.map((i) => i.type).join(",") : "(string)"}`);
     }
     const tokenCount = session.stats.lastInputTokens;
-    const turn = core.processTurn({ messages: msgs, state: session.state, config, tokenCount, renderTags: process.env.ACP_RENDER_NONE || isCompactionTrigger ? "none" : "text-only" });
+    const turn = core.processTurn({ messages: msgs, state: session.state, config, tokenCount, renderTags });
     session.state = turn.state;
     session.stats.compressCreditTokens = 0;
     if (turn.nudge) turn.nudge.compressibleRanges = viableRanges(turn.nudge.compressibleRanges);
@@ -56775,7 +56909,8 @@ function prepareResponses(parsed, req, opts, core, config, prompts, log2, sessio
       if (t) session.meta.title = t;
     }
     log2("info", diagTagSummary(turn.messages, sessionId, "text-only"));
-    log2("info", diagNudge(turn, sessionId, tokenCount, config.modelContextLimit, parsed.model));
+    const willInjectNudge = opts.compress.injectNudge && !!turn.nudge?.shouldInject && shouldInject && !isCompactionTrigger;
+    log2("info", diagNudge(turn, sessionId, tokenCount, config.modelContextLimit, parsed.model, willInjectNudge));
     processedMessages = stripKernelSummaries(turn.messages, turn.state);
     reapOrphanBlocks(session, msgs, deactivateBlock);
     rebuiltInput = patchResponsesInput(projection, processedMessages);
@@ -56791,7 +56926,7 @@ function prepareResponses(parsed, req, opts, core, config, prompts, log2, sessio
       const devContent = [...projection.systemParts, ...forgedSummaries].join("\n\n---\n\n");
       rebuiltInput = injectResponsesDeveloperMessage(rebuiltInput, devContent);
     }
-    if (opts.compress.injectNudge && !pluginMode && turn.nudge?.shouldInject && shouldInject && !isCompactionTrigger) {
+    if (willInjectNudge && turn.nudge) {
       try {
         const rendered = renderNudgeText(turn.nudge, prompts);
         if (rendered.text) {
@@ -56858,6 +56993,7 @@ function prepareResponses(parsed, req, opts, core, config, prompts, log2, sessio
     responsesTextProtocol,
     nudge,
     prompts,
+    renderTags,
     resetAfterSuccess: isCompactionTrigger,
     codexForge
   };
@@ -57360,9 +57496,21 @@ ${hdrText}
       const textProtocol = prepared.protocol === "responses" && !!prepared.responsesTextProtocol;
       const systemPrompt = textProtocol ? buildCompressHybridSystemPrompt(prepared.prompts ?? defaultPrompts) : buildCompressSystemPrompt(prepared.prompts ?? defaultPrompts);
       const adapter = pickAdapter(prepared.protocol, parsedReq, textProtocol, prepared.responsesProjection, prepared.anthropicSystem, prepared.openaiSystemText);
+      const refreshFolded = (current) => {
+        const turn = core.processTurn({
+          messages: prepared.originalMessages,
+          state: prepared.session.state,
+          config,
+          tokenCount: prepared.session.stats.lastInputTokens,
+          renderTags: prepared.renderTags ?? "text-only"
+        });
+        prepared.session.state = turn.state;
+        const records = current.filter((m2) => typeof m2.id === "string" && m2.id.startsWith("acp_loop_"));
+        return stripKernelSummaries([...turn.messages, ...records], turn.state);
+      };
       const loop = runCompressLoop(
         streamToRead,
-        { core, config, messages: prepared.processedMessages.length > 0 ? prepared.processedMessages : prepared.originalMessages, compressMessages: prepared.originalMessages, session: prepared.session, log: ctx.log, proxyUrl, protocol: prepared.protocol, textProtocol, debug: opts.debug, nudge: prepared.nudge },
+        { core, config, messages: prepared.processedMessages.length > 0 ? prepared.processedMessages : prepared.originalMessages, compressMessages: prepared.originalMessages, session: prepared.session, log: ctx.log, proxyUrl, protocol: prepared.protocol, textProtocol, debug: opts.debug, nudge: prepared.nudge, refreshFolded },
         parsedReq,
         { url: upstreamUrl, headers: reqHeaders },
         adapter,