mu-agent-bridge 1.0.73 → 1.0.78

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

@@ -0,0 +1,117 @@
+"use strict";
+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 session_memory_1 = require("../src-ts/plugins/personal-assistant/session-memory");
+const turn = (content) => [{ role: "user", content }, { role: "assistant", content: `回答：${content}` }];
+const toolTurn = [
+    { role: "user", content: "调用 WorkBuddy 记住 PA_TOOL" },
+    { role: "assistant", content: null, tool_calls: [{ id: "call-1", type: "function", function: { name: "agents_call", arguments: '{"id":"workbuddy","task":"记住 PA_TOOL"}' } }] },
+    { role: "tool", tool_call_id: "call-1", name: "agents_call", content: '{"text":"已记住 PA_TOOL"}' },
+    { role: "assistant", content: "WorkBuddy 已记住" },
+];
+(0, node_test_1.test)("会话历史裁剪保留完整轮次和工具调用配对", async () => {
+    const dataDir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "pa-memory-trim-"));
+    try {
+        const memory = new session_memory_1.PersonalAssistantSessionMemory(dataDir);
+        await memory.save("thread", [...toolTurn, ...Array.from({ length: 19 }, (_, i) => turn(String(i))).flat()]);
+        const result = await memory.load("thread");
+        strict_1.default.equal(result.length, 38);
+        strict_1.default.equal(result[0].role, "user");
+        strict_1.default.equal(result.some(message => message.role === "tool"), false);
+        await memory.save("tool-thread", toolTurn);
+        strict_1.default.deepEqual(await new session_memory_1.PersonalAssistantSessionMemory(dataDir).load("tool-thread"), toolTurn);
+    }
+    finally {
+        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-memory-concurrent-"));
+    try {
+        await (0, promises_1.writeFile)((0, node_path_1.join)(dataDir, "model-sessions.json"), JSON.stringify({ old: turn("旧记录") }));
+        const memory = new session_memory_1.PersonalAssistantSessionMemory(dataDir);
+        strict_1.default.deepEqual(await Promise.all([memory.load("old"), memory.load("old")]), [turn("旧记录"), turn("旧记录")]);
+        await Promise.all(Array.from({ length: 10 }, (_, i) => memory.save(`thread-${i}`, turn(`内容-${i}`))));
+        const restored = new session_memory_1.PersonalAssistantSessionMemory(dataDir);
+        for (let i = 0; i < 10; i++)
+            strict_1.default.deepEqual(await restored.load(`thread-${i}`), turn(`内容-${i}`));
+        if (process.platform !== "win32")
+            strict_1.default.equal((await (0, promises_1.stat)((0, node_path_1.join)(dataDir, "model-sessions.json"))).mode & 0o777, 0o600);
+    }
+    finally {
+        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-memory-invalid-"));
+    const warnings = [];
+    try {
+        const file = (0, node_path_1.join)(dataDir, "model-sessions.json");
+        await (0, promises_1.writeFile)(file, '{"private-token-secret-value": malformed');
+        const memory = new session_memory_1.PersonalAssistantSessionMemory(dataDir, (...args) => warnings.push(args));
+        strict_1.default.deepEqual(await memory.load("old"), []);
+        strict_1.default.equal(warnings.length, 1);
+        strict_1.default.doesNotMatch(JSON.stringify(warnings), /private-token-secret-value/);
+        await (0, promises_1.writeFile)(file, JSON.stringify({ good: turn("可用"), bad: [{ role: "user", content: "测试", secret: "private-token-secret-value" }, { role: "tool", content: "孤立工具结果", tool_call_id: "missing" }] }));
+        const restored = new session_memory_1.PersonalAssistantSessionMemory(dataDir);
+        strict_1.default.deepEqual(await restored.load("good"), turn("可用"));
+        strict_1.default.deepEqual(await restored.load("bad"), []);
+    }
+    finally {
+        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-memory-limit-"));
+    try {
+        const memory = new session_memory_1.PersonalAssistantSessionMemory(dataDir);
+        await memory.save("large", turn("字".repeat(121_000)));
+        strict_1.default.ok(JSON.stringify(await memory.load("large")).length <= 120_000);
+        for (let i = 0; i < 130; i++)
+            await memory.save(`s-${i}`, turn(String(i)));
+        const raw = JSON.parse(await (0, promises_1.readFile)((0, node_path_1.join)(dataDir, "model-sessions.json"), "utf8"));
+        strict_1.default.equal(Object.keys(raw).length, 128);
+        strict_1.default.deepEqual(await memory.load("s-0"), []);
+        strict_1.default.deepEqual(await memory.load("s-129"), turn("129"));
+    }
+    finally {
+        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-memory-write-failure-"));
+    const warnings = [];
+    try {
+        const blocked = (0, node_path_1.join)(dataDir, "不可写目录");
+        await (0, promises_1.writeFile)(blocked, "阻挡目录创建");
+        const memory = new session_memory_1.PersonalAssistantSessionMemory(blocked, (...args) => warnings.push(args));
+        await memory.save("thread", turn("有效回复"));
+        strict_1.default.deepEqual(await memory.load("thread"), turn("有效回复"));
+        strict_1.default.ok(JSON.stringify(warnings).includes("保存失败"));
+        strict_1.default.doesNotMatch(JSON.stringify(warnings), /有效回复|不可写目录/);
+    }
+    finally {
+        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-memory-invalid-save-"));
+    const warnings = [];
+    try {
+        const memory = new session_memory_1.PersonalAssistantSessionMemory(dataDir, (...args) => warnings.push(args));
+        await memory.save("thread", turn("先前回复"));
+        await memory.save("thread", [{ role: "tool", content: "孤立结果", tool_call_id: "missing" }]);
+        strict_1.default.deepEqual(await memory.load("thread"), turn("先前回复"));
+        strict_1.default.ok(JSON.stringify(warnings).includes("格式无效"));
+    }
+    finally {
+        await (0, promises_1.rm)(dataDir, { recursive: true, force: true });
+    }
+});

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

@@ -1,10 +1,47 @@
 "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");
@@ -17,6 +54,135 @@ const management = {
     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) => {
@@ -72,11 +238,40 @@ const 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) => {
@@ -108,9 +303,9 @@ const management = {
         await plugin.deactivate("stop");
     }
 });
-(0, node_test_1.test)("插件模型的坏 JSON 和无效决策在执行任一工具前被拒绝", async () => {
+(0, node_test_1.test)("插件模型的无效 JSON 决策在执行任一工具前被拒绝", async () => {
     let executed = 0;
-    for (const raw of ["不是 JSON", JSON.stringify({ role: "assistant", content: {}, tool_calls: [] }), JSON.stringify({ role: "assistant", content: null, tool_calls: [
+    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" } },
             ] })]) {
@@ -362,7 +557,7 @@ const management = {
     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" });
+    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) => {
@@ -387,3 +582,82 @@ const 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);
+});

package/dist/tests-ts/platform-integration.test.js

@@ -18,7 +18,7 @@ const qwenwork_1 = require("../src-ts/plugins/qwenwork");
     const state = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "agent-bridge-platform-"));
     const manager = new plugin_manager_1.PluginManager({ pluginsDir: (0, node_path_1.resolve)(process.cwd(), "plugins"), stateDir: state });
     const records = await manager.discover();
-    strict_1.default.deepEqual(records.map((record) => record.id).sort(), ["abweb", "aun", "chatgpt", "claude-cli", "codex-cli", "doubao", "dsh", "feishu", "personal-assistant", "qwenwork", "workbuddy"]);
+    strict_1.default.deepEqual(records.map((record) => record.id).sort(), ["abweb", "aun", "chatgpt", "claude-cli", "codex-cli", "doubao", "dsh", "feishu", "personal-assistant", "qwenwork", "workbuddy", "zcode"]);
     strict_1.default.equal(records.find((record) => record.id === "aun")?.type, "channel");
     const server = new control_server_1.ControlServer({ manager, host: "127.0.0.1", port: 0 });
     const address = await server.start();
@@ -171,6 +171,65 @@ const qwenwork_1 = require("../src-ts/plugins/qwenwork");
         await (0, promises_1.rm)(state, { recursive: true, force: true });
     }
 });
