billion-context 0.1.73 → 0.1.74-pr.477.294

package/dist/index.js

@@ -50217,12 +50217,6 @@ ${body.slice(0, 4e3)}...`;
 ${body}`;
 }
 
-// src/sse-util.ts
-function normalizeSseLineEndings(buf) {
-  if (buf.indexOf("\r") === -1) return buf;
-  return buf.replace(/\r\n|\r/g, "\n");
-}
-
 // src/loop/tag-echo-filter.ts
 var PAIRED = /\x3cacp\s[^<>]{0,256}>([^<>]{0,64})<\/acp>/;
 var LONE_OPEN = /\x3cacp(?:\s[^<>]{0,256})?>/;
@@ -51466,8 +51460,26 @@ function recordUsage(ctx, usage, round) {
 async function* runCompressLoop(upstream, ctx, requestBody, requestOptions, adapter, systemPrompt, signal) {
   let activeClearTimer = null;
   let currentUpstream = upstream;
+  let roundBody = requestBody;
   const coreMessages = [...ctx.messages];
   let degradedRetried = false;
+  let truncationRetried = false;
+  const fetchUpstream = (body) => fetchWithRetry(
+    requestOptions.url,
+    {
+      method: "POST",
+      headers: requestOptions.headers,
+      body: JSON.stringify(body),
+      ...ctx.proxyUrl ? { dispatcher: proxyDispatcher(ctx.proxyUrl) } : {}
+    },
+    void 0,
+    signal,
+    (info) => {
+      const lc = lastCompressSuffix(ctx.session.lastCompress);
+      ctx.log(`[acp-proxy: upstream rejected replay (HTTP ${info.status}: ${info.detail.slice(0, 120)}); likely provider risk-control \u2014 retrying in ${info.delayMs}ms (attempt ${info.attempt}/${info.maxAttempts})${lc}]`);
+      log("warn", `[acp-loop] upstream rejected replay (HTTP ${info.status}); retrying in ${info.delayMs}ms (attempt ${info.attempt}/${info.maxAttempts})${lc}`);
+    }
+  );
   try {
     for (let round = 1; round <= MAX_LOOP_ROUNDS; round++) {
       if (signal?.aborted) break;
@@ -51480,50 +51492,93 @@ async function* runCompressLoop(upstream, ctx, requestBody, requestOptions, adap
       let finishReason;
       let sawDone = false;
       let suppressCompletion = false;
-      for await (const ev of adapter.parseStream(currentUpstream, round)) {
-        if (signal?.aborted) break;
-        if (ev.kind === "text") {
-          assistantText += ev.delta;
-          if (!ctx.textProtocol && ev.raw) {
-            yield ev.raw;
-          } else if (!ctx.textProtocol && round > 1 && ev.delta.length > 0) {
-            yield adapter.emitText(ev.delta);
-          }
-        } else if (ev.kind === "reasoning") {
-          assistantReasoning += ev.delta;
-          let seg = reasoningSegments[reasoningSegments.length - 1];
-          if (reasoningSealed || !seg) {
-            seg = { text: "", signature: "" };
-            reasoningSegments.push(seg);
-            reasoningSealed = false;
-          }
-          seg.text += ev.delta;
-          if (ev.signature) seg.signature += ev.signature;
-          if (ev.blockEnd) reasoningSealed = true;
-          if (!ctx.textProtocol) {
-            if (ev.raw) {
-              yield ev.raw;
-            } else if (round > 1 && ev.delta.length > 0 && adapter.emitReasoning) {
-              yield adapter.emitReasoning(ev.delta);
-            }
-          }
-        } else if (ev.kind === "tool_call") {
-          calls.push({ name: ev.name, callId: ev.callId, arguments: ev.arguments, passthrough: ev.passthrough });
-        } else if (ev.kind === "usage") {
-          usage = {
-            inputTokens: ev.inputTokens,
-            outputTokens: ev.outputTokens,
-            cachedTokens: ev.cachedTokens
-          };
-        } else if (ev.kind === "done") {
-          sawDone = true;
-          finishReason = ev.finishReason;
-          suppressCompletion = ev.suppressCompletion === true;
-        } else if (ev.kind === "meta") {
-          if (round === 1 || !ev.firstRoundOnly) {
-            yield ev.chunk;
+      let truncatedDone = false;
+      let forwardedAny = false;
+      const fwd = (chunk) => {
+        forwardedAny = true;
+        return chunk;
+      };
+      for (; ; ) {
+        assistantText = "";
+        assistantReasoning = "";
+        reasoningSegments.length = 0;
+        reasoningSealed = true;
+        calls.length = 0;
+        usage = {};
+        finishReason = void 0;
+        sawDone = false;
+        suppressCompletion = false;
+        truncatedDone = false;
+        forwardedAny = false;
+        for await (const ev of adapter.parseStream(currentUpstream, round)) {
+          if (signal?.aborted) break;
+          if (ev.kind === "text") {
+            assistantText += ev.delta;
+            if (!ctx.textProtocol && ev.raw) {
+              yield fwd(ev.raw);
+            } else if (!ctx.textProtocol && round > 1 && ev.delta.length > 0) {
+              yield fwd(adapter.emitText(ev.delta));
+            }
+          } else if (ev.kind === "reasoning") {
+            assistantReasoning += ev.delta;
+            let seg = reasoningSegments[reasoningSegments.length - 1];
+            if (reasoningSealed || !seg) {
+              seg = { text: "", signature: "" };
+              reasoningSegments.push(seg);
+              reasoningSealed = false;
+            }
+            seg.text += ev.delta;
+            if (ev.signature) seg.signature += ev.signature;
+            if (ev.blockEnd) reasoningSealed = true;
+            if (!ctx.textProtocol) {
+              if (ev.raw) {
+                yield fwd(ev.raw);
+              } else if (round > 1 && ev.delta.length > 0 && adapter.emitReasoning) {
+                yield fwd(adapter.emitReasoning(ev.delta));
+              }
+            }
+          } else if (ev.kind === "tool_call") {
+            calls.push({ name: ev.name, callId: ev.callId, arguments: ev.arguments, passthrough: ev.passthrough });
+          } else if (ev.kind === "usage") {
+            usage = {
+              inputTokens: ev.inputTokens,
+              outputTokens: ev.outputTokens,
+              cachedTokens: ev.cachedTokens
+            };
+          } else if (ev.kind === "done") {
+            sawDone = true;
+            finishReason = ev.finishReason;
+            suppressCompletion = ev.suppressCompletion === true;
+            truncatedDone = ev.truncated === true;
+          } else if (ev.kind === "meta") {
+            if (round === 1 || !ev.firstRoundOnly) {
+              yield fwd(ev.chunk);
+            }
+          }
+        }
+        if ((!sawDone || truncatedDone) && !forwardedAny && calls.length === 0 && !(ctx.textProtocol && assistantText.length > 0) && !signal?.aborted && !truncationRetried) {
+          truncationRetried = true;
+          ctx.log(`[acp-loop] round ${round}: upstream truncated before any content reached the client; retrying fetch once`);
+          try {
+            const respResult2 = await fetchUpstream(roundBody);
+            if (!respResult2.response.body) {
+              respResult2.clearTimer();
+              throw new UpstreamHttpError(respResult2.response.status, "(empty response body)", 1);
+            }
+            currentUpstream = respResult2.response.body;
+            if (activeClearTimer) activeClearTimer();
+            activeClearTimer = respResult2.clearTimer;
+            continue;
+          } catch (e) {
+            if (e instanceof UpstreamHttpError) {
+              const suffix = e.attempts > 1 ? ` after ${e.attempts} attempt(s)` : "";
+              ctx.log(`[acp-loop] round ${round}: truncation retry failed (upstream error ${e.status}${suffix}: ${e.body.slice(0, 200)})`);
+            } else {
+              ctx.log(`[acp-loop] round ${round}: truncation retry failed (${e instanceof Error ? e.message : String(e)})`);
+            }
           }
         }
+        break;
       }
       if (usage.inputTokens !== void 0 || usage.outputTokens !== void 0 || usage.cachedTokens !== void 0) {
         recordUsage(ctx, usage, round);
@@ -51657,7 +51712,6 @@ async function* runCompressLoop(upstream, ctx, requestBody, requestOptions, adap
           const partialReasoning = assistantReasoning.length;
           const msg = `upstream stream truncated (no completion event; round ${round}, ${partialText} text chars + ${partialReasoning} reasoning chars received)`;
           ctx.log(`[acp-loop] round ${round}: ${msg}`);
-          log("error", `[acp-loop] ${msg}`);
           yield adapter.emitError(msg);
           return;
         }
@@ -51674,22 +51728,6 @@ async function* runCompressLoop(upstream, ctx, requestBody, requestOptions, adap
       }
       ctx.log(`[acp-loop] round ${round}: proxy tool executed; re-requesting so the model sees the result`);
       if (signal?.aborted) break;
-      const fetchUpstream = (body) => fetchWithRetry(
-        requestOptions.url,
-        {
-          method: "POST",
-          headers: requestOptions.headers,
-          body: JSON.stringify(body),
-          ...ctx.proxyUrl ? { dispatcher: proxyDispatcher(ctx.proxyUrl) } : {}
-        },
-        void 0,
-        signal,
-        (info) => {
-          const lc = lastCompressSuffix(ctx.session.lastCompress);
-          ctx.log(`[acp-proxy: upstream rejected replay (HTTP ${info.status}: ${info.detail.slice(0, 120)}); likely provider risk-control \u2014 retrying in ${info.delayMs}ms (attempt ${info.attempt}/${info.maxAttempts})${lc}]`);
-          log("warn", `[acp-loop] upstream rejected replay (HTTP ${info.status}); retrying in ${info.delayMs}ms (attempt ${info.attempt}/${info.maxAttempts})${lc}`);
-        }
-      );
       let newBody = adapter.buildRequest(coreMessages, systemPrompt, requestBody);
       if (process.env.ACP_DUMP_BODY === "1") {
         try {
@@ -51732,6 +51770,7 @@ async function* runCompressLoop(upstream, ctx, requestBody, requestOptions, adap
         return;
       }
       currentUpstream = respResult.response.body;
+      roundBody = newBody;
       if (activeClearTimer) activeClearTimer();
       activeClearTimer = respResult.clearTimer;
     }
@@ -52056,6 +52095,20 @@ function createResponsesAdapter(textProtocol, projection) {
   let responseObj = null;
   let terminalRaw = null;
   let terminalKind = null;
+  let createdForwarded = false;
+  let createdRespId = null;
+  const ensureCreated = () => {
+    if (createdForwarded) return null;
+    createdForwarded = true;
+    if (!createdRespId) createdRespId = `resp-proxy-${Date.now()}`;
+    return Buffer.from(
+      `event: response.created
+data: ${JSON.stringify({ type: "response.created", response: { id: createdRespId, status: "in_progress", output: [] } })}
+
+`,
+      "utf8"
+    );
+  };
   return {
     buildRequest(coreMessages, systemPrompt, requestBody) {
       const customToolCallIds = /* @__PURE__ */ new Set();
@@ -52110,6 +52163,11 @@ function createResponsesAdapter(textProtocol, projection) {
           outputIndex = Math.max(outputIndex, obj.output_index + 1);
         }
         if (type === "response.created" || type === "response.in_progress") {
+          if (type === "response.created") {
+            const resp = obj.response;
+            if (resp && typeof resp.id === "string") createdRespId = resp.id;
+            if (round === 1) createdForwarded = true;
+          }
           yield { kind: "meta", chunk: rawBuf, firstRoundOnly: true };
         } else if (type === "response.output_item.added") {
           const item = obj.item;
@@ -52243,7 +52301,7 @@ function createResponsesAdapter(textProtocol, projection) {
         }
       }
       if (!terminalKind) {
-        yield { kind: "done", finishReason: "failed" };
+        yield { kind: "done", finishReason: "failed", truncated: true };
       }
     },
     emitText(delta) {
@@ -52266,18 +52324,22 @@ function createResponsesAdapter(textProtocol, projection) {
         return terminalRaw;
       }
       if (!responseObj && opts?.finishReason === "failed") {
+        const parts = [];
+        const created = ensureCreated();
+        if (created) parts.push(created);
         const failed = {
-          id: `resp-error-${Date.now()}`,
+          id: createdRespId ?? `resp-error-${Date.now()}`,
           status: "failed",
           error: { code: "server_error", message: "upstream returned no response" }
         };
-        return Buffer.from(
+        parts.push(Buffer.from(
           `event: response.failed
 data: ${JSON.stringify({ type: "response.failed", response: failed })}
 
 `,
           "utf8"
-        );
+        ));
+        return Buffer.concat(parts);
       }
       let resp = responseObj ? { ...responseObj } : { id: `resp-proxy-${Date.now()}`, status: "completed", output: [] };
       if (opts?.usage) {
@@ -52297,18 +52359,22 @@ data: ${JSON.stringify({ type: "response.failed", response: failed })}
       return buildCompleted(resp);
     },
     emitError(message) {
+      const parts = [];
+      const created = ensureCreated();
+      if (created) parts.push(created);
       const resp = {
-        id: `resp-error-${Date.now()}`,
+        id: createdRespId ?? `resp-error-${Date.now()}`,
         status: "failed",
         error: { code: "server_error", message }
       };
-      return Buffer.from(
+      parts.push(Buffer.from(
         `event: response.failed
 data: ${JSON.stringify({ type: "response.failed", response: resp })}
 
 `,
         "utf8"
-      );
+      ));
+      return Buffer.concat(parts);
     },
     extractTextTriggers(text) {
       const calls = [];
@@ -52818,6 +52884,33 @@ function createAnthropicAdapter(requestBody, originalSystem) {
   const model = requestBody.model ?? void 0;
   let messageId;
   let clientIndex = 0;
+  let messageStartForwarded = false;
+  const openBlocks = [];
+  const removeOpenBlock = (index) => {
+    const i = openBlocks.indexOf(index);
+    if (i >= 0) openBlocks.splice(i, 1);
+  };
+  const buildSyntheticMessageStart = () => {
+    const extra = {};
+    if (model) extra.model = model;
+    const msg = {
+      id: messageId ?? `msg_acp_error_${Date.now()}`,
+      type: "message",
+      role: "assistant",
+      content: [],
+      stop_reason: null,
+      stop_sequence: null,
+      usage: { input_tokens: 0, output_tokens: 0 },
+      ...extra
+    };
+    return Buffer.from(
+      `event: message_start
+data: ${JSON.stringify({ type: "message_start", message: msg })}
+
+`,
+      "utf8"
+    );
+  };
   const buildTextBlock = (index, text) => Buffer.from(
     `event: content_block_start
 data: ${JSON.stringify({ type: "content_block_start", index, content_block: { type: "text", text: "" } })}
@@ -52901,6 +52994,7 @@ ${systemPrompt}` : systemPrompt;
           if (typeof u2.input_tokens === "number") roundInput = u2.input_tokens;
           if (typeof u2.cache_read_input_tokens === "number") roundCached = u2.cache_read_input_tokens;
           if (round === 1) {
+            messageStartForwarded = true;
             yield { kind: "meta", chunk: rawBuf, firstRoundOnly: true };
           }
         } else if (type === "ping") {
@@ -52916,6 +53010,7 @@ ${systemPrompt}` : systemPrompt;
             if (block.type === "thinking" || block.type === "redacted_thinking") thinkingIndexes.add(upstreamIndex);
             const ci2 = clientIndex++;
             indexMap.set(upstreamIndex, ci2);
+            openBlocks.push(ci2);
             yield { kind: "meta", chunk: remapIndexInEvent(eventStr, ci2), firstRoundOnly: round === 1 };
           }
         } else if (type === "content_block_delta") {
@@ -52965,10 +53060,12 @@ ${systemPrompt}` : systemPrompt;
             };
           } else if (thinkingIndexes.delete(upstreamIndex)) {
             const ci2 = indexMap.get(upstreamIndex) ?? upstreamIndex;
+            removeOpenBlock(ci2);
             yield { kind: "meta", chunk: remapIndexInEvent(eventStr, ci2), firstRoundOnly: false };
             yield { kind: "reasoning", delta: "", blockEnd: true };
           } else {
             const ci2 = indexMap.get(upstreamIndex) ?? upstreamIndex;
+            removeOpenBlock(ci2);
             if (lastTextIndex !== null) {
               const tail = tagFilter.flush();
               if (tail.length > 0) {
@@ -53060,10 +53157,22 @@ data: ${JSON.stringify({ type: "content_block_stop", index })}
       );
     },
     emitError(message) {
-      const errBlock = buildTextBlock(clientIndex++, `
+      const parts = [];
+      if (!messageStartForwarded) {
+        parts.push(buildSyntheticMessageStart());
+        messageStartForwarded = true;
+      }
+      for (const index of openBlocks.splice(0)) {
+        parts.push(Buffer.from(`event: content_block_stop
+data: ${JSON.stringify({ type: "content_block_stop", index })}
+
+`, "utf8"));
+      }
+      parts.push(buildTextBlock(clientIndex++, `
 [acp-proxy: ${message}]
-`);
-      return Buffer.concat([errBlock, buildTerminal("end_turn", 0, 0, 0)]);
+`));
+      parts.push(buildTerminal("end_turn", 0, 0, 0));
+      return Buffer.concat(parts);
     }
   };
 }
@@ -53383,6 +53492,11 @@ function rewriteResponsesJsonResponse(body, ctx) {
   if (!body || typeof body !== "object") return body;
   const b2 = body;
   if (!Array.isArray(b2.output)) return body;
+  const probe = JSON.stringify(b2.output);
+  if (containsRenderTagText(probe)) {
+    ctx.log(`[warn: tag echo] non-stream responses output contains <acp tag: ${probe.slice(0, 120).replace(/\n/g, " ")}`);
+    stripResponsesText(b2);
+  }
   let converted = false;
   let sawReal = false;
   const noteParts = [];
@@ -53944,6 +54058,14 @@ function buildStatusPanel(input) {
 import { fileURLToPath as fileURLToPath2 } from "url";
 import fs4 from "fs";
 import path8 from "path";
+
+// src/sse-util.ts
+function normalizeSseLineEndings(buf) {
+  if (buf.indexOf("\r") === -1) return buf;
+  return buf.replace(/\r\n|\r/g, "\n");
+}
+
+// src/plugin.ts
 var PROXY_VERSION = (() => {
   try {
     const here = fileURLToPath2(import.meta.url);
@@ -54603,7 +54725,7 @@ async function pipePluginJson(stream2, res, session, protocol) {
   try {
     const json = JSON.parse(text);
     const usage = json["usage"];
-    if (usage) {
+    if (session && usage) {
       const input = num2(usage["prompt_tokens"]) ?? num2(usage["input_tokens"]);
       if (input !== void 0) {
         applyUsageSample(session, {
@@ -57618,7 +57740,12 @@ ${hdrText}
     if (prepared && prepared.resetAfterSuccess) {
       const [toClient, toObserve] = responseBody.tee();
       const observed = observeResponsesTerminalState(toObserve, prepared.stream);
-      await pipeThrough(toClient, res);
+      const tagLog = (msg) => log2("info", `[${prepared.session.id}] ${msg}`);
+      if ((upstream.headers.get("content-type") ?? "").includes("text/event-stream")) {
+        await pipePluginResponsesWithStrip(toClient, res, void 0, tagLog);
+      } else {
+        await pipeThrough(toClient, res);
+      }
       clearUpstreamTimer();
       const terminal = await observed;
       if (terminal === "completed") {
@@ -57636,6 +57763,9 @@ ${hdrText}
         await pipePluginChatWithStrip(responseBody, res, p2.protocol, void 0, tagLog);
       }
       clearUpstreamTimer();
+    } else if (prepared && (upstream.headers.get("content-type") ?? "").includes("application/json")) {
+      await pipePluginJson(responseBody, res, void 0, prepared.protocol);
+      clearUpstreamTimer();
     } else {
       await pipeThrough(responseBody, res);
       clearUpstreamTimer();