mu-agent-bridge 1.0.71 → 1.0.78

package/plugins/dsh/dist/src-ts/plugins/dsh/cdp-client.js

@@ -0,0 +1,334 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DshCdpClient = void 0;
+const node_crypto_1 = require("node:crypto");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const node_os_1 = require("node:os");
+const attachments_1 = require("../../attachments");
+const dsh_agent_1 = require("../../dsh-agent");
+const stateExpression = `JSON.stringify((() => {
+  const content = document.querySelector('[data-conversation-content][data-conversation-session]');
+  const editor = document.querySelector('[data-composer-input][contenteditable="true"]');
+  const transcript = [...(content?.querySelectorAll('[data-chat-flow-kind="user"], [data-chat-flow-kind="assistant-step"]:not([data-chat-group-part="reasoning"])') || [])].map(node => node.getAttribute('data-chat-flow-kind') === 'user' ? node.querySelector('[data-slot="conversation.user.text.node"]')?.innerText.trim() || '' : node.innerText.trim()).filter(Boolean).join('\\n\\n');
+  const labels = button => [button.getAttribute('aria-label'), button.title, button.innerText].filter(Boolean).join(' ').trim();
+  const busy = [...document.querySelectorAll('button,[role="button"]')].some(button => /停止|stop|interrupt/i.test(labels(button)) && !button.disabled && button.getAttribute('aria-disabled') !== 'true');
+  const pending = document.querySelector('[data-composer-seat] [role="group"][aria-label*="Pending attachments"], [data-composer-seat] [role="group"][aria-label*="待发送附件"]');
+  const pendingAttachments = pending ? [...pending.querySelectorAll('[title],[alt]')].map(item => item.getAttribute('title') || item.getAttribute('alt')).filter(Boolean) : [];
+  return {
+    sessionId: content?.getAttribute('data-conversation-session') || '',
+    editorText: (editor?.innerText || '').replace(/[\\u200b\\ufeff]/g, '').trim(),
+    conversationText: transcript,
+    busy,
+    turnCount: content?.querySelectorAll('[data-turn-tail]').length || 0,
+    blank: content?.getAttribute('data-content-phase') === 'hero',
+    pendingAttachments,
+  };
+})())`;
+function sleep(ms) { return new Promise(resolve => setTimeout(resolve, ms)); }
+function normalize(value) { return value.replace(/[\u200b\ufeff]/g, "").replace(/\s+/g, " ").trim(); }
+class DshCdpClient {
+    options;
+    port;
+    timeoutMs;
+    connectionTimeoutMs;
+    fetchImpl;
+    webSocketFactory;
+    socket;
+    sequence = 0;
+    pending = new Map();
+    constructor(options = {}) {
+        this.options = options;
+        this.port = options.port ?? 9226;
+        this.timeoutMs = options.timeoutMs ?? 240_000;
+        this.connectionTimeoutMs = options.connectionTimeoutMs ?? 10_000;
+        this.fetchImpl = options.fetchImpl ?? fetch;
+        this.webSocketFactory = options.webSocketFactory ?? (url => new WebSocket(url));
+    }
+    connected() { return this.socket?.readyState === 1; }
+    async connect() {
+        if (this.connected())
+            return;
+        this.close();
+        const response = await this.fetchImpl(`http://127.0.0.1:${this.port}/json`, { signal: AbortSignal.timeout(this.connectionTimeoutMs) });
+        if (!response.ok)
+            throw new Error(`DSH CDP /json HTTP ${response.status}`);
+        const targets = await response.json();
+        const page = targets.find(item => item.type === "page" && item.url?.startsWith("dsh-app://app/") && item.webSocketDebuggerUrl);
+        if (!page?.webSocketDebuggerUrl)
+            throw new Error(`未找到 DSH 桌面会话页（CDP ${this.port}）`);
+        const socket = this.webSocketFactory(page.webSocketDebuggerUrl);
+        this.socket = socket;
+        let opened = false;
+        try {
+            await new Promise((resolve, reject) => {
+                const timer = setTimeout(() => reject(new Error("DSH CDP WebSocket 连接超时")), this.connectionTimeoutMs);
+                socket.onopen = () => { opened = true; clearTimeout(timer); resolve(); };
+                socket.onerror = () => { clearTimeout(timer); reject(new Error("DSH CDP WebSocket 连接失败")); };
+                socket.onclose = () => {
+                    if (this.socket === socket)
+                        this.socket = undefined;
+                    this.rejectPending(new Error("DSH CDP WebSocket 已关闭"));
+                    if (!opened) {
+                        clearTimeout(timer);
+                        reject(new Error("DSH CDP WebSocket 已关闭"));
+                    }
+                };
+                socket.onerror = () => {
+                    this.rejectPending(new Error("DSH CDP WebSocket 连接错误"));
+                    if (!opened) {
+                        clearTimeout(timer);
+                        reject(new Error("DSH CDP WebSocket 连接失败"));
+                    }
+                };
+                socket.onmessage = event => this.onMessage(String(event.data));
+            });
+            await this.cdp("Runtime.enable");
+            await this.waitForState(state => Boolean(state.sessionId), "DSH 桌面会话输入框未就绪", this.connectionTimeoutMs);
+        }
+        catch (error) {
+            this.close();
+            throw error;
+        }
+    }
+    async activeSession() { return (await this.state()).sessionId; }
+    async createSession() {
+        const before = await this.state();
+        this.assertIdle(before, "新建会话");
+        if (before.blank && before.turnCount === 0)
+            return before.sessionId;
+        const clicked = await this.evaluate(`(() => {
+      const labels = /^(?:新建会话|新会话|new session|new chat)$/i;
+      const button = [...document.querySelectorAll('button,[role="button"]')].find(item => {
+        const label = [item.getAttribute('aria-label'), item.title, item.innerText].filter(Boolean).join(' ').trim();
+        return labels.test(label) && !item.disabled && item.getAttribute('aria-disabled') !== 'true';
+      });
+      if (!button) return false;
+      button.click(); return true;
+    })()`);
+        if (clicked !== true)
+            throw new Error("DSH 桌面未找到可用的新建会话入口");
+        const state = await this.waitForState(value => value.sessionId !== before.sessionId && value.blank && !value.busy && !value.editorText && value.turnCount === 0 && !value.pendingAttachments.length, "DSH 新会话状态未确认");
+        if (!state.sessionId)
+            throw new Error("DSH 未返回真实新会话标识");
+        return state.sessionId;
+    }
+    async activateSession(sessionId) {
+        if (!sessionId.trim())
+            throw new Error("DSH 会话标识不能为空");
+        const before = await this.state();
+        if (before.sessionId === sessionId)
+            return;
+        this.assertIdle(before, "切换会话");
+        const clicked = await this.evaluate(`(() => {
+      const id = ${JSON.stringify(sessionId)};
+      const item = [...document.querySelectorAll('[data-row-key],[data-session-id],[data-session],[data-conversation-session]')]
+        .find(node => node.getAttribute('data-row-key') === 'session:' + id
+          || ['data-session-id', 'data-session', 'data-conversation-session'].some(key => node.getAttribute(key) === id));
+      const button = item?.matches('button,[role="button"],[role="treeitem"],a') ? item : item?.closest('button,[role="button"],[role="treeitem"],a');
+      if (!button || button.disabled || button.getAttribute('aria-disabled') === 'true') return false;
+      button.click(); return true;
+    })()`);
+        if (clicked !== true)
+            throw new Error(`DSH 桌面未找到可切换的会话 ${sessionId}，未发送消息`);
+        await this.waitForState(state => state.sessionId === sessionId, "DSH 会话切换未确认，未发送消息");
+    }
+    async complete(request) {
+        if (!request.task.trim())
+            throw new Error("DSH 消息内容不能为空");
+        (0, attachments_1.validateAttachments)(request.attachments);
+        const before = await this.state();
+        if (!before.sessionId)
+            throw new Error("DSH 当前没有可用会话");
+        this.assertIdle(before, "发送消息");
+        const deliveryBefore = request.attachmentOutput ? await this.readDeliveryState(before.sessionId) : undefined;
+        const workDirectory = request.attachments?.length ? await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "agent-bridge-dsh-cdp-")) : undefined;
+        let outputDirectory;
+        let outputCwd;
+        let failed = true;
+        try {
+            if (deliveryBefore) {
+                if (!(0, node_path_1.isAbsolute)(deliveryBefore.cwd))
+                    throw new Error("DSH 工作目录不是绝对路径，无法安全回传文件");
+                const cwd = await (0, promises_1.realpath)(deliveryBefore.cwd);
+                const info = await (0, promises_1.lstat)(cwd);
+                if (!info.isDirectory() || info.isSymbolicLink())
+                    throw new Error("DSH 工作目录不是受信任的目录");
+                outputCwd = cwd;
+                outputDirectory = (0, node_path_1.join)(cwd, `.agent-bridge-dsh-${(0, node_crypto_1.randomUUID)()}`);
+                await (0, promises_1.mkdir)(outputDirectory, { mode: 0o700 });
+                const outputRelative = (0, node_path_1.relative)(cwd, await (0, promises_1.realpath)(outputDirectory));
+                if (outputRelative === ".." || outputRelative.startsWith(`..${node_path_1.sep}`) || (0, node_path_1.isAbsolute)(outputRelative))
+                    throw new Error("DSH 回传目录超出工作目录");
+            }
+            const filenames = [];
+            if (request.attachments?.length && workDirectory) {
+                const paths = [];
+                for (const [index, item] of request.attachments.entries()) {
+                    const filename = (0, attachments_1.attachmentFilename)(item.filename);
+                    filenames.push(filename);
+                    const directory = (0, node_path_1.join)(workDirectory, String(index));
+                    await (0, promises_1.mkdir)(directory, { mode: 0o700 });
+                    const path = (0, node_path_1.join)(directory, filename);
+                    await (0, promises_1.writeFile)(path, item.data, { mode: 0o600, flag: "wx" });
+                    paths.push(path);
+                }
+                await this.setFiles(paths);
+                await this.waitForState(state => filenames.every(filename => state.pendingAttachments.includes(filename)), "DSH 未确认收到上传附件");
+            }
+            let task = request.task;
+            if (filenames.length)
+                task += `\n\n请读取本条已上传附件：${filenames.join("、")}。`;
+            if (outputDirectory)
+                task += `\n\n如需回传文件，将文件写入 ${outputDirectory} 并调用 present 声明。`;
+            await this.evaluate(`(() => { const editor = document.querySelector('[data-composer-input][contenteditable="true"]'); if (!editor || editor.innerText.trim()) return false; editor.focus(); return document.activeElement === editor; })()`);
+            await this.cdp("Input.insertText", { text: task });
+            const entered = await this.state();
+            if (normalize(entered.editorText) !== normalize(task))
+                throw new Error("DSH 输入框内容校验失败，未发送消息");
+            const turnCount = entered.turnCount;
+            await this.cdp("Input.dispatchKeyEvent", { type: "keyDown", key: "Enter", code: "Enter", windowsVirtualKeyCode: 13 });
+            await this.cdp("Input.dispatchKeyEvent", { type: "keyUp", key: "Enter", code: "Enter", windowsVirtualKeyCode: 13 });
+            const startedAt = Date.now();
+            let stable = 0;
+            let previous = "";
+            let observed = "";
+            while (Date.now() - startedAt < (request.timeoutMs ?? this.timeoutMs)) {
+                await sleep(600);
+                const state = await this.state();
+                if (state.sessionId !== before.sessionId)
+                    throw new Error("DSH 发送后会话发生变化，结果未确认且未重发");
+                if (state.conversationText.includes(task))
+                    observed = state.conversationText;
+                const signature = `${state.turnCount}:${state.busy}:${state.conversationText}`;
+                stable = !state.busy && state.turnCount > turnCount && signature === previous ? stable + 1 : 0;
+                previous = signature;
+                if (stable >= 2 && observed) {
+                    const userIndex = observed.lastIndexOf(task);
+                    const reply = userIndex >= 0 ? observed.slice(userIndex + task.length).trim() : "";
+                    const presented = request.attachmentOutput && deliveryBefore
+                        ? (await this.readDeliveryState(before.sessionId)).presented.filter(item => item.sequence > deliveryBefore.sequence).flatMap(item => item.paths)
+                        : [];
+                    const attachments = outputDirectory && presented.length
+                        ? await (0, dsh_agent_1.readPresentedFiles)(outputDirectory, presented, outputCwd, request.attachments ?? [])
+                        : [];
+                    if (!reply && !attachments.length)
+                        throw new Error("DSH 本轮历史中没有可确认的回复内容");
+                    failed = false;
+                    return { text: reply, ...(attachments.length ? { attachments } : {}) };
+                }
+            }
+            throw new Error(`DSH 桌面回复超时；任务已提交但未确认完成，未重发（会话 ${before.sessionId}）`);
+        }
+        finally {
+            if (workDirectory)
+                await (0, promises_1.rm)(workDirectory, { recursive: true, force: true });
+            if (outputDirectory) {
+                try {
+                    await (0, promises_1.rm)(outputDirectory, { recursive: true, force: true });
+                }
+                catch (error) {
+                    if (!failed)
+                        throw error;
+                }
+            }
+        }
+    }
+    close() {
+        const socket = this.socket;
+        this.socket = undefined;
+        socket?.close();
+        this.rejectPending(new Error("DSH CDP 已关闭"));
+    }
+    async setFiles(files) {
+        const document = await this.cdp("DOM.getDocument", { depth: -1, pierce: true });
+        const result = await this.cdp("DOM.querySelector", { nodeId: document.root.nodeId, selector: 'input[type="file"]' });
+        if (!result.nodeId)
+            throw new Error("DSH 桌面原生附件输入控件未找到");
+        await this.cdp("DOM.setFileInputFiles", { nodeId: result.nodeId, files });
+    }
+    assertIdle(state, action) {
+        if (state.busy)
+            throw new Error(`DSH 正在生成回复，不能${action}`);
+        if (state.editorText || state.pendingAttachments.length)
+            throw new Error(`DSH 输入框有未发送内容或附件，不能${action}`);
+    }
+    async state() {
+        const value = await this.evaluate(stateExpression);
+        if (typeof value !== "string")
+            throw new Error("DSH 桌面状态响应无效");
+        const state = JSON.parse(value);
+        if (!state || typeof state.sessionId !== "string" || typeof state.editorText !== "string" || typeof state.conversationText !== "string" || typeof state.busy !== "boolean" || !Number.isInteger(state.turnCount) || typeof state.blank !== "boolean" || !Array.isArray(state.pendingAttachments))
+            throw new Error("DSH 桌面页面结构不符合预期");
+        return state;
+    }
+    async waitForState(predicate, message, timeoutMs = this.timeoutMs) {
+        const deadline = Date.now() + timeoutMs;
+        let lastError;
+        while (Date.now() < deadline) {
+            try {
+                const state = await this.state();
+                if (predicate(state))
+                    return state;
+            }
+            catch (error) {
+                lastError = error;
+            }
+            await sleep(250);
+        }
+        throw new Error(message, lastError ? { cause: lastError } : undefined);
+    }
+    async evaluate(expression) {
+        const result = await this.cdp("Runtime.evaluate", { expression, returnByValue: true, awaitPromise: true, userGesture: true });
+        if (result.exceptionDetails)
+            throw new Error(`DSH CDP 页面执行失败：${result.exceptionDetails.text ?? result.exceptionDetails.exception?.description ?? "未知错误"}`);
+        return result.result?.value;
+    }
+    async cdp(method, params = {}) {
+        const socket = this.socket;
+        if (!socket || socket.readyState !== 1)
+            throw new Error("DSH CDP 未连接");
+        const id = ++this.sequence;
+        const promise = new Promise((resolve, reject) => this.pending.set(id, { resolve, reject }));
+        socket.send(JSON.stringify({ id, method, params }));
+        let timer;
+        try {
+            const timeout = new Promise((_, reject) => { timer = setTimeout(() => { this.pending.delete(id); reject(new Error(`DSH CDP ${method} 超时`)); }, this.connectionTimeoutMs); });
+            const response = await Promise.race([promise, timeout]);
+            if (response.error)
+                throw new Error(response.error.message ?? `DSH CDP ${method} 失败`);
+            return response.result ?? {};
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    }
+    onMessage(raw) {
+        let message;
+        try {
+            message = JSON.parse(raw);
+        }
+        catch {
+            return;
+        }
+        if (typeof message.id !== "number")
+            return;
+        const pending = this.pending.get(message.id);
+        if (!pending)
+            return;
+        this.pending.delete(message.id);
+        pending.resolve(message);
+    }
+    rejectPending(error) {
+        for (const pending of this.pending.values())
+            pending.reject(error);
+        this.pending.clear();
+    }
+    async readDeliveryState(sessionId) {
+        if (!this.options.readDeliveryState)
+            throw new Error("DSH 附件回传需要可读取的持久化会话日志");
+        return this.options.readDeliveryState(sessionId);
+    }
+}
+exports.DshCdpClient = DshCdpClient;

