@zhushanwen/pi-permission 0.0.1

package/src/classifier/__tests__/classifier.test.ts

@@ -0,0 +1,285 @@
+/**
+ * CT 系列：classifier.ts 单元测试（createClassifier + classifyRisk 主流程）。
+ *
+ * mock 策略：鸭子类型 mock streamSimple（返回只带 result() 的 AssistantMessageEventStream）。
+ *
+ * 重点验证：
+ *  - C1-C4 主流程 happy path（allow/deny/ask）
+ *  - C5-C7 fail-closed（resolveModel null / streamSimple 抛错 / 解析失败）
+ *  - C8 timeout 兜底
+ *  - C9 abort signal
+ *  - C10 timeout 秒→毫秒传递
+ *  - C11 G3 关键修正：stopReason='error' / 'aborted' → fallback（即使 result() resolve）
+ */
+import type { AssistantMessageEventStream, SimpleStreamOptions } from "@earendil-works/pi-ai";
+import { describe, expect, it } from "vitest";
+
+import type { ClassifierConfig, ToolInvocationContext } from "../../types.js";
+import type { ClassifierDeps } from "../classifier.js";
+import { createClassifier } from "../classifier.js";
+import type { ResolvedModel } from "../model-resolver.js";
+
+// ──────────────────────── fixtures ────────────────────────
+
+const FIXED_MODEL: ResolvedModel = {
+	provider: "test-co",
+	id: "test-model",
+	api: "openai-completions",
+	name: "Test Model",
+	baseUrl: "http://localhost",
+	inputCost: 0,
+};
+
+const CONFIG: ClassifierConfig = {
+	enabled: true,
+	model: "auto",
+	timeout: 90,
+	autoApproveLowRisk: true,
+	autoDenyHighRisk: true,
+};
+
+const CTX: ToolInvocationContext = {
+	toolName: "bash",
+	command: "ls",
+	cwd: "/tmp",
+};
+
+// ──────────────────────── mock helpers ────────────────────────
+
+/** 构造「立刻 resolve 给定 AssistantMessage」的 mock EventStream（鸭子类型） */
+function mockStreamFromMessage(message: unknown): AssistantMessageEventStream {
+	return {
+		result: () => Promise.resolve(message),
+	};
+}
+
+/** 构造「永不 resolve」的 mock EventStream（用于 timeout/abort 测试） */
+function mockStreamNever(): AssistantMessageEventStream {
+	return {
+		result: () => new Promise(() => {}),
+	};
+}
+
+/** 构造「streamSimple 同步抛错」的 mock 函数 */
+function throwingStreamSimple(error: Error): ClassifierDeps["streamSimple"] {
+	return () => {
+		throw error;
+	};
+}
+
+interface AssistantMessageMock {
+	stopReason?: string;
+	content?: { type: string; text?: string }[];
+}
+
+function textMessage(text: string, stopReason = "stop"): AssistantMessageMock {
+	return {
+		stopReason,
+		content: [{ type: "text", text }],
+	};
+}
+
+function makeDeps(over: Partial<ClassifierDeps> = {}): ClassifierDeps {
+	return {
+		resolveModel: () => FIXED_MODEL,
+		streamSimple: () => mockStreamFromMessage(textMessage('{"outcome":"allow","risk_level":"low","reasoning":"ok","confidence":0.9}')),
+		...over,
+	};
+}
+
+/** 捕获 streamSimple 调用参数的 spy（options 含 apiKey 等）。 */
+function capturingStreamSimple(message: unknown): {
+	spy: ClassifierDeps["streamSimple"];
+	getLastOptions: () => SimpleStreamOptions | undefined;
+} {
+	let lastOptions: SimpleStreamOptions | undefined;
+	const spy: ClassifierDeps["streamSimple"] = (_model, _context, options?) => {
+		lastOptions = options;
+		return mockStreamFromMessage(message);
+	};
+	return { spy, getLastOptions: () => lastOptions };
+}
+
+// ──────────────────────── C1-C4: happy path ────────────────────────
+
+describe("CT1: happy path — streamSimple resolve 正常文本", () => {
+	it("allow JSON → ClassifierResult.allow", async () => {
+		const classifier = createClassifier(makeDeps({
+			streamSimple: () => mockStreamFromMessage(textMessage('{"outcome":"allow","risk_level":"low","reasoning":"safe","confidence":0.9}')),
+		}));
+		const r = await classifier.classifyRisk(CTX, CONFIG);
+		expect(r.outcome).toBe("allow");
+		expect(r.risk_level).toBe("low");
+		expect(r.confidence).toBeCloseTo(0.9);
+	});
+
+	it("deny JSON → ClassifierResult.deny", async () => {
+		const classifier = createClassifier(makeDeps({
+			streamSimple: () => mockStreamFromMessage(textMessage('{"outcome":"deny","risk_level":"high","reasoning":"rm -rf /","confidence":0.95}')),
+		}));
+		const r = await classifier.classifyRisk(CTX, CONFIG);
+		expect(r.outcome).toBe("deny");
+		expect(r.risk_level).toBe("high");
+	});
+
+	it("ask JSON → ClassifierResult.ask", async () => {
+		const classifier = createClassifier(makeDeps({
+			streamSimple: () => mockStreamFromMessage(textMessage('{"outcome":"ask","risk_level":"medium","reasoning":"uncertain","confidence":0.5}')),
+		}));
+		const r = await classifier.classifyRisk(CTX, CONFIG);
+		expect(r.outcome).toBe("ask");
+	});
+
+	it("LLM 输出带 code fence → 正则提取仍成功", async () => {
+		const classifier = createClassifier(makeDeps({
+			streamSimple: () => mockStreamFromMessage(textMessage('```json\n{"outcome":"allow","risk_level":"low","reasoning":"x","confidence":0.8}\n```')),
+		}));
+		const r = await classifier.classifyRisk(CTX, CONFIG);
+		expect(r.outcome).toBe("allow");
+	});
+});
+
+// ──────────────────────── C5-C7: fail-closed ────────────────────────
+
+describe("CT2: fail-closed 路径", () => {
+	it("C5: resolveModel 返回 null → fallback ask", async () => {
+		const classifier = createClassifier(makeDeps({ resolveModel: () => null }));
+		const r = await classifier.classifyRisk(CTX, CONFIG);
+		expect(r.outcome).toBe("ask");
+		expect(r.confidence).toBe(0);
+	});
+
+	it("C6: streamSimple 同步抛错 → fallback ask", async () => {
+		const classifier = createClassifier(makeDeps({
+			streamSimple: throwingStreamSimple(new Error("network down")),
+		}));
+		const r = await classifier.classifyRisk(CTX, CONFIG);
+		expect(r.outcome).toBe("ask");
+	});
+
+	it("C7: LLM 输出无法解析 → parser fallback ask", async () => {
+		const classifier = createClassifier(makeDeps({
+			streamSimple: () => mockStreamFromMessage(textMessage("totally not json")),
+		}));
+		const r = await classifier.classifyRisk(CTX, CONFIG);
+		expect(r.outcome).toBe("ask");
+		expect(r.reasoning).toContain("parse failed");
+	});
+});
+
+// ──────────────────────── C8-C10: timeout / abort ────────────────────────
+
+describe("CT3: timeout 与 abort 兜底", () => {
+	it("C8: result() 永挂 + 短 timeout → fallback ask（不卡死）", async () => {
+		const shortTimeoutConfig: ClassifierConfig = { ...CONFIG, timeout: 1 };
+		const classifier = createClassifier(makeDeps({
+			streamSimple: () => mockStreamNever(),
+		}));
+		const r = await classifier.classifyRisk(CTX, shortTimeoutConfig);
+		expect(r.outcome).toBe("ask");
+	}, 10000);
+
+	it("C9: abort signal 已 abort → 立刻 fallback ask", async () => {
+		const ac = new AbortController();
+		ac.abort();
+		const classifier = createClassifier(makeDeps({
+			streamSimple: () => mockStreamNever(),
+		}));
+		const r = await classifier.classifyRisk(CTX, CONFIG, ac.signal);
+		expect(r.outcome).toBe("ask");
+	});
+
+	it("C10: timeout=0 → 不设外层超时，result() 正常返回", async () => {
+		const noTimeoutConfig: ClassifierConfig = { ...CONFIG, timeout: 0 };
+		const classifier = createClassifier(makeDeps({
+			streamSimple: () => mockStreamFromMessage(textMessage('{"outcome":"allow","risk_level":"low","reasoning":"x","confidence":0.5}')),
+		}));
+		const r = await classifier.classifyRisk(CTX, noTimeoutConfig);
+		expect(r.outcome).toBe("allow");
+	});
+});
+
+// ──────────────────────── C11: G3 stopReason 修正（关键） ────────────────────────
+
+describe("CT4 / C11: G3 — result() 不 reject，必须显式检查 stopReason", () => {
+	it("stopReason='error' → fallback ask（即使 result() 成功 resolve）", async () => {
+		const classifier = createClassifier(makeDeps({
+			streamSimple: () => mockStreamFromMessage(textMessage('{"outcome":"allow","risk_level":"low","reasoning":"x","confidence":0.9}', "error")),
+		}));
+		const r = await classifier.classifyRisk(CTX, CONFIG);
+		// 关键：result() resolve 了，但 stopReason=error → 不能当成功 allow
+		expect(r.outcome).toBe("ask");
+		expect(r.confidence).toBe(0);
+	});
+
+	it("stopReason='aborted' → fallback ask", async () => {
+		const classifier = createClassifier(makeDeps({
+			streamSimple: () => mockStreamFromMessage(textMessage('{"outcome":"deny","risk_level":"high","reasoning":"x","confidence":0.9}', "aborted")),
+		}));
+		const r = await classifier.classifyRisk(CTX, CONFIG);
+		expect(r.outcome).toBe("ask");
+	});
+
+	it("stopReason='stop'（正常）→ 正常解析，不受 G3 影响", async () => {
+		const classifier = createClassifier(makeDeps({
+			streamSimple: () => mockStreamFromMessage(textMessage('{"outcome":"allow","risk_level":"low","reasoning":"x","confidence":0.9}', "stop")),
+		}));
+		const r = await classifier.classifyRisk(CTX, CONFIG);
+		expect(r.outcome).toBe("allow");
+	});
+
+	it("stopReason 缺省（undefined）→ 不触发 G3 兜底，走正常解析", async () => {
+		const classifier = createClassifier(makeDeps({
+			streamSimple: () => mockStreamFromMessage(textMessage('{"outcome":"allow","risk_level":"low","reasoning":"x","confidence":0.9}')),
+		}));
+		const r = await classifier.classifyRisk(CTX, CONFIG);
+		expect(r.outcome).toBe("allow");
+	});
+});
+
+// ──────────────────────── CT5: apiKey 透传到 streamSimple options ────────────────────────
+
+describe("CT5: resolved.apiKey 透传到 streamSimple options", () => {
+	it("resolved model 含 apiKey → streamSimple 收到的 options.apiKey 是该值", async () => {
+		const { spy, getLastOptions } = capturingStreamSimple(
+			textMessage('{"outcome":"allow","risk_level":"low","reasoning":"x","confidence":0.9}'),
+		);
+		const classifier = createClassifier(makeDeps({
+			resolveModel: () => ({ ...FIXED_MODEL, apiKey: "sk-test-secret-key-12345" }),
+			streamSimple: spy,
+		}));
+		const r = await classifier.classifyRisk(CTX, CONFIG);
+		expect(r.outcome).toBe("allow");
+		const options = getLastOptions();
+		expect(options).toBeDefined();
+		expect(options?.apiKey).toBe("sk-test-secret-key-12345");
+	});
+
+	it("resolved model 无 apiKey → streamSimple options 不含 apiKey 字段", async () => {
+		// FIXED_MODEL 无 apiKey → options 不含 apiKey 键（spread 条件不触发）
+		const { spy, getLastOptions } = capturingStreamSimple(
+			textMessage('{"outcome":"allow","risk_level":"low","reasoning":"x","confidence":0.9}'),
+		);
+		const classifier = createClassifier(makeDeps({ streamSimple: spy }));
+		await classifier.classifyRisk(CTX, CONFIG);
+		const options = getLastOptions();
+		expect(options).toBeDefined();
+		expect("apiKey" in (options as object)).toBe(false);
+	});
+
+	it("apiKey 与 timeoutMs/signal 共存于 options", async () => {
+		// 验证 apiKey 与 timeoutMs 同时透传不互相覆盖（spread 合并正确）
+		const { spy, getLastOptions } = capturingStreamSimple(
+			textMessage('{"outcome":"allow","risk_level":"low","reasoning":"x","confidence":0.9}'),
+		);
+		const classifier = createClassifier(makeDeps({
+			resolveModel: () => ({ ...FIXED_MODEL, apiKey: "k9" }),
+			streamSimple: spy,
+		}));
+		// CONFIG.timeout=90 → timeoutMs=90000
+		await classifier.classifyRisk(CTX, CONFIG);
+		const options = getLastOptions();
+		expect(options?.apiKey).toBe("k9");
+		expect(options?.timeoutMs).toBe(90_000);
+	});
+});

