mu-agent-bridge 1.0.71 → 1.0.78

package/dist/src-ts/plugin-manager.js

@@ -25,6 +25,7 @@ const desktop_launch_1 = require("./plugins/desktop-launch");
 const workbuddy_1 = require("./plugins/workbuddy");
 const logger = { info() { }, warn() { }, error() { } };
 const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+const PLUGIN_UPGRADE_WAIT_MS = 2 * 60 * 60 * 1000;
 class PluginManager {
     options;
     controlUrl;
@@ -34,6 +35,7 @@ class PluginManager {
     root;
     messages = [];
     activeIngress = new Map();
+    issuedManagement = new WeakMap();
     trustConfig = defaultPluginTrustConfig();
     trustLoaded = false;
     publisherLookups = new Map();
@@ -110,7 +112,7 @@ class PluginManager {
             if (meta.name !== packageName || !meta.version || (version && meta.version !== version) || !meta.agentBridge?.plugin)
                 throw new agent_1.AgentError("npm 包声明无效");
             const manifest = (0, plugin_manifest_1.validateManifest)(JSON.parse(await (0, promises_1.readFile)((0, node_path_1.resolve)(candidate, meta.agentBridge.plugin), "utf8")), candidate);
-            if (manifest.id !== packageName.slice("agent-bridge-".length) || manifest.version !== meta.version)
+            if ((0, plugin_catalog_1.resolvePluginId)(packageName, meta.agentBridge.id) !== manifest.id || manifest.version !== meta.version)
                 throw new agent_1.AgentError("npm 包与插件清单不匹配");
             this.validateCandidate(manifest, meta.agentBridge);
             this.log("info", `插件下载完成：${manifest.id}`, { packageName, version: meta.version }, "插件升级");
@@ -168,7 +170,8 @@ class PluginManager {
                 return info.packageName ? this.versions.checkPackage(info.packageName, record.version) : Promise.resolve({ packageName: record.id, currentVersion: record.version, state: "latest", checkedAt: new Date().toISOString() });
             })]);
     }
