@ai-zen/agents-sdk 0.12.0 → 1.0.0-alpha.0

package/dist/scope/plugins/skills/SkillsScopePlugin.js

@@ -0,0 +1,48 @@
+import { isAbsolute, join } from "node:path";
+import { discoverSkills } from "./discover.js";
+import { createCallSkillSubAgentTool, createLoadSkillTool, } from "./skillTools.js";
+/**
+ * Skill 插件 —— 发现 SKILL.md + 装配渐进式披露元工具。
+ *
+ * 渐进式披露设计原样保留：
+ *   - `load_skill`            枚举所有允许的 skill
+ *   - `call_skill_sub_agent`  枚举 subAgent: true 的 skill（AgentToolLazy）
+ * 两个元工具名恒上报 `tools` 维度（供权限允许/拒绝 → 拒绝即切断披露通道）；
+ * 是否真正注册由 `instantiate()` 按允许名 + 候选条件决定。
+ */
+export class SkillsScopePlugin {
+    static ID = "skills";
+    id = SkillsScopePlugin.ID;
+    paths;
+    skills = [];
+    /** 解析后的 skill 目录（供 instantiate 时传给工具读取正文） */
+    dirs = [];
+    constructor(options) {
+        this.paths = options?.paths ?? [];
+    }
+    async discover(scope, options) {
+        this.dirs = this.paths.map((p) => (isAbsolute(p) ? p : join(scope.cwd, p)));
+        this.skills = await discoverSkills(this.dirs, options);
+    }
+    candidates() {
+        return {
+            skills: this.skills.map((s) => s.id),
+            tools: ["load_skill", "call_skill_sub_agent"],
+        };
+    }
+    instantiate(_scope, filtered) {
+        const allow = new Set(filtered.tools);
+        const allowedSkills = new Set(filtered.skills);
+        const filteredSkills = this.skills.filter((s) => allowedSkills.has(s.id));
+        const result = [];
+        if (allow.has("load_skill") && filteredSkills.length > 0) {
+            result.push(createLoadSkillTool(this.dirs, filteredSkills));
+        }
+        // call_skill_sub_agent：只要有支持子 Agent 的 skill 就注册
+        if (allow.has("call_skill_sub_agent") &&
+            filteredSkills.some((s) => s.subAgent)) {
+            result.push(createCallSkillSubAgentTool(this.dirs, filteredSkills));
+        }
+        return result;
+    }
+}

package/dist/{capabilities/discovery/skills.js → scope/plugins/skills/discover.js}

@@ -1,6 +1,6 @@
 import { promises as fs } from "node:fs";
 import { join } from "node:path";
-import { getLogger } from "../../shared/logger.js";
+import { getLogger } from "../../../shared/logger.js";
 const log = getLogger();
 // ---- 发现（返回完整 SkillInfo，不再丢失 subAgent 等信息）----
 /**

package/dist/{capabilities/implements → scope/plugins/skills}/skillTools.d.ts

@@ -1,5 +1,5 @@
 import { CallbackTool, AgentToolLazy } from "@ai-zen/agents-core";
-import type { SkillInfo } from "../discovery/skills.js";
+import type { SkillInfo } from "./discover.js";
 /**
  * 创建 load_skill 工具。
  * 枚举所有允许的 skill（不限是否支持子 Agent），由 filteredSkills 提供完整信息。

package/dist/{capabilities/implements → scope/plugins/skills}/skillTools.js

@@ -1,7 +1,7 @@
 import { CallbackTool, Agent, AgentToolLazy, Message } from "@ai-zen/agents-core";
-import { createDisclosureParam } from "../disclosure.js";
-import { readSkill } from "../discovery/skills.js";
-import { getLogger } from "../../shared/logger.js";
+import { createDisclosureParam } from "../../disclosure.js";
+import { readSkill } from "./discover.js";
+import { getLogger } from "../../../shared/logger.js";
 import { promises as fs } from "node:fs";
 const log = getLogger();
 const EMPTY_HINT = "（当前没有可用的 Skill，请联系用户添加）";

package/dist/scope/plugins/subagents/SubAgentsScopePlugin.d.ts

@@ -0,0 +1,20 @@
+import type { Tool } from "@ai-zen/agents-core";
+import type { Scope, FilterOutput } from "../../Scope.js";
+import type { ScopeCandidates, ScopePlugin } from "../../ScopePlugin.js";
+/**
+ * SubAgent 插件 —— 发现 `sub-agents/*.json`，将含 function 的定义注册为工具。
+ *
+ * 产物为 `AgentToolLazy`（延迟构建，避免工具列表构建阶段的递归创建）。
+ */
+export declare class SubAgentsScopePlugin implements ScopePlugin {
+    static readonly ID = "subagents";
+    readonly id = "subagents";
+    private readonly paths;
+    private subagents;
+    constructor(options?: {
+        paths?: string[];
+    });
+    discover(scope: Scope): Promise<void>;
+    candidates(): ScopeCandidates;
+    instantiate(scope: Scope, filtered: FilterOutput): Tool[];
+}

