mu-agent-bridge 1.0.71 → 1.0.78

package/plugins/personal-assistant/dist/src-ts/plugins/personal-assistant/remote-ability.js

@@ -0,0 +1,176 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoteAbilityClient = void 0;
+exports.createRemoteAbilityClient = createRemoteAbilityClient;
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const ajv_1 = __importDefault(require("ajv"));
+const node_crypto_1 = require("node:crypto");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+const aidPattern = /^[A-Za-z0-9][A-Za-z0-9._-]{2,255}$/;
+const idPattern = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,255}$/;
+const ajv = new ajv_1.default({ allErrors: true, strict: false });
+class RemoteAbilityClient {
+    cache = new Map();
+    selfAid;
+    ecPath;
+    timeoutMs;
+    constructor(options) {
+        if (!validAid(options.selfAid))
+            throw new Error("selfAid AID 无效");
+        this.selfAid = options.selfAid;
+        this.ecPath = options.ecPath?.trim() || "ec";
+        this.timeoutMs = options.timeoutMs && Number.isInteger(options.timeoutMs) && options.timeoutMs > 0 ? options.timeoutMs : 30_000;
+    }
+    async discover(providerAid) {
+        validProvider(providerAid);
+        const index = await this.readCat(["fs", "cat", `${providerAid}:/ability/index.json`], "能力索引");
+        const entries = Array.isArray(index.abilities) ? index.abilities : Array.isArray(index) ? index : undefined;
+        if (!entries)
+            throw new Error("能力索引缺少 abilities 列表");
+        const valid = [];
+        for (const value of entries) {
+            const entry = validateEntry(value);
+            if (!entry)
+                continue;
+            const detailPath = detailPathFor(providerAid, entry.detail_ref);
+            const detail = await this.readCat(["fs", "cat", `${providerAid}:${detailPath}`], "能力契约");
+            if (!sameContract(entry, detail))
+                continue;
+            this.cache.set(`${providerAid}\n${entry.path}`, { entry, detail: detail });
+            valid.push(entry);
+        }
+        return valid;
+    }
+    async call(providerAid, path, params) {
+        validProvider(providerAid);
+        if (!validPath(path))
+            throw new Error("能力路径无效");
+        let contract = this.cache.get(`${providerAid}\n${path}`);
+        if (!contract) {
+            await this.discover(providerAid);
+            contract = this.cache.get(`${providerAid}\n${path}`);
+        }
+        if (!contract)
+            throw new Error("能力索引或 L3 契约中不存在该精确路径");
+        const { entry, detail } = contract;
+        if (!sameContract(entry, detail))
+            throw new Error("L1 与 L3 能力契约不一致");
+        ensureReadOnly(entry);
+        const validateParams = ajv.compile(entry.params_schema);
+        if (!validateParams(params))
+            throw new Error(`参数不符合 schema：${ajv.errorsText(validateParams.errors)}`);
+        const callId = `c-${(0, node_crypto_1.randomUUID)()}`;
+        const operationId = `op-${(0, node_crypto_1.randomUUID)()}`;
+        const payload = {
+            type: "ability", role: "call", call_id: callId, operation_id: operationId,
+            ability_path: entry.path, definition_id: entry.definition_id, params, ttl: 30, async: false,
+        };
+        const receipt = object(await this.ec(["msg", "send", this.selfAid, providerAid, "--payload", JSON.stringify(payload), "--return", "required", "--timeout", "30s", "--format", "json"]), "发送回执");
+        return this.readReceipt(receipt, entry, callId, operationId);
+    }
+    async getRequest(providerAid, requestId) {
+        validProvider(providerAid);
+        if (!validId(requestId))
+            throw new Error("request_id 无效");
+        const receipt = object(await this.ec(["msg", "request", "get", this.selfAid, requestId, "--format", "json"]), "请求查询回执");
+        const request = object(receipt.request, "请求状态");
+        const status = normalizeState(request.state);
+        if (status !== "completed")
+            return { status, requestId };
+        const response = object(request.responsePayload, "Ability 响应");
+        const expected = this.findCallById(requestId);
+        if (!expected)
+            throw new Error("本地没有该请求对应的 Ability 契约；拒绝解释远端响应");
+        return this.validateResponse(response, expected.entry, requestId, expected.callId, expected.operationId);
+    }
+    async ec(args) {
+        const { stdout } = await execFileAsync(this.ecPath, args, { timeout: this.timeoutMs, maxBuffer: 1024 * 1024, encoding: "utf8", windowsHide: true });
+        try {
+            return JSON.parse(stdout);
+        }
+        catch {
+            throw new Error("ec 返回了无效 JSON");
+        }
+    }
+    async readCat(args, label) {
+        const value = object(await this.ec([...args, "--format", "json"]), label);
+        if (value.command !== "cat")
+            return value;
+        if (value.binary === true || typeof value.text !== "string")
+            throw new Error(`${label}不是 UTF-8 文本`);
+        try {
+            return object(JSON.parse(value.text), label);
+        }
+        catch {
+            throw new Error(`${label}不是有效 JSON`);
+        }
+    }
+    pending = new Map();
+    readReceipt(receipt, entry, callId, operationId) {
+        const requestId = typeof receipt.request_id === "string" ? receipt.request_id : callId;
+        if (receipt.request_state === "completed" && receipt.response && typeof receipt.response === "object") {
+            return this.validateResponse(receipt.response, entry, requestId, callId, operationId);
+        }
+        const status = normalizeState(receipt.request_state ?? receipt.status);
+        if (status === "pending" || status === "sent" || status === "unknown")
+            this.pending.set(requestId, { entry, callId, operationId });
+        return { status, requestId };
+    }
+    validateResponse(response, entry, requestId, callId, operationId) {
+        if (response.type !== "ability" || response.role !== "result" || response.call_id !== callId || response.operation_id !== operationId || response.ability_path !== entry.path || response.definition_id !== entry.definition_id)
+            throw new Error("Ability 响应关联字段不匹配");
+        if (response.ok !== true)
+            return { status: "failed", requestId, response, error: response.error };
+        if (response.execution_state !== "completed")
+            return { status: normalizeState(response.execution_state), requestId, response };
+        const validateResult = ajv.compile(entry.result_schema);
+        if (!validateResult(response.result))
+            throw new Error(`结果不符合 schema：${ajv.errorsText(validateResult.errors)}`);
+        return { status: "completed", requestId, response, result: response.result };
+    }
+    findCallById(requestId) {
+        return this.pending.get(requestId);
+    }
+}
+exports.RemoteAbilityClient = RemoteAbilityClient;
+function createRemoteAbilityClient(options) { return new RemoteAbilityClient(options); }
+function validAid(value) { return typeof value === "string" && aidPattern.test(value); }
+function validProvider(value) { if (!validAid(value))
+    throw new Error("Provider AID 无效"); }
+function validId(value) { return idPattern.test(value); }
+function validPath(value) { return typeof value === "string" && /^[A-Za-z0-9][A-Za-z0-9._/-]{0,255}$/.test(value) && !value.includes("..") && !value.startsWith("/"); }
+function detailPathFor(providerAid, ref) {
+    const prefix = `${providerAid}:/`;
+    const path = ref.startsWith(prefix) ? ref.slice(prefix.length) : ref.replace(/^\/+/, "");
+    if (!validPath(path))
+        throw new Error("detail_ref 路径无效或越界");
+    return `/${path}`;
+}
+function object(value, label) { if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error(`${label}必须是 JSON 对象`); return value; }
+function validateEntry(value) {
+    try {
+        const entry = object(value, "能力条目");
+        if (!validPath(entry.path) || !validId(String(entry.definition_id ?? "")) || typeof entry.detail_ref !== "string" || !entry.params_schema || typeof entry.params_schema !== "object" || !entry.result_schema || typeof entry.result_schema !== "object")
+            return undefined;
+        ajv.compile(entry.params_schema);
+        ajv.compile(entry.result_schema);
+        return entry;
+    }
+    catch {
+        return undefined;
+    }
+}
+function sameContract(entry, detail) {
+    return detail.path === entry.path && detail.definition_id === entry.definition_id && JSON.stringify(detail.params_schema) === JSON.stringify(entry.params_schema) && JSON.stringify(detail.result_schema) === JSON.stringify(entry.result_schema) && JSON.stringify(detail.effects) === JSON.stringify(entry.effects) && detail.auth_required === entry.auth_required && detail.require_confirm === entry.require_confirm;
+}
+function ensureReadOnly(entry) {
+    const effects = entry.effects;
+    if (!(effects === "read" || Array.isArray(effects) && effects.length > 0 && effects.every((effect) => effect === "read")) || entry.auth_required !== false || entry.require_confirm !== false)
+        throw new Error("能力契约不是无需认证和确认的纯只读调用");
+}
+function normalizeState(value) { return value === "completed" ? "completed" : value === "pending" ? "pending" : value === "sent" ? "sent" : value === "failed" ? "failed" : "unknown"; }

