mu-agent-bridge 1.0.71 → 1.0.78

package/dist/tests-ts/personal-assistant.test.js

@@ -0,0 +1,663 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_test_1 = require("node:test");
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const channel_sessions_1 = require("../src-ts/channel-sessions");
+const agent_1 = require("../src-ts/agent");
+const personal_assistant_1 = require("../src-ts/plugins/personal-assistant");
+const tools_1 = require("../src-ts/plugins/personal-assistant/tools");
+const management = {
+    listAgents: async () => [{ id: "qwenwork", displayName: "千问办公", status: "ready", available: true, reason: "", capabilities: ["chat"], aids: ["qwen.agentid.cn"], callable: true }],
+    callAgent: async (_id, task) => ({ text: `已处理：${task}` }),
+    listAunIdentities: async () => ({ identities: [] }),
+    createAunIdentity: async () => ({ status: "created" }),
+    bindAunIdentity: async () => ({ status: "bound" }),
+    runSessionCommand: async (command) => `执行：${command}`,
+    summarizeToday: async () => ({ supported: true, text: "今天完成了任务。", sources: [], complete: true }),
+};
+(0, node_test_1.test)("个人助理 Agent 通配符贯通模型工具，不把全部允许误判为名单外", async () => {
+    let round = 0;
+    let listed = false;
+    let called = false;
+    const plugin = new personal_assistant_1.PersonalAssistantPlugin({ fetch: async (_input, init) => {
+            const messages = JSON.parse(String(init?.body)).messages;
+            if (round++) {
+                listed = messages.some((message) => message.role === "tool" && message.content.includes('"callable":true'));
+                called = messages.some((message) => message.role === "tool" && message.content.includes("已处理：通配任务"));
+            }
+            return new Response(JSON.stringify({ choices: [{ message: round === 1 ? { role: "assistant", tool_calls: [
+                                { id: "list", type: "function", function: { name: "agents_list", arguments: "{}" } },
+                                { id: "call", type: "function", function: { name: "agents_call", arguments: JSON.stringify({ id: "qwenwork", task: "通配任务" }) } },
+                            ] } : { role: "assistant", content: "已完成" } }] }));
+        } });
+    try {
+        await plugin.activate({ config: { endpoint: "https://example.test/v1/chat/completions", model: "test", allowedPeers: ["*"], allowedAgents: ["*"] } });
+        strict_1.default.equal((await plugin.health()).status, "ready");
+        strict_1.default.equal((await plugin.handle({ task: "调用千问", management })).text, "已完成");
+        strict_1.default.ok(listed && called);
+    }
+    finally {
+        await plugin.deactivate("stop");
+    }
+});
+(0, node_test_1.test)("个人助理经真实通道会话入口执行 /new 并隔离旧上下文", async () => {
+    const dataDir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "pa-channel-new-"));
+    const prompts = [];
+    const plugin = new personal_assistant_1.PersonalAssistantPlugin({ fetch: async (_input, init) => {
+            prompts.push(JSON.parse(String(init?.body)).messages);
+            return new Response(JSON.stringify({ choices: [{ message: { role: "assistant", content: "已处理" } }] }));
+        } });
+    try {
+        await plugin.activate({ dataDir, config: { endpoint: "https://example.test/v1/chat/completions", model: "test", allowedPeers: ["*"], allowedAgents: [] } });
+        const p = plugin;
+        strict_1.default.ok(p.sessionOperations?.includes("new"));
+        const sessions = new channel_sessions_1.ChannelSessions(dataDir);
+        const send = (text) => sessions.run({ channel: "aun", recipientId: "pa.agentid.cn", peerId: "devproj.agentid.cn", text, reply: async () => { } }, "personal-assistant", (sessionId, newSession) => plugin.handle({ task: text, sessionId, newSession, management }), request => p.controlSession(request));
+        const first = await send("旧记号");
+        strict_1.default.match((await send("/new")).text, /新会话/);
+        const second = await send("新消息");
+        strict_1.default.notEqual(first.logicalSessionId, second.logicalSessionId);
+        strict_1.default.equal(prompts[1].length, 2);
+        strict_1.default.doesNotMatch(JSON.stringify(prompts[1]), /旧记号/);
+    }
+    finally {
+        await plugin.deactivate("stop");
+        await (0, promises_1.rm)(dataDir, { recursive: true, force: true });
+    }
+});
+(0, node_test_1.test)("后续模型请求保留上轮管理工具调用及结果且失败轮次不写入历史", async () => {
+    const dataDir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "pa-tool-continuity-"));
+    const prompts = [];
+    let fail = false;
+    const plugin = new personal_assistant_1.PersonalAssistantPlugin({ fetch: async (_input, init) => {
+            prompts.push(JSON.parse(String(init?.body)).messages);
+            if (fail)
+                throw new Error("请求失败");
+            const message = prompts.length === 1
+                ? { role: "assistant", content: null, tool_calls: [{ id: "call-1", type: "function", function: { name: "agents_call", arguments: '{"id":"workbuddy","task":"记住 PA_TOOL"}' } }] }
+                : { role: "assistant", content: "已完成" };
+            return new Response(JSON.stringify({ choices: [{ message }] }));
+        } });
+    try {
+        await plugin.activate({ dataDir, config: { endpoint: "https://example.test/v1/chat/completions", model: "test", allowedPeers: ["*"], allowedAgents: ["workbuddy"] } });
+        await plugin.handle({ task: "调用 WorkBuddy 记住 PA_TOOL", sessionId: "one", management });
+        await plugin.handle({ task: "接着做", sessionId: "one", management });
+        strict_1.default.deepEqual(prompts[2].map((m) => m.role), ["system", "user", "assistant", "tool", "assistant", "user"]);
+        strict_1.default.match(prompts[2][3].content, /PA_TOOL/);
+        fail = true;
+        await plugin.handle({ task: "失败输入", sessionId: "one", management });
+        fail = false;
+        await plugin.handle({ task: "再次续聊", sessionId: "one", management });
+        strict_1.default.doesNotMatch(JSON.stringify(prompts.at(-1)), /失败输入/);
+    }
+    finally {
+        await plugin.deactivate("stop");
+        await (0, promises_1.rm)(dataDir, { recursive: true, force: true });
+    }
+});
+(0, node_test_1.test)("Claude 临时模型调用沿用个人助理历史，不依赖 CLI 持久会话", async () => {
+    const dataDir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "pa-claude-continuity-"));
+    const prompts = [];
+    const plugin = new personal_assistant_1.PersonalAssistantPlugin();
+    try {
+        await plugin.activate({ dataDir, config: { modelProvider: "claude-cli", allowedPeers: ["*"], allowedAgents: [] }, modelInputGuard: true, callPlugin: async (_id, request) => {
+                prompts.push(JSON.parse(request.task).messages);
+                return { text: JSON.stringify({ role: "assistant", content: "记号 PA_CLAUDE", tool_calls: [] }) };
+            } });
+        await plugin.handle({ task: "记住 PA_CLAUDE", sessionId: "one", management });
+        await plugin.handle({ task: "继续", sessionId: "one", management });
+        strict_1.default.deepEqual(prompts[1].map((m) => m.role), ["system", "user", "assistant", "user"]);
+        strict_1.default.equal(prompts[1][1].content, "记住 PA_CLAUDE");
+        await plugin.handle({ task: "另一位 Peer", sessionId: "two", management });
+        strict_1.default.equal(prompts[2].length, 2);
+    }
+    finally {
+        await plugin.deactivate("stop");
+        await (0, promises_1.rm)(dataDir, { recursive: true, force: true });
+    }
+});
+(0, node_test_1.test)("个人助理在同一 AUN 会话中恢复模型历史并隔离新会话", async () => {
+    const dataDir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "pa-session-memory-"));
+    const requests = [];
+    let answer = 0;
+    const fetcher = async (_input, init) => {
+        const body = JSON.parse(String(init?.body));
+        requests.push(body);
+        answer++;
+        return new Response(JSON.stringify({ choices: [{ message: { role: "assistant", content: answer === 1 ? "第一条记号 PA_FIRST" : answer === 2 ? "第二条已记住 PA_FIRST" : "新会话没有旧记号", tool_calls: [] } }] }), { status: 200 });
+    };
+    const context = { dataDir, config: { endpoint: "https://example.test/v1/chat/completions", model: "test", allowedPeers: [], allowedAgents: [] }, logger: { info() { }, warn() { }, error() { } }, http: { register: () => undefined, unregister() { } }, callPlugin: async () => ({ text: "" }), pluginStatus: () => "ready" };
+    try {
+        const first = new personal_assistant_1.PersonalAssistantPlugin({ fetch: fetcher });
+        await first.activate(context);
+        strict_1.default.equal((await first.handle({ task: "记住 PA_FIRST", sessionId: "peer-thread", management })).text, "第一条记号 PA_FIRST");
+        await first.deactivate("reload");
+        const resumed = new personal_assistant_1.PersonalAssistantPlugin({ fetch: fetcher });
+        await resumed.activate(context);
+        strict_1.default.equal((await resumed.handle({ task: "请引用刚才的记号", sessionId: "peer-thread", management })).text, "第二条已记住 PA_FIRST");
+        strict_1.default.deepEqual(requests[1].messages.slice(-3).map(message => [message.role, message.content]), [["user", "记住 PA_FIRST"], ["assistant", "第一条记号 PA_FIRST"], ["user", "请引用刚才的记号"]]);
+        strict_1.default.equal((await resumed.handle({ task: "新会话测试", sessionId: "peer-thread-new", management })).text, "新会话没有旧记号");
+        strict_1.default.deepEqual(requests[2].messages.slice(-2).map(message => [message.role, message.content]), [["system", requests[2].messages[0].content], ["user", "新会话测试"]]);
+        await resumed.deactivate("stop");
+    }
+    finally {
+        await (0, promises_1.rm)(dataDir, { recursive: true, force: true });
+    }
+});
+(0, node_test_1.test)("个人助理保留工具调用历史并返回最终文本", async () => {
+    const requests = [];
+    const fetcher = async (_input, init) => {
+        requests.push(JSON.parse(String(init?.body)));
+        const round = requests.length;
+        const body = round === 1
+            ? { choices: [{ message: { role: "assistant", content: null, tool_calls: [{ id: "call-1", type: "function", function: { name: "agents_list", arguments: "{}" } }] }, finish_reason: "tool_calls" }] }
+            : { choices: [{ message: { role: "assistant", content: "可用 Agent：千问办公" }, finish_reason: "stop" }] };
+        return new Response(JSON.stringify(body), { status: 200, headers: { "content-type": "application/json" } });
+    };
+    const plugin = new personal_assistant_1.PersonalAssistantPlugin({ fetch: fetcher });
+    await plugin.activate({ dataDir: "/tmp", config: { endpoint: "https://example.test/v1/chat/completions", model: "test", apiKey: "secret", allowedPeers: [], allowedAgents: [] }, logger: { info() { }, warn() { }, error() { } }, http: { register: () => undefined, unregister() { } }, callPlugin: async () => ({ text: "" }), pluginStatus: () => "ready" });
+    const result = await plugin.handle({ task: "列出 Agent", management });
+    strict_1.default.equal(result.text, "可用 Agent：千问办公");
+    strict_1.default.equal(requests.length, 2);
+    const second = requests[1];
+    strict_1.default.deepEqual(second.messages.slice(-2).map((message) => message.role), ["assistant", "tool"]);
+    strict_1.default.equal(second.messages.at(-1)?.tool_call_id, "call-1");
+});
+(0, node_test_1.test)("个人助理复用 Claude CLI 默认模型并由管理接口执行自然语言工具调用", async () => {
+    const plugin = new personal_assistant_1.PersonalAssistantPlugin({ fetch: async () => { throw new Error("不应请求 HTTP 模型"); } });
+    const requests = [];
+    let executed = 0;
+    await plugin.activate({ modelInputGuard: true, config: { modelProvider: "claude-cli", allowedPeers: ["devproj.agentid.cn"], allowedAgents: ["workbuddy"] }, logger: { info() { }, warn() { }, error() { } }, callPlugin: async (id, request) => {
+            strict_1.default.equal(id, "claude-cli");
+            strict_1.default.ok(request.modelResponseSchema);
+            strict_1.default.equal(request.management, undefined);
+            strict_1.default.equal(request.signal.aborted, false);
+            const input = JSON.parse(request.task);
+            requests.push(input);
+            return { text: JSON.stringify(requests.length === 1
+                    ? { role: "assistant", content: null, tool_calls: [{ id: "claude-1", type: "function", function: { name: "agents_call", arguments: '{"id":"workbuddy","task":"测试任务"}' } }] }
+                    : { role: "assistant", content: "WorkBuddy 已完成测试任务", tool_calls: [] }) };
+        } });
+    strict_1.default.equal((await plugin.health()).status, "ready");
+    strict_1.default.equal((await plugin.health()).details?.modelConfigured, true);
+    const result = await plugin.handle({ task: "请调用 WorkBuddy 处理测试任务", management: { ...management, callAgent: async (id, task) => { executed++; strict_1.default.equal(id, "workbuddy"); strict_1.default.equal(task, "测试任务"); return { text: "真实执行结果" }; } } });
+    strict_1.default.equal(result.text, "WorkBuddy 已完成测试任务");
+    strict_1.default.equal(executed, 1);
+    strict_1.default.equal(requests.length, 2);
+    strict_1.default.match(requests[1].messages.at(-1).content, /真实执行结果/);
+    strict_1.default.equal(requests[0].tools.find((tool) => tool.function.name === "aun_identity_create"), undefined);
+    await plugin.deactivate("stop");
+});
+(0, node_test_1.test)("个人助理通过显式桌面模型来源生成并校验管理决策", async () => {
+    const calls = [];
+    const plugin = new personal_assistant_1.PersonalAssistantPlugin();
+    await plugin.activate({ config: { modelProvider: "plugin", modelPlugin: "qwenwork", allowedPeers: [], allowedAgents: [] }, logger: { info() { }, warn() { }, error() { } }, callPlugin: async () => { throw new Error("不得退回普通 Agent 调用"); }, callModelProvider: async (id, request) => {
+            calls.push({ id, request });
+            return { text: JSON.stringify({ role: "assistant", content: "来自千问的模型回复", tool_calls: [] }) };
+        } });
+    const result = await plugin.handle({ task: "只回答测试", sessionId: "aun-peer-thread", management });
+    strict_1.default.equal(result.text, "来自千问的模型回复");
+    strict_1.default.equal(calls.length, 1);
+    strict_1.default.equal(calls[0].id, "qwenwork");
+    const firstPrompt = JSON.parse(calls[0].request.prompt);
+    strict_1.default.equal(calls[0].request.prompt.includes("agents_call"), true);
+    strict_1.default.match(firstPrompt.instructions, /只决定 content/);
+    strict_1.default.match(firstPrompt.instructions, /responseSchema/);
+    strict_1.default.match(calls[0].request.sessionId, /^[a-f0-9]{64}$/);
+    strict_1.default.equal(firstPrompt.responseSchema.required.includes("tool_calls"), true);
+    strict_1.default.equal(firstPrompt.messages.at(-1).content, "只回答测试");
+    strict_1.default.equal("management" in calls[0].request, false);
+    strict_1.default.equal("onMessage" in calls[0].request, false);
+});
+(0, node_test_1.test)("通用模型来源返回纯文本时作为最终回复，不执行管理工具", async () => {
+    const plugin = new personal_assistant_1.PersonalAssistantPlugin();
+    let executed = 0;
+    await plugin.activate({ config: { modelProvider: "plugin", modelPlugin: "workbuddy", allowedPeers: [], allowedAgents: [] }, callModelProvider: async () => ({ text: "桌面模型的普通回答" }) });
+    const result = await plugin.handle({ task: "只回答测试", management: { ...management, listAgents: async () => { executed++; return []; } } });
+    strict_1.default.equal(result.text, "桌面模型的普通回答");
+    strict_1.default.equal(executed, 0);
+});
+(0, node_test_1.test)("CLI 模型请求格式失败在回复和日志中说明具体原因", async () => {
+    for (const provider of ["claude-cli", "codex-cli"]) {
+        const reason = `${provider === "claude-cli" ? "Claude" : "Codex"} CLI 模型请求必须是包含 responseSchema 的 JSON 对象`;
+        const logs = [];
+        const plugin = new personal_assistant_1.PersonalAssistantPlugin();
+        await plugin.activate({ config: { modelProvider: "plugin", modelPlugin: provider, allowedPeers: [], allowedAgents: [] }, logger: { info() { }, warn: (_message, fields) => logs.push(fields), error() { } }, callModelProvider: async () => { throw new Error(reason); } });
+        try {
+            const result = await plugin.handle({ task: "测试", management });
+            strict_1.default.ok(result.text.includes(reason));
+            strict_1.default.ok(JSON.stringify(logs).includes(reason));
+        }
+        finally {
+            await plugin.deactivate("stop");
+        }
+    }
+});
+(0, node_test_1.test)("本机 OpenAI 兼容模型允许无密钥调用", async () => {
+    let authorization = "未检查";
+    const plugin = new personal_assistant_1.PersonalAssistantPlugin({ fetch: async (_input, init) => {
+            authorization = new Headers(init?.headers).get("authorization");
+            return new Response(JSON.stringify({ choices: [{ message: { role: "assistant", content: "本地模型已回复" } }] }), { status: 200 });
+        } });
+    await plugin.activate({ config: { endpoint: "http://127.0.0.1:11434/v1/chat/completions", model: "local", allowedPeers: [], allowedAgents: [] }, logger: { info() { }, warn() { }, error() { } } });
+    strict_1.default.equal((await plugin.handle({ task: "测试", management })).text, "本地模型已回复");
+    strict_1.default.equal(authorization, null);
+});
+(0, node_test_1.test)("插件模型失败显示来源、阶段和底层错误码，日志不包含提示和凭据", async () => {
+    const records = [];
+    const plugin = new personal_assistant_1.PersonalAssistantPlugin();
+    await plugin.activate({ config: { modelProvider: "plugin", modelPlugin: "qwenwork", allowedPeers: [], allowedAgents: [] }, logger: { info: (_message, fields) => records.push(fields), warn: (_message, fields) => records.push(fields), error() { } }, callModelProvider: async (_id, request) => {
+            throw new Error(`连接失败 token=secret-value ${request.prompt}`, { cause: Object.assign(new Error("连接被拒绝"), { code: "ECONNREFUSED" }) });
+        } });
+    try {
+        const result = await plugin.handle({ task: "此处是不能写入日志的用户任务", sessionId: "private-peer-thread", management });
+        strict_1.default.match(result.text, /qwenwork/);
+        strict_1.default.match(result.text, /模型调用/);
+        strict_1.default.match(result.text, /ECONNREFUSED/);
+        strict_1.default.doesNotMatch(result.text, /secret-value|此处是不能写入日志的用户任务|private-peer-thread/);
+        const log = JSON.stringify(records);
+        strict_1.default.match(log, /requestId/);
+        strict_1.default.match(log, /durationMs/);
+        strict_1.default.doesNotMatch(log, /secret-value|此处是不能写入日志的用户任务|private-peer-thread/);
+    }
+    finally {
+        await plugin.deactivate("stop");
+    }
+});
+(0, node_test_1.test)("插件模型的无效 JSON 决策在执行任一工具前被拒绝", async () => {
+    let executed = 0;
+    for (const raw of [JSON.stringify({ role: "assistant", content: {}, tool_calls: [] }), JSON.stringify({ role: "assistant", content: null, tool_calls: [
+                { id: "good", type: "function", function: { name: "agents_list", arguments: "{}" } },
+                { id: "bad", type: "function", function: { name: "agents_list", arguments: "{bad" } },
+            ] })]) {
+        const plugin = new personal_assistant_1.PersonalAssistantPlugin();
+        await plugin.activate({ config: { modelProvider: "plugin", modelPlugin: "doubao", allowedPeers: [], allowedAgents: [] }, callModelProvider: async () => ({ text: raw }) });
+        try {
+            const result = await plugin.handle({ task: "查询", management: { ...management, listAgents: async () => { executed++; return []; } } });
+            strict_1.default.match(result.text, /doubao/);
+            strict_1.default.match(result.text, /结构化校验/);
+        }
+        finally {
+            await plugin.deactivate("stop");
+        }
+    }
+    strict_1.default.equal(executed, 0);
+});
+(0, node_test_1.test)("来源异常不能借任意错误文字回显用户正文，保留底层错误码", async () => {
+    const logs = [];
+    const plugin = new personal_assistant_1.PersonalAssistantPlugin();
+    await plugin.activate({ config: { modelProvider: "plugin", modelPlugin: "doubao", allowedPeers: [], allowedAgents: [] }, logger: { info() { }, warn: (_message, fields) => logs.push(fields), error() { } }, callModelProvider: async () => {
+            throw new Error("今天的私密正文", { cause: Object.assign(new Error("连接失败"), { code: "ETIMEDOUT" }) });
+        } });
+    const result = await plugin.handle({ task: "今天的私密正文", management });
+    strict_1.default.match(result.text, /ETIMEDOUT/);
+    strict_1.default.doesNotMatch(JSON.stringify([result, logs]), /今天的私密正文/);
+});
+(0, node_test_1.test)("模型来源未就绪时保留端口或缺失接口原因并隐藏任意附加内容", async () => {
+    const cases = [
+        ["模型来源插件“千问办公”未就绪：无法连接千问办公 CDP 端口 9228；token=private-value", /无法连接千问办公 CDP 端口 9228/],
+        ["模型来源插件“千问办公”未就绪：插件未实现模型来源接口", /插件未实现模型来源接口/],
+        ["模型来源插件 qwenwork 未安装", /qwenwork 未安装/],
+    ];
+    for (const [reason, expected] of cases) {
+        const plugin = new personal_assistant_1.PersonalAssistantPlugin();
+        await plugin.activate({ config: { modelProvider: "plugin", modelPlugin: "qwenwork", allowedPeers: [], allowedAgents: [] }, callModelProvider: async () => { throw new Error(reason); } });
+        try {
+            const result = await plugin.handle({ task: "测试", management });
+            strict_1.default.match(result.text, expected);
+            strict_1.default.doesNotMatch(result.text, /private-value/);
+        }
+        finally {
+            await plugin.deactivate("stop");
+        }
+    }
+});
+(0, node_test_1.test)("桌面模型提交失败显示固定按钮原因，不回显附加提示或路径", async () => {
+    const plugin = new personal_assistant_1.PersonalAssistantPlugin();
+    await plugin.activate({ config: { modelProvider: "plugin", modelPlugin: "workbuddy", allowedPeers: [], allowedAgents: [] }, callModelProvider: async () => {
+            throw new agent_1.AgentOperationError("WORKBUDDY_TASK_FAILED", "向 WorkBuddy 提交任务", new Error("WorkBuddy 发送按钮未就绪；token=private-value；/home/private/prompt"));
+        } });
+    try {
+        const result = await plugin.handle({ task: "测试", management });
+        strict_1.default.match(result.text, /WORKBUDDY_TASK_FAILED/);
+        strict_1.default.match(result.text, /WorkBuddy 发送按钮未就绪/);
+        strict_1.default.doesNotMatch(result.text, /private-value|private\/prompt/);
+    }
+    finally {
+        await plugin.deactivate("stop");
+    }
+});
+(0, node_test_1.test)("旧核心缺少模型隔离保证时不调用 Claude CLI", async () => {
+    const plugin = new personal_assistant_1.PersonalAssistantPlugin();
+    let calls = 0;
+    await plugin.activate({ config: { modelProvider: "claude-cli", allowedPeers: [], allowedAgents: [] }, callPlugin: async () => { calls++; return { text: "不应执行" }; } });
+    strict_1.default.equal((await plugin.health()).status, "degraded");
+    strict_1.default.match((await plugin.health()).message, /升级核心/);
+    strict_1.default.equal((await plugin.health()).details?.modelConfigured, false);
+    await plugin.handle({ task: "调用 WorkBuddy", management });
+    strict_1.default.equal(calls, 0);
+});
+(0, node_test_1.test)("AUN 上游取消会停止仍在运行的 Claude 模型请求", async () => {
+    const plugin = new personal_assistant_1.PersonalAssistantPlugin();
+    let started;
+    const ready = new Promise(resolve => { started = resolve; });
+    let cliCancelled = false;
+    await plugin.activate({ modelInputGuard: true, config: { modelProvider: "claude-cli", allowedPeers: [], allowedAgents: [] }, logger: { info() { }, warn() { }, error() { } }, callPlugin: async (_id, request) => new Promise((_resolve, reject) => {
+            request.signal.addEventListener("abort", () => { cliCancelled = true; reject(new Error("取消")); }, { once: true });
+            started();
+        }) });
+    const upstream = new AbortController();
+    const pending = plugin.handle({ task: "调用 Agent", management, signal: upstream.signal });
+    await ready;
+    upstream.abort();
+    strict_1.default.match((await pending).text, /取消/);
+    strict_1.default.equal(cliCancelled, true);
+    await plugin.deactivate("stop");
+});
+(0, node_test_1.test)("停用个人助理会取消 Claude 模型请求，未知模型来源不能就绪", async () => {
+    const plugin = new personal_assistant_1.PersonalAssistantPlugin();
+    let started;
+    const ready = new Promise(resolve => { started = resolve; });
+    const context = { modelInputGuard: true, config: { modelProvider: "claude-cli", allowedPeers: [], allowedAgents: [] }, logger: { info() { }, warn() { }, error() { } }, callPlugin: async (_id, request) => new Promise((_resolve, reject) => { request.signal.addEventListener("abort", () => reject(new Error("取消")), { once: true }); started(); }) };
+    await plugin.activate(context);
+    const pending = plugin.handle({ task: "查询状态", management });
+    await ready;
+    strict_1.default.equal((await plugin.health()).details?.modelConfigured, true);
+    await plugin.deactivate("stop");
+    strict_1.default.match((await pending).text, /取消/);
+    await plugin.activate({ ...context, config: { ...context.config, modelProvider: "unknown" } });
+    strict_1.default.equal((await plugin.health()).status, "degraded");
+});
+(0, node_test_1.test)("没有可信管理上下文时不调用模型", async () => {
+    let calls = 0;
+    const plugin = new personal_assistant_1.PersonalAssistantPlugin({ fetch: async () => { calls++; return new Response("{}", { status: 500 }); } });
+    const result = await plugin.handle({ task: "列出 Agent" });
+    strict_1.default.match(result.text, /授权的 AUN/);
+    strict_1.default.equal(calls, 0);
+});
+(0, node_test_1.test)("未配置模型时仍可启动并执行显式管理转发", async () => {
+    const plugin = new personal_assistant_1.PersonalAssistantPlugin();
+    const context = { dataDir: "/tmp", config: { allowedPeers: ["devproj.agentid.cn"], allowedAgents: ["workbuddy"] }, logger: { info() { }, warn() { }, error() { } }, http: { register: () => undefined, unregister() { } }, callPlugin: async () => ({ text: "" }), pluginStatus: () => "ready" };
+    await plugin.activate(context);
+    strict_1.default.equal((await plugin.health()).status, "ready");
+    strict_1.default.deepEqual((await plugin.health()).details, { modelConfigured: false });
+    const result = await plugin.handle({ task: "/assistant agent call workbuddy 请仅回复 WORKBUDDY_LINK_OK", management: { ...management, callAgent: async () => ({ text: "WORKBUDDY_LINK_OK" }) } });
+    strict_1.default.equal(result.text, "WORKBUDDY_LINK_OK");
+    await plugin.deactivate("stop");
+});
+(0, node_test_1.test)("拒绝超过八次的模型工具调用且不执行其中的操作", async () => {
+    let executed = 0;
+    const tools = Array.from({ length: 9 }, (_, index) => ({ id: `call-${index}`, type: "function", function: { name: "agents_list", arguments: "{}" } }));
+    const plugin = new personal_assistant_1.PersonalAssistantPlugin({ fetch: async () => new Response(JSON.stringify({ choices: [{ message: { role: "assistant", tool_calls: tools } }] }), { status: 200 }) });
+    await plugin.activate({ dataDir: "/tmp", config: { endpoint: "https://example.test/v1/chat/completions", model: "test", apiKey: "secret", allowedPeers: [], allowedAgents: [] }, logger: { info() { }, warn() { }, error() { } }, http: { register: () => undefined, unregister() { } }, callPlugin: async () => ({ text: "" }), pluginStatus: () => "ready" });
+    const result = await plugin.handle({ task: "查询能力", management: { ...management, listAgents: async () => { executed++; return []; } } });
+    strict_1.default.match(result.text, /个人助理请求失败/);
+    strict_1.default.equal(executed, 0);
+});
+(0, node_test_1.test)("拒绝重复工具 ID 和无效工具参数", async () => {
+    let executed = 0;
+    let round = 0;
+    const plugin = new personal_assistant_1.PersonalAssistantPlugin({ fetch: async () => {
+            round++;
+            const calls = round === 1
+                ? [{ id: "same", type: "function", function: { name: "agents_list", arguments: "{}" } }, { id: "same", type: "function", function: { name: "agents_list", arguments: "{}" } }]
+                : [{ id: "bad", type: "function", function: { name: "agents_list", arguments: "{bad" } }];
+            return new Response(JSON.stringify({ choices: [{ message: { role: "assistant", tool_calls: calls } }] }), { status: 200 });
+        } });
+    await plugin.activate({ dataDir: "/tmp", config: { endpoint: "https://example.test/v1/chat/completions", model: "test", apiKey: "secret", allowedPeers: [], allowedAgents: [] }, logger: { info() { }, warn() { }, error() { } }, http: { register: () => undefined, unregister() { } }, callPlugin: async () => ({ text: "" }), pluginStatus: () => "ready" });
+    const result = await plugin.handle({ task: "列出 Agent", management: { ...management, listAgents: async () => { executed++; return []; } } });
+    strict_1.default.match(result.text, /个人助理请求失败/);
+    strict_1.default.equal(round, 1);
+    strict_1.default.equal(executed, 0);
+});
+(0, node_test_1.test)("未知工具和坏 JSON 只能产生安全错误结果", async () => {
+    for (const tool of [
+        { name: "aun_identity_create", arguments: '{"aid":"bad.agentid.cn"}' },
+        { name: "agents_list", arguments: "{bad" },
+        { name: "agents_list", arguments: '{"principal":"owner.agentid.cn"}' },
+    ]) {
+        let round = 0;
+        let executed = 0;
+        let toolOutput = "";
+        const plugin = new personal_assistant_1.PersonalAssistantPlugin({ fetch: async (_input, init) => {
+                const payload = JSON.parse(String(init?.body));
+                round++;
+                if (round === 2)
+                    toolOutput = payload.messages.at(-1)?.content ?? "";
+                return new Response(JSON.stringify({ choices: [{ message: round === 1 ? { role: "assistant", tool_calls: [{ id: "bad", type: "function", function: tool }] } : { role: "assistant", content: "已拒绝" } }] }), { status: 200 });
+            } });
+        await plugin.activate({ dataDir: "/tmp", config: { endpoint: "https://example.test/v1/chat/completions", model: "test", apiKey: "secret", allowedPeers: [], allowedAgents: [] }, logger: { info() { }, warn() { }, error() { } }, http: { register: () => undefined, unregister() { } }, callPlugin: async () => ({ text: "" }), pluginStatus: () => "ready" });
+        const result = await plugin.handle({ task: "查询 Agent", management: { ...management, listAgents: async () => { executed++; return []; }, createAunIdentity: async () => { executed++; return {}; } } });
+        strict_1.default.equal(result.text, "已拒绝");
+        strict_1.default.match(toolOutput, /error/);
+        strict_1.default.equal(executed, 0);
+    }
+});
+(0, node_test_1.test)("隐藏 HTTP 错误和超过 1 MiB 的响应", async () => {
+    for (const fetcher of [
+        async () => new Response("Authorization: Bearer secret", { status: 503 }),
+        async () => new Response(" ".repeat(1024 * 1024 + 1), { status: 200 }),
+    ]) {
+        const plugin = new personal_assistant_1.PersonalAssistantPlugin({ fetch: fetcher });
+        await plugin.activate({ dataDir: "/tmp", config: { endpoint: "https://example.test/v1/chat/completions", model: "test", apiKey: "secret", allowedPeers: [], allowedAgents: [] }, logger: { info() { }, warn() { }, error() { } }, http: { register: () => undefined, unregister() { } }, callPlugin: async () => ({ text: "" }), pluginStatus: () => "ready" });
+        const result = await plugin.handle({ task: "列出 Agent", management });
+        strict_1.default.match(result.text, /个人助理请求失败/);
+        strict_1.default.doesNotMatch(result.text, /secret|Authorization/);
+    }
+});
+(0, node_test_1.test)("工具调用循环最多请求六轮", async () => {
+    let calls = 0;
+    const plugin = new personal_assistant_1.PersonalAssistantPlugin({ fetch: async () => {
+            calls++;
+            return new Response(JSON.stringify({ choices: [{ message: { role: "assistant", tool_calls: [{ id: `call-${calls}`, type: "function", function: { name: "agents_list", arguments: "{}" } }] } }] }), { status: 200 });
+        } });
+    await plugin.activate({ dataDir: "/tmp", config: { endpoint: "https://example.test/v1/chat/completions", model: "test", apiKey: "secret", allowedPeers: [], allowedAgents: [] }, logger: { info() { }, warn() { }, error() { } }, http: { register: () => undefined, unregister() { } }, callPlugin: async () => ({ text: "" }), pluginStatus: () => "ready" });
+    const result = await plugin.handle({ task: "列出 Agent", management });
+    strict_1.default.match(result.text, /个人助理请求失败/);
+    strict_1.default.equal(calls, 6);
+});
+(0, node_test_1.test)("模型请求超时后不再继续", async () => {
+    let calls = 0;
+    const plugin = new personal_assistant_1.PersonalAssistantPlugin({ fetch: async (_input, init) => new Promise((_resolve, reject) => {
+            calls++;
+            init?.signal?.addEventListener("abort", () => reject(new Error("abort")), { once: true });
+        }) });
+    await plugin.activate({ dataDir: "/tmp", config: { endpoint: "https://example.test/v1/chat/completions", model: "test", apiKey: "secret", allowedPeers: [], allowedAgents: [] }, logger: { info() { }, warn() { }, error() { } }, http: { register: () => undefined, unregister() { } }, callPlugin: async () => ({ text: "" }), pluginStatus: () => "ready" });
+    const result = await plugin.handle({ task: "列出 Agent", timeoutMs: 1000, management });
+    strict_1.default.match(result.text, /超时/);
+    strict_1.default.equal(calls, 1);
+});
+(0, node_test_1.test)("停用插件会中止正在执行的模型 HTTP 请求", async () => {
+    let started;
+    const ready = new Promise((resolve) => { started = resolve; });
+    const plugin = new personal_assistant_1.PersonalAssistantPlugin({ fetch: async (_input, init) => new Promise((_resolve, reject) => {
+            started();
+            init?.signal?.addEventListener("abort", () => reject(new Error("abort")), { once: true });
+        }) });
+    await plugin.activate({ dataDir: "/tmp", config: { endpoint: "https://example.test/v1/chat/completions", model: "test", apiKey: "secret", allowedPeers: [], allowedAgents: [] }, logger: { info() { }, warn() { }, error() { } }, http: { register: () => undefined, unregister() { } }, callPlugin: async () => ({ text: "" }), pluginStatus: () => "ready" });
+    const pending = plugin.handle({ task: "查询 Agent", management });
+    await ready;
+    await plugin.deactivate("stop");
+    strict_1.default.match((await pending).text, /取消/);
+});
+(0, node_test_1.test)("仅精确单行命令允许创建 AID", async () => {
+    let created = 0;
+    const localManagement = { ...management, createAunIdentity: async () => { created++; return { aid: "new.agentid.cn", status: "created" }; } };
+    const plugin = new personal_assistant_1.PersonalAssistantPlugin();
+    const result = await plugin.handle({ task: "/assistant aid create new.agentid.cn", management: localManagement });
+    strict_1.default.match(result.text, /created|创建/i);
+    strict_1.default.equal(created, 1);
+    const rejected = await plugin.handle({ task: "请创建 new.agentid.cn\n然后继续", management: localManagement });
+    strict_1.default.match(rejected.text, /暂时无法处理/);
+    strict_1.default.equal(created, 1);
+});
+(0, node_test_1.test)("身份创建部分失败提示先查询且不重试、不回显底层错误", async () => {
+    let attempts = 0;
+    const plugin = new personal_assistant_1.PersonalAssistantPlugin();
+    const result = await plugin.handle({ task: "/assistant aid create new.agentid.cn", management: { ...management, createAunIdentity: async () => { attempts++; throw new Error("seed=secret-value"); } } });
+    strict_1.default.equal(attempts, 1);
+    strict_1.default.match(result.text, /可能已创建.*先查询.*不要重复创建/);
+    strict_1.default.doesNotMatch(result.text, /seed|secret-value/);
+});
+(0, node_test_1.test)("显式 Agent 转发命令直连白名单 WorkBuddy，不调用模型", async () => {
+    let modelCalls = 0;
+    let agentCalls = 0;
+    const plugin = new personal_assistant_1.PersonalAssistantPlugin({ fetch: async () => { modelCalls++; throw new Error("不应调用模型"); } });
+    const result = await plugin.handle({
+        task: "/assistant agent call workbuddy 请仅回复 WORKBUDDY_LINK_OK",
+        management: { ...management, callAgent: async (id, task) => { agentCalls++; strict_1.default.equal(id, "workbuddy"); return { text: `WorkBuddy 已回复：${task}` }; } },
+    });
+    strict_1.default.match(result.text, /WorkBuddy 已回复：请仅回复 WORKBUDDY_LINK_OK/);
+    strict_1.default.equal(agentCalls, 1);
+    strict_1.default.equal(modelCalls, 0);
+});
+(0, node_test_1.test)("Agent 任务上限与核心保持二万字符且工具结果不含附件字节", async () => {
+    const task = "测".repeat(20_000);
+    strict_1.default.equal((0, tools_1.parseToolArguments)("agents_call", JSON.stringify({ id: "qwenwork", task })).task, task);
+    strict_1.default.throws(() => (0, tools_1.parseToolArguments)("agents_call", JSON.stringify({ id: "qwenwork", task: `${task}试` })), /参数不符合/);
+    const definition = (0, tools_1.toolDefinitions)().find((tool) => tool.function.name === "agents_call");
+    strict_1.default.equal(definition.function.parameters.properties.task.maxLength, 20_000);
+    const result = await (0, tools_1.executeTool)("agents_call", { id: "qwenwork", task: "处理任务" }, { ...management, callAgent: async () => ({ text: "完成", sessionId: "session-1", attachments: [{ data: new Uint8Array([1, 2, 3]), filename: "secret.txt", contentType: "text/plain", kind: "file" }], images: [{ data: new Uint8Array([4, 5]), filename: "image.png", contentType: "image/png" }] }) }, ["qwenwork"]);
+    strict_1.default.deepEqual(result, { text: "完成", sessionId: "session-1", attachments: [{ filename: "secret.txt", contentType: "text/plain" }], attachmentDelivery: "附件将随最终回复自动回传，由通道确认发送结果，无需模型另行读取或发送。" });
+});
+(0, node_test_1.test)("上游小于一秒的超时仍会中止请求", async () => {
+    const plugin = new personal_assistant_1.PersonalAssistantPlugin({ fetch: async (_input, init) => new Promise((_resolve, reject) => {
+            init?.signal?.addEventListener("abort", () => reject(new Error("abort")), { once: true });
+        }) });
+    await plugin.activate({ dataDir: "/tmp", config: { endpoint: "https://example.test/v1/chat/completions", model: "test", apiKey: "secret", allowedPeers: [], allowedAgents: [] }, logger: { info() { }, warn() { }, error() { } }, http: { register: () => undefined, unregister() { } }, callPlugin: async () => ({ text: "" }), pluginStatus: () => "ready" });
+    let timer;
+    try {
+        const result = await Promise.race([plugin.handle({ task: "查询 Agent", timeoutMs: 10, management }), new Promise((resolve) => { timer = setTimeout(() => resolve({ text: "未尊重上游超时" }), 200); })]);
+        strict_1.default.match(result.text, /请求超时/);
+    }
+    finally {
+        clearTimeout(timer);
+        await plugin.deactivate("stop");
+    }
+});
+(0, node_test_1.test)("模型异常日志不回显密钥或任意错误文字", async () => {
+    const logs = [];
+    const plugin = new personal_assistant_1.PersonalAssistantPlugin({ fetch: async () => { throw new Error("request failed apiKey=secret-value arbitrary-provider-error"); } });
+    await plugin.activate({ dataDir: "/tmp", config: { endpoint: "https://example.test/v1/chat/completions", model: "test", apiKey: "secret-value", allowedPeers: [], allowedAgents: [] }, logger: { info() { }, warn(message, fields) { logs.push({ message, fields }); }, error() { } }, http: { register: () => undefined, unregister() { } }, callPlugin: async () => ({ text: "" }), pluginStatus: () => "ready" });
+    await plugin.handle({ task: "查询 Agent", management });
+    strict_1.default.equal(logs.length, 1);
+    strict_1.default.doesNotMatch(JSON.stringify(logs), /secret-value|arbitrary-provider-error/);
+});
+(0, node_test_1.test)("个人助理显式调用保留目标图片且不替换助理会话", async () => {
+    const plugin = new personal_assistant_1.PersonalAssistantPlugin();
+    const images = [{ data: new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]), filename: "画像.png", contentType: "image/png" }];
+    const result = await plugin.handle({ task: "/assistant agent call workbuddy 生成人像", sessionId: "助理会话", management: { ...management, callAgent: async () => ({ text: "完成", sessionId: "目标会话", images }) } });
+    strict_1.default.deepEqual(result.images, images);
+    strict_1.default.notEqual(result.sessionId, "目标会话");
+});
+(0, node_test_1.test)("个人助理自然语言调用回传真实附件，模型只接收附件信息且后续请求不复用附件", async () => {
+    const inputs = [];
+    const plugin = new personal_assistant_1.PersonalAssistantPlugin({ fetch: async (_url, init) => {
+            inputs.push(JSON.parse(String(init?.body)));
+            const message = inputs.length === 1
+                ? { role: "assistant", tool_calls: [{ id: "图片调用", type: "function", function: { name: "agents_call", arguments: '{"id":"workbuddy","task":"生成画像"}' } }] }
+                : { role: "assistant", content: "完成" };
+            return new Response(JSON.stringify({ choices: [{ message }] }));
+        } });
+    await plugin.activate({ config: { endpoint: "https://example.test/v1/chat/completions", model: "test", apiKey: "secret", allowedPeers: ["*"], allowedAgents: ["workbuddy"] } });
+    strict_1.default.equal((await plugin.health()).status, "ready");
+    const attachments = [{ kind: "file", data: new TextEncoder().encode("仅回传给通道的文件正文"), filename: "结果.txt", contentType: "text/plain" }];
+    const mg = { ...management, callAgent: async () => ({ text: "已生成", attachments }) };
+    const result = await plugin.handle({ task: "调用 WorkBuddy", sessionId: "原会话", management: mg });
+    strict_1.default.deepEqual(result.attachments, attachments);
+    strict_1.default.match(inputs[1].messages.at(-1).content, /结果.txt/);
+    strict_1.default.match(inputs[1].messages.at(-1).content, /附件将随最终回复自动回传/);
+    strict_1.default.match(inputs[0].messages[0].content, /不能读取附件字节不代表不能回传/);
+    strict_1.default.doesNotMatch(JSON.stringify(inputs), /仅回传给通道的文件正文|\"data\"/);
+    const next = await plugin.handle({ task: "谢谢", sessionId: "原会话", management: mg });
+    strict_1.default.equal(next.attachments, undefined);
+});
+(0, node_test_1.test)("个人助理保存同会话上下文，隔离其他会话并在重载后保留", async (t) => {
+    const dataDir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "pa-context-reload-"));
+    const inputs = [];
+    const plugin = new personal_assistant_1.PersonalAssistantPlugin({ fetch: async (_url, init) => {
+            inputs.push(JSON.parse(String(init?.body)));
+            return new Response(JSON.stringify({ choices: [{ message: { role: "assistant", content: "已收到" } }] }));
+        } });
+    t.after(async () => { await plugin.deactivate("stop"); await (0, promises_1.rm)(dataDir, { recursive: true, force: true }); });
+    const ctx = { dataDir, config: { endpoint: "https://example.test/v1/chat/completions", model: "test", apiKey: "secret", allowedPeers: [], allowedAgents: [] } };
+    await plugin.activate(ctx);
+    await plugin.handle({ task: "画一位成年人", sessionId: "甲", management: management });
+    await plugin.handle({ task: "风格要古装西域", sessionId: "甲", management: management });
+    strict_1.default.deepEqual(inputs[1].messages.slice(1).map((m) => m.content), ["画一位成年人", "已收到", "风格要古装西域"]);
+    await plugin.handle({ task: "另一个用户", sessionId: "乙", management: management });
+    strict_1.default.equal(inputs[2].messages.length, 2);
+    await plugin.deactivate("reload");
+    await plugin.activate(ctx);
+    await plugin.handle({ task: "重载后", sessionId: "甲", management: management });
+    strict_1.default.deepEqual(inputs[3].messages.slice(1).map((m) => m.content), ["画一位成年人", "已收到", "风格要古装西域", "已收到", "重载后"]);
+});
+(0, node_test_1.test)("个人助理的通配来源配置通过 Schema，未知通配形式仍拒绝", async () => {
+    const { readFile } = await Promise.resolve().then(() => __importStar(require("node:fs/promises")));
+    const schema = JSON.parse(await readFile("plugins/personal-assistant/config.schema.json", "utf8"));
+    const pattern = new RegExp(schema.properties.allowedPeers.items.pattern);
+    strict_1.default.equal(pattern.test("*"), true);
+    strict_1.default.equal(pattern.test("owner.agentid.cn"), true);
+    strict_1.default.equal(pattern.test("*.agentid.cn"), false);
+});
+(0, node_test_1.test)("个人助理持久上下文按整轮裁剪并限制会话数量", async (t) => {
+    const dataDir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "pa-context-limits-"));
+    const inputs = [];
+    const plugin = new personal_assistant_1.PersonalAssistantPlugin({ fetch: async (_url, init) => {
+            inputs.push(JSON.parse(String(init?.body)));
+            return new Response(JSON.stringify({ choices: [{ message: { role: "assistant", content: "收到" } }] }));
+        } });
+    t.after(async () => { await plugin.deactivate("stop"); await (0, promises_1.rm)(dataDir, { recursive: true, force: true }); });
+    await plugin.activate({ dataDir, config: { endpoint: "https://example.test/v1/chat/completions", model: "test", apiKey: "secret", allowedPeers: [], allowedAgents: [] } });
+    const send = (sessionId, task) => plugin.handle({ sessionId, task, management: management });
+    for (let i = 0; i < 22; i++)
+        await send("连续", String(i));
+    strict_1.default.equal(inputs.at(-1).messages.length, 42);
+    strict_1.default.equal(inputs.at(-1).messages[1].content, "1");
+    await send("连续", "长".repeat(120_000));
+    await send("连续", "边界");
+    strict_1.default.equal(inputs.at(-1).messages.length, 2);
+    for (let i = 0; i < 129; i++)
+        await send(String(i), "独立会话");
+    await send("0", "已淘汰");
+    strict_1.default.equal(inputs.at(-1).messages.length, 2);
+});