mu-agent-bridge 1.0.71 → 1.0.78

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

@@ -50,6 +50,38 @@ const dsh_1 = require("../src-ts/plugins/dsh");
     strict_1.default.deepEqual(plugin.sessionOperations, ["new"]);
     strict_1.default.equal(plugin.attachmentInput, true);
 });
+(0, node_test_1.default)("DSH 插件通过桌面 CDP 发送并返回真实会话标识", async () => {
+    const calls = [];
+    const client = {
+        connect: async () => { calls.push("connect"); },
+        close: () => { calls.push("close"); },
+        connected: () => true,
+        activeSession: async () => "",
+        createSession: async () => { calls.push("new"); return "dsh-session-7"; },
+        activateSession: async (id) => { calls.push(`select:${id}`); },
+        complete: async (request) => { calls.push(`send:${request.task}`); return { text: "桌面回复" }; },
+    };
+    const plugin = Reflect.construct(dsh_1.DshPlugin, [{ client }]);
+    await plugin.activate({ config: {} });
+    const response = await plugin.handle({ task: "CDP 历史可见性测试", sessionId: "logical-id", newSession: true });
+    strict_1.default.deepEqual(calls, ["connect", "new", "send:CDP 历史可见性测试"]);
+    strict_1.default.deepEqual(response, { text: "桌面回复", sessionId: "dsh-session-7" });
+    strict_1.default.deepEqual(await plugin.health(), { status: "ready", details: { transport: "cdp", port: 9226, connected: true } });
+    await plugin.deactivate();
+});
+(0, node_test_1.default)("DSH 插件不能在 CDP 断开时回退到后台 CLI", async () => {
+    const calls = [];
+    const client = {
+        connect: async () => { throw new Error("DSH CDP 端口不可达"); },
+        close: () => { calls.push("close"); },
+        connected: () => false,
+    };
+    const plugin = Reflect.construct(dsh_1.DshPlugin, [{ client }]);
+    await strict_1.default.rejects(plugin.activate({ config: {} }), /DSH CDP 端口不可达/);
+    strict_1.default.equal((await plugin.health()).status, "failed");
+    strict_1.default.deepEqual((await plugin.health()).details, { transport: "cdp", port: 9226, connected: false });
+    strict_1.default.deepEqual(calls, ["close"]);
+});
 function fakeSpawn(_file, _args, _options) {
     const child = new node_events_1.EventEmitter();
     child.stdin = { end: (task) => { child.task = task; queueMicrotask(() => { child.stdout.emit("data", `{"type":"session","sessionId":"session-1"}\n`); child.stdout.emit("data", `{"type":"final","text":"hello from model"}\n`); child.emit("close", 0); }); } };
@@ -62,6 +94,30 @@ 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: fakeSpawn });
     strict_1.default.deepEqual(await agent.send({ task: "hi" }), { text: "hello from model", sessionId: "session-1" });
 });
