mu-agent-bridge 1.0.71 → 1.0.73

package/dist/tests-ts/channel-sessions.test.js

@@ -161,6 +161,33 @@ const message = (text, extra = {}) => ({
         await (0, promises_1.rm)(root, { recursive: true, force: true });
     }
 });
+(0, node_test_1.default)("逻辑会话 ID 在 Agent 调用前可见且续用，调用失败不保存新绑定", async () => {
+    const root = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "mab-session-logical-callback-"));
+    try {
+        const sessions = new channel_sessions_1.ChannelSessions(root);
+        let firstId = "";
+        await sessions.run(message("首次"), "agent", async (_sessionId, _newSession, logicalSessionId) => {
+            strict_1.default.match(logicalSessionId, /^[0-9a-f-]{36}$/i);
+            firstId = logicalSessionId;
+            return { text: "完成" };
+        });
+        await sessions.run(message("继续"), "agent", async (_sessionId, _newSession, logicalSessionId) => {
+            strict_1.default.equal(logicalSessionId, firstId);
+            return { text: "继续完成" };
+        });
+        const other = message("另一个话题", { threadId: "topic-2" });
+        let failedId = "";
+        await strict_1.default.rejects(sessions.run(other, "agent", async (_sessionId, _newSession, logicalSessionId) => {
+            failedId = logicalSessionId;
+            strict_1.default.notEqual(failedId, firstId);
+            throw new Error("Agent失败");
+        }), /Agent失败/);
+        strict_1.default.equal((await sessions.current(other, "agent")).logicalSessionId === failedId, false);
+    }
+    finally {
+        await (0, promises_1.rm)(root, { recursive: true, force: true });
+    }
+});
 (0, node_test_1.default)("切换插件的普通调用失败时保留原活动会话和后端续聊目标", async () => {
     const root = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "mab-session-plugin-failure-"));
     try {

package/dist/tests-ts/chatgpt-plugin.test.js

@@ -38,6 +38,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const strict_1 = __importDefault(require("node:assert/strict"));
 const node_test_1 = __importDefault(require("node:test"));
+const node_vm_1 = require("node:vm");
 const chatgpt_1 = require("../src-ts/plugins/chatgpt");
 (0, node_test_1.default)("ChatGPT 插件通过已连接 CDP 客户端转发请求", async () => {
     const calls = [];
@@ -94,6 +95,35 @@ const chatgpt_1 = require("../src-ts/plugins/chatgpt");
         await rm(dataDir, { recursive: true, force: true });
     }
 });
+(0, node_test_1.default)("ChatGPT 模型来源为个人助理建立专用会话，不复用桌面当前会话", async () => {
+    const { mkdtemp, rm } = await Promise.resolve().then(() => __importStar(require("node:fs/promises")));
+    const { tmpdir } = await Promise.resolve().then(() => __importStar(require("node:os")));
+    const { join } = await Promise.resolve().then(() => __importStar(require("node:path")));
+    const dataDir = await mkdtemp(join(tmpdir(), "chatgpt-model-provider-"));
+    const existing = { id: "user-chat", host: "h", title: "用户会话" };
+    const dedicated = { id: "pa-chat", host: "h", title: "个人助理模型" };
+    let active = existing;
+    const calls = [];
+    const client = {
+        connect: async () => undefined, close() { }, connected: () => true,
+        listSessions: async () => [existing, dedicated],
+        activeSession: async () => active,
+        createSession: async () => { active = dedicated; return dedicated; },
+        switchSession: async (session) => { active = session; },
+        direct: async (text) => { calls.push(`${active.id}:${text}`); return "模型 JSON"; },
+    };
+    const plugin = new chatgpt_1.ChatgptPlugin({ client });
+    try {
+        await plugin.activate({ config: {}, dataDir, logger: { info() { }, warn() { }, error() { } } });
+        strict_1.default.deepEqual(await plugin.modelProvider.complete({ prompt: "模型提示", sessionId: "pa-thread", timeoutMs: 5000, signal: new AbortController().signal }), { text: "模型 JSON" });
+        strict_1.default.deepEqual(calls, ["pa-chat:模型提示"]);
+        strict_1.default.equal(active.id, "user-chat");
+    }
+    finally {
+        await plugin.deactivate();
+        await rm(dataDir, { recursive: true, force: true });
+    }
+});
 (0, node_test_1.default)("ChatGPT 一个来源待确认的新会话不阻塞其他来源", async () => {
     const { mkdtemp, rm } = await Promise.resolve().then(() => __importStar(require("node:fs/promises")));
     const { tmpdir } = await Promise.resolve().then(() => __importStar(require("node:os")));
@@ -773,3 +803,72 @@ const chatgpt_1 = require("../src-ts/plugins/chatgpt");
     });
     strict_1.default.deepEqual(await client.direct("返回附件", 5000), { text: "", attachments: [attachment] });
 });
