physical_byte_agent/tests/server-runtime.test.ts
d-robotics 06a19a61e8 refactor: 重构为生产级 pi Agent 项目(散装脚本 → npm 库包 + 单一 barrel 装配)
- 工程形态:@d-robotics/physical-byte-agent npm 库包
  - 单一 barrel src/extensions/index.ts 装配 21 域扩展(package.json pi.extensions 清单 + .pi/extensions/index.ts 重导出,pi 自动加载)
  - src/agent.ts PhysicalByteAgent(launch() 程序化调 createAgentSession + verifyAssembly() 离线自检)
  - bin/pba.ts CLI、models.json(glm-5.2 条目)、README.md、AGENTS.md
- 命名:全部域命名(glm-provider/safety-gate/flash/jtag-debugger/loop-orchestrator…),去掉 F 编号
- 架构:内联逻辑 + 顶层仅 import type(esbuild 擦除)+ 工厂内动态 import defineTool/Type
  - 逻辑离线可单测(不解析 pi),工厂在真 pi 内装配;fail-closed 语义保留
- 两命门:glm-provider.ts buildGlmModelConfig()(thinkingFormat:qwen + maxTokens:8192 + thinkingLevelMap 全 null)+ detectEmptyOutput();normalizeHexArg() + makeHexNormalizingPrepareArguments()
- 验证:tsc --noEmit 0 错(对 src/types/pi.d.ts 类型镜像)+ vitest 732 用例/21 文件全绿 + tsx 离线装配冒烟 21 扩展全就位
- 密钥铁律:grep sk-nAm 在 src/tests/bin/.pi = 0,key 全程 ${DROBOTICS_LLM_KEY} 占位

Co-Authored-By: Claude <noreply@anthropic.com>
2026-08-13 19:54:20 +08:00

329 lines
12 KiB
TypeScript
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

