mu-agent-bridge 1.0.34 → 1.0.39

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

@@ -0,0 +1,339 @@
+"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 session_history_1 = require("../src-ts/plugins/qwenwork/session-history");
+const now = "2026-10-21T03:48:50.000Z";
+function provider(responses) {
+    const calls = [];
+    const history = new session_history_1.QwenworkSessionHistoryProvider({
+        scope: "qwenwork:cdp:9228",
+        unavailableReason: () => "",
+        query: async (path, input) => {
+            calls.push({ path, input });
+            const key = path === "chats.listBySubChat" ? `${path}:${String(input.beforeSequence ?? "latest")}` : path;
+            const value = responses[key] ?? responses[path];
+            if (value instanceof Error)
+                throw value;
+            return value;
+        },
+    });
+    return { history, calls };
+}
+(0, node_test_1.default)("千问列出全部活跃、归档和删除会话并分页返回", async () => {
+    const { history, calls } = provider({
+        "chats.list": [{ id: "today", name: "今日任务", updatedAt: now }],
+        "chats.listArchived": [{ id: "archived", name: "归档任务", updatedAt: "2026-10-20T03:00:00.000Z", archivedAt: now }],
+        "chats.listDeleted": [{ id: "deleted", name: "已删除任务", updatedAt: "2026-10-19T03:00:00.000Z", deletedAt: now }],
+    });
+    const first = await history.listSessions({ limit: 2 });
+    strict_1.default.equal(first.supported, true);
+    if (!first.supported)
+        return;
+    strict_1.default.deepEqual(first.sessions.map(session => session.id), ["today", "archived"]);
+    strict_1.default.ok(first.nextCursor);
+    strict_1.default.equal(first.complete, true);
+    const second = await history.listSessions({ limit: 2, cursor: first.nextCursor });
+    strict_1.default.equal(second.supported, true);
+    if (!second.supported)
+        return;
+    strict_1.default.equal(second.sessions[0]?.id, "deleted");
+    strict_1.default.equal(second.nextCursor, undefined);
+    strict_1.default.equal(calls.filter(call => call.path === "chats.list").length, 2);
+});
+(0, node_test_1.default)("千问读取所有 sub-chat，保留真实消息时间并支持正文分页", async () => {
+    const { history, calls } = provider({
+        "chats.get": { id: "today", name: "今日任务", updatedAt: now, subChats: [
+                { id: "sub-a", name: "主任务", createdAt: now, updatedAt: now },
+                { id: "sub-b", name: "子任务", createdAt: now, updatedAt: now },
+            ] },
+        "chats.listBySubChat": {
+            messages: [
+                { id: "m3", role: "assistant", parts: [{ type: "tool-Thinking", text: "隐藏推理" }, { type: "text", text: "处理完成" }], createdAt: "2026-10-21T04:00:00.000Z", sequence: 3 },
+                { id: "m2", role: "user", parts: [{ type: "text", text: "请处理这个问题" }], createdAt: "2026-10-21T03:50:00.000Z", sequence: 2 },
+            ], hasMoreBefore: true, hasMoreAfter: false, oldestSequence: 2, newestSequence: 3,
+        },
+        "chats.listBySubChat:2": {
+            messages: [{ id: "m1", role: "assistant", parts: [{ type: "text", text: "旧子任务结果" }], createdAt: "2026-10-21T03:40:00.000Z", sequence: 1 }],
+            hasMoreBefore: false, hasMoreAfter: true, oldestSequence: 1, newestSequence: 1,
+        },
+    });
+    const first = await history.readSession({ sessionId: "today", limit: 2 });
+    strict_1.default.equal(first.supported, true);
+    if (!first.supported)
+        return;
+    strict_1.default.deepEqual(first.turns.map(turn => [turn.id, turn.time, turn.text]), [
+        ["m1", "2026-10-21T03:40:00.000Z", "旧子任务结果"],
+        ["m2", "2026-10-21T03:50:00.000Z", "请处理这个问题"],
+    ]);
+    strict_1.default.ok(first.nextCursor);
+    strict_1.default.equal(first.complete, true);
+    const second = await history.readSession({ sessionId: "today", limit: 2, cursor: first.nextCursor });
+    strict_1.default.equal(second.supported, true);
+    if (!second.supported)
+        return;
+    strict_1.default.deepEqual(second.turns.map(turn => turn.id), ["m3"]);
+    strict_1.default.equal(second.nextCursor, undefined);
+    strict_1.default.equal(calls.filter(call => call.path === "chats.listBySubChat").length, 8);
+});
+(0, node_test_1.default)("千问未知可见正文块会标记不完整，思考块仍被排除", async () => {
+    const { history } = provider({
+        "chats.get": { id: "mixed", name: "混合正文", subChats: [{ id: "sub" }] },
+        "chats.listBySubChat": { messages: [
+                { id: "m1", role: "user", parts: [{ type: "text", text: "可见问题" }, { type: "file", uri: "private" }], createdAt: now },
+                { id: "m2", role: "assistant", parts: [{ type: "tool-Thinking", text: "不返回" }, { type: "text", text: "可见回答" }], createdAt: now },
+            ], hasMoreBefore: false },
+    });
+    const result = await history.readSession({ sessionId: "mixed", limit: 10 });
+    strict_1.default.equal(result.supported, true);
+    if (result.supported) {
+        strict_1.default.equal(result.complete, false);
+        strict_1.default.deepEqual(result.turns.map(turn => turn.text), ["可见问题", "可见回答"]);
+        strict_1.default.ok(result.missingReasons.some(reason => reason.includes("parts")));
+        strict_1.default.ok(!JSON.stringify(result).includes("不返回"));
+    }
+});
+(0, node_test_1.default)("千问会话或消息时间缺失时明确标记不完整", async () => {
+    const { history } = provider({
+        "chats.list": [{ id: "no-time", name: "未知时间" }],
+        "chats.listArchived": [],
+        "chats.listDeleted": [],
+        "chats.get": { id: "no-time", name: "未知时间", updatedAt: now, subChats: [{ id: "sub" }] },
+        "chats.listBySubChat": { messages: [{ id: "m", role: "user", parts: [{ type: "text", text: "问题" }] }], hasMoreBefore: false },
+    });
+    const listing = await history.listSessions({ limit: 10 });
+    strict_1.default.equal(listing.supported, true);
+    if (!listing.supported)
+        return;
+    strict_1.default.equal(listing.complete, false);
+    strict_1.default.match(listing.missingReasons.join(" "), /更新时间/);
+    const read = await history.readSession({ sessionId: "no-time", limit: 10 });
+    strict_1.default.equal(read.supported, true);
+    if (!read.supported)
+        return;
+    strict_1.default.equal(read.complete, false);
+    strict_1.default.match(read.missingReasons.join(" "), /创建时间/);
+    strict_1.default.deepEqual(read.turns, [{ id: "m", role: "user", text: "问题" }]);
+});
+(0, node_test_1.default)("千问畸形会话目录结构不会被当作完整空目录", async () => {
+    const malformed = provider({
+        "chats.list": [{ id: "valid", name: "有效会话", updatedAt: now }, null, { name: "缺少 ID" }],
+        "chats.listArchived": [],
+        "chats.listDeleted": [],
+    });
+    const partial = await malformed.history.listSessions({ limit: 10 });
+    strict_1.default.equal(partial.supported, true);
+    if (!partial.supported)
+        return;
+    strict_1.default.deepEqual(partial.sessions.map(session => session.id), ["valid"]);
+    strict_1.default.equal(partial.complete, false);
+    strict_1.default.match(partial.missingReasons.join(" "), /无法识别的条目/);
+    const invalid = provider({ "chats.list": "unexpected", "chats.listArchived": [], "chats.listDeleted": [] });
+    const unsupported = await invalid.history.listSessions({ limit: 10 });
+    strict_1.default.equal(unsupported.supported, false);
+    if (!unsupported.supported)
+        strict_1.default.match(unsupported.reason, /无法识别的结构/);
+});
+(0, node_test_1.default)("千问畸形 sub-chat 条目标记正文不完整，仍保留有效 sub-chat", async () => {
+    const { history } = provider({
+        "chats.get": { id: "chat", name: "任务", updatedAt: now, subChats: [null, { name: "缺少 ID" }, { id: "valid-sub" }] },
+        "chats.listBySubChat": { messages: [{ id: "m1", role: "user", parts: [{ type: "text", text: "消息" }], createdAt: now }], hasMoreBefore: false },
+    });
+    const result = await history.readSession({ sessionId: "chat", limit: 10 });
+    strict_1.default.equal(result.supported, true);
+    if (!result.supported)
+        return;
+    strict_1.default.equal(result.complete, false);
+    strict_1.default.match(result.missingReasons.join(" "), /sub-chat 目录缺失或含有无法识别的条目/);
+    strict_1.default.deepEqual(result.turns.map(turn => turn.id), ["m1"]);
+});
+(0, node_test_1.default)("千问正文游标可覆盖超过1000条消息", async () => {
+    const messages = Array.from({ length: 1002 }, (_, index) => ({
+        id: `m${index}`, role: "user", parts: [{ type: "text", text: `消息 ${index}` }],
+        createdAt: new Date(Date.parse(now) + index * 1000).toISOString(), sequence: 1002 - index,
+    }));
+    const { history } = provider({
+        "chats.get": { id: "chat", name: "任务", updatedAt: now, subChats: [{ id: "sub" }] },
+        "chats.listBySubChat": { messages, hasMoreBefore: false },
+    });
+    let result = await history.readSession({ sessionId: "chat", limit: 200 });
+    for (let page = 0; page < 5; page++) {
+        strict_1.default.equal(result.supported, true);
+        if (!result.supported || !result.nextCursor)
+            return;
+        result = await history.readSession({ sessionId: "chat", limit: 200, cursor: result.nextCursor });
+    }
+    strict_1.default.equal(result.supported, true);
+    if (!result.supported)
+        return;
+    strict_1.default.deepEqual(result.turns.map(turn => turn.id), ["m1000", "m1001"]);
+});
+(0, node_test_1.default)("千问 user/assistant 畸形 parts 标记不完整，纯 thinking 消息仍忽略", async () => {
+    const { history } = provider({
+        "chats.get": { id: "chat", name: "任务", updatedAt: now, subChats: [{ id: "sub" }] },
+        "chats.listBySubChat": { messages: [
+                { id: "bad-parts", role: "user", parts: "错误结构", createdAt: now },
+                { id: "bad-entry", role: "assistant", parts: [{ type: "text", text: "可见回复" }, null], createdAt: now },
+                { id: "thinking-only", role: "assistant", parts: [{ type: "tool-Thinking", text: "隐藏思考" }], createdAt: now },
+            ], hasMoreBefore: false },
+    });
+    const result = await history.readSession({ sessionId: "chat", limit: 10 });
+    strict_1.default.equal(result.supported, true);
+    if (!result.supported)
+        return;
+    strict_1.default.equal(result.complete, false);
+    strict_1.default.match(result.missingReasons.join(" "), /parts 格式无效/);
+    strict_1.default.match(result.missingReasons.join(" "), /无法识别的 parts/);
+    strict_1.default.deepEqual(result.turns.map(turn => [turn.id, turn.text]), [["bad-entry", "可见回复"]]);
+});
+(0, node_test_1.default)("千问纯 thinking 消息不产生正文，也不造成错误的不完整标记", async () => {
+    const { history } = provider({
+        "chats.get": { id: "chat", name: "任务", updatedAt: now, subChats: [{ id: "sub" }] },
+        "chats.listBySubChat": { messages: [
+                { id: "thinking-only", role: "assistant", parts: [{ type: "tool-Thinking", input: { text: "隐藏思考" } }], createdAt: now },
+            ], hasMoreBefore: false },
+    });
+    const result = await history.readSession({ sessionId: "chat", limit: 10 });
+    strict_1.default.equal(result.supported, true);
+    if (!result.supported)
+        return;
+    strict_1.default.equal(result.complete, true);
+    strict_1.default.deepEqual(result.turns, []);
+    strict_1.default.deepEqual(result.missingReasons, []);
+});
+(0, node_test_1.default)("since 过滤正文前仍参与快照校验，旧消息畸形 parts 不影响今日完整性", async () => {
+    const { history } = provider({
+        "chats.get": { id: "chat", name: "任务", updatedAt: now, subChats: [{ id: "sub" }] },
+        "chats.listBySubChat": { messages: [
+                { id: "old", role: "assistant", parts: [{ unknownOldShape: true }], createdAt: "2026-10-20T23:59:59.000Z", sequence: 1 },
+                { id: "today", role: "assistant", parts: [{ type: "text", text: "今天完成" }], createdAt: "2026-10-21T00:00:00.000Z", sequence: 2 },
+            ], hasMoreBefore: false, oldestSequence: 1, newestSequence: 2 },
+    });
+    const result = await history.readSession({ sessionId: "chat", limit: 10, since: "2026-10-21T00:00:00+00:00" });
+    strict_1.default.equal(result.supported, true);
+    if (!result.supported)
+        return;
+    strict_1.default.equal(result.complete, true);
+    strict_1.default.deepEqual(result.turns.map(turn => [turn.id, turn.time, turn.text]), [["today", "2026-10-21T00:00:00.000Z", "今天完成"]]);
+});
+(0, node_test_1.default)("since 无效时拒绝；分页游标绑定规范化 since", async () => {
+    const { history } = provider({
+        "chats.get": { id: "chat", name: "任务", updatedAt: now, subChats: [{ id: "sub" }] },
+        "chats.listBySubChat": { messages: [
+                { id: "m1", role: "user", parts: [{ type: "text", text: "一" }], createdAt: "2026-10-21T01:00:00.000Z" },
+                { id: "m2", role: "assistant", parts: [{ type: "text", text: "二" }], createdAt: "2026-10-21T02:00:00.000Z" },
+            ], hasMoreBefore: false },
+    });
+    const invalid = await history.readSession({ sessionId: "chat", limit: 10, since: "今天" });
+    strict_1.default.equal(invalid.supported, false);
+    if (!invalid.supported)
+        strict_1.default.match(invalid.reason, /since 时间格式无效/);
+    const first = await history.readSession({ sessionId: "chat", limit: 1, since: "2026-10-21T00:00:00Z" });
+    strict_1.default.equal(first.supported, true);
+    if (!first.supported || !first.nextCursor)
+        return;
+    const same = await history.readSession({ sessionId: "chat", limit: 1, since: "2026-10-21T00:00:00+00:00", cursor: first.nextCursor });
+    strict_1.default.equal(same.supported, true);
+    const changed = await history.readSession({ sessionId: "chat", limit: 1, since: "2026-10-21T00:01:00Z", cursor: first.nextCursor });
+    strict_1.default.equal(changed.supported, false);
+    if (!changed.supported)
+        strict_1.default.match(changed.reason, /游标无效/);
+});
+(0, node_test_1.default)("缺少创建时间的消息即使带 since 也标记不完整", async () => {
+    const { history } = provider({
+        "chats.get": { id: "chat", name: "任务", updatedAt: now, subChats: [{ id: "sub" }] },
+        "chats.listBySubChat": { messages: [{ id: "missing-time", role: "user", parts: [{ type: "text", text: "未知时间内容" }] }], hasMoreBefore: false },
+    });
+    const result = await history.readSession({ sessionId: "chat", limit: 10, since: "2026-10-21T00:00:00.000Z" });
+    strict_1.default.equal(result.supported, true);
+    if (!result.supported)
+        return;
+    strict_1.default.equal(result.complete, false);
+    strict_1.default.match(result.missingReasons.join(" "), /缺少有效创建时间/);
+});
+(0, node_test_1.default)("千问附件和文件产物转换成可供总结使用的提示文本", async () => {
+    const { history } = provider({
+        "chats.get": { id: "chat", name: "任务", updatedAt: now, subChats: [{ id: "sub" }] },
+        "chats.listBySubChat": { messages: [
+                { id: "input", role: "user", parts: [{ type: "data-file", filename: "输入.txt", mediaType: "text/plain" }], createdAt: now },
+                { id: "output", role: "assistant", parts: [{ type: "artifact", fileName: "结果.txt", mediaType: "file" }], createdAt: now },
+            ], hasMoreBefore: false },
+    });
+    const result = await history.readSession({ sessionId: "chat", limit: 10, since: "2026-10-21T00:00:00Z" });
+    strict_1.default.equal(result.supported, true);
+    if (!result.supported)
+        return;
+    strict_1.default.equal(result.complete, true);
+    strict_1.default.deepEqual(result.turns.map(turn => turn.text), ["[附件：输入.txt]", "[文件产物：结果.txt]"]);
+});
+(0, node_test_1.default)("千问列表分页发现目录变化时要求重新列举", async () => {
+    let changed = false;
+    const history = new session_history_1.QwenworkSessionHistoryProvider({
+        scope: "qwenwork:cdp:9228", unavailableReason: () => "",
+        query: async (path) => {
+            if (path === "chats.list")
+                return changed
+                    ? [{ id: "new", name: "新会话", updatedAt: now }, { id: "a", name: "A", updatedAt: now }, { id: "b", name: "B", updatedAt: now }]
+                    : [{ id: "a", name: "A", updatedAt: now }, { id: "b", name: "B", updatedAt: now }, { id: "c", name: "C", updatedAt: now }];
+            if (path === "chats.listArchived" || path === "chats.listDeleted")
+                return [];
+            throw new Error("unexpected");
+        },
+    });
+    const first = await history.listSessions({ limit: 2 });
+    strict_1.default.equal(first.supported, true);
+    if (!first.supported || !first.nextCursor)
+        return;
+    changed = true;
+    const next = await history.listSessions({ limit: 2, cursor: first.nextCursor });
+    strict_1.default.equal(next.supported, false);
+    if (!next.supported)
+        strict_1.default.match(next.reason, /发生变化，请重新列举/);
+});
+(0, node_test_1.default)("千问正文分页发现消息变化时要求重新读取", async () => {
+    let changed = false;
+    const history = new session_history_1.QwenworkSessionHistoryProvider({
+        scope: "qwenwork:cdp:9228", unavailableReason: () => "",
+        query: async (path, input) => {
+            if (path === "chats.get")
+                return { id: "chat", name: "任务", updatedAt: now, subChats: [{ id: "sub" }] };
+            if (path === "chats.listBySubChat") {
+                const messages = changed
+                    ? [{ id: "new", role: "assistant", parts: [{ type: "text", text: "新" }], createdAt: now }]
+                    : [
+                        { id: "m1", role: "user", parts: [{ type: "text", text: "一" }], createdAt: "2026-10-21T03:00:00Z" },
+                        { id: "m2", role: "assistant", parts: [{ type: "text", text: "二" }], createdAt: "2026-10-21T04:00:00Z" },
+                    ];
+                return { messages, hasMoreBefore: false, oldestSequence: input.beforeSequence ? 1 : 2, newestSequence: 2 };
+            }
+            throw new Error("unexpected");
+        },
+    });
+    const first = await history.readSession({ sessionId: "chat", limit: 1 });
+    strict_1.default.equal(first.supported, true);
+    if (!first.supported || !first.nextCursor)
+        return;
+    changed = true;
+    const next = await history.readSession({ sessionId: "chat", limit: 1, cursor: first.nextCursor });
+    strict_1.default.equal(next.supported, false);
+    if (!next.supported)
+        strict_1.default.match(next.reason, /发生变化，请重新读取/);
+});
+(0, node_test_1.default)("千问无效游标和不可用状态不会访问客户端", async () => {
+    let requests = 0;
+    const history = new session_history_1.QwenworkSessionHistoryProvider({
+        scope: "qwenwork:cdp:9228", unavailableReason: () => "千问当前忙",
+        query: async () => { requests++; return []; },
+    });
+    const result = await history.listSessions({ limit: 10, cursor: "tampered" });
+    strict_1.default.equal(result.supported, false);
+    strict_1.default.match(result.reason, /当前忙/);
+    strict_1.default.equal(requests, 0);
+    const available = provider({});
+    const invalid = await available.history.readSession({ sessionId: "x", limit: 10, cursor: "tampered" });
+    strict_1.default.equal(invalid.supported, false);
+    strict_1.default.equal(available.calls.length, 0);
+});

