billion-context 0.1.68 → 0.1.69-pr.444.270

package/README.md

@@ -50,6 +50,67 @@ Agent (Claude Code / Codex / Cursor / Aider ...)
 
 The proxy injects four context-management tools (`compress`, `decompress`, `search_context`, `acp_status`) into the conversation. The model calls `compress` when the conversation grows, and the proxy executes it server-side — the compressed ranges are folded into the conversation history before the next turn.
 
+### Two compression modes — who executes `compress`
+
+The proxy runs in one of two modes, and **the mode decides who executes
+`compress`, which in turn decides how the summary travels to the model** (the
+"carrier"). This distinction is the root of #377.
+
+| | **Launcher / plugin mode** (`bili pi`, `bili codex`, …) | **Proxy mode** (plain client → `/bili/`) |
+|---|---|---|
+| Client | ACP-native agent with the bili extension (pi/omp) | Any OpenAI/Anthropic client, no extension |
+| Who executes `compress` | **The agent** (pi runs it locally) | **The proxy** (server-side compress loop) |
+| `compress` tool call in the re-sent history? | Yes — part of the agent's own conversation | No — ephemeral proxy-loop traffic |
+| Preflight blocks (no tool call)? | No — overflow forces the model to call `compress` | Yes — `src/preflight.ts` compresses behind the client's back |
+| **Summary carrier on the wire** | **the `compress` tool call** | **an `acp_summary` user message** |
+| System messages on the wire | always exactly 1 (client + prompt) | always exactly 1 (client + prompt) — summaries ride on user messages |
+| SGLang "single system" 400 (#377) | cannot happen | cannot happen (summaries are user messages, not system) |
+| Proxy-injected tools + nudge | none (agent owns compression) | the 4 context tools + nudge (when enabled) |
+
+**Why the carriers differ.** In plugin mode the agent owns compression: the
+`compress` call + result live in the agent's own history and are re-sent every
+turn, so the summary rides on the tool call and the agent's view never renders
+the kernel's `acp_summary` fallback (`billion-context-pi` `src/messages.ts`
+skips `acp_summary_*`). In proxy mode the client is not ACP-native, so the
+proxy executes `compress` server-side; the tool call never enters the client's
+history, and preflight blocks have no tool call at all — so the kernel's
+`acp_summary` message is the only carrier. The kernel renders it as role
+`system`, but strict OpenAI-compatible backends (SGLang) require exactly one
+system message at index 0, so `systemToUser` (`src/util.ts`) re-voices it as a
+`user` message, leaving it at its anchor position. This keeps the head system
+message (the prefix-cache anchor) byte-stable across compress turns, so a new
+block does not invalidate the whole-conversation prefix.
+
+**Why `user`, not `system` or a forged tool call.** A mid-stream `system`
+message is what SGLang rejects (#377). A forged `compress` tool call would be
+the "pure" carrier, but in proxy mode it requires fabricating an
+assistant `tool_calls` + `user` `tool_result` pair by id, declaring the tool in
+the request, and handling preflight blocks that have no authentic call — far
+more invasive than re-voicing a standalone note. A `user` message is allowed
+anywhere in the conversation, so it is the minimal change that satisfies both
+SGLang's one-system rule and prefix-cache stability. The accepted trade-off:
+a summary is a stand-in for the folded history, and re-voicing it as a user
+turn is a semantic mismatch the model tolerates (it is clearly marked
+`[Compressed conversation section]`).
+
+**Do the two modes coexist?**
+
+- **Same proxy instance: yes, by design.** One proxy serves plugin and plain
+  clients at once; `pluginMode` is decided per request (`x-bili-plugin` header)
+  and bound per session (`session.metadata.pluginAgent`). The launcher reuses a
+  running proxy.
+- **Same session: the mode is sticky.** A session created in plugin mode stays
+  plugin mode (metadata inheritance); a plain session can only be *upgraded* to
+  plugin mode if a plugin request arrives with a matching conversation id (the
+  header outranks) — and never downgraded. In practice a plain→plugin upgrade
+  requires the plugin client's conversation id to match an existing plain
+  session id, which doesn't happen (each client generates its own id).
+- **Cross-mode block hazard: theoretical only.** It would require the same
+  conversation id to span a mode switch. plugin→proxy is safe (the tool call is
+  in the shared history); proxy→plugin could orphan proxy-created block
+  summaries (their tool call isn't in the agent's history and the agent's view
+  skips `acp_summary`) — but that needs the id match above, which doesn't occur.
+
 ## Install
 
 ```bash

package/dist/index.js

@@ -19050,7 +19050,7 @@ var require_response = __commonJS({
     var assert = __require("assert");
     var { isomorphicEncode, serializeJavascriptValueToJSONString } = require_infra();
     var textEncoder = new TextEncoder("utf-8");
-    var Response = class _Response {
+    var Response2 = class _Response {
       /** @type {Headers} */
       #headers;
       #state;
@@ -19222,13 +19222,13 @@ var require_response = __commonJS({
         response.#state = newState;
       }
     };
-    var { getResponseHeaders, setResponseHeaders, getResponseState, setResponseState } = Response;
-    Reflect.deleteProperty(Response, "getResponseHeaders");
-    Reflect.deleteProperty(Response, "setResponseHeaders");
-    Reflect.deleteProperty(Response, "getResponseState");
-    Reflect.deleteProperty(Response, "setResponseState");
-    mixinBody(Response, getResponseState);
-    Object.defineProperties(Response.prototype, {
+    var { getResponseHeaders, setResponseHeaders, getResponseState, setResponseState } = Response2;
+    Reflect.deleteProperty(Response2, "getResponseHeaders");
+    Reflect.deleteProperty(Response2, "setResponseHeaders");
+    Reflect.deleteProperty(Response2, "getResponseState");
+    Reflect.deleteProperty(Response2, "setResponseState");
+    mixinBody(Response2, getResponseState);
+    Object.defineProperties(Response2.prototype, {
       type: kEnumerableProperty,
       url: kEnumerableProperty,
       status: kEnumerableProperty,
@@ -19244,7 +19244,7 @@ var require_response = __commonJS({
         configurable: true
       }
     });
-    Object.defineProperties(Response, {
+    Object.defineProperties(Response2, {
       json: kEnumerableProperty,
       redirect: kEnumerableProperty,
       error: kEnumerableProperty
@@ -19377,7 +19377,7 @@ var require_response = __commonJS({
       }
     }
     function fromInnerResponse(innerResponse, guard) {
-      const response = new Response(kConstruct);
+      const response = new Response2(kConstruct);
       setResponseState(response, innerResponse);
       const headers = new Headers(kConstruct);
       setResponseHeaders(response, headers);
@@ -19431,14 +19431,14 @@ var require_response = __commonJS({
         converter: webidl.converters.HeadersInit
       }
     ]);
-    webidl.is.Response = webidl.util.MakeTypeAssertion(Response);
+    webidl.is.Response = webidl.util.MakeTypeAssertion(Response2);
     module.exports = {
       isNetworkError,
       makeNetworkError,
       makeResponse,
       makeAppropriateNetworkError,
       filterResponse,
-      Response,
+      Response: Response2,
       cloneResponse,
       fromInnerResponse,
       getResponseState
@@ -48010,7 +48010,11 @@ var MAX_REQUEST_BYTES = 100 * 1024 * 1024;
 var UPSTREAM_TIMEOUT_MS = 10 * 60 * 1e3;
 async function fetchWithTimeout(url, opts, timeoutMs = UPSTREAM_TIMEOUT_MS, externalSignal) {
   const controller = new AbortController();
-  const timer2 = setTimeout(() => controller.abort(), timeoutMs);
+  let timer2 = setTimeout(() => controller.abort(), timeoutMs);
+  const rearm = () => {
+    clearTimeout(timer2);
+    timer2 = setTimeout(() => controller.abort(), timeoutMs);
+  };
   let onExternalAbort = null;
   if (externalSignal) {
     if (externalSignal.aborted) controller.abort();
@@ -48019,22 +48023,54 @@ async function fetchWithTimeout(url, opts, timeoutMs = UPSTREAM_TIMEOUT_MS, exte
       externalSignal.addEventListener("abort", onExternalAbort, { once: true });
     }
   }
+  const cleanup = () => {
+    clearTimeout(timer2);
+    if (onExternalAbort && externalSignal) externalSignal.removeEventListener("abort", onExternalAbort);
+  };
   try {
     const finalOpts = { ...opts, signal: controller.signal };
-    const response = await fetch(url, finalOpts);
-    return {
-      response,
-      clearTimer: () => {
-        clearTimeout(timer2);
-        if (onExternalAbort && externalSignal) externalSignal.removeEventListener("abort", onExternalAbort);
-      }
-    };
+    const raw = await fetch(url, finalOpts);
+    if (raw.body) {
+      const wrapped = armIdleBody(raw.body, rearm);
+      return {
+        response: new Response(wrapped, {
+          status: raw.status,
+          statusText: raw.statusText,
+          headers: raw.headers
+        }),
+        clearTimer: cleanup
+      };
+    }
+    return { response: raw, clearTimer: cleanup };
   } catch (e) {
-    clearTimeout(timer2);
-    if (onExternalAbort && externalSignal) externalSignal.removeEventListener("abort", onExternalAbort);
+    cleanup();
     throw e;
   }
 }
+function armIdleBody(body, rearm) {
+  const reader = body.getReader();
+  return new ReadableStream({
+    async pull(controller) {
+      try {
+        const result = await reader.read();
+        if (result.done) {
+          controller.close();
+          return;
+        }
+        rearm();
+        controller.enqueue(result.value);
+      } catch (e) {
+        controller.error(e);
+      }
+    },
+    async cancel(reason) {
+      try {
+        await reader.cancel(reason);
+      } catch {
+      }
+    }
+  });
+}
 var UpstreamHttpError = class extends Error {
   status;
   body;
@@ -51718,25 +51754,18 @@ function reserveOutputHeadroom(window2, maxOutput) {
   }
   return window2;
 }
-function hoistMidSystemMessages(messages) {
-  let lead = 0;
-  while (lead < messages.length && (messages[lead].role === "system" || messages[lead].role === "developer")) lead++;
-  if (lead === messages.length) return messages;
-  let midCount = 0;
-  for (let i = lead; i < messages.length; i++) {
-    const r = messages[i].role;
-    if (r === "system" || r === "developer") midCount++;
-  }
-  if (midCount === 0) return messages;
-  const head = messages.slice(0, lead);
-  const mid = [];
-  const rest = [];
-  for (let i = lead; i < messages.length; i++) {
-    const r = messages[i].role;
-    if (r === "system" || r === "developer") mid.push(messages[i]);
-    else rest.push(messages[i]);
-  }
-  return [...head, ...mid, ...rest];
+function systemToUser(messages) {
+  let hasSys = false;
+  for (const m2 of messages) {
+    if (m2.role === "system" || m2.role === "developer") {
+      hasSys = true;
+      break;
+    }
+  }
+  if (!hasSys) return messages;
+  return messages.map(
+    (m2) => m2.role === "system" || m2.role === "developer" ? { ...m2, role: "user" } : m2
+  );
 }
 function shouldReserveOutputHeadroom(protocol) {
   return protocol !== "anthropic";
@@ -51966,6 +51995,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();
@@ -52020,6 +52063,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;
@@ -52176,18 +52224,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) {
@@ -52207,18 +52259,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 = [];
@@ -52330,6 +52386,20 @@ function rewriteContentChunk(parsed, content) {
 
 `, "utf8");
 }
