mu-agent-bridge 1.0.71 → 1.0.78

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

@@ -37,17 +37,38 @@ 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_test_1 = __importStar(require("node:test"));
 const node_vm_1 = require("node:vm");
+const childProcess = require("node:child_process");
 const promises_1 = require("node:fs/promises");
+const node_fs_1 = require("node:fs");
 const node_os_1 = require("node:os");
 const node_path_1 = require("node:path");
+const fsPromises = require("node:fs/promises");
 const doubao = __importStar(require("../src-ts/plugins/doubao/cdp-client"));
 const doubao_1 = require("../src-ts/plugins/doubao");
 const cdp_client_1 = require("../src-ts/plugins/doubao/cdp-client");
 const attachments_1 = require("../src-ts/plugins/doubao/attachments");
+const desktopLaunch = __importStar(require("../src-ts/plugins/desktop-launch"));
 const imageUrl = "https://p3-flow-imagex-sign.byteimg.com/tos-cn-i-a9rns2rl98/rc_gen_image/test.png?signature=test";
 const png = Buffer.from("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+jRZkAAAAASUVORK5CYII=", "base64");
+(0, node_test_1.default)("豆包升级清理保留桌面，普通停止仍关闭桥接持有的进程", async (t) => {
+    const terminated = [];
+    t.mock.method(desktopLaunch, "terminateOwnedProcess", async (child) => { if (child)
+        terminated.push(child); });
+    let closed = 0;
+    const plugin = new doubao_1.DoubaoPlugin({ connect: async () => undefined, close: async () => { closed++; }, connected: () => true, direct: async () => "回复" });
+    const owned = { pid: 12345 };
+    await plugin.activate({ config: {} });
+    plugin.ownedProcess = owned;
+    await plugin.deactivate("reload", { preserveDesktop: true });
+    strict_1.default.equal(closed, 1);
+    strict_1.default.deepEqual(terminated, []);
+    await plugin.activate({ config: {} });
+    plugin.ownedProcess = owned;
+    await plugin.deactivate();
+    strict_1.default.deepEqual(terminated, [owned]);
+});
 function deferred() {
     let resolve;
     let reject;
@@ -123,14 +144,35 @@ 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();
+    const client = new cdp_client_1.DoubaoCdpClient({ mode: "chat" });
     for (const [filename, contentType, error] of [["clip.mp4", "video/mp4", /不支持视频/], ["archive.zip", "application/zip", /不支持.*文件类型/]]) {
         await strict_1.default.rejects(client.complete("读取附件", undefined, [{ kind: "file", data: Buffer.from("data"), filename, contentType }]), error);
     }
 });
 (0, node_test_1.default)("豆包上传和清理同时失败时保留两个错误", async () => {
-    const client = new cdp_client_1.DoubaoCdpClient({ timeoutMs: 3000 });
+    const client = new cdp_client_1.DoubaoCdpClient({ mode: "chat", timeoutMs: 3000 });
     let uploadName = "";
     client.evaluate = async (expression) => {
         if (expression.includes("const transfer = new DataTransfer")) {
@@ -149,7 +191,7 @@ function deferred() {
     });
 });
 (0, node_test_1.default)("豆包上传启动阶段异常也清理本次附件", async () => {
-    const client = new cdp_client_1.DoubaoCdpClient();
+    const client = new cdp_client_1.DoubaoCdpClient({ mode: "chat" });
     let cleaned = false;
     client.evaluate = async (expression) => {
         if (expression.includes("names.includes")) {
@@ -185,6 +227,39 @@ function deferred() {
     strict_1.default.deepEqual(extract({ block_type: 2074, is_finish: true, content_obj: { creations: [{ type: 2, video: { status: 4, vid: "failed" } }] } }), { artifacts: [], pending: false, failed: true });
     strict_1.default.deepEqual(extract(null), { artifacts: [], pending: false });
 });
+(0, node_test_1.default)("豆包本地电脑文件操作块只回传工作区内的真实文件", async (t) => {
+    const workspace = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "mab-doubao-files-"));
+    const filename = "倍距点数轴题.docx";
+    const filePath = (0, node_path_1.join)(workspace, filename);
+    const data = Buffer.from("word-file-content");
+    await (0, promises_1.writeFile)(filePath, data);
+    t.after(() => (0, promises_1.rm)(workspace, { recursive: true, force: true }));
+    const extract = new Function(`return (${doubao.responseArtifactsScript})`)();
+    const result = extract([
+        { block_type: 10019, is_finish: true, content: { file_operation_block: { file_type: "diff", path: filePath } } },
+        { block_type: 10019, is_finish: true, content: { file_operation_block: { file_type: "shell", path: filePath } } },
+    ], workspace);
+    strict_1.default.deepEqual(result, { artifacts: [{ kind: "file", filename, path: filePath, workspace }], pending: false });
+    const attachment = await doubao.downloadDoubaoArtifact(result.artifacts[0]);
+    strict_1.default.equal(attachment.kind, "file");
+    strict_1.default.equal(attachment.filename, filename);
+    strict_1.default.deepEqual(attachment.data, data);
+    const outside = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "mab-doubao-outside-"));
+    const outsidePath = (0, node_path_1.join)(outside, "outside.docx");
+    await (0, promises_1.writeFile)(outsidePath, data);
+    t.after(() => (0, promises_1.rm)(outside, { recursive: true, force: true }));
+    await strict_1.default.rejects(doubao.downloadDoubaoArtifact({ ...result.artifacts[0], path: outsidePath }), /工作区/);
+});
+(0, node_test_1.default)("豆包本地电脑富媒体卡片采集完成原图，忽略工具预览和未完成卡片", () => {
+    const extract = new Function(`return (${doubao.responseArtifactsScript})`)();
+    const image = { status: 2, image_ori: { url: imageUrl }, image_thumb: { url: "https://example.com/thumb.png" } };
+    const card = { block_type: 10084, is_finish: true, content: { rich_media_layout_block: { media: [{ type: 6, creation: { type: 1, image } }, { type: 0 }] } } };
+    strict_1.default.deepEqual(extract([
+        { block_type: 10010, is_finish: true, content: { gen_image_block: { images: [{ uri: "https://example.com/preview", full_size_url: ["https://example.com/preview"] }] } } },
+        card, card,
+    ]), { artifacts: [{ kind: "image", url: imageUrl }], pending: false });
+    strict_1.default.deepEqual(extract({ ...card, is_finish: false }), { artifacts: [], pending: true });
+});
 (0, node_test_1.default)("豆包异步产物只匹配同会话、本轮回复或原始问题引用", () => {
     const file = { block_type: 10020, is_finish: true, content_obj: { name: "result.txt", uri: "own-file" } };
     const question = "59158521582734851";
@@ -252,7 +327,7 @@ function deferred() {
             return new Response(JSON.stringify({ code: 0, data: { play_infos: [{ main: videoUrl }] } }));
         },
     };
-    const client = new cdp_client_1.DoubaoCdpClient({ conversationId: "own", timeoutMs: 5000, fetchImpl: async (input) => new Response(String(input) === imageUrl ? png : String(input) === videoUrl ? mp4 : "marker", { headers: { "content-type": String(input) === imageUrl ? "image/png" : String(input) === videoUrl ? "video/mp4" : "text/plain" } }) });
+    const client = new cdp_client_1.DoubaoCdpClient({ mode: "chat", conversationId: "own", timeoutMs: 5000, fetchImpl: async (input) => new Response(String(input) === imageUrl ? png : String(input) === videoUrl ? mp4 : "marker", { headers: { "content-type": String(input) === imageUrl ? "image/png" : String(input) === videoUrl ? "video/mp4" : "text/plain" } }) });
     client.connect = async () => { };
     client.evaluate = async (expression) => (0, node_vm_1.runInNewContext)(expression, page);
     const result = await client.complete("生成产物");
@@ -279,7 +354,7 @@ function deferred() {
             return new Response(`event: STREAM_MSG_NOTIFY\ndata: ${JSON.stringify({ content: { content_block: text === "请求甲" ? [block] : [{ content: { text_block: { text: "第二轮回复" } } }] } })}\n\nevent: CHUNK_DELTA\ndata: ${JSON.stringify({ text: text === "请求甲" ? "第一轮回复" : "" })}\n\n`);
         },
     };