package/src/classifier/__tests__/json-parser.test.ts

@@ -0,0 +1,118 @@
+/**
+ * JT 系列：json-parser.ts 单元测试（三层容错）。
+ *
+ * 覆盖：
+ *  - 正常 JSON 提取与字段验证
+ *  - 三层容错：正则提取 / JSON.parse / 字段验证 各层失败路径
+ *  - G5 多 JSON 对象 limitation
+ *  - fail-closed fallback
+ */
+import { describe, expect, it } from "vitest";
+
+import { PARSE_FALLBACK_RESULT, parseClassifierResponse } from "../json-parser.js";
+
+describe("JT1: 正常 JSON（裸 JSON）", () => {
+	it("裸 JSON 对象 → 解析成功", () => {
+		const r = parseClassifierResponse('{"outcome":"allow","risk_level":"low","reasoning":"safe","confidence":0.9}');
+		expect(r).toEqual({ outcome: "allow", risk_level: "low", reasoning: "safe", confidence: 0.9 });
+	});
+
+	it("JSON 含大写枚举 → 小写归一", () => {
+		const r = parseClassifierResponse('{"outcome":"DENY","risk_level":"HIGH","reasoning":"x","confidence":0.8}');
+		expect(r.outcome).toBe("deny");
+		expect(r.risk_level).toBe("high");
+	});
+});
+
+describe("JT2: 第一层 — 正则提取（前后有 prose / code fence）", () => {
+	it("markdown code fence 包裹的 JSON → 提取成功", () => {
+		const text = 'Here is the result:\n```json\n{"outcome":"ask","risk_level":"medium","reasoning":"maybe","confidence":0.5}\n```\n';
+		const r = parseClassifierResponse(text);
+		expect(r.outcome).toBe("ask");
+		expect(r.risk_level).toBe("medium");
+		expect(r.confidence).toBeCloseTo(0.5);
+	});
+
+	it("JSON 后有尾部 prose → 贪婪匹配到最后的 }", () => {
+		const text = '{"outcome":"allow","risk_level":"low","reasoning":"ok","confidence":1.0} That looks safe.';
+		const r = parseClassifierResponse(text);
+		expect(r.outcome).toBe("allow");
+	});
+
+	it("无 { } → fallback", () => {
+		expect(parseClassifierResponse("no json here at all")).toEqual(PARSE_FALLBACK_RESULT);
+	});
+});
+
+describe("JT3: 第二层 — JSON.parse 失败", () => {
+	it("提取到非法 JSON（缺引号）→ fallback", () => {
+		expect(parseClassifierResponse('{outcome:"allow"}')).toEqual(PARSE_FALLBACK_RESULT);
+	});
+
+	it("G5 多 JSON 对象（贪婪吞掉中间）→ fallback", () => {
+		// 两个独立对象：贪婪正则匹配成 '{...}{...}'，JSON.parse 失败
+		const text = '{"outcome":"allow","risk_level":"low","reasoning":"a","confidence":0.1} {"outcome":"deny","risk_level":"high","reasoning":"b","confidence":0.9}';
+		expect(parseClassifierResponse(text)).toEqual(PARSE_FALLBACK_RESULT);
+	});
+});
+
+describe("JT4: 第三层 — 字段验证失败 → fallback", () => {
+	it("outcome 非法值 → fallback", () => {
+		const r = parseClassifierResponse('{"outcome":"maybe","risk_level":"low","reasoning":"x","confidence":0.5}');
+		expect(r).toEqual(PARSE_FALLBACK_RESULT);
+	});
+
+	it("risk_level 非法值 → fallback", () => {
+		const r = parseClassifierResponse('{"outcome":"allow","risk_level":"critical","reasoning":"x","confidence":0.5}');
+		expect(r).toEqual(PARSE_FALLBACK_RESULT);
+	});
+
+	it("confidence 非数字 → fallback", () => {
+		const r = parseClassifierResponse('{"outcome":"allow","risk_level":"low","reasoning":"x","confidence":"high"}');
+		expect(r).toEqual(PARSE_FALLBACK_RESULT);
+	});
+});
+
+describe("JT5: confidence 归一化", () => {
+	it("confidence 字符串数字 → 接受", () => {
+		const r = parseClassifierResponse('{"outcome":"allow","risk_level":"low","reasoning":"x","confidence":"0.7"}');
+		expect(r.confidence).toBeCloseTo(0.7);
+	});
+
+	it("confidence > 1 → clamp 到 1", () => {
+		const r = parseClassifierResponse('{"outcome":"allow","risk_level":"low","reasoning":"x","confidence":1.5}');
+		expect(r.confidence).toBe(1);
+	});
+
+	it("confidence < 0 → clamp 到 0", () => {
+		const r = parseClassifierResponse('{"outcome":"allow","risk_level":"low","reasoning":"x","confidence":-0.3}');
+		expect(r.confidence).toBe(0);
+	});
+});
+
+describe("JT6: 兼容字段 + 边界", () => {
+	it("reason 别名（reasoning 缺省时）→ 接受", () => {
+		const r = parseClassifierResponse('{"outcome":"allow","risk_level":"low","reason":"alt","confidence":0.5}');
+		expect(r.reasoning).toBe("alt");
+	});
+
+	it("score 别名 confidence → 接受", () => {
+		const r = parseClassifierResponse('{"outcome":"allow","risk_level":"low","reasoning":"x","score":0.4}');
+		expect(r.confidence).toBeCloseTo(0.4);
+	});
+
+	it("空字符串输入 → fallback", () => {
+		expect(parseClassifierResponse("")).toEqual(PARSE_FALLBACK_RESULT);
+	});
+
+	it("reasoning 缺省 → 用 fallback reasoning", () => {
+		const r = parseClassifierResponse('{"outcome":"allow","risk_level":"low","confidence":0.5}');
+		expect(r.reasoning).toBe(PARSE_FALLBACK_RESULT.reasoning);
+	});
+
+	it("返回的对象是深拷贝（修改不影响 PARSE_FALLBACK_RESULT）", () => {
+		const r = parseClassifierResponse("garbage");
+		r.reasoning = "mutated";
+		expect(PARSE_FALLBACK_RESULT.reasoning).not.toBe("mutated");
+	});
+});

