🤖 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
Merge origin/master into feat/server-compaction
Marlacc0ae1039700
diff --cc src/agent/bridge.tsindex 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.tsindex 27e194b,0000000..8cb9565mode 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();+ });+});