package/dist/tests-ts/qwenwork-images.test.js

@@ -0,0 +1,166 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_test_1 = __importDefault(require("node:test"));
+const node_vm_1 = require("node:vm");
+const cdp_client_1 = require("../src-ts/plugins/qwenwork/cdp-client");
+const attachments_1 = require("../src-ts/attachments");
+(0, node_test_1.default)("千问图片链接兼容编码的 Windows 路径并拒绝远端文件地址", () => {
+    strict_1.default.equal((0, cdp_client_1.normalizeQwenImageUrl)("file://D:%5Cwork%5C%E7%8C%AB.jpg"), "file:///D:/work/%E7%8C%AB.jpg");
+    for (const value of ["file://server/share/a.jpg", "file:////server/share/a.jpg", "https://example.com/a.jpg", "file:///tmp/a.jpg?x=1", "file:///%2fserver/a.jpg"])
+        strict_1.default.equal((0, cdp_client_1.normalizeQwenImageUrl)(value), undefined, value);
+});
+(0, node_test_1.default)("图片附件按实际字节识别类型，文本或伪装扩展名不会发送", () => {
+    strict_1.default.equal((0, attachments_1.detectImageContentType)(new Uint8Array([255, 216, 255, 1])), "image/jpeg");
+    strict_1.default.equal((0, attachments_1.detectImageContentType)(new TextEncoder().encode("不是图片")), undefined);
+});
+(0, node_test_1.default)("解析千问展开后的 data 图片并校验真实字节", () => {
+    const image = (0, cdp_client_1.decodeQwenDataImage)(`data:image/jpeg;base64,${Buffer.from([255, 216, 255, 1]).toString("base64")}`);
+    strict_1.default.equal(image?.contentType, "image/jpeg");
+    strict_1.default.deepEqual([...image.data], [255, 216, 255, 1]);
+    strict_1.default.equal((0, cdp_client_1.decodeQwenDataImage)("data:image/jpeg;base64,bm90LWltYWdl"), undefined);
+});
+(0, node_test_1.default)("只从最终文件工具参数提取 Windows 文件路径", () => {
+    const details = (0, cdp_client_1.parseQwenFinalFileDetails)(JSON.stringify({ files: [
+            { file_path: "D:\\\\work\\\\result.txt" },
+            { file_path: "D:\\\\work\\\\result.mp4" },
+            { file_path: "https://example.com/not-local" },
+            { file_path: "\\\\server\\\\share\\\\escape.txt" },
+        ] }));
+    strict_1.default.deepEqual(details.map((item) => [item.address, item.filename]), [
+        ["file:///D:/work/result.txt", "result.txt"],
+        ["file:///D:/work/result.mp4", "result.mp4"],
+    ]);
+});
+(0, node_test_1.default)("千问实际文件产物保留普通文件和视频 MIME，不局限于图片", async () => {
+    const { QwenCdpClient } = await Promise.resolve().then(() => __importStar(require("../src-ts/plugins/qwenwork/cdp-client")));
+    const client = new QwenCdpClient();
+    const encoded = [Buffer.from("校验内容").toString("base64"), Buffer.from([0, 0, 0, 20, 102, 116, 121, 112, 105, 115, 111, 109]).toString("base64")];
+    client.evaluate = async (expression) => {
+        if (expression.includes("const urls ="))
+            return [
+                { url: "file:///D:/result.txt", data: encoded[0], contentType: "text/plain" },
+                { url: "file:///D:/result.mp4", data: encoded[1], contentType: "video/mp4" },
+            ];
+        if (expression.includes("const files =")) {
+            strict_1.default.ok(!expression.includes('a[href^="file://"]'), "不能读取消息正文的本地文件链接");
+            strict_1.default.ok(expression.includes('location.href'), "产物采集必须绑定当前会话");
+            return JSON.stringify([{ details: JSON.stringify({ files: [{ file_path: "D:/result.txt" }, { file_path: "D:/result.mp4" }] }) }]);
+        }
+        return true;
+    };
+    client.evaluateArtifactResult = client.evaluate;
+    const result = await client.readArtifacts(new Set(), "file:///D:/qwen/index.html?chat=验收");
+    strict_1.default.deepEqual(result.map((item) => [item.kind, item.filename, item.contentType]), [["file", "result.txt", "text/plain"], ["file", "result.mp4", "video/mp4"]]);
+});
+(0, node_test_1.default)("千问上传部分成功后失败只清理本轮唯一名附件", async () => {
+    const { QwenCdpClient } = await Promise.resolve().then(() => __importStar(require("../src-ts/plugins/qwenwork/cdp-client")));
+    const client = new QwenCdpClient();
+    const removed = [];
+    const props = {
+        files: [],
+        async onAddAttachments(files) {
+            strict_1.default.match(files[0].name, /^校验-mab-[a-f0-9-]+\.txt$/);
+            props.files.push({ id: "bridge", filename: files[0].name }, { id: "user", filename: "校验.txt" });
+            throw new Error("原生上传失败");
+        },
+        onRemoveFile(id) { removed.push(id); },
+    };
+    const editor = { __reactFiberTest: { memoizedProps: props } };
+    client.evaluate = async (expression) => (0, node_vm_1.runInNewContext)(expression, { document: { querySelector: () => editor }, File, atob });
+    await strict_1.default.rejects(client.injectAttachments([{ kind: "file", filename: "校验.txt", contentType: "text/plain", data: Buffer.from("随机内容") }]), /原生上传失败/);
+    strict_1.default.deepEqual(removed, ["bridge"]);
+});
+(0, node_test_1.default)("千问发送确认失败会清理本轮附件，清理失败保留原错", async () => {
+    const { QwenCdpClient } = await Promise.resolve().then(() => __importStar(require("../src-ts/plugins/qwenwork/cdp-client")));
+    for (const cleanupFails of [false, true]) {
+        const client = new QwenCdpClient();
+        client.ensureVisible = client.recoverDraft = async () => undefined;
+        client.evaluate = async (expression) => expression.includes("JSON.stringify([...document.querySelectorAll") ? "[]" : true;
+        client.cdp = async () => undefined;
+        client.injectAttachments = async () => ["bridge-only"];
+        client.waitFor = async () => { throw new Error("提交确认失败"); };
+        let cleaned = [];
+        client.cleanupAttachments = async (ids) => { cleaned = ids; if (cleanupFails)
+            throw new Error("CDP 已断开"); };
+        await strict_1.default.rejects(client.complete("任务", 1, undefined, undefined, [{ kind: "file", filename: "输入.txt", contentType: "text/plain", data: Buffer.from("内容") }]), /提交确认失败/);
+        strict_1.default.deepEqual(cleaned, ["bridge-only"]);
+    }
+});
+(0, node_test_1.default)("千问大视频和内联图片分块读取，正常与失败均清理页面缓存", async () => {
+    for (const media of ["video", "image"]) {
+        for (const mode of ["normal", "truncated", "switched"]) {
+            const { QwenCdpClient } = await Promise.resolve().then(() => __importStar(require("../src-ts/plugins/qwenwork/cdp-client")));
+            const client = new QwenCdpClient();
+            const video = Buffer.alloc(5_287_422, 37);
+            if (media === "image")
+                Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]).copy(video);
+            const inline = { getAttribute: (name) => name === "src" ? `data:image/png;base64,${video.toString("base64")}` : "result.png" };
+            const button = { innerText: "已展示最终文件", getAttribute: () => "true", parentElement: { parentElement: { querySelectorAll: () => [{ textContent: JSON.stringify({ files: [{ file_path: "D:/result.mp4" }] }) }] } } };
+            const part = { getAttribute: () => "new", closest() { return this; }, querySelectorAll: (selector) => media === "image" ? selector.startsWith("img") ? [inline] : [] : selector === "button" ? [button] : [] };
+            const window = {};
+            const context = (0, node_vm_1.createContext)({ window, location: { href: "file:///index.html?chat=验收" }, document: { querySelectorAll: () => [part] }, fetch: async () => new Response(video, { headers: { "content-type": "video/mp4" } }), Uint8Array, btoa });
+            let chunks = 0;
+            client.evaluate = async (expression) => {
+                const readingChunk = expression.includes("?.slice(");
+                if (readingChunk) {
+                    chunks++;
+                    if (mode === "switched" && chunks > 1)
+                        context.location.href = "file:///index.html?chat=其他任务";
+                }
+                const value = await (0, node_vm_1.runInContext)(expression, context);
+                if (readingChunk && chunks > 1 && mode === "truncated")
+                    return value.slice(1);
+                if (Buffer.byteLength(JSON.stringify(value) ?? "") > 1_000_000)
+                    throw new Error("模拟CDP响应超过上限");
+                return value;
+            };
+            if (mode === "normal") {
+                const result = await client.readArtifacts(new Set(), "file:///index.html?chat=验收");
+                strict_1.default.equal(result.length, 1);
+                strict_1.default.deepEqual(Buffer.from(result[0].data), video);
+                strict_1.default.ok(chunks > 1);
+            }
+            else {
+                await strict_1.default.rejects(client.readArtifacts(new Set(), "file:///index.html?chat=验收"), mode === "truncated" ? /不完整/ : /会话已切换/);
+            }
+            strict_1.default.deepEqual(Object.keys(window), []);
+        }
+    }
+});

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