+(0, node_test_1.default)("ChatGPT 模型取消立即结束等待并保留原队列，普通消息恢复用户会话", async () => {
+    const user = { id: "user", host: "h", title: "用户任务" };
+    const model = { id: "model", host: "h", title: "模型会话" };
+    let active = user;
+    let release;
+    const calls = [];
+    const plugin = new chatgpt_1.ChatgptPlugin({ client: {
+            connect: async () => undefined, close() { }, connected: () => true,
+            listSessions: async () => [user, model], activeSession: async () => active,
+            createSession: async () => { calls.push("create"); active = model; return model; },
+            switchSession: async (session) => { active = session; },
+            direct: async (text) => { calls.push(`${active.id}:${text}`); if (text === "模型提示")
+                await new Promise(resolve => { release = resolve; }); return "回复"; },
+        } });
+    await plugin.activate({ config: {}, logger: { info() { }, warn() { }, error() { } } });
+    const controller = new AbortController();
+    let error;
+    const generating = plugin.modelProvider.complete({ prompt: "模型提示", sessionId: "pa-cancel", timeoutMs: 5000, signal: controller.signal }).catch((value) => { error = value; });
+    await new Promise(resolve => setImmediate(resolve));
+    const normal = plugin.handle({ task: "用户续聊" });
+    controller.abort(new Error("取消模型等待"));
+    await new Promise(resolve => setImmediate(resolve));
+    const canceledImmediately = Boolean(error);
+    const callsBeforeReply = [...calls];
+    release();
+    await generating;
+    await normal;
+    await plugin.deactivate();
+    strict_1.default.equal(canceledImmediately, true);
+    strict_1.default.match(error.stage, /generate/);
+    strict_1.default.deepEqual(callsBeforeReply, ["create", "model:模型提示"]);
+    strict_1.default.deepEqual(calls, ["create", "model:模型提示", "user:用户续聊"]);
+});
+(0, node_test_1.default)("ChatGPT 模型来源在断线时拒绝且不调用桌面恢复", async () => {
+    let connected = true;
+    let reconnects = 0;
+    let creates = 0;
+    const chat = { id: "user", host: "h", title: "用户任务" };
+    const plugin = new chatgpt_1.ChatgptPlugin({ client: {
+            connect: async () => undefined, close() { }, connected: () => connected,
+            listSessions: async () => [chat], activeSession: async () => chat,
+            createSession: async () => { creates++; return chat; }, switchSession: async () => undefined,
+            direct: async () => "回复",
+        } });
+    await plugin.activate({ config: {}, logger: { info() { }, warn() { }, error() { } } });
+    plugin.reconnect = async () => { reconnects++; connected = true; };
+    connected = false;
+    const error = await plugin.modelProvider.complete({ prompt: "模型提示", sessionId: "pa-offline", timeoutMs: 5000, signal: new AbortController().signal }).then(() => undefined, (value) => value);
+    await plugin.deactivate();
+    strict_1.default.match(String(error), /连接|断开/);
+    strict_1.default.equal(reconnects, 0);
+    strict_1.default.equal(creates, 0);
+});
+(0, node_test_1.default)("ChatGPT 模型新建、切换和提交时保留用户草稿", async () => {
+    for (const operation of ["create", "switch", "direct"]) {
+        const client = new chatgpt_1.ChatgptCdpClient();
+        const editor = { innerText: "用户正在编辑" };
+        let edits = 0, clicks = 0;
+        client.recoverDraft = async () => { edits++; editor.innerText = ""; };
+        client.waitFor = async () => undefined;
+        client.activeSession = async () => undefined;
+        client.evaluate = async (expression) => (0, node_vm_1.runInNewContext)(expression, {
+            document: { querySelector: (selector) => selector.includes("contenteditable") ? editor : null, querySelectorAll: (selector) => selector.includes("sidebar-thread-id") || selector.startsWith("button,") ? [{ textContent: "新聊天", getAttribute: (key) => key.endsWith("thread-id") ? "model" : key.endsWith("host-id") ? "h" : null, click() { clicks++; } }] : [] },
+        });
+        const run = () => operation === "create" ? client.createSession(undefined, true) : operation === "switch" ? client.switchSession({ id: "model", host: "h", title: "模型" }, true) : client.directTurn("模型提示", 1, undefined, "slot", "out", Date.now(), undefined, true);
+        await strict_1.default.rejects(run(), /未发送内容/);
+        strict_1.default.deepEqual({ edits, clicks, text: editor.innerText }, { edits: 0, clicks: 0, text: "用户正在编辑" });
+    }
+});

