Skip to content

🤖 Open-source, local-first alternative to Grok Bot, OpenAI dots and Claude Duet. Your own AI bots on any model: GPT, Claude, Gemini, Grok, DeepSeek, Kimi, GLM and 70+ more through one Modelflare key. Reach them in the app, WeChat or Feishu; they remember you, work in the background, run commands and use your computer. Pay per use.

Merge origin/master into feat/server-compaction

Marlacc0ae1039700
diff --cc src/agent/bridge.ts
index 9ff5236,19c65df..cd3c93d
--- a/src/agent/bridge.ts
+++ b/src/agent/bridge.ts
@@@ -3,9 -3,10 +3,11 @@@ import crypto from "node:crypto"
import { Readable } from "node:stream";
import type { AddressInfo } from "node:net";
import { logger, redactText, registerSecret } from "../log.js";
+import { peekStream, type CompactionPlan, type ServerCompaction } from "./server-compaction.js";
const log = logger("agent.bridge");
+ /** 长调用的保活间隔:远小于 fetch 默认的 5 分钟数据间隔超时 */
+ const KEEPALIVE_MS = 60_000;
export interface BridgeHandlers {
/** 模型上游(magpie 网关或外部端点),密钥只在本进程内使用 */
diff --cc test/server-compaction.unit.test.ts
index 27e194b,0000000..8cb9565
mode 100644,000000..100644
--- a/test/server-compaction.unit.test.ts
+++ b/test/server-compaction.unit.test.ts
@@@ -1,813 -1,0 +1,813 @@@
+/**
+ * 服务端压缩(server-compaction.ts):前缀匹配与改写、探测与缓存、各种失败时的退回,以及经真实 bridge 的整条路径。
+ * 上游是按 OpenAI 文档行为写的 mock:/v1/responses/compact 保留用户消息并给出一个带密文的 compaction 项;
+ * /v1/responses 只接受这个 mock 给同一模型签出的压缩项。另有 grok 模式,照 Modelflare 实测的样子回(见 GROK_*)。
+ */
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { listen } from "./helpers.js";
+import { AgentBridge, type Rejection } from "../src/agent/bridge.js";
+import { shapeRejection } from "../src/agent/api-fallback.js";
+import { closeFileLog, initFileLog, readLogTail } from "../src/log.js";
+import { AgentManager } from "../src/agent/manager.js";
+import { ActivityLog } from "../src/agent/activity.js";
+import { Store } from "../src/store/db.js";
+import { locateDshRuntime } from "../src/agent/host.js";
+import { MagpieSupervisor, findAppRoot } from "../src/magpie/supervisor.js";
+import { loadModelInfo } from "../src/account/model-info.js";
+import {
+ ServerCompaction,
+ compactLine,
+ compactedWindow,
+ estimateTokens,
+ peekStream,
+ prefixHashes,
+ splitLead,
+ sseVerdict,
+ usageOf,
+ type CompactionEvent,
+} from "../src/agent/server-compaction.js";
+
+const LEAD = { role: "developer", content: "SYSTEM PROMPT" };
+const TOOLS = [{ type: "function", name: "bash", description: "run", parameters: { type: "object", properties: { command: { type: "string" } }, required: ["command"] }, strict: false }];
+const user = (t: string) => ({ role: "user", content: [{ type: "input_text", text: t }] });
+/** 一次工具调用(约 1000 tokens 的输出) */
+const call = (i: number) => [
+ { type: "reasoning", id: `rs_${i}`, summary: [], encrypted_content: `R${i}` },
+ { type: "function_call", id: `fc_${i}`, call_id: `call_${i}`, name: "bash", arguments: JSON.stringify({ command: `ls ${i}` }) },
+ { type: "function_call_output", call_id: `call_${i}`, output: `${i}`.padEnd(3000, "x") },
+];
+const calls = (from: number, to: number) => Array.from({ length: to - from + 1 }, (_, k) => call(from + k)).flat();
+/** pi-ai 发出的 Responses 请求形状 */
+const req = (model: string, items: unknown[], session = "sess-1", lead: unknown[] = [LEAD]) => ({
+ model,
+ input: [...lead, ...items],
+ stream: true,
+ prompt_cache_key: session,
+ store: false,
+ tools: TOOLS,
+ reasoning: { effort: "medium", summary: "auto" },
+ include: ["reasoning.encrypted_content"],
+});
+const buf = (j: unknown) => Buffer.from(JSON.stringify(j));
+const HEADERS = { session_id: "sess-1" };
+
+/**
+ * Modelflare 上 grok-4.5 / 4.7 实测:/v1/responses/compact 回 200,object 是 "response",output 只有一个 compaction 项
+ * (不保留用户消息),推理很重;而任何 /v1/responses 请求的 input 里只要带着这个项就回下面这个 400。
+ */
+const GROK_REJECT = { error: { message: "无效的参数 (request id: 2026103112000012345678)", type: "invalid_request_error", param: "", code: "invalid_request" } };
+const GROK_USAGE = { input_tokens: 812, output_tokens: 3400, output_tokens_details: { reasoning_tokens: 3100 }, total_tokens: 4212, cost_in_usd_ticks: 187_000_000 };
+
+interface MockState {
+ /** grok:Modelflare 实测的回复;big:compaction 项比原输入还大;slow:晚 50ms 才回 */
+ compact: "ok" | "404" | "badshape" | "503" | "grok" | "big" | "slow";
+ /** grok:带 compaction 项的 /v1/responses 一律回 GROK_REJECT;429:带 compaction 项的回 429 */
+ items: "ok" | "reject" | "streamfail" | "grok" | "429";
+ /** reject:所有 /v1/responses 都按"参数不支持"回 400(代理接口回退会认的那种) */
+ responses: "ok" | "reject";
+ /** 回复里报的 input_tokens = 估算 × boost */
+ boost: number;
+ /** 助手回复的文字 */
+ reply: string;
+}
+
+/** 按文档行为的上游:记下每个请求 */
+async function mockUpstream() {
+ const state: MockState = { compact: "ok", items: "ok", responses: "ok", boost: 1, reply: "ok" };
+ const seen: Array<{ path: string; auth?: string; body: any }> = [];
+ let n = 0;
+ const srv = await listen(async (req, res) => {
+ let raw = "";
+ for await (const c of req) raw += c;
+ const body = raw ? JSON.parse(raw) : {};
+ const p = String(req.url).split("?")[0];
+ seen.push({ path: p, auth: req.headers.authorization, body });
+ const name = String(body.model ?? "").split("/").pop();
+ const json = (status: number, j: unknown) => res.writeHead(status, { "content-type": "application/json" }).end(JSON.stringify(j));
+ if (p === "/v1/responses/compact") {
+ if (state.compact === "404") return json(404, { error: { message: "Invalid URL (POST /v1/responses/compact)", type: "invalid_request_error" } });
+ if (state.compact === "503") return json(503, { error: { message: "upstream overloaded" } });
+ if (state.compact === "grok" || state.compact === "big") {
+ const enc = `ENC.${name}.${++n}.` + (state.compact === "big" ? "E".repeat(raw.length * 2) : "gAAAAB");
+ const item = { type: "compaction", id: `cmp_${n}`, status: "completed", summary: "The user asked for the code word; lookup returned teal.", encrypted_content: enc };
+ return json(200, { id: `resp_c${n}`, object: "response", created_at: 1, status: "completed", model: name, output: [item], usage: GROK_USAGE });
+ }
+ if (state.compact === "slow") await new Promise((r) => setTimeout(r, 50));
+ // 保留用户(和 developer)消息,其余压进一个 compaction 项
+ const kept = body.input.filter((it: any) => it.role === "user" || it.role === "developer").map((it: any, i: number) => ({ id: `msg_${i}`, type: "message", status: "completed", ...it }));
+ const output = state.compact === "badshape" ? kept : [...kept, { type: "compaction", id: `cmp_${++n}`, encrypted_content: `ENC.${name}.${n}` }];
+ return json(200, { id: `resp_c${n}`, object: "response.compaction", created_at: 1, output, usage: { input_tokens: 1000, output_tokens: 100, total_tokens: 1100 } });
+ }
+ if (p !== "/v1/responses") return json(404, { error: { message: "not found" } });
+ const sealed = (body.input as any[]).filter((it) => it?.type === "compaction");
+ if (sealed.length) {
+ if (state.items === "grok") return json(400, GROK_REJECT);
+ if (state.items === "429") return json(429, { error: { message: "slow down", type: "rate_limit_error" } });
+ if (state.items === "reject") return json(400, { error: { message: "Invalid value: 'compaction'. Supported values are: 'message', 'reasoning', ...", type: "invalid_request_error" } });
+ if (sealed.some((it) => String(it.encrypted_content).split(".")[1] !== name)) return json(400, { error: { message: "The encrypted content could not be decrypted", code: "invalid_encrypted_content" } });
+ }
+ if (state.responses === "reject") return json(400, { error: { message: "Unsupported parameter: 'reasoning.summary' is not supported with this model.", type: "invalid_request_error", code: "unsupported_parameter" } });
+ const input_tokens = Math.round(estimateTokens(body.input) * state.boost);
+ const usage = { input_tokens, output_tokens: 10, total_tokens: input_tokens + 10 };
+ const output = [{ type: "message", id: `msg_out${seen.length}`, role: "assistant", status: "completed", content: [{ type: "output_text", text: state.reply, annotations: [] }] }];
+ if (!body.stream) return json(200, { id: "resp_1", object: "response", status: "completed", output, usage });
+ res.writeHead(200, { "content-type": "text/event-stream" });
+ const ev = (o: any) => res.write(`event: ${o.type}\ndata: ${JSON.stringify(o)}\n\n`);
+ ev({ type: "response.created", response: { id: "resp_1", status: "in_progress" } });
+ if (sealed.length && state.items === "streamfail") {
+ ev({ type: "error", code: "invalid_request_error", message: "compaction item not supported" });
+ return res.end();
+ }
+ ev({ type: "response.output_item.added", output_index: 0, item: { ...output[0], content: [] } });
+ ev({ type: "response.output_text.delta", output_index: 0, content_index: 0, delta: state.reply });
+ ev({ type: "response.output_item.done", output_index: 0, item: output[0] });
+ ev({ type: "response.completed", response: { id: "resp_1", status: "completed", output, usage } });
+ res.end();
+ });
+ return { ...srv, state, seen, of: (p: string) => seen.filter((s) => s.path === p) };
+}
+
+let dir = "";
+let mock: Awaited<ReturnType<typeof mockUpstream>>;
+const env = { ...process.env };
+
+function make(o: { listed?: boolean | undefined; key?: string; now?: () => number; events?: CompactionEvent[] } = {}) {
+ return new ServerCompaction({
+ dir,
+ upstream: () => ({ baseUrl: mock.url + "/v1", apiKey: "gateway-key" }),
+ endpoint: (model) => ({ baseUrl: mock.url + "/v1", apiKey: o.key ?? "mf-key-1", model: model.split("/").pop()!, headers: { "x-skill": "t" } }),
+ listed: async () => ("listed" in o ? o.listed : true),
+ limits: async () => ({ window: 400_000, maxTokens: 32_000 }),
+ onEvent: (e) => o.events?.push(e),
+ now: o.now,
+ });
+}
+
+/** 发一次请求(先让窗口大小等后台信息就位),等后台任务结束 */
+async function send(sc: ServerCompaction, body: unknown, headers: Record<string, string> = HEADERS) {
+ const plan = sc.prepare("/v1/responses", headers, buf(body));
+ await sc.settled();
+ return plan;
+}
+
+beforeEach(async () => {
+ dir = fs.mkdtempSync(path.join(os.tmpdir(), "amb-sc-"));
+ mock = await mockUpstream();
+ process.env.AMB_SERVER_COMPACTION_TOKENS = "4000";
+ delete process.env.AMB_SERVER_COMPACTION;
+});
+afterEach(async () => {
+ process.env = { ...env };
+ await mock.close();
+ fs.rmSync(dir, { recursive: true, force: true });
+});
+
+describe("服务端压缩:纯函数", () => {
+ it("压缩线:不超过 20 万、窗口一半,并且在 DSH 自己的压缩线之前;太小的窗口不做", () => {
+ delete process.env.AMB_SERVER_COMPACTION_TOKENS;
+ expect(compactLine(1_050_000, 32_000)).toBe(200_000);
+ expect(compactLine(400_000, 32_000)).toBe(200_000);
+ // 256k:DSH 在 min(204.8k, 158.5k) 压缩,服务端压缩要在它之前
+ expect(compactLine(256_000, 32_000)).toBe(128_000);
+ expect(compactLine(200_000, 32_000)).toBeLessThan(200_000 - 32_000 - 65_536);
+ expect(compactLine(64_000, 16_000)).toBe(0);
+ process.env.AMB_SERVER_COMPACTION_TOKENS = "1234";
+ expect(compactLine(1_050_000, 32_000)).toBe(1234);
+ });
+
+ it("估算偏大:中文按字节,密文和图片单算", () => {
+ expect(estimateTokens([user("a".repeat(3000))])).toBeGreaterThanOrEqual(1000);
+ expect(estimateTokens([user("中".repeat(1000))])).toBeGreaterThanOrEqual(1000);
+ expect(estimateTokens([{ type: "compaction", encrypted_content: "x".repeat(4000) }])).toBeGreaterThanOrEqual(1000);
+ expect(estimateTokens([{ role: "user", content: [{ type: "input_image", image_url: "data:image/png;base64," + "A".repeat(500_000) }] }])).toBeLessThan(2000);
+ });
+
+ it("开头的 system / developer 消息是系统提示,不算进历史哈希", () => {
+ const { lead, rest } = splitLead([LEAD, { role: "system", content: "x" }, user("hi"), { role: "developer", content: "mid" }]);
+ expect(lead).toHaveLength(2);
+ expect(rest).toEqual([user("hi"), { role: "developer", content: "mid" }]);
+ // 逐项累计:前缀相同哈希就相同,任何一项不同之后都不同
+ const a = prefixHashes([user("1"), user("2"), user("3")]);
+ const b = prefixHashes([user("1"), user("2"), user("X")]);
+ expect(a).toHaveLength(4);
+ expect(a.slice(0, 3)).toEqual(b.slice(0, 3));
+ expect(a[3]).not.toBe(b[3]);
+ });
+
+ it("压缩回复的校验:要有带密文的 compaction 项;object 是 response.compaction、response(Modelflare 实测)或没有", () => {
+ const ok = { object: "response.compaction", output: [user("hi"), { type: "compaction", id: "cmp_1", encrypted_content: "gAAA" }] };
+ expect(compactedWindow(ok)).toEqual(ok.output);
+ expect(compactedWindow({ output: ok.output })).toEqual(ok.output);
+ expect(compactedWindow({ ...ok, object: "response" })).toEqual(ok.output);
+ // grok:object 是 response,output 只有一个 compaction 项(带 status、summary)
+ const grok = { id: "resp_c1", object: "response", status: "completed", output: [{ type: "compaction", id: "cmp_1", status: "completed", summary: "s", encrypted_content: "gAAA" }], usage: GROK_USAGE };
+ expect(compactedWindow(grok)).toEqual(grok.output);
+ expect(compactedWindow({ ...ok, object: "list" })).toBeUndefined();
+ expect(compactedWindow({ ...grok, status: "failed" })).toBeUndefined();
+ expect(compactedWindow({ ...grok, error: { message: "x" } })).toBeUndefined();
+ expect(compactedWindow({ ...grok, error: null })).toEqual(grok.output);
+ expect(compactedWindow({ object: "response.compaction", output: [user("hi")] })).toBeUndefined();
+ expect(compactedWindow({ object: "response.compaction", output: [{ type: "compaction", encrypted_content: "" }] })).toBeUndefined();
+ expect(compactedWindow({ object: "response.compaction", output: [1, { type: "compaction", encrypted_content: "x" }] })).toBeUndefined();
+ expect(compactedWindow({ error: { message: "x" } })).toBeUndefined();
+ // 用量与费用(日志用)
+ expect(usageOf(grok)).toEqual({ input: 812, output: 3400, reasoning: 3100, costTicks: 187_000_000 });
+ expect(usageOf({ usage: { input_tokens: 5 } })).toEqual({ input: 5 });
+ expect(usageOf({ output: [] })).toBeUndefined();
+ });
+
+ it("流开头的判断:created / in_progress 之后看第一个实质事件", async () => {
+ const ev = (o: any) => `event: ${o.type}\ndata: ${JSON.stringify(o)}\n\n`;
+ expect(sseVerdict(ev({ type: "response.created" }))).toBe("wait");
+ expect(sseVerdict(ev({ type: "response.created" }) + ev({ type: "response.output_item.added" }))).toBe("ok");
+ expect(sseVerdict(ev({ type: "response.created" }) + ev({ type: "error", message: "bad item" }))).toEqual({ error: "bad item" });
+ expect(sseVerdict(ev({ type: "response.failed", response: { error: { message: "nope" } } }))).toEqual({ error: "nope" });
+ expect(sseVerdict('data: {"type":"response.output_text.delta"')).toBe("wait");
+ // 看过开头后交出去的流从第一个字节开始
+ const enc = new TextEncoder();
+ const parts = [ev({ type: "response.created" }), ev({ type: "response.output_text.delta", delta: "a" }), ev({ type: "response.completed" })];
+ const src = new ReadableStream<Uint8Array>({ start: (c) => (parts.forEach((p) => c.enqueue(enc.encode(p))), c.close()) });
+ const peek = await peekStream(src);
+ expect(peek.error).toBeUndefined();
+ expect(await new Response(peek.stream).text()).toBe(parts.join(""));
+ });
+});
+
+describe("服务端压缩:探测、压缩与改写", () => {
+ it("先探测一次,过线后在后台压缩,之后同一会话的请求把这段历史换成压缩窗口(系统提示用当次的)", async () => {
+ const events: CompactionEvent[] = [];
+ const sc = make({ events });
+ const M = "mf/good";
+ // 短对话:不探测、不改写
+ expect((await send(sc, req(M, [user("start"), ...calls(1, 1)])))!.rewritten).toBe(false);
+ expect(mock.seen).toHaveLength(0);
+ // 过了压缩线的一半:探测(直连压缩 + 经网关续接)
+ await send(sc, req(M, [user("start"), ...calls(1, 3)]));
+ const [probeCompact] = mock.of("/v1/responses/compact");
+ expect(probeCompact.body.model).toBe("good");
+ expect(probeCompact.auth).toBe("Bearer mf-key-1");
+ const [follow] = mock.of("/v1/responses");
+ expect(follow.auth).toBe("Bearer gateway-key");
+ expect(follow.body).toMatchObject({ model: M, store: false, stream: false });
+ expect(follow.body.input.at(-2)).toMatchObject({ type: "compaction" });
+ expect(sc.status()[M]).toMatchObject({ ok: true });
+ // 过了压缩线:后台压缩这次请求的全部输入
+ const h3 = [user("start"), ...calls(1, 5)];
+ const p3 = await send(sc, req(M, h3));
+ expect(p3!.rewritten).toBe(false);
+ const compact = mock.of("/v1/responses/compact")[1];
+ expect(compact.body).toEqual({ model: "good", input: [LEAD, ...h3], tools: TOOLS });
+ expect(events).toEqual([expect.objectContaining({ session: "sess-1", model: M, ok: true })]);
+ expect(events[0].after!).toBeLessThan(events[0].before);
+ // 往后长的历史:开头这段换成压缩窗口(窗口里重复的系统提示去掉),新增的原样接上
+ const p4 = await send(sc, req(M, [...h3, ...call(6)], "sess-1", [{ role: "developer", content: "SYSTEM PROMPT v2" }]));
+ expect(p4!.rewritten).toBe(true);
+ const sent = JSON.parse(p4!.body.toString());
+ expect(sent.input).toEqual([
+ { role: "developer", content: "SYSTEM PROMPT v2" },
+ { id: "msg_1", type: "message", status: "completed", ...user("start") },
+ { type: "compaction", id: "cmp_2", encrypted_content: "ENC.good.2" },
+ ...call(6),
+ ]);
+ expect(sent).toMatchObject({ model: M, tools: TOOLS, store: false, prompt_cache_key: "sess-1" });
+ // 上游接受改写后的请求
+ const up = await fetch(mock.url + "/v1/responses", { method: "POST", body: new Uint8Array(p4!.body) });
+ expect(up.status).toBe(200);
+ p4!.accepted();
+ });
+
+ it("历史开头对不上、换了模型或 Key 都原样发;重启后从磁盘读回映射", async () => {
+ const sc = make();
+ const M = "mf/good";
+ const h = [user("start"), ...calls(1, 5)];
+ await send(sc, req(M, h.slice(0, 1)));
+ await send(sc, req(M, [user("start"), ...calls(1, 3)]));
+ await send(sc, req(M, h));
+ expect(mock.of("/v1/responses/compact")).toHaveLength(2);
+ // 中间改了一项(例如 DSH 自己压缩过):原样
+ const edited = [...h];
+ edited[3] = { ...(edited[3] as any), output: "changed" };
+ expect(sc.prepare("/v1/responses", HEADERS, buf(req(M, [...edited, ...call(6)])))!.rewritten).toBe(false);
+ // 同一会话换了模型(那个模型自己也探测通过了):不把别的模型压出来的项发过去
+ const probed = async (s: ServerCompaction, model: string) => {
+ for (const n of [0, 3]) await send(s, req(model, [user("probe"), ...calls(1, n)], "sess-probe"), { session_id: "sess-probe" });
+ expect(s.status()[model]).toMatchObject({ ok: true });
+ };
+ await probed(sc, "mf/other");
+ expect(sc.prepare("/v1/responses", HEADERS, buf(req("mf/other", [...h, ...call(6)])))!.rewritten).toBe(false);
+ expect(sc.prepare("/v1/responses", HEADERS, buf(req(M, [...h, ...call(6)])))!.rewritten).toBe(true);
+ // 同一模型换了 Key(可能换了账户;新 Key 也探测通过了)
+ const other = make({ key: "mf-key-2" });
+ await probed(other, M);
+ expect(other.prepare("/v1/responses", HEADERS, buf(req(M, [...h, ...call(6)])))!.rewritten).toBe(false);
+ await sc.settled();
+ await other.settled();
+ // 应用重启:探测结果和映射都在磁盘上
+ const again = make();
+ const plan = again.prepare("/v1/responses", HEADERS, buf(req(M, [...h, ...call(6)])));
+ expect(plan!.rewritten).toBe(true);
+ expect(JSON.parse(plan!.body.toString()).input.filter((it: any) => it.type === "compaction")).toHaveLength(1);
+ // 没有 prompt_cache_key 时按会话头找
+ const { prompt_cache_key: _k, ...noKey } = req(M, [...h, ...call(6)]);
+ expect(again.prepare("/v1/responses", HEADERS, buf(noKey))!.rewritten).toBe(true);
+ await again.settled();
+ });
+
+ it("目录没列出(或不知道)就不探测,也不改写", async () => {
+ for (const listed of [false, undefined]) {
+ const sc = make({ listed });
+ for (const n of [1, 3, 5, 7]) await send(sc, req("mf/good", [user("start"), ...calls(1, n)]));
+ expect(mock.seen).toHaveLength(0);
+ }
+ });
+
+ it("压缩端点 404 / 回复里没有压缩项:记为不支持,存盘,7 天内不再探测", async () => {
+ let now = 1_800_000_000_000;
+ for (const mode of ["404", "badshape"] as const) {
+ mock.state.compact = mode;
+ mock.seen.length = 0;
+ fs.rmSync(path.join(dir, "probe.json"), { force: true });
+ const sc = make({ now: () => now });
+ await send(sc, req("mf/good", [user("start")]));
+ for (const n of [3, 5, 7]) await send(sc, req("mf/good", [user("start"), ...calls(1, n)]));
+ expect(mock.of("/v1/responses/compact"), mode).toHaveLength(1);
+ expect(mock.of("/v1/responses"), mode).toHaveLength(0);
+ expect(sc.status()["mf/good"]).toMatchObject({ ok: false, reason: expect.stringMatching(mode === "404" ? /^probe: compact call failed: HTTP 404: Invalid URL/ : /^probe: compact call failed: no usable compaction item/) });
+ // 重启后仍记得;一天、六天后都不探测,过了 7 天重新探测
+ const again = make({ now: () => now });
+ await send(again, req("mf/good", [user("start"), ...calls(1, 8)]));
+ expect(mock.of("/v1/responses/compact"), mode).toHaveLength(1);
+ for (const days of [1, 5]) {
+ now += days * 24 * 3600_000;
+ await send(again, req("mf/good", [user("start"), ...calls(1, 9)]));
+ expect(mock.of("/v1/responses/compact"), mode).toHaveLength(1);
+ }
+ now += 25 * 3600_000;
+ await send(again, req("mf/good", [user("start"), ...calls(1, 9)]));
+ await send(again, req("mf/good", [user("start"), ...calls(1, 9)]));
+ expect(mock.of("/v1/responses/compact"), mode).toHaveLength(2);
+ }
+ });
+
+ it("续接请求不收压缩项:探测不通过", async () => {
+ mock.state.items = "reject";
+ const sc = make();
+ await send(sc, req("mf/good", [user("start")]));
+ for (const n of [3, 5, 7]) await send(sc, req("mf/good", [user("start"), ...calls(1, n)]));
+ expect(sc.status()["mf/good"]).toMatchObject({ ok: false, reason: expect.stringContaining("follow-up /v1/responses carrying its compaction item was rejected (HTTP 400): Invalid value: 'compaction'") });
+ expect(mock.of("/v1/responses/compact")).toHaveLength(1);
+ });
+
+ it("临时失败(5xx)不记结论,10 分钟后再探测;连着失败等得更久", async () => {
+ let now = 1_800_000_000_000;
+ mock.state.compact = "503";
+ const sc = make({ now: () => now });
+ await send(sc, req("mf/good", [user("start")]));
+ await send(sc, req("mf/good", [user("start"), ...calls(1, 3)]));
+ await send(sc, req("mf/good", [user("start"), ...calls(1, 5)]));
+ expect(mock.of("/v1/responses/compact")).toHaveLength(1);
+ expect(sc.status()).toEqual({});
+ now += 11 * 60_000;
+ await send(sc, req("mf/good", [user("start"), ...calls(1, 6)]));
+ expect(mock.of("/v1/responses/compact")).toHaveLength(2);
+ // 第二次失败后等 20 分钟
+ now += 11 * 60_000;
+ await send(sc, req("mf/good", [user("start"), ...calls(1, 7)]));
+ expect(mock.of("/v1/responses/compact")).toHaveLength(2);
+ mock.state.compact = "ok";
+ now += 10 * 60_000;
+ await send(sc, req("mf/good", [user("start"), ...calls(1, 8)]));
+ expect(mock.of("/v1/responses/compact")).toHaveLength(3);
+ expect(sc.status()["mf/good"]).toMatchObject({ ok: true });
+ });
+
+ it("grok(Modelflare 实测):压缩调用能过,带着 compaction 项续接被拒 → 不支持,原因写明是续接被拒;用量记日志;7 天内不再探测", async () => {
+ const logDir = fs.mkdtempSync(path.join(os.tmpdir(), "amb-sc-log-"));
+ initFileLog(logDir);
+ try {
+ let now = 1_800_000_000_000;
+ mock.state.compact = "grok";
+ mock.state.items = "grok";
+ const events: CompactionEvent[] = [];
+ const sc = make({ now: () => now, events });
+ const M = "modelflare/grok-4.7";
+ await send(sc, req(M, [user("start")]));
+ for (const n of [3, 5, 7]) await send(sc, req(M, [user("start"), ...calls(1, n)]));
+ // 一次压缩调用 + 一次续接,就此定论
+ expect(mock.of("/v1/responses/compact")).toHaveLength(1);
+ expect(mock.of("/v1/responses/compact")[0].body.model).toBe("grok-4.7");
+ const follow = mock.of("/v1/responses");
+ expect(follow).toHaveLength(1);
+ expect(follow[0].body.input.filter((it: any) => it.type === "compaction")).toEqual([expect.objectContaining({ id: "cmp_1", encrypted_content: "ENC.grok-4.7.1.gAAAAB" })]);
+ const v = sc.status()[M];
+ expect(v.ok).toBe(false);
+ expect(v.reason).toBe("probe: compact call ok, but the follow-up /v1/responses carrying its compaction item was rejected (HTTP 400): 无效的参数 (request id: 2026103112000012345678)");
+ expect(v.reason).not.toContain("no usable compaction item");
+ // 不压缩、不改写
+ expect(events).toEqual([]);
+ expect(sc.prepare("/v1/responses", HEADERS, buf(req(M, [user("start"), ...calls(1, 8)])))!.rewritten).toBe(false);
+ // 用量和费用记进日志
+ const logs = readLogTail(100, logDir).join("\n");
+ expect(logs).toMatch(/server compaction probe: compact call ok .*"usage":\{"input":812,"output":3400,"reasoning":3100,"costTicks":187000000\}/);
+ expect(logs).toMatch(/server compaction probe: follow-up rejected .*"status":400/);
+ // 别的会话、重启以后也一样:7 天内不再探测
+ const again = make({ now: () => now });
+ for (const days of [0, 1, 5]) {
+ now += days * 24 * 3600_000;
+ await send(again, req(M, [user("other"), ...calls(1, 6)], `sess-${days}`), { session_id: `sess-${days}` });
+ await send(again, req(M, [user("other"), ...calls(1, 7)], `sess-${days}`), { session_id: `sess-${days}` });
+ }
+ expect(mock.of("/v1/responses/compact")).toHaveLength(1);
+ now += 25 * 3600_000;
+ await send(again, req(M, [user("other"), ...calls(1, 8)], "sess-5"), { session_id: "sess-5" });
+ expect(mock.of("/v1/responses/compact")).toHaveLength(2);
+ expect(again.status()[M]).toMatchObject({ ok: false, reason: expect.stringContaining("follow-up /v1/responses carrying its compaction item was rejected") });
+ } finally {
+ closeFileLog();
+ fs.rmSync(logDir, { recursive: true, force: true });
+ }
+ });
+
+ it("同一模型 + Key 同时只探测一次(几个会话一起过线)", async () => {
+ const sc = make();
+ const M = "mf/good";
+ await send(sc, req(M, [user("warm")], "warm"), { session_id: "warm" });
+ mock.state.compact = "slow";
+ for (const s of ["a", "b", "c", "d"]) sc.prepare("/v1/responses", { session_id: s }, buf(req(M, [user(s), ...calls(1, 3)], s)));
+ await sc.settled();
+ for (const s of ["a", "b"]) sc.prepare("/v1/responses", { session_id: s }, buf(req(M, [user(s), ...calls(1, 3)], s)));
+ await sc.settled();
+ expect(mock.of("/v1/responses/compact")).toHaveLength(1);
+ expect(mock.of("/v1/responses")).toHaveLength(1);
+ expect(sc.status()[M]).toMatchObject({ ok: true });
+ });
+
+ it("压缩窗口只有一个 compaction 项(不保留用户消息)也照常用:系统提示 + 这一项 + 之后新增的", async () => {
+ mock.state.compact = "grok";
+ const events: CompactionEvent[] = [];
+ const sc = make({ events });
+ const M = "mf/good";
+ const h = [user("start"), ...calls(1, 5)];
+ for (const items of [h.slice(0, 1), [user("start"), ...calls(1, 3)], h]) await send(sc, req(M, items));
+ expect(sc.status()[M]).toMatchObject({ ok: true });
+ expect(events).toEqual([expect.objectContaining({ ok: true })]);
+ expect(events[0].after!).toBeLessThan(events[0].before * 0.7);
+ const plan = sc.prepare("/v1/responses", HEADERS, buf(req(M, [...h, ...call(6)])))!;
+ expect(plan.rewritten).toBe(true);
+ expect(JSON.parse(plan.body.toString()).input).toEqual([LEAD, { type: "compaction", id: "cmp_2", status: "completed", summary: expect.any(String), encrypted_content: "ENC.good.2.gAAAAB" }, ...call(6)]);
+ await sc.settled();
+ });
+
+ it("压缩后要小三成:很大的 compaction 项不用、半小时内这个会话不再压;系统提示和工具占一半以上时先不压", async () => {
+ let now = 1_800_000_000_000;
+ const events: CompactionEvent[] = [];
+ mock.state.compact = "big";
+ const sc = make({ now: () => now, events });
+ const M = "mf/good";
+ const h = [user("start"), ...calls(1, 5)];
+ for (const items of [h.slice(0, 1), [user("start"), ...calls(1, 3)], h]) await send(sc, req(M, items));
+ expect(mock.of("/v1/responses/compact")).toHaveLength(2);
+ expect(events).toEqual([expect.objectContaining({ ok: false, error: expect.stringContaining("not smaller") })]);
+ expect((await send(sc, req(M, [...h, ...call(6)])))!.rewritten).toBe(false);
+ expect(mock.of("/v1/responses/compact")).toHaveLength(2);
+ // 不是临时失败:过了 10 分钟也不重压,半小时后再压(这次压得小)
+ mock.state.compact = "grok";
+ now += 11 * 60_000;
+ await send(sc, req(M, [...h, ...calls(6, 7)]));
+ expect(mock.of("/v1/responses/compact")).toHaveLength(2);
+ now += 20 * 60_000;
+ await send(sc, req(M, [...h, ...calls(6, 8)]));
+ expect(mock.of("/v1/responses/compact")).toHaveLength(3);
+ expect(events.at(-1)).toMatchObject({ ok: true });
+
+ // 系统提示占了大半:过了线也先不压,等历史长到一半以上
+ const bigLead = [{ role: "developer", content: "S".repeat(30_000) }];
+ const lead = (n: number) => send(sc, req(M, [user("lead-heavy"), ...calls(1, n)], "sess-lead", bigLead), { session_id: "sess-lead" });
+ for (const n of [1, 2, 3, 4]) await lead(n);
+ expect(mock.of("/v1/responses/compact")).toHaveLength(3);
+ await lead(14);
+ await lead(15);
+ expect(mock.of("/v1/responses/compact")).toHaveLength(4);
+ });
+
+ it("改写过的请求被拒、原请求能过:这段映射作废,记下不支持,之后不再改写", async () => {
+ const sc = make();
+ const h = [user("start"), ...calls(1, 5)];
+ await send(sc, req("mf/good", h.slice(0, 1)));
+ await send(sc, req("mf/good", [user("start"), ...calls(1, 3)]));
+ await send(sc, req("mf/good", h));
+ const plan = sc.prepare("/v1/responses", HEADERS, buf(req("mf/good", [...h, ...call(6)])))!;
+ expect(plan.rewritten).toBe(true);
+ // 5xx 一次:映射还留着
+ plan.rejected(502, "bad gateway", true);
+ expect(sc.prepare("/v1/responses", HEADERS, buf(req("mf/good", [...h, ...call(6)])))!.rewritten).toBe(true);
+ plan.rejected(400, "Invalid value: 'compaction'", true);
+ expect(sc.status()["mf/good"]).toMatchObject({ ok: false });
+ expect(sc.prepare("/v1/responses", HEADERS, buf(req("mf/good", [...h, ...calls(6, 7)])))!.rewritten).toBe(false);
+ await sc.settled();
+ });
+
+ it("历史不是往后长的(例如 DSH 的摘要请求)不触发压缩;压出来没被用上的会话半小时内不再压", async () => {
+ const sc = make();
+ await send(sc, req("mf/good", [user("start")]));
+ await send(sc, req("mf/good", [user("start"), ...calls(1, 3)]));
+ // 和上一次不是同一段历史
+ await send(sc, req("mf/good", [user("other start"), ...calls(1, 5)]));
+ expect(mock.of("/v1/responses/compact")).toHaveLength(1);
+ await send(sc, req("mf/good", [user("other start"), ...calls(1, 6)]));
+ expect(mock.of("/v1/responses/compact")).toHaveLength(2);
+ // 压完以后历史开头又变了(映射用不上),还在线上:不反复压
+ for (const n of [7, 8, 9]) await send(sc, req("mf/good", [user("third"), ...calls(1, n)]));
+ expect(mock.of("/v1/responses/compact")).toHaveLength(2);
+ });
+
+ it("AMB_SERVER_COMPACTION=0 整个关掉;不是无状态 Responses 请求的不碰", async () => {
+ const sc = make();
+ const body = req("mf/good", [user("start"), ...calls(1, 5)]);
+ expect(sc.prepare("/v1/chat/completions", HEADERS, buf(body))).toBeUndefined();
+ expect(sc.prepare("/v1/responses", HEADERS, buf({ ...body, store: true }))).toBeUndefined();
+ expect(sc.prepare("/v1/responses", HEADERS, buf({ ...body, previous_response_id: "resp_1" }))).toBeUndefined();
+ expect(sc.prepare("/v1/responses", HEADERS, buf({ ...body, context_management: [{ type: "compaction", compact_threshold: 1000 }] }))).toBeUndefined();
+ expect(sc.prepare("/v1/responses", HEADERS, Buffer.from("not json"))).toBeUndefined();
+ expect(sc.prepare("/v1/responses", HEADERS, buf(body))).toBeDefined();
+ process.env.AMB_SERVER_COMPACTION = "0";
+ expect(sc.prepare("/v1/responses", HEADERS, buf(body))).toBeUndefined();
+ await sc.settled();
+ });
+});
+
+describe("服务端压缩:经 bridge", () => {
+ async function bridgeWith(sc: ServerCompaction) {
+ const bridge = new AgentBridge({
+ upstream: () => ({ baseUrl: mock.url + "/v1", apiKey: "gateway-key" }),
+ ask: async () => ({ id: "" }),
+ wait: async () => ({}),
+ cancel: async () => {},
+ compaction: sc,
+ });
+ await bridge.start();
+ const post = async (body: unknown) => {
+ const r = await fetch(`${bridge.url}/v1/responses`, { method: "POST", headers: { authorization: `Bearer ${bridge.token}`, "content-type": "application/json", session_id: "sess-1" }, body: JSON.stringify(body) });
+ const text = await r.text();
+ await sc.settled();
+ return { status: r.status, text };
+ };
+ return { bridge, post };
+ }
+
+ /** 让会话走到"已压缩":返回下一次请求会被改写的历史 */
+ async function compacted(post: (b: unknown) => Promise<{ status: number; text: string }>) {
+ const h = [user("start"), ...calls(1, 5)];
+ for (const items of [h.slice(0, 1), [user("start"), ...calls(1, 3)], h]) expect((await post(req("mf/good", items))).status).toBe(200);
+ expect(mock.of("/v1/responses/compact")).toHaveLength(2);
+ return [...h, ...call(6)];
+ }
+
+ it("改写后的请求经 bridge 发出;上游拒绝压缩项时用原请求重发一次,回合照常,之后不再改写", async () => {
+ const sc = make();
+ const { bridge, post } = await bridgeWith(sc);
+ try {
+ const h = await compacted(post);
+ let r = await post(req("mf/good", h));
+ expect(r.status).toBe(200);
+ expect(r.text).toContain("response.completed");
+ const last = mock.of("/v1/responses").at(-1)!;
+ expect(last.auth).toBe("Bearer gateway-key");
+ expect(last.body.input.some((it: any) => it.type === "compaction")).toBe(true);
+ // 上游(换了渠道等)不再收压缩项:bridge 重发原请求,DSH 看到的是成功
+ mock.state.items = "reject";
+ const before = mock.of("/v1/responses").length;
+ r = await post(req("mf/good", [...h, ...call(7)]));
+ expect(r.status).toBe(200);
+ expect(r.text).toContain("response.completed");
+ const [rejected, original] = mock.of("/v1/responses").slice(before);
+ expect(rejected.body.input.some((it: any) => it.type === "compaction")).toBe(true);
+ expect(original.body.input).toEqual(req("mf/good", [...h, ...call(7)]).input);
+ expect(sc.status()["mf/good"]).toMatchObject({ ok: false });
+ // 之后原样发
+ r = await post(req("mf/good", [...h, ...calls(7, 8)]));
+ expect(r.status).toBe(200);
+ expect(mock.of("/v1/responses").at(-1)!.body.input.some((it: any) => it.type === "compaction")).toBe(false);
+ } finally {
+ await bridge.stop();
+ }
+ });
+
+ it("改写过的请求被拒不报给代理接口回退(不会让模型改走 Chat);原请求重发成功,回合照常", async () => {
+ const sc = make();
+ const { bridge, post } = await bridgeWith(sc);
+ const seen: Rejection[] = [];
+ const off = bridge.onRejection((r) => void seen.push(r));
+ try {
+ const h = await compacted(post);
+ // 上游像 Modelflare 那样:带 compaction 项就 400「无效的参数」,原请求能过
+ mock.state.items = "grok";
+ const before = mock.of("/v1/responses").length;
+ const r = await post(req("mf/good", h));
+ expect(r.status).toBe(200);
+ const [rewritten, original] = mock.of("/v1/responses").slice(before);
+ expect(rewritten.body.input.some((it: any) => it.type === "compaction")).toBe(true);
+ expect(original.body.input.some((it: any) => it.type === "compaction")).toBe(false);
+ expect(seen).toEqual([]);
+ expect(sc.status()["mf/good"]).toMatchObject({ ok: false, reason: expect.stringContaining("rewritten request rejected (400): 无效的参数") });
+ } finally {
+ off();
+ await bridge.stop();
+ }
+ });
+
+ it("改写过的请求被拒、原请求重发后也被拒(请求形状的问题):只报原请求那次,代理接口回退照常认", async () => {
+ const sc = make();
+ const { bridge, post } = await bridgeWith(sc);
+ const seen: Rejection[] = [];
+ const off = bridge.onRejection((r) => void seen.push(r));
+ try {
+ const h = await compacted(post);
+ mock.state.items = "grok";
+ mock.state.responses = "reject";
+ const before = mock.of("/v1/responses").length;
+ const r = await post(req("mf/good", h));
+ expect(r.status).toBe(400);
+ expect(r.text).toContain("Unsupported parameter");
+ expect(mock.of("/v1/responses").slice(before).map((s) => s.body.input.some((it: any) => it.type === "compaction"))).toEqual([true, false]);
+ expect(seen).toHaveLength(1);
+ expect(seen[0]).toMatchObject({ path: "/v1/responses", status: 400 });
+ expect(seen[0].error).toContain("Unsupported parameter");
+ expect(seen[0].error).not.toContain("无效的参数");
+ expect(shapeRejection(seen, "")).toMatch(/^HTTP 400: Unsupported parameter/);
+ // 原请求也不过:不是压缩项的问题,映射丢掉但不记"不支持"
+ expect(sc.status()["mf/good"]).toMatchObject({ ok: true });
+ } finally {
+ off();
+ await bridge.stop();
+ }
+ });
+
+ it("改写过的请求遇到 429:不重发、原样交给 DSH(它会重试),也不报给代理接口回退", async () => {
+ const sc = make();
+ const { bridge, post } = await bridgeWith(sc);
+ const seen: Rejection[] = [];
+ const off = bridge.onRejection((r) => void seen.push(r));
+ try {
+ const h = await compacted(post);
+ mock.state.items = "429";
+ const before = mock.of("/v1/responses").length;
+ expect((await post(req("mf/good", h))).status).toBe(429);
+ expect(mock.of("/v1/responses").length - before).toBe(1);
+ expect(seen).toEqual([]);
+ // 原样发的请求被拒照常报
+ mock.state.responses = "reject";
+ expect((await post(req("mf/good", [user("fresh")]))).status).toBe(400);
+ expect(seen).toHaveLength(1);
+ } finally {
+ off();
+ await bridge.stop();
+ }
+ });
+
+ it("流一开头就报错(还没交出任何字节):同样用原请求重发", async () => {
+ const sc = make();
+ const { bridge, post } = await bridgeWith(sc);
+ try {
+ const h = await compacted(post);
+ mock.state.items = "streamfail";
+ const before = mock.of("/v1/responses").length;
+ const r = await post(req("mf/good", h));
+ expect(r.status).toBe(200);
+ expect(r.text).not.toContain("compaction item not supported");
+ expect(r.text).toContain("response.completed");
+ expect(mock.of("/v1/responses").length - before).toBe(2);
+ expect(sc.status()["mf/good"]).toMatchObject({ ok: false, reason: expect.stringContaining("stream error") });
+ } finally {
+ await bridge.stop();
+ }
+ });
+
+ it("上游报的用量也算进压缩线(估算偏小时不至于压得太晚)", async () => {
+ const sc = make();
+ const { bridge, post } = await bridgeWith(sc);
+ try {
+ mock.state.boost = 3;
+ await post(req("mf/good", [user("start")]));
+ await post(req("mf/good", [user("start"), ...calls(1, 2)]));
+ expect(sc.status()["mf/good"]).toMatchObject({ ok: true });
+ // 估算还不到 4000,但上一次回复报了约三倍的用量
+ const next = req("mf/good", [user("start"), ...calls(1, 2), user("x")]);
+ expect(estimateTokens(next.input) + estimateTokens(next.tools)).toBeLessThan(4000);
+ await post(next);
+ expect(mock.of("/v1/responses/compact")).toHaveLength(2);
+ } finally {
+ await bridge.stop();
+ }
+ });
+});
+
+const runtime = locateDshRuntime(findAppRoot());
+const piAi = runtime ? path.join(runtime, "node_modules", "@earendil-works", "pi-ai") : "";
+
+describe("服务端压缩:DSH 用的 pi-ai 客户端", () => {
+ it.skipIf(!runtime || !fs.existsSync(piAi))("pi-ai 的真实请求经 bridge:过线后压缩、之后的请求带压缩窗口,回合不受影响", async () => {
+ const { stream } = await import(pathToFileURL(path.join(piAi, "dist", "api", "openai-responses.js")).href);
+ const { normalizeContext } = await import(pathToFileURL(path.join(piAi, "dist", "utils", "transcript.js")).href);
+ const sc = make();
+ const bridge = new AgentBridge({ upstream: () => ({ baseUrl: mock.url + "/v1", apiKey: "gateway-key" }), ask: async () => ({ id: "" }), wait: async () => ({}), cancel: async () => {}, compaction: sc });
+ await bridge.start();
+ try {
+ const model = { id: "mf/good", name: "good", api: "openai-responses", provider: "magpie", baseUrl: `${bridge.url}/v1`, reasoning: true, input: ["text"], cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, contextWindow: 400_000, maxTokens: 32_000 };
+ const tools = [{ name: "bash", description: "run", parameters: { type: "object", properties: { command: { type: "string" } }, required: ["command"] } }];
+ const messages: any[] = [];
+ // 长回复、短提问:压缩只保留用户消息,压完明显变小
+ mock.state.reply = "ok " + "z".repeat(3000);
+ for (let turn = 1; turn <= 8; turn++) {
+ messages.push({ role: "user", content: `turn ${turn}`, timestamp: turn });
+ let out: any;
+ for await (const e of stream(model, normalizeContext({ systemPrompt: "SYSTEM PROMPT", messages, tools }), { apiKey: bridge.token, sessionId: "sess-pi", reasoningEffort: "medium" })) {
+ if (e.type === "done") out = e.message;
+ if (e.type === "error") throw new Error(e.error.errorMessage);
+ }
+ expect(out.content.find((c: any) => c.type === "text")?.text).toBe(mock.state.reply);
+ messages.push(out);
+ await sc.settled();
+ }
+ const compacts = mock.of("/v1/responses/compact");
+ expect(compacts.length).toBeGreaterThanOrEqual(2);
+ // 真实请求(stream:true)里,压缩之后的那些带着压缩项、developer 系统提示在最前
+ const real = mock.of("/v1/responses").filter((s) => s.body.stream);
+ const withItem = real.filter((s) => s.body.input.some((it: any) => it.type === "compaction"));
+ expect(withItem.length).toBeGreaterThan(0);
+ for (const s of withItem) {
+ expect(s.body.input[0]).toEqual({ role: "developer", content: "SYSTEM PROMPT" });
+ expect(s.body.prompt_cache_key).toBe("sess-pi");
+ expect(s.body.input.at(-1)).toEqual({ role: "user", content: [{ type: "input_text", text: expect.stringMatching(/^turn \d+$/) }] });
+ }
+ // 改写后发往上游的比 DSH 发来的小
+ expect(estimateTokens(withItem.at(-1)!.body.input)).toBeLessThan(estimateTokens(normalizeContext({ systemPrompt: "SYSTEM PROMPT", messages, tools }).messages));
+ } finally {
+ await bridge.stop();
+ }
+ });
+});
+
+describe("服务端压缩:活动记录与模型资料", () => {
+ it("压缩做完时,正在进行回合的会话多一步「服务端压缩上下文」", () => {
+ const store = new Store(":memory:");
+ const mgr = new AgentManager({
+ store,
+ dataDir: dir,
+ runtimeDir: undefined,
+ upstream: () => ({ baseUrl: "", apiKey: "" }),
+ enabled: false,
+ serverCompaction: { listed: async () => true, endpoint: () => undefined },
+ });
+ expect(mgr.serverCompaction).toBeDefined();
+ store.setAgentSession("c1", "b1", "sess-1");
+ const activity = new ActivityLog();
- mgr.turnsInProgress.set("c1", { botId: "b1", since: 0, lastProgress: 0, activity, abort: new AbortController() });
++ mgr.turnsInProgress.set("c1", { botId: "b1", since: 0, lastProgress: 0, activity, abort: new AbortController(), tools: new Set(), media: 0 });
+ (mgr as any).onServerCompaction({ session: "sess-1", model: "mf/good", ok: true, before: 210_000, after: 31_000, at: 1000, ms: 4200 });
+ (mgr as any).onServerCompaction({ session: "sess-1", model: "mf/good", ok: false, before: 210_000, at: 2000, ms: 10, error: "HTTP 404" });
+ (mgr as any).onServerCompaction({ session: "other", model: "mf/good", ok: true, before: 1, after: 1, at: 3000, ms: 1 });
+ expect(activity.steps).toEqual([{ id: "sc1000", kind: "compact", title: "服务端压缩上下文", summary: "约 210k → 31k tokens", status: "ok", at: 1000, ms: 4200 }]);
+ expect(mgr.stewardLog.map((l) => l.action)).toEqual(["server-compact", "server-compact-failed"]);
+ });
+
+ it("内置网关的 provider 打开 nativeCompaction:只保存一次,失败后 10 分钟内不再试", async () => {
+ const sup = new MagpieSupervisor({ dataDir: dir });
+ const cfg = path.join(dir, "magpie", "config", "magpie");
+ fs.mkdirSync(cfg, { recursive: true });
+ const write = (p: Record<string, unknown>) => fs.writeFileSync(path.join(cfg, "providers.json"), JSON.stringify({ providers: [{ id: "modelflare", chat: "https://mf/v1", ...p }] }));
+ write({});
+ const saves: unknown[] = [];
+ let fail = true;
+ (sup as any).saveProvider = async (id: string, patch: Record<string, unknown>) => {
+ saves.push([id, patch]);
+ await new Promise((r) => setTimeout(r, 5));
+ if (fail) throw new Error("save refused");
+ write(patch);
+ };
+ expect(sup.nativeCompaction("modelflare")).toBe(false);
+ const both = await Promise.allSettled([sup.ensureNativeCompaction("modelflare"), sup.ensureNativeCompaction("modelflare")]);
+ expect(both.map((r) => r.status)).toEqual(["rejected", "rejected"]);
+ expect(saves).toEqual([["modelflare", { nativeCompaction: true }]]);
+ await sup.ensureNativeCompaction("modelflare");
+ expect(saves).toHaveLength(1);
+ // 冷却过后再试,成功后不再保存
+ (sup as any).nativeFailedAt.clear();
+ fail = false;
+ await sup.ensureNativeCompaction("modelflare");
+ expect(sup.nativeCompaction("modelflare")).toBe(true);
+ await sup.ensureNativeCompaction("modelflare");
+ expect(saves).toHaveLength(2);
+ });
+
+ it("模型资料带上价格目录的 supported_endpoint_types", async () => {
+ const fetchImpl = (async () =>
+ Response.json({ data: [{ model_name: "gpt-6.1-terra", quota_type: 0, supported_endpoint_types: ["openai", "openai-response", "openai-response-compact"] }, { model_name: "grok-4.7", quota_type: 0 }] })) as any;
+ const info = await loadModelInfo({ baseUrl: "http://mf/v1", apiKey: "", headers: {}, pricingUrl: "http://mf/api/pricing", fetchImpl });
+ expect(info["gpt-6.1-terra"].endpoints).toEqual(["openai", "openai-response", "openai-response-compact"]);
+ expect(info["grok-4.7"]?.endpoints).toBeUndefined();
+ });
+});