+(0, node_test_1.default)("DSH 纯文字请求不追加附件处理说明", async () => {
+    let task = "";
+    const spawn = (file, args, options) => {
+        const child = fakeSpawn(file, args, options);
+        const end = child.stdin.end;
+        child.stdin.end = (value) => { task = value; end(value); };
+        return child;
+    };
+    await new dsh_agent_1.DshAgent({ patchPath: "patch.yml", paths: { executable: "dsh.exe", cli: "cli.js", patch: "patch.yml" }, spawn }).send({ task: "只回答这一句" });
+    strict_1.default.equal(task, "只回答这一句");
+});
+(0, node_test_1.default)("DSH 为支持附件回复的通道提供回传目录但不声明空输入", async () => {
+    let task = "";
+    const spawn = (file, args, options) => {
+        const child = fakeSpawn(file, args, options);
+        const end = child.stdin.end;
+        child.stdin.end = (value) => { task = value; end(value); };
+        return child;
+    };
+    await new dsh_agent_1.DshAgent({ patchPath: "patch.yml", paths: { executable: "dsh.exe", cli: "cli.js", patch: "patch.yml" }, spawn }).send({ task: "生成报告", attachmentOutput: true });
+    strict_1.default.match(task, /附件传输：\n\{"outputDirectory":"/);
+    strict_1.default.doesNotMatch(task, /"inputs":\[\]/);
+    strict_1.default.match(task, /写入.*outputDirectory.*present/);
+});
 (0, node_test_1.default)("DSH agent includes a session id when continuing", async () => {
     let captured = [];
     const spawn = (file, args, options) => { captured = args; return fakeSpawn(file, args, options); };
@@ -77,6 +133,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 +157,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")));
@@ -178,13 +265,14 @@ function presentSpawn(prepare, status = "completed", text = "已完成") {
     const withoutPresent = await new dsh_agent_1.DshAgent({ patchPath: "patch.yml", paths: { executable: "dsh.exe", cli: "cli.js", patch: "patch.yml" }, spawn: fakeSpawn }).send({ task: "只读取", attachments: [input] });
     strict_1.default.equal(withoutPresent.attachments, undefined);
 });
-(0, node_test_1.default)("DSH 无输入附件时仍可生成并回传文件", async () => {
+(0, node_test_1.default)("DSH 为支持附件回复的通道生成并回传无输入文件", async () => {
     const spawn = presentSpawn(async (block) => {
+        strict_1.default.equal(block.inputs, undefined);
         const path = (0, node_path_1.join)(block.outputDirectory, "result.txt");
         await (await Promise.resolve().then(() => __importStar(require("node:fs/promises")))).writeFile(path, "生成文件");
         return [path];
     });
-    const response = await new dsh_agent_1.DshAgent({ patchPath: "patch.yml", paths: { executable: "dsh.exe", cli: "cli.js", patch: "patch.yml" }, spawn }).send({ task: "创建文本文件并回传" });
+    const response = await new dsh_agent_1.DshAgent({ patchPath: "patch.yml", paths: { executable: "dsh.exe", cli: "cli.js", patch: "patch.yml" }, spawn }).send({ task: "创建文本文件并回传", attachmentOutput: true });
     strict_1.default.equal(Buffer.from(response.attachments[0].data).toString(), "生成文件");
 });
 (0, node_test_1.default)("DSH 允许只有成功交付附件的空正文回复", async () => {
@@ -193,7 +281,7 @@ function presentSpawn(prepare, status = "completed", text = "已完成") {
         await (await Promise.resolve().then(() => __importStar(require("node:fs/promises")))).writeFile(path, "附件正文");
         return [path];
     }, "completed", "");
-    const response = await new dsh_agent_1.DshAgent({ patchPath: "patch.yml", paths: { executable: "dsh.exe", cli: "cli.js", patch: "patch.yml" }, spawn }).send({ task: "只回传文件" });
+    const response = await new dsh_agent_1.DshAgent({ patchPath: "patch.yml", paths: { executable: "dsh.exe", cli: "cli.js", patch: "patch.yml" }, spawn }).send({ task: "只回传文件", attachmentOutput: true });
     strict_1.default.equal(response.text, "");
     strict_1.default.equal(response.attachments?.length, 1);
 });
@@ -216,6 +304,7 @@ function presentSpawn(prepare, status = "completed", text = "已完成") {
     }
 });
 (0, node_test_1.default)("DSH 拒绝回传超量和超大附件", async () => {
+    const input = { kind: "file", data: Buffer.from("输入"), filename: "输入.txt", contentType: "text/plain" };
     for (const limit of ["count", "size"]) {
         const spawn = presentSpawn(async (block) => {
             const path = (0, node_path_1.join)(block.outputDirectory, "large.txt");
@@ -225,7 +314,7 @@ function presentSpawn(prepare, status = "completed", text = "已完成") {
                 await truncate(path, 32 * 1024 * 1024 + 1);
             return limit === "count" ? Array.from({ length: 9 }, (_, index) => (0, node_path_1.join)(block.outputDirectory, `${index}.txt`)) : [path];
         });
-        await strict_1.default.rejects(new dsh_agent_1.DshAgent({ patchPath: "patch.yml", paths: { executable: "dsh.exe", cli: "cli.js", patch: "patch.yml" }, spawn }).send({ task: "回传文件" }), /最多|大小/);
+        await strict_1.default.rejects(new dsh_agent_1.DshAgent({ patchPath: "patch.yml", paths: { executable: "dsh.exe", cli: "cli.js", patch: "patch.yml" }, spawn }).send({ task: "回传文件", attachments: [input] }), /最多|大小/);
     }
 });
 (0, node_test_1.default)("DSH 使用发现的真实安装路径构建 CLI 路径，启动前拒绝不存在的程序", async () => {
@@ -237,10 +326,6 @@ function presentSpawn(prepare, status = "completed", text = "已完成") {
         const paths = await (0, dsh_paths_1.resolveDshPaths)("patch.yml", executable);
         strict_1.default.equal(paths.executable, executable);
         strict_1.default.equal(paths.cli, (0, node_path_1.join)(root, "resources", "app.asar", "dsh", "node_modules", "@deepseek-ai", "dsh-desktop-host", "lib", "cli.js"));
-        const plugin = new dsh_1.DshPlugin();
-        await plugin.activate({ config: { executablePath: executable } });
-        strict_1.default.equal(plugin.agent.paths.executable, executable);
-        await plugin.deactivate();
         process.env.DSH_INSTALL_DIR = root;
         strict_1.default.equal((await (0, dsh_paths_1.resolveDshPaths)("patch.yml")).executable, executable);
         await (0, promises_1.rm)(executable);
@@ -255,3 +340,67 @@ function presentSpawn(prepare, status = "completed", text = "已完成") {
         await (0, promises_1.rm)(root, { recursive: true, force: true });
     }
 });
+(0, node_test_1.default)("DSH 模型排队取消立即返回，桌面请求完成前不启动模型 CLI", async () => {
+    let release;
+    const sent = [];
+    const plugin = new dsh_1.DshPlugin({ client: {
+            connect: async () => undefined, close() { }, connected: () => true,
+            activeSession: async () => "desktop-session", createSession: async () => "desktop-session", activateSession: async () => undefined,
+            complete: async (request) => { sent.push(request); if (request.task === "用户任务")
+                await new Promise(resolve => { release = resolve; }); return { text: "回复" }; },
+        } });
+    await plugin.activate({ config: {} });
+    plugin.agent = { send: async () => { throw new Error("排队取消后不应调用模型 CLI"); } };
+    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 模型会话在重载后恢复，普通桌面任务不调用 CLI 或写入模型映射", 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 = [];
+    const desktopRequests = [];
+    const { mock } = await Promise.resolve().then(() => __importStar(require("node:test")));
+    const stub = mock.method(dsh_agent_1.DshAgent.prototype, "send", async (request, modelRequest) => {
+        strict_1.default.equal(modelRequest, true);
+        requests.push(request);
+        return { text: "模型回复", sessionId: "native-model-session" };
+    });
+    try {
+        for (let round = 0; round < 2; round++) {
+            const plugin = new dsh_1.DshPlugin({ client: {
+                    connect: async () => undefined, close() { }, connected: () => true,
+                    activeSession: async () => "ordinary-session", createSession: async () => "ordinary-session", activateSession: async () => undefined,
+                    complete: async (request) => { desktopRequests.push(request.task); return { text: "桌面回复" }; },
+                } });
+            await plugin.activate({ config: { executablePath }, dataDir: directory });
+            await plugin.handle({ task: "普通用户任务", sessionId: "ordinary-session" });
+            strict_1.default.equal(plugin.agent, undefined);
+            await plugin.modelProvider.complete({ prompt: "模型提示", sessionId: "pa-logical", timeoutMs: 1000, signal: new AbortController().signal });
+            await plugin.deactivate();
+        }
+        strict_1.default.deepEqual(desktopRequests, ["普通用户任务", "普通用户任务"]);
+        strict_1.default.equal(requests.length, 2);
+        strict_1.default.equal(requests[0].newSession, true);
+        strict_1.default.equal(requests[1].sessionId, "native-model-session");
+        strict_1.default.equal(requests[1].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 {
+        stub.mock.restore();
+        await (0, promises_1.rm)(directory, { recursive: true, force: true });
+    }
+});

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

@@ -0,0 +1,148 @@
+"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 = __importDefault(require("node:test"));
+const cdp_client_1 = require("../src-ts/plugins/dsh/cdp-client");
+class FakeWebSocket {
+    readyState = 0;
+    onopen;
+    onclose;
+    onerror;
+    onmessage;
+    sent = [];
+    state = { sessionId: "dsh-session-1", editorText: "", conversationText: "已有历史", busy: false, turnCount: 1, blank: false, pendingAttachments: [] };
+    flowNodes = [
+        { kind: "user", text: "已有历史\n12:00", userText: "已有历史" },
+        { kind: "assistant-step", part: "response", text: "旧回复" },
+        { kind: "turn-tail", text: "12:00" },
+    ];
+    messages = ["已有历史"];
+    pendingAttachmentLabel = "待发送附件";
+    inserted = "";
+    sessionRows = ["dsh-session-1", "dsh-session-2"];
+    constructor() { queueMicrotask(() => { this.readyState = 1; this.onopen?.(); }); }
+    send(raw) {
+        const request = JSON.parse(raw);
+        this.sent.push(request);
+        if (request.method === "Input.insertText") {
+            this.inserted = String(request.params.text);
+            this.state.editorText = this.inserted;
+        }
+        if (request.method === "Input.dispatchKeyEvent" && request.params.type === "keyDown" && request.params.key === "Enter") {
+            this.messages.push(this.inserted, "桌面模型回复");
+            this.flowNodes.push({ kind: "user", text: `${this.inserted}\n13:15`, userText: this.inserted }, { kind: "turn-process", text: "已完成\n已完成，用时 1 秒" }, { kind: "assistant-step", part: "reasoning", text: "内部思考" }, { kind: "assistant-step", part: "response", text: "桌面模型回复" }, { kind: "turn-tail", text: "13:15" });
+            this.state.conversationText = `${this.messages.join("\n\n")}\n13:15\n已完成，用时 1 秒\n13:15`;
+            this.state.editorText = "";
+            this.state.turnCount++;
+        }
+        if (request.method === "DOM.setFileInputFiles") {
+            this.state.pendingAttachments = request.params.files.map(path => path.replaceAll("\\", "/").split("/").at(-1));
+        }
+        const expression = String(request.params.expression);
+        const value = request.method === "Runtime.evaluate"
+            ? expression.includes("[data-conversation-content]")
+                ? JSON.stringify({ ...this.state, conversationText: expression.includes('[data-chat-flow-kind="user"]')
+                        ? this.flowNodes.filter(node => (node.kind === "user" || node.kind === "assistant-step") && node.part !== "reasoning").map(node => node.kind === "user" && expression.includes("conversation.user.text.node") ? node.userText : node.text).join("\n\n")
+                        : this.flowNodes.map(node => node.text).join("\n\n"), pendingAttachments: expression.includes(`aria-label*=\"${this.pendingAttachmentLabel}\"`) ? this.state.pendingAttachments : [] })
+                : expression.includes("const id =")
+                    ? Function("document", `return ${expression}`)({ querySelectorAll: () => this.sessionRows.map(id => ({
+                            getAttribute: (key) => key === "data-row-key" ? `session:${id}` : null,
+                            matches: (selector) => selector.includes('[role="treeitem"]'),
+                            closest: () => null,
+                            click: () => { this.state.sessionId = id; },
+                        })) })
+                    : true
+            : undefined;
+        const result = request.method === "Runtime.evaluate" ? { result: { value } }
+            : request.method === "DOM.getDocument" ? { root: { nodeId: 1 } }
+                : request.method === "DOM.querySelector" ? { nodeId: 2 }
+                    : {};
+        queueMicrotask(() => this.onmessage?.({ data: JSON.stringify({ id: request.id, result }) }));
+    }
+    close() { this.readyState = 3; this.onclose?.(); }
+}
+(0, node_test_1.default)("DSH CDP 只连接 DSH 会话页，并将用户原文提交到可见历史", async () => {
+    let socket;
+    const client = new cdp_client_1.DshCdpClient({
+        port: 9226,
+        fetchImpl: async () => new Response(JSON.stringify([{ type: "page", title: "DeepSeek Harness", url: "dsh-app://app/", webSocketDebuggerUrl: "ws://127.0.0.1:9226/devtools/page/dsh" }])),
+        webSocketFactory: () => (socket = new FakeWebSocket()),
+    });
+    await client.connect();
+    strict_1.default.equal(await client.activeSession(), "dsh-session-1");
+    const request = { task: "请只回答：CDP历史可见" };
+    const result = await client.complete(request);
+    strict_1.default.equal(socket?.inserted, request.task);
+    strict_1.default.equal(result.text, "桌面模型回复");
+    strict_1.default.ok(socket?.sent.some(item => item.method === "Input.dispatchKeyEvent" && item.params.key === "Enter"));
+    client.close();
+});
+(0, node_test_1.default)("DSH CDP 通过桌面文件控件上传真实附件", async () => {
+    let socket;
+    const client = new cdp_client_1.DshCdpClient({
+        port: 9226,
+        timeoutMs: 3_000,
+        fetchImpl: async () => new Response(JSON.stringify([{ type: "page", url: "dsh-app://app/", webSocketDebuggerUrl: "ws://127.0.0.1:9226/devtools/page/dsh" }])),
+        webSocketFactory: () => (socket = new FakeWebSocket()),
+    });
+    await client.connect();
+    const result = await client.complete({
+        task: "请分析这个文件",
+        attachments: [{ kind: "file", filename: "说明.txt", contentType: "text/plain", data: Buffer.from("真实文件内容") }],
+    });
+    strict_1.default.deepEqual(socket?.state.pendingAttachments, ["说明.txt"]);
+    strict_1.default.match(socket?.inserted ?? "", /请读取本条已上传附件：说明\.txt/);
+    strict_1.default.ok(socket?.sent.some(item => item.method === "DOM.setFileInputFiles"));
+    strict_1.default.equal(result.text, "桌面模型回复");
+    client.close();
+});
+(0, node_test_1.default)("DSH CDP 不连接其他 Electron 页面", async () => {
+    const client = new cdp_client_1.DshCdpClient({
+        port: 9226,
+        fetchImpl: async () => new Response(JSON.stringify([{ type: "page", title: "设置", url: "dsh-app://shell/update-dialog.html", webSocketDebuggerUrl: "ws://127.0.0.1:9226/devtools/page/other" }])),
+        webSocketFactory: () => { throw new Error("不能连接非 DSH 会话页面"); },
+    });
+    await strict_1.default.rejects(client.connect(), /未找到 DSH 桌面会话页/);
+});
+(0, node_test_1.default)("DSH CDP 点击侧栏 treeitem 恢复已有会话，并保护当前草稿和任务", async () => {
+    let socket;
+    const client = new cdp_client_1.DshCdpClient({
+        timeoutMs: 100,
+        fetchImpl: async () => new Response(JSON.stringify([{ type: "page", url: "dsh-app://app/", webSocketDebuggerUrl: "ws://127.0.0.1:9226/devtools/page/dsh" }])),
+        webSocketFactory: () => (socket = new FakeWebSocket()),
+    });
+    try {
+        await client.connect();
+        socket.state.editorText = "用户未发送的草稿";
+        await strict_1.default.rejects(client.activateSession("dsh-session-2"), /未发送内容或附件/);
+        strict_1.default.equal(await client.activeSession(), "dsh-session-1");
+        socket.state.editorText = "";
+        socket.state.busy = true;
+        await strict_1.default.rejects(client.activateSession("dsh-session-2"), /正在生成回复/);
+        socket.state.busy = false;
+        await client.activateSession("dsh-session-2");
+        strict_1.default.equal(await client.activeSession(), "dsh-session-2");
+        await strict_1.default.rejects(client.activateSession("不存在的会话"), /未找到可切换的会话/);
+    }
+    finally {
+        client.close();
+    }
+});
+(0, node_test_1.default)("DSH 新建允许桌面复用已确认的空白会话，拒绝复用历史会话", async () => {
+    let socket;
+    const client = new cdp_client_1.DshCdpClient({
+        timeoutMs: 100,
+        fetchImpl: async () => new Response(JSON.stringify([{ type: "page", url: "dsh-app://app/", webSocketDebuggerUrl: "ws://127.0.0.1:9226/devtools/page/dsh" }])),
+        webSocketFactory: () => (socket = new FakeWebSocket()),
+    });
+    await client.connect();
+    await strict_1.default.rejects(client.createSession(), /新会话状态未确认/);
+    socket.state.blank = true;
+    socket.state.turnCount = 0;
+    socket.state.conversationText = "探索未至之境";
+    strict_1.default.equal(await client.createSession(), "dsh-session-1");
+    client.close();
+});

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

@@ -56,6 +56,43 @@ const event = (seq, type, data, time = "2026-10-21T02:00:00.000Z") => ({ seq, ty
         await f.close();
     }
 });
+(0, node_test_1.default)("DSH 日志返回工作目录、事件序号和本轮 present 文件", async () => {
+    const f = await fixture();
+    try {
+        await f.session("delivery", [
+            event(0, "user/message", { content: [{ type: "text", text: "旧请求" }] }),
+            event(1, "deliverables/presented", { turn: 1, callId: "present-1", files: [{ path: "report.txt" }] }),
+        ]);
+        const state = await f.provider.readDeliveryState("session-delivery");
+        strict_1.default.deepEqual(state, { cwd: "C:\\project", sequence: 1, presented: [{ sequence: 1, paths: ["report.txt"] }] });
+    }
+    finally {
+        await f.close();
+    }
+});
+(0, node_test_1.default)("DSH 文件任务的作业生命周期事件不阻断附件与正文读取，未知事件仍拒绝交付", async () => {
+    const f = await fixture();
+    try {
+        const job = { jobId: "pwsh-test", owner: "session-jobs", kind: "pwsh", label: "不应回传的命令", startedAt: 1792512000000 };
+        const events = [
+            event(0, "user/message", { content: [{ type: "text", text: "生成文件" }] }),
+            event(1, "job/registered", job),
+            event(2, "job/settled", { ...job, finishedAt: 1792512001000, status: "completed", cause: "producer", producerReported: true, detail: "exit code: 0" }),
+            event(3, "deliverables/presented", { turn: 1, callId: "present-test", files: [{ path: "report.txt" }] }),
+            event(4, "assistant/message", { message: { content: [{ type: "text", text: "文件已生成" }] } }),
+        ];
+        await f.session("jobs", events);
+        strict_1.default.deepEqual(await f.provider.readDeliveryState("session-jobs"), { cwd: "C:\\project", sequence: 4, presented: [{ sequence: 3, paths: ["report.txt"] }] });
+        const body = await f.provider.readSession({ sessionId: "session-jobs", limit: 10 });
+        strict_1.default.equal(body.supported && body.complete, true);
+        strict_1.default.deepEqual(body.supported && body.turns.map(turn => turn.text), ["生成文件", "文件已生成"]);
+        await f.session("jobs", [...events, event(5, "job/future-event", {})]);
+        await strict_1.default.rejects(f.provider.readDeliveryState("session-jobs"), /未知且不可安全忽略.*job\/future-event/);
+    }
+    finally {
+        await f.close();
+    }
+});
 (0, node_test_1.default)("DSH 遇到未知事件、未知代际或越界游标时显式报告不完整/拒绝", async () => {
     const f = await fixture();
     try {

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, plugin.manifest.version);
         const run = async (...argv) => {
             response.statusCode = 0;
             await postCommands(node_stream_1.Readable.from([JSON.stringify({ protocolVersion: 1, argv })]), response);

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

@@ -0,0 +1,18 @@
+"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 = __importDefault(require("node:test"));
+const http_agent_1 = require("../src-ts/http-agent");
+(0, node_test_1.default)("HTTP 验收 Agent 解析 OpenAI 兼容响应", async () => {
+    const original = globalThis.fetch;
+    globalThis.fetch = (async () => new Response(JSON.stringify({ choices: [{ message: { content: "reply" } }] }), { status: 200 }));
+    try {
+        strict_1.default.deepEqual(await new http_agent_1.HttpAgent("http://127.0.0.1:1").send({ task: "hi" }), { text: "reply" });
+    }
+    finally {
+        globalThis.fetch = original;
+    }
+});

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+/);