ework-qq-bridge 0.5.0 → 0.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ework-qq-bridge",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "QQ group <-> ework issue bridge (OneBot 11 reverse WebSocket)",
   "type": "module",
   "main": "src/index.ts",

package/src/chat.ts

@@ -24,42 +24,54 @@ export function estimateTokens(text: string): number {
 // Single-message hard cap so one pasted log cannot eat the whole budget.
 export const CHAT_MSG_CHAR_CAP = 24000;
 
-function capContent(text: string): string {
+// Evict in bulk, never slide. A sliding window re-derives "last N" on every
+// build, shifting the prompt prefix each request, missing the serving
+// engine's prefix cache (radix cache) and forcing a full re-prefill of the
+// whole context every turn once history is full. trimStored is instead
+// STICKY: it is a no-op while under the limits and, on crossing one, drops
+// the oldest turns down to TRIM_FLOOR_RATIO in a single shot. Between
+// evictions the stored history only ever grows append-only, so the prompt
+// prefix (system + history) stays byte-identical and cached prefixes keep
+// hitting; only the first request after each eviction re-fills.
+export const TRIM_FLOOR_RATIO = 0.7;
+
+export function capContent(text: string): string {
   return text.length > CHAT_MSG_CHAR_CAP ? text.slice(0, CHAT_MSG_CHAR_CAP) + "…（已截断）" : text;
 }
 
-// Keep the newest turns that fit the token budget (oldest dropped first).
-export function trimToContext(
-  history: ChatTurn[],
-  maxContextTokens: number,
-  reservedTokens: number,
-): ChatTurn[] {
-  const budget = Math.max(0, maxContextTokens - reservedTokens);
-  const kept: ChatTurn[] = [];
-  let used = 0;
-  for (let i = history.length - 1; i >= 0; i--) {
-    const turn = history[i];
-    if (!turn) continue;
-    const cost = estimateTokens(turn.content);
-    if (used + cost > budget) break;
-    used += cost;
-    kept.unshift(turn);
+function historyTokens(history: ChatTurn[]): number {
+  return history.reduce((n, t) => n + estimateTokens(t.content), 0);
+}
+
+// Headroom for the fixed prompt furniture (system + one max-size question).
+function reserveTokens(): number {
+  return estimateTokens(CHAT_SYSTEM_PROMPT) + estimateTokens("x".repeat(CHAT_MSG_CHAR_CAP));
+}
+
+export function trimStored(history: ChatTurn[], maxHistory: number, maxContextTokens: number): ChatTurn[] {
+  const countLimit = Math.max(2, maxHistory * 2);
+  const tokenLimit = Math.max(0, maxContextTokens - reserveTokens());
+  if (history.length <= countLimit && historyTokens(history) <= tokenLimit) return history;
+  const countFloor = Math.max(2, Math.floor(countLimit * TRIM_FLOOR_RATIO));
+  const tokenFloor = Math.floor(tokenLimit * TRIM_FLOOR_RATIO);
+  let start = 0;
+  let total = historyTokens(history);
+  while (start < history.length && (history.length - start > countFloor || total > tokenFloor)) {
+    const turn = history[start];
+    if (!turn) break;
+    total -= estimateTokens(turn.content);
+    start++;
   }
-  return kept;
+  return history.slice(start);
 }
 
 export function buildChatMessages(
   history: ChatTurn[],
   question: ChatTurn,
-  maxHistory: number,
-  maxContextTokens: number,
 ): { role: string; name?: string; content: string }[] {
-  const system = { role: "system", content: CHAT_SYSTEM_PROMPT };
-  const recent = history.slice(-maxHistory);
-  const kept = trimToContext(recent, maxContextTokens, estimateTokens(CHAT_SYSTEM_PROMPT) + estimateTokens(question.content));
   return [
-    system,
-    ...kept.map((t) => ({ role: t.role, name: t.name, content: capContent(t.content) })),
+    { role: "system", content: CHAT_SYSTEM_PROMPT },
+    ...history.map((t) => ({ role: t.role, name: t.name, content: capContent(t.content) })),
     { role: question.role, name: question.name, content: capContent(question.content) },
   ];
 }

package/src/router.ts

@@ -3,7 +3,7 @@ import type { EworkClient } from "./ework";
 import type { GroupMessageEvent } from "./onebot";
 import type { BridgeStore } from "./db";
 import type { BindingStore } from "./bindings";
-import { buildChatMessages, chatComplete, splitForQQ, type ChatTurn } from "./chat";
+import { buildChatMessages, capContent, chatComplete, splitForQQ, trimStored, type ChatTurn } from "./chat";
 
 const HELP_TEXT = [
   "用法：",
@@ -52,12 +52,12 @@ export function createRouter(deps: RouterDeps) {
 
   async function answerChat(ev: GroupMessageEvent, question: string): Promise<void> {
     try {
-      const turn: ChatTurn = { role: "user", name: ev.nickname, content: question };
-      const history = chatHistory.get(ev.groupId) ?? [];
-      const messages = buildChatMessages(history, turn, cfg.WORK_CHAT_MAX_HISTORY, cfg.WORK_CHAT_MAX_CONTEXT);
+      const turn: ChatTurn = { role: "user", name: ev.nickname, content: capContent(question) };
+      const stored = trimStored(chatHistory.get(ev.groupId) ?? [], cfg.WORK_CHAT_MAX_HISTORY, cfg.WORK_CHAT_MAX_CONTEXT);
+      chatHistory.set(ev.groupId, stored);
+      const messages = buildChatMessages(stored, turn);
       const answer = await chatComplete(cfg.WORK_CHAT_API, cfg.WORK_CHAT_API_KEY, cfg.WORK_CHAT_MODEL, messages, cfg.WORK_CHAT_TIMEOUT_MS);
-      history.push(turn, { role: "assistant", name: "bot", content: answer });
-      chatHistory.set(ev.groupId, history.slice(-cfg.WORK_CHAT_MAX_HISTORY * 2));
+      chatHistory.set(ev.groupId, [...stored, turn, { role: "assistant", name: "bot", content: capContent(answer) }]);
       for (const part of splitForQQ(answer)) {
         await deps.reply(ev.groupId, part);
       }

package/tests/bridge.test.ts

@@ -231,7 +231,7 @@ describe("issue pinning", () => {
 });
 
 describe("pure-API chat", () => {
-  const { estimateTokens, trimToContext, buildChatMessages, CHAT_SYSTEM_PROMPT, CHAT_MSG_CHAR_CAP } = require("../src/chat");
+  const { estimateTokens, trimStored, buildChatMessages, CHAT_SYSTEM_PROMPT, CHAT_MSG_CHAR_CAP } = require("../src/chat");
   const turn = (content: string, role: "user" | "assistant" = "user") => ({ role, name: "u", content });
 
   test("estimateTokens grows with length", () => {
@@ -239,27 +239,71 @@ describe("pure-API chat", () => {
     expect(estimateTokens("abcd".repeat(100))).toBeGreaterThan(estimateTokens("abcd"));
   });
 
-  test("trimToContext drops oldest first when over budget", () => {
-    const hist = [turn("a".repeat(1000)), turn("b".repeat(1000)), turn("c".repeat(1000)), turn("d".repeat(1000))];
-    const budget = estimateTokens("c".repeat(1000)) + estimateTokens("d".repeat(1000));
-    const kept = trimToContext(hist, budget, 0);
-    expect(kept.map((t: { content: string }) => t.content[0])).toEqual(["c", "d"]);
+  test("trimStored is a no-op under both limits", () => {
+    const hist = [turn("hi"), turn("yo"), turn("lo")];
+    expect(trimStored(hist, 20, 50000)).toBe(hist);
   });
 
-  test("trimToContext keeps everything under budget", () => {
-    const hist = [turn("hi"), turn("yo")];
-    expect(trimToContext(hist, 100000, 0).length).toBe(2);
+  test("trimStored evicts in bulk on count overflow and is sticky", () => {
+    const mk = (n: number) => Array.from({ length: n }, (_, i) => turn("m" + i));
+    const over = trimStored(mk(41), 20, 5000000);
+    expect(over.length).toBe(Math.max(2, Math.floor(40 * 0.7)));
+    expect(over[over.length - 1].content).toBe("m40");
+    expect(trimStored(over, 20, 5000000)).toBe(over);
+  });
+
+  test("trimStored evicts in bulk on token overflow", () => {
+    const hist = Array.from({ length: 10 }, (_, i) => turn("x".repeat(1000) + i));
+    const per = estimateTokens("x".repeat(1000));
+    const reserve = estimateTokens(CHAT_SYSTEM_PROMPT) + estimateTokens("x".repeat(CHAT_MSG_CHAR_CAP));
+    const budget = reserve + per * 6;
+    const kept = trimStored(hist, 100, budget);
+    expect(kept.length).toBeLessThan(10);
+    const keptTotal = kept.reduce((n: number, t: { content: string }) => n + estimateTokens(t.content), 0);
+    const tokenFloor = Math.floor(per * 6 * 0.7);
+    expect(keptTotal).toBeLessThanOrEqual(tokenFloor + per);
+    expect(kept[kept.length - 1].content.endsWith("9")).toBe(true);
+  });
+
+  test("count cap evicts in bulk too (no sliding window)", () => {
+    const mk = (n: number) => Array.from({ length: n }, (_, i) => turn("m" + i));
+    expect(buildChatMessages(mk(40), turn("q")).length).toBe(42);
+    const over = trimStored(mk(41), 20, 5000000);
+    expect(buildChatMessages(over, turn("q")).length).toBe(Math.floor(40 * 0.7) + 2);
+  });
+
+  test("prompt grows append-only between evictions (prefix cache friendly)", () => {
+    const maxHistory = 3;
+    let hist: { role: "user" | "assistant"; name: string; content: string }[] = [];
+    let prev: { role: string; content: string }[] | null = null;
+    let evictions = 0;
+    for (let i = 0; i < 12; i++) {
+      const turnU = { role: "user" as const, name: "u", content: "q" + i };
+      const trimmed = trimStored(hist, maxHistory, 5000000);
+      if (trimmed !== hist) evictions++;
+      hist = trimmed;
+      const msgs = buildChatMessages(hist, turnU).map((m: { role: string; content: string }) => ({ role: m.role, content: m.content }));
+      if (prev) {
+        const prefixIntact = prev.every((pm, idx) => msgs[idx] && msgs[idx].role === pm.role && msgs[idx].content === pm.content);
+        const grewAppendOnly = msgs.length >= prev.length;
+        if (!grewAppendOnly) evictions++;
+        expect(prefixIntact || !grewAppendOnly).toBe(true);
+      }
+      prev = msgs;
+      hist = [...hist, turnU, { role: "assistant", name: "bot", content: "a" + i }];
+    }
+    expect(evictions).toBeGreaterThan(0);
   });
 
   test("buildChatMessages truncates oversized single message", () => {
-    const msgs = buildChatMessages([], turn("x".repeat(CHAT_MSG_CHAR_CAP + 500)), 20, 50000);
+    const msgs = buildChatMessages([], turn("x".repeat(CHAT_MSG_CHAR_CAP + 500)));
     expect(msgs[msgs.length - 1].content.length).toBeLessThanOrEqual(CHAT_MSG_CHAR_CAP + 10);
     expect(msgs[msgs.length - 1].content).toContain("已截断");
   });
 
   test("buildChatMessages keeps system prompt first and reserves question budget", () => {
     const hist = [turn("a".repeat(40000)), turn("b")];
-    const msgs = buildChatMessages(hist, turn("q"), 20, 50000);
+    const msgs = buildChatMessages(trimStored(hist, 20, 50000), turn("q"));
     expect(msgs[0].role).toBe("system");
     expect(msgs[0].content).toBe(CHAT_SYSTEM_PROMPT);
     const total = msgs.reduce((n: number, m: { content: string }) => n + estimateTokens(m.content), 0);