package/dist/scope/plugins/subagents/SubAgentsScopePlugin.js

@@ -0,0 +1,34 @@
+import { isAbsolute, join } from "node:path";
+import { discoverSubAgents } from "./discover.js";
+import { createSubAgentTool } from "./subAgentTools.js";
+/**
+ * SubAgent 插件 —— 发现 `sub-agents/*.json`，将含 function 的定义注册为工具。
+ *
+ * 产物为 `AgentToolLazy`（延迟构建，避免工具列表构建阶段的递归创建）。
+ */
+export class SubAgentsScopePlugin {
+    static ID = "subagents";
+    id = SubAgentsScopePlugin.ID;
+    paths;
+    subagents = [];
+    constructor(options) {
+        this.paths = options?.paths ?? [];
+    }
+    async discover(scope) {
+        const dirs = this.paths.map((p) => (isAbsolute(p) ? p : join(scope.cwd, p)));
+        this.subagents = await discoverSubAgents(dirs);
+    }
+    candidates() {
+        return {
+            subagents: this.subagents
+                .filter((d) => d.function)
+                .map((d) => d.function.name),
+        };
+    }
+    instantiate(scope, filtered) {
+        const allow = new Set(filtered.subagents);
+        return this.subagents
+            .filter((d) => d.function && allow.has(d.function.name))
+            .map((d) => createSubAgentTool(d, scope));
+    }
+}

package/dist/{capabilities/discovery/subagents.d.ts → scope/plugins/subagents/discover.d.ts}

@@ -1,4 +1,4 @@
-import type { AgentDefinition } from "../../types/index.js";
+import type { AgentDefinition } from "../../../types/index.js";
 /**
  * 扫描多个目录中发现的所有 SubAgent 完整定义。
  * 按优先级从高到低传入路径列表，同名 function.name 靠前的路径优先（先到先得）。

package/dist/{capabilities/implements → scope/plugins/subagents}/subAgentTools.d.ts

@@ -1,10 +1,10 @@
 import type { Tool } from "@ai-zen/agents-core";
-import type { AgentDefinition } from "../../types/index.js";
-import type { Provider } from "../../runtime/Provider.js";
+import type { AgentDefinition } from "../../../types/index.js";
+import type { Scope } from "../../Scope.js";
 /**
  * 创建 SubAgent 工具（AgentToolLazy）。
  *
  * SubAgent 是有 `function` 字段的 Agent，可被其他 Agent 作为工具调用。
  * 使用延迟构建（AgentToolLazy）避免工具列表构建阶段的递归创建问题。
  */
-export declare function createSubAgentTool(def: AgentDefinition, provider: Provider): Tool;
+export declare function createSubAgentTool(def: AgentDefinition, scope: Scope): Tool;

package/dist/{capabilities/implements → scope/plugins/subagents}/subAgentTools.js

@@ -1,12 +1,12 @@
 import { Agent, AgentToolLazy } from "@ai-zen/agents-core";