package/dist/tests-ts/control-server.test.js

@@ -118,6 +118,20 @@ const plugin_manager_1 = require("../src-ts/plugin-manager");
         await server.stop();
     }
 });
+(0, node_test_1.default)("control server exposes dynamic model provider status without plugin configuration", async () => {
+    const modelProviders = [{ id: "qwenwork", displayName: "千问办公", status: "ready", available: true, reason: "" }];
+    const manager = { list: () => [], listModelProviders: () => modelProviders };
+    const server = new control_server_1.ControlServer({ manager, host: "127.0.0.1", port: 0 });
+    const address = await server.start();
+    try {
+        const response = await fetch(`http://${address.host}:${address.port}/api/model-providers`);
+        strict_1.default.equal(response.status, 200);
+        strict_1.default.deepEqual(await response.json(), { providers: modelProviders });
+    }
+    finally {
+        await server.stop();
+    }
+});
 (0, node_test_1.default)("信任管理 API 支持查询、变更和拒绝无效配置", async () => {
     const root = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "mab-trust-api-"));
     const previous = process.env.AGENT_BRIDGE_TRUSTED_PACKAGES;
@@ -182,6 +196,28 @@ const plugin_manager_1 = require("../src-ts/plugin-manager");
         await server.stop();
     }
 });
+(0, node_test_1.default)("版本和下载 API 使用已安装插件的真实 npm 包名", async () => {
+    const calls = [];
+    const record = { id: "personal-assistant", packageName: "agent-bridge-pa", version: "1.0.0" };
+    const status = { packageName: "agent-bridge-pa", state: "update-available" };
+    const manager = {
+        list: () => [record], versions: { get: (name) => name === "agent-bridge-pa" ? status : undefined },
+        packageInfo: () => ({ packageName: record.packageName }),
+        downloadPackage: async (...args) => { calls.push(args); return "下载目录"; },
+    };
+    const server = new control_server_1.ControlServer({ manager, host: "127.0.0.1", port: 0 });
+    const address = await server.start();
+    try {
+        const base = `http://${address.host}:${address.port}`;
+        strict_1.default.deepEqual((await (await fetch(`${base}/api/versions`)).json()).plugins[0].versionStatus, status);
+        const response = await fetch(`${base}/api/plugins/personal-assistant/download`, { method: "POST", body: JSON.stringify({ version: "1.0.1" }) });
+        strict_1.default.equal(response.status, 200);
+        strict_1.default.deepEqual(calls, [["agent-bridge-pa", "1.0.1"]]);
+    }
+    finally {
+        await server.stop();
+    }
+});
 (0, node_test_1.default)("control server dispatches plugin HTTP routes and unregisters them on stop", async () => {
     const root = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "agent-bridge-http-plugin-"));
     try {

package/dist/tests-ts/doubao-plugin.test.js

@@ -123,6 +123,27 @@ function deferred() {
         await legacy.deactivate();
     }
 });