-    const client = new cdp_client_1.DoubaoCdpClient({ conversationId: "test", timeoutMs: 5000, fetchImpl: async () => {
+    const client = new cdp_client_1.DoubaoCdpClient({ mode: "chat", conversationId: "test", timeoutMs: 5000, fetchImpl: async () => {
             downloadStarted.resolve();
             await downloadGate.promise;
             return new Response(png, { headers: { "content-type": "image/png" } });
@@ -313,6 +388,58 @@ function deferred() {
     strict_1.default.equal(results[0].attachments.length, 1);
     strict_1.default.equal(results[1].attachments, undefined);
 });
+(0, node_test_1.default)("豆包本地电脑任务持续产生流式进度时超过静默超时仍等待最终回复", { timeout: 10_000 }, async () => {
+    const client = new cdp_client_1.DoubaoCdpClient({ timeoutMs: 1_100 });
+    let requestId = "", polls = 0, progressSequence = 0, completed = false;
+    client.connect = async () => { };
+    client.evaluate = async (expression) => {
+        if (expression.includes("buildGeneralAgentCompletionTaskParam")) {
+            requestId = expression.match(/"unique_key":"([^"]+)"/)?.[1] ?? "";
+            strict_1.default.ok(requestId);
+            setTimeout(() => { progressSequence = 1; }, 600);
+            setTimeout(() => { progressSequence = 2; }, 1_300);
+            setTimeout(() => { completed = true; }, 2_300);
+            return "started";
+        }
+        if (expression === "window.__mab_doubao_result") {
+            polls++;
+            return completed ? JSON.stringify({ requestId, ok: true, reply: "图片已生成", conversationId: "123" }) : null;
+        }
+        if (expression === "window.__mab_doubao_progress")
+            return { requestId, sequence: progressSequence };
+    };
+    const result = await client.complete("生成图片");
+    strict_1.default.equal(result.text, "图片已生成");
+    strict_1.default.equal(polls, 3);
+});
+for (const state of ["无输出", "进度不再变化", "其他请求的进度"]) {
+    (0, node_test_1.default)(`豆包本地电脑${state}不能持续延长等待`, async (t) => {
+        t.mock.timers.enable({ apis: ["setTimeout", "Date"] });
+        const client = new cdp_client_1.DoubaoCdpClient({ timeoutMs: 2_000 });
+        let requestId = "", polls = 0;
+        client.connect = async () => { };
+        client.evaluate = async (expression) => {
+            if (expression.includes("buildGeneralAgentCompletionTaskParam")) {
+                requestId = expression.match(/"unique_key":"([^"]+)"/)?.[1] ?? "";
+                strict_1.default.ok(requestId);
+                return "started";
+            }
+            if (expression === "window.__mab_doubao_result") {
+                polls++;
+                return null;
+            }
+            if (expression === "window.__mab_doubao_progress")
+                return { requestId: state === "其他请求的进度" ? "other-request" : requestId, sequence: state === "无输出" ? 0 : state === "进度不再变化" ? 1 : polls };
+        };
+        const result = strict_1.default.rejects(client.complete("等待本轮回复"), (error) => error.code === "DOUBAO_REPLY_TIMEOUT");
+        for (let i = 0; i < 5; i++) {
+            await new Promise(setImmediate);
+            t.mock.timers.tick(1_000);
+        }
+        await result;
+        strict_1.default.equal(polls, state === "进度不再变化" ? 3 : 2);
+    });
+}
 for (const late of ["成功", "失败"]) {
     (0, node_test_1.default)(`豆包前轮超时后的晚${late}回调不覆盖下一轮结果`, { timeout: 10_000 }, async () => {
         const firstResponse = deferred(), nextResponse = deferred(), nextStarted = deferred();
@@ -323,7 +450,7 @@ for (const late of ["成功", "失败"]) {
             fetch: () => { if (++requests === 1)
                 return firstResponse.promise; nextStarted.resolve(); return nextResponse.promise; },
         };
-        const client = new cdp_client_1.DoubaoCdpClient({ conversationId: "test", timeoutMs: 20 });
+        const client = new cdp_client_1.DoubaoCdpClient({ mode: "chat", conversationId: "test", timeoutMs: 20 });
         client.connect = async () => { };
         client.evaluate = async (expression) => (0, node_vm_1.runInNewContext)(expression, page);
         await strict_1.default.rejects(client.complete("请求甲"), /等待豆包回复超时/);
@@ -348,6 +475,304 @@ for (const late of ["成功", "失败"]) {
 (0, node_test_1.default)("豆包流式合并不吞掉正文中重复出现的词", () => {
     strict_1.default.equal(doubao.mergeDoubaoReply("天空是蓝色。海水也是", "蓝色"), "天空是蓝色。海水也是蓝色");
 });
+(0, node_test_1.default)("豆包预分配失败且未确认时复用原请求有限重试", { timeout: 10_000 }, async () => {
+    const client = new cdp_client_1.DoubaoCdpClient({ mode: "chat", timeoutMs: 4_000 });
+    const bodies = [];
+    let requests = 0;
+    const page = { window: {}, URL, AbortController, TextDecoder, navigator: { userAgent: "Chrome/147.0.0.0 SamanthaDoubao/2.32.6" }, performance: { getEntriesByType: () => [] }, fetch: async (_url, init) => {
+            bodies.push(String(init.body));
+            if (++requests === 1)
+                return new Response('event: STREAM_ERROR\ndata: {"error_code":718013001,"error_msg":"预分配会话位置信息失败"}\n\n');
+            return new Response('event: SSE_ACK\ndata: {"ack_client_meta":{"conversation_id":"123"}}\n\nevent: CHUNK_DELTA\ndata: {"text":"重试后回复"}\n\n');
+        } };
+    client.connect = async () => { };
+    client.evaluate = async (expression) => (0, node_vm_1.runInNewContext)(expression, page);
+    const result = await client.complete("重试请求");
+    strict_1.default.equal(result.text, "重试后回复");
+    strict_1.default.equal(requests, 2);
+    strict_1.default.equal(bodies[0], bodies[1]);
+});
+(0, node_test_1.default)("豆包预分配失败重试耗尽时保留平台错误码", { timeout: 10_000 }, async () => {
+    const client = new cdp_client_1.DoubaoCdpClient({ mode: "chat", timeoutMs: 4_000 });
+    let requests = 0;
+    const page = { window: {}, URL, AbortController, TextDecoder, navigator: { userAgent: "Chrome/147.0.0.0 SamanthaDoubao/2.32.6" }, performance: { getEntriesByType: () => [] }, fetch: async () => {
+            requests++;
+            return new Response('event: STREAM_ERROR\ndata: {"error_code":718013001,"error_msg":"预分配会话位置信息失败"}\n\n');
+        } };
+    client.connect = async () => { };
+    client.evaluate = async (expression) => (0, node_vm_1.runInNewContext)(expression, page);
+    await strict_1.default.rejects(client.complete("重试请求"), /718013001.*尝试 3 次/);
+    strict_1.default.equal(requests, 3);
+});
+(0, node_test_1.default)("豆包已确认或已有进展的流错误不自动重发", { timeout: 10_000 }, async () => {
+    for (const stream of [
+        'event: SSE_ACK\ndata: {"ack_client_meta":{"conversation_id":"123"}}\n\nevent: STREAM_ERROR\ndata: {"error_code":718013001,"error_msg":"预分配会话位置信息失败"}\n\n',
+        'event: CHUNK_DELTA\ndata: {"text":"已开始"}\n\nevent: STREAM_ERROR\ndata: {"error_code":718013001,"error_msg":"预分配会话位置信息失败"}\n\n',
+        'event: STREAM_CHUNK\ndata: {"patch_op":[{"patch_value":{"content_block":[{"block_type":10020,"is_finish":false,"content":{"file_block":{"name":"生成中.pdf","uri":"pending"}}}]}}]}\n\nevent: STREAM_ERROR\ndata: {"error_code":718013001,"error_msg":"预分配会话位置信息失败"}\n\n',
+    ]) {
+        const client = new cdp_client_1.DoubaoCdpClient({ mode: "chat", timeoutMs: 2_000 });
+        let requests = 0;
+        const page = { window: {}, URL, AbortController, TextDecoder, navigator: { userAgent: "Chrome/147.0.0.0 SamanthaDoubao/2.32.6" }, performance: { getEntriesByType: () => [] }, fetch: async () => { requests++; return new Response(stream); } };
+        client.connect = async () => { };
+        client.evaluate = async (expression) => (0, node_vm_1.runInNewContext)(expression, page);
+        await strict_1.default.rejects(client.complete("不要重复发送"), /718013001/);
+        strict_1.default.equal(requests, 1);
+    }
+});
+(0, node_test_1.default)("豆包轮询期间 CDP 断开时重连后继续读取原结果且不重发", async () => {
+    const client = new cdp_client_1.DoubaoCdpClient({ mode: "chat", timeoutMs: 4_000 });
+    let connected = 0;
+    let disconnected = false;
+    let submissions = 0;
+    const page = { window: {}, URL, AbortController, TextDecoder, navigator: { userAgent: "Chrome/147.0.0.0 SamanthaDoubao/2.32.6" }, performance: { getEntriesByType: () => [] }, fetch: async () => {
+            submissions++;
+            return new Response('event: SSE_ACK\ndata: {"ack_client_meta":{"conversation_id":"456"}}\n\nevent: CHUNK_DELTA\ndata: {"text":"断线后继续回复"}\n\n');
+        } };
+    client.connect = async () => { connected++; };
+    client.evaluate = async (expression) => {
+        if (expression.includes("new AbortController()"))
+            disconnected = true;
+        if (expression === "window.__mab_doubao_result" && disconnected) {
+            disconnected = false;
+            throw new Error("豆包 CDP 已断开");
+        }
+        return (0, node_vm_1.runInNewContext)(expression, page);
+    };
+    const result = await client.complete("断线恢复");
+    strict_1.default.equal(result.text, "断线后继续回复");
+    strict_1.default.equal(connected, 2);
+    strict_1.default.equal(submissions, 1);
+});
+for (const recoveredState of ["已完成", "有新进度", "无新进度", "仍然断开"]) {
+    (0, node_test_1.default)(`豆包本地电脑流恢复跨过截止时间后核对原任务：${recoveredState}`, async (t) => {
+        t.mock.timers.enable({ apis: ["setTimeout", "Date"] });
+        const client = new cdp_client_1.DoubaoCdpClient({ timeoutMs: 2_000 });
+        let requestId = "", sequence = 0, submissions = 0, disconnected = false, reads = 0, connections = 0;
+        client.connect = async () => {
+            if (++connections > 1)
+                t.mock.timers.tick(2_500);
+        };
+        client.evaluate = async (expression) => {
+            if (expression.includes("buildGeneralAgentCompletionTaskParam")) {
+                submissions++;
+                requestId = expression.match(/"unique_key":"([^"]+)"/)?.[1] ?? "";
+                return "started";
+            }
+            if (expression === "window.__mab_doubao_request_id")
+                return requestId;
+            if (expression === "window.__mab_doubao_result") {
+                reads++;
+                if (!disconnected && reads === 2) {
+                    disconnected = true;
+                    throw new Error("豆包 CDP 已断开");
+                }
+                strict_1.default.ok(reads <= 4, "没有新进度时不得无限重连");
+                if (reads > 2 && recoveredState === "仍然断开")
+                    throw new Error("豆包 CDP 已断开");
+                if (reads > 2 && recoveredState === "有新进度")
+                    sequence = 1;
+                return reads > (recoveredState === "有新进度" ? 3 : 2) && (recoveredState === "已完成" || recoveredState === "有新进度")
+                    ? JSON.stringify({ requestId, ok: true, reply: "断线期间完成的回复", conversationId: "123" }) : null;
+            }
+            if (expression === "window.__mab_doubao_progress")
+                return { requestId, sequence };
+        };
+        const running = client.complete("断线期间持续生成", undefined, undefined, "");
+        void running.catch(() => undefined);
+        for (let i = 0; i < 5; i++) {
+            await new Promise(setImmediate);
+            t.mock.timers.tick(1_000);
+        }
+        if (recoveredState === "已完成" || recoveredState === "有新进度")
+            strict_1.default.equal((await running).text, "断线期间完成的回复");
+        else
+            await strict_1.default.rejects(running, (error) => error.code === "DOUBAO_REPLY_TIMEOUT");
+        strict_1.default.equal(reads, recoveredState === "有新进度" ? 4 : 3, "恢复后应重新读取原请求结果");
+        strict_1.default.equal(connections, 2);
+        strict_1.default.equal(submissions, 1, "恢复不应重复提交任务");
+    });
+}
+(0, node_test_1.default)("豆包任务执行中 CDP 端口拒绝连接时恢复桌面并读取原任务，不重复提交", async () => {
+    const client = new cdp_client_1.DoubaoCdpClient({ mode: "chat", timeoutMs: 4_000, recoverCdp: async () => { recoveries++; connected = true; } });
+    let connected = false, connections = 0, recoveries = 0, disconnected = false, submissions = 0;
+    let requestId = "";
+    client.connected = () => connected;
+    client.connect = async () => {
+        connections++;
+        if (connections === 2)
+            throw Object.assign(new Error("fetch failed"), { cause: { code: "ECONNREFUSED" } });
+        connected = true;
+    };
+    client.evaluate = async (expression) => {
+        if (expression.includes("new AbortController()")) {
+            submissions++;
+            requestId = JSON.parse(expression.match(/window\.__mab_doubao_request_id = (.*?);/)?.[1] ?? '""');
+            disconnected = true;
+            return "started";
+        }
+        if (expression === "window.__mab_doubao_result" && disconnected) {
+            disconnected = false;
+            connected = false;
+            throw new Error("豆包 CDP 已断开");
+        }
+        if (expression === "window.__mab_doubao_request_id")
+            return requestId;
+        if (expression === "window.__mab_doubao_result")
+            return JSON.stringify({ ok: true, reply: "恢复后的原任务回复", conversationId: "123" });
+    };
+    strict_1.default.equal((await client.complete("执行中的任务")).text, "恢复后的原任务回复");
+    strict_1.default.equal(recoveries, 1);
+    strict_1.default.equal(submissions, 1);
+});
+(0, node_test_1.default)("豆包 CDP 命令超时但旧 socket 仍打开时重建连接并继续读取原任务", { timeout: 10_000 }, async () => {
+    const original = globalThis.WebSocket;
+    const sockets = [];
+    let discoveries = 0;
+    let submissions = 0;
+    let requestId = "";
+    class TestWebSocket {
+        url;
+        readyState = 0;
+        onopen;
+        onclose;
+        onmessage;
+        constructor(url) {
+            this.url = url;
+            sockets.push(this);
+            queueMicrotask(() => { this.readyState = 1; this.onopen?.(); });
+        }
+        send(raw) {
+            const request = JSON.parse(raw);
+            const expression = request.params?.expression ?? "";
+            if (expression.includes("new AbortController()")) {
+                submissions++;
+                requestId = JSON.parse(expression.match(/window\.__mab_doubao_request_id = (.*?);/)?.[1] ?? '""');
+            }
+            if (sockets[0] === this && expression === "window.__mab_doubao_result")
+                return;
+            const value = expression === "window.__mab_doubao_request_id"
+                ? requestId
+                : expression === "window.__mab_doubao_result"
+                    ? JSON.stringify({ ok: true, reply: "超时后恢复的回复", conversationId: "456" })
+                    : "started";
+            queueMicrotask(() => this.onmessage?.({ data: JSON.stringify({ id: request.id, result: { result: { value } } }) }));
+        }
+        close() { if (this.readyState === 3)
+            return; this.readyState = 3; this.onclose?.(); }
+    }
+    globalThis.WebSocket = TestWebSocket;
+    const client = new cdp_client_1.DoubaoCdpClient({ mode: "chat", timeoutMs: 2_500, fetchImpl: async () => new Response(JSON.stringify([
+            { type: "page", url: "doubao://doubao-chat/chat/test", webSocketDebuggerUrl: `ws://page-${++discoveries}` },
+        ])) });
+    const cdp = client.cdp.bind(client);
+    client.cdp = (method, params, timeoutMs = 50) => cdp(method, params, timeoutMs);
+    try {
+        strict_1.default.equal((await client.complete("超时后继续")).text, "超时后恢复的回复");
+        strict_1.default.equal(discoveries, 2);
+        strict_1.default.equal(sockets.length, 2);
+        strict_1.default.equal(submissions, 1);
+    }
+    finally {
+        await client.close();
+        globalThis.WebSocket = original;
+    }
+});
+(0, node_test_1.default)("豆包等待流结束时不重复注入请求", async () => {
+    const client = new cdp_client_1.DoubaoCdpClient({ mode: "chat", timeoutMs: 4_000 });
+    let submissions = 0, polls = 0;
+    client.connect = async () => { };
+    client.evaluate = async (expression) => {
+        if (expression.includes("new AbortController()")) {
+            submissions++;
+            return "started";
+        }
+        if (expression === "window.__mab_doubao_result" && ++polls >= 2)
+            return JSON.stringify({ ok: true, reply: "原任务回复", conversationId: "456" });
+    };
+    strict_1.default.equal((await client.complete("只提交一次")).text, "原任务回复");
+    strict_1.default.equal(submissions, 1);
+});
+(0, node_test_1.default)("豆包重连后原页面任务丢失时明确报告结果未知，不重发", async () => {
+    const client = new cdp_client_1.DoubaoCdpClient({ mode: "chat", timeoutMs: 4_000 });
+    let submissions = 0;
+    client.connect = async () => { };
+    client.evaluate = async (expression) => {
+        if (expression.includes("new AbortController()")) {
+            submissions++;
+            return "started";
+        }
+        if (expression === "window.__mab_doubao_result")
+            throw new Error("豆包 CDP 已断开");
+    };
+    await strict_1.default.rejects(client.complete("不能重复执行"), (error) => error.code === "DOUBAO_RESULT_UNKNOWN" && /原任务|页面/.test(error.message));
+    strict_1.default.equal(submissions, 1);
+});
+(0, node_test_1.default)("豆包 CDP 连接暂时失败会重试并记录恢复，耗尽时保留端口和原因", async () => {
+    const logs = [];
+    const client = new cdp_client_1.DoubaoCdpClient({ mode: "chat", port: 19227, timeoutMs: 4_000, logger: { warn: (message) => logs.push(message) } });
+    let attempts = 0;
+    client.openConnection = async () => { if (++attempts < 3)
+        throw Object.assign(new Error("fetch failed"), { cause: { code: "ECONNREFUSED" } }); };
+    await client.connect();
+    strict_1.default.equal(attempts, 3);
+    strict_1.default.ok(logs.some(message => /19227.*重试/.test(message)));
+    attempts = 0;
+    client.openConnection = async () => { attempts++; throw Object.assign(new Error("fetch failed"), { cause: { code: "ECONNREFUSED" } }); };
+    await strict_1.default.rejects(client.complete("未提交的任务"), (error) => error.code === "DOUBAO_CDP_UNAVAILABLE" && /19227.*ECONNREFUSED/.test(error.message));
+    strict_1.default.equal(attempts, 3);
+});
+(0, node_test_1.default)("豆包预分配失败遇到取消不再重试", async () => {
+    const controller = new AbortController();
+    const client = new cdp_client_1.DoubaoCdpClient({ mode: "chat", timeoutMs: 4_000 });
+    let submissions = 0;
+    const page = { window: {}, URL, AbortController, TextDecoder, navigator: { userAgent: "Chrome/147.0.0.0 SamanthaDoubao/2.32.6" }, performance: { getEntriesByType: () => [] }, fetch: async () => {
+            submissions++;
+            controller.abort();
+            return new Response('event: STREAM_ERROR\ndata: {"error_code":718013001,"error_msg":"预分配会话位置信息失败"}\n\n');
+        } };
+    client.connect = async () => { };
+    client.evaluate = async (expression) => (0, node_vm_1.runInNewContext)(expression, page);
+    await strict_1.default.rejects(client.complete("取消测试", controller.signal), /取消/);
+    strict_1.default.equal(submissions, 1);
+});
+(0, node_test_1.default)("豆包提交后 CDP 回执丢失时恢复原任务，不重复执行", async () => {
+    const client = new cdp_client_1.DoubaoCdpClient({ mode: "chat", timeoutMs: 4_000 });
+    let submissions = 0, connections = 0;
+    const page = { window: {}, URL, AbortController, TextDecoder, navigator: { userAgent: "Chrome/147.0.0.0 SamanthaDoubao/2.32.6" }, performance: { getEntriesByType: () => [] }, fetch: async () => {
+            submissions++;
+            return new Response('event: SSE_ACK\ndata: {"ack_client_meta":{"conversation_id":"456"}}\n\nevent: CHUNK_DELTA\ndata: {"text":"提交回执丢失后仍收到回复"}\n\n');
+        } };
+    client.connect = async () => { connections++; };
+    client.evaluate = async (expression) => {
+        const result = (0, node_vm_1.runInNewContext)(expression, page);
+        if (expression.includes("new AbortController()"))
+            throw new Error("豆包 CDP 已断开");
+        return result;
+    };
+    strict_1.default.equal((await client.complete("提交一次")).text, "提交回执丢失后仍收到回复");
+    strict_1.default.equal(submissions, 1);
+    strict_1.default.equal(connections, 2);
+});
+(0, node_test_1.default)("豆包风控和未知网络错误不重发任务，保留具体平台原因", async () => {
+    for (const failure of [
+        { error_code: 718013001, error_msg: "需要验证", extra: { decision: { type: "verify", subtype: "slide" } } },
+        { error_code: 12345, error_msg: "平台临时拒绝" },
+        undefined,
+    ]) {
+        const client = new cdp_client_1.DoubaoCdpClient({ mode: "chat", timeoutMs: 4_000 });
+        let submissions = 0;
+        const page = { window: {}, URL, AbortController, TextDecoder, navigator: { userAgent: "Chrome/147.0.0.0 SamanthaDoubao/2.32.6" }, performance: { getEntriesByType: () => [] }, fetch: async () => {
+                submissions++;
+                if (!failure)
+                    throw new Error("fetch failed");
+                return new Response(`event: STREAM_ERROR\ndata: ${JSON.stringify(failure)}\n\n`);
+            } };
+        client.connect = async () => { };
+        client.evaluate = async (expression) => (0, node_vm_1.runInNewContext)(expression, page);
+        await strict_1.default.rejects(client.complete("不要重复执行"), (error) => /DOUBAO_(PLATFORM_ERROR|STREAM_FAILED)/.test(error.code) && /豆包平台流式响应/.test(error.stage));
+        strict_1.default.equal(submissions, 1);
+    }
+});
 (0, node_test_1.default)("豆包完整回复解析 SSE 图片并保留增量正文中的重复词", async () => {
     const original = globalThis.WebSocket;
     const block = { block_type: 2074, is_finish: true, content: { creation_block: { creations: [{ image: { status: 2, image_ori: { url: imageUrl } } }] } } };
@@ -392,7 +817,7 @@ for (const late of ["成功", "失败"]) {
     }
     globalThis.WebSocket = TestWebSocket;
     let downloads = 0;
-    const client = new cdp_client_1.DoubaoCdpClient({ fetchImpl: async (input) => {
+    const client = new cdp_client_1.DoubaoCdpClient({ mode: "chat", fetchImpl: async (input) => {
             if (String(input).endsWith("/json"))
                 return new Response(JSON.stringify([{ type: "page", url: "doubao://doubao-chat/chat/test", webSocketDebuggerUrl: "ws://test" }]));
             strict_1.default.equal(String(input), imageUrl);
@@ -481,7 +906,7 @@ for (const late of ["成功", "失败"]) {
 });
 (0, node_test_1.default)("未配置豆包参数时保留默认 CDP 端口", async () => {
     let url = "";
-    const client = new cdp_client_1.DoubaoCdpClient({ port: undefined, conversationId: undefined, botId: undefined, timeoutMs: undefined, fetchImpl: async (input) => { url = String(input); return new Response("[]"); } });
+    const client = new cdp_client_1.DoubaoCdpClient({ mode: "chat", port: undefined, conversationId: undefined, botId: undefined, timeoutMs: undefined, fetchImpl: async (input) => { url = String(input); return new Response("[]"); } });
     await strict_1.default.rejects(client.connect(), /未找到豆包/);
     strict_1.default.match(url, /:\d+\/json$/);
 });
@@ -531,6 +956,10 @@ for (const late of ["成功", "失败"]) {
     const existing = JSON.parse((0, cdp_client_1.requestBody)("继续", "123", "bot"));
     strict_1.default.equal(existing.option.need_create_conversation, false);
     strict_1.default.equal(existing.client_meta.local_conversation_id, undefined);
+    const localComputer = JSON.parse((0, cdp_client_1.requestBody)("执行", "123", "bot", [], [], "local-computer"));
+    strict_1.default.equal(localComputer.option.agent_mode, 1);
+    strict_1.default.equal(localComputer.option.aggregate_params.agent_mode, "1");
+    strict_1.default.equal(localComputer.ext.agent_mode, "1");
 });
 (0, node_test_1.default)("停止豆包客户端时向页面发送请求取消指令", async () => {
     const original = globalThis.WebSocket;
@@ -549,7 +978,7 @@ for (const late of ["成功", "失败"]) {
     }
     globalThis.WebSocket = TestWebSocket;
     try {
-        const client = new cdp_client_1.DoubaoCdpClient({ fetchImpl: async () => new Response(JSON.stringify([{ type: "page", url: "https://www.doubao.com/chat/test", webSocketDebuggerUrl: "ws://test" }])) });
+        const client = new cdp_client_1.DoubaoCdpClient({ mode: "chat", fetchImpl: async () => new Response(JSON.stringify([{ type: "page", url: "https://www.doubao.com/chat/test", webSocketDebuggerUrl: "ws://test" }])) });
         await client.connect();
         const pending = client.direct("停止测试").catch((error) => String(error));
         await new Promise((resolve) => setImmediate(resolve));
@@ -586,7 +1015,7 @@ for (const late of ["成功", "失败"]) {
         close() { this.readyState = 3; this.onclose?.(); }
     }
     globalThis.WebSocket = TestWebSocket;
-    const client = new cdp_client_1.DoubaoCdpClient({ fetchImpl: async () => {
+    const client = new cdp_client_1.DoubaoCdpClient({ mode: "chat", fetchImpl: async () => {
             if (++discoveries === 2)
                 await secondDiscovery.promise;
             return new Response(JSON.stringify([{ type: "page", url: "doubao://doubao-chat/chat/test", webSocketDebuggerUrl: "ws://test" }]));
@@ -642,7 +1071,7 @@ for (const late of ["成功", "失败"]) {
     }
     globalThis.WebSocket = TestWebSocket;
     let discoveries = 0;
-    const client = new cdp_client_1.DoubaoCdpClient({ timeoutMs: 2000, fetchImpl: async () => new Response(JSON.stringify([
+    const client = new cdp_client_1.DoubaoCdpClient({ mode: "chat", timeoutMs: 2000, fetchImpl: async () => new Response(JSON.stringify([
             { type: "page", url: "doubao://doubao-chat/chat/test", webSocketDebuggerUrl: `ws://page-${++discoveries}` },
         ])) });
     try {
@@ -682,6 +1111,264 @@ for (const late of ["成功", "失败"]) {
         await plugin.deactivate();
     }
 });
+(0, node_test_1.default)("豆包自动启动复用默认用户目录，但不结束人工进程", async () => {
+    const root = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "doubao-default-profile-"));
+    const executable = (0, node_path_1.join)(root, "Doubao.exe");
+    const platform = Object.getOwnPropertyDescriptor(process, "platform");
+    await (0, promises_1.writeFile)(executable, "");
+    let connections = 0;
+    let profile = "未捕获";
+    const connect = node_test_1.mock.method(cdp_client_1.DoubaoCdpClient.prototype, "connect", async () => {
+        connections++;
+        if (connections === 1)
+            throw Object.assign(new TypeError("fetch failed"), { cause: { code: "ECONNREFUSED" } });
+    });
+    let terminated = false;
+    const terminate = node_test_1.mock.method(desktopLaunch, "terminateWindowsDesktop", async () => { terminated = true; return []; });
+    const restart = node_test_1.mock.method(desktopLaunch, "restartOwnedAndWait", async (...args) => { profile = args[3]; });
+    Object.defineProperty(process, "platform", { value: "win32" });
+    const plugin = new doubao_1.DoubaoPlugin();
+    try {
+        await plugin.activate({ config: { executablePath: executable } });
+        strict_1.default.equal(terminated, false);
+        strict_1.default.equal(profile, undefined);
+    }
+    finally {
+        await plugin.deactivate();
+        restart.mock.restore();
+        terminate.mock.restore();
+        connect.mock.restore();
+        Object.defineProperty(process, "platform", platform);
+        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)(), "doubao-connect-error-"));
+    const executable = (0, node_path_1.join)(root, "Doubao.exe");
+    const platform = Object.getOwnPropertyDescriptor(process, "platform");
+    await (0, promises_1.writeFile)(executable, "");
+    let terminated = false;
+    let restarted = false;
+    const connect = node_test_1.mock.method(cdp_client_1.DoubaoCdpClient.prototype, "connect", async () => { throw new Error("豆包页面协议错误"); });
+    const terminate = node_test_1.mock.method(desktopLaunch, "terminateWindowsDesktop", async () => { terminated = true; return []; });
+    const restart = node_test_1.mock.method(desktopLaunch, "restartOwnedAndWait", async () => { restarted = true; });
+    Object.defineProperty(process, "platform", { value: "win32" });
+    const plugin = new doubao_1.DoubaoPlugin();
+    try {
+        await strict_1.default.rejects(plugin.activate({ config: { executablePath: executable } }), /豆包页面协议错误/);
+        strict_1.default.equal(terminated, false);
+        strict_1.default.equal(restarted, false);
+    }
+    finally {
+        await plugin.deactivate();
+        restart.mock.restore();
+        terminate.mock.restore();
+        connect.mock.restore();
+        Object.defineProperty(process, "platform", platform);
+        await (0, promises_1.rm)(root, { recursive: true, force: true });
+    }
+});
+(0, node_test_1.default)("豆包普通任务 CDP 端口拒绝连接时恢复桥接实例并继续原会话", async () => {
+    const root = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "doubao-cleanup-error-"));
+    const executable = (0, node_path_1.join)(root, "Doubao.exe");
+    const platform = Object.getOwnPropertyDescriptor(process, "platform");
+    await (0, promises_1.writeFile)(executable, "");
+    let connected = true, connections = 0, restarted = false;
+    const connect = node_test_1.mock.method(cdp_client_1.DoubaoCdpClient.prototype, "connect", async () => { connections++; if (!connected)
+        throw Object.assign(new Error("CDP 未连接"), { code: "ECONNREFUSED" }); });
+    const connectionState = node_test_1.mock.method(cdp_client_1.DoubaoCdpClient.prototype, "connected", () => connected);
+    const terminate = node_test_1.mock.method(desktopLaunch, "terminateWindowsDesktop", async () => { strict_1.default.fail("不能结束人工桌面"); return []; });
+    const restart = node_test_1.mock.method(desktopLaunch, "restartOwnedAndWait", async (...args) => {
+        strict_1.default.equal(args[0], undefined, "不得接管人工进程");
+        restarted = true;
+        connected = true;
+        await args[4]();
+    });
+    const complete = node_test_1.mock.method(cdp_client_1.DoubaoCdpClient.prototype, "complete", async (_text, _signal, _attachments, conversationId) => {
+        strict_1.default.ok(connected);
+        strict_1.default.equal(conversationId, "123");
+        return { text: "原会话已恢复", sessionId: "123" };
+    });
+    Object.defineProperty(process, "platform", { value: "win32" });
+    const plugin = new doubao_1.DoubaoPlugin();
+    try {
+        await plugin.activate({ config: { executablePath: executable } });
+        plugin.bindings.set("peer-a", "123");
+        connected = false;
+        strict_1.default.deepEqual(await plugin.handle({ task: "恢复原任务", sessionId: "peer-a" }), { text: "原会话已恢复", sessionId: "peer-a" });
+        strict_1.default.equal(restarted, true);
+        strict_1.default.equal(connections, 3);
+    }
+    finally {
+        await plugin.deactivate();
+        restart.mock.restore();
+        terminate.mock.restore();
+        connect.mock.restore();
+        connectionState.mock.restore();
+        complete.mock.restore();
+        Object.defineProperty(process, "platform", platform);
+        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)(), "doubao-profile-fallback-"));
+    const executable = (0, node_path_1.join)(root, "Doubao.exe");
+    const localAppData = (0, node_path_1.join)(root, "local-app-data");
+    const dataDir = (0, node_path_1.join)(root, "state");
+    const defaultProfile = (0, node_path_1.join)(localAppData, "Doubao", "User Data");
+    const cookieFile = (0, node_path_1.join)(defaultProfile, "Default", "Network", "Cookies");
+    const platform = Object.getOwnPropertyDescriptor(process, "platform");
+    const previousLocalAppData = process.env.LOCALAPPDATA;
+    await (0, promises_1.mkdir)((0, node_path_1.join)(defaultProfile, "Default", "Network"), { recursive: true });
+    await (0, promises_1.writeFile)(executable, "");
+    await (0, promises_1.writeFile)(cookieFile, "logged-in-cookie");
+    process.env.LOCALAPPDATA = localAppData;
+    let connections = 0;
+    const profiles = [];
+    const connect = node_test_1.mock.method(cdp_client_1.DoubaoCdpClient.prototype, "connect", async () => {
+        connections++;
+        if (connections === 1)
+            throw Object.assign(new Error("CDP 未连接"), { code: "ECONNREFUSED" });
+    });
+    const restart = node_test_1.mock.method(desktopLaunch, "restartOwnedAndWait", async (...args) => {
+        profiles.push(args[3]);
+        if (profiles.length === 1)
+            throw new Error("默认用户目录已被占用");
+    });
+    const terminate = node_test_1.mock.method(desktopLaunch, "terminateWindowsDesktop", async () => []);
+    Object.defineProperty(process, "platform", { value: "win32" });
+    const plugin = new doubao_1.DoubaoPlugin();
+    try {
+        await plugin.activate({ config: { executablePath: executable }, dataDir });
+        strict_1.default.equal(profiles[0], undefined);
+        strict_1.default.equal(profiles.length, 2);
+        strict_1.default.equal(typeof profiles[1], "string");
+        strict_1.default.equal(await (0, promises_1.readFile)((0, node_path_1.join)(String(profiles[1]), "Default", "Network", "Cookies"), "utf8"), "logged-in-cookie");
+    }
+    finally {
+        await plugin.deactivate();
+        terminate.mock.restore();
+        restart.mock.restore();
+        connect.mock.restore();
+        Object.defineProperty(process, "platform", platform);
+        if (previousLocalAppData === undefined)
+            delete process.env.LOCALAPPDATA;
+        else
+            process.env.LOCALAPPDATA = previousLocalAppData;
+        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)(), "doubao-locked-profile-"));
+    const executable = (0, node_path_1.join)(root, "Doubao.exe");
+    const localAppData = (0, node_path_1.join)(root, "local-app-data");
+    const dataDir = (0, node_path_1.join)(root, "state");
+    const defaultProfile = (0, node_path_1.join)(localAppData, "Doubao", "User Data");
+    const platform = Object.getOwnPropertyDescriptor(process, "platform");
+    const previousLocalAppData = process.env.LOCALAPPDATA;
+    await (0, promises_1.mkdir)(defaultProfile, { recursive: true });
+    await (0, promises_1.mkdir)((0, node_path_1.join)(dataDir, "desktop-profile"), { recursive: true });
+    await (0, promises_1.writeFile)(executable, "");
+    await (0, promises_1.writeFile)((0, node_path_1.join)(defaultProfile, "Local State"), "logged-in-state");
+    await (0, promises_1.writeFile)((0, node_path_1.join)(dataDir, "desktop-profile", "Local State"), "existing-login-state");
+    process.env.LOCALAPPDATA = localAppData;
+    let connections = 0;
+    const profiles = [];
+    const connect = node_test_1.mock.method(cdp_client_1.DoubaoCdpClient.prototype, "connect", async () => {
+        connections++;
+        if (connections === 1)
+            throw Object.assign(new Error("CDP 未连接"), { code: "ECONNREFUSED" });
+    });
+    const restart = node_test_1.mock.method(desktopLaunch, "restartOwnedAndWait", async (...args) => {
+        profiles.push(args[3]);
+        if (profiles.length === 1)
+            throw new Error("默认用户目录已被占用");
+    });
+    const terminate = node_test_1.mock.method(desktopLaunch, "terminateWindowsDesktop", async () => []);
+    const copy = node_test_1.mock.method(fsPromises, "cp", async () => {
+        throw Object.assign(new Error("文件被占用"), { code: "EBUSY" });
+    });
+    Object.defineProperty(process, "platform", { value: "win32" });
+    const plugin = new doubao_1.DoubaoPlugin();
+    try {
+        await plugin.activate({ config: { executablePath: executable }, dataDir });
+        strict_1.default.equal(profiles.length, 2);
+        strict_1.default.equal(await (0, promises_1.readFile)((0, node_path_1.join)(dataDir, "desktop-profile", "Local State"), "utf8"), "existing-login-state");
+    }
+    finally {
+        await plugin.deactivate();
+        copy.mock.restore();
+        terminate.mock.restore();
+        restart.mock.restore();
+        connect.mock.restore();
+        Object.defineProperty(process, "platform", platform);
+        if (previousLocalAppData === undefined)
+            delete process.env.LOCALAPPDATA;
+        else
+            process.env.LOCALAPPDATA = previousLocalAppData;
+        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)(), "doubao-backup-profile-"));
+    const executable = (0, node_path_1.join)(root, "Doubao.exe");
+    const localAppData = (0, node_path_1.join)(root, "local-app-data");
+    const dataDir = (0, node_path_1.join)(root, "state");
+    const defaultProfile = (0, node_path_1.join)(localAppData, "Doubao", "User Data");
+    const platform = Object.getOwnPropertyDescriptor(process, "platform");
+    const previousLocalAppData = process.env.LOCALAPPDATA;
+    await (0, promises_1.mkdir)(defaultProfile, { recursive: true });
+    await (0, promises_1.writeFile)(executable, "");
+    await (0, promises_1.writeFile)((0, node_path_1.join)(defaultProfile, "Local State"), "logged-in-state");
+    process.env.LOCALAPPDATA = localAppData;
+    let connections = 0;
+    const profiles = [];
+    const connect = node_test_1.mock.method(cdp_client_1.DoubaoCdpClient.prototype, "connect", async () => {
+        connections++;
+        if (connections === 1)
+            throw Object.assign(new Error("CDP 未连接"), { code: "ECONNREFUSED" });
+    });
+    const restart = node_test_1.mock.method(desktopLaunch, "restartOwnedAndWait", async (...args) => {
+        profiles.push(args[3]);
+        if (profiles.length === 1)
+            throw new Error("默认用户目录已被占用");
+    });
+    const terminate = node_test_1.mock.method(desktopLaunch, "terminateWindowsDesktop", async () => []);
+    const copy = node_test_1.mock.method(fsPromises, "cp", async () => {
+        throw Object.assign(new Error("文件被占用"), { code: "EBUSY" });
+    });
+    const robocopy = node_test_1.mock.method(childProcess, "execFile", (file, args, _options, callback) => {
+        strict_1.default.equal(file, "robocopy.exe");
+        const source = args[0];
+        const target = args[1];
+        const name = args[2];
+        (0, node_fs_1.mkdirSync)(target, { recursive: true });
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(target, name), (0, node_fs_1.readFileSync)((0, node_path_1.join)(source, name)));
+        callback(null);
+        return {};
+    });
+    Object.defineProperty(process, "platform", { value: "win32" });
+    const plugin = new doubao_1.DoubaoPlugin();
+    try {
+        await plugin.activate({ config: { executablePath: executable }, dataDir });
+        strict_1.default.equal(profiles.length, 2);
+        strict_1.default.equal(await (0, promises_1.readFile)((0, node_path_1.join)(dataDir, "desktop-profile", "Local State"), "utf8"), "logged-in-state");
+    }
+    finally {
+        await plugin.deactivate();
+        robocopy.mock.restore();
+        copy.mock.restore();
+        terminate.mock.restore();
+        restart.mock.restore();
+        connect.mock.restore();
+        Object.defineProperty(process, "platform", platform);
+        if (previousLocalAppData === undefined)
+            delete process.env.LOCALAPPDATA;
+        else
+            process.env.LOCALAPPDATA = previousLocalAppData;
+        await (0, promises_1.rm)(root, { recursive: true, force: true });
+    }
+});
 (0, node_test_1.default)("豆包 /new 切换独立会话，重载后仍使用服务端会话标识", async () => {
     const dataDir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "doubao-sessions-"));
     const targets = [];
@@ -754,3 +1441,77 @@ 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;
+    let connections = 0;
+    const plugin = new doubao_1.DoubaoPlugin({
+        connect: async () => { connections++; connected = true; }, close: async () => undefined, connected: () => connected,
+        direct: async () => "回复", createSession: async () => { creates++; }, complete: async () => ({ text: "回复", sessionId: "123" }),
+    });
+    await plugin.activate({ config: {} });
+    const reconnect = plugin.reconnect;
+    plugin.reconnect = async () => { reconnects++; await reconnect(); };
+    connected = false;
+    const result = await plugin.modelProvider.complete({ prompt: "模型提示", sessionId: "pa-offline", timeoutMs: 5000, signal: new AbortController().signal });
+    await plugin.deactivate();
+    strict_1.default.equal(result.text, "回复");
+    strict_1.default.equal(connections, 2);
+    strict_1.default.equal(reconnects, 1);
+    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({ mode: "chat", 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);
+});