+function stripFinishReasonChunk(buf) {
+  const m2 = /^data: (.*)\n\n$/s.exec(buf.toString("utf8"));
+  if (!m2) return buf;
+  try {
+    const parsed = JSON.parse(m2[1]);
+    if (!Array.isArray(parsed.choices)) return buf;
+    parsed.choices = parsed.choices.map((c) => ({ ...c, finish_reason: null }));
+    return Buffer.from(`data: ${JSON.stringify(parsed)}
+
+`, "utf8");
+  } catch {
+    return buf;
+  }
+}
 function createOpenaiAdapter(requestBody, clientSystem) {
   const model = requestBody.model ?? "unknown";
   let responseId = `chatcmpl-proxy-${Date.now()}`;
@@ -52399,7 +52469,7 @@ function createOpenaiAdapter(requestBody, clientSystem) {
   );
   return {
     buildRequest(coreMessages, systemPrompt, body) {
-      const messages = hoistMidSystemMessages(coreToOpenai(coreMessages));
+      const messages = systemToUser(coreToOpenai(coreMessages));
       const withSys = injectOpenaiSystem(messages, [clientSystem, systemPrompt].filter((p2) => typeof p2 === "string" && p2.length > 0));
       return { ...body, messages: withSys };
     },
@@ -52526,6 +52596,7 @@ function createOpenaiAdapter(requestBody, clientSystem) {
           if (sawRealToolCall) {
             yield { kind: "meta", chunk: rawBuf };
             yield { kind: "done", finishReason, suppressCompletion: true };
+            continue;
           } else {
             yield {
               kind: "done",
@@ -52535,7 +52606,7 @@ function createOpenaiAdapter(requestBody, clientSystem) {
         }
         if (!delta) continue;
         if (typeof delta.reasoning_content === "string" && delta.reasoning_content.length > 0) {
-          yield { kind: "reasoning", delta: delta.reasoning_content, raw: rawBuf };
+          yield { kind: "reasoning", delta: delta.reasoning_content, raw: finishReason ? stripFinishReasonChunk(rawBuf) : rawBuf };
         }
         if (delta.tool_calls) {
           const tcs = delta.tool_calls;
@@ -52570,10 +52641,10 @@ function createOpenaiAdapter(requestBody, clientSystem) {
           const clean = tagFilter.push(delta.content);
           if (clean.length > 0) {
             const raw = clean === delta.content ? rawBuf : rewriteContentChunk(parsed, clean);
-            yield { kind: "text", delta: clean, ...hasReasoning ? {} : { raw } };
+            yield { kind: "text", delta: clean, ...hasReasoning ? {} : { raw: finishReason ? stripFinishReasonChunk(raw) : raw } };
           }
         } else if (!hasReasoning && (delta.role || Object.keys(delta).length === 0 && !finishReason)) {
-          yield { kind: "meta", chunk: rawBuf, firstRoundOnly: true };
+          yield { kind: "meta", chunk: finishReason ? stripFinishReasonChunk(rawBuf) : rawBuf, firstRoundOnly: true };
         }
       }
     },
@@ -56593,7 +56664,7 @@ function prepareAnthropic(parsed, req, opts, core, config, prompts, log2, sessio
     if (injectTools) {
       toolsOut = injectTool(parsed.tools);
     }
-    if (opts.compress.injectNudge && turn.nudge?.shouldInject) {
+    if (opts.compress.injectNudge && !pluginMode && turn.nudge?.shouldInject) {
       try {
         const rendered = renderNudgeText(turn.nudge, prompts);
         if (rendered.text) {
@@ -56645,7 +56716,7 @@ function prepareOpenai(parsed, req, opts, core, config, prompts, log2, session,
     log2("info", diagNudge(turn, sessionId, tokenCount, config.modelContextLimit, parsed.model));
     processedMessages = stripKernelSummaries(turn.messages, turn.state);
     reapOrphanBlocks(session, msgs, deactivateBlock);
-    rebuiltMessages = hoistMidSystemMessages(coreToOpenai(processedMessages));
+    rebuiltMessages = systemToUser(coreToOpenai(processedMessages));
     const sysParts = [];
     if (systemText) sysParts.push(systemText);
     if (shouldInject) sysParts.push(buildCompressSystemPrompt(prompts));
@@ -56653,7 +56724,7 @@ function prepareOpenai(parsed, req, opts, core, config, prompts, log2, session,
     if (injectTools) {
       toolsOut = injectOpenaiTool(parsed.tools);
     }
-    if (opts.compress.injectNudge && turn.nudge?.shouldInject && shouldInject) {
+    if (opts.compress.injectNudge && !pluginMode && turn.nudge?.shouldInject && shouldInject) {
       try {
         const rendered = renderNudgeText(turn.nudge, prompts);
         if (rendered.text) {
@@ -56747,7 +56818,7 @@ function prepareResponses(parsed, req, opts, core, config, prompts, log2, sessio
       const devContent = [...projection.systemParts, ...forgedSummaries].join("\n\n---\n\n");
       rebuiltInput = injectResponsesDeveloperMessage(rebuiltInput, devContent);
     }
-    if (opts.compress.injectNudge && turn.nudge?.shouldInject && shouldInject && !isCompactionTrigger) {
+    if (opts.compress.injectNudge && !pluginMode && turn.nudge?.shouldInject && shouldInject && !isCompactionTrigger) {
       try {
         const rendered = renderNudgeText(turn.nudge, prompts);
         if (rendered.text) {