+(0, node_test_1.default)("豆包模型来源由服务端创建独立会话，不切换用户桌面", async () => {
+    const controller = new AbortController();
+    const calls = [];
+    const client = {
+        async connect() { }, async close() { }, connected: () => true, direct: async () => "不应使用普通入口",
+        createSession: async () => { calls.push("create"); },
+        complete: async (text, signal, _items, conversationId) => {
+            calls.push([text, signal, conversationId]);
+            return { text: "模型 JSON", sessionId: "314159" };
+        },
+    };
+    const plugin = new doubao_1.DoubaoPlugin(client);
+    try {
+        await plugin.activate({ config: {} });
+        strict_1.default.deepEqual(await plugin.modelProvider.complete({ prompt: "模型提示", sessionId: "pa-thread", timeoutMs: 5000, signal: controller.signal }), { text: "模型 JSON" });
+        strict_1.default.deepEqual(calls, [["模型提示", controller.signal, ""]]);
+    }
+    finally {
+        await plugin.deactivate();
+    }
+});
 (0, node_test_1.default)("豆包在访问页面前明确拒绝视频与不支持的文件类型", async () => {
     const client = new cdp_client_1.DoubaoCdpClient();
     for (const [filename, contentType, error] of [["clip.mp4", "video/mp4", /不支持视频/], ["archive.zip", "application/zip", /不支持.*文件类型/]]) {
@@ -754,3 +775,74 @@ for (const late of ["成功", "失败"]) {
         await plugin.deactivate();
     }
 });
+(0, node_test_1.default)("豆包模型排队取消不新建会话，生成取消后仍等待底层结束", async () => {
+    let release;
+    const calls = [];
+    const plugin = new doubao_1.DoubaoPlugin({
+        connect: async () => undefined, close: async () => undefined, connected: () => true,
+        direct: async () => "回复", createSession: async () => { calls.push("create"); },
+        complete: async (text) => { calls.push(text); if (text === "模型提示")
+            await new Promise(resolve => { release = resolve; }); return { text: "回复", sessionId: "123" }; },
+    });
+    await plugin.activate({ config: {} });
+    const activeController = new AbortController();
+    let error;
+    const generating = plugin.modelProvider.complete({ prompt: "模型提示", sessionId: "pa-active", timeoutMs: 5000, signal: activeController.signal }).catch((value) => { error = value; });
+    await new Promise(resolve => setImmediate(resolve));
+    const queuedController = new AbortController();
+    let queuedError;
+    const queued = plugin.modelProvider.complete({ prompt: "不应发送", sessionId: "pa-queued", timeoutMs: 5000, signal: queuedController.signal }).catch((value) => { queuedError = value; });
+    activeController.abort(new Error("取消生成等待"));
+    queuedController.abort(new Error("取消排队等待"));
+    await new Promise(resolve => setImmediate(resolve));
+    const rejectedImmediately = Boolean(error && queuedError);
+    const before = [...calls];
+    release();
+    await Promise.all([generating, queued]);
+    await plugin.handle({ task: "普通任务" });
+    await plugin.deactivate();
+    strict_1.default.equal(rejectedImmediately, true);
+    strict_1.default.match(error.stage, /generate/);
+    strict_1.default.match(queuedError.stage, /queue/);
+    strict_1.default.deepEqual(before, ["模型提示"]);
+    strict_1.default.deepEqual(calls, ["模型提示", "普通任务"]);
+});
+(0, node_test_1.default)("豆包模型断线时不调用可能重启桌面的恢复入口", async () => {
+    let connected = true;
+    let reconnects = 0;
+    let creates = 0;
+    const plugin = new doubao_1.DoubaoPlugin({
+        connect: async () => undefined, close: async () => undefined, connected: () => connected,
+        direct: async () => "回复", createSession: async () => { creates++; }, complete: async () => ({ text: "回复", sessionId: "123" }),
+    });
+    await plugin.activate({ config: {} });
+    plugin.reconnect = async () => { reconnects++; connected = true; };
+    connected = false;
+    const error = await plugin.modelProvider.complete({ prompt: "模型提示", sessionId: "pa-offline", timeoutMs: 5000, signal: new AbortController().signal }).then(() => undefined, (value) => value);
+    await plugin.deactivate();
+    strict_1.default.ok(error);
+    strict_1.default.equal(reconnects, 0);
+    strict_1.default.equal(creates, 0);
+});
+(0, node_test_1.default)("豆包取消后仍读取真实页面请求的迟到结果，不提前释放内部队列", async (t) => {
+    t.mock.timers.enable({ apis: ["setTimeout", "Date"] });
+    const client = new cdp_client_1.DoubaoCdpClient({ timeoutMs: 10 });
+    const controller = new AbortController();
+    let polled = false;
+    let settled = false;
+    client.connect = async () => undefined;
+    client.evaluate = async (expression) => {
+        if (expression === "window.__mab_doubao_result") {
+            polled = true;
+            return JSON.stringify({ ok: true, reply: "迟到回复", conversationId: "123" });
+        }
+    };
+    const running = client.complete("模型提示", controller.signal, undefined, "").then((value) => { settled = true; return value; });
+    await new Promise(resolve => setImmediate(resolve));
+    controller.abort(new Error("停止等待"));
+    await new Promise(resolve => setImmediate(resolve));
+    strict_1.default.equal(settled, false);
+    t.mock.timers.tick(1000);
+    strict_1.default.deepEqual(await running, { text: "迟到回复", sessionId: "123" });
+    strict_1.default.equal(polled, true);
+});

package/dist/tests-ts/dsh-agent.test.js

@@ -77,6 +77,18 @@ function fakeSpawn(_file, _args, _options) {
     strict_1.default.equal(captured.includes("--session-id"), false);
     strict_1.default.equal(response.sessionId, "session-1");
 });