-import { createModel } from "../../runtime/createModel.js";
+import { createModel } from "../../../runtime/createModel.js";
 /**
  * 创建 SubAgent 工具（AgentToolLazy）。
  *
  * SubAgent 是有 `function` 字段的 Agent，可被其他 Agent 作为工具调用。
  * 使用延迟构建（AgentToolLazy）避免工具列表构建阶段的递归创建问题。
  */
-export function createSubAgentTool(def, provider) {
+export function createSubAgentTool(def, scope) {
     if (!def.function) {
         throw new Error(`Agent "${def.id}" 没有 function 字段，不能作为 SubAgent 工具`);
     }
@@ -24,7 +24,7 @@ export function createSubAgentTool(def, provider) {
             let model;
             let modelConfig;
             if (def.modelId) {
-                const m = createModel(provider, def.modelId);
+                const m = createModel(scope, def.modelId);
                 client = m.client;
                 model = m.model;
                 modelConfig = m.modelConfig;
@@ -39,12 +39,12 @@ export function createSubAgentTool(def, provider) {
                 modelConfig = parent.modelConfig;
             }
             // SubAgent 独立解析自己的工具（排除自身，防止递归）
-            const subFiltered = provider.filter(def, {
+            const subFiltered = scope.filter(def, {
                 exclude: {
                     subagents: def.function?.name ? [def.function.name] : undefined,
                 },
             });
-            const tools = provider.instantiate(subFiltered);
+            const tools = scope.instantiate(subFiltered);
             const subAgent = new Agent({
                 client,
                 model,

package/dist/scope/plugins/usertools/UserToolsScopePlugin.d.ts

@@ -0,0 +1,24 @@
+import type { Tool } from "@ai-zen/agents-core";
+import type { AgentDefinition } from "../../../types/index.js";
+import type { Scope, FilterOutput } from "../../Scope.js";
+import type { ScopeCandidates, ScopePlugin } from "../../ScopePlugin.js";
+/**
+ * 用户工具插件 —— 扫描 `tools/*.js` / `*.mjs` 动态加载。
+ *
+ * 与内置工具插件分开，以便单独替换/停用其中一类。
+ * 路径可为绝对路径或相对路径（相对则按 scope.cwd join）。
+ */
+export declare class UserToolsScopePlugin implements ScopePlugin {
+    static readonly ID = "user-tools";
+    readonly id = "user-tools";
+    private readonly paths;
+    private tools;
+    constructor(options?: {
+        paths?: string[];
+    });
+    discover(scope: Scope, options?: {
+        silent?: boolean;
+    }): Promise<void>;
+    candidates(_scope: Scope, _definition: AgentDefinition): ScopeCandidates;
+    instantiate(_scope: Scope, filtered: FilterOutput): Tool[];
+}

package/dist/scope/plugins/usertools/UserToolsScopePlugin.js

@@ -0,0 +1,28 @@
+import { isAbsolute, join } from "node:path";
+import { discoverUserTools } from "./discover.js";
+/**
+ * 用户工具插件 —— 扫描 `tools/*.js` / `*.mjs` 动态加载。
+ *
+ * 与内置工具插件分开，以便单独替换/停用其中一类。
+ * 路径可为绝对路径或相对路径（相对则按 scope.cwd join）。
+ */
+export class UserToolsScopePlugin {
+    static ID = "user-tools";
+    id = UserToolsScopePlugin.ID;
+    paths;
+    tools = [];
+    constructor(options) {
+        this.paths = options?.paths ?? [];
+    }
+    async discover(scope, options) {
+        const dirs = this.paths.map((p) => (isAbsolute(p) ? p : join(scope.cwd, p)));
+        this.tools = await discoverUserTools(dirs, options);
+    }
+    candidates(_scope, _definition) {
+        return { tools: this.tools.map((t) => t.function.name) };
+    }
+    instantiate(_scope, filtered) {
+        const allow = new Set(filtered.tools);
+        return this.tools.filter((t) => allow.has(t.function.name));
+    }
+}

package/dist/{capabilities/discovery/usertools.js → scope/plugins/usertools/discover.js}

@@ -2,7 +2,7 @@ import { promises as fs } from "node:fs";
 import { join } from "node:path";
 import { pathToFileURL } from "node:url";
 import { Tool, CallbackTool } from "@ai-zen/agents-core";
-import { getLogger } from "../../shared/logger.js";
+import { getLogger } from "../../../shared/logger.js";
 /**
  * 扫描多个 tools/ 目录，发现所有 .js / .mjs 文件，动态加载为 Tool 实例。
  * 使用原生 dynamic import() 加载（在 "type": "module" 下 .js 也是 ESM），

package/dist/types/index.d.ts

@@ -88,9 +88,9 @@ export interface AppConfig {
     maxToolOutput?: number;
 }
 /**
- * 工具环境 — Provider 在实例化内置工具时注入的环境信息。
+ * 工具环境 — Scope 的能力插件在实例化内置工具时注入的环境信息。
  *
- * cwd 是相对路径解析的基准（每个 Provider 对应一个工作目录）；
+ * cwd 是相对路径解析的基准（每个 Scope 对应一个工作目录）；
  * config 供需要模型/端点配置的工具（如 generateImage）使用。
  */
 export interface ToolEnv {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-zen/agents-sdk",
-  "version": "0.12.0",
+  "version": "1.0.0-alpha.0",
   "description": "AI-Zen Agents SDK — shared business logic for CLI and Desktop",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -16,10 +16,10 @@
   "author": "LZQCN",
   "license": "MIT",
   "dependencies": {
-    "@ai-zen/agents-core": "^4.3.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "dayjs": "^1.11.21",
-    "openai": "^7.5.0"
+    "openai": "^7.5.0",
+    "@ai-zen/agents-core": "^4.3.0"
   },
   "devDependencies": {
     "@types/node": "^24.12.2",

package/dist/runtime/Provider.d.ts

@@ -1,119 +0,0 @@
-import type { Tool } from "@ai-zen/agents-core";
-import type { AppConfig, AgentDefinition, McpServerConfig, ToolEnv } from "../types/index.js";
-import type { SkillInfo } from "../capabilities/discovery/skills.js";
-import { McpConnectionManager } from "./McpConnectionManager.js";
-/**
- * 能力过滤系统的公共类型。
- * FilterOutput 由 filter() 产出，由 instantiate() 消费。
- */
-export interface FilterOutput {
-    tools: string[];
-    subagents: string[];
-    skills: string[];
-    mcps: string[];
-}
-/**
- * 排除项黑名单（优先级高于 permissions）。
- * 与 permissions 四维对称，用于安全预过滤。
- */
-export interface ExcludeOptions {
-    tools?: string[];
-    skills?: string[];
-    mcps?: string[];
-    subagents?: string[];
-}
-/** filter / buildTools 的过滤选项 */
-export interface FilterOptions {
-    /** 排除项黑名单（优先级高于 permissions） */
-    exclude?: ExcludeOptions;
-}
-/**
- * Provider — 全局上下文实例 + 能力注册表。
- *
- * Provider 是 SDK 的全局单例（按需创建），持有：
- *   - 应用配置（端点、模型等）
- *   - 文件系统路径（Agent 目录、Skill 目录等）
- *   - 全局能力注册表（内置工具、用户工具、SubAgent、Skill、MCP）
- *   - MCP 连接管理器
- *
- * 创建方式：
- * ```ts
- * // 推荐：一步完成构造 + 能力发现
- * const provider = await Provider.create({ ... });
- *
- * // 仅构造（能力需后续加载）
- * const provider = new Provider({ ... });
- * await provider.init();
- * ```
- *
- * 设计原则：
- *   - Provider 实例一旦创建不可变（路径、配置等不变），refresh 时重新发现能力
- *   - 各层不直接 import 散装函数，而是通过 Provider 实例获取
- */
-export declare class Provider {
-    /** 应用配置（端点、模型等） */
-    readonly config: AppConfig;
-    /** 当前工作目录 — 相对路径解析基准，也是 ToolEnv.cwd 的来源 */
-    readonly cwd: string;
-    /** 工具环境 — 实例化内置工具时注入 */
-    readonly env: ToolEnv;
-    readonly agentsDir: string;
-    readonly subAgentsPaths: string[];
-    readonly skillsPaths: string[];
-    readonly toolsPaths: string[];
-    readonly mcpPaths: string[];
-    builtinTools: Tool[];
-    userTools: Tool[];
-    subagents: AgentDefinition[];
-    /** 完整 SkillInfo，含 subAgent 标记，可据此区分枚举 */
-    skills: SkillInfo[];
-    /** 完整 MCP 服务器配置 */
-    mcps: McpServerConfig[];
-    readonly mcpManager: McpConnectionManager | undefined;
-    constructor(options: {
-        config: AppConfig;
-        agentsDir: string;
-        subAgentsPaths?: string[];
-        skillsPaths?: string[];
-        toolsPaths?: string[];
-        mcpPaths?: string[];
-        /** 当前工作目录，默认 process.cwd() */
-        cwd?: string;
-    });
-    /**
-     * 异步创建 Provider，一步完成构造 + 全局能力发现。
-     */
-    static create(options: {
-        config: AppConfig;
-        agentsDir: string;
-        subAgentsPaths?: string[];
-        skillsPaths?: string[];
-        toolsPaths?: string[];
-        mcpPaths?: string[];
-        /** 当前工作目录，默认 process.cwd() */
-        cwd?: string;
-    }): Promise<Provider>;
-    /**
-     * 初始化：执行全局能力发现。
-     */
-    init(): Promise<void>;
-    /**
-     * 按权限过滤候选集，返回过滤后的名称列表。
-     * 纯名称操作（安全预过滤 + 权限过滤），不涉及 Tool 实例化。
-     */
-    filter(definition: AgentDefinition, options?: FilterOptions): FilterOutput;
-    /**
-     * 快捷方法：filter + instantiate 一步完成。
-     */
-    buildTools(definition: AgentDefinition, options?: FilterOptions): Tool[];
-    /**
-     * 将过滤后的名称列表实例化为 Tool 数组。
-     */
-    instantiate(filtered: FilterOutput): Tool[];
-    /**
-     * 重新执行全局发现（重新扫描文件系统）。
-     */
-    refresh(options?: {
-        silent?: boolean;
-    }): Promise<void>;
-}

package/dist/runtime/Provider.js

@@ -1,218 +0,0 @@
-import { McpConnectionManager } from "./McpConnectionManager.js";
-import { PermissionEvaluator } from "../capabilities/PermissionEvaluator.js";
-import { createLoadSkillTool, createCallSkillSubAgentTool } from "../capabilities/implements/skillTools.js";
-import { createLoadMcpTool, createCallMcpTool, createReadMcpResourceTool } from "../capabilities/implements/mcpTools.js";
-import { createSubAgentTool } from "../capabilities/implements/subAgentTools.js";
-import { discoverBuiltinTools } from "../capabilities/discovery/builtin.js";
-import { discoverSubAgents } from "../capabilities/discovery/subagents.js";
-import { discoverSkills } from "../capabilities/discovery/skills.js";
-import { discoverMcpServers } from "../capabilities/discovery/mcp.js";
-import { discoverUserTools } from "../capabilities/discovery/usertools.js";
-/**
- * Provider — 全局上下文实例 + 能力注册表。
- *
- * Provider 是 SDK 的全局单例（按需创建），持有：
- *   - 应用配置（端点、模型等）
- *   - 文件系统路径（Agent 目录、Skill 目录等）
- *   - 全局能力注册表（内置工具、用户工具、SubAgent、Skill、MCP）
- *   - MCP 连接管理器
- *
- * 创建方式：
- * ```ts
- * // 推荐：一步完成构造 + 能力发现
- * const provider = await Provider.create({ ... });
- *
- * // 仅构造（能力需后续加载）
- * const provider = new Provider({ ... });
- * await provider.init();
- * ```
- *
- * 设计原则：
- *   - Provider 实例一旦创建不可变（路径、配置等不变），refresh 时重新发现能力
- *   - 各层不直接 import 散装函数，而是通过 Provider 实例获取
- */
-export class Provider {
-    /** 应用配置（端点、模型等） */
-    config;
-    /** 当前工作目录 — 相对路径解析基准，也是 ToolEnv.cwd 的来源 */
-    cwd;
-    /** 工具环境 — 实例化内置工具时注入 */
-    env;
-    // ---- 路径 ----
-    agentsDir;
-    subAgentsPaths;
-    skillsPaths;
-    toolsPaths;
-    mcpPaths;
-    // ---- 全局候选集（发现一次，全局复用）----
-    builtinTools;
-    userTools;
-    subagents;
-    /** 完整 SkillInfo，含 subAgent 标记，可据此区分枚举 */
-    skills;
-    /** 完整 MCP 服务器配置 */
-    mcps;
-    // ---- MCP ----
-    mcpManager;
-    constructor(options) {
-        this.config = options.config;
-        this.cwd = options.cwd ?? process.cwd();
-        this.env = { cwd: this.cwd, config: this.config };
-        this.agentsDir = options.agentsDir;
-        this.subAgentsPaths = options.subAgentsPaths ?? [];
-        this.skillsPaths = options.skillsPaths ?? [];
-        this.toolsPaths = options.toolsPaths ?? [];
-        this.mcpPaths = options.mcpPaths ?? [];
-        this.builtinTools = [];
-        this.userTools = [];
-        this.subagents = [];
-        this.skills = [];
-        this.mcps = [];
-        this.mcpManager = this.mcpPaths.length > 0 ? new McpConnectionManager() : undefined;
-    }
-    /**
-     * 异步创建 Provider，一步完成构造 + 全局能力发现。
-     */
-    static async create(options) {
-        const provider = new Provider(options);
-        await provider.init();
-        return provider;
-    }
-    /**
-     * 初始化：执行全局能力发现。
-     */
-    async init() {
-        await this.refresh();
-    }
-    // ==================================================================
-    // 能力过滤与实例化
-    // ==================================================================
-    /**
-     * 按权限过滤候选集，返回过滤后的名称列表。
-     * 纯名称操作（安全预过滤 + 权限过滤），不涉及 Tool 实例化。
-     */
-    filter(definition, options) {
-        const exclude = options?.exclude ?? {};
-        const excludeTools = new Set(exclude.tools ?? []);
-        const excludeSkills = new Set(exclude.skills ?? []);
-        const excludeMcps = new Set(exclude.mcps ?? []);
-        const excludeSubAgents = new Set(exclude.subagents ?? []);
-        const safeSubagents = excludeSubAgents.size === 0
-            ? this.subagents
-            : this.subagents.filter((def) => !excludeSubAgents.has(def.function?.name ?? ""));
-        const DYNAMIC_TOOL_NAMES = [
-            "load_skill",
-            "call_skill_sub_agent",
-            "load_mcp",
-            "call_mcp_tool",
-            "read_mcp_resource",
-        ];
-        const toolNames = [
-            ...this.builtinTools.map((t) => t.function.name),
-            ...this.userTools.map((t) => t.function.name),
-            ...DYNAMIC_TOOL_NAMES,
-        ].filter((name) => !excludeTools.has(name));
-        // 工具可用性过滤：调用候选工具的 isAvailable（直接透传完整 app config + agent definition）。
-        // 工具自行声明可用条件（如依赖图片模型配置、仅视觉模型可用），返回 false 则剔除。
-        const candidates = [...this.builtinTools, ...this.userTools];
-        for (let i = toolNames.length - 1; i >= 0; i--) {
-            const tool = candidates.find((t) => t.function.name === toolNames[i]);
-            const isAvailable = tool?.isAvailable;
-            if (isAvailable && !isAvailable(this.config, definition)) {
-                toolNames.splice(i, 1);
-            }
-        }
-        const evaluator = new PermissionEvaluator(definition.permissions);
-        const filtered = evaluator.filter({
-            tools: toolNames,
-            skills: this.skills
-                .filter((s) => !excludeSkills.has(s.id))
-                .map((s) => s.id),
-            mcps: this.mcps
-                .filter((m) => !excludeMcps.has(m.id))
-                .map((m) => m.id),
-            subagents: safeSubagents.map((d) => d.function.name),
-        });
-        return {
-            tools: filtered.tools,
-            subagents: filtered.subagents,
-            skills: filtered.skills,
-            mcps: filtered.mcps,
-        };
-    }
-    /**
-     * 快捷方法：filter + instantiate 一步完成。
-     */
-    buildTools(definition, options) {
-        return this.instantiate(this.filter(definition, options));
-    }
-    /**
-     * 将过滤后的名称列表实例化为 Tool 数组。
-     */
-    instantiate(filtered) {
-        const result = [];
-        const allowedToolNames = new Set(filtered.tools);
-        // 1. 内置 + 用户工具
-        for (const t of [...this.builtinTools, ...this.userTools]) {
-            if (allowedToolNames.has(t.function.name)) {
-                result.push(t);
-            }
-        }
-        // 2. 筛选候选项（保留完整信息，传给工具函数自行决定如何构建枚举）
-        const allowedSkillSet = new Set(filtered.skills);
-        const allowedMcpSet = new Set(filtered.mcps);
-        const filteredSkills = this.skills.filter((s) => allowedSkillSet.has(s.id));
-        const filteredMcps = this.mcps.filter((m) => allowedMcpSet.has(m.id));
-        // 3. 动态工具
-        if (allowedToolNames.has("load_skill") && filteredSkills.length > 0) {
-            result.push(createLoadSkillTool(this.skillsPaths, filteredSkills));
-        }
-        // call_skill_sub_agent：只要有支持子 Agent 的 skill 就注册
-        const hasSubAgentSkills = filteredSkills.some((s) => s.subAgent);
-        if (allowedToolNames.has("call_skill_sub_agent") && hasSubAgentSkills) {
-            result.push(createCallSkillSubAgentTool(this.skillsPaths, filteredSkills));
-        }
-        const mcpManager = this.mcpManager;
-        if (allowedToolNames.has("load_mcp") && mcpManager && filteredMcps.length > 0) {
-            result.push(createLoadMcpTool(mcpManager, filteredMcps));
-        }
-        if (allowedToolNames.has("call_mcp_tool") && mcpManager) {
-            result.push(createCallMcpTool(mcpManager));
-        }
-        if (allowedToolNames.has("read_mcp_resource") && mcpManager) {
-            result.push(createReadMcpResourceTool(mcpManager));
-        }
-        // 4. SubAgent
-        const allowedSubagentSet = new Set(filtered.subagents);
-        for (const def of this.subagents) {
-            if (!def.function || !allowedSubagentSet.has(def.function.name))
-                continue;
-            result.push(createSubAgentTool(def, this));
-        }
-        // 5. 去重
-        return dedupTools(result);
-    }
-    /**
-     * 重新执行全局发现（重新扫描文件系统）。
-     */
-    async refresh(options) {
-        const silent = options?.silent ?? false;
-        this.builtinTools = discoverBuiltinTools(this.env);
-        this.userTools = await discoverUserTools(this.toolsPaths, { silent });
-        this.subagents = await discoverSubAgents(this.subAgentsPaths);
-        this.skills = await discoverSkills(this.skillsPaths, { silent });
-        this.mcps = await discoverMcpServers(this.mcpPaths);
-    }
-}
-function dedupTools(tools) {
-    const seen = new Set();
-    const result = [];
-    for (let i = tools.length - 1; i >= 0; i--) {
-        const name = tools[i].function.name;
-        if (!seen.has(name)) {
-            seen.add(name);
-            result.unshift(tools[i]);
-        }
-    }
-    return result;
-}