package/plugins/personal-assistant/dist/src-ts/plugins/personal-assistant/session-memory.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PersonalAssistantSessionMemory = void 0;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const node_crypto_1 = require("node:crypto");
+const MAX_SESSIONS = 128;
+const MAX_MESSAGES = 40;
+const MAX_CHARS = 120_000;
+class PersonalAssistantSessionMemory {
+    dataDir;
+    warn;
+    sessions = new Map();
+    loaded;
+    writes = Promise.resolve();
+    file;
+    constructor(dataDir, warn) {
+        this.dataDir = dataDir;
+        this.warn = warn;
+        this.file = (0, node_path_1.join)(dataDir, "model-sessions.json");
+    }
+    async load(sessionId) {
+        await this.ensureLoaded();
+        await this.writes;
+        return structuredClone(this.sessions.get(sessionId) ?? []);
+    }
+    async save(sessionId, messages) {
+        await this.ensureLoaded();
+        const task = this.writes.then(async () => {
+            const trimmed = trimMessages(messages);
+            this.sessions.delete(sessionId);
+            this.sessions.set(sessionId, trimmed);
+            while (this.sessions.size > MAX_SESSIONS)
+                this.sessions.delete(this.sessions.keys().next().value);
+            const temporary = `${this.file}.${process.pid}.${(0, node_crypto_1.randomUUID)()}.tmp`;
+            try {
+                await (0, promises_1.mkdir)(this.dataDir, { recursive: true, mode: 0o700 });
+                await (0, promises_1.writeFile)(temporary, `${JSON.stringify(Object.fromEntries(this.sessions))}\n`, { mode: 0o600, flag: "wx" });
+                await (0, promises_1.rename)(temporary, this.file);
+                await (0, promises_1.chmod)(this.file, 0o600);
+            }
+            catch {
+                this.warn?.("个人助理会话历史保存失败，本次回复仍有效；重载前可继续使用内存历史");
+            }
+            finally {
+                await (0, promises_1.rm)(temporary, { force: true }).catch(() => { });
+            }
+        });
+        this.writes = task.catch(() => { this.warn?.("个人助理会话历史格式无效，本轮未保存"); });
+        await this.writes;
+    }
+    ensureLoaded() {
+        this.loaded ??= (async () => {
+            try {
+                if ((await (0, promises_1.stat)(this.file)).size > MAX_SESSIONS * MAX_CHARS * 4)
+                    throw new Error("历史文件超过限制");
+                const raw = JSON.parse(await (0, promises_1.readFile)(this.file, "utf8"));
+                if (!raw || typeof raw !== "object" || Array.isArray(raw))
+                    throw new Error("历史文件格式无效");
+                for (const [id, value] of Object.entries(raw).slice(-MAX_SESSIONS)) {
+                    if (!id || id.length > 128 || !Array.isArray(value))
+                        continue;
+                    try {
+                        this.sessions.set(id, trimMessages(value));
+                    }
+                    catch {
+                        this.warn?.("个人助理丢弃了一条格式无效的会话历史");
+                    }
+                }
+            }
+            catch (error) {
+                if (error.code !== "ENOENT")
+                    this.warn?.("个人助理会话历史读取失败，已使用空历史");
+            }
+        })();
+        return this.loaded;
+    }
+}
+exports.PersonalAssistantSessionMemory = PersonalAssistantSessionMemory;
+function trimMessages(messages) {
+    const result = [];
+    const pending = new Set();
+    let next = "user";
+    for (const value of messages) {
+        if (!value || typeof value !== "object")
+            throw new Error("会话消息无效");
+        const m = value;
+        if (m.role !== next || (m.content !== undefined && m.content !== null && typeof m.content !== "string"))
+            throw new Error("会话消息顺序无效");
+        if (m.role === "assistant" && m.tool_calls?.length) {
+            if (!Array.isArray(m.tool_calls) || m.tool_calls.length > 8)
+                throw new Error("工具调用无效");
+            const calls = m.tool_calls.map(call => {
+                if (typeof call?.id !== "string" || !call.id || pending.has(call.id) || call.type !== "function" || typeof call.function?.name !== "string" || typeof call.function.arguments !== "string")
+                    throw new Error("工具调用无效");
+                pending.add(call.id);
+                return { id: call.id, type: "function", function: { name: call.function.name, arguments: call.function.arguments } };
+            });
+            result.push({ role: "assistant", content: m.content ?? null, tool_calls: calls });
+            next = "tool";
+        }
+        else if (m.role === "tool") {
+            if (typeof m.content !== "string" || !m.tool_call_id || !pending.delete(m.tool_call_id))
+                throw new Error("工具结果无效");
+            result.push({ role: "tool", content: m.content, tool_call_id: m.tool_call_id, ...(typeof m.name === "string" ? { name: m.name } : {}) });
+            if (!pending.size)
+                next = "assistant";
+        }
+        else {
+            if (typeof m.content !== "string")
+                throw new Error("会话正文无效");
+            result.push({ role: m.role, content: m.content });
+            next = m.role === "user" ? "assistant" : "user";
+        }
+    }
+    if (next !== "user")
+        throw new Error("会话轮次未完成");
+    // 以整轮用户消息裁剪，避免留下缺少工具调用的孤立 tool 消息。
+    while (result.length > MAX_MESSAGES || JSON.stringify(result).length > MAX_CHARS) {
+        const end = result.findIndex((message, index) => index > 0 && message.role === "user");
+        result.splice(0, end < 0 ? result.length : end);
+    }
+    return result;
+}

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

