billion-context 0.1.31 → 0.1.32

package/dist/index.js

@@ -46420,7 +46420,6 @@ function rejectLegacyRoute(key, value) {
 // src/server.ts
 import http from "http";
 import fs3 from "fs";
-import { tmpdir as tmpdir2 } from "os";
 
 // src/registry.ts
 import { readFile, writeFile, mkdir } from "fs/promises";
@@ -47698,9 +47697,15 @@ async function flushAllSessions() {
 var COMPRESS_TOOL_NAME = "compress";
 var ACP_TEXT_OPEN = "<acp_compress>";
 var ACP_TEXT_CLOSE = "</acp_compress>";
+var ACP_STATUS_OPEN = "<acp_status>";
+var ACP_STATUS_CLOSE = "</acp_status>";
+var ACP_SEARCH_OPEN = "<acp_search>";
+var ACP_SEARCH_CLOSE = "</acp_search>";
+var ACP_DECOMPRESS_OPEN = "<acp_decompress>";
+var ACP_DECOMPRESS_CLOSE = "</acp_decompress>";
 var COMPRESS_TOOL = {
   name: COMPRESS_TOOL_NAME,
-  description: "Replace a contiguous range of older conversation with a detailed summary you write. Use when content is genuinely consumed. Batch form: content=[{startId,endId,summary,topic?}].",
+  description: "Replace a contiguous range of older conversation with a detailed summary you write. Use when content is genuinely consumed. Batch form: content=[{startId,endId,summary,topic?}]. REQUIRED \u2014 compress without content is invalid.",
   input_schema: {
     type: "object",
     properties: {
@@ -47719,23 +47724,23 @@ var COMPRESS_TOOL = {
           required: ["startId", "endId", "summary"]
         }
       }
-    }
+    },
+    required: ["content"]
   }
 };
-function parseCompressInput(input) {
+function parseCompressInput(input, callId) {
   if (!input || typeof input !== "object") {
     log("warn", `[acp-compress-input] rejected: not object (${typeof input})`);
     return [];
   }
   const obj = input;
-  if (Array.isArray(obj.content)) {
-    const out = obj.content.map((r) => toRange(r)).filter((r) => r !== null);
-    if (out.length === 0) log("warn", `[acp-compress-input] content array but 0 valid ranges. keys per item: ${obj.content.map((c) => Object.keys(c ?? {}).join(",")).join(" | ")}`);
-    return out;
-  }
   const single = toRange(obj);
-  if (!single) log("warn", `[acp-compress-input] no content array, single-parse failed. top keys: ${Object.keys(obj).join(",")}`);
-  return single ? [single] : [];
+  const ranges = Array.isArray(obj.content) ? obj.content.map((r) => toRange(r)).filter((r) => r !== null) : single ? [single] : [];
+  if (ranges.length === 0) {
+    log("warn", `[acp-compress-input] parsed 0 valid ranges. top keys: ${Object.keys(obj).join(",")}`);
+  }
+  if (callId) for (const r of ranges) r.compressCallId = callId;
+  return ranges;
 }
 function toRange(r) {
   const startRef = pick(r, "startId", "startRef");
@@ -47764,7 +47769,7 @@ var COMPRESS_TOOL_OPENAI = {
         topic: { type: "string", description: "Optional short title for the compressed range" },
         content: {
           type: "array",
-          description: "One or more ranges to compress into separate summary blocks",
+          description: "One or more ranges to compress into separate summary blocks. REQUIRED \u2014 compress without content is invalid.",
           items: {
             type: "object",
             properties: {
@@ -47776,7 +47781,8 @@ var COMPRESS_TOOL_OPENAI = {
             required: ["startId", "endId", "summary"]
           }
         }
-      }
+      },
+      required: ["content"]
     }
   }
 };
@@ -47826,7 +47832,29 @@ Rules for the trigger:
 - JSON shape matches the compress tool: {"content":[{startId,endId,summary,topic?}]}. Batch multiple ranges in one trigger.
 - After emitting the marker, STOP your turn. Do not continue with other text \u2014 the proxy will execute the compression and return the result, then you continue fresh.
 - Do NOT wrap the marker in code fences, quotes, or commentary.
-- NEVER compress on short conversations or when context is small (well below the window limit). Only compress when context is genuinely large.`;
+- NEVER compress on short conversations or when context is small (well below the window limit). Only compress when context is genuinely large.
+
+ACP TOOLS (TEXT TRIGGERS)
+
+Since host tools cannot coexist with a declared tools field, ALL ACP tools use text triggers. Emit the marker; the proxy intercepts and executes it; the marker is stripped from what the user sees.
+
+1. acp_status \u2014 view context usage, compression state, and compressible ranges:
+   ${ACP_STATUS_OPEN}${ACP_STATUS_CLOSE}
+   No payload needed. Use this FIRST when unsure about context state.
+
+2. search_context \u2014 search compressed block summaries by keyword:
+   ${ACP_SEARCH_OPEN}{"query":"auth token refresh"}${ACP_SEARCH_CLOSE}
+   Use when you need details that may have been compressed away.
+
+3. decompress \u2014 restore compressed content for exact details:
+   ${ACP_DECOMPRESS_OPEN}{"blockId":"b5"}${ACP_DECOMPRESS_CLOSE}
+   Optional: {"blockId":"b5","toFile":"/tmp/b5.txt"} to write to file instead.
+   Optional: {"blockId":"b5","full":true} to restore all the way to original messages.
+
+Rules for ALL triggers:
+- Output on its own, NO surrounding prose. Just the raw marker.
+- After emitting, STOP your turn. The proxy executes and returns the result.
+- Do NOT wrap in code fences, quotes, or commentary.`;
 }
 var DECOMPRESS_TOOL_NAME = "decompress";
 var DECOMPRESS_TOOL_OPENAI = {
@@ -47936,6 +47964,14 @@ var PROXY_TOOL_NAMES = /* @__PURE__ */ new Set([
   SEARCH_CONTEXT_TOOL_NAME,
   ACP_STATUS_TOOL_NAME
 ]);
+var MUTATING_PROXY_TOOLS = /* @__PURE__ */ new Set([
+  COMPRESS_TOOL_NAME,
+  DECOMPRESS_TOOL_NAME
+]);
+var READONLY_PROXY_TOOLS = /* @__PURE__ */ new Set([
+  SEARCH_CONTEXT_TOOL_NAME,
+  ACP_STATUS_TOOL_NAME
+]);
 
 // src/decompress-shared.ts
 import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync3 } from "fs";
@@ -48595,7 +48631,9 @@ async function* compressLoopStream(initialUpstream, ctx, requestBody, requestOpt
       }).filter((tc) => tc.name.length > 0);
       const proxyCalls = toolCalls.filter((tc) => PROXY_TOOL_NAMES.has(tc.name));
       const realCalls = toolCalls.filter((tc) => !PROXY_TOOL_NAMES.has(tc.name));
-      const hasOnlyProxy = proxyCalls.length > 0 && realCalls.length === 0;
+      const mutatingProxy = proxyCalls.filter((tc) => MUTATING_PROXY_TOOLS.has(tc.name));
+      const readonlyProxy = proxyCalls.filter((tc) => READONLY_PROXY_TOOLS.has(tc.name));
+      const hasMutatingOnly = mutatingProxy.length > 0 && realCalls.length === 0;
       if (usage) {
         const prompt = usage.prompt_tokens ?? usage.input_tokens;
         const det = usage.prompt_tokens_details ?? usage.prompt_cache_hit_tokens;
@@ -48611,7 +48649,27 @@ async function* compressLoopStream(initialUpstream, ctx, requestBody, requestOpt
           ctx.session.stats.cacheSamples += 1;
         }
       }
