mu-agent-bridge 1.0.70 → 1.0.73

package/README.md

@@ -1,8 +1,7 @@
 # mu-agent-bridge 动态插件平台
 
 运行时使用 TypeScript/Node.js，实现一个可动态发现、启动、停止、重载和安装插件的 daemon。
-当前插件包括千问办公 `qwenwork`、DeepSeek Harness `dsh`、豆包 `doubao`、基于 CodeBuddy CLI 的 `workbuddy`、远程 ChatGPT/Codex CDP 插件 `chatgpt`，以及插件化管理后台
-`abweb`。插件之间独立失败，管理 API 和 OpenAI 兼容接口由同一个本地控制服务提供。
+当前插件包括千问办公 `qwenwork`、DeepSeek Harness `dsh`、豆包 `doubao`、基于 CodeBuddy CLI 的 `workbuddy`、远程 ChatGPT/Codex CDP 插件 `chatgpt`、个人助理管理 Agent `personal-assistant`，以及插件化管理后台 `abweb`。插件之间独立失败，管理 API 和 OpenAI 兼容接口由同一个本地控制服务提供。
 
 ## 快速开始
 
@@ -48,14 +47,14 @@ abweb 的“配置码”栏；配对码 10 分钟有效，只能使用一次，
 
 ## npm 插件
 
-默认包 `mu-agent-bridge` 已内置 abweb、AUN、千问办公、DSH、豆包、飞书、WorkBuddy 和 ChatGPT/Codex 八个插件，直接安装即可使用：
+默认包 `mu-agent-bridge` 已内置 abweb、AUN、千问办公、DSH、豆包、飞书、WorkBuddy、ChatGPT/Codex、Codex CLI、Claude CLI 和个人助理共十一个插件，直接安装即可使用：
 
 ```powershell
 npm install -g mu-agent-bridge@latest
 mab start
 ```
 
-八个插件会从核心包的 `plugins/` 目录自动发现。插件仍分别发布为独立 npm 包，可用于单独测试、升级或替换版本。安装与发布说明见
+十一个插件会从核心包的 `plugins/` 目录自动发现。插件仍分别发布为独立 npm 包，可用于单独测试、升级或替换版本。安装与发布说明见
 [`docs/npm-publishing.md`](docs/npm-publishing.md)。
 
 `mab start` 启动时会查询核心包和托管插件的 npm 最新版本，检查状态保存于 mab 状态目录的
@@ -77,12 +76,16 @@ mab start
 abweb 插件目录从 npm 搜索带 `mu-agent-bridge-plugin` 关键词的包，按包元数据中的
 `agentBridge.type` 展示 Agent、Channel 和管理插件；安装后以 `plugin.json` 的类型和能力
 再次校验，不根据包名推断类型。搜索结果有收录延迟，可在页面直接输入 `agent-bridge-*`
-包名安装。已安装插件按清单能力兼容旧版分类。AUN 通道插件包名为 `agent-bridge-aun`，安装后在 AUN 身份页手动关联每个 AID；未关联的 AID 不会自动投递，关联操作只修改指定 AID，不影响其它身份。`workbuddy` 插件包名为 `agent-bridge-workbuddy`，显式关联到 WorkBuddy 后即可按对端保持 CodeBuddy 会话。默认问答使用独立的 `@tencent-ai/codebuddy-code` CLI，须单独登录；没有 CLI 时使用 WorkBuddy 桌面端 CDP，并默认自动启动桌面应用。CLI 未登录时不会自动切换到桌面端账号；可设置 `transport` 为 `cdp` 显式使用桌面端。
+包名安装。已安装插件按清单能力兼容旧版分类。AUN 通道插件包名为 `agent-bridge-aun`，安装后在 AUN 身份页手动关联每个 AID；未关联的 AID 不会自动投递，关联操作只修改指定 AID。
+
+个人助理的独立 npm 包名为 `agent-bridge-pa`，运行时 ID、源码和数据目录仍用 `personal-assistant`。在 ABWeb 的“已安装插件 → 个人助理 → 配置模型”选择已安装来源：五个桌面 Agent、Codex CLI、Claude CLI，或 OpenAI 兼容接口；列表由后台动态发现。来源未就绪时显示原因并保留原配置。专用 AUN AID 仍关联到 `personal-assistant`，Peer 和可调用 Agent 仍受原白名单限制。详见[个人助理使用说明](packages/personal-assistant/README.md)。
+
+`workbuddy` 插件包名为 `agent-bridge-workbuddy`，显式关联后按对端保持会话。默认问答使用独立的 `@tencent-ai/codebuddy-code` CLI，须单独登录；没有 CLI 时使用桌面端 CDP。CLI 未登录时不会自动切换到桌面账号。个人助理选择 WorkBuddy 桌面模型来源时请设置 `transport: "cdp"`。
 
 插件仍在 daemon 的同一个 Node.js 进程内运行。修改插件入口依赖后应重启 daemon，避免模块缓存
 影响新代码。
 
