🤖 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
feat(agent): server-side compaction for long Responses sessions
Marla584000a6c24d
diff --git a/src/account/model-info.ts b/src/account/model-info.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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.tsnew file mode 100644index 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();+ });+});