+(0, node_test_1.default)("DSH 模型入口只发送决策提示，不追加普通附件任务指令", async () => {
+    let input = "";
+    const spawn = (file, args, options) => {
+        const child = fakeSpawn(file, args, options);
+        const end = child.stdin.end;
+        child.stdin.end = (task) => { input = task; end(task); };
+        return child;
+    };
+    const agent = new dsh_agent_1.DshAgent({ patchPath: "patch.yml", paths: { executable: "dsh.exe", cli: "cli.js", patch: "patch.yml" }, spawn });
+    await agent.send({ task: "只返回结构化决策" }, true);
+    strict_1.default.equal(input, "只返回结构化决策");
+});
 (0, node_test_1.default)("DSH 新会话缺少真实 ID 时拒绝用逻辑 ID 冒充创建成功", async () => {
     const spawn = () => {
         const child = fakeSpawn("", [], {});
@@ -89,6 +101,25 @@ function fakeSpawn(_file, _args, _options) {
     const agent = new dsh_agent_1.DshAgent({ patchPath: "patch.yml", paths: { executable: "dsh.exe", cli: "cli.js", patch: "patch.yml" }, spawn });
     await strict_1.default.rejects(agent.send({ task: "首条消息", sessionId: "logical-id", newSession: true }), /未返回真实新会话标识/);
 });
+(0, node_test_1.default)("DSH 取消时只终止本次启动的 CLI 子进程", async () => {
+    let child;
+    let killed = 0;
+    const spawn = () => {
+        child = new node_events_1.EventEmitter();
+        child.stdin = { end: () => undefined };
+        child.stdout = new node_events_1.EventEmitter();
+        child.stderr = new node_events_1.EventEmitter();
+        child.kill = () => { killed++; queueMicrotask(() => child.emit("close", null)); return true; };
+        return child;
+    };
+    const agent = new dsh_agent_1.DshAgent({ patchPath: "patch.yml", paths: { executable: "dsh.exe", cli: "cli.js", patch: "patch.yml" }, spawn, defaultTimeoutMs: 20 });
+    const controller = new AbortController();
+    const task = agent.send({ task: "长任务", signal: controller.signal });
+    await new Promise((resolve) => setImmediate(resolve));
+    controller.abort(new Error("模型请求已取消"));
+    await strict_1.default.rejects(task, /模型请求已取消/);
+    strict_1.default.equal(killed, 1);
+});
 (0, node_test_1.default)("DSH 附件先落盘供真实工具读取，成功 present 后回传原字节与 MIME 并清理临时目录", async () => {
     const { readFile, copyFile, access } = await Promise.resolve().then(() => __importStar(require("node:fs/promises")));
     const { join } = await Promise.resolve().then(() => __importStar(require("node:path")));
@@ -255,3 +286,49 @@ function presentSpawn(prepare, status = "completed", text = "已完成") {
         await (0, promises_1.rm)(root, { recursive: true, force: true });
     }
 });
+(0, node_test_1.default)("DSH 模型排队取消立即返回，下一请求在原 CLI 关闭后继续", async () => {
+    const plugin = new dsh_1.DshPlugin();
+    let release;
+    const sent = [];
+    plugin.status = "ready";
+    plugin.agent = { send: async (request) => { sent.push(request); if (request.task === "用户任务")
+            await new Promise(resolve => { release = resolve; }); return { text: "回复", sessionId: "desktop-session" }; } };
+    const running = plugin.handle({ task: "用户任务" });
+    await new Promise(resolve => setImmediate(resolve));
+    const controller = new AbortController();
+    let error;
+    const model = plugin.modelProvider.complete({ prompt: "不应发送", sessionId: "pa-queued", timeoutMs: 5000, signal: controller.signal }).catch((value) => { error = value; });
+    controller.abort(new Error("排队取消"));
+    await new Promise(resolve => setImmediate(resolve));
+    const canceledImmediately = Boolean(error);
+    release();
+    await Promise.all([running, model]);
+    await plugin.handle({ task: "用户续聊" });
+    await plugin.deactivate();
+    strict_1.default.equal(canceledImmediately, true);
+    strict_1.default.match(error.stage, /queue/);
+    strict_1.default.deepEqual(sent, [{ task: "用户任务" }, { task: "用户续聊" }]);
+});
+(0, node_test_1.default)("DSH 模型会话在重载后恢复，普通任务不写入模型映射", async () => {
+    const directory = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "dsh-model-session-"));
+    const executablePath = (0, node_path_1.join)(directory, "DeepSeek Harness.exe");
+    await (0, promises_1.writeFile)(executablePath, "");
+    const requests = [];
+    try {
+        for (let round = 0; round < 2; round++) {
+            const plugin = new dsh_1.DshPlugin();
+            await plugin.activate({ config: { executablePath }, dataDir: directory });
+            plugin.agent = { send: async (request) => { requests.push(request); return { text: "模型回复", sessionId: "native-model-session" }; } };
+            await plugin.handle({ task: "普通用户任务", sessionId: "ordinary-session" });
+            await plugin.modelProvider.complete({ prompt: "模型提示", sessionId: "pa-logical", timeoutMs: 1000, signal: new AbortController().signal });
+            await plugin.deactivate();
+        }
+        strict_1.default.equal(requests[1].newSession, true);
+        strict_1.default.equal(requests[3].sessionId, "native-model-session");
+        strict_1.default.equal(requests[3].newSession, undefined);
+        strict_1.default.deepEqual(JSON.parse(await (0, promises_1.readFile)((0, node_path_1.join)(directory, "model-provider-sessions.json"), "utf8")), { "pa-logical": "native-model-session" });
+    }
+    finally {
+        await (0, promises_1.rm)(directory, { recursive: true, force: true });
+    }
+});