-    async upgradePackage(id, packageName = `agent-bridge-${id}`, version) {
+    async upgradePackage(id, packageName, version) {
+        packageName ??= this.plugins.get(id)?.record.packageName ?? `agent-bridge-${id}`;
         const pending = this.upgrades.get(id);
         if (pending) {
             if (pending.packageName === packageName && pending.version === version)
@@ -215,11 +218,25 @@ class PluginManager {
             if (!meta.agentBridge?.plugin)
                 throw new agent_1.AgentError("npm 包未声明 agentBridge.plugin");
             const manifest = (0, plugin_manifest_1.validateManifest)(JSON.parse(await (0, promises_1.readFile)((0, node_path_1.resolve)(candidate, meta.agentBridge.plugin), "utf8")), candidate);
-            if (manifest.id !== id || manifest.version !== meta.version)
+            if (manifest.id !== id || (0, plugin_catalog_1.resolvePluginId)(packageName, meta.agentBridge.id) !== id || manifest.version !== meta.version)
                 throw new agent_1.AgentError("npm 包插件 ID 或版本不匹配");
             this.validateCandidate(manifest, meta.agentBridge);
-            await this.stop(id, "reload");
-            stopped = true;
+            const deadline = new AbortController();
+            const cancellation = loaded.cancellation;
+            const error = new agent_1.AgentOperationError("PLUGIN_UPGRADE_WAIT_TIMEOUT", "等待旧插件任务结束", new Error("升级已等待两小时，强制结束桥接任务并继续升级"));
+            this.log("info", `插件升级等待旧任务结束：${id}`, { waitMs: PLUGIN_UPGRADE_WAIT_MS, deadline: new Date(Date.now() + PLUGIN_UPGRADE_WAIT_MS).toISOString() }, "插件升级");
+            const timer = setTimeout(() => {
+                this.log("warn", `插件升级等待超时，强制结束桥接任务：${id}`, { code: error.code, waitMs: PLUGIN_UPGRADE_WAIT_MS }, "插件升级");
+                cancellation?.abort(error);
+                deadline.abort(error);
+            }, PLUGIN_UPGRADE_WAIT_MS);
+            try {
+                await this.stop(id, "reload", deadline.signal);
+            }
+            finally {
+                clearTimeout(timer);
+                stopped = !loaded.instance;
+            }
             if (hadPrefix)
                 await (0, promises_1.rename)(prefix, backup);
             await (0, promises_1.rename)(staging, prefix);
@@ -255,6 +272,39 @@ class PluginManager {
         }
     }
     get(id) { return this.plugins.get(id); }
+    listModelProviders() {
+        return [...this.plugins.values()].filter(({ record }) => record.capabilities.includes("model-provider")).map(({ record, instance }) => {
+            const available = record.status === "ready" && typeof instance?.modelProvider?.complete === "function";
+            return { id: record.id, displayName: record.displayName, status: record.status, available, reason: available ? "" : record.error ?? (record.status === "ready" ? "插件未实现模型来源接口" : `插件当前状态：${record.status}`) };
+        });
+    }
+    async completeModelProvider(id, request) {
+        const loaded = this.plugins.get(id);
+        if (!loaded)
+            throw new agent_1.AgentError(`模型来源插件 ${id} 未安装`);
+        if (!loaded.record.capabilities.includes("model-provider"))
+            throw new agent_1.AgentError(`插件 ${id} 未声明模型来源能力`);
+        if (!loaded.instance || loaded.record.status !== "ready" || typeof loaded.instance.modelProvider?.complete !== "function")
+            throw new agent_1.AgentError(`模型来源插件“${loaded.record.displayName}”未就绪：${loaded.record.error ?? (loaded.record.status === "ready" ? "插件未实现模型来源接口" : loaded.record.status)}`);
+        if (!request || typeof request.prompt !== "string" || !request.prompt.trim() || Buffer.byteLength(request.prompt) > 1024 * 1024)
+            throw new agent_1.AgentError("模型来源请求内容为空或超过 1 MiB");
+        if (typeof request.sessionId !== "string" || !request.sessionId.trim() || request.sessionId.length > 512)
+            throw new agent_1.AgentError("模型来源会话标识无效");
+        if (!Number.isInteger(request.timeoutMs) || request.timeoutMs < 1000 || request.timeoutMs > 120_000)
+            throw new agent_1.AgentError("模型来源超时时间无效");
+        if (!(request.signal instanceof AbortSignal))
+            throw new agent_1.AgentError("模型来源请求缺少取消信号");
+        // 模型来源只接收最小调用契约，避免把未来扩展字段误传给桌面或 CLI 插件。
+        const result = await this.runPluginTask(loaded, request.signal, signal => loaded.instance.modelProvider.complete({
+            prompt: request.prompt,
+            sessionId: request.sessionId,
+            timeoutMs: request.timeoutMs,
+            signal,
+        }));
+        if (!result || typeof result.text !== "string" || !result.text.trim() || Buffer.byteLength(result.text) > 1024 * 1024)
+            throw new agent_1.AgentError(`模型来源插件“${loaded.record.displayName}”返回空内容或超大响应`);
+        return { text: result.text };
+    }
     recentMessages(id) { return this.messages.filter((item) => !id || item.pluginId === id).slice(-200).reverse(); }
     recordMessage(pluginId, direction, text, peer, agentAid) {
         if (direction === "error" && isNoisyAgentError(text))
@@ -267,8 +317,9 @@ class PluginManager {
         if (!/^agent-bridge-[a-z0-9-]+(?:@[0-9][a-zA-Z0-9.+-]*)?$/.test(packageName))
             throw new agent_1.AgentError("仅支持 agent-bridge-* npm 包名");
         const name = packageName.replace(/@.*$/, "");
-        if (this.plugins.has(name.replace(/^agent-bridge-/, "")))
-            throw new agent_1.AgentError("插件已经存在");
+        const version = packageName.slice(name.length + 1);
+        if (this.list().some((record) => record.packageName === name))
+            throw new agent_1.AgentError("插件已经存在，请使用升级操作");
         const prefix = (0, node_path_1.join)(this.options.stateDir, "npm", name);
         if (await this.existsDir(prefix))
             throw new agent_1.AgentError("插件包已经安装");
@@ -283,12 +334,16 @@ class PluginManager {
             const meta = JSON.parse(await (0, promises_1.readFile)((0, node_path_1.join)(directory, "package.json"), "utf8"));
             if (meta.name !== name || !meta.version || !meta.agentBridge?.plugin)
                 throw new agent_1.AgentError("npm 包名称或插件声明无效");
+            if (version && meta.version !== version)
+                throw new agent_1.AgentError("npm 包版本与请求不匹配");
             const manifestFile = (0, node_path_1.resolve)(directory, meta.agentBridge.plugin);
             if (!manifestFile.startsWith(`${(0, node_path_1.resolve)(directory)}${node_path_1.sep}`))
                 throw new agent_1.AgentError("插件清单路径越界");
             const manifest = (0, plugin_manifest_1.validateManifest)(JSON.parse(await (0, promises_1.readFile)(manifestFile, "utf8")), directory);
-            if (manifest.id !== name.slice("agent-bridge-".length) || manifest.version !== meta.version || (meta.agentBridge.type && meta.agentBridge.type !== manifest.type))
+            if ((0, plugin_catalog_1.resolvePluginId)(name, meta.agentBridge.id) !== manifest.id || manifest.version !== meta.version || (meta.agentBridge.type && meta.agentBridge.type !== manifest.type))
                 throw new agent_1.AgentError("npm 包与插件清单不匹配");
+            if (this.plugins.has(manifest.id))
+                throw new agent_1.AgentError("插件已经存在；不同 npm 来源不能覆盖，请先显式处理现有插件");
             this.validateCandidate(manifest, meta.agentBridge);
             await this.discoverDirectory(directory, name, manifestFile);
             await this.resolvePendingPublisherLookups();
@@ -326,7 +381,7 @@ class PluginManager {
         }
         if (loaded.instance) {
             try {
-                await loaded.instance.deactivate("reload");
+                await loaded.instance.deactivate("reload", this.upgrades.has(id) ? { preserveDesktop: true } : undefined);
             }
             catch (error) {
                 this.log("warn", `插件恢复前清理失败：${id}`, { error: error instanceof Error ? error.message : String(error) }, "插件生命周期");
@@ -356,14 +411,12 @@ class PluginManager {
         let instance;
         try {
             instance = await this.load(loaded.record);
+            const cancellation = loaded.cancellation = new AbortController();
+            loaded.tasks = new Set();
+            const http = loaded.http = this.createHttpRegistry(id);
             const dataDir = (0, node_path_1.join)(this.options.stateDir, id);
             await (0, promises_1.mkdir)(dataDir, { recursive: true });
-            const configPath = (0, node_path_1.join)(dataDir, "config.json");
-            let config = {};
-            try {
-                config = JSON.parse(await (0, promises_1.readFile)(configPath, "utf8"));
-            }
-            catch { /* defaults */ }
+            const config = await this.config(id);
             const pluginLogger = {
                 info: (message, fields) => { this.log("info", message, fields, id); this.options.logger?.info(message, fields); if (fields?.direction && typeof fields.text === "string")
                     this.recordMessage(id, fields.direction, fields.text, typeof fields.peer === "string" ? fields.peer : undefined, typeof fields.agentAid === "string" ? fields.agentAid : undefined); },
@@ -374,15 +427,33 @@ class PluginManager {
                 dataDir,
                 config,
                 logger: pluginLogger,
-                http: this.createHttpRegistry(id),
+                http,
+                modelInputGuard: true,
                 callPlugin: async (targetId, request) => {
                     if (targetId === id)
                         throw new agent_1.AgentError(`插件不能调用自身: ${id}`);
-                    return this.handle(targetId, request);
+                    if (request.management)
+                        throw new agent_1.AgentError("插件间调用不能传递管理能力");
+                    cancellation.signal.throwIfAborted();
+                    if (loaded.cancellation !== cancellation || !loaded.instance)
+                        throw new agent_1.AgentError("插件实例已停止，旧调用已失效");
+                    return this.handle(targetId, { ...request, signal: request.signal ? AbortSignal.any([request.signal, cancellation.signal]) : cancellation.signal });
+                },
+                callModelProvider: async (targetId, request) => {
+                    if (targetId === id)
+                        throw new agent_1.AgentError(`插件不能调用自身: ${id}`);
+                    cancellation.signal.throwIfAborted();
+                    if (loaded.cancellation !== cancellation || !loaded.instance)
+                        throw new agent_1.AgentError("插件实例已停止，旧调用已失效");
+                    return this.completeModelProvider(targetId, { ...request, signal: AbortSignal.any([request.signal, cancellation.signal]) });
                 },
                 pluginStatus: (targetId) => this.plugins.get(targetId)?.record.status,
                 ingress: {
-                    publish: async (message) => {
+                    publish: message => this.runPluginTask(loaded, undefined, async (signal) => {
+                        if (loaded.cancellation !== cancellation || loaded.instance !== instance)
+                            throw new agent_1.AgentError("通道插件实例已停止，旧调用已失效");
+                        if (loaded.record.status !== "ready")
+                            throw new agent_1.AgentError("通道插件正在停止或尚未就绪，不再接收新任务");
                         if (message.channel !== id)
                             throw new agent_1.AgentError("消息来源与通道插件身份不一致");
                         const trustedChannel = loaded.record.type === "channel" && (id === "aun" || id === "feishu");
@@ -396,7 +467,8 @@ class PluginManager {
                                 throw new agent_1.AgentError("当前通道不支持会话管理");
                             const current = await this.sessions.current(message, target);
                             const result = await this.sessionManagement.command(message.text, { source: current.source, sessionId: current.logicalSessionId });
-                            await message.reply(result);
+                            signal.throwIfAborted();
+                            await (0, agent_1.abortable)(message.reply(result, signal), signal);
                             return;
                         }
                         if (trustedChannel)
@@ -407,30 +479,51 @@ class PluginManager {
                         if (trustedChannel)
                             this.activeIngress.set(source, (this.activeIngress.get(source) ?? 0) + 1);
                         try {
-                            const instance = this.plugins.get(target)?.instance;
-                            const control = instance?.sessionOperations?.includes("new")
-                                ? (request) => this.controlSession(target, request)
+                            const agentInstance = this.plugins.get(target)?.instance;
+                            const control = agentInstance?.sessionOperations?.includes("new")
+                                ? (request) => this.controlSession(target, request, signal)
                                 : undefined;
                             const task = !message.text.trim() && message.attachments?.length ? "请处理收到的附件" : message.text;
                             const forwarded = new Set();
                             const sent = [];
                             const onMessage = async (text) => {
+                                signal.throwIfAborted();
                                 if (!text.trim() || forwarded.has(text))
                                     return;
-                                await message.reply(text);
+                                await (0, agent_1.abortable)(message.reply(text, signal), signal);
+                                signal.throwIfAborted();
                                 forwarded.add(text);
                                 sent.push({ text });
                                 this.recordMessage(target, "reply", text, message.peerId);
                             };
-                            const response = await this.sessions.run(message, target, (sessionId, newSession) => this.handle(target, { task, sessionId, onMessage, ...(newSession ? { newSession: true } : {}), ...(message.attachments ? { attachments: message.attachments } : {}) }), control);
+                            const response = await this.sessions.run(message, target, async (sessionId, newSession, logicalSessionId) => {
+                                const targetRecord = this.plugins.get(target)?.record;
+                                const config = targetRecord?.type === "agent" && targetRecord.capabilities.includes("management") ? await this.config(target) : undefined;
+                                const ability = trustedChannel && id === "aun" && loaded.instance === instance && loaded.record.status === "ready" && Array.isArray(config?.allowedPeers) && (config.allowedPeers.length === 0 || config.allowedPeers.includes("*") || config.allowedPeers.includes(message.peerId))
+                                    ? this.createRequestManagement(target, message.peerId, source, logicalSessionId, { signal, onMessage, ...(message.replyAttachments ? { attachmentOutput: true } : {}) }) : undefined;
+                                signal.throwIfAborted();
+                                const request = { task, sessionId, signal, onMessage, ...(newSession ? { newSession: true } : {}), ...(message.attachments ? { attachments: message.attachments } : {}), ...(message.replyAttachments ? { attachmentOutput: true } : {}), ...(ability ? { management: ability } : {}) };
+                                const issued = ability ? this.issuedManagement.get(ability) : undefined;
+                                if (issued)
+                                    issued.active = true;
+                                try {
+                                    return await this.handle(target, request);
+                                }
+                                finally {
+                                    if (issued)
+                                        issued.active = false;
+                                }
+                            }, control);
+                            signal.throwIfAborted();
                             const attachments = response.attachments?.length ? response.attachments : (0, attachments_1.asAttachments)(response.images);
                             (0, attachments_1.validateAttachments)(attachments);
                             if (attachments.length) {
                                 if (!message.replyAttachments) {
-                                    await message.reply("当前通道不支持附件回传");
+                                    await (0, agent_1.abortable)(message.reply("当前通道不支持附件回传", signal), signal);
                                     throw new agent_1.AgentError("当前通道不支持附件回传");
                                 }
-                                await message.replyAttachments(attachments, response.text);
+                                await (0, agent_1.abortable)(message.replyAttachments(attachments, response.text, signal), signal);
+                                signal.throwIfAborted();
                                 sent.push({ text: response.text, attachments });
                                 this.recordMessage(target, "reply", response.text, message.peerId);
                             }
@@ -462,7 +555,7 @@ class PluginManager {
                             else
                                 this.activeIngress.delete(source);
                         }
-                    },
+                    }),
                 },
                 runtime: { controlUrl: this.controlUrl, ports: {
                         qwenwork: Number(process.env.AGENT_BRIDGE_QWEN_CDP_PORT ?? process.env.QWEN_CDP_PORT ?? "9228"),
@@ -478,13 +571,15 @@ class PluginManager {
         catch (error) {
             if (instance) {
                 try {
-                    await instance.deactivate("reload");
+                    await instance.deactivate("reload", this.upgrades.has(id) ? { preserveDesktop: true } : undefined);
                 }
                 catch (cleanupError) {
                     this.log("warn", `插件启动失败后的清理失败：${id}`, { error: cleanupError instanceof Error ? cleanupError.message : String(cleanupError) }, "插件生命周期");
                 }
                 this.unregisterHttpRoutes(id);
             }
+            loaded.http?.unregister();
+            loaded.cancellation?.abort(new agent_1.AgentError("插件启动失败，调用已取消"));
             loaded.instance = undefined;
             loaded.record.status = "failed";
             loaded.record.error = error instanceof Error ? error.message : String(error);
@@ -492,17 +587,44 @@ class PluginManager {
             throw error;
         }
     }
-    async stop(id, reason = "stop") {
+    async stop(id, reason = "stop", deadline) {
         const loaded = this.plugins.get(id);
         if (!loaded)
             throw new agent_1.AgentError(`unknown plugin: ${id}`);
         if (loaded.instance) {
             loaded.record.status = "stopping";
+            const instance = loaded.instance;
+            const stopping = Promise.resolve().then(async () => {
+                if (deadline)
+                    await Promise.allSettled([...(loaded.tasks ?? [])]);
+                await instance.deactivate(reason, deadline ? { preserveDesktop: true } : undefined);
+            });
             try {
-                await loaded.instance.deactivate(reason);
+                try {
+                    await (0, agent_1.abortable)(stopping, deadline);
+                }
+                catch (error) {
+                    if (!deadline?.aborted)
+                        throw error;
+                    let cleanupTimer;
+                    try {
+                        const cleaned = await Promise.race([
+                            stopping.then(() => true, () => false),
+                            new Promise(resolve => { cleanupTimer = setTimeout(() => resolve(false), 5_000); }),
+                        ]);
+                        if (!cleaned)
+                            this.log("warn", `旧插件未完成清理，已隔离并继续升级：${id}`, { code: "PLUGIN_UPGRADE_CLEANUP_TIMEOUT" }, "插件升级");
+                    }
+                    finally {
+                        clearTimeout(cleanupTimer);
+                    }
+                }
             }
             finally {
+                loaded.http?.unregister();
                 this.unregisterHttpRoutes(id);
+                if (deadline)
+                    loaded.cancellation?.abort(new agent_1.AgentError("插件已停止，旧实例调用已取消"));
                 loaded.instance = undefined;
             }
         }
@@ -583,13 +705,31 @@ class PluginManager {
         }
     }
     async setAid(id, aid) { await this.saveConfig(id, { ...await this.config(id), aid }); }
-    async config(id) { if (!this.plugins.has(id))
-        throw new agent_1.AgentError(`unknown plugin: ${id}`); try {
-        return JSON.parse(await (0, promises_1.readFile)((0, node_path_1.join)(this.options.stateDir, id, "config.json"), "utf8"));
+    async config(id) {
+        const loaded = this.plugins.get(id);
+        if (!loaded)
+            throw new agent_1.AgentError(`unknown plugin: ${id}`);
+        let defaults = {};
+        if (loaded.record.manifest.configSchema) {
+            try {
+                const schema = JSON.parse(await (0, promises_1.readFile)((0, node_path_1.resolve)(loaded.record.path, loaded.record.manifest.configSchema), "utf8"));
+                if (schema.default && typeof schema.default === "object" && !Array.isArray(schema.default))
+                    defaults = schema.default;
+            }
+            catch { /* 默认声明不可读时保留已有配置 */ }
+        }
+        try {
+            const saved = JSON.parse(await (0, promises_1.readFile)((0, node_path_1.join)(this.options.stateDir, id, "config.json"), "utf8"));
+            if (!saved || typeof saved !== "object" || Array.isArray(saved))
+                throw new agent_1.AgentError("插件配置必须是对象");
+            return { ...defaults, ...saved };
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return defaults;
+            throw new agent_1.AgentError(`插件 ${id} 的配置无法读取或格式无效`);
+        }
     }
-    catch {
-        return {};
-    } }
     async reloadStrategy(record) { if (!record.manifest.configSchema)
         return "reload"; try {
         const schema = JSON.parse(await (0, promises_1.readFile)((0, node_path_1.resolve)(record.path, record.manifest.configSchema), "utf8"));
@@ -620,9 +760,143 @@ class PluginManager {
             ...await (0, agent_availability_1.agentAvailability)(plugin.id, await this.config(plugin.id), plugin.status),
         })));
     }
+    createRequestManagement(pluginId, peerId, source, logicalSessionId, output) {
+        const issued = { pluginId, instance: this.plugins.get(pluginId)?.instance, active: false };
+        const cancellation = this.plugins.get(pluginId)?.cancellation;
+        const checkActive = () => {
+            const current = this.plugins.get(pluginId);
+            if (!issued.active || !current?.instance || current.instance !== issued.instance)
+                throw new agent_1.AgentError("管理能力请求已结束或已撤销");
+            cancellation?.signal.throwIfAborted();
+        };
+        const allowed = async (agentId) => {
+            checkActive();
+            const loaded = this.plugins.get(pluginId);
+            if (!loaded?.instance || (loaded.record.status !== "ready" && !(loaded.record.status === "stopping" && this.upgrades.has(pluginId))) || !loaded.record.capabilities.includes("management"))
+                throw new agent_1.AgentError("当前插件未声明管理能力或未就绪");
+            const config = await this.config(pluginId);
+            checkActive();
+            const peers = config.allowedPeers;
+            if (!Array.isArray(peers) || (peers.length > 0 && !peers.includes("*") && !peers.includes(peerId)))
+                throw new agent_1.AgentError("当前 AUN 身份无权使用管理能力");
+            if (agentId !== undefined) {
+                const agents = config.allowedAgents;
+                if (!Array.isArray(agents) || (agents.length > 0 && !agents.includes("*") && !agents.includes(agentId)))
+                    throw new agent_1.AgentError("目标 Agent 不在允许列表中");
+            }
+            return { loaded, config };
+        };
+        const management = {
+            listAgents: async () => {
+                const { config } = await allowed();
+                const aun = this.plugins.get("aun");
+                let bindings = {};
+                let identitiesAvailable = false;
+                try {
+                    const health = aun?.record.status === "ready" ? await aun.instance?.health() : undefined;
+                    const details = health?.details;
+                    if (health?.status === "ready" && details && typeof details === "object" && !Array.isArray(details)) {
+                        const raw = details.bindings;
+                        if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+                            bindings = raw;
+                            identitiesAvailable = true;
+                        }
+                    }
+                }
+                catch { /* AUN 状态不可用时只返回 Agent 能力 */ }
+                const result = [];
+                const agents = this.list().filter(item => item.type === "agent");
+                const agentIds = new Set(agents.map(item => item.id));
+                for (const record of agents) {
+                    const agentConfig = await this.config(record.id);
+                    const current = this.plugins.get(record.id);
+                    const currentRecord = current?.record ?? record;
+                    const availability = await (0, agent_availability_1.agentAvailability)(record.id, agentConfig, currentRecord.status);
+                    const latest = this.plugins.get(record.id);
+                    const latestRecord = latest?.record ?? currentRecord;
+                    const aids = identitiesAvailable
+                        ? Object.entries(bindings).filter(([aid, bound]) => /^[a-z0-9][a-z0-9_-]{2,63}\.[a-z0-9-]+(?:\.[a-z0-9-]+)+$/.test(aid) && agentIds.has(bound) && bound === record.id).map(([aid]) => aid).sort()
+                        : [];
+                    const callable = Boolean(latest?.instance) && latestRecord.type === "agent" && latestRecord.id !== pluginId && latestRecord.status === "ready" && availability.available && !latestRecord.capabilities.includes("management") && (Array.isArray(config.allowedAgents) && (config.allowedAgents.length === 0 || config.allowedAgents.includes("*") || config.allowedAgents.includes(record.id)));
+                    result.push({ id: latestRecord.id, displayName: latestRecord.displayName, status: latestRecord.status, ...availability, reason: !identitiesAvailable && !availability.reason ? "AUN 身份数据不可用" : availability.reason, capabilities: [...latestRecord.capabilities], aids, callable });
+                }
+                await allowed();
+                return result;
+            },
+            callAgent: async (id, task) => {
+                const { loaded } = await allowed(id);
+                if (typeof task !== "string" || !task.trim() || task.length > 20_000)
+                    throw new agent_1.AgentError("Agent 调用内容无效");
+                const target = this.plugins.get(id);
+                if (!target?.instance || target.record.type !== "agent" || target.record.status !== "ready" || target.record.capabilities.includes("management") || id === pluginId)
+                    throw new agent_1.AgentError("目标 Agent 不可调用");
+                if (!(await (0, agent_availability_1.agentAvailability)(id, await this.config(id), target.record.status)).available)
+                    throw new agent_1.AgentError("目标 Agent 当前不可用");
+                await allowed(id);
+                // shortcut: 仅 WorkBuddy 已验证未知逻辑会话 ID 可安全建会话，其他插件验证后再扩展。
+                const sessionId = id === "workbuddy" && target.instance?.sessionOperations?.includes("new")
+                    ? `management-${(0, node_crypto_1.createHash)("sha256").update(`${logicalSessionId}\0${id}`).digest("hex")}`
+                    : undefined;
+                const signal = output?.signal ? AbortSignal.any([output.signal, cancellation.signal]) : cancellation.signal;
+                const response = await this.handle(id, { task, ...output, signal, ...(sessionId ? { sessionId } : {}) });
+                if (loaded.instance !== this.plugins.get(pluginId)?.instance)
+                    throw new agent_1.AgentError("管理插件已重载");
+                await allowed(id);
+                return response;
+            },
+            listAunIdentities: async () => {
+                await allowed();
+                const aun = this.plugins.get("aun")?.instance;
+                let result;
+                if (aun?.aunManagement)
+                    result = await aun.aunManagement.list();
+                else if (aun?.identity) {
+                    // 旧 AUN 只有身份列表和健康绑定；兼容只读查询，不开放创建或绑定操作。
+                    const groups = await aun.identity.list();
+                    const health = await aun.health();
+                    const aidPattern = /^[A-Za-z0-9][A-Za-z0-9._-]{2,255}$/;
+                    const aids = [...new Set([...groups.evolcore, ...groups.muAgentBridge, ...(groups.localMuAgentBridge ?? [])])].filter(aid => aidPattern.test(aid)).sort();
+                    const raw = health.details?.bindings;
+                    const bindings = raw && typeof raw === "object" && !Array.isArray(raw)
+                        ? Object.fromEntries(Object.entries(raw).filter(([aid, id]) => aidPattern.test(aid) && typeof id === "string" && /^[a-z0-9][a-z0-9-]{0,63}$/.test(id))) : {};
+                    result = { aids, bindings };
+                }
+                else
+                    throw new agent_1.AgentError("AUN 身份管理不可用");
+                await allowed();
+                return result;
+            },
+            createAunIdentity: async (input) => { await allowed(); const aun = this.plugins.get("aun")?.instance; if (!aun?.aunManagement)
+                throw new agent_1.AgentError("AUN 身份管理不可用"); const result = await aun.aunManagement.create(input); await allowed(); return result; },
+            bindAunIdentity: async (input) => { await allowed(input.agentId); const target = this.plugins.get(input.agentId); if (!target?.instance || target.record.type !== "agent" || target.record.status !== "ready")
+                throw new agent_1.AgentError("只能关联已就绪的 Agent 插件"); const aun = this.plugins.get("aun")?.instance; if (!aun?.aunManagement)
+                throw new agent_1.AgentError("AUN 身份管理不可用"); const result = await aun.aunManagement.bind(input); await allowed(input.agentId); return result; },
+            runSessionCommand: async (command) => { await allowed(); if (typeof command !== "string" || command.length > 2_000 || !/^\/sessions(?:\s|$)/.test(command.trimStart()))
+                throw new agent_1.AgentError("仅支持 /sessions 只读命令"); const result = await this.sessionManagement.command(command, { source, sessionId: logicalSessionId }); await allowed(); if (result === undefined)
+                throw new agent_1.AgentError("不支持的 /sessions 命令"); return result; },
+            summarizeToday: async () => { await allowed(); const result = await this.sessionManagement.summarizeToday({ source, sessionId: logicalSessionId }); await allowed(); return result; },
+        };
+        Object.freeze(management);
+        this.issuedManagement.set(management, issued);
+        return management;
+    }
     async health(id) { const loaded = this.plugins.get(id); if (!loaded)
         throw new agent_1.AgentError(`unknown plugin: ${id}`); if (!loaded.instance)
         return { status: loaded.record.status }; return loaded.instance.health(); }
+    async runPluginTask(loaded, upstream, work) {
+        const local = loaded.cancellation.signal;
+        const signal = upstream ? AbortSignal.any([upstream, local]) : local;
+        signal.throwIfAborted();
+        const task = (0, agent_1.abortable)(work(signal), signal);
+        const tasks = loaded.tasks;
+        tasks.add(task);
+        try {
+            return await task;
+        }
+        finally {
+            tasks.delete(task);
+        }
+    }
     async handle(id, request) {
         const loaded = this.plugins.get(id);
         if (!loaded?.instance || loaded.record.status !== "ready") {
@@ -632,20 +906,32 @@ class PluginManager {
             const reason = loaded?.record.error ? `启动错误：${loaded.record.error}` : `当前状态：${loaded?.record.status ?? "未发现"}`;
             throw new agent_1.AgentError(`插件“${name}”无法调用，插件未就绪：${processText}${reason}`);
         }
+        if (request.modelResponseSchema !== undefined && !loaded.instance.modelInput)
+            throw new agent_1.AgentError("目标插件不支持无工具模型请求");
+        if (request.management) {
+            const issued = this.issuedManagement.get(request.management);
+            if (!issued || !issued.active || issued.pluginId !== id || issued.instance !== loaded.instance)
+                throw new agent_1.AgentError("管理能力无效或已撤销");
+        }
         (0, attachments_1.validateAttachments)(request.attachments);
         if (request.attachments?.length && !loaded.instance.attachmentInput)
             throw new agent_1.AgentError(`插件 ${id} 不支持接收附件`);
-        return loaded.instance.handle(request);
+        const instance = loaded.instance;
+        return this.runPluginTask(loaded, request.signal, signal => instance.handle({
+            ...request, signal,
+            ...(request.onMessage ? { onMessage: async (text) => { signal.throwIfAborted(); await request.onMessage(text); } } : {}),
+        }));
     }
-    async controlSession(id, request) {
+    async controlSession(id, request, signal) {
         const loaded = this.plugins.get(id);
         if (!loaded?.instance || loaded.record.status !== "ready")
             throw new agent_1.AgentError(`插件 ${id} 未就绪，无法控制会话`);
         if (!loaded.instance.sessionOperations?.includes(request.operation))
             throw new agent_1.AgentError(`插件 ${id} 不支持新建会话`);
-        const response = loaded.instance.controlSession
-            ? await loaded.instance.controlSession(request)
-            : { text: `${loaded.record.displayName} 已创建新会话`, sessionId: request.sessionId };
+        const instance = loaded.instance;
+        const response = await this.runPluginTask(loaded, signal, async () => instance.controlSession
+            ? instance.controlSession(request)
+            : { text: `${loaded.record.displayName} 已创建新会话`, sessionId: request.sessionId });
         if (typeof response.sessionId !== "string" || !response.sessionId.trim())
             throw new agent_1.AgentError("插件未返回有效的新会话标识，原会话绑定保持不变");
         return response;
@@ -663,18 +949,25 @@ class PluginManager {
         return true;
     }
     createHttpRegistry(pluginId) {
+        const disposers = new Set();
+        let closed = false;
+        const check = () => { if (closed)
+            throw new agent_1.AgentError("插件 HTTP 注册表已停止"); };
+        const remember = (dispose) => { disposers.add(dispose); return () => { dispose(); disposers.delete(dispose); }; };
         return {
             register: (routeOrMethod, pathOrHandler, maybeHandler) => {
+                check();
                 if (typeof routeOrMethod === "object")
-                    return this.registerHttpRoute(pluginId, routeOrMethod.method, routeOrMethod.path, routeOrMethod.handler);
+                    return remember(this.registerHttpRoute(pluginId, routeOrMethod.method, routeOrMethod.path, routeOrMethod.handler));
                 if (typeof pathOrHandler === "string" && maybeHandler)
-                    return this.registerHttpRoute(pluginId, routeOrMethod, pathOrHandler, maybeHandler);
+                    return remember(this.registerHttpRoute(pluginId, routeOrMethod, pathOrHandler, maybeHandler));
                 if (typeof pathOrHandler === "function")
-                    return this.registerLegacyRoute(pluginId, routeOrMethod, pathOrHandler);
+                    return remember(this.registerLegacyRoute(pluginId, routeOrMethod, pathOrHandler));
                 throw new agent_1.AgentError("invalid plugin HTTP route");
             },
-            registerRoute: (path, handler) => this.registerLegacyRoute(pluginId, path, handler),
-            unregister: () => this.unregisterHttpRoutes(pluginId),
+            registerRoute: (path, handler) => { check(); return remember(this.registerLegacyRoute(pluginId, path, handler)); },
+            unregister: () => { closed = true; for (const dispose of disposers)
+                dispose(); disposers.clear(); },
         };
     }
     registerHttpRoute(pluginId, method, path, handler) {
@@ -686,8 +979,9 @@ class PluginManager {
         const existing = this.httpRoutes.get(key);
         if (existing)
             throw new agent_1.AgentError(`HTTP route already registered: ${normalizedMethod} ${normalizedPath}`);
-        this.httpRoutes.set(key, { pluginId, method: normalizedMethod, path: normalizedPath, handler });
-        return () => { if (this.httpRoutes.get(key)?.pluginId === pluginId)
+        const route = { pluginId, method: normalizedMethod, path: normalizedPath, handler };
+        this.httpRoutes.set(key, route);
+        return () => { if (this.httpRoutes.get(key) === route)
             this.httpRoutes.delete(key); };
     }
     registerLegacyRoute(pluginId, path, handler) {
@@ -708,8 +1002,9 @@ class PluginManager {
                     response.setHeader(name, value);
             response.end(result?.body ?? "");
         };
-        this.httpRoutes.set(key, { pluginId, method: "*", path: normalizedPath, handler: nativeHandler });
-        return () => { if (this.httpRoutes.get(key)?.pluginId === pluginId)
+        const route = { pluginId, method: "*", path: normalizedPath, handler: nativeHandler };
+        this.httpRoutes.set(key, route);
+        return () => { if (this.httpRoutes.get(key) === route)
             this.httpRoutes.delete(key); };
     }
     unregisterHttpRoutes(pluginId) { for (const [key, route] of this.httpRoutes)
@@ -812,6 +1107,8 @@ class PluginManager {
             try {
                 const packageJson = JSON.parse(await (0, promises_1.readFile)((0, node_path_1.join)(directory, "package.json"), "utf8"));
                 packageName = packageJson.name;
+                if (packageName && (packageName.startsWith("agent-bridge-") || packageJson.agentBridge?.id !== undefined) && (0, plugin_catalog_1.resolvePluginId)(packageName, packageJson.agentBridge?.id) !== manifest.id)
+                    throw new agent_1.AgentError("npm 包声明的插件 ID 与清单不一致");
                 coreConstraint = packageJson.agentBridge?.requires?.["mu-agent-bridge"];
                 const declared = packageJson.agentBridge?.requires?.plugins;
                 if (declared && JSON.stringify(declared) !== JSON.stringify(manifest.dependencies ?? {}))
@@ -824,6 +1121,10 @@ class PluginManager {
             const coreVersion = require((0, node_path_1.resolve)(__dirname, "../../package.json")).version;
             const error = coreConstraint && !(0, version_manager_1.satisfiesVersion)(coreVersion, coreConstraint) ? `核心版本 ${coreVersion} 不满足插件要求 ${coreConstraint}` : undefined;
             const record = { id: manifest.id, version: manifest.version, type: manifest.type ?? "other", displayName: manifest.displayName ?? manifest.id, status: error ? "failed" : "discovered", capabilities: manifest.capabilities, manifest, path: directory, ...(packageName ? { packageName } : {}), ...(coreConstraint ? { coreConstraint } : {}), ...(error ? { error } : {}) };
+            if (existing && existing.record.packageName && packageName && existing.record.packageName !== packageName) {
+                this.log("warn", "插件 npm 来源冲突，保留现有来源", { id: manifest.id, existingPackageName: existing.record.packageName, ignoredPackageName: packageName }, "插件发现");
+                return;
+            }
             if (existing) {
                 const versionOrder = (0, version_manager_1.compareVersions)(record.version, existing.record.version);
                 const candidateManaged = (0, node_path_1.resolve)(directory).startsWith(`${(0, node_path_1.resolve)(this.options.stateDir, "npm")}${node_path_1.sep}`);

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

@@ -5,7 +5,7 @@ const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const MANIFEST = {
     id: "abweb",
-    version: "1.0.11",
+    version: "1.0.15",
     displayName: "Agent Bridge Web",
     entry: "dist/index.js",
     apiVersion: "1",