import { describe, it, expect, vi } from "vitest";
import {
AgentSessionRuntime,
AuthError,
SessionLockedError,
SessionNotFoundError,
SessionDisposedError,
readAuthToken,
makePlaceholderTurnFn,
type AgentTurnFn,
type SendMessageInput,
} from "../src/extensions/server-runtime.js";
// ---- 工具:构造一个可控制完成的 turnFn(用于观察 streaming 中间态 + 响应 abort)----
function makeControllableTurn() {
let resolveTurn: (r: { text: string; stopReason?: string }) => void;
const promise = new Promise<{ text: string; stopReason?: string }>((r) => {
resolveTurn = r;
});
const turnFn: AgentTurnFn = vi.fn(
async (
_sessionId: string,
_input: SendMessageInput,
_onToken: (chunk: string) => void,
signal: { aborted: boolean },
) => {
// 轮询 abort 信号 + 等待外部 resolve,模拟真实 agent loop 响应中断
return await new Promise<{ text: string; stopReason?: string }>((resolve, reject) => {
const interval = setInterval(() => {
if (signal.aborted) {
clearInterval(interval);
reject(new Error("aborted"));
}
}, 5);
promise.then((r) => {
clearInterval(interval);
resolve(r);
});
});
},
);
return { turnFn, resolve: (r: { text: string; stopReason?: string }) => resolveTurn!(r) };
}
// 默认 echo turnFn
const echoTurn: AgentTurnFn = async (_id, input) => ({
text: `echo: ${input.text}`,
stopReason: "stop",
});
describe("server-runtime AgentSessionRuntime — startSession + 鉴权", () => {
it("startSession 返回 id 且初始 phase=idle/locked=false", async () => {
const rt = new AgentSessionRuntime({ turnFn: echoTurn });
const id = await rt.startSession({});
expect(id).toMatch(/^sess-/);
const snap = rt.getStatus(id);
expect(snap).not.toBeNull();
expect(snap!.phase).toBe("idle");
// locked 真实化:idle 时 locked=false(治 #20 locked:true 恒真)
expect(snap!.locked).toBe(false);
expect(snap!.model).toBe("glm-5.2");
});
it("required=true 时缺 token → AuthError(fail-closed)", async () => {
const rt = new AgentSessionRuntime({
turnFn: echoTurn,
auth: { required: true, expectedToken: "${DROBOTICS_LLM_KEY}" },
});
await expect(rt.startSession({})).rejects.toBeInstanceOf(AuthError);
});
it("required=true 时坏 token → AuthError", async () => {
const rt = new AgentSessionRuntime({
turnFn: echoTurn,
auth: { required: true, expectedToken: "${DROBOTICS_LLM_KEY}" },
});
await expect(rt.startSession({ authToken: "wrong-token" })).rejects.toBeInstanceOf(AuthError);
});
it("required=true 时正确 token 放行", async () => {
const rt = new AgentSessionRuntime({
turnFn: echoTurn,
auth: { required: true, expectedToken: "${DROBOTICS_LLM_KEY}" },
});
const id = await rt.startSession({ authToken: "${DROBOTICS_LLM_KEY}" });
expect(rt.getStatus(id)?.phase).toBe("idle");
});
it("checkToken 直接调用:required=false 恒放行", () => {
const rt = new AgentSessionRuntime({ turnFn: echoTurn });
expect(rt.checkToken(undefined)).toBe(true);
expect(rt.checkToken("anything")).toBe(true);
});
});
describe("server-runtime 状态机 idle → streaming → idle", () => {
it("sendMessage 驱动 idle→streaming→idle,transcript 含 user+assistant", async () => {
const { turnFn, resolve } = makeControllableTurn();
const rt = new AgentSessionRuntime({ turnFn });
const id = await rt.startSession({});
// 发消息但先不 resolve,观察 streaming
const p = rt.sendMessage(id, { text: "hello" });
// 让微任务推进到 streaming
await Promise.resolve();
await Promise.resolve();
const mid = rt.getStatus(id);
expect(mid!.phase).toBe("streaming");
expect(mid!.locked).toBe(true); // locked = phase !== idle
expect(mid!.transcript.some((m) => m.role === "user" && m.content === "hello")).toBe(true);
resolve({ text: "hi there", stopReason: "stop" });
const res = await p;
expect(res.aborted).toBe(false);
expect(res.text).toBe("hi there");
const after = rt.getStatus(id);
expect(after!.phase).toBe("idle");
expect(after!.locked).toBe(false);
expect(after!.transcript.some((m) => m.role === "assistant" && m.content === "hi there")).toBe(true);
});
it("locked 时 sendMessage 被拒绝(互斥,fail-closed)", async () => {
const { turnFn, resolve } = makeControllableTurn();
const rt = new AgentSessionRuntime({ turnFn });
const id = await rt.startSession({});
const p = rt.sendMessage(id, { text: "first" });
await Promise.resolve();
await Promise.resolve();
// 此时 streaming(locked),再发一条应被拒
await expect(rt.sendMessage(id, { text: "second" })).rejects.toBeInstanceOf(SessionLockedError);
resolve({ text: "ok" });
await p;
expect(rt.getStatus(id)?.phase).toBe("idle");
});
});
describe("server-runtime abort", () => {
it("abort 中断 streaming,phase 回 idle,result.aborted=true", async () => {
const { turnFn, resolve } = makeControllableTurn();
const rt = new AgentSessionRuntime({ turnFn });
const id = await rt.startSession({});
const p = rt.sendMessage(id, { text: "long task" });
await Promise.resolve();
await Promise.resolve();
expect(rt.getStatus(id)?.phase).toBe("streaming");
const aborted = await rt.abort(id);
expect(aborted).toBe(true);
// turnFn 会因 signal.aborted 抛错
const res = await p;
expect(res.aborted).toBe(true);
expect(rt.getStatus(id)?.phase).toBe("idle");
// 不 resolve 也不会泄漏;为防 unhandled rejection,消化掉
resolve({ text: "should-not-matter" });
});
it("abort 空闲会话返回 false", async () => {
const rt = new AgentSessionRuntime({ turnFn: echoTurn });
const id = await rt.startSession({});
expect(await rt.abort(id)).toBe(false);
});
it("abort 不存在的会话返回 false", async () => {
const rt = new AgentSessionRuntime({ turnFn: echoTurn });
expect(await rt.abort("nope")).toBe(false);
});
});
describe("server-runtime fork + resume + shutdown", () => {
it("fork 拷贝 transcript,新会话 phase=idle", async () => {
const rt = new AgentSessionRuntime({ turnFn: echoTurn });
const id = await rt.startSession({});
await rt.sendMessage(id, { text: "hello" });
const forkId = await rt.fork(id);
expect(forkId).not.toBe(id);
const snap = rt.getStatus(forkId)!;
expect(snap.phase).toBe("idle");
expect(snap.forkedFrom).toBe(id);
// transcript 含源会话的 user+assistant
expect(snap.transcript.some((m) => m.role === "user" && m.content === "hello")).toBe(true);
expect(snap.transcript.some((m) => m.role === "assistant")).toBe(true);
});
it("fork 不存在的会话 → SessionNotFoundError", async () => {
const rt = new AgentSessionRuntime({ turnFn: echoTurn });
await expect(rt.fork("nope")).rejects.toBeInstanceOf(SessionNotFoundError);
});
it("fork 坏 token → AuthError", async () => {
const rt = new AgentSessionRuntime({
turnFn: echoTurn,
auth: { required: true, expectedToken: "${DROBOTICS_LLM_KEY}" },
});
const id = await rt.startSession({ authToken: "${DROBOTICS_LLM_KEY}" });
await expect(rt.fork(id, { authToken: "bad" })).rejects.toBeInstanceOf(AuthError);
});
it("shutdown 置所有会话 disposed,sendMessage → SessionDisposedError", async () => {
const rt = new AgentSessionRuntime({ turnFn: echoTurn });
const id = await rt.startSession({});
await rt.shutdown();
const snap = rt.getStatus(id)!;
expect(snap.disposed).toBe(true);
await expect(rt.sendMessage(id, { text: "x" })).rejects.toBeInstanceOf(SessionDisposedError);
});
it("resume 恢复 disposed 会话后可继续 sendMessage", async () => {
const rt = new AgentSessionRuntime({ turnFn: echoTurn });
const id = await rt.startSession({});
await rt.shutdown();
expect(rt.resume(id)).toBe(true);
expect(rt.getStatus(id)?.disposed).toBe(false);
const res = await rt.sendMessage(id, { text: "after resume" });
expect(res.text).toBe("echo: after resume");
});
it("resume 不存在会话返回 false", () => {
const rt = new AgentSessionRuntime({ turnFn: echoTurn });
expect(rt.resume("nope")).toBe(false);
});
});
describe("server-runtime listSessions + getStatus 边界", () => {
it("getStatus 不存在返回 null", () => {
const rt = new AgentSessionRuntime({ turnFn: echoTurn });
expect(rt.getStatus("nope")).toBeNull();
});
it("listSessions 列出全部会话(含 disposed)", async () => {
const rt = new AgentSessionRuntime({ turnFn: echoTurn });
const a = await rt.startSession({});
const b = await rt.startSession({});
await rt.shutdown();
const list = rt.listSessions();
expect(list).toHaveLength(2);
expect(list.map((s) => s.id).sort()).toEqual([a, b].sort());
expect(list.every((s) => s.disposed)).toBe(true);
});
it("sendMessage 不存在会话 → SessionNotFoundError", async () => {
const rt = new AgentSessionRuntime({ turnFn: echoTurn });
await expect(rt.sendMessage("nope", { text: "x" })).rejects.toBeInstanceOf(SessionNotFoundError);
});
it("并发两 session 各自独立 prompt 互不干扰", async () => {
// 每个会话独立的 echo turnFn,按 sessionId 区分输出
const turnFn: AgentTurnFn = vi.fn(async (_id, input) => ({
text: `resp:${input.text}`,
stopReason: "stop",
}));
const rt = new AgentSessionRuntime({ turnFn });
const a = await rt.startSession({});
const b = await rt.startSession({});
const [ra, rb] = await Promise.all([
rt.sendMessage(a, { text: "from-a" }),
rt.sendMessage(b, { text: "from-b" }),
]);
expect(ra.text).toBe("resp:from-a");
expect(rb.text).toBe("resp:from-b");
// 两者都回 idle
expect(rt.getStatus(a)?.phase).toBe("idle");
expect(rt.getStatus(b)?.phase).toBe("idle");
// transcript 各自独立
const sa = rt.getStatus(a)!;
const sb = rt.getStatus(b)!;
expect(sa.transcript.some((m) => m.content === "from-a")).toBe(true);
expect(sa.transcript.some((m) => m.content === "from-b")).toBe(false);
expect(sb.transcript.some((m) => m.content === "from-b")).toBe(true);
expect(sb.transcript.some((m) => m.content === "from-a")).toBe(false);
});
});
describe("server-runtime 密钥铁律 + 辅助函数", () => {
it("expectedToken 用 ${DROBOTICS_LLM_KEY} 占位,绝不硬编码 sk- 开头", () => {
const rt = new AgentSessionRuntime({
turnFn: echoTurn,
auth: { required: true, expectedToken: "${DROBOTICS_LLM_KEY}" },
});
const token = (rt as unknown as { auth: { expectedToken: string } }).auth.expectedToken;
expect(token).toBe("${DROBOTICS_LLM_KEY}");
expect(token).not.toMatch(/^sk-/);
});
it("readAuthToken 未配 env 时鉴权关闭(开发模式)", () => {
const saved = process.env.DROBOTICS_LLM_KEY;
delete process.env.DROBOTICS_LLM_KEY;
try {
const cfg = readAuthToken();
expect(cfg.required).toBe(false);
} finally {
if (saved) process.env.DROBOTICS_LLM_KEY = saved;
}
});
it("readAuthToken 配了 env 时 required=true + expectedToken=env 值(fail-closed)", () => {
const saved = process.env.DROBOTICS_LLM_KEY;
process.env.DROBOTICS_LLM_KEY = "test-key-placeholder";
try {
const cfg = readAuthToken();
expect(cfg.required).toBe(true);
expect(cfg.expectedToken).toBe("test-key-placeholder");
expect(cfg.expectedToken).not.toMatch(/^sk-/);
} finally {
if (saved) process.env.DROBOTICS_LLM_KEY = saved;
else delete process.env.DROBOTICS_LLM_KEY;
}
});
it("makePlaceholderTurnFn 透传 input.text + 轮询 signal.aborted", async () => {
const fn = makePlaceholderTurnFn();
const res = await fn("sess-x", { text: "ping" }, () => {}, { aborted: false });
expect(res.text).toBe("[server-runtime placeholder] received: ping");
expect(res.stopReason).toBe("stop");
// aborted signal → 抛错
await expect(fn("sess-x", { text: "ping" }, () => {}, { aborted: true })).rejects.toThrow("aborted");
});
it("clear 清空后会话列表为空", async () => {
const rt = new AgentSessionRuntime({ turnFn: echoTurn });
await rt.startSession({});
expect(rt.listSessions()).toHaveLength(1);
rt.clear();
expect(rt.listSessions()).toHaveLength(0);
expect(rt.getStatus("nope")).toBeNull();
});
});