billion-context 0.1.72 → 0.1.73-pr.440.290

package/dist/index.js

@@ -51466,8 +51466,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 +51498,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 +51718,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 +51734,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 +51776,7 @@ async function* runCompressLoop(upstream, ctx, requestBody, requestOptions, adap
         return;
       }
       currentUpstream = respResult.response.body;
+      roundBody = newBody;
       if (activeClearTimer) activeClearTimer();
       activeClearTimer = respResult.clearTimer;
     }
@@ -52056,6 +52101,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 +52169,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 +52307,7 @@ function createResponsesAdapter(textProtocol, projection) {
         }
       }
       if (!terminalKind) {
-        yield { kind: "done", finishReason: "failed" };
+        yield { kind: "done", finishReason: "failed", truncated: true };
       }
     },
     emitText(delta) {
@@ -52266,18 +52330,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 +52365,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 +52890,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 +53000,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 +53016,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 +53066,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 +53163,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);
     }
   };
 }
@@ -53254,6 +53369,86 @@ async function compressLoopResponsesJson(initialResponse, ctx, requestBody, requ
   return current;
 }
 
+// src/fake-completion.ts
+var FAKE_COMPLETION_HINT = "[billion-context] Your last reply described a tool call as plain text instead of invoking it, so no tool actually ran. To act, invoke the tool through the proper tool-calling mechanism (emit a tool_use / tool_calls / function_call block). Do not write tool-call markup as text in your reply.";
+function maxFakeCompletionRetries() {
+  const n = Number.parseInt(process.env.BILI_FAKE_COMPLETION_RETRIES ?? "0", 10);
+  return Number.isFinite(n) && n >= 0 ? n : 0;
+}
+function fakeBufCap() {
+  const n = Number.parseInt(process.env.BILI_FAKE_BUF_CAP ?? String(16 * 1024 * 1024), 10);
+  return Number.isFinite(n) && n > 0 ? n : 16 * 1024 * 1024;
+}
+var ANTHROPIC_TOOL_BLOCK = /"type"\s*:\s*"tool_use"/;
+var OPENAI_TOOL_BLOCK = /"tool_calls"\s*:\s*\[\s*\{/;
+var RESPONSES_TOOL_BLOCK = /"type"\s*:\s*"function_call"/;
+function hasToolBlock(protocol, rawText) {
+  switch (protocol) {
+    case "anthropic":
+      return ANTHROPIC_TOOL_BLOCK.test(rawText);
+    case "openai":
+      return OPENAI_TOOL_BLOCK.test(rawText);
+    case "responses":
+      return RESPONSES_TOOL_BLOCK.test(rawText);
+  }
+}
+var TOOL_OPEN = /\x3c(?!\s*\/)(?:antml:)?(invoke|tool_calls|tool_call|parameter|parameters)\b|\\u003c(?!\s*\/)(?:antml:)?(invoke|tool_calls|tool_call|parameter|parameters)\b/i;
+var TOOL_CLOSE_GLOBAL = /\x3c\/(?:antml:)?(invoke|tool_calls|tool_call|parameter|parameters)\b|\\u003c\/(?:antml:)?(invoke|tool_calls|tool_call|parameter|parameters)\b/gi;
+function hasToolCallStructure(text) {
+  if (!containsToolCallXmlFragment(text)) return false;
+  if (TOOL_OPEN.test(text)) return true;
+  const closes = /* @__PURE__ */ new Set();
+  for (const m2 of text.matchAll(TOOL_CLOSE_GLOBAL)) {
+    const name = m2[1] ?? m2[2];
+    if (name) closes.add(name.toLowerCase());
+  }
+  return closes.size >= 2;
+}
+function isFakeCompletion(protocol, rawText) {
+  return hasToolCallStructure(rawText) && !hasToolBlock(protocol, rawText);
+}
+function injectFakeCompletionHint(protocol, body) {
+  const raw = typeof body === "string" ? body : body.toString("utf8");
+  let obj;
+  try {
+    obj = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (protocol === "responses") {
+    const input = obj.input;
+    if (!Array.isArray(input)) return null;
+    const arr2 = input;
+    const last2 = arr2[arr2.length - 1];
+    if (last2 && typeof last2 === "object" && last2.role === "user") {
+      const c = last2.content;
+      if (typeof c === "string") last2.content = `${c}
+
+${FAKE_COMPLETION_HINT}`;
+      else if (Array.isArray(c)) last2.content = [...c, { type: "input_text", text: FAKE_COMPLETION_HINT }];
+      else last2.content = FAKE_COMPLETION_HINT;
+    } else {
+      arr2.push({ role: "user", content: [{ type: "input_text", text: FAKE_COMPLETION_HINT }] });
+    }
+    return JSON.stringify(obj);
+  }
+  const messages = obj.messages;
+  if (!Array.isArray(messages)) return null;
+  const arr = messages;
+  const last = arr[arr.length - 1];
+  if (last && typeof last === "object" && last.role === "user") {
+    const c = last.content;
+    if (typeof c === "string") last.content = `${c}
+
+${FAKE_COMPLETION_HINT}`;
+    else if (Array.isArray(c)) last.content = [...c, { type: "text", text: FAKE_COMPLETION_HINT }];
+    else last.content = FAKE_COMPLETION_HINT;
+  } else {
+    arr.push({ role: "user", content: FAKE_COMPLETION_HINT });
+  }
+  return JSON.stringify(obj);
+}
+
 // src/stream-openai.ts
 function rewriteOpenaiJsonResponse(body, ctx) {
   if (!body || typeof body !== "object") return body;
@@ -54221,7 +54416,7 @@ function mergeUsageSample(acc, sample) {
   if (sample.cachedTokens !== void 0) acc.cachedTokens = sample.cachedTokens;
   if (sample.outputTokens !== void 0) acc.outputTokens = sample.outputTokens;
 }
-async function pipePluginChatWithStrip(stream2, res, session, protocol, log2) {
+async function pipePluginChatWithStrip(stream2, res, protocol, session, log2) {
   const reader = stream2.getReader();
   const decoder = new TextDecoder("utf-8");
   let buf = "";
@@ -54375,7 +54570,7 @@ data: ${JSON.stringify({ type: "content_block_delta", index, delta: { type: delt
     }
     const rest = flushTails();
     if (rest.length > 0 && !res.destroyed && !res.writableEnded) await write(rest);
-    if (acc.inputTokens !== void 0 || acc.outputTokens !== void 0 || acc.cachedTokens !== void 0) {
+    if (session && (acc.inputTokens !== void 0 || acc.outputTokens !== void 0 || acc.cachedTokens !== void 0)) {
       applyUsageSample(session, acc, protocol);
       markDirty(session);
     }
@@ -54484,7 +54679,7 @@ async function pipePluginResponsesWithStrip(stream2, res, session, log2) {
       const rest = flushTail("");
       if (rest.length > 0) await write(rest);
     }
-    if (acc.inputTokens !== void 0 || acc.outputTokens !== void 0 || acc.cachedTokens !== void 0) {
+    if (session && (acc.inputTokens !== void 0 || acc.outputTokens !== void 0 || acc.cachedTokens !== void 0)) {
       applyUsageSample(session, acc, "responses");
       markDirty(session);
     }
@@ -57511,7 +57706,7 @@ ${hdrText}
       if (prepared.protocol === "responses") {
         await pipePluginResponsesWithStrip(upstream.body, res, prepared.session, (msg) => log2("info", `[${prepared.session.id}] ${msg}`));
       } else {
-        await pipePluginChatWithStrip(upstream.body, res, prepared.session, prepared.protocol, (msg) => log2("info", `[${prepared.session.id}] ${msg}`));
+        await pipePluginChatWithStrip(upstream.body, res, prepared.protocol, prepared.session, (msg) => log2("info", `[${prepared.session.id}] ${msg}`));
       }
     } else {
       await pipePluginJson(upstream.body, res, prepared.session, prepared.protocol);
@@ -57519,10 +57714,24 @@ ${hdrText}
     clearUpstreamTimer();
     return;
   }
+  let responseBody = upstream.body;
+  if (prepared !== null && prepared.stream && maxFakeCompletionRetries() > 0) {
+    const resolvedBuf = await resolveFakeCompletion(upstream.body, {
+      protocol: prepared.protocol,
+      body,
+      upstreamUrl,
+      reqHeaders: buildForwardHeaders(headers),
+      proxyUrl,
+      signal: clientAbort.signal,
+      session: prepared.session,
+      log: log2
+    });
+    responseBody = bufferToStream(resolvedBuf);
+  }
   const useRewriter = prepared !== null && prepared.compressInjected && prepared.processedMessages.length > 0;
   if (!useRewriter || prepared === null) {
     if (prepared && prepared.resetAfterSuccess) {
-      const [toClient, toObserve] = upstream.body.tee();
+      const [toClient, toObserve] = responseBody.tee();
       const observed = observeResponsesTerminalState(toObserve, prepared.stream);
       await pipeThrough(toClient, res);
       clearUpstreamTimer();
@@ -57533,8 +57742,17 @@ ${hdrText}
       } else {
         log2("warn", `[${prepared.session.id}] native compact response terminal=${terminal}; rebase NOT scheduled`);
       }
+    } else if (prepared && prepared.stream && (upstream.headers.get("content-type") ?? "").includes("text/event-stream")) {
+      const p2 = prepared;
+      const tagLog = (msg) => log2("info", `[${p2.session.id}] ${msg}`);
+      if (p2.protocol === "responses") {
+        await pipePluginResponsesWithStrip(responseBody, res, void 0, tagLog);
+      } else {
+        await pipePluginChatWithStrip(responseBody, res, p2.protocol, void 0, tagLog);
+      }
+      clearUpstreamTimer();
     } else {
-      await pipeThrough(upstream.body, res);
+      await pipeThrough(responseBody, res);
       clearUpstreamTimer();
     }
     return;
@@ -57548,10 +57766,10 @@ ${hdrText}
     debug: opts.debug
   };
   if (prepared.stream) {
-    let streamToRead = upstream.body;
+    let streamToRead = responseBody;
     let dumpRaw;
     if (opts.dumpSse) {
-      const [a, b2] = upstream.body.tee();
+      const [a, b2] = responseBody.tee();
       streamToRead = a;
       dumpRaw = dumpStreamToFile(b2, opts.dumpSse, `${Date.now()}-${safeSessionId(prepared.session.id)}-raw.sse`);
     }
@@ -57677,6 +57895,58 @@ async function readStreamToBuffer(stream2, maxBytes = 1 << 20) {
   }
   return Buffer.concat(chunks);
 }
+function bufferToStream(buf) {
+  return new ReadableStream({
+    start(controller) {
+      controller.enqueue(new Uint8Array(buf));
+      controller.close();
+    }
+  });
+}
+async function resolveFakeCompletion(stream2, opts) {
+  let buffer = await readStreamToBuffer(stream2, fakeBufCap());
+  const max = maxFakeCompletionRetries();
+  const sid = opts.session.id;
+  const priorStreak = opts.session.metadata.fakeCompletionStreak ?? 0;
+  if (max > 0 && priorStreak < max && isFakeCompletion(opts.protocol, buffer.toString("utf8"))) {
+    for (let attempt = 1; attempt <= max && !opts.signal.aborted; attempt++) {
+      const hinted = injectFakeCompletionHint(opts.protocol, opts.body);
+      if (hinted === null) break;
+      opts.log("warn", `[${sid}] fake completion (tool-call XML, no tool block); retry ${attempt}/${max} with corrective hint`);
+      let r;
+      try {
+        r = await fetchWithTimeout(
+          opts.upstreamUrl,
+          {
+            method: "POST",
+            headers: opts.reqHeaders,
+            body: hinted,
+            ...opts.proxyUrl ? { dispatcher: proxyDispatcher(opts.proxyUrl) } : {}
+          },
+          void 0,
+          opts.signal
+        );
+      } catch (e) {
+        opts.log("warn", `[${sid}] fake-completion retry failed: ${String(e)}; presenting original`);
+        break;
+      }
+      try {
+        if (!r.response.ok || !r.response.body) {
+          opts.log("warn", `[${sid}] fake-completion retry rejected (HTTP ${r.response.status}); presenting original`);
+          break;
+        }
+        buffer = await readStreamToBuffer(r.response.body, fakeBufCap());
+      } finally {
+        r.clearTimer();
+      }
+      if (!isFakeCompletion(opts.protocol, buffer.toString("utf8"))) break;
+    }
+  }
+  const stillFake = isFakeCompletion(opts.protocol, buffer.toString("utf8"));
+  opts.session.metadata.fakeCompletionStreak = stillFake ? priorStreak + 1 : 0;
+  markDirty(opts.session);
+  return buffer;
+}
 async function pipeThrough(stream2, res) {
   const reader = stream2.getReader();
   try {