@@ -0,0 +1,167 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_NAMES = void 0;
+exports.toolDefinitions = toolDefinitions;
+exports.parseToolArguments = parseToolArguments;
+exports.executeTool = executeTool;
+exports.parseExplicitCommand = parseExplicitCommand;
+exports.stringifyToolResult = stringifyToolResult;
+const ajv_1 = __importDefault(require("ajv"));
+const coordination_1 = require("./coordination");
+exports.TOOL_NAMES = ["agents_list", "agents_call", "aun_identity_list", "sessions_command", "sessions_today", "self_status", "ability_discover", "ability_call", "ability_request_get", "coordination_dispatch", "coordination_status", "owner_context_read"];
+const ajv = new ajv_1.default({ allErrors: false, strict: false });
+const schemas = {
+    agents_list: ajv.compile({ type: "object", additionalProperties: false, properties: {} }),
+    agents_call: ajv.compile({ type: "object", additionalProperties: false, required: ["id", "task"], properties: { id: { type: "string", minLength: 1, maxLength: 128 }, task: { type: "string", minLength: 1, maxLength: 20_000 } } }),
+    aun_identity_list: ajv.compile({ type: "object", additionalProperties: false, properties: {} }),
+    sessions_command: ajv.compile({ type: "object", additionalProperties: false, required: ["command"], properties: { command: { type: "string", minLength: 1, maxLength: 512 } } }),
+    sessions_today: ajv.compile({ type: "object", additionalProperties: false, properties: {} }),
+    self_status: ajv.compile({ type: "object", additionalProperties: false, properties: {} }),
+    ability_discover: ajv.compile({ type: "object", additionalProperties: false, required: ["providerAid"], properties: { providerAid: { type: "string", minLength: 3, maxLength: 256 } } }),
+    ability_call: ajv.compile({ type: "object", additionalProperties: false, required: ["providerAid", "path", "params"], properties: { providerAid: { type: "string", minLength: 3, maxLength: 256 }, path: { type: "string", minLength: 1, maxLength: 256 }, params: { type: "object" } } }),
+    ability_request_get: ajv.compile({ type: "object", additionalProperties: false, required: ["providerAid", "requestId"], properties: { providerAid: { type: "string", minLength: 3, maxLength: 256 }, requestId: { type: "string", minLength: 1, maxLength: 256 } } }),
+    coordination_dispatch: ajv.compile({ type: "object", additionalProperties: false, required: ["agentId", "aid", "task"], properties: { agentId: { type: "string", minLength: 1, maxLength: 64 }, aid: { type: "string", minLength: 3, maxLength: 256 }, task: { type: "string", minLength: 1, maxLength: 20000 } } }),
+    coordination_status: ajv.compile({ type: "object", additionalProperties: false, required: ["aid", "threadId"], properties: { aid: { type: "string", minLength: 3, maxLength: 256 }, threadId: { type: "string", minLength: 1, maxLength: 256 } } }),
+    owner_context_read: ajv.compile({ type: "object", additionalProperties: false, properties: {} }),
+};
+const toolDescriptions = {
+    agents_list: { name: "agents_list", description: "列出当前可调用的 Agent 及其 AID。", parameters: { type: "object", additionalProperties: false, properties: {} } },
+    agents_call: { name: "agents_call", description: "向白名单中的 Agent 发送一项独立任务。", parameters: { type: "object", additionalProperties: false, required: ["id", "task"], properties: { id: { type: "string", minLength: 1, maxLength: 128 }, task: { type: "string", minLength: 1, maxLength: 20_000 } } } },
+    aun_identity_list: { name: "aun_identity_list", description: "列出本机已知 AUN 身份及绑定状态。", parameters: { type: "object", additionalProperties: false, properties: {} } },
+    sessions_command: { name: "sessions_command", description: "执行只读的 /sessions 管理命令。", parameters: { type: "object", additionalProperties: false, required: ["command"], properties: { command: { type: "string", minLength: 1, maxLength: 512 } } } },
+    sessions_today: { name: "sessions_today", description: "生成今天工作的小结。", parameters: { type: "object", additionalProperties: false, properties: {} } },
+    self_status: { name: "self_status", description: "报告个人助理自身状态。", parameters: { type: "object", additionalProperties: false, properties: {} } },
+    ability_discover: { name: "ability_discover", description: "发现已配置 Provider 的只读 AUN Ability。", parameters: { type: "object", additionalProperties: false, required: ["providerAid"], properties: { providerAid: { type: "string", minLength: 3, maxLength: 256 } } } },
+    ability_call: { name: "ability_call", description: "调用无需认证和确认的纯只读 AUN Ability。", parameters: { type: "object", additionalProperties: false, required: ["providerAid", "path", "params"], properties: { providerAid: { type: "string", minLength: 3, maxLength: 256 }, path: { type: "string", minLength: 1, maxLength: 256 }, params: { type: "object" } } } },
+    ability_request_get: { name: "ability_request_get", description: "查询已发送 AUN Ability 的请求状态，不重新发送。", parameters: { type: "object", additionalProperties: false, required: ["providerAid", "requestId"], properties: { providerAid: { type: "string", minLength: 3, maxLength: 256 }, requestId: { type: "string", minLength: 1, maxLength: 256 } } } },
+    coordination_dispatch: { name: "coordination_dispatch", description: "显式向白名单 Agent 派发任务并创建独立 thread。", parameters: { type: "object", additionalProperties: false, required: ["agentId", "aid", "task"], properties: { agentId: { type: "string", minLength: 1, maxLength: 64 }, aid: { type: "string", minLength: 3, maxLength: 256 }, task: { type: "string", minLength: 1, maxLength: 20000 } } } },
+    coordination_status: { name: "coordination_status", description: "读取派发任务对应 thread 的当前状态和历史。", parameters: { type: "object", additionalProperties: false, required: ["aid", "threadId"], properties: { aid: { type: "string", minLength: 3, maxLength: 256 }, threadId: { type: "string", minLength: 1, maxLength: 256 } } } },
+    owner_context_read: { name: "owner_context_read", description: "读取管理员配置的 Owner 共享资料，仅作为参考。", parameters: { type: "object", additionalProperties: false, properties: {} } },
+};
+function toolDefinitions() {
+    return exports.TOOL_NAMES.map((name) => ({ type: "function", function: { ...toolDescriptions[name], parameters: { ...toolDescriptions[name].parameters } } }));
+}
+function parseToolArguments(name, raw) {
+    if (!exports.TOOL_NAMES.includes(name))
+        throw new Error("未知的管理工具");
+    let value;
+    try {
+        value = JSON.parse(raw);
+    }
+    catch {
+        throw new Error("管理工具参数不是有效 JSON");
+    }
+    const validate = schemas[name];
+    if (!validate(value))
+        throw new Error("管理工具参数不符合要求");
+    return value;
+}
+async function executeTool(name, args, management, allowedAgents, runtime = {}) {
+    if (!exports.TOOL_NAMES.includes(name))
+        throw new Error("未知的管理工具");
+    if (!schemas[name](args))
+        throw new Error("管理工具参数不符合要求");
+    switch (name) {
+        case "agents_list": {
+            const agents = await management.listAgents();
+            return allowedAgents?.length && !allowedAgents.includes("*") ? agents.map((agent) => allowedAgents.includes(agent.id) ? agent : { ...agent, callable: false, reason: "未加入个人助理 Agent 白名单" }) : agents;
+        }
+        case "agents_call": {
+            if (allowedAgents?.length && !allowedAgents.includes("*") && !allowedAgents.includes(String(args.id)))
+                throw new Error("目标 Agent 未加入个人助理白名单");
+            const result = await management.callAgent(String(args.id), String(args.task));
+            return {
+                text: result.text,
+                ...((result.attachments?.length || result.images?.length) ? { attachments: (result.attachments?.length ? result.attachments : result.images).map(({ filename, contentType }) => ({ filename, contentType })), attachmentDelivery: "附件将随最终回复自动回传，由通道确认发送结果，无需模型另行读取或发送。" } : {}),
+                ...(result.sessionId ? { sessionId: result.sessionId } : {}),
+            };
+        }
+        case "aun_identity_list": return management.listAunIdentities();
+        case "sessions_command": {
+            const command = String(args.command).trim();
+            if (!/^\/sessions(?:\s|$)/.test(command) || /[\r\n]/.test(command))
+                throw new Error("只支持单行 /sessions 只读命令");
+            return management.runSessionCommand(command);
+        }
+        case "sessions_today": return management.summarizeToday();
+        case "self_status": return { status: "ready", capabilities: exports.TOOL_NAMES };
+        case "ability_discover": {
+            const providerAid = String(args.providerAid);
+            if (!runtime.allowedProviders?.includes(providerAid) || !runtime.remoteAbility)
+                throw new Error("Provider 未加入远程 Ability 白名单");
+            return runtime.remoteAbility.discover(providerAid);
+        }
+        case "ability_call": {
+            const providerAid = String(args.providerAid);
+            if (!runtime.allowedProviders?.includes(providerAid) || !runtime.remoteAbility)
+                throw new Error("Provider 未加入远程 Ability 白名单");
+            return runtime.remoteAbility.call(providerAid, String(args.path), args.params);
+        }
+        case "ability_request_get": {
+            const providerAid = String(args.providerAid);
+            if (!runtime.allowedProviders?.includes(providerAid) || !runtime.remoteAbility)
+                throw new Error("Provider 未加入远程 Ability 白名单");
+            return runtime.remoteAbility.getRequest(providerAid, String(args.requestId));
+        }
+        case "coordination_dispatch": {
+            if (!allowedAgents || (allowedAgents.length > 0 && !allowedAgents.includes("*") && !allowedAgents.includes(String(args.agentId))) || !runtime.selfAid)
+                throw new Error("目标 Agent 未加入个人助理白名单");
+            const abilities = await management.listAgents();
+            const agent = abilities.find((item) => item.id === args.agentId && item.callable && item.aids.includes(String(args.aid)));
+            if (!agent)
+                throw new Error("目标 Agent/AID 当前不可派活");
+            const coordinator = (0, coordination_1.createCoordinator)({ selfAid: runtime.selfAid, ecPath: runtime.ecPath, allowedAgents: [{ id: agent.id, aids: agent.aids }] });
+            const result = await coordinator.dispatch({ agentId: agent.id, aid: String(args.aid), task: String(args.task) });
+            if (runtime.threads && runtime.threads.size >= 128)
+                runtime.threads.delete(runtime.threads.keys().next().value);
+            runtime.threads?.set(result.threadId, result.aid);
+            return result;
+        }
+        case "coordination_status": {
+            if (!runtime.selfAid)
+                throw new Error("个人助理 AID 未配置");
+            if (runtime.threads?.get(String(args.threadId)) !== String(args.aid))
+                throw new Error("thread 不属于本个人助理已派发的任务");
+            const coordinator = (0, coordination_1.createCoordinator)({ selfAid: runtime.selfAid, ecPath: runtime.ecPath, allowedAgents: [] });
+            return coordinator.getStatus({ aid: String(args.aid), threadId: String(args.threadId) });
+        }
+        case "owner_context_read": {
+            if (!runtime.ownerContext)
+                throw new Error("Owner 共享上下文尚未配置");
+            return runtime.ownerContext.get();
+        }
+    }
+}
+function parseExplicitCommand(task) {
+    if (!task.startsWith("/assistant ") && !task.startsWith("/sessions"))
+        return undefined;
+    if (/[\r\n]/.test(task))
+        return { kind: "invalid" };
+    if (task.startsWith("/sessions"))
+        return /^\/sessions(?:\s|$)/.test(task) ? { kind: "sessions", command: task } : { kind: "invalid" };
+    if (task === "/assistant context refresh")
+        return { kind: "context-refresh" };
+    const agentCall = task.match(/^\/assistant agent call ([a-z0-9][a-z0-9-]{0,63}) ([\s\S]{1,20000})$/);
+    if (agentCall)
+        return { kind: "agent-call", agentId: agentCall[1], task: agentCall[2] };
+    const create = task.match(/^\/assistant aid create ([A-Za-z0-9][A-Za-z0-9._-]{2,255})(?: --owner ([A-Za-z0-9][A-Za-z0-9._-]{2,255}))?$/);
+    if (create)
+        return { kind: "create", aid: create[1], ...(create[2] ? { ownerAid: create[2] } : {}) };
+    const bind = task.match(/^\/assistant aid bind ([A-Za-z0-9][A-Za-z0-9._-]{2,255}) ([A-Za-z0-9][A-Za-z0-9._-]{0,127})( --replace)?$/);
+    if (bind)
+        return { kind: "bind", aid: bind[1], agentId: bind[2], replace: Boolean(bind[3]) };
+    return { kind: "invalid" };
+}
+function stringifyToolResult(value) {
+    let text;
+    try {
+        text = typeof value === "string" ? value : JSON.stringify(value);
+    }
+    catch {
+        text = "工具返回结果不可序列化";
+    }
+    return text.length > 64_000 ? `${text.slice(0, 64_000)}\n[结果已截断]` : text;
+}