package/src/classifier/__tests__/model-resolver.test.ts

@@ -0,0 +1,173 @@
+/**
+ * MRT 系列：model-resolver.ts 单元测试。
+ *
+ * 覆盖：
+ *  - G2：agentDir 解析（env override / 默认）
+ *  - loadModelsJson（文件缺失返回 null + onWarning）
+ *  - flattenModels（拍平 + hasApiKey 推断）
+ *  - findCheapestModel（过滤 hasApiKey + 按 input cost 升序）
+ *  - resolveClassifierModel（'auto' / 'provider/model-id' / 非法格式）
+ *
+ * 用真实 fs + 临时目录（不用 mock fs），与 config.test.ts 风格一致。
+ */
+import { existsSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+
+import { findCheapestModel, flattenModels, loadModelsJson, resolveClassifierModel } from "../model-resolver.js";
+
+let tempDir: string;
+let modelsJsonPath: string;
+
+beforeEach(() => {
+	tempDir = mkdtempSync(join(tmpdir(), "pi-perm-mr-"));
+	modelsJsonPath = join(tempDir, "models.json");
+});
+
+afterEach(() => {
+	rmSync(tempDir, { recursive: true, force: true });
+});
+
+const MODELS_JSON = {
+	providers: {
+		"cheap-co": {
+			baseUrl: "http://x",
+			apiKey: "k1",
+			api: "openai-completions",
+			models: [
+				{ id: "mini", cost: { input: 0.1, output: 0.1, cacheRead: 0, cacheWrite: 0 } },
+				{ id: "big", cost: { input: 1.0, output: 1.0, cacheRead: 0, cacheWrite: 0 } },
+			],
+		},
+		"noauth-co": {
+			baseUrl: "http://y",
+			// 无 apiKey
+			api: "openai-completions",
+			models: [{ id: "ultra-cheap", cost: { input: 0.001, output: 0, cacheRead: 0, cacheWrite: 0 } }],
+		},
+		"noapi-co": {
+			baseUrl: "http://z",
+			apiKey: "k3",
+			// 无 api
+			models: [{ id: "ghost", cost: { input: 0.5, output: 0, cacheRead: 0, cacheWrite: 0 } }],
+		},
+	},
+};
+
+function writeModels(data: unknown): void {
+	writeFileSync(modelsJsonPath, JSON.stringify(data), "utf-8");
+}
+
+describe("MRT1: loadModelsJson", () => {
+	it("文件不存在 → null（不抛错）", () => {
+		expect(existsSync(modelsJsonPath)).toBe(false);
+		expect(loadModelsJson(undefined, modelsJsonPath)).toBeNull();
+	});
+
+	it("合法 JSON → 返回解析对象", () => {
+		writeModels(MODELS_JSON);
+		const data = loadModelsJson(undefined, modelsJsonPath);
+		expect(data?.providers).toBeDefined();
+	});
+
+	it("损坏 JSON → null + onWarning 被调用", () => {
+		writeFileSync(modelsJsonPath, "{ broken json", "utf-8");
+		const warnings: string[] = [];
+		const data = loadModelsJson((m) => warnings.push(m), modelsJsonPath);
+		expect(data).toBeNull();
+		expect(warnings.length).toBe(1);
+		expect(warnings[0]).toContain("models.json");
+	});
+});
+
+describe("MRT2: flattenModels", () => {
+	it("拍平所有 provider.model，过滤无 api 的 model", () => {
+		const entries = flattenModels(MODELS_JSON);
+		const ids = entries.map((e) => e.id).sort();
+		// noapi-co/ghost 无 api → 过滤；其余保留
+		expect(ids).toEqual(["big", "mini", "ultra-cheap"]);
+	});
+
+	it("hasApiKey 从 provider.apiKey 推断", () => {
+		const entries = flattenModels(MODELS_JSON);
+		const cheap = entries.find((e) => e.id === "mini");
+		const noauth = entries.find((e) => e.id === "ultra-cheap");
+		expect(cheap?.hasApiKey).toBe(true);
+		expect(noauth?.hasApiKey).toBe(false);
+	});
+
+	it("apiKey 值从 provider.apiKey 透传（MRT2 补充：不只断言 hasApiKey 布尔）", () => {
+		const entries = flattenModels(MODELS_JSON);
+		const cheap = entries.find((e) => e.id === "mini");
+		const noauth = entries.find((e) => e.id === "ultra-cheap");
+		// 有 apiKey 的 provider：apiKey 字段透传真实值（"k1"）
+		expect(cheap?.apiKey).toBe("k1");
+		// 无 apiKey 的 provider：apiKey 字段为 undefined（而非空串）
+		expect(noauth?.apiKey).toBeUndefined();
+		// 同 provider 下所有 model 共享 provider.apiKey
+		const big = entries.find((e) => e.id === "big");
+		expect(big?.apiKey).toBe("k1");
+	});
+});
+
+describe("MRT3: findCheapestModel", () => {
+	it("过滤无 apiKey 的，返回 input cost 最低", () => {
+		const cheapest = findCheapestModel(MODELS_JSON);
+		// cheap-co/mini (0.1) < cheap-co/big (1.0)；noauth-co/ultra-cheap 被 hasApiKey 过滤掉
+		expect(cheapest?.id).toBe("mini");
+		expect(cheapest?.cost.input).toBeCloseTo(0.1);
+	});
+
+	it("全部无 apiKey → null", () => {
+		const data = {
+			providers: {
+				x: { baseUrl: "http://x", api: "openai-completions", models: [{ id: "m", cost: { input: 0.1, output: 0, cacheRead: 0, cacheWrite: 0 } }] },
+			},
+		};
+		expect(findCheapestModel(data)).toBeNull();
+	});
+});
+
+describe("MRT4: resolveClassifierModel", () => {
+	it("'auto' → 最便宜可用模型", () => {
+		const r = resolveClassifierModel("auto", MODELS_JSON);
+		expect(r?.id).toBe("mini");
+		expect(r?.provider).toBe("cheap-co");
+	});
+
+	it("'provider/model-id' → 精确匹配", () => {
+		const r = resolveClassifierModel("cheap-co/big", MODELS_JSON);
+		expect(r?.id).toBe("big");
+		expect(r?.provider).toBe("cheap-co");
+	});
+
+	it("'provider/model-id' 未匹配 → null", () => {
+		expect(resolveClassifierModel("cheap-co/nonexistent", MODELS_JSON)).toBeNull();
+	});
+
+	it("非法格式（无斜线）→ null", () => {
+		expect(resolveClassifierModel("just-a-name", MODELS_JSON)).toBeNull();
+	});
+
+	it("非法格式（斜线在首/尾）→ null", () => {
+		expect(resolveClassifierModel("/leading", MODELS_JSON)).toBeNull();
+		expect(resolveClassifierModel("trailing/", MODELS_JSON)).toBeNull();
+	});
+
+	it("ResolvedModel 携带 baseUrl/name/inputCost（G4）", () => {
+		const r = resolveClassifierModel("cheap-co/mini", MODELS_JSON);
+		expect(r?.baseUrl).toBe("http://x");
+		expect(r?.name).toBe("mini"); // 无 name → fallback 到 id
+		expect(r?.inputCost).toBeCloseTo(0.1);
+	});
+
+	it("ResolvedModel 携带 apiKey 值（MRT4 补充：透传给 streamSimple 用）", () => {
+		// reviewer 指出 MRT4 只断言 hasApiKey，没断言 apiKey 值。补断言。
+		const auto = resolveClassifierModel("auto", MODELS_JSON);
+		expect(auto?.apiKey).toBe("k1"); // cheap-co 的 apiKey
+		const explicit = resolveClassifierModel("cheap-co/big", MODELS_JSON);
+		expect(explicit?.apiKey).toBe("k1");
+	});
+});

package/src/classifier/__tests__/prompt.test.ts

@@ -0,0 +1,59 @@
+/**
+ * PT 系列：prompt.ts 单元测试。
+ *
+ * 验证 CLASSIFIER_SYSTEM_PROMPT 约束 + buildClassifierUserPrompt 字段拼接。
+ */
+import { describe, expect, it } from "vitest";
+
+import type { ToolInvocationContext } from "../../types.js";
+import { buildClassifierUserPrompt, CLASSIFIER_SYSTEM_PROMPT } from "../prompt.js";
+
+function ctx(over: Partial<ToolInvocationContext> = {}): ToolInvocationContext {
+	return {
+		toolName: "bash",
+		command: "ls",
+		cwd: "/tmp",
+		...over,
+	};
+}
+
+describe("PT1: CLASSIFIER_SYSTEM_PROMPT", () => {
+	it("包含 JSON 字段约束（outcome/risk_level/reasoning/confidence）", () => {
+		expect(CLASSIFIER_SYSTEM_PROMPT).toContain("outcome");
+		expect(CLASSIFIER_SYSTEM_PROMPT).toContain("risk_level");
+		expect(CLASSIFIER_SYSTEM_PROMPT).toContain("reasoning");
+		expect(CLASSIFIER_SYSTEM_PROMPT).toContain("confidence");
+	});
+
+	it("包含三态动作说明（allow/deny/ask）", () => {
+		expect(CLASSIFIER_SYSTEM_PROMPT).toContain("allow");
+		expect(CLASSIFIER_SYSTEM_PROMPT).toContain("deny");
+		expect(CLASSIFIER_SYSTEM_PROMPT).toContain("ask");
+	});
+});
+
+describe("PT2: buildClassifierUserPrompt 字段拼接", () => {
+	it("默认拼接 tool/command/path/cwd", () => {
+		const p = buildClassifierUserPrompt(ctx({ toolName: "bash", command: "ls -la", cwd: "/home" }));
+		expect(p).toContain("tool: bash");
+		expect(p).toContain("command: ls -la");
+		expect(p).toContain("cwd: /home");
+	});
+
+	it("command 缺省时显示 (none)", () => {
+		const p = buildClassifierUserPrompt(ctx({ toolName: "read", command: undefined }));
+		expect(p).toContain("command: (none)");
+	});
+
+	it("path 缺省时显示 (none)", () => {
+		const p = buildClassifierUserPrompt(ctx({ toolName: "read", path: undefined }));
+		expect(p).toContain("path: (none)");
+	});
+
+	it("agentName 存在时附 agent 行；缺省则无", () => {
+		const withAgent = buildClassifierUserPrompt(ctx({ agentName: "coder" }));
+		expect(withAgent).toContain("agent: coder");
+		const noAgent = buildClassifierUserPrompt(ctx({ agentName: undefined }));
+		expect(noAgent).not.toContain("agent:");
+	});
+});