ework-qq-bridge 0.5.1 → 0.5.3

package/package.json

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

package/src/chat-store.ts

@@ -0,0 +1,56 @@
+import { mkdirSync, readFileSync, writeFileSync, renameSync, existsSync } from "node:fs";
+import { dirname } from "node:path";
+import type { ChatTurn } from "./chat";
+
+// Persistent @bot chat history: group -> turns, survives restarts.
+// No trimming here — set() callers must pass already-trimmed arrays
+// (same trimStored policy as before), keeping the file bounded.
+type HistoryFile = Record<string, ChatTurn[]>;
+
+function validTurn(v: unknown): v is ChatTurn {
+  if (typeof v !== "object" || v === null) return false;
+  const t = v as { role?: unknown; content?: unknown };
+  return (t.role === "user" || t.role === "assistant") && typeof t.content === "string";
+}
+
+export class ChatHistoryStore {
+  private history = new Map<number, ChatTurn[]>();
+
+  constructor(private file: string) {
+    try {
+      if (existsSync(file)) {
+        const raw = JSON.parse(readFileSync(file, "utf8")) as HistoryFile;
+        for (const [k, v] of Object.entries(raw)) {
+          if (Number.isInteger(Number(k)) && Array.isArray(v)) {
+            const turns = v.filter(validTurn);
+            if (turns.length > 0) this.history.set(Number(k), turns);
+          }
+        }
+      }
+    } catch (err) {
+      console.warn(`[qq-bridge] chat history file unreadable, starting clean: ${err instanceof Error ? err.message : err}`);
+    }
+  }
+
+  private persist(): void {
+    const out: HistoryFile = {};
+    for (const [g, turns] of this.history) out[String(g)] = turns;
+    try {
+      mkdirSync(dirname(this.file), { recursive: true });
+      const tmp = `${this.file}.tmp`;
+      writeFileSync(tmp, JSON.stringify(out));
+      renameSync(tmp, this.file);
+    } catch (err) {
+      console.error(`[qq-bridge] failed to persist chat history: ${err instanceof Error ? err.message : err}`);
+    }
+  }
+
+  get(groupId: number): ChatTurn[] {
+    return this.history.get(groupId) ?? [];
+  }
+
+  set(groupId: number, turns: ChatTurn[]): void {
+    this.history.set(groupId, turns);
+    this.persist();
+  }
+}

package/src/chat.ts

@@ -76,12 +76,17 @@ export function buildChatMessages(
   ];
 }
 
