🤖 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.
Python ai-agentai-assistantchatbotclaudecomputer-usedeepseekdesktop-appdshelectronfeishugeminigptgrokllmlocal-firstmodelflaremulti-modelopenai-compatiblepersonal-ai-agentwechat
/**
* 服务端压缩(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(), tools: new Set(), jobs: new Set(), media: 0, interim: [] });
(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();
});
});