package/plugins/dsh/dist/src-ts/plugins/dsh/index.js

@@ -1,45 +1,94 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DshPlugin = exports.dshManifest = void 0;
+const promises_1 = require("node:fs/promises");
 const node_path_1 = require("node:path");
+const agent_1 = require("../../agent");
 const dsh_agent_1 = require("../../dsh-agent");
 const dsh_paths_1 = require("../../dsh-paths");
+const plugin_1 = require("../../plugin");
 const openai_adapter_1 = require("../qwenwork/openai-adapter");
 const session_history_1 = require("./session-history");
+const cdp_client_1 = require("./cdp-client");
 exports.dshManifest = {
     id: "dsh",
-    version: "1.0.11",
+    version: "1.0.15",
     displayName: "DeepSeek Harness",
     entry: "dist/index.js",
     apiVersion: "1",
     process: "in-process",
-    capabilities: ["chat", "health"],
+    capabilities: ["chat", "health", "model-provider"],
     configSchema: "config.schema.json",
 };
 class DshPlugin {
+    options;
     manifest = exports.dshManifest;
+    modelProvider = { complete: (request) => this.completeModelProvider(request) };
     attachmentInput = true;
     sessionOperations = ["new"];
     sessionHistory;
+    client;
     agent;
+    modelConfig = {};
+    modelSessions = new Map();
+    modelSessionsPath;
     status = "failed";
     message = "插件尚未启动";
     adapter;
     activeRequests = 0;
+    port = 9226;
+    queue = Promise.resolve();
+    pendingSessions = new Set();
     unregister = [];
+    constructor(options = {}) {
+        this.options = options;
+    }
     async activate(context) {
-        const configured = context.config.patchPath;
-        const patchPath = typeof configured === "string" && configured.trim()
-            ? configured
-            : (0, node_path_1.resolve)(__dirname, "..", "..", "headless-account.patch.yml");
-        const paths = await (0, dsh_paths_1.resolveDshPaths)(patchPath, typeof context.config.executablePath === "string" ? context.config.executablePath : undefined);
-        this.agent = new dsh_agent_1.DshAgent({ patchPath, paths });
-        context.logger?.info?.("DSH 客户端路径已确认", { executablePath: paths.executable });
+        this.modelConfig = context.config;
+        this.modelSessions.clear();
+        this.modelSessionsPath = context.dataDir ? (0, node_path_1.join)(context.dataDir, "model-provider-sessions.json") : undefined;
+        if (this.modelSessionsPath) {
+            try {
+                const saved = JSON.parse(await (0, promises_1.readFile)(this.modelSessionsPath, "utf8"));
+                const valid = (value) => typeof value === "string" && value.trim() && value.length <= 512 && !/[\u0000-\u001f]/.test(value);
+                if (!saved || typeof saved !== "object" || Array.isArray(saved) || Object.entries(saved).some(([key, value]) => !valid(key) || !valid(value)))
+                    throw new Error("DSH 个人助理模型会话记录无效");
+                for (const [key, value] of Object.entries(saved))
+                    this.modelSessions.set(key, value);
+            }
+            catch (error) {
+                if (error.code !== "ENOENT")
+                    throw error;
+            }
+        }
+        this.port = (0, plugin_1.resolveRuntimePort)(context.config, context.runtime, "dsh", "DSH_CDP_PORT", 9226);
+        const sessionsRoot = typeof context.config.sessionsRoot === "string" ? context.config.sessionsRoot : undefined;
         this.sessionHistory = new session_history_1.DshSessionHistoryProvider({
-            sessionsRoot: typeof context.config.sessionsRoot === "string" ? context.config.sessionsRoot : undefined,
+            ...(sessionsRoot ? { sessionsRoot } : {}),
             unavailableReason: () => this.status !== "ready" ? "DSH 插件尚未就绪" : this.activeRequests ? "DSH 正在处理任务，暂不读取持久化历史" : "",
         });
-        this.adapter = new openai_adapter_1.OpenAIAdapter((prompt) => this.handle({ task: prompt, timeoutMs: 240_000 }).then((result) => result.text), { model: "dsh", prefix: "/dsh/v1", onExchange: (direction, text, peer, agentAid) => context.logger?.info?.("DSH 通信", { direction, text, peer, agentAid }) });
+        this.client = this.options.client ?? new cdp_client_1.DshCdpClient({
+            port: this.port,
+            timeoutMs: typeof context.config.timeoutMs === "number" && context.config.timeoutMs > 0 ? context.config.timeoutMs : undefined,
+            connectionTimeoutMs: typeof context.config.startupTimeoutMs === "number" && context.config.startupTimeoutMs > 0 ? context.config.startupTimeoutMs : undefined,
+            readDeliveryState: sessionId => this.sessionHistory.readDeliveryState(sessionId),
+        });
+        this.adapter = new openai_adapter_1.OpenAIAdapter((prompt) => this.handle({ task: prompt, timeoutMs: 240_000 }).then(result => result.text), {
+            model: "dsh", prefix: "/dsh/v1",
+            onExchange: (direction, text, peer, agentAid) => context.logger?.info?.("DSH 通信", { direction, text, peer, agentAid }),
+        });
+        try {
+            await this.client.connect();
+            this.status = "ready";
+            this.message = "";
+        }
+        catch (error) {
+            this.status = "failed";
+            this.message = error instanceof Error ? error.message : String(error);
+            context.logger?.error?.(this.message);
+            this.client.close();
+            throw error;
+        }
         if (context.http) {
             for (const [method, path] of [["GET", "/dsh/v1/models"], ["POST", "/dsh/v1/chat/completions"], ["OPTIONS", "/dsh/v1/chat/completions"]]) {
                 const dispose = context.http.register({ method, path, handler: (req, res) => this.adapter.handle(req, res) });
@@ -47,34 +96,136 @@ class DshPlugin {
                     this.unregister.push(dispose);
             }
         }
-        this.status = "ready";
-        this.message = "";
-        context.logger?.info?.("dsh plugin activated");
+        context.logger?.info?.("DSH 桌面 CDP 已连接", { port: this.port });
     }
     async deactivate() {
+        this.status = "failed";
+        this.message = "插件正在停止";
+        await this.queue;
         for (const dispose of this.unregister.splice(0))
             dispose();
         await this.adapter?.close();
         this.adapter = undefined;
+        this.client?.close();
+        this.client = undefined;
         this.agent = undefined;
         this.sessionHistory = undefined;
+        this.pendingSessions.clear();
         this.status = "failed";
         this.message = "插件已停止";
     }
     async health() {
-        return { status: this.status, ...(this.message ? { message: this.message } : {}), details: { adapter: "DshAgent" } };
+        const connected = this.client?.connected() === true;
+        return {
+            status: connected ? "ready" : this.status === "failed" ? "failed" : "degraded",
+            ...(!connected ? { message: this.message || "DSH CDP 已断开" } : {}),
+            details: { transport: "cdp", port: this.port, connected },
+        };
+    }
+    async controlSession(request) {
+        if (request.operation !== "new")
+            throw new Error(`DSH 不支持会话操作：${String(request.operation)}`);
+        if (!request.sessionId?.trim())
+            throw new Error("DSH 新会话缺少 sessionId");
+        return this.enqueue(async () => {
+            this.assertConnected();
+            const sessionId = await this.client.createSession();
+            this.pendingSessions.add(sessionId);
+            return { text: "DSH 已创建新会话", sessionId };
+        });
     }
     async handle(request) {
-        if (!this.agent || this.status !== "ready")
-            throw new Error("dsh 插件未就绪");
-        this.activeRequests++;
+        return this.enqueue(async () => {
+            this.assertConnected();
+            this.activeRequests++;
+            try {
+                const current = await this.client.activeSession();
+                let sessionId = request.sessionId?.trim();
+                if (request.newSession) {
+                    if (sessionId && (this.pendingSessions.has(sessionId) || current === sessionId)) {
+                        if (current !== sessionId)
+                            await this.client.activateSession(sessionId);
+                        this.pendingSessions.delete(sessionId);
+                    }
+                    else {
+                        sessionId = await this.client.createSession();
+                    }
+                }
+                else if (sessionId) {
+                    if (current !== sessionId)
+                        await this.client.activateSession(sessionId);
+                }
+                else {
+                    sessionId = await this.client.createSession();
+                }
+                const response = await this.client.complete(request);
+                return { ...response, sessionId };
+            }
+            finally {
+                this.activeRequests--;
+            }
+        });
+    }
+    async completeModelProvider(request) {
+        let stage = "DSH 模型排队（queue）";
         try {
-            return await this.agent.send(request);
+            request.signal.throwIfAborted();
+            const run = this.queue.then(async () => {
+                request.signal.throwIfAborted();
+                stage = "连接 DSH 模型（connect）";
+                if (this.status !== "ready")
+                    throw new Error("DSH 插件未就绪");
+                if (!this.agent) {
+                    const configured = this.modelConfig.patchPath;
+                    const patchPath = typeof configured === "string" && configured.trim() ? configured : (0, node_path_1.resolve)(__dirname, "..", "..", "headless-account.patch.yml");
+                    const paths = await (0, dsh_paths_1.resolveDshPaths)(patchPath, typeof this.modelConfig.executablePath === "string" ? this.modelConfig.executablePath : undefined);
+                    this.agent = new dsh_agent_1.DshAgent({ patchPath, paths });
+                }
+                this.activeRequests++;
+                try {
+                    const sessionId = this.modelSessions.get(request.sessionId);
+                    stage = "等待 DSH 模型生成（generate）";
+                    const response = await this.agent.send({
+                        task: request.prompt,
+                        timeoutMs: request.timeoutMs,
+                        signal: request.signal,
+                        ...(sessionId ? { sessionId } : { newSession: true }),
+                    }, true);
+                    if (!sessionId) {
+                        if (!response.sessionId)
+                            throw new Error("DSH 未返回个人助理模型会话标识");
+                        const next = new Map(this.modelSessions).set(request.sessionId, response.sessionId);
+                        if (this.modelSessionsPath) {
+                            await (0, promises_1.mkdir)((0, node_path_1.resolve)(this.modelSessionsPath, ".."), { recursive: true });
+                            await (0, promises_1.writeFile)(`${this.modelSessionsPath}.tmp`, JSON.stringify(Object.fromEntries(next)), { mode: 0o600 });
+                            await (0, promises_1.rename)(`${this.modelSessionsPath}.tmp`, this.modelSessionsPath);
+                        }
+                        this.modelSessions.set(request.sessionId, response.sessionId);
+                    }
+                    return { text: response.text };
+                }
+                finally {
+                    this.activeRequests--;
+                }
+            });
+            this.queue = run.then(() => undefined, () => undefined);
+            return await (0, agent_1.abortable)(run, request.signal);
         }
-        finally {
-            this.activeRequests--;
+        catch (error) {
+            if (error instanceof agent_1.AgentOperationError)
+                throw error;
+            throw new agent_1.AgentOperationError("DSH_MODEL_FAILED", stage, error);
         }
     }
+    enqueue(work) {
+        const run = this.queue.then(work);
+        this.queue = run.then(() => undefined, () => undefined);
+        return run;
+    }
+    assertConnected() {
+        if (!this.client || this.status !== "ready" || !this.client.connected())
+            throw new Error(this.message || `DSH CDP ${this.port} 未连接`);
+    }
 }
 exports.DshPlugin = DshPlugin;
 exports.default = DshPlugin;