+export function stripThink(text: string): string {
+  return text.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
+}
+
 export async function chatComplete(
   apiBase: string,
   apiKey: string,
   model: string,
   messages: { role: string; name?: string; content: string }[],
   timeoutMs: number,
+  noThink = true,
 ): Promise<string> {
   const ctrl = new AbortController();
   const timer = setTimeout(() => ctrl.abort(), timeoutMs);
@@ -89,14 +94,18 @@ export async function chatComplete(
     const res = await fetch(`${apiBase.replace(/\/+$/, "")}/chat/completions`, {
       method: "POST",
       headers: { "Content-Type": "application/json", Authorization: `Bearer ${apiKey}` },
-      body: JSON.stringify({ model, messages, max_tokens: 1024, temperature: 0.4 }),
+      body: JSON.stringify(
+        noThink
+          ? { model, messages, max_tokens: 1024, temperature: 0.4, chat_template_kwargs: { enable_thinking: false } }
+          : { model, messages, max_tokens: 1024, temperature: 0.4 },
+      ),
       signal: ctrl.signal,
     });
     if (!res.ok) {
       throw new Error(`LLM ${res.status}: ${(await res.text()).slice(0, 120)}`);
     }
     const data = (await res.json()) as { choices?: { message?: { content?: string } }[] };
-    const text = data.choices?.[0]?.message?.content?.trim();
+    const text = stripThink(data.choices?.[0]?.message?.content ?? "");
     if (!text) throw new Error("LLM returned empty content");
     return text;
   } finally {

package/src/config.ts

@@ -35,6 +35,14 @@ const Schema = z.object({
   // Token budget (heuristic estimate) for one chat request; when history
   // exceeds it the oldest turns are dropped ("满了就清理").
   WORK_CHAT_MAX_CONTEXT: z.coerce.number().int().default(50000),
+  // Disable the model's thinking pass for QQ chat replies only (default on:
+  // "仅仅这个机器人关掉"); "0" restores thinking. Daemon/opencode sessions
+  // are untouched — they use their own runtime.
+  WORK_CHAT_NO_THINK: z.preprocess((v) => (v === undefined || v === "" ? "1" : v), z.string()).transform((v) => v !== "0"),
+
+  // Where @bot chat history is persisted (JSON, group -> turns). Restarting
+  // the bridge no longer clears conversations.
+  WORK_CHAT_HISTORY_FILE: z.string().default(""),
 
   // QQ user_ids allowed to dispatch AI work (comma-separated). Messages from
   // other members are logged and ignored — same trust model as the GitHub
@@ -104,5 +112,8 @@ export function loadConfig(): Config {
   if (!cfg.WORK_BINDINGS_FILE) {
     cfg.WORK_BINDINGS_FILE = `${process.env.HOME ?? "/tmp"}/.ework-qq-bridge/bindings.json`;
   }
+  if (!cfg.WORK_CHAT_HISTORY_FILE) {
+    cfg.WORK_CHAT_HISTORY_FILE = `${process.env.HOME ?? "/tmp"}/.ework-qq-bridge/chat-history.json`;
+  }
   return cfg;
 }

package/src/index.ts

@@ -1,6 +1,7 @@
 import { loadConfig, parseGroupMap, parseList } from "./config";
 import { BridgeStore } from "./db";
 import { BindingStore } from "./bindings";
+import { ChatHistoryStore } from "./chat-store";
 import { createOneBotServer, type OneBotApi, type GroupMessageEvent } from "./onebot";
 import { createRouter } from "./router";
 import { createIngest } from "./ingest";
@@ -16,6 +17,7 @@ async function main() {
 const store = new BridgeStore(cfg.DB_PATH || "/tmp/ework-qq-bridge.db");
 
   const bindings = new BindingStore(parseGroupMap(cfg.GROUP_MAP), cfg.WORK_BINDINGS_FILE);
+  const chatHistory = new ChatHistoryStore(cfg.WORK_CHAT_HISTORY_FILE);
 
   let api: OneBotApi | null = null;
   const send = async (groupId: number, text: string) => {
@@ -28,6 +30,7 @@ const store = new BridgeStore(cfg.DB_PATH || "/tmp/ework-qq-bridge.db");
   const router = createRouter({
     cfg,
     bindings,
+    chatHistory,
     wakeList: new Set(parseList(cfg.QQ_WAKE_LIST)),
     ework,
     store,

package/src/router.ts

@@ -3,6 +3,7 @@ import type { EworkClient } from "./ework";
 import type { GroupMessageEvent } from "./onebot";
 import type { BridgeStore } from "./db";
 import type { BindingStore } from "./bindings";
+import type { ChatHistoryStore } from "./chat-store";
 import { buildChatMessages, capContent, chatComplete, splitForQQ, trimStored, type ChatTurn } from "./chat";
 
 const HELP_TEXT = [
@@ -12,13 +13,14 @@ const HELP_TEXT = [
   "  绑定 #<编号> —— 把本群绑定到该 issue（长记忆模式：此后发言都进这个 issue）",
   "  解绑 —— 恢复为项目模式（接收整个项目的回复）",
   "  查询 —— 列出最近 issue",
-  "  @我 <问题> —— 即时问答（纯 API，不留 issue，上下文满自动清理）",
+  "  @我 <问题> —— 即时问答（纯 API 直连 bili 压缩，历史落盘，重启不清）",
   "  （绑定后：普通发言进绑定的 issue，AI 回复自动回群）",
 ].join("\n");
 
 export interface RouterDeps {
   cfg: Config;
   bindings: BindingStore;
+  chatHistory: ChatHistoryStore;
   wakeList: Set<string>;
   ework: EworkClient;
   store: BridgeStore;
@@ -47,16 +49,14 @@ export function parseCommand(raw: string): ParsedCommand | null {
 }
 
 export function createRouter(deps: RouterDeps) {
-  const { cfg, bindings, wakeList, ework, store } = deps;
-  const chatHistory = new Map<number, ChatTurn[]>();
+  const { cfg, bindings, chatHistory, wakeList, ework, store } = deps;
 
   async function answerChat(ev: GroupMessageEvent, question: string): Promise<void> {
     try {
       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 stored = trimStored(chatHistory.get(ev.groupId), cfg.WORK_CHAT_MAX_HISTORY, cfg.WORK_CHAT_MAX_CONTEXT);
       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);
+      const answer = await chatComplete(cfg.WORK_CHAT_API, cfg.WORK_CHAT_API_KEY, cfg.WORK_CHAT_MODEL, messages, cfg.WORK_CHAT_TIMEOUT_MS, cfg.WORK_CHAT_NO_THINK);
       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

@@ -1,9 +1,11 @@
 import { describe, test, expect } from "bun:test";
 import { parseCommand } from "../src/router";
 import { BindingStore } from "../src/bindings";
+import { ChatHistoryStore } from "../src/chat-store";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
 const pinFile = () => `${tmpdir()}/qqb-test-${randomUUID()}.json`;
+const histFile = () => `${tmpdir()}/qqb-hist-${randomUUID()}.json`;
 import { parseGroupMap, parseList } from "../src/config";
 import { buildScrubber } from "../src/scrub";
 import { verifySignature } from "../src/ingest";
@@ -88,6 +90,7 @@ describe("@bot unified routing", () => {
     const router = createRouter({
       cfg: { VERBOSE: false },
       bindings: bs,
+      chatHistory: new ChatHistoryStore(histFile()),
       wakeList: new Set(["1"]),
       ework: { createIssue: async () => 9, addComment: async (o: string, r: string, n: number, b: string) => { comments.push([o, r, n, b]); } },
       store: { seenPost: () => false },
@@ -180,6 +183,7 @@ describe("issue pinning", () => {
     const router = createRouter({
       cfg: { VERBOSE: false },
       bindings: new BindingStore([{ groupId: 1, owner: "o", repo: "r", issue: 7 }], pinFile()),
+      chatHistory: new ChatHistoryStore(histFile()),
       wakeList: new Set(["1"]),
       ework: { createIssue: async () => 9, addComment: async (o: string, r: string, n: number, b: string) => { comments.push([o, r, n, b]); } },
       store: { seenPost: () => false },
@@ -324,6 +328,7 @@ describe("pure-API chat", () => {
       const router = createRouter({
         cfg: { VERBOSE: false, WORK_CHAT_API: "http://x/v1", WORK_CHAT_API_KEY: "k", WORK_CHAT_MODEL: "m", WORK_CHAT_TIMEOUT_MS: 1000, WORK_CHAT_MAX_HISTORY: 20, WORK_CHAT_MAX_CONTEXT: 50000 },
         bindings: new BindingStore([{ groupId: 1, owner: "o", repo: "r", issue: 7 }], pinFile()),
+        chatHistory: new ChatHistoryStore(histFile()),
         wakeList: new Set(["1"]),
         ework: { createIssue: async () => 9, addComment: async (...a: unknown[]) => { comments.push(a); } },
         store: { seenPost: () => false },
@@ -349,6 +354,7 @@ describe("pure-API chat", () => {
       const router = createRouter({
         cfg: { VERBOSE: false, WORK_CHAT_API: "http://x/v1", WORK_CHAT_API_KEY: "k", WORK_CHAT_MODEL: "m", WORK_CHAT_TIMEOUT_MS: 1000, WORK_CHAT_MAX_HISTORY: 20, WORK_CHAT_MAX_CONTEXT: 50000 },
         bindings: new BindingStore([{ groupId: 1, owner: "o", repo: "r" }], pinFile()),
+        chatHistory: new ChatHistoryStore(histFile()),
         wakeList: new Set(["1"]),
         ework: { createIssue: async () => 9, addComment: async () => {} },
         store: { seenPost: () => false },
@@ -361,3 +367,129 @@ describe("pure-API chat", () => {
     }
   });
 });
+
+describe("no-think", () => {
+  const { stripThink } = require("../src/chat");
+
+  test("stripThink removes inline think blocks", () => {
+    expect(stripThink("<think>internal</think>答案")).toBe("答案");
+    expect(stripThink("<think>a</think>前<think>b</think>后")).toBe("前后");
+    expect(stripThink("普通回复")).toBe("普通回复");
+  });
+
+  test("chat request carries enable_thinking:false by default", async () => {
+    const origFetch = globalThis.fetch;
+    let sent: Record<string, unknown> = {};
+    globalThis.fetch = (async (_u: unknown, init?: { body?: string }) => {
+      sent = JSON.parse(String(init?.body));
+      return new Response(JSON.stringify({ choices: [{ message: { content: "ok" } }] }), { status: 200 });
+    }) as typeof fetch;
+    try {
+      const { chatComplete } = require("../src/chat");
+      const out = await chatComplete("http://x/v1", "k", "m", [{ role: "user", content: "q" }], 1000);
+      expect(out).toBe("ok");
+      expect((sent.chat_template_kwargs as { enable_thinking?: boolean })?.enable_thinking).toBe(false);
+      await chatComplete("http://x/v1", "k", "m", [{ role: "user", content: "q" }], 1000, false);
+      expect(sent.chat_template_kwargs).toBeUndefined();
+    } finally {
+      globalThis.fetch = origFetch;
+    }
+  });
+
+  test("thinking payload is stripped before replying", async () => {
+    const origFetch = globalThis.fetch;
+    globalThis.fetch = (async () => new Response(JSON.stringify({ choices: [{ message: { content: "<think>隐藏推理</think>可见答案" } }] }), { status: 200 })) as typeof fetch;
+    try {
+      const { createRouter } = require("../src/router");
+      const replies: string[] = [];
+      const router = createRouter({
+        cfg: { VERBOSE: false, WORK_CHAT_API: "http://x/v1", WORK_CHAT_API_KEY: "k", WORK_CHAT_MODEL: "m", WORK_CHAT_TIMEOUT_MS: 1000, WORK_CHAT_MAX_HISTORY: 20, WORK_CHAT_MAX_CONTEXT: 50000, WORK_CHAT_NO_THINK: true },
+        bindings: new BindingStore([{ groupId: 1, owner: "o", repo: "r" }], pinFile()),
+        chatHistory: new ChatHistoryStore(histFile()),
+        wakeList: new Set(["1"]),
+        ework: { createIssue: async () => 9, addComment: async () => {} },
+        store: { seenPost: () => false },
+        reply: async (_g: number, x: string) => { replies.push(x); },
+      });
+      await router.handleGroupMessage({ groupId: 1, userId: 1, nickname: "u", postId: "nt1", rawMessage: "[CQ:at,qq=2661222094] 问" });
+      expect(replies).toEqual(["可见答案"]);
+    } finally {
+      globalThis.fetch = origFetch;
+    }
+  });
+});
+
+describe("chat history persistence", () => {
+  const { ChatHistoryStore } = require("../src/chat-store");
+  const { trimStored } = require("../src/chat");
+  const { writeFileSync } = require("node:fs");
+
+  test("set then reload returns same turns", () => {
+    const f = histFile();
+    const a = new ChatHistoryStore(f);
+    a.set(1, [{ role: "user", content: "早" }, { role: "assistant", content: "早呀" }]);
+    a.set(2, [{ role: "user", content: "群二的问题" }]);
+    const b = new ChatHistoryStore(f);
+    expect(b.get(1)).toEqual([{ role: "user", content: "早" }, { role: "assistant", content: "早呀" }]);
+    expect(b.get(2)).toEqual([{ role: "user", content: "群二的问题" }]);
+    expect(b.get(3)).toEqual([]);
+  });
+
+  test("invalid file starts clean", () => {
+    const f = histFile();
+    writeFileSync(f, "{not json");
+    const s = new ChatHistoryStore(f);
+    expect(s.get(1)).toEqual([]);
+    s.set(1, [{ role: "user", content: "x" }]);
+    expect(new ChatHistoryStore(f).get(1)).toEqual([{ role: "user", content: "x" }]);
+  });
+
+  test("invalid turns filtered on load, groups isolated", () => {
+    const f = histFile();
+    writeFileSync(f, JSON.stringify({ "1": [{ role: "system", content: "bad" }, { role: "user", content: "ok" }], "2": "nope" }));
+    const s = new ChatHistoryStore(f);
+    expect(s.get(1)).toEqual([{ role: "user", content: "ok" }]);
+    expect(s.get(2)).toEqual([]);
+  });
+
+  test("evicted turns stay evicted across reload", () => {
+    const f = histFile();
+    const turns = Array.from({ length: 50 }, (_, i) => ({ role: "user" as const, content: `msg${i}` }));
+    const trimmed = trimStored(turns, 10, 500000);
+    expect(trimmed.length).toBeLessThan(50);
+    new ChatHistoryStore(f).set(7, trimmed);
+    const re = new ChatHistoryStore(f);
+    expect(re.get(7)).toEqual(trimmed);
+    const again = trimStored(re.get(7), 10, 500000);
+    expect(again.length).toBe(trimmed.length);
+  });
+
+  test("router chat survives simulated restart", async () => {
+    const origFetch = globalThis.fetch;
+    globalThis.fetch = (async () => new Response(JSON.stringify({ choices: [{ message: { content: "第一答" } }] }), { status: 200 })) as typeof fetch;
+    try {
+      const { createRouter } = require("../src/router");
+      const f = histFile();
+      const mk2 = () => {
+        const replies: string[] = [];
+        const router = createRouter({
+          cfg: { VERBOSE: false, WORK_CHAT_API: "http://x/v1", WORK_CHAT_API_KEY: "k", WORK_CHAT_MODEL: "m", WORK_CHAT_TIMEOUT_MS: 1000, WORK_CHAT_MAX_HISTORY: 20, WORK_CHAT_MAX_CONTEXT: 50000 },
+          bindings: new BindingStore([{ groupId: 1, owner: "o", repo: "r", issue: 7 }], pinFile()),
+          chatHistory: new ChatHistoryStore(f),
+          wakeList: new Set(["1"]),
+          ework: { createIssue: async () => 9, addComment: async () => {} },
+          store: { seenPost: () => false },
+          reply: async (_g: number, x: string) => { replies.push(x); },
+        });
+        return { router, replies };
+      };
+      const first = mk2();
+      await first.router.handleGroupMessage({ groupId: 1, userId: 1, nickname: "u", postId: "r1", rawMessage: "[CQ:at,qq=2661222094] 记住暗号是西瓜" });
+      const second = mk2();
+      await second.router.handleGroupMessage({ groupId: 1, userId: 1, nickname: "u", postId: "r2", rawMessage: "[CQ:at,qq=2661222094] 我刚才说了什么" });
+      expect(new ChatHistoryStore(f).get(1).map((t: { content: string }) => t.content)).toContain("记住暗号是西瓜");
+    } finally {
+      globalThis.fetch = origFetch;
+    }
+  });
+});