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.

feat(agent): server-side compaction for long Responses sessions

Marla584000a6c24d
diff --git a/src/account/model-info.ts b/src/account/model-info.ts
index 0611a58..9985c5e 100644
--- a/src/account/model-info.ts
+++ b/src/account/model-info.ts
@@ -12,6 +12,8 @@ export interface ModelInfo {
tools?: boolean;
reasoning?: boolean;
price?: { input?: number; output?: number; perCall?: number };
+ /** 价格目录的 supported_endpoint_types(openai、openai-response、openai-response-compact…) */
+ endpoints?: string[];
}
interface Profile {
@@ -33,6 +35,7 @@ export interface PricingEntry {
billing_mode?: string;
pricing_rules?: unknown;
sale_price_multiplier?: number;
+ supported_endpoint_types?: string[];
}
export interface PricingCatalog {
@@ -93,6 +96,7 @@ export async function loadModelInfo(o: {
for (const entry of catalog?.data ?? []) {
const price = referencePrice(entry, catalog!);
if (price) out[entry.model_name] = { ...out[entry.model_name], price };
+ if (Array.isArray(entry.supported_endpoint_types)) out[entry.model_name] = { ...out[entry.model_name], endpoints: entry.supported_endpoint_types.map(String) };
// 没有 Key(拿不到 model-profiles)时,上下文长度用公开目录里的
if (Number(entry.context_window) > 0 && !out[entry.model_name]?.context) out[entry.model_name] = { ...out[entry.model_name], context: Number(entry.context_window) };
}
diff --git a/src/agent/activity.ts b/src/agent/activity.ts
index 1504ce3..0125ee2 100644
--- a/src/agent/activity.ts
+++ b/src/agent/activity.ts
@@ -148,6 +148,12 @@ export class ActivityLog {
if (prev) this.put({ ...prev, status: "ok", ms: Math.max(0, time - prev.at) });
return true;
}
+ // bridge 在后台让上游压缩了这个会话的历史(不是 DSH 事件,见 server-compaction.ts);不算代理有进展
+ case "server-compaction": {
+ const k = (n: unknown) => `${Math.round((Number(n) || 0) / 1000)}k`;
+ this.put({ id: `sc${time}`, kind: "compact", title: "服务端压缩上下文", summary: `约 ${k(data.before)} → ${k(data.after)} tokens`, status: "ok", at: time, ms: Number(data.ms) || undefined });
+ return false;
+ }
case "subagent/started":
this.put({ id: `s${data.childSessionId}`, kind: "subagent", title: "子代理", status: "running", at: time });
return true;
diff --git a/src/agent/bridge.ts b/src/agent/bridge.ts
index cbef5c9..b05f96c 100644
--- a/src/agent/bridge.ts
+++ b/src/agent/bridge.ts
@@ -3,6 +3,7 @@ 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");
@@ -18,6 +19,8 @@ export interface BridgeHandlers {
steward?(body: any): Promise<unknown>;
/** amb-media 插件:生图 / 生视频 */
media?(body: any): Promise<unknown>;
+ /** 服务端压缩:长会话的 /v1/responses 换上上游压缩过的历史(见 server-compaction.ts) */
+ compaction?: ServerCompaction;
}
/** 模型代理的一次请求(故障排查的"测试代理"用它判断模型调用这一步) */
@@ -126,9 +129,19 @@ export class AgentBridge {
res.on("close", () => ac.abort());
// 上游迟迟不回响应头时每分钟记一条:代理"一直转圈"多半是这里卡住(代理自己要等 5 分钟才判超时并重试)
const slow = setInterval(() => log.warn("model request still waiting for upstream response", { path: p, waitedMs: Date.now() - t0 }), 60_000);
+ const send = (b: Buffer | undefined) => fetch(target, { method: req.method, headers, body: b ? new Uint8Array(b) : undefined, signal: ac.signal });
+ let plan: CompactionPlan | undefined;
+ if (body && req.method === "POST" && this.h.compaction) {
+ try {
+ plan = this.h.compaction.prepare(p, req.headers, body);
+ } catch (e) {
+ log.warn("server compaction skipped", { message: (e as Error).message });
+ }
+ }
let r: Response;
try {
- r = await fetch(target, { method: req.method, headers, body: body ? new Uint8Array(body) : undefined, signal: ac.signal });
+ r = await send(plan?.body ?? body);
+ if (plan?.rewritten) r = await this.checkRewritten(plan, r, () => send(body), p);
} catch (e) {
const error = (e as Error).message;
this.emitProxy({ phase: "error", id, path: p, ms: Date.now() - t0, error });
@@ -155,7 +168,10 @@ export class AgentBridge {
if (!r.body) return void res.end();
const stream = Readable.fromWeb(r.body as any);
let bytes = 0;
- stream.on("data", (c: Buffer) => (bytes += c.length));
+ stream.on("data", (c: Buffer) => {
+ bytes += c.length;
+ plan?.observe(c);
+ });
stream.on("end", () => log.info("model request done", { path: p, status: r.status, headersMs, totalMs: Date.now() - t0, bytes }));
stream.on("error", (e) => {
// 子进程读完 [DONE] 就断开时上游流会被中止(res close → abort),这不是错误
@@ -166,6 +182,32 @@ export class AgentBridge {
stream.pipe(res);
}
+ /**
+ * 改写过(换上压缩历史)的请求:被拒(4xx/5xx,Key 与限流问题除外)或流一开头就报错时,用原请求重发一次,
+ * 回合照常进行;server-compaction 据此记下这个模型不支持。
+ */
+ private async checkRewritten(plan: CompactionPlan, r: Response, original: () => Promise<Response>, p: string): Promise<Response> {
+ if (r.status >= 400 && r.status !== 401 && r.status !== 429) {
+ const text = await r.text().catch(() => "");
+ log.warn("compacted model request rejected, resending the original", { path: p, status: r.status, body: redactText(text.slice(0, 500)) });
+ const again = await original();
+ plan.rejected(r.status, text, again.status < 400);
+ return again;
+ }
+ if (r.status < 300 && r.body && /event-stream/i.test(r.headers.get("content-type") ?? "")) {
+ const peek = await peekStream(r.body as ReadableStream<Uint8Array>);
+ if (peek.error !== undefined) {
+ log.warn("compacted model request failed at stream start, resending the original", { path: p, error: redactText(peek.error) });
+ const again = await original();
+ plan.rejected(0, peek.error, again.status < 400);
+ return again;
+ }
+ r = new Response(peek.stream, { status: r.status, statusText: r.statusText, headers: r.headers });
+ }
+ if (r.status < 400) plan.accepted();
+ return r;
+ }
+
private async dsh(req: http.IncomingMessage, res: http.ServerResponse, url: string): Promise<void> {
if (req.method !== "POST") return void res.writeHead(405).end();
const raw = await this.readBody(req);
diff --git a/src/agent/manager.ts b/src/agent/manager.ts
index 1bf3ad3..b4ba8aa 100644
--- a/src/agent/manager.ts
+++ b/src/agent/manager.ts
@@ -3,7 +3,8 @@ import type { Store } from "../store/db.js";
import { logger } from "../log.js";
import { AgentBridge } from "./bridge.js";
import path from "node:path";
-import { AgentHost, TurnStopped, callDetail, type TurnInput, type TurnObserver, type TurnUsage } from "./host.js";
+import { AgentHost, TurnStopped, callDetail, modelLimits, type TurnInput, type TurnObserver, type TurnUsage } from "./host.js";
+import { ServerCompaction, type CompactEndpoint, type CompactionEvent } from "./server-compaction.js";
import { ActivityLog, type ActivityStep } from "./activity.js";
import type { MediaModel, MediaPlan, MediaService } from "./media.js";
import { APPROVAL_TTL_MS, ApprovalCenter, type QuestionItem } from "./approvals.js";
@@ -44,6 +45,14 @@ export interface AgentManagerOptions {
onNotice?: (text: string) => void;
/** 模型的上下文长度(Modelflare 模型资料),写进 DSH 补丁 */
contextWindow?: (model: string) => Promise<number | undefined>;
+ /**
+ * 服务端压缩(见 server-compaction.ts):listed = 价格目录是否列出该模型的压缩端点(只是提示,用前还要探测);
+ * endpoint = 该模型(网关里的名字)直连的压缩端点。缺省则不做。
+ */
+ serverCompaction?: {
+ listed(model: string): Promise<boolean | undefined>;
+ endpoint(model: string): CompactEndpoint | undefined;
+ };
}
/** 一个进行中的回合(/status、/stop、排队提示、信息面板和故障排查用) */
@@ -92,8 +101,22 @@ export class AgentManager {
/** 最近一次管家/整理结果(状态页展示) */
readonly stewardLog: Array<{ at: number; conversationId: string; action: string; detail: string }> = [];
+ /** 服务端压缩(经 bridge 改写长会话的 Responses 请求);没有注入时为空 */
+ readonly serverCompaction: ServerCompaction | undefined;
+
constructor(private o: AgentManagerOptions) {
this.approvals = new ApprovalCenter(o.store, { ttlMs: o.approvalTtlMs });
+ const sc = o.serverCompaction;
+ this.serverCompaction = sc
+ ? new ServerCompaction({
+ dir: path.join(o.dataDir, "dsh", "server-compaction"),
+ upstream: o.upstream,
+ endpoint: (model) => sc.endpoint(model),
+ listed: (model) => sc.listed(model),
+ limits: async (model) => modelLimits(model, await o.contextWindow?.(model).catch(() => undefined)),
+ onEvent: (e) => this.onServerCompaction(e),
+ })
+ : undefined;
this.bridge = new AgentBridge({
upstream: o.upstream,
ask: (b) => this.ask(b),
@@ -102,6 +125,7 @@ export class AgentManager {
memory: (b) => this.memoryOp(b),
steward: (b) => this.stewardCall(b),
media: (b) => this.mediaOp(b),
+ compaction: this.serverCompaction,
});
this.memory = new MemoryStore(path.join(o.dataDir, "memory"));
}
@@ -292,6 +316,14 @@ export class AgentManager {
log.info("steward", { conversationId, action, detail: detail.slice(0, 200) });
}
+ /** 服务端压缩做完:记进管家日志;会话正在进行回合时在活动记录里加一步(失败只记日志,请求照常发) */
+ private onServerCompaction(e: CompactionEvent): void {
+ const conv = e.session ? this.o.store.conversationForSession(e.session) : undefined;
+ if (!conv) return;
+ this.note(conv, e.ok ? "server-compact" : "server-compact-failed", `${e.model} ≈${e.before}${e.after !== undefined ? `→${e.after}` : ""} tokens${e.error ? `: ${e.error}` : ""}`);
+ if (e.ok) this.turnsInProgress.get(conv)?.activity.apply("server-compaction", e, e.at);
+ }
+
private utilityModel(botId: string, model: string): string {
return this.settings(botId).utilityModel || model;
}
@@ -597,11 +629,20 @@ export class AgentManager {
}
/** 故障排查:运行时位置 + 每个已创建的代理进程的详细状态(stderr 尾部、最近一次退出)+ 进行中的回合 */
- diagnostics(): { enabled: boolean; available: boolean; runtimeDir?: string; hosts: Record<string, Record<string, unknown>>; turns: Array<{ conversationId: string; botId: string; forMs: number; idleMs?: number; lastStep?: ActivityStep }> } {
+ diagnostics(): {
+ enabled: boolean;
+ available: boolean;
+ runtimeDir?: string;
+ hosts: Record<string, Record<string, unknown>>;
+ turns: Array<{ conversationId: string; botId: string; forMs: number; idleMs?: number; lastStep?: ActivityStep }>;
+ serverCompaction?: { enabled: boolean; models: Record<string, { ok: boolean; at: number; reason: string }> };
+ } {
return {
enabled: this.o.enabled,
available: this.available,
runtimeDir: this.o.runtimeDir,
+ // 服务端压缩:各模型的探测结论(支持 / 不支持及原因)
+ ...(this.serverCompaction ? { serverCompaction: { enabled: this.serverCompaction.enabled, models: this.serverCompaction.status() } } : {}),
hosts: Object.fromEntries([...this.hosts].map(([id, h]) => [id, h.diagnostics()])),
turns: [...this.turnsInProgress].map(([conversationId, t]) => ({
conversationId,
diff --git a/src/agent/server-compaction.ts b/src/agent/server-compaction.ts
new file mode 100644
index 0000000..ceb317f
--- /dev/null
+++ b/src/agent/server-compaction.ts
@@ -0,0 +1,738 @@
+/**
+ * 服务端压缩(OpenAI Responses API 的 compaction):长会话里,把 DSH 每次重发的完整历史换成上游压缩出来的窗口。
+ *
+ * - DSH 的 Responses 客户端(pi-ai)是无状态的:store:false,每次请求都带上全部历史;它不发 context_management,
+ * 也会丢掉回复里不认识的 compaction 输出项。所以这件事在 bridge 里做。
+ * - 某个会话发往上游的输入过了压缩线,就在后台调一次 POST /responses/compact(内置网关不转发这个路径,直接发给该模型
+ * 所在的 Modelflare 连接),记下"这段历史(逐项哈希)→ 压缩后的窗口",按会话存盘。之后同一会话的请求只要开头逐项
+ * 一致,就把这段换成压缩窗口再发(系统提示用当次请求的);有任何不一致就原样发。压缩不阻塞当次请求。
+ * - 价格目录列出 openai-response-compact 只是提示:每个模型(连同所用的 Key)先做一次很小的压缩 + 续接探测,通过了才用,
+ * 结果缓存(内存 + 磁盘,会过期)。
+ * - 改写过的请求被拒(4xx、流一开头就报错)时,bridge 用原请求重发一次,这里记下该模型不支持。压缩项只发回产生它的
+ * 同一个模型 + 同一个 Key。AMB_SERVER_COMPACTION=0 整个关掉。
+ *
+ * 接口形状见 OpenAI 文档 https://developers.openai.com/api/docs/guides/compaction 与
+ * https://developers.openai.com/api/reference/resources/responses/methods/compact 。
+ */
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { StringDecoder } from "node:string_decoder";
+import type { IncomingHttpHeaders } from "node:http";
+import { logger, redactText } from "../log.js";
+
+const log = logger("agent.compaction");
+
+/** Modelflare 价格目录 supported_endpoint_types 里表示 POST /v1/responses/compact 的值 */
+export const COMPACT_ENDPOINT = "openai-response-compact";
+
+const DAY = 24 * 3600_000;
+/** 探测结果的有效期:支持 3 天,不支持 1 天(之后重新探测);临时失败 10 分钟后再试 */
+const OK_TTL = 3 * DAY;
+const NO_TTL = DAY;
+const RETRY_MS = 10 * 60_000;
+/** 一个会话最多留几段映射;映射文件多久没动就删 */
+const KEEP_MAPPINGS = 3;
+const FILE_TTL = 14 * DAY;
+/** 上次压缩出来的映射一次都没用上(历史开头不稳定)时,这么久之内不再压缩同一会话 */
+const QUIET_MS = 30 * 60_000;
+const COMPACT_TIMEOUT_MS = 180_000;
+
+/** 直连压缩端点:地址(…/v1)、Key、上游模型名(去掉网关的 provider 前缀)、附加请求头 */
+export interface CompactEndpoint {
+ baseUrl: string;
+ apiKey: string;
+ model: string;
+ headers?: Record<string, string>;
+}
+
+export interface ServerCompactionOptions {
+ /** 映射与探测结果的存放目录 */
+ dir: string;
+ /** bridge 代理的上游(内置网关):探测的续接请求和真实请求走同一条路 */
+ upstream(): { baseUrl: string; apiKey: string };
+ /** 该模型(网关里的名字)的压缩端点;没有就不压缩 */
+ endpoint(model: string): CompactEndpoint | undefined;
+ /** 价格目录是否列出了压缩端点(只是提示;undefined = 不知道) */
+ listed(model: string): Promise<boolean | undefined>;
+ /** 上下文窗口与最大输出(定压缩线) */
+ limits(model: string): Promise<{ window: number; maxTokens: number }>;
+ /** 一次压缩结束(成功或失败);session 是 DSH 会话 id(不知道时为空) */
+ onEvent?(e: CompactionEvent): void;
+ fetchImpl?: typeof fetch;
+ now?(): number;
+}
+
+export interface CompactionEvent {
+ session: string;
+ model: string;
+ ok: boolean;
+ /** 压缩前后发往上游的输入(估算 tokens) */
+ before: number;
+ after?: number;
+ at: number;
+ ms: number;
+ error?: string;
+}
+
+/** bridge 对一次 /v1/responses 请求的处理方案 */
+export interface CompactionPlan {
+ /** 发给上游的请求体:改写过的,或原样 */
+ body: Buffer;
+ rewritten: boolean;
+ /** 改写过的请求上游接受了 */
+ accepted(): void;
+ /** 改写过的请求被拒(status 0 = 流一开头就报错);originalOk:随后用原请求重发成功了 */
+ rejected(status: number, error: string, originalOk: boolean): void;
+ /** 流式回复的字节(读 response.completed 里的用量) */
+ observe(chunk: Buffer): void;
+}
+
+interface Verdict {
+ ok: boolean;
+ at: number;
+ reason: string;
+}
+
+interface Mapping {
+ id: string;
+ model: string;
+ /** 压缩时所用 Key 的指纹:换了 Key(可能换了账户)就不再用 */
+ key: string;
+ /** 覆盖的历史条数与这段的哈希(不含开头的系统提示) */
+ k: number;
+ hash: string;
+ window: unknown[];
+ at: number;
+ before: number;
+ after: number;
+ hits?: number;
+ /** 改写后连续遇到 5xx 的次数 */
+ fails?: number;
+}
+
+interface SessionState {
+ file: string;
+ mappings: Mapping[];
+ /** 上一次请求的历史(判断会话是不是在往后长) */
+ last?: { len: number; hash: string; model: string };
+ /** 上一次回复报的用量(同一份映射下才可比) */
+ usage?: { mapping: string; tokens: number };
+ busy?: boolean;
+ quietUntil?: number;
+}
+
+class CompactError extends Error {
+ constructor(
+ message: string,
+ /** 这个模型不支持(4xx、形状不对);否则是临时问题 */
+ readonly unsupported: boolean,
+ readonly status = 0,
+ ) {
+ super(message);
+ }
+}
+
+export function serverCompactionEnabled(): boolean {
+ return process.env.AMB_SERVER_COMPACTION !== "0";
+}
+
+/**
+ * 压缩线:发往上游的输入(估算)过了它就在后台压缩。不超过 20 万、窗口的一半,并且留在 DSH 自己的压缩线之前
+ * (compaction-basic 默认 min(窗口 × 0.8, 窗口 − 最大输出 − 65536)),让服务端压缩先发生;太小的窗口不做。
+ * AMB_SERVER_COMPACTION_TOKENS 可覆盖(测试用)。
+ */
+export function compactLine(window: number, maxTokens: number): number {
+ const env = Number(process.env.AMB_SERVER_COMPACTION_TOKENS);
+ if (env > 0) return env;
+ const dsh = Math.min(window * 0.8, window - maxTokens - 65_536);
+ const line = Math.floor(Math.min(200_000, window / 2, dsh * 0.85));
+ return line >= 16_000 ? line : 0;
+}
+
+/** 粗估 tokens(偏大):文字按 UTF-8 字节 / 3,密文 / 4,内联图片每张 1500 */
+export function estimateTokens(v: unknown): number {
+ let bytes = 0;
+ let sealed = 0;
+ let images = 0;
+ let items = 0;
+ const walk = (x: unknown, key: string, depth: number): void => {
+ if (typeof x === "string") {
+ if (key === "encrypted_content") sealed += x.length;
+ else if (x.startsWith("data:") && x.length > 1000) images++;
+ else bytes += Buffer.byteLength(x);
+ } else if (Array.isArray(x)) {
+ if (depth === 0) items += x.length;
+ for (const y of x) walk(y, key, depth + 1);
+ } else if (x && typeof x === "object") {
+ for (const [k, y] of Object.entries(x)) walk(y, k, depth + 1);
+ }
+ };
+ walk(v, "", 0);
+ return Math.ceil(bytes / 3 + sealed / 4 + images * 1500 + items * 4);
+}
+
+function isInstruction(it: any): boolean {
+ return !!it && typeof it === "object" && (it.role === "system" || it.role === "developer") && (it.type === undefined || it.type === "message");
+}
+
+/** 开头的系统提示(system / developer 消息)与其后的历史 */
+export function splitLead(input: unknown[]): { lead: unknown[]; rest: unknown[] } {
+ let i = 0;
+ while (i < input.length && isInstruction(input[i])) i++;
+ return { lead: input.slice(0, i), rest: input.slice(i) };
+}
+
+const sha = (s: string) => crypto.createHash("sha256").update(s).digest("hex");
+
+/** 逐项累计哈希:h[i] = 前 i 项(h[0] 为空串) */
+export function prefixHashes(items: unknown[]): string[] {
+ const out = [""];
+ let h = "";
+ for (const it of items) {
+ h = sha(h + sha(JSON.stringify(it)));
+ out.push(h);
+ }
+ return out;
+}
+
+/** 改写后的输入:当次请求的系统提示 + 压缩窗口 + 压缩之后新增的历史 */
+export function splice(lead: unknown[], window: unknown[], tail: unknown[]): unknown[] {
+ return [...lead, ...window, ...tail];
+}
+
+/** /responses/compact 的回复是否可用:output 里至少有一个带密文的 compaction 项;不可用时 undefined */
+export function compactedWindow(j: any): unknown[] | undefined {
+ if (!j || typeof j !== "object" || !Array.isArray(j.output) || !j.output.length) return undefined;
+ if (j.object !== undefined && j.object !== "response.compaction") return undefined;
+ const items: any[] = j.output;
+ if (!items.every((it) => it && typeof it === "object" && !Array.isArray(it) && (typeof it.type === "string" || typeof it.role === "string"))) return undefined;
+ if (!items.some((it) => it.type === "compaction" && typeof it.encrypted_content === "string" && it.encrypted_content.length > 0)) return undefined;
+ return items;
+}
+
+/** 流式回复开头的判断:ok = 已经开始正常输出;wait = 还看不出来;error = 开头就报错 */
+export function sseVerdict(text: string): "ok" | "wait" | { error: string } {
+ const blocks = text.split(/\r?\n\r?\n/);
+ for (const block of blocks.slice(0, -1)) {
+ const data = block
+ .split(/\r?\n/)
+ .filter((l) => l.startsWith("data:"))
+ .map((l) => l.slice(5).trimStart())
+ .join("\n");
+ if (!data || data === "[DONE]") continue;
+ let ev: any;
+ try {
+ ev = JSON.parse(data);
+ } catch {
+ return "ok"; // 看不懂的不拦
+ }
+ const type = String(ev?.type ?? "");
+ if (type === "response.created" || type === "response.in_progress" || type === "response.queued") continue;
+ if (type === "error" || type === "response.failed") return { error: String(ev?.error?.message ?? ev?.message ?? ev?.response?.error?.message ?? type).slice(0, 300) };
+ return "ok";
+ }
+ return "wait";
+}
+
+/**
+ * 读流式回复的开头,直到第一个实质事件;开头就报错(error / response.failed)时返回错误,一个字节都还没交给下游,
+ * 可以换原请求重发。其余情况返回一条从头开始的完整流。
+ */
+export async function peekStream(body: ReadableStream<Uint8Array>, maxBytes = 256 * 1024): Promise<{ error?: string; stream: ReadableStream<Uint8Array> }> {
+ const reader = body.getReader();
+ const head: Uint8Array[] = [];
+ const dec = new TextDecoder();
+ let text = "";
+ let n = 0;
+ for (;;) {
+ const r = await reader.read();
+ if (r.done) break;
+ head.push(r.value);
+ n += r.value.length;
+ text += dec.decode(r.value, { stream: true });
+ const v = sseVerdict(text);
+ if (v === "ok") break;
+ if (v !== "wait") {
+ void reader.cancel().catch(() => undefined);
+ return { error: v.error, stream: new ReadableStream({ start: (c) => c.close() }) };
+ }
+ if (n >= maxBytes) break;
+ }
+ const stream = new ReadableStream<Uint8Array>({
+ start(c) {
+ for (const h of head) c.enqueue(h);
+ },
+ async pull(c) {
+ const r = await reader.read();
+ if (r.done) c.close();
+ else c.enqueue(r.value);
+ },
+ cancel(reason) {
+ return reader.cancel(reason);
+ },
+ });
+ return { stream };
+}
+
+/** 只改写无状态的 Responses 请求:输入是数组、store:false,没有 previous_response_id / conversation / context_management,也没带压缩项 */
+function stateless(j: any): boolean {
+ return (
+ !!j &&
+ typeof j === "object" &&
+ typeof j.model === "string" &&
+ !!j.model &&
+ Array.isArray(j.input) &&
+ j.input.length > 0 &&
+ j.store === false &&
+ j.previous_response_id == null &&
+ j.conversation == null &&
+ j.context_management == null &&
+ !j.input.some((it: any) => it?.type === "compaction" || it?.type === "compaction_trigger")
+ );
+}
+
+/** 会话:pi-ai 的 prompt_cache_key(= DSH 会话 id),其次 session_id 请求头;都没有就按模型 + 第一条历史分组(是否可用仍靠逐项哈希) */
+function sessionOf(j: any, headers: IncomingHttpHeaders, rest: unknown[]): { key: string; session: string } {
+ const h = (n: string) => {
+ const v = headers[n];
+ return Array.isArray(v) ? v[0] : v;
+ };
+ const id = (typeof j.prompt_cache_key === "string" && j.prompt_cache_key) || h("session_id") || h("x-client-request-id") || "";
+ return id ? { key: `s:${id}`, session: id } : { key: `h:${j.model}:${sha(JSON.stringify(rest[0] ?? null))}`, session: "" };
+}
+
+const keyPrint = (ep: CompactEndpoint) => sha(`${ep.baseUrl}\n${ep.apiKey}`).slice(0, 16);
+
+/** 消息的文字(content 是字符串或内容块数组) */
+function messageText(it: any): string {
+ const c = it?.content;
+ if (typeof c === "string") return c;
+ return Array.isArray(c) ? c.map((p: any) => (typeof p === "string" ? p : String(p?.text ?? ""))).join("") : "";
+}
+
+/**
+ * 压缩窗口里去掉系统提示:上游可能把输入里的 system / developer 消息原样保留(还会加上 id、status)。
+ * 当次请求的系统提示每次都放在最前面,窗口里再留一份就重复了(还是旧的)。
+ */
+export function withoutLead(window: unknown[], lead: unknown[]): unknown[] {
+ const texts = new Set(lead.map(messageText));
+ return window.filter((it: any) => !((it?.role === "system" || it?.role === "developer") && texts.has(messageText(it))));
+}
+
+function writeJson(file: string, data: unknown): void {
+ fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+ const tmp = `${file}.${process.pid}.${crypto.randomBytes(4).toString("hex")}.tmp`;
+ fs.writeFileSync(tmp, JSON.stringify(data), { mode: 0o600 });
+ fs.renameSync(tmp, file);
+}
+
+function readJson(file: string): any {
+ try {
+ return JSON.parse(fs.readFileSync(file, "utf8"));
+ } catch {
+ return undefined;
+ }
+}
+
+// ---------- 探测用的小对话(和 pi-ai 发的形状一致:系统提示、用户消息、工具调用与结果、助手回复) ----------
+const PROBE_LEAD = [{ role: "system", content: "You are a terse assistant. Answer in one word." }];
+const PROBE_ITEMS = [
+ { role: "user", content: [{ type: "input_text", text: "Look up the code word with the lookup tool." }] },
+ { type: "function_call", call_id: "call_amb_probe", name: "lookup", arguments: '{"what":"code word"}' },
+ { type: "function_call_output", call_id: "call_amb_probe", output: "teal" },
+ { type: "message", role: "assistant", content: [{ type: "output_text", text: "The code word is teal.", annotations: [] }], status: "completed", id: "msg_amb_probe" },
+];
+const PROBE_ASK = { role: "user", content: [{ type: "input_text", text: "Reply with the code word only." }] };
+const PROBE_TOOLS = [
+ {
+ type: "function",
+ name: "lookup",
+ description: "Look something up.",
+ parameters: { type: "object", properties: { what: { type: "string" } }, required: ["what"] },
+ strict: false,
+ },
+];
+
+export class ServerCompaction {
+ private sessions = new Map<string, SessionState>();
+ private verdicts = new Map<string, Verdict>();
+ private retryAt = new Map<string, number>();
+ private probing = new Map<string, Promise<void>>();
+ private limitCache = new Map<string, { window: number; maxTokens: number; at: number }>();
+ private limitPending = new Set<string>();
+ private tasks = new Set<Promise<unknown>>();
+ private readonly fetch: typeof fetch;
+
+ constructor(private o: ServerCompactionOptions) {
+ this.fetch = o.fetchImpl ?? fetch;
+ const saved = readJson(this.verdictFile);
+ for (const [k, v] of Object.entries<any>(saved && typeof saved === "object" ? saved : {})) {
+ if (typeof v?.ok === "boolean" && Number(v.at) > 0) this.verdicts.set(k, { ok: v.ok, at: Number(v.at), reason: String(v.reason ?? "") });
+ }
+ if (this.enabled) this.track(this.prune());
+ }
+
+ get enabled(): boolean {
+ return serverCompactionEnabled();
+ }
+
+ private now(): number {
+ return this.o.now?.() ?? Date.now();
+ }
+ private get verdictFile(): string {
+ return path.join(this.o.dir, "probe.json");
+ }
+ private get sessionDir(): string {
+ return path.join(this.o.dir, "sessions");
+ }
+
+ /** 后台任务(压缩、探测)都结束(测试用) */
+ async settled(): Promise<void> {
+ while (this.tasks.size) await Promise.allSettled([...this.tasks]);
+ }
+
+ private track<T>(p: Promise<T>): Promise<T> {
+ this.tasks.add(p);
+ void p.catch(() => undefined).finally(() => this.tasks.delete(p));
+ return p;
+ }
+
+ /** 故障排查用:各模型的探测结论 */
+ status(): Record<string, { ok: boolean; at: number; reason: string }> {
+ return Object.fromEntries([...this.verdicts].map(([k, v]) => [k.split("|")[0], v]));
+ }
+
+ /**
+ * 一次 DSH → 上游的请求:不是可改写的 /v1/responses 时返回 undefined(bridge 原样转发)。
+ * 不阻塞:探测、取窗口大小、压缩都在后台做,这次用不上就下次。
+ */
+ prepare(p: string, headers: IncomingHttpHeaders, body: Buffer): CompactionPlan | undefined {
+ if (!this.enabled || p !== "/v1/responses" || body.length < 2) return undefined;
+ let j: any;
+ try {
+ j = JSON.parse(body.toString("utf8"));
+ } catch {
+ return undefined;
+ }
+ if (!stateless(j)) return undefined;
+ const model: string = j.model;
+ const { lead, rest } = splitLead(j.input);
+ const hashes = prefixHashes(rest);
+ const { key, session } = sessionOf(j, headers, rest);
+ const st = this.state(key);
+ const ep = this.endpointFor(model);
+ const fp = ep ? keyPrint(ep) : "";
+ const verdict = ep ? this.verdicts.get(`${model}|${fp}`) : undefined;
+ // 只用同一模型、同一 Key 压出来的映射,且历史开头逐项一致;覆盖最长的那段优先
+ const mapping = verdict?.ok
+ ? st.mappings.filter((m) => m.model === model && m.key === fp && m.k <= rest.length && hashes[m.k] === m.hash).sort((a, b) => b.k - a.k || b.at - a.at)[0]
+ : undefined;
+ const input = mapping ? splice(lead, mapping.window, rest.slice(mapping.k)) : j.input;
+ const out = mapping ? Buffer.from(JSON.stringify({ ...j, input })) : body;
+ let tokens = estimateTokens(input) + estimateTokens(j.tools);
+ if (st.usage && st.usage.mapping === (mapping?.id ?? "")) tokens = Math.max(tokens, st.usage.tokens);
+ const growing = !!st.last && st.last.model === model && rest.length > st.last.len && hashes[st.last.len] === st.last.hash;
+ st.last = { len: rest.length, hash: hashes[rest.length], model };
+ if (ep) {
+ try {
+ this.consider({ st, key, session, model, ep, fp, verdict, tokens, growing, input, lead, tools: j.tools, instructions: j.instructions, k: rest.length, hash: hashes[rest.length] });
+ } catch (e) {
+ log.warn("server compaction check failed", { message: (e as Error).message });
+ }
+ }
+ const mid = mapping?.id ?? "";
+ let decoder: StringDecoder | undefined;
+ let buf = "";
+ return {
+ body: out,
+ rewritten: !!mapping,
+ accepted: () => {
+ if (!mapping) return;
+ mapping.hits = (mapping.hits ?? 0) + 1;
+ mapping.fails = 0;
+ },
+ rejected: (status, error, originalOk) => {
+ if (!mapping) return;
+ const snippet = redactText(error).replace(/\s+/g, " ").slice(0, 300);
+ log.warn("compacted request rejected upstream; resent the original", { model, status, originalOk, error: snippet });
+ // 5xx 可能只是上游一时的问题:映射先留着,连着两次才不用;其余(4xx、流开头报错)这段映射不再用
+ if (status >= 500 && (mapping.fails = (mapping.fails ?? 0) + 1) < 2) return;
+ st.mappings = st.mappings.filter((m) => m !== mapping);
+ this.saveSession(key, st);
+ // 原请求能过、改写的不能:是压缩项的问题,记下这个模型不支持
+ if (originalOk && status < 500) this.setVerdict(model, fp, { ok: false, at: this.now(), reason: `rewritten request rejected (${status || "stream error"}): ${snippet}` });
+ },
+ observe: (chunk) => {
+ decoder ??= new StringDecoder("utf8");
+ buf += decoder.write(chunk);
+ let i: number;
+ while ((i = buf.indexOf("\n")) >= 0) {
+ const line = buf.slice(0, i);
+ buf = buf.slice(i + 1);
+ if (!line.startsWith("data:") || !(line.includes('"response.completed"') || line.includes('"response.incomplete"'))) continue;
+ try {
+ const u = JSON.parse(line.slice(5))?.response?.usage;
+ const t = (Number(u?.input_tokens) || 0) + (Number(u?.output_tokens) || 0);
+ if (t > 0) st.usage = { mapping: mid, tokens: t };
+ } catch {
+ /* ignore */
+ }
+ }
+ // 一行太长(整段回复带密文)就不读了
+ if (buf.length > 16 * 1024 * 1024) buf = "";
+ },
+ };
+ }
+
+ /** 要不要探测 / 压缩(都在后台) */
+ private consider(c: {
+ st: SessionState;
+ key: string;
+ session: string;
+ model: string;
+ ep: CompactEndpoint;
+ fp: string;
+ verdict: Verdict | undefined;
+ tokens: number;
+ growing: boolean;
+ input: unknown[];
+ lead: unknown[];
+ tools: unknown;
+ instructions: unknown;
+ k: number;
+ hash: string;
+ }): void {
+ const lim = this.limitsFor(c.model);
+ if (!lim) return;
+ const line = compactLine(lim.window, lim.maxTokens);
+ if (!line || c.tokens < line / 2) return;
+ // 快到压缩线了:先确认这个模型(和这把 Key)真的支持
+ const fresh = c.verdict && this.now() - c.verdict.at < (c.verdict.ok ? OK_TTL : NO_TTL);
+ if (!fresh) this.ensureVerdict(c.model, c.ep, c.fp);
+ if (!c.verdict?.ok || c.tokens < line || !c.growing || c.st.busy || this.now() < (c.st.quietUntil ?? 0)) return;
+ const prev = c.st.mappings.at(-1);
+ if (prev && !prev.hits && this.now() - prev.at < QUIET_MS) return;
+ this.track(this.compact(c));
+ }
+
+ /** 端点(地址、Key)每次都要读网关配置文件:缓存半分钟 */
+ private endpoints = new Map<string, { ep: CompactEndpoint | undefined; at: number }>();
+ private endpointFor(model: string): CompactEndpoint | undefined {
+ const hit = this.endpoints.get(model);
+ if (hit && Date.now() - hit.at < 30_000) return hit.ep;
+ const ep = this.o.endpoint(model);
+ this.endpoints.set(model, { ep, at: Date.now() });
+ return ep;
+ }
+
+ private limitsFor(model: string): { window: number; maxTokens: number } | undefined {
+ const hit = this.limitCache.get(model);
+ if (hit && this.now() - hit.at < 10 * 60_000) return hit;
+ if (!this.limitPending.has(model)) {
+ this.limitPending.add(model);
+ this.track(
+ this.o
+ .limits(model)
+ .then((l) => {
+ if (Number(l?.window) > 0) this.limitCache.set(model, { window: Number(l.window), maxTokens: Number(l.maxTokens) || 0, at: this.now() });
+ })
+ .catch(() => undefined)
+ .finally(() => this.limitPending.delete(model)),
+ );
+ }
+ return hit;
+ }
+
+ private async compact(c: Parameters<ServerCompaction["consider"]>[0]): Promise<void> {
+ const { st, model, fp } = c;
+ st.busy = true;
+ const at = this.now();
+ const t0 = Date.now();
+ try {
+ const output = await this.callCompact(c.ep, { input: c.input, tools: c.tools, instructions: c.instructions });
+ const window = withoutLead(output, c.lead);
+ const after = estimateTokens(splice(c.lead, window, [])) + estimateTokens(c.tools);
+ if (after > c.tokens * 0.7) throw new CompactError(`compacted window is not smaller (${after} vs ${c.tokens})`, false);
+ const m: Mapping = { id: crypto.randomBytes(6).toString("hex"), model, key: fp, k: c.k, hash: c.hash, window, at, before: c.tokens, after };
+ st.mappings = [...st.mappings, m].slice(-KEEP_MAPPINGS);
+ this.saveSession(c.key, st);
+ log.info("server compaction done", { model, session: c.session.slice(0, 12), before: c.tokens, after, items: window.length, ms: Date.now() - t0 });
+ this.o.onEvent?.({ session: c.session, model, ok: true, before: c.tokens, after, at, ms: Date.now() - t0 });
+ } catch (e) {
+ const err = e as CompactError;
+ const message = redactText(err.message).slice(0, 300);
+ log.warn("server compaction failed; requests go on uncompacted", { model, session: c.session.slice(0, 12), status: err.status, unsupported: !!err.unsupported, message });
+ if (err.unsupported) this.setVerdict(model, fp, { ok: false, at: this.now(), reason: `compact: ${message}` });
+ st.quietUntil = this.now() + (err.unsupported ? QUIET_MS : RETRY_MS);
+ this.o.onEvent?.({ session: c.session, model, ok: false, before: c.tokens, at, ms: Date.now() - t0, error: message });
+ } finally {
+ st.busy = false;
+ }
+ }
+
+ /** POST /responses/compact(直连):返回压缩后的窗口;失败抛 CompactError */
+ private async callCompact(ep: CompactEndpoint, req: { input: unknown[]; tools?: unknown; instructions?: unknown }): Promise<any[]> {
+ const url = ep.baseUrl.replace(/\/+$/, "").replace(/\/v1$/, "") + "/v1/responses/compact";
+ const body = { model: ep.model, input: req.input, ...(Array.isArray(req.tools) && req.tools.length ? { tools: req.tools } : {}), ...(typeof req.instructions === "string" && req.instructions ? { instructions: req.instructions } : {}) };
+ let r: Response;
+ try {
+ r = await this.fetch(url, {
+ method: "POST",
+ headers: { "content-type": "application/json", accept: "application/json", ...ep.headers, authorization: `Bearer ${ep.apiKey}` },
+ body: JSON.stringify(body),
+ signal: AbortSignal.timeout(COMPACT_TIMEOUT_MS),
+ });
+ } catch (e) {
+ throw new CompactError(`network: ${(e as Error).message}`, false);
+ }
+ const text = await r.text().catch(() => "");
+ if (r.status >= 400) throw new CompactError(`HTTP ${r.status}: ${text.slice(0, 300)}`, unsupportedStatus(r.status), r.status);
+ let j: any;
+ try {
+ j = JSON.parse(text);
+ } catch {
+ throw new CompactError(`not JSON: ${text.slice(0, 120)}`, true, r.status);
+ }
+ const out = compactedWindow(j);
+ if (!out) throw new CompactError("no usable compaction item in the reply", true, r.status);
+ return out;
+ }
+
+ /** 确认这个模型 + Key 支持服务端压缩(后台;目录没列出就不探测) */
+ private ensureVerdict(model: string, ep: CompactEndpoint, fp: string): void {
+ const k = `${model}|${fp}`;
+ if (this.probing.has(k) || this.now() < (this.retryAt.get(k) ?? 0)) return;
+ const job = (async () => {
+ const listed = await this.o.listed(model).catch(() => undefined);
+ if (listed !== true) {
+ // 目录明确不再列出:已有的"支持"作废;不知道(目录读不到)就先不动
+ if (listed === false && this.verdicts.get(k)?.ok) this.setVerdict(model, fp, { ok: false, at: this.now(), reason: "no longer listed in the catalog" });
+ this.retryAt.set(k, this.now() + 30 * 60_000);
+ return;
+ }
+ const v = await this.probe(model, ep);
+ if (v) this.setVerdict(model, fp, v);
+ else this.retryAt.set(k, this.now() + RETRY_MS);
+ })()
+ .catch((e) => {
+ log.warn("server compaction probe crashed", { model, message: (e as Error).message });
+ this.retryAt.set(k, this.now() + RETRY_MS);
+ })
+ .finally(() => this.probing.delete(k));
+ this.probing.set(k, job);
+ this.track(job);
+ }
+
+ /**
+ * 探测:① 直连 /responses/compact 压一段很小的对话,回复里要有带密文的 compaction 项;② 把压缩窗口按真实请求的拼法
+ * 经内置网关发一次 /v1/responses 续接,上游要接受。返回 undefined = 临时问题(网络、限流、5xx),过一会儿再试。
+ */
+ async probe(model: string, ep: CompactEndpoint): Promise<Verdict | undefined> {
+ const t0 = Date.now();
+ let window: any[];
+ try {
+ window = await this.callCompact(ep, { input: [...PROBE_LEAD, ...PROBE_ITEMS], tools: PROBE_TOOLS });
+ } catch (e) {
+ const err = e as CompactError;
+ log.warn("server compaction probe: compact call failed", { model, status: err.status, unsupported: err.unsupported, message: redactText(err.message).slice(0, 300) });
+ return err.unsupported ? { ok: false, at: this.now(), reason: `probe compact: ${redactText(err.message).slice(0, 200)}` } : undefined;
+ }
+ const up = this.o.upstream();
+ if (!up.baseUrl) return undefined;
+ const input = splice(PROBE_LEAD, withoutLead(window, PROBE_LEAD), [PROBE_ASK]);
+ let r: Response;
+ try {
+ r = await this.fetch(up.baseUrl.replace(/\/+$/, "").replace(/\/v1$/, "") + "/v1/responses", {
+ method: "POST",
+ headers: { "content-type": "application/json", accept: "application/json", ...(up.apiKey ? { authorization: `Bearer ${up.apiKey}` } : {}) },
+ body: JSON.stringify({ model, input, tools: PROBE_TOOLS, store: false, stream: false, max_output_tokens: 64 }),
+ signal: AbortSignal.timeout(120_000),
+ });
+ } catch (e) {
+ log.warn("server compaction probe: follow-up failed", { model, message: (e as Error).message });
+ return undefined;
+ }
+ const text = await r.text().catch(() => "");
+ if (r.status >= 400) {
+ const message = redactText(text).replace(/\s+/g, " ").slice(0, 300);
+ log.warn("server compaction probe: follow-up rejected", { model, status: r.status, message });
+ return unsupportedStatus(r.status) ? { ok: false, at: this.now(), reason: `probe follow-up HTTP ${r.status}: ${message.slice(0, 200)}` } : undefined;
+ }
+ let j: any;
+ try {
+ j = JSON.parse(text);
+ } catch {
+ return { ok: false, at: this.now(), reason: "probe follow-up: not JSON" };
+ }
+ if ((j?.object !== undefined && j.object !== "response") || j?.status === "failed" || (j?.error && typeof j.error === "object") || !Array.isArray(j?.output)) {
+ return { ok: false, at: this.now(), reason: `probe follow-up: unexpected reply (${String(j?.status ?? j?.object ?? "?")})` };
+ }
+ log.info("server compaction probe passed", { model, ms: Date.now() - t0, windowItems: window.length });
+ return { ok: true, at: this.now(), reason: "probe passed" };
+ }
+
+ private setVerdict(model: string, fp: string, v: Verdict): void {
+ const k = `${model}|${fp}`;
+ const prev = this.verdicts.get(k);
+ this.verdicts.set(k, v);
+ if (!v.ok && prev?.ok !== false) log.warn("server compaction off for this model", { model, reason: v.reason });
+ try {
+ writeJson(this.verdictFile, Object.fromEntries(this.verdicts));
+ } catch (e) {
+ log.warn("saving server compaction probe results failed", { message: (e as Error).message });
+ }
+ }
+
+ private state(key: string): SessionState {
+ let st = this.sessions.get(key);
+ if (st) {
+ this.sessions.delete(key);
+ this.sessions.set(key, st);
+ return st;
+ }
+ const file = path.join(this.sessionDir, `${sha(key).slice(0, 40)}.json`);
+ const saved = readJson(file);
+ const cutoff = this.now() - FILE_TTL;
+ const mappings: Mapping[] = (saved?.key === key && Array.isArray(saved.mappings) ? saved.mappings : []).filter(
+ (m: any) => m && typeof m.model === "string" && typeof m.hash === "string" && Number.isInteger(m.k) && Array.isArray(m.window) && Number(m.at) > cutoff,
+ );
+ st = { file, mappings };
+ this.sessions.set(key, st);
+ if (this.sessions.size > 500) this.sessions.delete(this.sessions.keys().next().value!);
+ return st;
+ }
+
+ private saveSession(key: string, st: SessionState): void {
+ try {
+ if (!st.mappings.length) fs.rmSync(st.file, { force: true });
+ else writeJson(st.file, { v: 1, key, mappings: st.mappings.map(({ hits: _h, fails: _f, ...m }) => m) });
+ } catch (e) {
+ log.warn("saving server compaction mapping failed", { message: (e as Error).message });
+ }
+ }
+
+ /** 删掉很久没动的映射文件 */
+ private async prune(): Promise<void> {
+ let names: string[] = [];
+ try {
+ names = await fs.promises.readdir(this.sessionDir);
+ } catch {
+ return;
+ }
+ const cutoff = Date.now() - FILE_TTL;
+ for (const n of names) {
+ const f = path.join(this.sessionDir, n);
+ try {
+ if ((await fs.promises.stat(f)).mtimeMs < cutoff) await fs.promises.rm(f, { force: true });
+ } catch {
+ /* ignore */
+ }
+ }
+ }
+}
+
+/** 这个状态码说明"不支持"(不是 Key、限流、超时或上游一时的问题) */
+function unsupportedStatus(status: number): boolean {
+ return (status >= 400 && status < 500 && ![401, 408, 409, 429].includes(status)) || status === 501;
+}
diff --git a/src/app.ts b/src/app.ts
index f37410e..fcee7ab 100644
--- a/src/app.ts
+++ b/src/app.ts
@@ -37,6 +37,7 @@ import { AccountManager } from "./account/manager.js";
import { AccountVault, type SecretBox } from "./account/vault.js";
import { loadModelInfo, type ModelInfo } from "./account/model-info.js";
import { MediaService, pickDefault } from "./agent/media.js";
+import { COMPACT_ENDPOINT, serverCompactionEnabled, type CompactEndpoint } from "./agent/server-compaction.js";
import type { BotSettings } from "./agent/settings.js";
const log = logger("app");
@@ -165,6 +166,14 @@ export class App {
const bare = bareModel(model);
return (info[bare] ?? info[bare.split("/").pop() ?? bare])?.context;
},
+ // 服务端压缩:价格目录列出压缩端点只是提示,bridge 用之前会探测
+ serverCompaction: {
+ listed: async (model) => {
+ const info = await this.modelInfoFor(model);
+ return info?.endpoints ? info.endpoints.includes(COMPACT_ENDPOINT) : undefined;
+ },
+ endpoint: (model) => this.compactEndpoint(model),
+ },
// 后台小任务(管家判定/交接/记忆整理)直接走 magpie,不经代理子进程
complete: (botId, model, system, user) =>
this.models.streamChat(
@@ -210,6 +219,35 @@ export class App {
}
}
+ /** 某个模型(网关里的名字也行)的 Modelflare 模型资料 */
+ private async modelInfoFor(model: string): Promise<ModelInfo | undefined> {
+ const info = await this.modelInfo();
+ const bare = bareModel(model);
+ return info[bare] ?? info[bare.split("/").pop() ?? bare];
+ }
+
+ /**
+ * 服务端压缩直连的端点:内置网关不转发 /v1/responses/compact(回 404),压缩请求直接发给模型所在的 Modelflare 连接
+ * (同一把 Key)。压缩后的请求仍经网关;网关要先开启 nativeCompaction,带压缩项的请求被拒时才会原样报错,
+ * 而不是悄悄删掉压缩项重试(那样会丢掉之前的上下文)。外部端点模式直接用那个端点。
+ */
+ private compactEndpoint(model: string): CompactEndpoint | undefined {
+ if (!this.magpie) {
+ const baseUrl = this.config.magpie.externalBaseUrl.replace(/\/+$/, "");
+ return baseUrl ? { baseUrl, apiKey: this.config.magpie.externalApiKey, model } : undefined;
+ }
+ // 网关里的模型名是 <provider id>/<上游模型名>;provider 必须正好是它(upstreamEndpoint 找不到时会退回共用连接)
+ const i = model.indexOf("/");
+ const id = i > 0 ? model.slice(0, i) : "";
+ const up = id ? this.magpie.upstreamEndpoint(id) : undefined;
+ if (!up || up.id !== id) return undefined;
+ if (!this.magpie.nativeCompaction(up.id)) {
+ void this.magpie.ensureNativeCompaction(up.id).catch((e) => log.warn("turning on native compaction failed", { provider: up.id, message: (e as Error).message }));
+ return undefined;
+ }
+ return { baseUrl: up.baseUrl, apiKey: up.apiKey, model: model.slice(i + 1), headers: this.requestHeaders() };
+ }
+
/** 每个经 Modelflare 的请求都带的请求头(调用归因) */
requestHeaders(): Record<string, string> {
return skillHeader(appVersion());
@@ -240,6 +278,7 @@ export class App {
if (!key) continue;
try {
await magpie.ensureModelflareApis(id);
+ if (serverCompactionEnabled()) await magpie.ensureNativeCompaction(id).catch((e) => log.warn("turning on native compaction failed", { provider: id, message: (e as Error).message }));
const r = await verifyModelflareKey(baseUrl, key, { line: this.config.modelflare.line });
if (r.ok) await magpie.setModelPicks(id, r.chatModels);
} catch (e) {
diff --git a/src/magpie/supervisor.ts b/src/magpie/supervisor.ts
index da97f02..bd7ca3f 100644
--- a/src/magpie/supervisor.ts
+++ b/src/magpie/supervisor.ts
@@ -441,6 +441,33 @@ export class MagpieSupervisor {
if (p?.responses !== want.responses || p?.anthropic !== want.anthropic) await this.saveProvider(id, want);
}
+ /**
+ * 服务端压缩的前提:provider 开启 nativeCompaction 后,网关对带 compaction 项的请求只直传(不转成 Chat 协议),
+ * 上游拒绝时原样回报错;关着时网关会悄悄删掉压缩项再重试,之前的上下文就丢了。对不带压缩项的请求没有影响。
+ */
+ nativeCompaction(id: string): boolean {
+ return this.readProviderRaw(id)?.nativeCompaction === true;
+ }
+
+ private nativeSaving = new Map<string, Promise<void>>();
+ private nativeFailedAt = new Map<string, number>();
+ /** 打开 nativeCompaction;保存失败后 10 分钟内不再试(失败时抛错一次) */
+ async ensureNativeCompaction(id: string): Promise<void> {
+ if (this.nativeCompaction(id) || Date.now() - (this.nativeFailedAt.get(id) ?? 0) < 10 * 60_000) return;
+ let p = this.nativeSaving.get(id);
+ if (!p) {
+ p = this.saveProvider(id, { nativeCompaction: true })
+ .then(() => void this.nativeFailedAt.delete(id))
+ .catch((e) => {
+ this.nativeFailedAt.set(id, Date.now());
+ throw e;
+ })
+ .finally(() => this.nativeSaving.delete(id));
+ this.nativeSaving.set(id, p);
+ }
+ await p;
+ }
+
/** 断开 Modelflare:删除共用连接和所有机器人自己的 provider */
async disconnectModelflare(): Promise<void> {
for (const id of [this.modelflareId(), ...this.botProviderIds()]) if (id) await this.deleteProvider(id);
diff --git a/test/server-compaction.unit.test.ts b/test/server-compaction.unit.test.ts
new file mode 100644
index 0000000..d584b71
--- /dev/null
+++ b/test/server-compaction.unit.test.ts
@@ -0,0 +1,585 @@
+/**
+ * 服务端压缩(server-compaction.ts):前缀匹配与改写、探测与缓存、各种失败时的退回,以及经真实 bridge 的整条路径。
+ * 上游是按 OpenAI 文档行为写的 mock:/v1/responses/compact 保留用户消息并给出一个带密文的 compaction 项;
+ * /v1/responses 只接受这个 mock 给同一模型签出的压缩项。
+ */
+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 } from "../src/agent/bridge.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,
+ 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" };
+
+interface MockState {
+ compact: "ok" | "404" | "badshape" | "503";
+ items: "ok" | "reject" | "streamfail";
+ /** 回复里报的 input_tokens = 估算 × boost */
+ boost: number;
+ /** 助手回复的文字 */
+ reply: string;
+}
+
+/** 按文档行为的上游:记下每个请求 */
+async function mockUpstream() {
+ const state: MockState = { compact: "ok", items: "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" } });
+ // 保留用户(和 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 === "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" } });
+ }
+ 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 对得上", () => {
+ 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" })).toBeUndefined();
+ 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();
+ });
+
+ 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 / 回复里没有压缩项:记为不支持,存盘,一天内不再探测", 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 });
+ // 重启后仍记得;过了一天重新探测
+ 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);
+ 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("HTTP 400") });
+ 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({});
+ mock.state.compact = "ok";
+ now += 11 * 60_000;
+ await send(sc, req("mf/good", [user("start"), ...calls(1, 6)]));
+ expect(sc.status()["mf/good"]).toMatchObject({ ok: true });
+ });
+
+ 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("流一开头就报错(还没交出任何字节):同样用原请求重发", 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 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();
+ });
+});