mu-agent-bridge 1.0.71 → 1.0.78

package/dist/src-ts/plugins/dsh/session-history.js

@@ -16,7 +16,7 @@ const KNOWN_EVENTS = new Set([
     "agent-preset/selected", "agent/inbox/spliced", "approval/asked", "approval/decided", "approval/policy", "assistant/attempt", "assistant/message",
     "command/done", "command/run", "compaction/end", "compaction/prune", "compaction/start", "compaction/summary", "deliverables/presented",
     "developer/message", "feedback/message-delete", "feedback/message-put", "feedback/record", "goal/change", "hook/invoked", "hook/result",
-    "image/offload", "llm/retry", "llm/retry-started", "model/selection", "permission/preset", "plan/mode", "request/context", "request/header",
+    "image/offload", "job/registered", "job/settled", "llm/retry", "llm/retry-started", "model/selection", "permission/preset", "plan/mode", "request/context", "request/header",
     "sandbox/mode", "schedule/change", "session-log-deepseek/delivery-accepted", "session/end-seed", "session/title", "session/title-llm-request",
     "step/end", "step/start", "subagent/catalog", "subagent/descriptor", "subagent/model-selection-policy", "system/message", "team/member",
     "team/message/delivered", "team/message/queued", "team/task", "todo/write", "tool-workflow/agent-end", "tool-workflow/agent-start",
@@ -134,6 +134,21 @@ class DshSessionHistoryProvider {
             readAt: new Date().toISOString(),
         };
     }
+    async readDeliveryState(sessionId) {
+        if (typeof sessionId !== "string" || !sessionId.trim() || sessionId.length > 512)
+            throw new Error("DSH 会话标识无效");
+        const root = await this.realRoot();
+        if (typeof root !== "string")
+            throw new Error(root.reason);
+        const discovered = await this.discover(root);
+        const entry = discovered.entries.find(item => item.id === sessionId);
+        if (!entry)
+            throw new Error("DSH 会话尚无可读取的持久化日志");
+        const parsed = await this.readEntry(root, entry);
+        if (!parsed.complete || !parsed.cwd)
+            throw new Error(parsed.reasons.join("；") || "DSH 会话工作目录无法验证");
+        return { cwd: parsed.cwd, sequence: parsed.sequence, presented: parsed.presented };
+    }
     async realRoot() {
         try {
             const resolved = await (0, promises_1.realpath)(this.root);
@@ -251,7 +266,7 @@ class DshSessionHistoryProvider {
     }
     async readEntry(root, entry) {
         const reasons = [];
-        const fail = (reason) => ({ session: { id: entry.id, title: entry.id }, turns: [], complete: false, reasons: [...new Set([...reasons, reason])] });
+        const fail = (reason) => ({ session: { id: entry.id, title: entry.id }, turns: [], complete: false, reasons: [...new Set([...reasons, reason])], sequence: -1, presented: [] });
         try {
             if (!await this.inside(root, entry.path))
                 return fail("DSH 会话日志路径越界或为符号链接");
@@ -285,7 +300,9 @@ class DshSessionHistoryProvider {
             if (header.type !== "session" || header.version !== 4 || header.id !== entry.id || !validTime(header.createdAt) || typeof header.isSeeded !== "boolean" || !Number.isSafeInteger(header.delegationDepth) || header.delegationDepth < 0)
                 return fail("DSH 会话头格式或身份无法验证");
             const turns = [];
+            const presented = [];
             let complete = true;
+            let sequence = -1;
             for (let index = 1; index < rows.length; index++) {
                 let event;
                 try {
@@ -296,11 +313,22 @@ class DshSessionHistoryProvider {
                 }
                 if (!event || event.seq !== index - 1 || typeof event.type !== "string" || !validTime(event.time) || typeof event.data !== "object" || event.data === null)
                     return fail("DSH 会话事件序号、时间或结构无法验证");
+                sequence = event.seq;
                 if (!KNOWN_EVENTS.has(event.type) && event.ignorable !== true) {
                     complete = false;
                     reasons.push(`存在未知且不可安全忽略的 DSH 事件：${event.type}`);
                     continue;
                 }
+                if (event.type === "deliverables/presented") {
+                    const files = event.data.files;
+                    if (!Array.isArray(files) || files.some((file) => !file || typeof file.path !== "string" || !file.path.trim())) {
+                        complete = false;
+                        reasons.push("DSH present 事件缺少有效文件路径");
+                        continue;
+                    }
+                    presented.push({ sequence, paths: files.map((file) => file.path) });
+                    continue;
+                }
                 if (event.type !== "user/message" && event.type !== "assistant/message")
                     continue;
                 const declaredRole = event.type === "user/message" ? event.data.role : event.data.message?.role;
@@ -335,7 +363,7 @@ class DshSessionHistoryProvider {
                 if (message)
                     turns.push({ id: `${entry.id}:${event.seq}`, role: event.type === "user/message" ? "user" : "assistant", text: message, time: new Date(event.time).toISOString() });
             }
-            return { session: { id: entry.id, title: entry.id, updatedAt: new Date(before.mtimeMs).toISOString() }, turns, complete, reasons: [...new Set(reasons)] };
+            return { session: { id: entry.id, title: entry.id, updatedAt: new Date(before.mtimeMs).toISOString() }, turns, complete, reasons: [...new Set(reasons)], ...(typeof header.cwd === "string" ? { cwd: header.cwd } : {}), sequence, presented };
         }
         catch (error) {
             return fail(error instanceof Error && /maximum output length|larger than/.test(error.message) ? "DSH 解压日志超过读取上限" : "DSH 会话日志无法按官方 v4 格式完整解析");

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

@@ -5,7 +5,7 @@ const promises_1 = require("node:fs/promises");
 const node_path_1 = require("node:path");
 const qrcode_1 = require("qrcode");
 const client_1 = require("./client");
-const manifest = { id: "feishu", version: "1.0.7", type: "channel", displayName: "飞书通道", entry: "dist/src-ts/plugins/feishu/index.js", apiVersion: "1", process: "in-process", capabilities: ["channel", "channel.bot.setup", "channel.receive", "channel.send", "health", "cli"], configSchema: "config.schema.json", managementPage: "/abweb/channels/feishu" };
+const manifest = { id: "feishu", version: "1.0.8", type: "channel", displayName: "飞书通道", entry: "dist/src-ts/plugins/feishu/index.js", apiVersion: "1", process: "in-process", capabilities: ["channel", "channel.bot.setup", "channel.receive", "channel.send", "health", "cli"], configSchema: "config.schema.json", managementPage: "/abweb/channels/feishu" };
 const newSessionCommand = /^\/new(?:[ \t]+[^\r\n]+)?$/;
 const commands = [
     { name: "status", summary: "查看飞书通道状态", usage: "mab feishu status" },

package/dist/src-ts/plugins/local-cli/agent.js

@@ -6,6 +6,7 @@ const node_child_process_1 = require("node:child_process");
 const node_fs_1 = require("node:fs");
 const promises_1 = require("node:fs/promises");
 const node_path_1 = require("node:path");
+const node_os_1 = require("node:os");
 const node_crypto_1 = require("node:crypto");
 const nativeId = /^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i;
 const maximumOutput = 4 * 1024 * 1024;
@@ -22,6 +23,21 @@ function diagnostic(value) {
     } })
         .slice(0, 2000);
 }
+function modelDiagnostic(error) {
+    const message = String(error);
+    const code = /CLI 退出码 (?:\d+|[A-Z][A-Z0-9_]+)/.exec(message)?.[0];
+    if (code)
+        return `${code}：请检查 CLI 登录、权限和网络`;
+    if (message.includes("CLI 调用超时"))
+        return "CLI 模型调用超时，请检查登录、网络或权限审批";
+    if (message.includes("CLI 请求已取消"))
+        return "CLI 模型请求已取消";
+    if (message.includes("插件已停止"))
+        return "插件已停止，当前 CLI 模型任务已终止";
+    if (message.includes("CLI 输出超过"))
+        return "CLI 模型输出超过 4MB 限制";
+    return "CLI 模型调用或结构化输出失败，请检查 CLI 状态";
+}
 async function resolveWindowsCliShim(file, provider) {
     const modules = (0, node_path_1.basename)((0, node_path_1.dirname)(file)) === ".bin" ? (0, node_path_1.dirname)((0, node_path_1.dirname)(file)) : (0, node_path_1.join)((0, node_path_1.dirname)(file), "node_modules");
     const root = (0, node_path_1.join)(modules, ...(provider === "codex" ? ["@openai", "codex"] : ["@anthropic-ai", "claude-code"]));
@@ -76,6 +92,8 @@ class LocalCliAgent {
     ready = false;
     message = "插件尚未启动";
     version = "";
+    modelModeSupported = false;
+    get modelInput() { return this.ready && this.modelModeSupported; }
     sessions = new Map();
     writes = Promise.resolve();
     pending = new Map();
@@ -108,6 +126,9 @@ class LocalCliAgent {
             const help = (await this.run(this.provider === "codex" ? ["exec", "--help"] : ["--help"], "", 10000)).stdout;
             if (this.provider === "codex" ? !help.includes("--json") || !help.includes("resume") : !help.includes("--output-format") || !help.includes("--resume"))
                 throw new Error("CLI 版本不支持所需的结构化输出和会话恢复，请升级 CLI");
+            this.modelModeSupported = this.provider === "claude"
+                ? ["--json-schema", "--tools", "--strict-mcp-config", "--mcp-config", "--no-session-persistence", "--settings", "--setting-sources"].every(flag => help.includes(flag))
+                : ["--output-schema", "--ephemeral", "--sandbox", "--disable", "--config", "--ignore-rules"].every(flag => help.includes(flag));
             this.sessions = new Map();
             try {
                 const data = JSON.parse(await (0, promises_1.readFile)((0, node_path_1.join)(context.dataDir, "cli-sessions.json"), "utf8"));
@@ -128,7 +149,9 @@ class LocalCliAgent {
             throw new Error(this.message);
         }
     }
-    run(args, input, timeout) {
+    run(args, input, timeout, signal) {
+        if (signal?.aborted)
+            return Promise.reject(new Error("CLI 请求已取消"));
         const command = this.command;
         let child;
         let stop;
@@ -153,8 +176,10 @@ class LocalCliAgent {
                 }
             };
             stop = () => terminate("插件已停止，当前 CLI 任务已终止");
+            const abort = () => terminate("CLI 请求已取消");
+            signal?.addEventListener("abort", abort, { once: true });
             const timer = setTimeout(() => terminate(`CLI 调用超时（${timeout}ms），请检查登录、网络或权限审批`), timeout);
-            const cleanup = () => { clearTimeout(timer); this.children.delete(child); };
+            const cleanup = () => { clearTimeout(timer); signal?.removeEventListener("abort", abort); this.children.delete(child); };
             child.stdout.setEncoding("utf8");
             child.stderr.setEncoding("utf8");
             const collect = (value, error) => {
@@ -227,35 +252,70 @@ class LocalCliAgent {
             throw new Error(`${this.manifest.displayName} 本期不支持附件输入`);
         if (!request.task?.trim())
             throw new Error("CLI 任务文本不能为空");
+        return this.executeCli(request, request.modelResponseSchema);
+    }
+    /**
+     * 模型来源的独立入口。调用方只提供最小模型契约，不能通过普通 Agent handle 进入管理路径。
+     */
+    async completeStructuredModel(request, responseSchema) {
+        if (!request.prompt?.trim())
+            throw new Error("模型请求文本不能为空");
+        if (!request.sessionId?.trim())
+            throw new Error("模型请求会话标识不能为空");
+        const response = await this.executeCli({ task: request.prompt, sessionId: request.sessionId, timeoutMs: request.timeoutMs, signal: request.signal }, responseSchema);
+        return { text: response.text };
+    }
+    async executeCli(request, modelSchema) {
+        const modelMode = modelSchema !== undefined;
+        if (modelMode && !this.modelModeSupported)
+            throw new Error("当前 CLI 不支持无工具结构化模型请求，请升级 CLI");
+        const schema = modelMode ? JSON.stringify(modelSchema) : undefined;
+        if (modelMode && (!modelSchema || typeof modelSchema !== "object" || Array.isArray(modelSchema) || !schema || Buffer.byteLength(schema) > 64_000))
+            throw new Error("模型输出 Schema 无效或过大");
         const logical = request.sessionId || (0, node_crypto_1.randomUUID)();
         return this.serial(logical, async () => {
             this.requireReady();
-            const id = request.newSession ? undefined : this.sessions.get(logical);
+            const id = modelMode || request.newSession ? undefined : this.sessions.get(logical);
+            let schemaFile;
+            let schemaDirectory;
             const args = this.provider === "codex"
                 ? ["exec", ...(id ? ["resume", id] : []), "--json", "-"]
                 : ["--print", "--output-format", "json", ...(id ? ["--resume", id] : [])];
+            if (modelMode && this.provider === "claude")
+                args.push("--json-schema", schema, "--tools", "", "--strict-mcp-config", "--mcp-config", '{"mcpServers":{}}', "--settings", '{"disableAllHooks":true}', "--setting-sources", "user", "--no-session-persistence");
             const timeout = request.timeoutMs ?? this.timeoutMs;
             if (!Number.isInteger(timeout) || timeout <= 0 || timeout > 2147483647)
                 throw new Error("任务超时必须是有效的正整数毫秒数");
             const started = Date.now();
             this.context.logger.info("本地 CLI 任务开始", { plugin: this.manifest.id, sessionId: logical, resume: Boolean(id) });
             try {
-                const output = await this.run(args, request.task, timeout);
-                const response = this.parse(output.stdout);
+                if (modelMode && this.provider === "codex") {
+                    schemaDirectory = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "mab-codex-model-"));
+                    schemaFile = (0, node_path_1.join)(schemaDirectory, "response-schema.json");
+                    await (0, promises_1.writeFile)(schemaFile, schema, { flag: "wx", mode: 0o600 });
+                    args.splice(-1, 0, "--ephemeral", "--sandbox", "read-only", "--output-schema", schemaFile, "--disable", "shell_tool", "--disable", "apps", "--disable", "plugins", "--disable", "hooks", "--ignore-rules", "--config", "mcp_servers={}");
+                }
+                const output = await this.run(args, request.task, timeout, request.signal);
+                const response = this.parse(output.stdout, modelMode);
                 if (id && response.id !== id)
                     throw new Error("CLI 恢复返回的会话 ID 与指定会话不一致，保留原会话绑定");
-                await this.save(logical, response.id);
+                if (!modelMode)
+                    await this.save(logical, response.id);
                 this.context.logger.info("本地 CLI 任务完成", { plugin: this.manifest.id, sessionId: logical, durationMs: Date.now() - started, exitCode: 0 });
-                return { text: response.text, sessionId: logical };
+                return { text: response.text, ...(!modelMode ? { sessionId: logical } : {}) };
             }
             catch (error) {
-                const detail = diagnostic(String(error));
+                const detail = modelMode ? modelDiagnostic(error) : diagnostic(String(error));
                 this.context.logger.error("本地 CLI 任务失败", { plugin: this.manifest.id, sessionId: logical, durationMs: Date.now() - started, error: detail });
                 throw new Error(`${this.manifest.displayName}：${detail}`);
             }
+            finally {
+                if (schemaFile && schemaDirectory)
+                    await (0, promises_1.rm)(schemaDirectory, { recursive: true, force: true });
+            }
         });
     }
-    parse(stdout) {
+    parse(stdout, modelMode = false) {
         let id = "", text = "";
         try {
             if (this.provider === "codex") {
@@ -287,6 +347,11 @@ class LocalCliAgent {
                     throw new Error(JSON.stringify(event.errors ?? event));
                 id = event.session_id;
                 text = event.result;
+                if (modelMode) {
+                    if (!event.structured_output || typeof event.structured_output !== "object" || Array.isArray(event.structured_output))
+                        throw new Error("缺少有效结构化模型输出");
+                    text = JSON.stringify(event.structured_output);
+                }
             }
             if (typeof id !== "string" || !nativeId.test(id))
                 throw new Error("缺少有效原生会话 ID");

package/dist/src-ts/plugins/personal-assistant/claude-cli-model.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.responseSchema = void 0;
+exports.claudeCliCompletion = claudeCliCompletion;
+const tools_1 = require("./tools");
+exports.responseSchema = {
+    type: "object", additionalProperties: false, required: ["role", "content", "tool_calls"],
+    properties: {
+        role: { type: "string", enum: ["assistant"] },
+        content: { type: ["string", "null"], maxLength: 32_000 },
+        tool_calls: { type: "array", maxItems: 8, items: {
+                type: "object", additionalProperties: false, required: ["id", "type", "function"],
+                properties: {
+                    id: { type: "string", minLength: 1, maxLength: 128 }, type: { type: "string", enum: ["function"] },
+                    function: { type: "object", additionalProperties: false, required: ["name", "arguments"], properties: {
+                            name: { type: "string", enum: [...tools_1.TOOL_NAMES] }, arguments: { type: "string", maxLength: 64_000 },
+                        } },
+                },
+            } },
+    },
+};
+function claudeCliCompletion(callPlugin, timeoutMs) {
+    return async (messages, signal) => {
+        const response = await callPlugin("claude-cli", {
+            task: JSON.stringify({ instructions: "你是个人助理的模型推理器。按照 messages 中的系统要求处理最后一条用户消息；tools 仅描述宿主提供的管理工具。需要查询或执行任务时返回 tool_calls，待工具结果返回后再回答；不要编造结果。每次调用使用不同 id。最终回答时 tool_calls 为空数组。仅返回 Schema 规定的 JSON。", messages, tools: (0, tools_1.toolDefinitions)() }),
+            modelResponseSchema: exports.responseSchema, timeoutMs, signal,
+        });
+        return response.text;
+    };
+}

package/dist/src-ts/plugins/personal-assistant/coordination.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCoordinator = createCoordinator;
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+const isAid = (value) => typeof value === "string" && /^[A-Za-z0-9][A-Za-z0-9._-]{2,255}$/.test(value);
+const isAgentId = (value) => typeof value === "string" && /^[a-z0-9][a-z0-9-]{0,63}$/.test(value);
+const isThreadId = (value) => typeof value === "string" && /^[A-Za-z0-9][A-Za-z0-9._:-]{0,255}$/.test(value);
+function createCoordinator(options) {
+    if (!isAid(options.selfAid))
+        throw new Error("selfAid 无效");
+    const allowed = new Map();
+    for (const agent of options.allowedAgents) {
+        if (!isAgentId(agent.id) || !Array.isArray(agent.aids) || agent.aids.some((aid) => !isAid(aid)))
+            throw new Error("Agent 白名单无效");
+        allowed.set(agent.id, new Set(agent.aids));
+    }
+    const run = options.execFile ?? (async (file, args) => execFileAsync(file, args, { timeout: 30_000, maxBuffer: 1024 * 1024, encoding: "utf8", windowsHide: true }));
+    const command = async (args) => {
+        const { stdout } = await run(options.ecPath ?? "ec", args);
+        let value;
+        try {
+            value = JSON.parse(stdout);
+        }
+        catch {
+            throw new Error("EvolCore 返回了无效 JSON");
+        }
+        if (!value || typeof value !== "object" || Array.isArray(value) || value.ok === false)
+            throw new Error("EvolCore 命令失败");
+        return value;
+    };
+    return {
+        async dispatch({ agentId, aid, task }) {
+            if (!isAgentId(agentId) || !isAid(aid) || !allowed.get(agentId)?.has(aid))
+                throw new Error("目标 Agent/AID 不在白名单中");
+            if (typeof task !== "string" || !task.trim() || task.length > 20_000)
+                throw new Error("任务长度无效");
+            const thread = await command(["thread", "create", aid, "--name", `个人助理派活-${agentId}`, "--format", "json"]);
+            const threadId = thread.thread_id ?? thread.threadId ?? thread.id;
+            if (!isThreadId(threadId))
+                throw new Error("EvolCore 未返回有效 threadId");
+            await command(["msg", "send", options.selfAid, aid, "--text", task, "--thread", threadId, "--return", "required", "--format", "json"]);
+            return { status: "pending", agentId, aid, threadId };
+        },
+        async getStatus({ aid, threadId }) {
+            if (!isAid(aid))
+                throw new Error("AID 无效");
+            if (!isThreadId(threadId))
+                throw new Error("threadId 无效");
+            const history = await command(["thread", "history", threadId, "--format", "json"]);
+            const state = history.status ?? history.state;
+            const status = state === "completed" || state === "failed" || state === "cancelled" ? state : "pending";
+            return { status, aid, threadId, history };
+        },
+    };
+}

package/dist/src-ts/plugins/personal-assistant/index.js

@@ -0,0 +1,263 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PersonalAssistantPlugin = exports.personalAssistantManifest = void 0;
+const attachments_1 = require("../../attachments");
+const agent_1 = require("../../agent");
+const node_crypto_1 = require("node:crypto");
+const model_client_1 = require("./model-client");
+const tools_1 = require("./tools");
+const remote_ability_1 = require("./remote-ability");
+const owner_context_1 = require("./owner-context");
+const claude_cli_model_1 = require("./claude-cli-model");
+const session_memory_1 = require("./session-memory");
+exports.personalAssistantManifest = {
+    id: "personal-assistant",
+    version: "1.0.7",
+    type: "agent",
+    displayName: "个人助理",
+    entry: "dist/src-ts/plugins/personal-assistant/index.js",
+    apiVersion: "1",
+    process: "in-process",
+    capabilities: ["chat", "management", "health"],
+    configSchema: "config.schema.json",
+};
+class PersonalAssistantPlugin {
+    manifest = exports.personalAssistantManifest;
+    sessionOperations = ["new"];
+    context;
+    client;
+    state = "failed";
+    stateMessage = "插件尚未启动";
+    fetcher;
+    ownerContext;
+    threads = new Map();
+    constructor(options = {}) { this.fetcher = options.fetch; }
+    async activate(context) {
+        this.context = context;
+        const config = context.config;
+        try {
+            const endpoint = validEndpoint(config.endpoint);
+            if (!Array.isArray(config.allowedPeers) || !Array.isArray(config.allowedAgents) || !config.allowedPeers.every(value => value === "*" || isAid(value)) || !config.allowedAgents.every(value => value === "*" || isPluginId(value)))
+                throw new Error("allowedPeers 或 allowedAgents 配置无效");
+            if (config.modelProvider !== undefined && !["openai", "claude-cli", "plugin"].includes(config.modelProvider))
+                throw new Error("不支持该模型来源");
+            const claudeMode = config.modelProvider === "claude-cli";
+            const pluginMode = config.modelProvider === "plugin";
+            const modelPlugin = pluginMode && isPluginId(config.modelPlugin) ? config.modelPlugin : undefined;
+            if (claudeMode && context.modelInputGuard !== true)
+                throw new Error("当前核心不支持安全的 Claude 模型调用，请升级核心");
+            if (pluginMode && !modelPlugin)
+                throw new Error("请选择有效的模型来源插件");
+            if (pluginMode && typeof context.callModelProvider !== "function")
+                throw new Error("当前核心不支持通用模型来源，请升级核心");
+            const modelConfigured = claudeMode || pluginMode || Boolean(config.endpoint || config.model || config.apiKey);
+            if (!claudeMode && !pluginMode && modelConfigured && (!endpoint || !config.model?.trim()))
+                throw new Error("请配置有效的模型 endpoint 和 model");
+            const selfAid = isAid(config.selfAid) ? config.selfAid : undefined;
+            const abilityProviders = Array.isArray(config.abilityProviders) && config.abilityProviders.every(isAid) ? config.abilityProviders : [];
+            const remoteAbility = selfAid && abilityProviders.length ? (0, remote_ability_1.createRemoteAbilityClient)({ selfAid, ecPath: validEcPath(config.ecPath) }) : undefined;
+            this.ownerContext = isAid(config.ownerAid) && typeof config.ownerContextPath === "string"
+                ? (0, owner_context_1.createOwnerContextStore)({ ownerAid: config.ownerAid, path: config.ownerContextPath, ttlMs: validContextTtl(config.ownerContextTtlMs), ecPath: validEcPath(config.ecPath) })
+                : undefined;
+            this.threads.clear();
+            const callModelProvider = context.callModelProvider;
+            const pluginCompletion = pluginMode && modelPlugin && callModelProvider ? async (messages, signal, sessionId) => (await callModelProvider(modelPlugin, {
+                prompt: JSON.stringify({ instructions: "你是个人助理的模型推理器。依据 messages 处理本轮请求。需要查询或执行已列出的管理工具时，只返回 assistant JSON 中的 tool_calls；收到工具结果后再回答。最终回答只写入 content，tool_calls 为空数组。只返回符合 responseSchema 的 JSON 对象，禁止 Markdown 或额外文字。messages 中要求只回复某个词或标记时，只决定 content，不得省略 JSON 包装。", messages, tools: (0, tools_1.toolDefinitions)(), responseSchema: claude_cli_model_1.responseSchema }),
+                sessionId,
+                timeoutMs: validTimeout(config.timeoutMs),
+                signal,
+            })).text : undefined;
+            const sessionMemory = modelConfigured && typeof context.dataDir === "string" && context.dataDir
+                ? new session_memory_1.PersonalAssistantSessionMemory(context.dataDir, context.logger?.warn?.bind(context.logger))
+                : undefined;
+            this.client = modelConfigured ? new model_client_1.PersonalAssistantModelClient({ endpoint, model: config.model?.trim(), apiKey: config.apiKey, cliCompletion: claudeMode ? (0, claude_cli_model_1.claudeCliCompletion)(context.callPlugin, validTimeout(config.timeoutMs)) : undefined, pluginCompletion, timeoutMs: validTimeout(config.timeoutMs), fetch: this.fetcher ?? fetch, allowedAgents: config.allowedAgents, sessionMemory, toolRuntime: { selfAid, ecPath: validEcPath(config.ecPath), allowedProviders: abilityProviders, remoteAbility, ownerContext: this.ownerContext, threads: this.threads } }) : undefined;
+            this.context = { config: context.config, logger: context.logger, callModelProvider };
+            this.state = "ready";
+            this.stateMessage = "";
+        }
+        catch (error) {
+            this.client = undefined;
+            this.state = "degraded";
+            this.stateMessage = error instanceof Error ? error.message : "模型配置无效";
+        }
+    }
+    async deactivate(_reason) {
+        this.client?.close();
+        this.client = undefined;
+        this.ownerContext = undefined;
+        this.threads.clear();
+        this.context = undefined;
+        this.state = "failed";
+        this.stateMessage = "插件已停止";
+    }
+    async health() {
+        return { status: this.state, ...(this.stateMessage ? { message: this.stateMessage } : {}), details: { modelConfigured: Boolean(this.client) } };
+    }
+    async controlSession(request) {
+        if (request.operation !== "new")
+            throw new Error("个人助理只支持新建会话");
+        return { text: "个人助理已创建新会话", sessionId: (0, node_crypto_1.randomUUID)() };
+    }
+    async handle(request) {
+        const management = request.management;
+        if (!management)
+            return { text: "请通过已授权的 AUN 身份访问管理能力。" };
+        const command = (0, tools_1.parseExplicitCommand)(request.task);
+        if (command?.kind === "invalid")
+            return { text: "不支持该管理命令，请检查命令格式后重试。" };
+        if (command?.kind === "sessions") {
+            try {
+                return { text: await management.runSessionCommand(command.command) };
+            }
+            catch {
+                return { text: "会话管理命令执行失败，请检查权限和命令格式。" };
+            }
+        }
+        if (command?.kind === "context-refresh") {
+            if (!this.ownerContext)
+                return { text: "Owner 共享上下文尚未配置。" };
+            try {
+                const refreshed = await this.ownerContext.refresh();
+                return { text: `Owner 共享上下文已刷新（${refreshed.content.length} 字符）。` };
+            }
+            catch {
+                return { text: "Owner 共享上下文刷新失败，已保留之前成功读取的缓存。" };
+            }
+        }
+        if (command?.kind === "agent-call") {
+            try {
+                const result = await management.callAgent(command.agentId, command.task);
+                return { ...result, sessionId: request.sessionId };
+            }
+            catch {
+                return { text: `调用 Agent ${command.agentId} 失败，请检查白名单和目标状态。` };
+            }
+        }
+        if (command?.kind === "create") {
+            try {
+                return { text: safeJson(await management.createAunIdentity({ aid: command.aid, ...(command.ownerAid ? { ownerAid: command.ownerAid } : {}) })) };
+            }
+            catch {
+                return { text: "AUN 身份创建未能确认完成；身份可能已创建，请先查询 AID 列表确认状态，不要重复创建。" };
+            }
+        }
+        if (command?.kind === "bind") {
+            try {
+                return { text: safeJson(await management.bindAunIdentity({ aid: command.aid, agentId: command.agentId, replace: command.replace })) };
+            }
+            catch {
+                return { text: "AUN 身份绑定失败，请检查身份、目标和权限。" };
+            }
+        }
+        if (!this.client || this.state !== "ready")
+            return { text: "个人助理模型尚未配置，暂时无法处理请求。" };
+        const attachments = [];
+        const scopedManagement = { ...management, callAgent: async (id, task) => {
+                const result = await management.callAgent(id, task);
+                const items = result.attachments?.length ? result.attachments : (0, attachments_1.asAttachments)(result.images);
+                (0, attachments_1.validateAttachments)([...attachments, ...items]);
+                attachments.push(...items);
+                return result;
+            } };
+        const requestId = (0, node_crypto_1.randomUUID)();
+        const startedAt = Date.now();
+        const provider = this.context?.config.modelProvider === "plugin"
+            ? String(this.context.config.modelPlugin ?? "未指定插件")
+            : String(this.context?.config.modelProvider ?? "openai");
+        const sessionKey = (0, node_crypto_1.createHash)("sha256").update(`${this.manifest.id}\0${provider}\0${request.sessionId ?? (0, node_crypto_1.randomUUID)()}`).digest("hex");
+        try {
+            let context;
+            try {
+                const ownerContext = await this.ownerContext?.get();
+                if (ownerContext)
+                    context = `读取状态：${ownerContext.status}；缓存年龄：${ownerContext.ageMs} 毫秒。\n${ownerContext.content}`;
+            }
+            catch { /* 共享资料不可用时保留常规助理能力 */ }
+            const modelSessionId = sessionKey;
+            const result = await this.client.complete(request.task, scopedManagement, request.signal, requestTimeout(request.timeoutMs), context, modelSessionId);
+            this.context?.logger?.info("个人助理请求完成", { requestId, provider, durationMs: Date.now() - startedAt });
+            return { text: result, ...(attachments.length ? { attachments } : {}) };
+        }
+        catch (error) {
+            const detail = modelFailure(error, provider);
+            this.context?.logger?.warn("个人助理请求失败", { requestId, provider, session: sessionKey, stage: detail.stage, code: detail.code, durationMs: Date.now() - startedAt, ...(detail.message ? { error: detail.message } : {}) });
+            return { text: detail.text, ...(attachments.length ? { attachments } : {}) };
+        }
+    }
+}
+exports.PersonalAssistantPlugin = PersonalAssistantPlugin;
+function validEndpoint(value) {
+    if (typeof value !== "string" || !value.trim())
+        return undefined;
+    try {
+        const url = new URL(value);
+        if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.hash || url.search || !url.pathname.endsWith("/chat/completions"))
+            return undefined;
+        return url.toString();
+    }
+    catch {
+        return undefined;
+    }
+}
+function isAid(value) { return typeof value === "string" && /^[A-Za-z0-9][A-Za-z0-9._-]{2,255}$/.test(value); }
+function isPluginId(value) { return typeof value === "string" && /^[a-z0-9][a-z0-9-]{0,63}$/.test(value); }
+function validTimeout(value) { return typeof value === "number" && Number.isInteger(value) && value >= 1000 && value <= 120_000 ? value : 120_000; }
+function requestTimeout(value) { return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 120_000; }
+function validEcPath(value) { return typeof value === "string" && value.trim() ? value.trim() : undefined; }
+function validContextTtl(value) { return typeof value === "number" && Number.isSafeInteger(value) && value >= 1_000 && value <= 300_000 ? value : 60_000; }
+function safeJson(value) { try {
+    return JSON.stringify(value);
+}
+catch {
+    return "操作完成。";
+} }
+function modelFailure(error, provider) {
+    const operation = error instanceof agent_1.AgentOperationError ? error : undefined;
+    const stage = operation?.stage ?? "模型调用";
+    const code = operation?.code ?? "PA_REQUEST_FAILED";
+    if (code === "PA_REQUEST_CANCELLED")
+        return { text: `个人助理请求已取消（来源 ${provider}，阶段：${stage}）。`, stage, code };
+    if (code === "PA_REQUEST_TIMEOUT")
+        return { text: `个人助理请求超时（来源 ${provider}，阶段：${stage}）。`, stage, code };
+    const message = safeFailureMessage(operation?.cause ?? error);
+    return { text: `个人助理请求失败（来源 ${provider}，阶段：${stage}，错误码：${errorCode(error) ?? code}）${message ? `：${message}` : "。"}`, stage, code, ...(message ? { message } : {}) };
+}
+function errorCode(error) {
+    let result;
+    for (let current = error, count = 0; current && count++ < 5;) {
+        const code = current.code;
+        if (typeof code === "string" && /^[A-Z][A-Z0-9_]{2,31}$/.test(code))
+            result = code;
+        current = current.cause;
+    }
+    return result;
+}
+function safeFailureMessage(error) {
+    // 只回显宿主定义的诊断，插件任意异常可能含提示正文、凭据或本地路径。
+    const message = error instanceof Error ? error.message : "";
+    if (/^模型(?:服务请求失败：HTTP \d{3}|服务不允许重定向|响应超过大小限制|响应不是有效的工具决策 JSON|响应格式无效|未返回有效回复|返回了空回复|工具调用次数超过限制|返回的工具调用无效)$/.test(message))
+        return message;
+    if (/^(?:插件 [a-z0-9-]+ 未声明模型来源能力|模型来源插件 [a-z0-9-]+ 未安装)$/.test(message))
+        return message;
+    if (/^(?:Claude|Codex) CLI 模型请求(?:必须是包含 responseSchema 的 JSON 对象|缺少有效 responseSchema)$/.test(message))
+        return message;
+    const unavailable = /^模型来源插件“[^”\r\n]{1,64}”未就绪：([\s\S]+)$/.exec(message);
+    const reason = unavailable?.[1] ?? message;
+    if (/^(?:ready|degraded|failed|disabled|installed|discovered|starting|stopping|插件未实现模型来源接口)$/.test(reason))
+        return `模型来源未就绪：${reason}`;
+    const cdp = /(?:无法连接)?(千问办公|WorkBuddy|ChatGPT|豆包) CDP (?:端口 )?(\d{1,5})\b/.exec(reason);
+    if (cdp)
+        return `无法连接${cdp[1]} CDP 端口 ${cdp[2]}`;
+    const desktop = /(?:千问(?:办公)?|WorkBuddy|ChatGPT|豆包) ?(?:发送按钮(?:未就绪|不可用)|输入框(?:未就绪|未找到|含有未发送内容)|当前有未发送内容或正在生成回复，不能(?:新建|切换)会话)/.exec(reason);
+    if (desktop)
+        return desktop[0];
+    if (/^(?:WorkBuddy|ChatGPT|豆包) CDP (?:未连接|已断开)，模型请求不会启动或重启桌面$/.test(reason))
+        return reason;
+    if (reason === "千问办公未连接或不支持隔离模型会话，模型请求不会启动或重启桌面" || reason === "DSH 插件未就绪")
+        return reason;
+    if (reason === "WorkBuddy 当前有用户草稿、待确认操作或正在生成回复，模型请求未切换会话")
+        return reason;
+    const code = errorCode(error);
+    return code ? `底层错误码 ${code}` : undefined;
+}
+exports.default = PersonalAssistantPlugin;