billion-context 0.1.97 → 0.1.98-pr.665.492

package/dist/index.js

@@ -48726,6 +48726,7 @@ function mergeCompress(global2, provider, model) {
   const promptLevels = [global2?.prompts, provider?.prompts, model?.prompts].filter(Boolean);
   const rangeOf = (s3) => s3?.minCompressRangeChars ?? s3?.minCompressRange;
   const absorbLevels = [global2?.absorb, provider?.absorb, model?.absorb].filter(Boolean);
+  const reasoningLevels = [global2?.reasoning, provider?.reasoning, model?.reasoning].filter(Boolean);
   return {
     modelContextLimit: pick("modelContextLimit"),
     maxContextLimit: pick("maxContextLimit"),
@@ -48739,7 +48740,11 @@ function mergeCompress(global2, provider, model) {
     acknowledgePromptsRisk: pick("acknowledgePromptsRisk"),
     absorb: absorbLevels.length > 0 ? Object.assign({}, ...absorbLevels) : void 0,
     stripImages: pick("stripImages"),
-    stripImagesKeepRecent: pick("stripImagesKeepRecent")
+    stripImagesKeepRecent: pick("stripImagesKeepRecent"),
+    // `reasoning` is a third nested-object field merged sub-field-wise
+    // exactly like `absorb`/`prompts`: a model-level `threshold` must not
+    // discard a provider-level `drop: false`.
+    reasoning: reasoningLevels.length > 0 ? Object.assign({}, ...reasoningLevels) : void 0
   };
 }
 function resolveCompress(routes, upstreamUrl, model, global2) {
@@ -48819,6 +48824,53 @@ function resolveRequestConfig(base, routes, embeddedUrl, model, native, globalCo
   return applyCompressSettings(base, limit, compress);
 }
 
+// src/reasoning-drop.ts
+var DEFAULT_COMPRESS_REASONING = { drop: true, threshold: 2048 };
+function resolveReasoningDrop(cfg) {
+  let threshold = DEFAULT_COMPRESS_REASONING.threshold;
+  if (cfg?.threshold !== void 0) {
+    const t = cfg.threshold;
+    if (typeof t === "number" && Number.isFinite(t) && t >= 0) {
+      threshold = Math.floor(t);
+    }
+  }
+  return { drop: cfg?.drop !== false, threshold };
+}
+function dropCompressReasoning(messages, cfg) {
+  const { drop, threshold } = resolveReasoningDrop(cfg);
+  if (!drop || messages.length === 0) return messages;
+  try {
+    const last = messages.length - 1;
+    const resultAt = /* @__PURE__ */ new Map();
+    for (let i = 0; i <= last; i++) {
+      const m2 = messages[i];
+      if (m2.contentType === "tool-result" && typeof m2.toolCallId === "string" && !resultAt.has(m2.toolCallId)) {
+        resultAt.set(m2.toolCallId, i);
+      }
+    }
+    const dropIdx = /* @__PURE__ */ new Set();
+    for (let i = 0; i <= last; i++) {
+      const m2 = messages[i];
+      if (m2.contentType !== "tool-call" || m2.toolName !== "compress") continue;
+      const ri2 = typeof m2.toolCallId === "string" ? resultAt.get(m2.toolCallId) : void 0;
+      if (ri2 === void 0 || ri2 <= i || ri2 >= last) continue;
+      let total = 0;
+      let j2 = i - 1;
+      while (j2 >= 0 && messages[j2].contentType === "reasoning") {
+        total += (messages[j2].text ?? "").length;
+        j2--;
+      }
+      if (total > threshold) {
+        for (let k2 = j2 + 1; k2 < i; k2++) dropIdx.add(k2);
+      }
+    }
+    if (dropIdx.size === 0) return messages;
+    return messages.filter((_2, idx) => !dropIdx.has(idx));
+  } catch {
+    return messages;
+  }
+}
+
 // src/strip-images.ts
 var DEFAULT_STRIP_IMAGES_KEEP_RECENT = 5;
 var IMAGE_PLACEHOLDER = "[image]";
@@ -51880,16 +51932,41 @@ function splitChunks(messages, startIdx, endIdx, budget, minUnits, countText = d
   }
   return chunks;
 }
-function summaryPayload(protocol, model, system, content, stream2) {
+function summaryPayload(protocol, model, system, content, stream2, includeMaxOutputTokens) {
   if (protocol === "anthropic") {
     return { model, max_tokens: MAX_SUMMARY_OUTPUT_TOKENS, system, messages: [{ role: "user", content }], stream: stream2 };
   }
   if (protocol === "openai") {
     return { model, max_tokens: MAX_SUMMARY_OUTPUT_TOKENS, messages: [{ role: "system", content: system }, { role: "user", content }], stream: stream2 };
   }
-  return { model, max_output_tokens: MAX_SUMMARY_OUTPUT_TOKENS, instructions: system, input: [{ role: "user", content }], stream: stream2, store: false };
+  const payload = { model, instructions: system, input: [{ role: "user", content }], stream: stream2, store: false };
+  if (includeMaxOutputTokens) payload.max_output_tokens = MAX_SUMMARY_OUTPUT_TOKENS;
+  return payload;
 }
 var STREAM_REQUIRED_RE = /\bstream\b[^\n]{0,60}\btrue\b/i;
+var MAX_OUTPUT_TOKENS_REJECTED_RE = /\bmax_output_tokens\b/i;
+function noMaxOutputTokensKey(deps) {
+  return `${deps.url}\0${deps.model}`;
+}
+function hasLearnedNoMaxOutputTokens(deps) {
+  const learned = deps.session.metadata.preflightNoMaxOutputTokens;
+  return typeof learned === "object" && learned !== null && learned[noMaxOutputTokensKey(deps)] === true;
+}
+function rememberNoMaxOutputTokens(deps) {
+  const learned = deps.session.metadata.preflightNoMaxOutputTokens;
+  const map = typeof learned === "object" && learned !== null ? learned : {};
+  map[noMaxOutputTokensKey(deps)] = true;
+  deps.session.metadata.preflightNoMaxOutputTokens = map;
+}
+var SUMMARY_STRIP_HEADERS = /* @__PURE__ */ new Set(["x-openai-internal-codex-responses-lite"]);
+function summaryHeaders(deps) {
+  const headers = {};
+  for (const [k2, v2] of Object.entries(deps.headers)) {
+    if (SUMMARY_STRIP_HEADERS.has(k2.toLowerCase())) continue;
+    headers[k2] = v2;
+  }
+  return headers;
+}
 function extractSummaryFromSse(protocol, text) {
   let out = "";
   for (const line of text.split("\n")) {
@@ -51953,25 +52030,39 @@ async function summarizeRange(deps, content, startRef, endRef) {
   const system = buildCompressSystemPrompt(deps.prompts) + `
 
 TASK: The conversation segment below (messages ${startRef}\u2013${endRef}) must be compressed because the session context exceeds the current model's window. Write a tier-1 compression summary of the segment following every rule above. Output ONLY the summary text \u2014 no preamble, no closing remarks, no tool calls.`;
-  const learned = deps.session.metadata.preflightStreamSummary === true;
-  try {
-    return await requestSummary(deps, system, content, learned);
-  } catch (err2) {
-    if (err2 instanceof UpstreamHttpError && err2.status === 400 && !learned && STREAM_REQUIRED_RE.test(err2.body)) {
-      deps.session.metadata.preflightStreamSummary = true;
-      deps.log("info", "[preflight] upstream requires stream for summaries; retrying with SSE (learned for this session)");
-      return await requestSummary(deps, system, content, true);
+  let stream2 = deps.session.metadata.preflightStreamSummary === true;
+  let includeMaxOutputTokens = !(deps.protocol === "responses" && hasLearnedNoMaxOutputTokens(deps));
+  for (; ; ) {
+    try {
+      return await requestSummary(deps, system, content, stream2, includeMaxOutputTokens);
+    } catch (err2) {
+      if (err2 instanceof UpstreamHttpError && err2.status === 400) {
+        let adapted = false;
+        if (!stream2 && STREAM_REQUIRED_RE.test(err2.body)) {
+          deps.session.metadata.preflightStreamSummary = true;
+          stream2 = true;
+          adapted = true;
+          deps.log("info", "[preflight] upstream requires stream for summaries; retrying with SSE (learned for this session)");
+        }
+        if (deps.protocol === "responses" && includeMaxOutputTokens && MAX_OUTPUT_TOKENS_REJECTED_RE.test(err2.body)) {
+          rememberNoMaxOutputTokens(deps);
+          includeMaxOutputTokens = false;
+          adapted = true;
+          deps.log("info", `[preflight] upstream rejects max_output_tokens for summaries (model=${deps.model}); retrying without it (learned for this session+upstream+model)`);
+        }
+        if (adapted) continue;
+      }
+      throw err2;
     }
-    throw err2;
   }
 }
-async function requestSummary(deps, system, content, stream2) {
+async function requestSummary(deps, system, content, stream2, includeMaxOutputTokens) {
   const { response, clearTimer } = await fetchWithRetry(
     deps.url,
     {
       method: "POST",
-      headers: { "content-type": "application/json", ...deps.headers },
-      body: JSON.stringify(summaryPayload(deps.protocol, deps.model, system, content, stream2)),
+      headers: { "content-type": "application/json", ...summaryHeaders(deps) },
+      body: JSON.stringify(summaryPayload(deps.protocol, deps.model, system, content, stream2, includeMaxOutputTokens)),
       dispatcher: proxyDispatcher(deps.proxyUrl)
     },
     void 0,
@@ -56255,15 +56346,28 @@ function handlePluginManifest(res) {
     statusEndpoint: "/__bili/plugin/status"
   }));
 }
+function conversationIdForSession(sessionId) {
+  let bestId;
+  let bestSeen = -Infinity;
+  for (const [cid, entry] of conversations) {
+    if (entry.sessionId === sessionId && entry.lastSeen > bestSeen) {
+      bestId = cid;
+      bestSeen = entry.lastSeen;
+    }
+  }
+  return bestId;
+}
 function handlePluginStatus(conversationId2, res, deps, fallbackLatest = false) {
   let entry = conversations.get(conversationId2);
   let session = entry ? peekSession(entry.sessionId) : void 0;
   let viaFallback = false;
+  let resolvedConversationId = conversationId2;
   if ((!entry || !session) && fallbackLatest) {
     const latest = listSessions().filter((s3) => s3.restored !== true).sort((a, b2) => (b2.lastSeen ?? 0) - (a.lastSeen ?? 0))[0];
     if (latest) {
       session = latest;
       viaFallback = true;
+      resolvedConversationId = conversationIdForSession(latest.id) ?? conversationId2;
     } else {
       res.writeHead(404, { "content-type": "application/json" });
       res.end(JSON.stringify({ ok: false, error: "no session with activity since boot \u2014 issue a model request or pass the conversation id" }));
@@ -56313,7 +56417,7 @@ function handlePluginStatus(conversationId2, res, deps, fallbackLatest = false)
   res.writeHead(200, { "content-type": "application/json" });
   res.end(JSON.stringify({
     ok: true,
-    conversationId: conversationId2,
+    conversationId: resolvedConversationId,
     fallback: viaFallback || void 0,
     label: session.meta.label ?? null,
     pluginAgent: session.metadata.pluginAgent ?? null,
@@ -56348,8 +56452,12 @@ async function handlePluginTool(payload, res, deps) {
   const entry = conversations.get(conversationId2);
   const session = entry ? peekSession(entry.sessionId) : void 0;
   if (!entry || !session) {
+    deps.log("warn", `[plugin] tool "${tool}" rejected for conversation ${conversationId2}: ${entry ? "id registered but session not resident in this proxy instance" : "id never registered (stale shim session id after host resume?)"}`);
     res.writeHead(404, { "content-type": "application/json" });
-    res.end(JSON.stringify({ ok: false, error: "unknown plugin conversation (no model request has arrived with this conversation id yet)" }));
+    res.end(JSON.stringify({
+      ok: false,
+      error: !entry ? "unknown plugin conversation (no model request has arrived with this conversation id yet)" : "unknown plugin conversation (id registered but its session is not resident in this proxy instance \u2014 a fresh model request re-binds it)"
+    }));
     return;
   }
   if (!isProxyToolFor(tool, session, deps.config)) {
@@ -59214,13 +59322,14 @@ ${bodyBuffer.toString("utf8")}`);
       await withSessionLock(session, async () => {
         const runPrepare = () => {
           const cs2 = resolveCompress(opts.routes, route?.rewrittenUrl, parsed.model, opts.compress);
+          const reasoningCfg = cs2.reasoning;
           const keepRecent = cs2.stripImagesKeepRecent ?? DEFAULT_STRIP_IMAGES_KEEP_RECENT;
           const stripped = cs2.stripImages ? stripHistoricalImages(parsed, protocol, keepRecent) : { body: parsed, removed: 0 };
           if (opts.debug && stripped.removed > 0) {
             log2("info", `[debug] strip-images: dropped ${stripped.removed} historical image part(s), kept last ${keepRecent} (session=${session.id})`);
           }
           const work = stripped.body;
-          return countTokens ? prepareCountTokens(work, core, reqConfig, log2, session) : protocol === "anthropic" ? prepareAnthropic(work, req, opts, core, reqConfig, reqPrompts, log2, session, pluginMode) : protocol === "openai" ? prepareOpenai(work, req, opts, core, reqConfig, reqPrompts, log2, session, pluginMode, nativeWindow) : responsesCompact ? prepareResponsesCompact(stripped.removed > 0 ? Buffer.from(JSON.stringify(work)) : bodyBuffer, work, session, req, core, reqConfig, log2) : prepareResponses(work, req, opts, core, reqConfig, reqPrompts, log2, session, responsesIdentity, pluginMode, upstreamOrigin, nativeWindow);
+          return countTokens ? prepareCountTokens(work, core, reqConfig, log2, session) : protocol === "anthropic" ? prepareAnthropic(work, req, opts, core, reqConfig, reqPrompts, log2, session, pluginMode, reasoningCfg) : protocol === "openai" ? prepareOpenai(work, req, opts, core, reqConfig, reqPrompts, log2, session, pluginMode, nativeWindow, reasoningCfg) : responsesCompact ? prepareResponsesCompact(stripped.removed > 0 ? Buffer.from(JSON.stringify(work)) : bodyBuffer, work, session, req, core, reqConfig, log2) : prepareResponses(work, req, opts, core, reqConfig, reqPrompts, log2, session, responsesIdentity, pluginMode, upstreamOrigin, nativeWindow, reasoningCfg);
         };
         const isCodexCompactTrigger = protocol === "responses" && !responsesCompact && isCodexClient(req.headers) && hasCompactionTrigger(parsed.input);
         if (isCodexCompactTrigger) {
@@ -59308,6 +59417,13 @@ ${bodyBuffer.toString("utf8")}`);
   }
 }
 var ACP_TAG_MARK = "<acp ";
+function withReasoningDrop(msgs, reasoning, log2, sessionId) {
+  const out = dropCompressReasoning(msgs, reasoning);
+  if (out.length !== msgs.length) {
+    log2("info", `[${sessionId}] compress-reasoning: dropped ${msgs.length - out.length} reasoning message(s) from closed compress turns (#651)`);
+  }
+  return out;
+}
 function stripKernelSummaries(messages, state) {
   const carried = /* @__PURE__ */ new Set();
   for (const b2 of state.blocks) {
@@ -59409,12 +59525,13 @@ function effectiveTokenCount(session, msgs) {
   if (!session.metadata.anonymousPrefixAffinity) return 0;
   return estimateCoreMessagesUpper(msgs);
 }
-function prepareAnthropic(parsed, req, opts, core, config, prompts, log2, session, pluginMode) {
+function prepareAnthropic(parsed, req, opts, core, config, prompts, log2, session, pluginMode, reasoning) {
   const sessionId = session.id;
   const stream2 = parsed.stream === true;
   ++session.stats.requests;
   session.hostCreditTokens = 0;
   const injectTools = opts.compress.injectTool && !pluginMode;
+  const stripReasoning = (msgs) => withReasoningDrop(msgs, reasoning, log2, sessionId);
   if (isAutoModeClassifier(parsed)) {
     log2("info", `[${sessionId}] auto-mode classifier passthrough (skipping compress injection)`);
     return { body: JSON.stringify(parsed), session, processedMessages: [], originalMessages: [], anthropicSystem: parsed.system, protocol: "anthropic", stream: stream2, compressInjected: false, pluginMode, nudge: void 0, prompts };
@@ -59452,7 +59569,7 @@ function prepareAnthropic(parsed, req, opts, core, config, prompts, log2, sessio
     log2("info", diagTagSummary(turn.messages, sessionId, "text-only"));
     const willInjectNudge = opts.compress.injectNudge && !!turn.nudge && (turn.nudge.shouldInject || emergencyNudge(turn.nudge));
     log2("info", diagNudge(turn, sessionId, tokenCount, config.modelContextLimit, parsed.model, willInjectNudge));
-    processedMessages = stripKernelSummaries(turn.messages, turn.state);
+    processedMessages = stripReasoning(stripKernelSummaries(turn.messages, turn.state));
     applyCompactionArchive(session, activeBefore, new Set(msgs.map((m2) => m2.id)), log2);
     reapOrphanBlocks(session, msgs, deactivateBlock);
     rebuiltMessages = coreToAnthropic(processedMessages, cacheControls);
@@ -59534,12 +59651,13 @@ function clampOutgoingOutput(rebuilt, field, ctx, sessionId, log2) {
     log2("info", `[${sessionId}] output budget clamped ${raw} -> ${capped} (input~${inputEstimate}, window=${ctx.nativeWindow}); prevents input+output overflow (#453)`);
   }
 }
-function prepareOpenai(parsed, req, opts, core, config, prompts, log2, session, pluginMode, nativeWindow) {
+function prepareOpenai(parsed, req, opts, core, config, prompts, log2, session, pluginMode, nativeWindow, reasoning) {
   const sessionId = session.id;
   const stream2 = parsed.stream === true;
   ++session.stats.requests;
   session.hostCreditTokens = 0;
   let openaiSystemText = "";
+  const stripReasoning = (msgs) => withReasoningDrop(msgs, reasoning, log2, sessionId);
   let openaiOutboundSystem;
   let processedMessages = [];
   let originalMessages = [];
@@ -59577,7 +59695,7 @@ function prepareOpenai(parsed, req, opts, core, config, prompts, log2, session,
     log2("info", diagTagSummary(turn.messages, sessionId, "text-only"));
     const willInjectNudge = opts.compress.injectNudge && !!turn.nudge && shouldInject && (turn.nudge.shouldInject || emergencyNudge(turn.nudge));
     log2("info", diagNudge(turn, sessionId, tokenCount, config.modelContextLimit, parsed.model, willInjectNudge));
-    processedMessages = stripKernelSummaries(turn.messages, turn.state);
+    processedMessages = stripReasoning(stripKernelSummaries(turn.messages, turn.state));
     applyCompactionArchive(session, activeBefore, new Set(msgs.map((m2) => m2.id)), log2);
     reapOrphanBlocks(session, msgs, deactivateBlock);
     rebuiltMessages = systemToUser(coreToOpenai(processedMessages));
@@ -59617,11 +59735,12 @@ function prepareOpenai(parsed, req, opts, core, config, prompts, log2, session,
   markDirty(session);
   return { body: JSON.stringify(rebuilt), session, processedMessages, originalMessages, protocol: "openai", stream: stream2, compressInjected: injectTools, pluginMode, nudge, prompts, openaiSystemText, renderTags: "text-only" };
 }
-function prepareResponses(parsed, req, opts, core, config, prompts, log2, session, identity, pluginMode, upstreamOrigin, nativeWindow) {
+function prepareResponses(parsed, req, opts, core, config, prompts, log2, session, identity, pluginMode, upstreamOrigin, nativeWindow, reasoning) {
   const sessionId = session.id;
   const stream2 = parsed.stream === true;
   ++session.stats.requests;
   session.hostCreditTokens = 0;
+  const stripReasoning = (msgs) => withReasoningDrop(msgs, reasoning, log2, sessionId);
   if (reconcileNativeCompactionBoundary(session)) {
     log2("info", `[${sessionId}] reconciled ACP state after native Responses compact boundary`);
   }
@@ -59686,7 +59805,7 @@ function prepareResponses(parsed, req, opts, core, config, prompts, log2, sessio
     log2("info", diagTagSummary(turn.messages, sessionId, "text-only"));
     const willInjectNudge = opts.compress.injectNudge && !!turn.nudge && shouldInject && !isCompactionTrigger && (turn.nudge.shouldInject || emergencyNudge(turn.nudge));
     log2("info", diagNudge(turn, sessionId, tokenCount, config.modelContextLimit, parsed.model, willInjectNudge));
-    processedMessages = repairResponsesAssistantOrdering(stripKernelSummaries(turn.messages, turn.state), originalMessages);
+    processedMessages = repairResponsesAssistantOrdering(stripReasoning(stripKernelSummaries(turn.messages, turn.state)), originalMessages);
     reapOrphanBlocks(session, msgs, deactivateBlock);
     rebuiltInput = patchResponsesInput(projection, processedMessages);
     const forgedSummaries = echoReplaced ? [] : session.metadata.codexForgedSummaries ?? [];
@@ -64321,6 +64440,7 @@ function resolveProxyOrigin() {
 var TOOL_TIMEOUT_MS = 6e4;
 var CONVERSATION_FROM_ENV = process.env.CLAUDE_CODE_SESSION_ID?.trim() || process.env.BILI_CONVERSATION_ID?.trim() || void 0;
 var IDENTITY_BINDING = Boolean(process.env.CLAUDE_CODE_SESSION_ID?.trim());
+var ORPHAN_ADOPT = IDENTITY_BINDING && process.env.BILI_MCP_NO_ORPHAN_ADOPT !== "1";
 var manifestTools = [];
 var conversationId = CONVERSATION_FROM_ENV;
 var registered = false;
@@ -64353,21 +64473,45 @@ function ensureManifest() {
   return manifestPromise;
 }
 async function forwardTool(tool, args, timeoutMs = TOOL_TIMEOUT_MS) {
-  let res;
+  for (let attempt = 0; ; attempt++) {
+    let res;
+    try {
+      res = await fetch(`${resolveProxyOrigin()}/__bili/plugin/tool`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ conversationId, tool, args }),
+        signal: AbortSignal.timeout(timeoutMs)
+      });
+    } catch (err2) {
+      if (err2 instanceof Error && err2.name === "TimeoutError") throw new Error(`tool forward timed out after ${timeoutMs}ms: ${tool}`);
+      throw err2;
+    }
+    const data = await res.json();
+    if (res.ok && data.ok) return data.result ?? "";
+    if (res.status === 404 && attempt === 0 && ORPHAN_ADOPT && conversationId && typeof data.error === "string" && data.error.includes("no model request has arrived")) {
+      if (await adoptLatestActiveConversation()) continue;
+    }
+    throw new Error(data.error ?? `tool forward failed: ${res.status}`);
+  }
+}
+async function adoptLatestActiveConversation() {
   try {
-    res = await fetch(`${resolveProxyOrigin()}/__bili/plugin/tool`, {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({ conversationId, tool, args }),
-      signal: AbortSignal.timeout(timeoutMs)
-    });
-  } catch (err2) {
-    if (err2 instanceof Error && err2.name === "TimeoutError") throw new Error(`tool forward timed out after ${timeoutMs}ms: ${tool}`);
-    throw err2;
+    const res = await fetch(
+      `${resolveProxyOrigin()}/__bili/plugin/status?conversationId=${encodeURIComponent(conversationId ?? "")}&fallback=latest`,
+      { signal: AbortSignal.timeout(5e3) }
+    );
+    if (!res.ok) return false;
+    const data = await res.json();
+    if (data.ok !== true || data.fallback !== true || !data.conversationId || data.conversationId === conversationId) return false;
+    process.stderr.write(
+      `[bili-mcp] conversation id no longer known by the proxy (host resumed its session?); adopting latest active conversation ${data.conversationId}
+`
+    );
+    conversationId = data.conversationId;
+    return true;
+  } catch {
+    return false;
   }
-  const data = await res.json();
-  if (!res.ok || !data.ok) throw new Error(data.error ?? `tool forward failed: ${res.status}`);
-  return data.result ?? "";
 }
 var ERR_TOOL = -32602;
 async function handleMessage(msg) {