package/dist/tests-ts/feishu-plugin.test.js

@@ -231,7 +231,7 @@ const feishu_1 = require("../src-ts/plugins/feishu");
         const manifest = JSON.parse(response.body);
         strict_1.default.deepEqual(manifest.commands.map((command) => command.name), ["status", "list", "agents", "configure", "bind", "unbind"]);
         strict_1.default.equal(manifest.protocolVersion, 1);
-        strict_1.default.equal(manifest.version, "1.0.5");
+        strict_1.default.equal(manifest.version, "1.0.7");
         const run = async (...argv) => {
             response.statusCode = 0;
             await postCommands(node_stream_1.Readable.from([JSON.stringify({ protocolVersion: 1, argv })]), response);

package/dist/tests-ts/installer-assets.test.js

@@ -48,7 +48,7 @@ const node_util_1 = require("node:util");
     strict_1.default.match(setup, /Get-Command npm\.cmd/);
     strict_1.default.match(setup, /\$npmCommand\.Source prefix --global/);
     strict_1.default.match(setup, /@\(\$nodeDirectory, \$npmDirectory, \$npmPrefix\)/);
-    strict_1.default.match(setup, /mu-agent-bridge@latest --engine-strict/);
+    strict_1.default.match(setup, /mu-agent-bridge@\{1\} --engine-strict/);
     strict_1.default.match(setup, /--prefer-online/);
     strict_1.default.match(setup, /npm 安装遇到版本尚未同步或文件占用.*重试/);
     strict_1.default.doesNotMatch(setup, /mu-agent-bridge@\d+\.\d+\.\d+/);

package/dist/tests-ts/local-cli.test.js

@@ -16,7 +16,7 @@ const fixture = String.raw `
 const fs = require('node:fs'); const {randomUUID}=require('node:crypto');
 const args=process.argv.slice(2);
 if(args.includes('--version')) { console.log('1.0.0'); process.exit(0); }
-if(args.includes('--help')) { console.log('exec resume --json --print --output-format --resume'); process.exit(0); }
+if(args.includes('--help')) { console.log('exec resume --json --print --output-format --resume --json-schema --tools --strict-mcp-config --mcp-config --no-session-persistence --settings --setting-sources --output-schema --ephemeral --sandbox --disable --config --ignore-rules'); process.exit(0); }
 let input=''; process.stdin.setEncoding('utf8'); process.stdin.on('data',x=>input+=x);
 process.stdin.on('end',()=>{
  fs.appendFileSync('calls.jsonl',JSON.stringify({args,input})+'\n');
@@ -25,6 +25,8 @@ process.stdin.on('end',()=>{
  if(input==='permission') {console.error('permission denied EACCES'); process.exit(9);}
  if(input==='structured-error') { if(args[0]==='exec') console.log(JSON.stringify({type:'turn.failed',error:{message:'E_AUTH_42 登录失败'}})); else console.log(JSON.stringify({type:'result',is_error:true,errors:['E_AUTH_42 登录失败']})); return; }
  if(input==='malformed') {console.log('{}'); return;}
+ if(args.includes('--json-schema')) {console.log(JSON.stringify({type:'result',session_id:randomUUID(),is_error:false,result:'',...(input==='missing-structured'?{}:{structured_output:{text:'模型回复'}})}));return;}
+ if(args.includes('--output-schema')) { const id=randomUUID(); console.log(JSON.stringify({type:'thread.started',thread_id:id})); console.log(JSON.stringify({type:'item.completed',item:{type:'agent_message',text:JSON.stringify({text:'模型回复'})}})); console.log(JSON.stringify({type:'turn.completed'})); return; }
  const codex=args[0]==='exec'; const resume=codex?args.indexOf('resume'):args.indexOf('--resume');
  let id=resume>=0?args[resume+1]:randomUUID();
  if(input==='wrong-session') id=randomUUID();
@@ -108,6 +110,122 @@ for (const [name, Constructor] of [["Codex", codex_cli_1.default], ["Claude", cl
         await strict_1.default.rejects(plugin.handle({ task: "recall" }), /未启动|停止/);
     });
 }
+(0, node_test_1.default)("Claude 无工具模型请求使用默认模型及结构化输出，不保存聊天映射", async (t) => {
+    const { root, context } = await setup(t);
+    const plugin = new claude_cli_1.default();
+    await plugin.activate(context);
+    try {
+        const modelResponseSchema = { type: "object", properties: { text: { type: "string" } }, required: ["text"], additionalProperties: false };
+        const response = await plugin.handle({ task: "模型请求", modelResponseSchema });
+        strict_1.default.deepEqual(JSON.parse(response.text), { text: "模型回复" });
+        strict_1.default.equal(response.sessionId, undefined);
+        const call = JSON.parse((await (0, promises_1.readFile)((0, node_path_1.join)(root, "calls.jsonl"), "utf8")).trim());
+        strict_1.default.equal(call.args[call.args.indexOf("--tools") + 1], "");
+        strict_1.default.ok(call.args.includes("--strict-mcp-config"));
+        strict_1.default.deepEqual(JSON.parse(call.args[call.args.indexOf("--mcp-config") + 1]), { mcpServers: {} });
+        strict_1.default.deepEqual(JSON.parse(call.args[call.args.indexOf("--settings") + 1]), { disableAllHooks: true });
+        strict_1.default.ok(call.args.includes("--no-session-persistence"));
+        strict_1.default.ok(!call.args.includes("--model"));
+        strict_1.default.deepEqual(JSON.parse(call.args[call.args.indexOf("--json-schema") + 1]), modelResponseSchema);
+        await strict_1.default.rejects((0, promises_1.readFile)((0, node_path_1.join)(context.dataDir, "cli-sessions.json")), /ENOENT/);
+        await strict_1.default.rejects(plugin.handle({ task: "missing-structured", modelResponseSchema }), /结构化/);
+        const controller = new AbortController();
+        const pending = strict_1.default.rejects(plugin.handle({ task: "hang", modelResponseSchema, signal: controller.signal }), /取消/);
+        setTimeout(() => controller.abort(), 100);
+        await pending;
+    }
+    finally {
+        await plugin.deactivate("stop");
+    }
+});
+(0, node_test_1.default)("Claude 独立模型来源解析 prompt Schema，不保存管理会话", async (t) => {
+    const { root, context } = await setup(t);
+    const plugin = new claude_cli_1.default();
+    strict_1.default.equal(plugin.modelProvider, undefined);
+    await plugin.activate(context);
+    try {
+        const responseSchema = { type: "object", properties: { text: { type: "string" } }, required: ["text"], additionalProperties: false };
+        const provider = plugin.modelProvider;
+        strict_1.default.ok(provider);
+        plugin.handle = async () => { throw new Error("模型来源不能委托普通 handle"); };
+        const response = await provider.complete({
+            prompt: JSON.stringify({ instructions: "只返回结构化结果", responseSchema }),
+            sessionId: "pa-model",
+            timeoutMs: 2_000,
+            signal: new AbortController().signal,
+        });
+        strict_1.default.deepEqual(JSON.parse(response.text), { text: "模型回复" });
+        await strict_1.default.rejects((0, promises_1.readFile)((0, node_path_1.join)(context.dataDir, "cli-sessions.json")), /ENOENT/);
+        await strict_1.default.rejects(provider.complete({ prompt: JSON.stringify({ instructions: "缺少 Schema" }), sessionId: "pa-model", timeoutMs: 2_000, signal: new AbortController().signal }), /Schema/);
+        const call = JSON.parse((await (0, promises_1.readFile)((0, node_path_1.join)(root, "calls.jsonl"), "utf8")).trim());
+        strict_1.default.equal(call.args[call.args.indexOf("--tools") + 1], "");
+        strict_1.default.ok(call.args.includes("--strict-mcp-config"));
+        strict_1.default.deepEqual(JSON.parse(call.args[call.args.indexOf("--mcp-config") + 1]), { mcpServers: {} });
+        strict_1.default.deepEqual(JSON.parse(call.args[call.args.indexOf("--settings") + 1]), { disableAllHooks: true });
+        strict_1.default.deepEqual(JSON.parse(call.args[call.args.indexOf("--json-schema") + 1]), responseSchema);
+        strict_1.default.ok(call.args.includes("--no-session-persistence"));
+        strict_1.default.ok(!call.args.includes("--model"));
+    }
+    finally {
+        await plugin.deactivate("stop");
+    }
+    strict_1.default.equal(plugin.modelProvider, undefined);
+});
+(0, node_test_1.default)("Codex CLI 提供隔离模型来源，且普通对话仍可用", async (t) => {
+    const { root, context } = await setup(t);
+    const plugin = new codex_cli_1.default();
+    strict_1.default.ok(plugin.manifest.capabilities.includes("model-provider"));
+    strict_1.default.equal(plugin.modelProvider, undefined);
+    await plugin.activate(context);
+    try {
+        strict_1.default.equal(plugin.modelInput, true);
+        const responseSchema = { type: "object", properties: { text: { type: "string" } }, required: ["text"], additionalProperties: false };
+        const provider = plugin.modelProvider;
+        strict_1.default.ok(provider);
+        const response = await provider.complete({
+            prompt: JSON.stringify({ instructions: "只返回结构化结果", responseSchema }),
+            sessionId: "pa-codex-model",
+            timeoutMs: 2_000,
+            signal: new AbortController().signal,
+        });
+        strict_1.default.deepEqual(JSON.parse(response.text), { text: "模型回复" });
+        const call = JSON.parse((await (0, promises_1.readFile)((0, node_path_1.join)(root, "calls.jsonl"), "utf8")).trim());
+        strict_1.default.equal(call.args[0], "exec");
+        strict_1.default.ok(call.args.includes("--ephemeral"));
+        strict_1.default.deepEqual(call.args.slice(call.args.indexOf("--sandbox"), call.args.indexOf("--sandbox") + 2), ["--sandbox", "read-only"]);
+        for (const feature of ["shell_tool", "apps", "plugins", "hooks"]) {
+            const index = call.args.indexOf(feature);
+            strict_1.default.ok(index > 0);
+            strict_1.default.equal(call.args[index - 1], "--disable");
+        }
+        strict_1.default.ok(call.args.includes("--ignore-rules"));
+        strict_1.default.ok(call.args.includes("mcp_servers={}"));
+        strict_1.default.ok(call.args.includes("--output-schema"));
+        strict_1.default.ok(!call.args.includes("resume"));
+        strict_1.default.ok(!call.args.includes("--model"));
+        await strict_1.default.rejects((0, promises_1.readFile)((0, node_path_1.join)(context.dataDir, "cli-sessions.json")), /ENOENT/);
+        strict_1.default.equal((await plugin.handle({ task: "普通 Codex 请求" })).text, "普通 Codex 请求");
+        const calls = (await (0, promises_1.readFile)((0, node_path_1.join)(root, "calls.jsonl"), "utf8")).trim().split("\n").map(line => JSON.parse(line));
+        strict_1.default.ok(calls.some(entry => entry.args[0] === "exec" && entry.args.includes("--json")));
+    }
+    finally {
+        await plugin.deactivate("stop");
+    }
+});
+(0, node_test_1.default)("CLI 模型失败保留退出码但不记录外部错误夹带的提示正文", async (t) => {
+    const { context } = await setup(t);
+    const records = [];
+    const plugin = new codex_cli_1.default();
+    await plugin.activate({ ...context, logger: { info() { }, warn() { }, error: (_message, fields) => records.push(fields) } });
+    plugin.run = async () => { throw new Error("codex CLI 退出码 5：请检查 CLI 配置及网络；外部回显的私密用户提示"); };
+    try {
+        await strict_1.default.rejects(plugin.modelProvider.complete({ prompt: JSON.stringify({ responseSchema: { type: "object" } }), sessionId: "model", timeoutMs: 1000, signal: new AbortController().signal }), error => /退出码 5/.test(String(error)) && !/私密用户提示/.test(String(error)));
+        strict_1.default.doesNotMatch(JSON.stringify(records), /私密用户提示/);
+    }
+    finally {
+        await plugin.deactivate("stop");
+    }
+});
 (0, node_test_1.default)("配置无效和 CLI 未安装时不冒充就绪", async (t) => {
     const { context } = await setup(t);
     const plugin = new codex_cli_1.default();