-npm 尚未发布时，核心包内置的八个默认插件仍会出现在插件列表。abweb 的“安装本地插件”
+npm 尚未发布时，核心包内置的十一个默认插件仍会出现在插件列表。abweb 的“安装本地插件”
 可填写 **Windows 主机上**包含 `plugin.json` 的目录路径，例如编译后的
 `C:\path\to\agent_bridge\packages\dsh`；安装后可在下拉框中启动。已内置的千问办公无需再次安装。
 “安装 npm 插件”只适用于包已经公开发布的情况。npm 发布令牌仅供发布脚本向 npm 官网认证，

package/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/dist/src-ts/channel-sessions.js

@@ -136,12 +136,13 @@ class ChannelSessions {
             const active = this.sessions[this.active[source]];
             const entry = !command && active?.agentPlugin === agentPlugin ? active : undefined;
             const sessionId = entry?.sessionId ?? (0, node_crypto_1.randomUUID)();
+            const logicalSessionId = entry?.logicalSessionId ?? (0, node_crypto_1.randomUUID)();
             const response = command
                 ? await control({ operation: "new", sessionId, ...(command[1]?.trim() ? { name: command[1].trim() } : {}) })
-                : await call(sessionId, !entry || entry.newSession === true);
+                : await call(sessionId, !entry || entry.newSession === true, logicalSessionId);
             if (command && (typeof response.sessionId !== "string" || !response.sessionId.trim()))
                 throw new Error("插件未返回有效的新会话标识，原会话绑定保持不变");
-            const next = { source, logicalSessionId: entry?.logicalSessionId ?? (0, node_crypto_1.randomUUID)(), agentPlugin, sessionId: response.sessionId || sessionId, updatedAt: new Date().toISOString(), ...(command ? { newSession: true } : {}) };
+            const next = { source, logicalSessionId, agentPlugin, sessionId: response.sessionId || sessionId, updatedAt: new Date().toISOString(), ...(command ? { newSession: true } : {}) };
             await this.save(next);
             return command ? response : { ...response, source, logicalSessionId: next.logicalSessionId, agentPlugin, request: message, response };
         });

package/dist/src-ts/control-server.js