package/plugins/personal-assistant/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "agent-bridge-pa",
+  "version": "1.0.7",
+  "description": "mu-agent-bridge 的个人助理管理 Agent 插件。",
+  "keywords": [
+    "mu-agent-bridge-plugin",
+    "mu-agent-bridge-agent"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://codeup.aliyun.com/6808da56fb3da14b899afd54/agent_bridge.git",
+    "directory": "packages/personal-assistant"
+  },
+  "main": "dist/src-ts/plugins/personal-assistant/index.js",
+  "files": [
+    "dist/",
+    "plugin.json",
+    "config.schema.json",
+    "README.md"
+  ],
+  "agentBridge": {
+    "id": "personal-assistant",
+    "plugin": "./plugin.json",
+    "type": "agent",
+    "requires": {
+      "mu-agent-bridge": ">=1.0.78"
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "engines": {
+    "node": ">=22.16.0"
+  },
+  "dependencies": {
+    "ajv": "^8.20.0"
+  }
+}

package/plugins/personal-assistant/plugin.json

@@ -0,0 +1,15 @@
+{
+  "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"
+}

package/plugins/qwenwork/dist/src-ts/agent.js

@@ -1,7 +1,42 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgentOperationError = exports.AgentError = void 0;
+exports.abortable = abortable;
 exports.errorDetails = errorDetails;
+async function abortable(promise, signal) {
+    if (!signal)
+        return promise;
+    if (signal.aborted) {
+        // promise 已在调用方启动，先观察其拒绝，避免预取消时产生未处理拒绝。
+        void promise.catch(() => undefined);
+        signal.throwIfAborted();
+    }
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const cleanup = () => signal.removeEventListener("abort", abort);
+        const abort = () => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            reject(signal.reason);
+        };
+        signal.addEventListener("abort", abort, { once: true });
+        promise.then((value) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            resolve(value);
+        }, (error) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            reject(error);
+        });
+    });
+}
 class AgentError extends Error {
     constructor(message, options) {
         super(message, options);

package/plugins/qwenwork/dist/src-ts/plugins/cdp-draft.js

@@ -5,7 +5,7 @@ const promises_1 = require("node:fs/promises");
 const node_os_1 = require("node:os");
 const node_path_1 = require("node:path");
 /** 空闲时先备份旧草稿，再通过编辑器原生删除事件清理，避免只修改 DOM。 */
-async function recoverCdpDraft(evaluate, editorSelector, stopSelector, dataDir = (0, node_path_1.join)((0, node_os_1.tmpdir)(), "agent-bridge-draft-recovery")) {
+async function recoverCdpDraft(evaluate, editorSelector, stopSelector, dataDir = (0, node_path_1.join)((0, node_os_1.tmpdir)(), "agent-bridge-draft-recovery"), expected) {
     const state = await evaluate(`(() => ({
     text: document.querySelector(${JSON.stringify(editorSelector)})?.innerText ?? null,
     generating: Boolean(document.querySelector(${JSON.stringify(stopSelector)})),
@@ -15,13 +15,16 @@ async function recoverCdpDraft(evaluate, editorSelector, stopSelector, dataDir =
         throw new Error("桌面端正在生成回复，不能清理输入或切换会话");
     if (state.text === null)
         throw new Error("桌面端输入框未就绪");
+    if (expected && (state.text !== expected.text || state.url !== expected.url))
+        return;
     if (!state.text?.trim())
         return;
     await (0, promises_1.mkdir)(dataDir, { recursive: true, mode: 0o700 });
     await (0, promises_1.appendFile)((0, node_path_1.join)(dataDir, "draft-recovery.jsonl"), JSON.stringify({ time: new Date().toISOString(), url: state.url, text: state.text }) + "\n", { encoding: "utf8", mode: 0o600 });
     const cleared = await evaluate(`(() => {
     const editor = document.querySelector(${JSON.stringify(editorSelector)});
-    const unchanged = () => editor && editor.innerText === ${JSON.stringify(state.text)}
+    const unchanged = () => editor && document.querySelector(${JSON.stringify(editorSelector)}) === editor
+      && editor.innerText === ${JSON.stringify(state.text)} && (document.URL ?? '') === ${JSON.stringify(state.url)}
       && !document.querySelector(${JSON.stringify(stopSelector)});
     if (!unchanged()) return false;
     editor.focus();