+(0, node_test_1.default)("个人助理默认白名单允许任意 AUN Peer 调用所有 Agent，显式限制优先", async () => {
+    const root = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "mab-assistant-defaults-"));
+    const pluginsDir = (0, node_path_1.join)(root, "plugins");
+    const stateDir = (0, node_path_1.join)(root, "state");
+    const desktops = ["workbuddy", "qwenwork", "doubao", "dsh", "chatgpt"];
+    const manager = new plugin_manager_1.PluginManager({ pluginsDir, stateDir });
+    try {
+        await (0, promises_1.mkdir)(pluginsDir, { recursive: true });
+        await (0, promises_1.cp)((0, node_path_1.join)(process.cwd(), "plugins", "personal-assistant"), (0, node_path_1.join)(pluginsDir, "personal-assistant"), { recursive: true });
+        await (0, promises_1.symlink)((0, node_path_1.resolve)(process.cwd(), "node_modules"), (0, node_path_1.join)(root, "node_modules"), "dir");
+        const addPlugin = async (id) => {
+            const dir = (0, node_path_1.join)(pluginsDir, id);
+            await (0, promises_1.mkdir)(dir);
+            await (0, promises_1.writeFile)((0, node_path_1.join)(dir, "plugin.json"), JSON.stringify({ id, version: "1.0.0", type: id === "aun" ? "channel" : "agent", entry: "index.js", apiVersion: "1", capabilities: id === "aun" ? ["channel"] : ["chat"] }));
+            await (0, promises_1.writeFile)((0, node_path_1.join)(dir, "index.js"), "module.exports=class{async activate(c){this.ingress=c.ingress}async deactivate(){}async health(){return {status:'ready'}}async handle(r){return {text:'目标已处理：'+r.task}}async publish(m){return this.ingress.publish(m)}};");
+        };
+        for (const id of [...desktops, "codex-cli", "aun"])
+            await addPlugin(id);
+        await manager.discover();
+        strict_1.default.deepEqual((await manager.config("personal-assistant")).allowedPeers, []);
+        strict_1.default.deepEqual((await manager.config("personal-assistant")).allowedAgents, []);
+        await manager.start("personal-assistant");
+        strict_1.default.equal((await manager.health("personal-assistant")).status, "ready");
+        for (const id of [...desktops, "codex-cli"]) {
+            await manager.saveConfig(id, { executablePath: process.execPath });
+            await manager.start(id);
+        }
+        await manager.start("aun");
+        const channel = manager.get("aun").instance;
+        const send = async (peerId, id) => {
+            let reply = "";
+            await channel.publish({ channel: "aun", peerId, agentPlugin: "personal-assistant", text: `/assistant agent call ${id} 默认测试`, reply: async (text) => { reply = text; } });
+            return reply;
+        };
+        for (const id of desktops)
+            strict_1.default.equal(await send(`${id}.agentid.cn`, id), "目标已处理：默认测试");
+        strict_1.default.equal(await send("any.agentid.cn", "codex-cli"), "目标已处理：默认测试");
+        await addPlugin("new-agent");
+        await manager.discover();
+        await manager.start("new-agent");
+        strict_1.default.equal(await send("newpeer.agentid.cn", "new-agent"), "目标已处理：默认测试");
+        await manager.saveConfig("personal-assistant", { allowedPeers: ["owner.agentid.cn"], allowedAgents: ["workbuddy"] });
+        strict_1.default.match(await send("any.agentid.cn", "workbuddy"), /授权的 AUN/);
+        strict_1.default.equal(await send("owner.agentid.cn", "workbuddy"), "目标已处理：默认测试");
+        strict_1.default.match(await send("owner.agentid.cn", "dsh"), /白名单/);
+        await manager.saveConfig("personal-assistant", { allowedPeers: [], allowedAgents: [] });
+        strict_1.default.equal(await send("owner.agentid.cn", "workbuddy"), "目标已处理：默认测试");
+        strict_1.default.equal(await send("new-peer.agentid.cn", "dsh"), "目标已处理：默认测试");
+        strict_1.default.deepEqual((await manager.config("personal-assistant")).allowedPeers, []);
+        strict_1.default.deepEqual((await manager.config("personal-assistant")).allowedAgents, []);
+    }
+    finally {
+        for (const record of manager.list())
+            if (manager.get(record.id)?.instance)
+                await manager.stop(record.id);
+        await manager.logs.flush();
+        await (0, promises_1.rm)(root, { recursive: true, force: true });
+    }
+});
 (0, node_test_1.default)("model manifests keep the platform defaults and explicit doubao degraded adapter", async () => {
     strict_1.default.equal(qwenwork_1.qwenworkManifest.defaults.cdpPort, 9228);
     strict_1.default.equal(qwenwork_1.qwenworkManifest.defaults.httpPort, 17893);