@@ -183,7 +183,9 @@ class ControlServer {
             if (method === "GET" && url.pathname === "/api/health")
                 return this.json(res, 200, { status: "ok", plugins: this.options.manager.list().length });
             if (method === "GET" && url.pathname === "/api/versions")
-                return this.json(res, 200, { core: this.options.manager.versions.get("mu-agent-bridge") ?? null, plugins: this.options.manager.list().map((plugin) => ({ ...plugin, versionStatus: this.options.manager.versions.get(`agent-bridge-${plugin.id}`) ?? null })) });
+                return this.json(res, 200, { core: this.options.manager.versions.get("mu-agent-bridge") ?? null, plugins: this.options.manager.list().map((plugin) => ({ ...plugin, versionStatus: this.options.manager.versions.get(plugin.packageName ?? `agent-bridge-${plugin.id}`) ?? null })) });
+            if (method === "GET" && url.pathname === "/api/model-providers")
+                return this.json(res, 200, { providers: this.options.manager.listModelProviders() });
             if (method === "GET" && url.pathname === "/api/update-policy")
                 return this.json(res, 200, await this.options.manager.updatePolicy());
             if (method === "PATCH" && url.pathname === "/api/update-policy")
@@ -283,7 +285,8 @@ class ControlServer {
                 }
                 if (method === "POST" && parts[3] === "download") {
                     const body = await this.body(req);
-                    return this.json(res, 200, { ok: true, path: await this.options.manager.downloadPackage(body.packageName ?? `agent-bridge-${id}`, body.version) });
+                    const packageName = body.packageName ?? this.options.manager.packageInfo(id).packageName ?? `agent-bridge-${id}`;
+                    return this.json(res, 200, { ok: true, path: await this.options.manager.downloadPackage(packageName, body.version) });
                 }
                 if (method === "DELETE" && parts.length === 3) {
                     await this.options.manager.uninstall(id);

package/dist/src-ts/dsh-agent.js

@@ -61,19 +61,23 @@ async function readPresentedFiles(directory, paths, cwd, inputs, returnPaths) {
     return result;
 }
 class DshAgent {
+    options;
     name = "dsh";
     paths;
     spawnProcess;
     defaultTimeoutMs;
     constructor(options) {
-        this.paths = options.paths ?? (0, dsh_paths_1.resolveDshPaths)(options.patchPath);
+        this.options = options;
+        this.paths = options.paths;
         this.spawnProcess = options.spawn ?? node_child_process_1.spawn;
         this.defaultTimeoutMs = options.defaultTimeoutMs ?? 300_000;
     }
-    async send(request) {
+    async send(request, modelRequest = false) {
         if (!request.task.trim())
             throw new agent_1.AgentError("DSH task must not be empty");
+        request.signal?.throwIfAborted();
         (0, attachments_1.validateAttachments)(request.attachments);
+        const paths = this.paths ?? await (0, dsh_paths_1.resolveDshPaths)(this.options.patchPath);
         const workDirectory = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "agent-bridge-dsh-"));
         let failed = false;
         try {
@@ -84,12 +88,12 @@ class DshAgent {
             const inputPaths = (request.attachments ?? []).map((item, index) => ({ path: (0, node_path_1.join)(workDirectory, `${index}-${(0, attachments_1.attachmentFilename)(item.filename)}`), returnPath: (0, node_path_1.join)(outputDirectory, `${index}-${(0, attachments_1.attachmentFilename)(item.filename)}`), filename: item.filename, contentType: item.contentType }));
             for (const [index, item] of (request.attachments ?? []).entries())
                 await (0, promises_1.writeFile)(inputPaths[index].returnPath, item.data, { mode: 0o600 });
-            const task = `${request.task}\n\n请使用真实文件工具读取输入附件；生成的回传文件必须写入 outputDirectory 的直接子文件，并调用 present 工具声明文件。原附件已准备 returnPath 副本，原样回传时直接 present 此路径，无需 shell 复制。图片或视频无法理解时请明确说明，仍可原样回传。\n附件传输：\n${JSON.stringify({ inputs: inputPaths, outputDirectory })}`;
-            const args = ["--expose-internals", this.paths.cli, "--profile", "headless", "--patch", this.paths.patch, "--json"];
+            const task = modelRequest ? request.task : `${request.task}\n\n请使用真实文件工具读取输入附件；生成的回传文件必须写入 outputDirectory 的直接子文件，并调用 present 工具声明文件。原附件已准备 returnPath 副本，原样回传时直接 present 此路径，无需 shell 复制。图片或视频无法理解时请明确说明，仍可原样回传。\n附件传输：\n${JSON.stringify({ inputs: inputPaths, outputDirectory })}`;
+            const args = ["--expose-internals", paths.cli, "--profile", "headless", "--patch", paths.patch, "--json"];
             if (request.sessionId && !request.newSession)
                 args.push("--session-id", request.sessionId);
             args.push("-");
-            const child = this.spawnProcess(this.paths.executable, args, {
+            const child = this.spawnProcess(paths.executable, args, {
                 cwd: request.cwd,
                 env: { ...process.env, ELECTRON_RUN_AS_NODE: "1" },
                 stdio: ["pipe", "pipe", "pipe"],
@@ -126,18 +130,30 @@ class DshAgent {
             });
             child.stderr.on("data", (chunk) => { errors += chunk; });
             await new Promise((resolve, reject) => {
-                const timer = setTimeout(() => {
-                    child.kill();
-                    reject(new agent_1.AgentError(`DSH task timed out after ${request.timeoutMs ?? this.defaultTimeoutMs}ms`));
-                }, request.timeoutMs ?? this.defaultTimeoutMs);
-                child.once("error", (error) => { clearTimeout(timer); reject(new agent_1.AgentError("failed to start DSH", { cause: error })); });
-                child.once("close", (code) => {
+                let timedOut = false;
+                const finish = (action) => {
                     clearTimeout(timer);
-                    if (code !== 0 && !finalText)
-                        reject(new agent_1.AgentError(errors.trim() || `DSH exited with code ${code}`));
-                    else
-                        resolve();
+                    request.signal?.removeEventListener("abort", abort);
+                    action();
+                };
+                const abort = () => { child.kill(); };
+                const timer = setTimeout(() => { timedOut = true; child.kill(); }, request.timeoutMs ?? this.defaultTimeoutMs);
+                child.once("error", (error) => finish(() => reject(new agent_1.AgentError("failed to start DSH", { cause: error }))));
+                child.once("close", (code) => {
+                    finish(() => {
+                        if (request.signal?.aborted)
+                            reject(request.signal.reason instanceof Error ? request.signal.reason : new agent_1.AgentError("DSH task canceled"));
+                        else if (timedOut)
+                            reject(new agent_1.AgentError(`DSH task timed out after ${request.timeoutMs ?? this.defaultTimeoutMs}ms`));
+                        else if (code !== 0 && !finalText)
+                            reject(new agent_1.AgentError(errors.trim() || `DSH exited with code ${code}`));
+                        else
+                            resolve();
+                    });
                 });
+                request.signal?.addEventListener("abort", abort, { once: true });
+                if (request.signal?.aborted)
+                    abort();
                 child.stdin.end(task, "utf8");
             });
             if (request.newSession && !sessionId)

package/dist/src-ts/dsh-paths.js

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveDshPaths = resolveDshPaths;
-const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
-function resolveDshPaths(patch) {
-    const override = process.env.DSH_INSTALL_DIR;
-    const candidates = [override, "D:\\Programs\\DeepSeek Harness", "D:\\DSH"].filter((value) => Boolean(value));
-    const root = candidates.find((candidate) => (0, node_fs_1.existsSync)((0, node_path_1.join)(candidate, "DeepSeek Harness.exe"))) ?? candidates[0];
+const desktop_launch_1 = require("./plugins/desktop-launch");
+async function resolveDshPaths(patch, configured) {
+    const executable = await (0, desktop_launch_1.findWindowsExecutable)("DeepSeek Harness.exe", configured ?? (process.env.DSH_INSTALL_DIR ? (0, node_path_1.join)(process.env.DSH_INSTALL_DIR, "DeepSeek Harness.exe") : undefined));
+    if (!executable)
+        throw new Error("未找到 DeepSeek Harness 可执行文件，请先安装 DSH 或重新检测客户端路径");
     return {
-        executable: (0, node_path_1.join)(root, "DeepSeek Harness.exe"),
-        cli: (0, node_path_1.join)(root, "resources", "app.asar", "dsh", "node_modules", "@deepseek-ai", "dsh-desktop-host", "lib", "cli.js"),
+        executable,
+        cli: (0, node_path_1.join)((0, node_path_1.dirname)(executable), "resources", "app.asar", "dsh", "node_modules", "@deepseek-ai", "dsh-desktop-host", "lib", "cli.js"),
         patch,
     };
 }

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

@@ -1,8 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePluginId = resolvePluginId;
 exports.searchPluginCatalog = searchPluginCatalog;
 const registry = "https://registry.npmjs.org";
 const pluginName = /^agent-bridge-[a-z0-9-]+$/;
+const pluginId = /^[a-z][a-z0-9-]{1,63}$/;
+function resolvePluginId(packageName, declaredId) {
+    if (!pluginName.test(packageName))
+        return;
+    const id = declaredId === undefined ? packageName.slice("agent-bridge-".length) : declaredId;
+    return typeof id === "string" && pluginId.test(id) ? id : undefined;
+}
 async function getJson(url) {
     const response = await fetch(url, { signal: AbortSignal.timeout(10_000) });
     if (!response.ok)
@@ -24,9 +32,10 @@ async function searchPluginCatalog(query = "", get = getJson) {
             const version = metadata?.["dist-tags"]?.latest;
             const pkg = metadata?.versions?.[version];
             const type = pkg?.agentBridge?.type;
-            if (!pkg?.agentBridge?.plugin || !["agent", "channel", "management"].includes(type))
+            const id = resolvePluginId(name, pkg?.agentBridge?.id);
+            if (!id || !pkg?.agentBridge?.plugin || !["agent", "channel", "management"].includes(type))
                 return;
-            return { name, version, description: typeof entry.package.description === "string" ? entry.package.description : "", type };
+            return { name, id, version, description: typeof entry.package.description === "string" ? entry.package.description : "", type };
         }
         catch {
             return;

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

@@ -34,6 +34,7 @@ class PluginManager {
     root;
     messages = [];
     activeIngress = new Map();
+    issuedManagement = new WeakMap();
     trustConfig = defaultPluginTrustConfig();
     trustLoaded = false;
     publisherLookups = new Map();
@@ -110,7 +111,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 +169,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,7 +217,7 @@ 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");
@@ -255,6 +257,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 loaded.instance.modelProvider.complete({
+            prompt: request.prompt,
+            sessionId: request.sessionId,
+            timeoutMs: request.timeoutMs,
+            signal: request.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 +302,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 +319,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();
@@ -375,11 +415,19 @@ class PluginManager {
                 config,
                 logger: pluginLogger,
                 http: this.createHttpRegistry(id),
+                modelInputGuard: true,
                 callPlugin: async (targetId, request) => {
                     if (targetId === id)
                         throw new agent_1.AgentError(`插件不能调用自身: ${id}`);
+                    if (request.management)
+                        throw new agent_1.AgentError("插件间调用不能传递管理能力");
                     return this.handle(targetId, request);
                 },
+                callModelProvider: async (targetId, request) => {
+                    if (targetId === id)
+                        throw new agent_1.AgentError(`插件不能调用自身: ${id}`);
+                    return this.completeModelProvider(targetId, request);
+                },
                 pluginStatus: (targetId) => this.plugins.get(targetId)?.record.status,
                 ingress: {
                     publish: async (message) => {
@@ -407,8 +455,8 @@ 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")
+                            const agentInstance = this.plugins.get(target)?.instance;
+                            const control = agentInstance?.sessionOperations?.includes("new")
                                 ? (request) => this.controlSession(target, request)
                                 : undefined;
                             const task = !message.text.trim() && message.attachments?.length ? "请处理收到的附件" : message.text;
@@ -422,7 +470,23 @@ class PluginManager {
                                 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.includes("*") || config.allowedPeers.includes(message.peerId))
+                                    ? this.createRequestManagement(target, message.peerId, source, logicalSessionId) : undefined;
+                                const request = { task, sessionId, onMessage, ...(newSession ? { newSession: true } : {}), ...(message.attachments ? { attachments: message.attachments } : {}), ...(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);
                             const attachments = response.attachments?.length ? response.attachments : (0, attachments_1.asAttachments)(response.images);
                             (0, attachments_1.validateAttachments)(attachments);
                             if (attachments.length) {
@@ -620,6 +684,103 @@ class PluginManager {
             ...await (0, agent_availability_1.agentAvailability)(plugin.id, await this.config(plugin.id), plugin.status),
         })));
     }
+    createRequestManagement(pluginId, peerId, source, logicalSessionId) {
+        const issued = { pluginId, instance: this.plugins.get(pluginId)?.instance, active: false };
+        const checkActive = () => {
+            const current = this.plugins.get(pluginId);
+            if (!issued.active || !current?.instance || current.instance !== issued.instance)
+                throw new agent_1.AgentError("管理能力请求已结束或已撤销");
+        };
+        const allowed = async (agentId) => {
+            checkActive();
+            const loaded = this.plugins.get(pluginId);
+            if (!loaded?.instance || loaded.record.status !== "ready" || !loaded.record.capabilities.includes("management"))
+                throw new agent_1.AgentError("当前插件未声明管理能力或未就绪");
+            const config = await this.config(pluginId);
+            checkActive();
+            const peers = Array.isArray(config.allowedPeers) ? config.allowedPeers : [];
+            if (!peers.includes("*") && !peers.includes(peerId))
+                throw new agent_1.AgentError("当前 AUN 身份无权使用管理能力");
+            if (agentId !== undefined) {
+                const agents = Array.isArray(config.allowedAgents) ? config.allowedAgents : [];
+                if (!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.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 response = await this.handle(id, { task, ...(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; if (!aun?.aunManagement)
+                throw new agent_1.AgentError("AUN 身份管理不可用"); const result = await aun.aunManagement.list(); 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(); }
@@ -632,6 +793,13 @@ 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} 不支持接收附件`);
@@ -812,6 +980,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 +994,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.9",
+    version: "1.0.13",
     displayName: "Agent Bridge Web",
     entry: "dist/index.js",
     apiVersion: "1",