@@ -337,7 +337,8 @@ const cdp_client_1 = require("../src-ts/plugins/qwenwork/cdp-client");
         querySelector: (selector) => selector.includes("contenteditable") ? editor : selector.includes('aria-label="发送消息"') ? { disabled: false, getAttribute() { return null; }, click() { sent = true; editor.innerText = ""; } } : null,
         querySelectorAll: () => sent ? [reply] : [],
     };
-    client.evaluate = async (expression) => (0, node_vm_1.runInNewContext)(expression, { document });
+    const window = {};
+    client.evaluate = async (expression) => (0, node_vm_1.runInNewContext)(expression, { document, window, location: { href: "file:///index.html?chat=current" } });
     client.cdp = async (method, params) => {
         if (method === "Input.insertText") {
             inserted++;
@@ -560,3 +561,41 @@ const cdp_client_1 = require("../src-ts/plugins/qwenwork/cdp-client");
         globalThis.WebSocket = original;
     }
 });
+(0, node_test_1.default)("千问结构化回复保留图片附件并经同一任务队列返回", async () => {
+    const response = { text: "图片已生成", attachments: [{ kind: "image", filename: "猫捉鱼.jpg", contentType: "image/jpeg", data: new Uint8Array([255, 216, 255]) }] };
+    const plugin = new qwenwork_1.QwenworkPlugin({ httpPort: 0, client: {
+            connect: async () => undefined, close: () => undefined, connected: () => true,
+            send: async () => undefined, direct: async () => { throw new Error("不应退回纯文本接口"); },
+            complete: async () => response,
+        } });
+    await plugin.activate({ config: {}, dataDir: "." });
+    try {
+        strict_1.default.deepEqual(await plugin.handle({ task: "生成图片" }), response);
+    }
+    finally {
+        await plugin.deactivate("stop");
+    }
+});
+(0, node_test_1.default)("千问将入站附件透传给桌面客户端，不能静默降为纯文本", async () => {
+    const attachments = [{ kind: "file", filename: "校验.txt", contentType: "text/plain", data: new TextEncoder().encode("随机内容") }];
+    let received;
+    const client = { connect: async () => undefined, close: () => undefined, connected: () => true, send: async () => undefined, direct: async () => "", complete: async (...args) => { received = args[4]; return { text: "已读取" }; }, attachmentInput: true };
+    const plugin = new qwenwork_1.QwenworkPlugin({ httpPort: 0, client });
+    await plugin.activate({ config: {}, dataDir: "." });
+    try {
+        strict_1.default.equal(plugin.attachmentInput, true);
+        await plugin.handle({ task: "读取附件", attachments });
+        strict_1.default.deepEqual(received, attachments);
+    }
+    finally {
+        await plugin.deactivate("stop");
+    }
+});
+(0, node_test_1.default)("千问新版停止按钮出现时禁止新建会话或发送，避免打断媒体生成", async () => {
+    const { QwenCdpClient } = await Promise.resolve().then(() => __importStar(require("../src-ts/plugins/qwenwork/cdp-client")));
+    const client = new QwenCdpClient();
+    let clicked = false;
+    client.evaluate = async (expression) => (0, node_vm_1.runInNewContext)(expression, { document: { querySelector: (selector) => selector.includes('aria-label="停止"') ? {} : selector.includes('aria-label="新任务"') ? { click() { clicked = true; } } : null }, window: {} });
+    await strict_1.default.rejects(client.createSession(), /正在生成回复/);
+    strict_1.default.equal(clicked, false);
+});