-      if (!hasOnlyProxy) {
+      if (!hasMutatingOnly) {
+        for (const tc of readonlyProxy) {
+          let args = {};
+          try {
+            args = JSON.parse(tc.arguments);
+          } catch {
+            args = {};
+          }
+          let result;
+          try {
+            result = executeProxyTool(tc.name, args, ctx);
+          } catch (e) {
+            result = `[${tc.name} FAILED: ${e instanceof Error ? e.message : String(e)}]`;
+          }
+          const preview = result.length > 120 ? result.slice(0, 120) + "..." : result;
+          ctx.log(`[acp-proxy: ${tc.name} (${tc.id}) \u2192 ${preview.replace(/\n/g, " ")}]`);
+          yield Buffer.from(
+            buildContentSse(responseId, model, buildVisibilityMarker(tc.name, result)),
+            "utf8"
+          );
+        }
         for (const tc of realCalls) {
           yield Buffer.from(buildToolCallSse(makeBase(), tc), "utf8");
         }
@@ -48867,8 +48925,23 @@ async function* compressLoopAnthropicStream(initialUpstream, ctx, requestBody, r
       }
       clientIndex = state.clientIndex;
       const proxyCalls = [...state.toolBlocks.values()].filter((b2) => PROXY_TOOL_NAMES.has(b2.name));
-      const hasOnlyProxy = proxyCalls.length > 0 && !hasRealToolUse;
-      if (!hasOnlyProxy) {
+      const mutatingProxy = proxyCalls.filter((b2) => MUTATING_PROXY_TOOLS.has(b2.name));
+      const readonlyProxy = proxyCalls.filter((b2) => READONLY_PROXY_TOOLS.has(b2.name));
+      const hasMutatingOnly = mutatingProxy.length > 0 && !hasRealToolUse;
+      if (!hasMutatingOnly) {
+        for (const tc of readonlyProxy) {
+          const args = safeParse2(tc.json);
+          let result;
+          try {
+            result = executeProxyTool2(tc.name, args, ctx);
+          } catch (e) {
+            result = `[${tc.name} FAILED: ${e instanceof Error ? e.message : String(e)}]`;
+          }
+          const preview = result.length > 120 ? result.slice(0, 120) + "..." : result;
+          ctx.log(`[acp-proxy: ${tc.name} (${tc.id}) \u2192 ${preview.replace(/\n/g, " ")}]`);
+          yield Buffer.from(buildTextBlockSse(clientIndex, buildVisibilityMarker(tc.name, result)), "utf8");
+          clientIndex++;
+        }
         const stop = hasRealToolUse ? "tool_use" : roundStopReason ?? "end_turn";
         yield Buffer.from(buildTerminalSse(stop, totalOutputTokens, totalInputTokens, totalCachedTokens, messageId, model), "utf8");
         return;
@@ -49281,6 +49354,31 @@ function replaceResponsesJsonText(parts, text) {
     part.text = index === 0 ? text : "";
   });
 }
+function surfaceReadonlyJson(current, proxyCalls, ctx) {
+  const markers = [];
+  for (const call of proxyCalls) {
+    if (MUTATING_PROXY_TOOLS.has(call.name)) continue;
+    let args = {};
+    try {
+      args = JSON.parse(call.arguments);
+    } catch {
+      args = {};
+    }
+    let result;
+    try {
+      result = executeProxyTool3(call.name, args, ctx);
+      ctx.log(`[acp-proxy: responses JSON ${call.name} (read-only) \u2192 ${result.slice(0, 120).replace(/\n/g, " ")}]`);
+    } catch (e) {
+      result = `\u274C [ACP] ${call.name} FAILED: ${String(e)}`;
+      ctx.log(`[acp-proxy: responses JSON ${call.name} (read-only) FAILED: ${String(e)}]`);
+    }
+    markers.push(buildVisibilityMarker(call.name, result));
+  }
+  if (markers.length === 0) return current;
+  const out = Array.isArray(current.output) ? [...current.output] : [];
+  out.push({ type: "message", id: `msg_acp_ro_${Date.now()}_${markers.length}`, role: "assistant", content: [{ type: "output_text", text: markers.join("\n") }] });
+  return { ...current, output: out };
+}
 async function compressLoopResponsesJson(initialResponse, ctx, requestBody, requestOptions) {
   let current = initialResponse;
   for (let loopCount = 1; loopCount <= 5; loopCount++) {
@@ -49289,8 +49387,12 @@ async function compressLoopResponsesJson(initialResponse, ctx, requestBody, requ
     const allCalls = [...output.calls, ...extracted.calls].filter((call) => call.name.length > 0);
     const proxyCalls = allCalls.filter((call) => PROXY_TOOL_NAMES.has(call.name));
     const realCalls = allCalls.filter((call) => !PROXY_TOOL_NAMES.has(call.name));
-    if (proxyCalls.length === 0 || realCalls.length > 0) {
-      if (proxyCalls.length > 0) replaceResponsesJsonText(output.textParts, extracted.clean);
+    const mutatingProxy = proxyCalls.filter((call) => MUTATING_PROXY_TOOLS.has(call.name));
+    if (mutatingProxy.length === 0 || realCalls.length > 0) {
+      if (proxyCalls.length > 0) {
+        replaceResponsesJsonText(output.textParts, extracted.clean);
+        current = surfaceReadonlyJson(current, proxyCalls, ctx);
+      }
       return current;
     }
     const inputItems = Array.isArray(requestBody.input) ? [...requestBody.input] : [];
@@ -49437,9 +49539,30 @@ async function* compressLoopResponsesStream(initialUpstream, ctx, requestBody, r
     const allCalls = [...fcByItemId.values()].filter((c) => c.name.length > 0);
     const proxyCalls = allCalls.filter((c) => PROXY_TOOL_NAMES.has(c.name));
     const realCalls = allCalls.filter((c) => !PROXY_TOOL_NAMES.has(c.name));
+    const readonlyProxy = proxyCalls.filter((c) => READONLY_PROXY_TOOLS.has(c.name));
     log("debug", `[acp-diag] round ${loopCount} allCalls=[${allCalls.map((c) => c.name).join(",")}] realCalls=[${realCalls.map((c) => c.name).join(",")}] customToolCalls=${customToolCalls} text=${JSON.stringify(contentText.slice(0, 120))}`);
-    const hasOnlyProxy = proxyCalls.length > 0 && realCalls.length === 0;
-    if (!hasOnlyProxy) {
+    const hasMutatingOnly = proxyCalls.some((c) => MUTATING_PROXY_TOOLS.has(c.name)) && realCalls.length === 0;
+    if (!hasMutatingOnly) {
+      for (const fc of readonlyProxy) {
+        let args = {};
+        try {
+          args = JSON.parse(fc.arguments);
+        } catch (e) {
+          log("warn", `[acp-compress-args] ${fc.name} JSON.parse failed: ${String(e)}`);
+          args = {};
+        }
+        let result;
+        try {
+          result = executeProxyTool3(fc.name, args, ctx);
+          const preview = result.length > 120 ? result.slice(0, 120) + "..." : result;
+          ctx.log(`[acp-proxy: responses ${fc.name} (read-only) (${fc.callId}) \u2192 ${preview.replace(/\n/g, " ")}]`);
+        } catch (e) {
+          result = `\u274C [ACP] ${fc.name} FAILED: ${String(e)}`;
+          ctx.log(`[acp-proxy: responses ${fc.name} (read-only) (${fc.callId}) FAILED: ${String(e)}]`);
+        }
+        const markerItemId = `msg_acp_ro_${Date.now()}_${nextOutputIndex}`;
+        yield Buffer.from(buildMessageItemSequence(markerItemId, nextOutputIndex++, buildVisibilityMarker(fc.name, result)), "utf8");
+      }
       let oi2 = nextOutputIndex;
       for (const fc of realCalls) {
         yield Buffer.from(buildFunctionCallEvents(fc, oi2), "utf8");
@@ -49451,7 +49574,8 @@ async function* compressLoopResponsesStream(initialUpstream, ctx, requestBody, r
         return;
       }
       const hasUsage = !!responseObj?.usage;
-      if (contentText.length === 0 && realCalls.length === 0 && customToolCalls === 0 && !hasUsage) {
+      const emittedReadonly = readonlyProxy.length > 0;
+      if (contentText.length === 0 && realCalls.length === 0 && customToolCalls === 0 && !emittedReadonly && !hasUsage) {
         ctx.log("[acp-proxy: empty upstream response (no content/usage) \u2014 injecting response.failed for client retry]");
         yield Buffer.from(buildFailed(responseObj), "utf8");
         return;
@@ -49532,6 +49656,1070 @@ async function* compressLoopResponsesStream(initialUpstream, ctx, requestBody, r
   }
 }
 
+// src/loop/core.ts
+var MAX_LOOP_ROUNDS = 10;
+function executeProxyTool4(toolName, args, ctx, callId) {
+  if (toolName === "compress") {
+    return applyRanges(parseCompressInput(args, callId), ctx);
+  }
+  if (toolName === "decompress") {
+    return resolveDecompress(args, ctx);
+  }
+  if (toolName === "search_context") {
+    const query = typeof args.query === "string" ? args.query : "";
+    if (query.length === 0) return "[search_context FAILED: query is required]";
+    const limit = typeof args.limit === "number" && args.limit > 0 ? Math.floor(args.limit) : 5;
+    const blocks = ctx.core.search(query, ctx.session.state).slice(0, limit);
+    if (blocks.length === 0) return `[No blocks matched "${query}"]`;
+    const lines = blocks.map((b2) => {
+      const topic = b2.topic ?? "(no topic)";
+      const preview = b2.summary.length > 200 ? b2.summary.slice(0, 200) + "..." : b2.summary;
+      return `${b2.blockId} (T${b2.tier}) "${topic}"
+  ${preview}`;
+    });
+    return `Found ${blocks.length} block(s) for "${query}":
+
+${lines.join("\n\n")}`;
+  }
+  if (toolName === "acp_status") {
+    return buildStatusReport(ctx.session.state, ctx.messages, estimateTokensFast);
+  }
+  return `[Unknown proxy tool: ${toolName}]`;
+}
+function recordUsage(ctx, usage, round) {
+  const prompt = usage.inputTokens;
+  const cached = usage.cachedTokens;
+  const out = usage.outputTokens;
+  if (typeof prompt === "number") ctx.session.stats.inputTokens += prompt;
+  ctx.session.stats.lastInputTokens = (typeof prompt === "number" ? prompt : 0) + (typeof cached === "number" ? cached : 0);
+  if (typeof cached === "number") ctx.session.stats.cachedTokens += cached;
+  if (typeof out === "number") ctx.session.stats.outputTokens += out;
+  ctx.session.stats.cacheSamples += 1;
+  const hitPct = typeof prompt === "number" && typeof cached === "number" && prompt + cached > 0 ? Math.round(cached / (prompt + cached) * 100) : 0;
+  ctx.log(
+    `[acp-usage] round ${round} input=${ctx.session.stats.lastInputTokens} cached=${cached ?? 0} (cache hit ${hitPct}%)`
+  );
+}
+async function* runCompressLoop(upstream, ctx, requestBody, requestOptions, adapter, systemPrompt) {
+  let activeClearTimer = null;
+  let currentUpstream = upstream;
+  const coreMessages = [...ctx.messages];
+  try {
+    for (let round = 1; round <= MAX_LOOP_ROUNDS; round++) {
+      let assistantText = "";
+      const calls = [];
+      let usage = {};
+      let finishReason;
+      for await (const ev of adapter.parseStream(currentUpstream, round)) {
+        if (ev.kind === "text") {
+          assistantText += ev.delta;
+          if (!ctx.textProtocol && round === 1 && ev.raw) {
+            yield ev.raw;
+          }
+        } else if (ev.kind === "tool_call") {
+          calls.push({ name: ev.name, callId: ev.callId, arguments: ev.arguments });
+        } else if (ev.kind === "usage") {
+          usage = {
+            inputTokens: ev.inputTokens,
+            outputTokens: ev.outputTokens,
+            cachedTokens: ev.cachedTokens
+          };
+        } else if (ev.kind === "done") {
+          finishReason = ev.finishReason;
+        } else if (ev.kind === "meta") {
+          if (round === 1 || !ev.firstRoundOnly) {
+            yield ev.chunk;
+          }
+        }
+      }
+      if (usage.inputTokens !== void 0 || usage.outputTokens !== void 0 || usage.cachedTokens !== void 0) {
+        recordUsage(ctx, usage, round);
+      }
+      let resolvedText = assistantText;
+      let allCalls = calls;
+      if (ctx.textProtocol && assistantText.length > 0 && adapter.extractTextTriggers) {
+        const extracted = adapter.extractTextTriggers(assistantText);
+        resolvedText = extracted.clean;
+        allCalls = [...calls, ...extracted.calls];
+      }
+      if (ctx.textProtocol && resolvedText.length > 0) {
+        yield adapter.emitText(resolvedText);
+      } else if (!ctx.textProtocol && round > 1 && resolvedText.length > 0) {
+        yield adapter.emitText(resolvedText);
+      }
+      let realCalls = 0;
+      const realToolCalls = [];
+      const proxyResults = [];
+      for (const call of allCalls) {
+        if (PROXY_TOOL_NAMES.has(call.name)) {
+          let parsedArgs;
+          try {
+            parsedArgs = call.arguments.length > 0 ? JSON.parse(call.arguments) : {};
+          } catch {
+            parsedArgs = {};
+          }
+          const result = executeProxyTool4(call.name, parsedArgs, ctx, call.callId);
+          proxyResults.push({ name: call.name, callId: call.callId, result, arguments: call.arguments });
+          yield adapter.emitMarker(call.name, result);
+        } else {
+          realToolCalls.push(call);
+          realCalls += 1;
+        }
+      }
+      if (ctx.debug) {
+        const callSummary = allCalls.map((c) => {
+          const argSnippet = c.arguments.length > 200 ? c.arguments.slice(0, 200) + "..." : c.arguments;
+          return `${c.name}(${argSnippet})`;
+        }).join(" | ");
+        ctx.log(`[acp-loop] round ${round}: ${allCalls.length} call(s): ${callSummary || "(none)"}`);
+        for (const pr2 of proxyResults) {
+          const resSnippet = pr2.result.length > 300 ? pr2.result.slice(0, 300) + "..." : pr2.result;
+          ctx.log(`[acp-loop]   \u2192 ${pr2.name} result: ${resSnippet}`);
+        }
+        if (realCalls > 0) ctx.log(`[acp-loop] round ${round}: ${realCalls} real tool call(s) forwarded to client`);
+      }
+      if (proxyResults.length > 0) {
+        if (resolvedText.length > 0) {
+          coreMessages.push({
+            id: `acp_loop_r${round}_asst`,
+            role: "assistant",
+            contentType: "text",
+            text: resolvedText
+          });
+        }
+        for (const pr2 of proxyResults) {
+          if (ctx.textProtocol) {
+            coreMessages.push({
+              id: `acp_loop_r${round}_marker_${pr2.callId}`,
+              role: "user",
+              contentType: "text",
+              text: buildVisibilityMarker(pr2.name, pr2.result)
+            });
+          } else {
+            coreMessages.push({
+              id: `acp_loop_r${round}_asst_tc_${pr2.callId}`,
+              role: "assistant",
+              contentType: "tool-call",
+              toolName: pr2.name,
+              toolCallId: pr2.callId,
+              text: pr2.arguments
+            });
+            coreMessages.push({
+              id: `acp_loop_r${round}_tool_${pr2.callId}`,
+              role: "tool",
+              contentType: "tool-result",
+              toolCallId: pr2.callId,
+              text: pr2.result
+            });
+          }
+        }
+        if (!ctx.textProtocol) {
+          const hidden = hideConsumedCompressCalls(ctx.session.state, coreMessages);
+          if (hidden.hidden > 0) {
+            ctx.log(`[acp-loop] round ${round} hideConsumed hid ${hidden.hidden} compress record(s)`);
+            coreMessages.length = 0;
+            coreMessages.push(...hidden.messages);
+          }
+        }
+      }
+      for (const tc of realToolCalls) {
+        yield adapter.emitToolCall(tc);
+      }
+      const reRequest = proxyResults.length > 0 && realCalls === 0;
+      if (!reRequest) {
+        yield adapter.emitCompletion({ finishReason, usage });
+        return;
+      }
+      if (round >= MAX_LOOP_ROUNDS) {
+        ctx.log(`[acp-loop] round ${round} hit MAX_LOOP_ROUNDS; completing gracefully`);
+        log("warn", `[acp-loop] loop limit (${MAX_LOOP_ROUNDS}) reached; completing gracefully`);
+        yield adapter.emitCompletion({ finishReason: "length", usage });
+        return;
+      }
+      ctx.log(`[acp-loop] round ${round} saw mutating proxy tool; re-requesting`);
+      const newBody = adapter.buildRequest(coreMessages, systemPrompt, requestBody);
+      if (process.env.ACP_DUMP_REQ !== "0" && ctx.debug) {
+        try {
+          const fs5 = await import("fs");
+          const dumpDir = process.env.ACP_DUMP_DIR || `${process.env.HOME}/.local/state/billion-context/dumps`;
+          fs5.mkdirSync(dumpDir, { recursive: true });
+          const sid = ctx.session.id ?? "unknown";
+          fs5.writeFileSync(`${dumpDir}/req-${Date.now()}-${sid}-REREQUEST.json`, JSON.stringify(newBody, null, 2));
+        } catch {
+        }
+      }
+      const { response: resp, clearTimer } = await fetchWithTimeout(requestOptions.url, {
+        method: "POST",
+        headers: requestOptions.headers,
+        body: JSON.stringify(newBody),
+        ...ctx.proxyUrl ? { dispatcher: proxyDispatcher(ctx.proxyUrl) } : {}
+      });
+      if (!resp.ok || !resp.body) {
+        clearTimer();
+        const errText = await resp.text().catch(() => "upstream error");
+        ctx.log(`[acp-proxy: compress loop upstream error ${resp.status}: ${errText.slice(0, 200)}]`);
+        log("error", `[acp-loop] upstream error ${resp.status}: ${errText.slice(0, 200)}`);
+        yield adapter.emitError(`upstream error ${resp.status}: ${errText.slice(0, 200)}`);
+        return;
+      }
+      currentUpstream = resp.body;
+      if (activeClearTimer) activeClearTimer();
+      activeClearTimer = clearTimer;
+    }
+  } finally {
+    if (activeClearTimer) {
+      activeClearTimer();
+      activeClearTimer = null;
+    }
+  }
+}
+
+// src/loop/adapter-responses.ts
+async function* iterSseEvents(stream2) {
+  const reader = stream2.getReader();
+  let buf = "";
+  try {
+    while (true) {
+      let done;
+      let value;
+      try {
+        ({ done, value } = await reader.read());
+      } catch {
+        break;
+      }
+      if (done) break;
+      buf += new TextDecoder().decode(value, { stream: true });
+      buf = buf.replace(/\r\n|\r/g, "\n");
+      let idx;
+      while ((idx = buf.indexOf("\n\n")) >= 0) {
+        const raw = buf.slice(0, idx);
+        buf = buf.slice(idx + 2);
+        if (raw.trim().length > 0) yield raw;
+      }
+    }
+    if (buf.trim().length > 0) yield buf;
+  } finally {
+    reader.releaseLock();
+  }
+}
+function extractEventType2(rawEvent) {
+  for (const l of rawEvent.split("\n")) {
+    if (l.startsWith("event:")) return l.slice(6).trim();
+  }
+  return null;
+}
+function extractDataLine2(rawEvent) {
+  const parts = [];
+  for (const l of rawEvent.split("\n")) {
+    if (l.startsWith("data:")) {
+      let v2 = l.slice(5);
+      if (v2.startsWith(" ")) v2 = v2.slice(1);
+      parts.push(v2);
+    }
+  }
+  return parts.length ? parts.join("\n") : null;
+}
+function buildMessageItemSequence2(itemId, outputIndex, text) {
+  const item = { type: "message", id: itemId, role: "assistant", content: [] };
+  const part = { type: "output_text", text: "" };
+  const doneItem = {
+    type: "message",
+    id: itemId,
+    role: "assistant",
+    content: [{ type: "output_text", text }]
+  };
+  return Buffer.from(
+    [
+      `event: response.output_item.added
+data: ${JSON.stringify({ type: "response.output_item.added", output_index: outputIndex, item })}
+
+`,
+      `event: response.content_part.added
+data: ${JSON.stringify({ type: "response.content_part.added", item_id: itemId, output_index: outputIndex, part })}
+
+`,
+      `event: response.output_text.delta
+data: ${JSON.stringify({ type: "response.output_text.delta", item_id: itemId, output_index: outputIndex, delta: text })}
+
+`,
+      `event: response.output_text.done
+data: ${JSON.stringify({ type: "response.output_text.done", item_id: itemId, output_index: outputIndex, text })}
+
+`,
+      `event: response.content_part.done
+data: ${JSON.stringify({ type: "response.content_part.done", item_id: itemId, output_index: outputIndex, part: { type: "output_text", text } })}
+
+`,
+      `event: response.output_item.done
+data: ${JSON.stringify({ type: "response.output_item.done", output_index: outputIndex, item: doneItem })}
+
+`
+    ].join(""),
+    "utf8"
+  );
+}
+function buildFunctionCallEvents2(fc, itemId, outputIndex) {
+  return Buffer.from(
+    [
+      `event: response.output_item.added
+data: ${JSON.stringify({
+        type: "response.output_item.added",
+        output_index: outputIndex,
+        item: { type: "function_call", id: itemId, call_id: fc.callId, name: fc.name, arguments: "" }
+      })}
+
+`,
+      `event: response.function_call_arguments.delta
+data: ${JSON.stringify({
+        type: "response.function_call_arguments.delta",
+        item_id: itemId,
+        delta: fc.arguments
+      })}
+
+`,
+      `event: response.function_call_arguments.done
+data: ${JSON.stringify({
+        type: "response.function_call_arguments.done",
+        item_id: itemId,
+        arguments: fc.arguments
+      })}
+
+`,
+      `event: response.output_item.done
+data: ${JSON.stringify({
+        type: "response.output_item.done",
+        output_index: outputIndex,
+        item: { type: "function_call", id: itemId, call_id: fc.callId, name: fc.name, arguments: fc.arguments }
+      })}
+
+`
+    ].join(""),
+    "utf8"
+  );
+}
+function buildCompleted2(responseObj) {
+  const resp = responseObj ?? { id: `resp-proxy-${Date.now()}`, status: "completed", output: [] };
+  return Buffer.from(
+    `event: response.completed
+data: ${JSON.stringify({ type: "response.completed", response: resp })}
+
+`,
+    "utf8"
+  );
+}
+function createResponsesAdapter(textProtocol, projection) {
+  const suppressTextLifecycle = !!textProtocol;
+  let outputIndex = 0;
+  let responseObj = null;
+  let terminalRaw = null;
+  let terminalKind = null;
+  return {
+    buildRequest(coreMessages, systemPrompt, requestBody) {
+      const customToolCallIds = /* @__PURE__ */ new Set();
+      for (const m2 of coreMessages) {
+        const bm = m2;
+        const raw = bm?.rawResponsesItem;
+        if (raw && (raw.type === "custom_tool_call" || raw.type === "custom_tool_call_output")) {
+          const id = typeof raw.call_id === "string" ? raw.call_id : typeof raw.id === "string" ? raw.id : "";
+          if (id) customToolCallIds.add(id);
+        }
+      }
+      let inputItems;
+      if (projection) {
+        const rebuiltInput = patchResponsesInput(projection, coreMessages);
+        inputItems = typeof rebuiltInput === "string" ? [{ type: "message", role: "user", content: rebuiltInput }] : rebuiltInput;
+      } else {
+        inputItems = coreToResponses(coreMessages, customToolCallIds);
+      }
+      const devParts = projection && projection.systemParts.length > 0 ? [...projection.systemParts, systemPrompt] : [systemPrompt];
+      const withDev = injectResponsesDeveloperMessage(inputItems, devParts.join("\n\n---\n\n"));
+      const rebuilt = { ...requestBody, input: withDev };
+      delete rebuilt.previous_response_id;
+      delete rebuilt.instructions;
+      return rebuilt;
+    },
+    async *parseStream(upstream, round) {
+      const pending = /* @__PURE__ */ new Map();
+      for await (const eventStr of iterSseEvents(upstream)) {
+        const type = extractEventType2(eventStr);
+        const dataLine = extractDataLine2(eventStr);
+        if (!type || !dataLine) continue;
+        let obj;
+        try {
+          obj = JSON.parse(dataLine);
+        } catch {
+          continue;
+        }
+        const rawBuf = Buffer.from(eventStr + "\n\n", "utf8");
+        if (round === 1 && typeof obj.output_index === "number") {
+          outputIndex = Math.max(outputIndex, obj.output_index + 1);
+        }
+        if (type === "response.created" || type === "response.in_progress") {
+          yield { kind: "meta", chunk: rawBuf, firstRoundOnly: true };
+        } else if (type === "response.output_item.added") {
+          const item = obj.item;
+          if (item?.type === "function_call") {
+            const itemId = typeof item.id === "string" ? item.id : "";
+            pending.set(itemId, {
+              itemId,
+              callId: typeof item.call_id === "string" ? item.call_id : "",
+              name: typeof item.name === "string" ? item.name : "",
+              arguments: ""
+            });
+          } else if (item?.type === "custom_tool_call") {
+            yield { kind: "meta", chunk: rawBuf, firstRoundOnly: false };
+          } else if (!suppressTextLifecycle) {
+            yield { kind: "meta", chunk: rawBuf, firstRoundOnly: true };
+          }
+        } else if (type === "response.content_part.added" || type === "response.content_part.done" || type === "response.output_text.done") {
+          if (!suppressTextLifecycle) {
+            yield { kind: "meta", chunk: rawBuf, firstRoundOnly: true };
+          }
+        } else if (type === "response.output_text.delta") {
+          const delta = typeof obj.delta === "string" ? obj.delta : "";
+          if (delta.length > 0) {
+            yield { kind: "text", delta, raw: rawBuf };
+          }
+        } else if (type === "response.function_call_arguments.delta") {
+          const itemId = typeof obj.item_id === "string" ? obj.item_id : "";
+          const delta = typeof obj.delta === "string" ? obj.delta : "";
+          const fc = pending.get(itemId);
+          if (fc) fc.arguments += delta;
+        } else if (type === "response.function_call_arguments.done") {
+          const itemId = typeof obj.item_id === "string" ? obj.item_id : "";
+          const args = typeof obj.arguments === "string" ? obj.arguments : "";
+          const fc = pending.get(itemId);
+          if (fc && args) fc.arguments = args;
+        } else if (type === "response.output_item.done") {
+          const item = obj.item;
+          if (item?.type === "function_call") {
+            const itemId = typeof item.id === "string" ? item.id : "";
+            const fc = pending.get(itemId);
+            if (fc) {
+              if (typeof item.arguments === "string" && item.arguments) fc.arguments = item.arguments;
+              pending.delete(itemId);
+              yield {
+                kind: "tool_call",
+                name: fc.name,
+                callId: fc.callId,
+                arguments: fc.arguments
+              };
+            }
+          } else if (item?.type === "custom_tool_call") {
+            yield { kind: "meta", chunk: rawBuf, firstRoundOnly: false };
+          } else if (!suppressTextLifecycle) {
+            yield { kind: "meta", chunk: rawBuf, firstRoundOnly: true };
+          }
+        } else if (type === "response.completed") {
+          responseObj = obj.response ?? null;
+          terminalKind = "completed";
+          terminalRaw = null;
+          const respUsage = responseObj?.usage;
+          const pd = respUsage?.input_tokens_details;
+          yield {
+            kind: "usage",
+            inputTokens: typeof respUsage?.input_tokens === "number" ? respUsage.input_tokens : void 0,
+            outputTokens: typeof respUsage?.output_tokens === "number" ? respUsage.output_tokens : void 0,
+            cachedTokens: typeof pd?.cached_tokens === "number" ? pd.cached_tokens : void 0
+          };
+          yield { kind: "done", finishReason: "completed" };
+        } else if (type === "response.incomplete") {
+          terminalKind = "incomplete";
+          terminalRaw = rawBuf;
+          yield { kind: "done", finishReason: "incomplete" };
+        } else if (type === "response.failed" || type === "response.error") {
+          terminalKind = "failed";
+          terminalRaw = rawBuf;
+          yield { kind: "done", finishReason: "failed" };
+        } else {
+          yield { kind: "meta", chunk: rawBuf, firstRoundOnly: true };
+        }
+      }
+      if (!terminalKind) {
+        yield { kind: "done", finishReason: "failed" };
+      }
+    },
+    emitText(delta) {
+      return buildMessageItemSequence2(`msg-proxy-${Date.now()}-${outputIndex}`, outputIndex++, delta);
+    },
+    emitToolCall(call) {
+      const buf = buildFunctionCallEvents2(call, `fc-proxy-${Date.now()}-${outputIndex}`, outputIndex);
+      outputIndex += 1;
+      return buf;
+    },
+    emitMarker(toolName, result) {
+      return buildMessageItemSequence2(
+        `marker-${Date.now()}-${outputIndex}`,
+        outputIndex++,
+        buildVisibilityMarker(toolName, result)
+      );
+    },
+    emitCompletion(opts) {
+      if (terminalRaw && (terminalKind === "failed" || terminalKind === "incomplete")) {
+        return terminalRaw;
+      }
+      if (!responseObj && opts?.finishReason === "failed") {
+        const failed = {
+          id: `resp-error-${Date.now()}`,
+          status: "failed",
+          error: { code: "server_error", message: "upstream returned no response" }
+        };
+        return Buffer.from(
+          `event: response.failed
+data: ${JSON.stringify({ type: "response.failed", response: failed })}
+
+`,
+          "utf8"
+        );
+      }
+      let resp = responseObj ? { ...responseObj } : { id: `resp-proxy-${Date.now()}`, status: "completed", output: [] };
+      if (opts?.usage) {
+        const usage = {
+          ...typeof resp.usage === "object" ? resp.usage : {}
+        };
+        if (typeof opts.usage.inputTokens === "number") usage.input_tokens = opts.usage.inputTokens;
+        if (typeof opts.usage.outputTokens === "number") usage.output_tokens = opts.usage.outputTokens;
+        if (typeof opts.usage.cachedTokens === "number") {
+          usage.input_tokens_details = {
+            ...usage.input_tokens_details ?? {},
+            cached_tokens: opts.usage.cachedTokens
+          };
+        }
+        resp = { ...resp, usage };
+      }
+      return buildCompleted2(resp);
+    },
+    emitError(message) {
+      const resp = {
+        id: `resp-error-${Date.now()}`,
+        status: "failed",
+        error: { code: "server_error", message }
+      };
+      return Buffer.from(
+        `event: response.failed
+data: ${JSON.stringify({ type: "response.failed", response: resp })}
+
+`,
+        "utf8"
+      );
+    },
+    extractTextTriggers(text) {
+      const calls = [];
+      let clean = text;
+      let hadTrigger = false;
+      const triggers = [
+        { name: "compress", open: ACP_TEXT_OPEN, close: ACP_TEXT_CLOSE, requirePayload: true },
+        { name: "acp_status", open: ACP_STATUS_OPEN, close: ACP_STATUS_CLOSE, requirePayload: false },
+        { name: "search_context", open: ACP_SEARCH_OPEN, close: ACP_SEARCH_CLOSE, requirePayload: true },
+        { name: "decompress", open: ACP_DECOMPRESS_OPEN, close: ACP_DECOMPRESS_CLOSE, requirePayload: true }
+      ];
+      for (const t of triggers) {
+        let start = clean.indexOf(t.open);
+        while (start >= 0) {
+          const end = clean.indexOf(t.close, start + t.open.length);
+          if (end < 0) break;
+          hadTrigger = true;
+          const payload = clean.slice(start + t.open.length, end).trim();
+          if (payload.length > 0 || !t.requirePayload) {
+            const stamp = `${Date.now()}-${calls.length}`;
+            calls.push({
+              name: t.name,
+              callId: `call_text_${stamp}`,
+              arguments: payload.length > 0 ? payload : "{}"
+            });
+          }
+          clean = clean.slice(0, start) + clean.slice(end + t.close.length);
+          start = clean.indexOf(t.open);
+        }
+      }
+      return { clean: hadTrigger ? clean : text, calls };
+    }
+  };
+}
+
+// src/loop/adapter-openai.ts
+async function* iterSseChunks(stream2) {
+  const reader = stream2.getReader();
+  let buf = "";
+  try {
+    while (true) {
+      let done;
+      let value;
+      try {
+        ({ done, value } = await reader.read());
+      } catch {
+        break;
+      }
+      if (done) break;
+      buf += new TextDecoder().decode(value, { stream: true });
+      buf = buf.replace(/\r\n|\r/g, "\n");
+      let idx;
+      while ((idx = buf.indexOf("\n\n")) >= 0) {
+        const raw = buf.slice(0, idx);
+        buf = buf.slice(idx + 2);
+        if (raw.trim().length > 0) yield raw;
+      }
+    }
+    if (buf.trim().length > 0) yield buf;
+  } finally {
+    reader.releaseLock();
+  }
+}
+function createOpenaiAdapter(requestBody) {
+  const model = requestBody.model ?? "unknown";
+  let responseId = `chatcmpl-proxy-${Date.now()}`;
+  let toolIndex = 0;
+  const makeBase = () => ({
+    id: responseId,
+    object: "chat.completion.chunk",
+    created: Date.now(),
+    model
+  });
+  const buildContent = (content) => Buffer.from(
+    `data: ${JSON.stringify({
+      id: responseId,
+      object: "chat.completion.chunk",
+      created: Date.now(),
+      model,
+      choices: [{ index: 0, delta: { content }, finish_reason: null }]
+    })}
+
+`,
+    "utf8"
+  );
+  const buildToolCall = (call) => {
+    const idx = toolIndex++;
+    return Buffer.from(
+      `data: ${JSON.stringify({
+        ...makeBase(),
+        choices: [{
+          index: 0,
+          delta: {
+            tool_calls: [{
+              index: idx,
+              id: call.callId,
+              type: "function",
+              function: { name: call.name, arguments: call.arguments }
+            }]
+          },
+          finish_reason: null
+        }]
+      })}
+
+`,
+      "utf8"
+    );
+  };
+  const buildFinish = (finishReason, usage) => Buffer.from(
+    `data: ${JSON.stringify({
+      ...makeBase(),
+      choices: [{ index: 0, delta: {}, finish_reason: finishReason }],
+      ...usage ? { usage } : {}
+    })}
+
+`,
+    "utf8"
+  );
+  return {
+    buildRequest(coreMessages, systemPrompt, body) {
+      const messages = coreToOpenai(coreMessages);
+      const withSys = injectOpenaiSystem(messages, [systemPrompt]);
+      return { ...body, messages: withSys };
+    },
+    async *parseStream(upstream, _round) {
+      const pending = /* @__PURE__ */ new Map();
+      for await (const eventStr of iterSseChunks(upstream)) {
+        const dataLine = eventStr.split("\n").find((l) => l.startsWith("data:"));
+        if (!dataLine) continue;
+        const jsonStr = dataLine.slice(5).trim();
+        if (jsonStr === "[DONE]") {
+          for (const [, tc] of pending) {
+            if (tc.name.length > 0 || tc.id.length > 0) {
+              yield {
+                kind: "tool_call",
+                name: tc.name,
+                callId: tc.id,
+                arguments: tc.arguments
+              };
+            }
+          }
+          pending.clear();
+          yield { kind: "done", finishReason: "stop" };
+          continue;
+        }
+        let parsed;
+        try {
+          parsed = JSON.parse(jsonStr);
+        } catch {
+          continue;
+        }
+        const rawBuf = Buffer.from(eventStr + "\n\n", "utf8");
+        const choices = parsed.choices;
+        const choice = choices?.[0];
+        if (!choice) {
+          if (parsed.usage) {
+            const u2 = parsed.usage;
+            const pd = u2.prompt_tokens_details;
+            yield {
+              kind: "usage",
+              inputTokens: typeof u2.prompt_tokens === "number" ? u2.prompt_tokens : void 0,
+              outputTokens: typeof u2.completion_tokens === "number" ? u2.completion_tokens : void 0,
+              cachedTokens: typeof pd?.cached_tokens === "number" ? pd.cached_tokens : void 0
+            };
+          }
+          continue;
+        }
+        const delta = choice.delta;
+        const finishReason = typeof choice.finish_reason === "string" ? choice.finish_reason : void 0;
+        if (finishReason) {
+          for (const [, tc] of pending) {
+            if (tc.name.length > 0 || tc.id.length > 0) {
+              yield {
+                kind: "tool_call",
+                name: tc.name,
+                callId: tc.id,
+                arguments: tc.arguments
+              };
+            }
+          }
+          pending.clear();
+          const u2 = parsed.usage;
+          const pd = u2?.prompt_tokens_details;
+          yield {
+            kind: "usage",
+            inputTokens: typeof u2?.prompt_tokens === "number" ? u2.prompt_tokens : void 0,
+            outputTokens: typeof u2?.completion_tokens === "number" ? u2.completion_tokens : void 0,
+            cachedTokens: typeof pd?.cached_tokens === "number" ? pd.cached_tokens : void 0
+          };
+          yield { kind: "done", finishReason };
+        }
+        if (!delta) continue;
+        if (delta.tool_calls) {
+          const tcs = delta.tool_calls;
+          for (const tc of tcs) {
+            const idx = typeof tc.index === "number" ? tc.index : 0;
+            const fn = tc.function;
+            const name = typeof fn?.name === "string" ? fn.name : "";
+            const id = typeof tc.id === "string" ? tc.id : "";
+            const args = typeof fn?.arguments === "string" ? fn.arguments : "";
+            let buf = pending.get(idx);
+            if (!buf) {
+              buf = { index: idx, id, name, arguments: args };
+              pending.set(idx, buf);
+            } else {
+              if (id) buf.id = id;
+              if (name) buf.name = name;
+              buf.arguments += args;
+            }
+          }
+          if (typeof delta.content === "string" && delta.content.length > 0) {
+            yield { kind: "text", delta: delta.content };
+          }
+          continue;
+        }
+        if (typeof delta.content === "string" && delta.content.length > 0) {
+          yield { kind: "text", delta: delta.content, raw: rawBuf };
+        } else if (delta.role || Object.keys(delta).length === 0 && !finishReason) {
+          yield { kind: "meta", chunk: rawBuf, firstRoundOnly: true };
+        }
+      }
+    },
+    emitText(delta) {
+      return buildContent(delta);
+    },
+    emitToolCall(call) {
+      return buildToolCall(call);
+    },
+    emitMarker(toolName, result) {
+      return buildContent(buildVisibilityMarker(toolName, result));
+    },
+    emitCompletion(opts) {
+      const finishReason = opts?.finishReason ?? "stop";
+      const usage = opts?.usage ? {
+        prompt_tokens: opts.usage.inputTokens,
+        completion_tokens: opts.usage.outputTokens,
+        ...typeof opts.usage.cachedTokens === "number" ? { prompt_tokens_details: { cached_tokens: opts.usage.cachedTokens } } : {}
+      } : null;
+      return Buffer.concat([buildFinish(finishReason, usage), Buffer.from("data: [DONE]\n\n", "utf8")]);
+    },
+    emitError(message) {
+      return Buffer.concat([
+        buildContent(`
+[acp-proxy: ${message}]
+`),
+        buildFinish("stop", null),
+        Buffer.from("data: [DONE]\n\n", "utf8")
+      ]);
+    }
+  };
+}
+
+// src/loop/adapter-anthropic.ts
+async function* iterSseEvents2(stream2) {
+  const reader = stream2.getReader();
+  let buf = "";
+  try {
+    while (true) {
+      let done;
+      let value;
+      try {
+        ({ done, value } = await reader.read());
+      } catch {
+        break;
+      }
+      if (done) break;
+      buf += new TextDecoder().decode(value, { stream: true });
+      buf = buf.replace(/\r\n|\r/g, "\n");
+      let idx;
+      while ((idx = buf.indexOf("\n\n")) >= 0) {
+        const raw = buf.slice(0, idx);
+        buf = buf.slice(idx + 2);
+        if (raw.trim().length > 0) yield raw;
+      }
+    }
+    if (buf.trim().length > 0) yield buf;
+  } finally {
+    reader.releaseLock();
+  }
+}
+function parseAnthropicSse2(eventStr) {
+  const lines = eventStr.split("\n");
+  let type = "";
+  const dataLines = [];
+  for (const l of lines) {
+    if (l.startsWith("event:")) type = l.slice(6).trim();
+    else if (l.startsWith("data:")) dataLines.push(l.slice(5).replace(/^ /, ""));
+  }
+  if (!type) return null;
+  const jsonStr = dataLines.join("\n").trim();
+  if (!jsonStr) return { type, data: {} };
+  try {
+    return { type, data: JSON.parse(jsonStr) };
+  } catch {
+    return { type, data: {} };
+  }
+}
+function remapIndexInEvent(eventStr, newIndex) {
+  const lines = eventStr.split("\n");
+  const rebuilt = [];
+  let touched = false;
+  for (const l of lines) {
+    if (!touched && l.startsWith("data:")) {
+      const jsonStr = l.slice(5).replace(/^ /, "");
+      try {
+        const obj = JSON.parse(jsonStr);
+        if (typeof obj === "object" && obj !== null && typeof obj.index === "number") {
+          obj.index = newIndex;
+          rebuilt.push(`data: ${JSON.stringify(obj)}`);
+          touched = true;
+          continue;
+        }
+      } catch {
+      }
+    }
+    rebuilt.push(l);
+  }
+  return Buffer.from(rebuilt.join("\n") + "\n\n", "utf8");
+}
+function createAnthropicAdapter(requestBody, originalSystem) {
+  const model = requestBody.model ?? void 0;
+  let messageId;
+  let clientIndex = 0;
+  const buildTextBlock = (index, text) => Buffer.from(
+    `event: content_block_start
+data: ${JSON.stringify({ type: "content_block_start", index, content_block: { type: "text", text: "" } })}
+
+event: content_block_delta
+data: ${JSON.stringify({ type: "content_block_delta", index, delta: { type: "text_delta", text } })}
+
+event: content_block_stop
+data: ${JSON.stringify({ type: "content_block_stop", index })}
+
+`,
+    "utf8"
+  );
+  const buildToolUseBlock = (index, call) => Buffer.from(
+    `event: content_block_start
+data: ${JSON.stringify({ type: "content_block_start", index, content_block: { type: "tool_use", id: call.callId, name: call.name, input: {} } })}
+
+event: content_block_delta
+data: ${JSON.stringify({ type: "content_block_delta", index, delta: { type: "input_json_delta", partial_json: call.arguments } })}
+
+event: content_block_stop
+data: ${JSON.stringify({ type: "content_block_stop", index })}
+
+`,
+    "utf8"
+  );
+  const buildTerminal = (stopReason, outputTokens, inputTokens, cachedTokens) => {
+    const usage = {
+      input_tokens: inputTokens,
+      output_tokens: outputTokens,
+      cache_read_input_tokens: cachedTokens
+    };
+    const extra = {};
+    if (messageId) extra.id = messageId;
+    if (model) extra.model = model;
+    return Buffer.from(
+      `event: message_delta
+data: ${JSON.stringify({ type: "message_delta", delta: { stop_reason: stopReason, stop_sequence: null }, usage, ...extra })}
+
+event: message_stop
+data: ${JSON.stringify({ type: "message_stop" })}
+
+`,
+      "utf8"
+    );
+  };
+  return {
+    buildRequest(coreMessages, systemPrompt, body) {
+      const messages = coreToAnthropic(coreMessages);
+      const baseText = originalSystem !== void 0 ? extractSystem(originalSystem) : "";
+      const full = baseText ? `${baseText}
+
+---
+
+${systemPrompt}` : systemPrompt;
+      const system = originalSystem !== void 0 ? buildSystem(full, originalSystem) : full;
+      return { ...body, system, messages };
+    },
+    async *parseStream(upstream, round) {
+      const pending = /* @__PURE__ */ new Map();
+      let roundInput;
+      let roundCached;
+      let roundOutput;
+      let stopReason;
+      let usageYielded = false;
+      const indexMap = /* @__PURE__ */ new Map();
+      for await (const eventStr of iterSseEvents2(upstream)) {
+        const parsed = parseAnthropicSse2(eventStr);
+        if (!parsed) continue;
+        const { type, data } = parsed;
+        const rawBuf = Buffer.from(eventStr + "\n\n", "utf8");
+        if (type === "message_start") {
+          const msg2 = data.message ?? {};
+          if (typeof msg2.id === "string" && !messageId) messageId = msg2.id;
+          const u2 = msg2.usage ?? {};
+          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) {
+            yield { kind: "meta", chunk: rawBuf, firstRoundOnly: true };
+          }
+        } else if (type === "ping") {
+          yield { kind: "meta", chunk: rawBuf };
+        } else if (type === "content_block_start") {
+          const upstreamIndex = data.index ?? 0;
+          const block = data.content_block ?? {};
+          if (block.type === "tool_use") {
+            const name = typeof block.name === "string" ? block.name : "";
+            const id = typeof block.id === "string" ? block.id : `toolu_${upstreamIndex}`;
+            pending.set(upstreamIndex, { id, name, json: "" });
+          } else if (round === 1) {
+            const ci2 = clientIndex++;
+            indexMap.set(upstreamIndex, ci2);
+            yield { kind: "meta", chunk: remapIndexInEvent(eventStr, ci2), firstRoundOnly: true };
+          }
+        } else if (type === "content_block_delta") {
+          const upstreamIndex = data.index ?? 0;
+          const delta = data.delta ?? {};
+          if (pending.has(upstreamIndex)) {
+            if (delta.type === "input_json_delta" && typeof delta.partial_json === "string") {
+              pending.get(upstreamIndex).json += delta.partial_json;
+            }
+          } else if (delta.type === "text_delta" && typeof delta.text === "string") {
+            if (round === 1) {
+              const ci2 = indexMap.get(upstreamIndex) ?? upstreamIndex;
+              yield { kind: "text", delta: delta.text, raw: remapIndexInEvent(eventStr, ci2) };
+            } else {
+              yield { kind: "text", delta: delta.text };
+            }
+          } else if (round === 1) {
+            const ci2 = indexMap.get(upstreamIndex) ?? upstreamIndex;
+            yield { kind: "meta", chunk: remapIndexInEvent(eventStr, ci2), firstRoundOnly: true };
+          }
+        } else if (type === "content_block_stop") {
+          const upstreamIndex = data.index ?? 0;
+          const tb = pending.get(upstreamIndex);
+          if (tb) {
+            pending.delete(upstreamIndex);
+            yield {
+              kind: "tool_call",
+              name: tb.name,
+              callId: tb.id,
+              arguments: tb.json
+            };
+          } else if (round === 1) {
+            const ci2 = indexMap.get(upstreamIndex) ?? upstreamIndex;
+            yield { kind: "meta", chunk: remapIndexInEvent(eventStr, ci2), firstRoundOnly: true };
+          }
+        } else if (type === "message_delta") {
+          const u2 = data.usage ?? {};
+          if (typeof u2.output_tokens === "number") roundOutput = u2.output_tokens;
+          if (typeof u2.input_tokens === "number") roundInput = u2.input_tokens;
+          if (typeof u2.cache_read_input_tokens === "number") roundCached = u2.cache_read_input_tokens;
+          const d = data.delta ?? {};
+          if (typeof d.stop_reason === "string") stopReason = d.stop_reason;
+          if (!usageYielded) {
+            usageYielded = true;
+            yield {
+              kind: "usage",
+              inputTokens: roundInput,
+              outputTokens: roundOutput,
+              cachedTokens: roundCached
+            };
+          }
+          yield { kind: "done", finishReason: stopReason };
+        } else if (type === "message_stop") {
+          if (!usageYielded) {
+            usageYielded = true;
+            yield {
+              kind: "usage",
+              inputTokens: roundInput,
+              outputTokens: roundOutput,
+              cachedTokens: roundCached
+            };
+          }
+          yield { kind: "done", finishReason: stopReason ?? "end_turn" };
+        } else if (round === 1) {
+          yield { kind: "meta", chunk: rawBuf, firstRoundOnly: true };
+        }
+      }
+    },
+    emitText(delta) {
+      return buildTextBlock(clientIndex++, delta);
+    },
+    emitToolCall(call) {
+      return buildToolUseBlock(clientIndex++, call);
+    },
+    emitMarker(toolName, result) {
+      return buildTextBlock(clientIndex++, buildVisibilityMarker(toolName, result));
+    },
+    emitCompletion(opts) {
+      const stopReason = opts?.finishReason ?? "end_turn";
+      return buildTerminal(
+        stopReason,
+        opts?.usage?.outputTokens ?? 0,
+        opts?.usage?.inputTokens ?? 0,
+        opts?.usage?.cachedTokens ?? 0
+      );
+    },
+    emitError(message) {
+      const errBlock = buildTextBlock(clientIndex++, `
+[acp-proxy: ${message}]
+`);
+      return Buffer.concat([errBlock, buildTerminal("end_turn", 0, 0, 0)]);
+    }
+  };
+}
+
+// src/loop/index.ts
+function pickAdapter(protocol, requestBody, textProtocol, responsesProjection, anthropicSystem) {
+  if (protocol === "responses") return createResponsesAdapter(textProtocol, responsesProjection);
+  if (protocol === "openai") return createOpenaiAdapter(requestBody);
+  if (protocol === "anthropic") return createAnthropicAdapter(requestBody, anthropicSystem);
+  throw new Error(`[acp-loop] unknown protocol: ${protocol}`);
+}
+
 // src/stream-openai.ts
 function rewriteOpenaiJsonResponse(body, ctx) {
   if (!body || typeof body !== "object") return body;
@@ -49668,7 +50856,7 @@ function extractKey(headers) {
   return "(no-key)";
 }
 function clientConversationHeader(headers) {
-  const names = ["x-session-affinity", "x-acp-session", "x-session-id", "x-opencode-session", "session-id", "session_id"];
+  const names = ["x-claude-code-session-id", "x-session-affinity", "x-acp-session", "x-session-id", "x-opencode-session", "session-id", "session_id"];
   for (const name of names) {
     const v2 = headers[name];
     if (typeof v2 === "string" && v2.trim().length > 0) return v2.trim();
@@ -50985,7 +52173,7 @@ function prepareAnthropic(parsed, req, opts, core, config, log2, session) {
   }
   const rebuilt = { ...parsed, messages: rebuiltMessages, system: systemOut, tools: toolsOut };
   markDirty(session);
-  return { body: JSON.stringify(rebuilt), session, processedMessages, originalMessages, protocol: "anthropic", stream: stream2, compressInjected: opts.compress.injectTool };
+  return { body: JSON.stringify(rebuilt), session, processedMessages, originalMessages, anthropicSystem: parsed.system, protocol: "anthropic", stream: stream2, compressInjected: opts.compress.injectTool };
 }
 function prepareOpenai(parsed, req, opts, core, config, log2, session) {
   const sessionId = session.id;
@@ -51049,12 +52237,14 @@ function prepareResponses(parsed, req, opts, core, config, log2, session, identi
   }
   let processedMessages = [];
   let originalMessages = [];
+  let responsesProjection;
   let rebuiltInput = parsed.input;
   let toolsOut = parsed.tools;
   const shouldInject = opts.compress.injectTool;
   const responsesTextProtocol = FORCE_TEXT_PROTOCOL || isChatGptCodexUpstream(session.meta.upstreamOrigin) || isCodexResponsesLite(req.headers, parsed);
   try {
     const projection = responsesToCore(parsed);
+    responsesProjection = projection;
     const { msgs } = projection;
     originalMessages = msgs;
     if (process.env.ACP_DEBUG) {
@@ -51120,6 +52310,7 @@ function prepareResponses(parsed, req, opts, core, config, log2, session, identi
     session,
     processedMessages,
     originalMessages,
+    responsesProjection,
     protocol: "responses",
     stream: stream2,
     compressInjected: shouldInject,
@@ -51258,9 +52449,20 @@ async function forward(req, res, opts, body, prepared, core, config, log2, route
         return fn?.name ?? t.name ?? "?";
       });
       log2("info", `[debug] tools=[${toolNames.join(",")}] msgs=${parsed.messages?.length ?? 0} stream=${parsed.stream ?? false} system_len=${JSON.stringify(parsed.messages?.find((m2) => m2.role === "system")?.content ?? "").length}`);
-      if (process.env.ACP_DUMP_REQ === "1") {
-        const out = `${tmpdir2()}/acp-proxy-debug-req-${Date.now()}.json`;
-        fs3.writeFileSync(out, body.slice(0, 5e4));
+      if (process.env.ACP_DUMP_REQ !== "0") {
+        const dumpDir = process.env.ACP_DUMP_DIR || `${stateDir()}/dumps`;
+        try {
+          fs3.mkdirSync(dumpDir, { recursive: true });
+        } catch {
+        }
+        const sid = prepared?.session.id ?? "unknown";
+        const out = `${dumpDir}/req-${Date.now()}-${sid}.json`;
+        try {
+          const pretty = JSON.stringify(JSON.parse(body), null, 2);
+          fs3.writeFileSync(out, pretty);
+        } catch {
+          fs3.writeFileSync(out, body);
+        }
         log2("info", `[debug] forwarded body written to ${out}`);
       }
     } catch {
@@ -51276,6 +52478,13 @@ async function forward(req, res, opts, body, prepared, core, config, log2, route
     headers["x-session-id"] = affinity;
   }
   const proxyUrl = resolveProxy(opts.routes, opts.proxy, route?.rewrittenUrl ?? upstreamUrl, opts.proxyFallback);
+  if (opts.debug) {
+    const hdrLog = {};
+    for (const [hk, hv] of Object.entries(headers)) {
+      if (typeof hv === "string") hdrLog[hk] = hv.length > 200 ? hv.slice(0, 200) + "..." : hv;
+    }
+    log2("info", `[${prepared?.session.id ?? "unknown"}] \u2192 upstream headers: ${JSON.stringify(hdrLog)}`);
+  }
   const dispatcher = proxyDispatcher(proxyUrl);
   const init = {
     method: req.method ?? "GET",
@@ -51297,6 +52506,14 @@ async function forward(req, res, opts, body, prepared, core, config, log2, route
     if (UPSTREAM_HOP_HEADERS.has(k2.toLowerCase())) return;
     respHeaders[k2] = v2;
   });
+  if (opts.debug) {
+    const respLog = {};
+    upstream.headers.forEach((v2, k2) => {
+      if (UPSTREAM_HOP_HEADERS.has(k2.toLowerCase())) return;
+      respLog[k2] = v2.length > 300 ? v2.slice(0, 300) + "..." : v2;
+    });
+    log2("info", `[${prepared?.session.id ?? "unknown"}] \u2190 upstream response headers: ${JSON.stringify(respLog)}`);
+  }
   if (!upstream.ok) {
     res.writeHead(upstream.status, respHeaders);
     if (upstream.body) await pipeThrough(upstream.body, res);
@@ -51340,7 +52557,37 @@ async function forward(req, res, opts, body, prepared, core, config, log2, route
       dumpRaw = dumpStreamToFile(b2, opts.dumpSse, `${Date.now()}-${prepared.session.id}-raw.sse`);
     }
     try {
-      if (prepared.protocol === "openai") {
+      if (process.env.ACP_LOOP_V2 !== "0") {
+        const parsedReq = JSON.parse(typeof body === "string" ? body : body.toString("utf8"));
+        const reqHeaders = {};
+        for (const [k2, v2] of Object.entries(headers)) {
+          if (k2.toLowerCase() === "content-length" || k2.toLowerCase() === "host") continue;
+          reqHeaders[k2] = v2;
+        }
+        reqHeaders["content-type"] = "application/json";
+        const textProtocol = prepared.protocol === "responses" && !!prepared.responsesTextProtocol;
+        const systemPrompt = textProtocol ? buildCompressTextSystemPrompt() : buildCompressSystemPrompt();
+        const adapter = pickAdapter(prepared.protocol, parsedReq, textProtocol, prepared.responsesProjection, prepared.anthropicSystem);
+        const loop = runCompressLoop(
+          streamToRead,
+          { core, config, messages: prepared.processedMessages.length > 0 ? prepared.processedMessages : prepared.originalMessages, session: prepared.session, log: ctx.log, proxyUrl, textProtocol, debug: opts.debug },
+          parsedReq,
+          { url: upstreamUrl, headers: reqHeaders },
+          adapter,
+          systemPrompt
+        );
+        for await (const chunk of loop) {
+          {
+            const s3 = chunk.toString("utf8");
+            if (s3.includes("<acp ") || s3.includes("</acp")) {
+              log2("warn", `[${prepared.session.id}] tag echo: ${prepared.protocol} response stream contains <acp tag`);
+            }
+          }
+          res.write(chunk);
+          if (res.writableNeedDrain) await new Promise((r) => res.once("drain", () => r()));
+        }
+        res.end();
+      } else if (prepared.protocol === "openai") {
         const parsedReq = JSON.parse(typeof body === "string" ? body : body.toString("utf8"));
         const reqHeaders = {};
         for (const [k2, v2] of Object.entries(headers)) {