@zhin.js/core 1.0.25 → 1.0.26

package/lib/built/tool.js

@@ -1,7 +1,8 @@
 /**
- * Tool Service
- * 统一的工具管理服务，支持 Tool ↔ Command 互转
+ * ToolFeature — 统一的工具管理服务
+ * 支持 Tool ↔ Command 互转
  */
+import { Feature } from "../feature.js";
 import { MessageCommand } from "../command.js";
 import { getPlugin } from "../plugin.js";
 // ============================================================================
@@ -125,59 +126,13 @@ export function extractParamInfo(parameters) {
 }
 /**
  * 定义工具的辅助函数（提供类型推断）
- *
- * 使用泛型参数获得 execute 函数的类型检查，
- * 返回通用的 Tool 类型，可直接传给 addTool
- *
- * @example
- * ```typescript
- * const myTool = defineTool<{ name: string }>({
- *   name: 'greet',
- *   description: '打招呼',
- *   parameters: {
- *     type: 'object',
- *     properties: {
- *       name: { type: 'string', description: '名字' }
- *     },
- *     required: ['name']
- *   },
- *   execute: async (args) => {
- *     return `你好，${args.name}！`;  // args.name 有类型提示
- *   }
- * });
- *
- * plugin.addTool(myTool);  // 无需类型断言
- * ```
  */
 export function defineTool(tool) {
-    // ToolDefinition<TArgs> 兼容 Tool，因为 execute 参数是协变的
     return tool;
 }
 /**
  * ZhinTool 类
  * 提供类似 MessageCommand 的链式调用风格来定义工具
- *
- * @example
- * ```typescript
- * const weatherTool = new ZhinTool('weather')
- *   .desc('查询天气信息')
- *   .param('city', { type: 'string', description: '城市名称' }, true)
- *   .param('days', { type: 'number', description: '预报天数' })
- *   .platform('qq', 'telegram')
- *   .scope('group', 'private')
- *   .permission('user')
- *   // AI 调用时执行（必须）
- *   .execute(async (args, ctx) => {
- *     return `${args.city} 的天气是晴天`;
- *   })
- *   // 可选：命令回调（与 MessageCommand.action 一致）
- *   // 如果定义了此回调，会生成 Command
- *   .action(async (message, result) => {
- *     return `命令执行: ${result.params.city}`;
- *   });
- *
- * plugin.addTool(weatherTool);
- * ```
  */
 export class ZhinTool {
     #name;
@@ -190,47 +145,30 @@ export class ZhinTool {
     #permissionLevel = 'user';
     #permissions = [];
     #tags = [];
+    #keywords = [];
     /** 命令回调（入参是 message, matchResult） */
     #commandCallback;
     /** 命令配置 */
     #commandConfig = {};
     #hidden = false;
     #source;
-    /**
-     * 创建工具实例
-     * @param name 工具名称（唯一标识，建议使用 snake_case）
-     */
     constructor(name) {
         this.#name = name;
     }
-    /** 获取工具名称 */
     get name() {
         return this.#name;
     }
-    /** 获取工具描述 */
     get description() {
         return this.#description;
     }
-    /** 获取有序的参数列表 */
     get params() {
         return [...this.#params];
     }
-    /**
-     * 设置工具描述
-     * @param description 工具描述（供 AI 和帮助系统使用）
-     */
     desc(description) {
         this.#description = description;
         return this;
     }
-    /**
-     * 添加参数（按调用顺序保持有序）
-     * @param name 参数名称
-     * @param schema 参数 Schema（类型、描述等）
-     * @param required 是否必填（默认 false）
-     */
     param(name, schema, required = false) {
-        // 如果已存在同名参数，更新它
         const existingIndex = this.#params.findIndex(p => p.name === name);
         if (existingIndex >= 0) {
             this.#params[existingIndex] = { name, schema, required };
@@ -240,112 +178,61 @@ export class ZhinTool {
         }
         return this;
     }
-    /**
-     * 设置支持的平台
-     * @param platforms 平台名称列表（如 'qq', 'telegram'）
-     */
     platform(...platforms) {
         this.#platforms.push(...platforms);
         return this;
     }
-    /**
-     * 设置支持的场景
-     * @param scopes 场景类型列表（'private', 'group', 'channel'）
-     */
     scope(...scopes) {
         this.#scopes.push(...scopes);
         return this;
     }
-    /**
-     * 设置权限级别
-     * @param level 权限级别（'user', 'group_admin', 'group_owner', 'bot_admin', 'owner'）
-     */
     permission(level) {
         this.#permissionLevel = level;
         return this;
     }
-    /**
-     * 添加旧版权限要求（兼容 MessageCommand）
-     * @param permissions 权限字符串列表
-     */
     permit(...permissions) {
         this.#permissions.push(...permissions);
         return this;
     }
-    /**
-     * 添加标签
-     * @param tags 标签列表
-     */
     tag(...tags) {
         this.#tags.push(...tags);
         return this;
     }
-    /**
-     * 设置是否隐藏
-     * @param value 是否隐藏（默认 true）
-     */
+    keyword(...keywords) {
+        this.#keywords.push(...keywords);
+        return this;
+    }
     hidden(value = true) {
         this.#hidden = value;
         return this;
     }
-    /**
-     * 设置使用说明（命令配置）
-     * @param usage 使用说明列表
-     */
     usage(...usage) {
         this.#commandConfig.usage = [...(this.#commandConfig.usage || []), ...usage];
         return this;
     }
-    /**
-     * 设置示例（命令配置）
-     * @param examples 示例列表
-     */
     examples(...examples) {
         this.#commandConfig.examples = [...(this.#commandConfig.examples || []), ...examples];
         return this;
     }
-    /**
-     * 设置别名（命令配置）
-     * @param alias 别名列表
-     */
     alias(...alias) {
         this.#commandConfig.alias = [...(this.#commandConfig.alias || []), ...alias];
         return this;
     }
-    /**
-     * 设置自定义命令模式
-     * @param pattern 命令模式（如 'weather <city> [days]'）
-     */
     pattern(pattern) {
         this.#commandConfig.pattern = pattern;
         return this;
     }
-    /**
-     * 设置 AI 工具执行函数
-     * @param callback 执行回调，入参是 (args, context)
-     */
     execute(callback) {
         this.#execute = callback;
         return this;
     }
-    /**
-     * 设置命令回调（可选，与 MessageCommand.action 一致）
-     * 如果定义了此回调，会自动生成 Command
-     * 入参是 (message, matchResult)
-     *
-     * @param callback 命令回调
-     */
     action(callback) {
         this.#commandCallback = callback;
         return this;
     }
-    /**
-     * 构建有序的 ToolParametersSchema
-     */
     #buildParameters() {
         const properties = {};
         const required = [];
-        // 按顺序构建（必填参数排前面）
         const sortedParams = [...this.#params].sort((a, b) => {
             if (a.required && !b.required)
                 return -1;
@@ -365,15 +252,11 @@ export class ZhinTool {
             required: required.length > 0 ? required : undefined,
         };
     }
-    /**
-     * 生成命令模式字符串
-     */
     #generatePattern() {
         if (this.#commandConfig.pattern) {
             return this.#commandConfig.pattern;
         }
         const parts = [this.#name];
-        // 按顺序生成参数（必填在前，可选在后）
         const sortedParams = [...this.#params].sort((a, b) => {
             if (a.required && !b.required)
                 return -1;
@@ -392,9 +275,6 @@ export class ZhinTool {
         }
         return parts.join(' ');
     }
-    /**
-     * 转换为 Tool 对象
-     */
     toTool() {
         if (!this.#execute) {
             throw new Error(`Tool "${this.#name}" has no execute() defined`);
@@ -405,7 +285,6 @@ export class ZhinTool {
             parameters: this.#buildParameters(),
             execute: this.#execute,
         };
-        // 添加可选字段
         if (this.#platforms.length > 0)
             tool.platforms = this.#platforms;
         if (this.#scopes.length > 0)
@@ -420,7 +299,8 @@ export class ZhinTool {
             tool.hidden = this.#hidden;
         if (this.#source)
             tool.source = this.#source;
-        // 命令配置：如果没有定义 command 回调，则不生成命令
+        if (this.#keywords.length > 0)
+            tool.keywords = this.#keywords;
         if (!this.#commandCallback) {
             tool.command = false;
         }
@@ -433,23 +313,15 @@ export class ZhinTool {
         }
         return tool;
     }
-    /**
-     * 获取 action 回调（命令回调，如果有）
-     */
     getActionCallback() {
         return this.#commandCallback;
     }
-    /**
-     * 转换为 JSON 格式（供 AI 使用，不包含 execute 函数）
-     * 符合 OpenAI Function Calling 规范
-     */
     toJSON() {
         const json = {
             name: this.#name,
             description: this.#description,
             parameters: this.#buildParameters(),
         };
-        // 添加可选字段
         if (this.#platforms.length > 0)
             json.platforms = this.#platforms;
         if (this.#scopes.length > 0)
@@ -460,14 +332,10 @@ export class ZhinTool {
             json.tags = this.#tags;
         return json;
     }
-    /**
-     * 输出帮助信息（类似 MessageCommand）
-     */
     get help() {
         const lines = [this.#generatePattern()];
         if (this.#description)
             lines.push(`  ${this.#description}`);
-        // 参数信息（按顺序）
         if (this.#params.length > 0) {
             lines.push('  参数:');
             for (const param of this.#params) {
@@ -476,26 +344,21 @@ export class ZhinTool {
                 lines.push(`    ${param.name}: ${param.schema.type} ${required} ${desc}`);
             }
         }
-        // 权限信息
         if (this.#permissionLevel !== 'user') {
             lines.push(`  权限: ${this.#permissionLevel}`);
         }
-        // 平台限制
         if (this.#platforms.length > 0) {
             lines.push(`  平台: ${this.#platforms.join(', ')}`);
         }
-        // 场景限制
         if (this.#scopes.length > 0) {
             lines.push(`  场景: ${this.#scopes.join(', ')}`);
         }
-        // 命令说明
         if (this.#commandConfig.usage?.length) {
             lines.push('  用法:');
             for (const u of this.#commandConfig.usage) {
                 lines.push(`    ${u}`);
             }
         }
-        // 命令示例
         if (this.#commandConfig.examples?.length) {
             lines.push('  示例:');
             for (const e of this.#commandConfig.examples) {
@@ -504,41 +367,33 @@ export class ZhinTool {
         }
         return lines.join('\n');
     }
-    /**
-     * 输出简短信息
-     */
     toString() {
         return `[ZhinTool: ${this.#name}] ${this.#description}`;
     }
 }
-// 为了兼容 addTool，让 ZhinTool 可以隐式转换为 Tool
-// 通过在 ToolService 中检查是否是 ZhinTool 实例
 export function isZhinTool(obj) {
     return obj instanceof ZhinTool;
 }
+// ============================================================================
+// 内部工具函数
+// ============================================================================
 /**
  * 将 Tool 转换为 MessageCommand
  */
 function toolToCommand(tool) {
     const pattern = generatePattern(tool);
     const command = new MessageCommand(pattern);
-    // 设置描述
     command.desc(tool.description);
-    // 设置使用说明
     if (tool.command && tool.command.usage) {
         command.usage(...tool.command.usage);
     }
-    // 设置示例
     if (tool.command && tool.command.examples) {
         command.examples(...tool.command.examples);
     }
-    // 设置权限
     if (tool.permissions?.length) {
         command.permit(...tool.permissions);
     }
-    // 设置执行回调
     command.action(async (message, result) => {
-        // 构建工具上下文
         const context = {
             platform: message.$adapter,
             botId: message.$bot,
@@ -546,18 +401,15 @@ function toolToCommand(tool) {
             senderId: message.$sender.id,
             message,
         };
-        // 从 MatchResult 提取参数
         const args = extractArgsFromMatchResult(result, tool.parameters);
         try {
             const response = await tool.execute(args, context);
-            // 处理返回值
             if (response === undefined || response === null) {
                 return undefined;
             }
             if (typeof response === 'string') {
                 return response;
             }
-            // 对象类型，格式化输出
             return formatToolResult(response);
         }
         catch (error) {
@@ -570,9 +422,8 @@ function toolToCommand(tool) {
 /**
  * 将 MessageCommand 转换为 Tool
  */
-function commandToTool(command, pluginName) {
+function commandToToolFn(command, pluginName) {
     const { pattern, helpInfo } = command;
-    // 解析命令模式，提取参数
     const parameters = parseCommandPattern(pattern);
     return {
         name: `cmd_${pattern.split(' ')[0].replace(/[^a-zA-Z0-9_]/g, '_')}`,
@@ -581,7 +432,6 @@ function commandToTool(command, pluginName) {
         source: `command:${pluginName}`,
         tags: ['command', pluginName],
         execute: async (args, context) => {
-            // 重建命令字符串
             const cmdParts = [pattern.split(' ')[0]];
             if (parameters.properties) {
                 for (const [key, schema] of Object.entries(parameters.properties)) {
@@ -591,9 +441,7 @@ function commandToTool(command, pluginName) {
                 }
             }
             const cmdString = cmdParts.join(' ');
-            // 如果有消息上下文，模拟命令执行
             if (context?.message) {
-                // 创建一个临时消息副本，修改内容为命令字符串
                 const tempMessage = Object.create(context.message);
                 tempMessage.$content = cmdString;
                 const plugin = getPlugin();
@@ -605,7 +453,7 @@ function commandToTool(command, pluginName) {
                 command: cmdString
             };
         },
-        command: false, // 不再生成命令（已经是命令了）
+        command: false,
     };
 }
 /**
@@ -613,11 +461,9 @@ function commandToTool(command, pluginName) {
  */
 function extractArgsFromMatchResult(result, schema) {
     const args = {};
-    // params 包含所有提取的参数
     if (result.params) {
         Object.assign(args, result.params);
     }
-    // 类型转换
     if (schema.properties) {
         for (const [key, prop] of Object.entries(schema.properties)) {
             if (args[key] !== undefined) {
@@ -637,12 +483,10 @@ function extractArgsFromMatchResult(result, schema) {
 }
 /**
  * 解析命令模式，生成参数 Schema
- * @example 'weather <city> [days:number]' => { properties: { city: {...}, days: {...} }, required: ['city'] }
  */
 function parseCommandPattern(pattern) {
     const properties = {};
     const required = [];
-    // 匹配 <name:type> 或 [name:type] 格式
     const paramRegex = /([<\[])(\w+)(?::(\w+))?([>\]])/g;
     let match;
     while ((match = paramRegex.exec(pattern)) !== null) {
@@ -676,7 +520,6 @@ function formatToolResult(result) {
     if (result.error) {
         return `❌ ${result.error}`;
     }
-    // 尝试友好格式化
     try {
         return JSON.stringify(result, null, 2);
     }
@@ -684,151 +527,223 @@ function formatToolResult(result) {
         return String(result);
     }
 }
-/**
- * 创建工具服务 Context
- */
-export function createToolService() {
-    const tools = new Map();
-    const toolCommands = new Map();
-    const toolPluginMap = new Map();
-    const value = {
-        tools,
-        toolCommands,
-        add(toolInput, pluginName, generateCommand = true) {
-            // 保存原始 ZhinTool 引用（用于获取命令回调）
-            const zhinTool = isZhinTool(toolInput) ? toolInput : null;
-            // 转换为 Tool 对象
-            const tool = zhinTool ? zhinTool.toTool() : toolInput;
-            // 自动添加来源标识
-            const toolWithSource = {
-                ...tool,
-                source: tool.source || `plugin:${pluginName}`,
-                tags: [...(tool.tags || []), 'plugin', pluginName],
-            };
-            tools.set(tool.name, toolWithSource);
-            toolPluginMap.set(tool.name, pluginName);
-            // 生成对应的命令
-            // 只有当 tool.command !== false 且 generateCommand 为 true 时才生成
-            if (generateCommand && tool.command !== false) {
-                let command;
-                // 如果是 ZhinTool 且有自定义 action 回调，使用自定义回调
-                const customCallback = zhinTool?.getActionCallback();
-                if (customCallback) {
-                    // 使用自定义回调创建命令
-                    command = new MessageCommand(tool.command && typeof tool.command === 'object' && tool.command.pattern
-                        ? tool.command.pattern
-                        : generatePattern(toolWithSource));
-                    command.desc(tool.description);
-                    if (tool.command && typeof tool.command === 'object') {
-                        if (tool.command.usage)
-                            command.usage(...tool.command.usage);
-                        if (tool.command.examples)
-                            command.examples(...tool.command.examples);
-                    }
-                    if (tool.permissions?.length) {
-                        command.permit(...tool.permissions);
-                    }
-                    // 使用自定义回调
-                    command.action(customCallback);
-                }
-                else {
-                    // 使用默认的 toolToCommand（基于 tool.execute）
-                    command = toolToCommand(toolWithSource);
+// ============================================================================
+// ToolFeature 实现
+// ============================================================================
+export class ToolFeature extends Feature {
+    name = 'tool';
+    icon = 'Wrench';
+    desc = '工具';
+    /** 按名称索引 */
+    byName = new Map();
+    /** 工具对应的命令 */
+    toolCommands = new Map();
+    /** 工具到插件名的映射 */
+    #toolPluginMap = new Map();
+    /**
+     * 添加工具
+     * @param toolInput 工具或 ZhinTool 实例
+     * @param pluginName 注册插件名
+     * @param generateCommand 是否生成命令（默认 true）
+     */
+    addTool(toolInput, pluginName, generateCommand = true) {
+        const zhinTool = isZhinTool(toolInput) ? toolInput : null;
+        const tool = zhinTool ? zhinTool.toTool() : toolInput;
+        const toolWithSource = {
+            ...tool,
+            source: tool.source || `plugin:${pluginName}`,
+            tags: [...(tool.tags || []), 'plugin', pluginName],
+        };
+        this.byName.set(tool.name, toolWithSource);
+        this.#toolPluginMap.set(tool.name, pluginName);
+        // 生成对应的命令
+        if (generateCommand && tool.command !== false) {
+            let command;
+            const customCallback = zhinTool?.getActionCallback();
+            if (customCallback) {
+                command = new MessageCommand(tool.command && typeof tool.command === 'object' && tool.command.pattern
+                    ? tool.command.pattern
+                    : generatePattern(toolWithSource));
+                command.desc(tool.description);
+                if (tool.command && typeof tool.command === 'object') {
+                    if (tool.command.usage)
+                        command.usage(...tool.command.usage);
+                    if (tool.command.examples)
+                        command.examples(...tool.command.examples);
                 }
-                toolCommands.set(tool.name, command);
-                // 注册到命令服务
-                const plugin = getPlugin();
-                const commandService = plugin.root.inject('command');
-                if (commandService) {
-                    commandService.add(command, pluginName);
+                if (tool.permissions?.length) {
+                    command.permit(...tool.permissions);
                 }
+                command.action(customCallback);
             }
-            return () => value.remove(tool.name);
-        },
-        remove(name) {
-            const existed = tools.has(name);
-            tools.delete(name);
-            toolPluginMap.delete(name);
-            // 移除对应的命令
-            const command = toolCommands.get(name);
-            if (command) {
-                const plugin = getPlugin();
-                const commandService = plugin.root.inject('command');
-                if (commandService) {
-                    commandService.remove(command);
-                }
-                toolCommands.delete(name);
+            else {
+                command = toolToCommand(toolWithSource);
             }
-            return existed;
-        },
-        get(name) {
-            return tools.get(name);
-        },
-        getAll() {
-            return Array.from(tools.values());
-        },
-        getByTags(tags) {
-            return Array.from(tools.values()).filter(tool => tags.some(tag => tool.tags?.includes(tag)));
-        },
-        async execute(name, args, context) {
-            const tool = tools.get(name);
-            if (!tool) {
-                throw new Error(`Tool "${name}" not found`);
+            this.toolCommands.set(tool.name, command);
+            const plugin = getPlugin();
+            const commandService = plugin.root.inject('command');
+            if (commandService) {
+                commandService.add(command, pluginName);
             }
-            return tool.execute(args, context);
-        },
-        commandToTool,
-        collectAll(plugin) {
-            const allTools = [];
-            // 1. 收集 ToolService 中的所有工具
-            allTools.push(...value.getAll());
-            // 2. 收集 Command 并转换为 Tool
+        }
+        // Use Feature.add for item tracking
+        const baseDispose = super.add(toolWithSource, pluginName);
+        return () => {
+            this.removeTool(tool.name);
+            baseDispose();
+        };
+    }
+    /**
+     * 移除工具
+     */
+    removeTool(name) {
+        const tool = this.byName.get(name);
+        if (!tool)
+            return false;
+        this.byName.delete(name);
+        this.#toolPluginMap.delete(name);
+        // 移除对应的命令
+        const command = this.toolCommands.get(name);
+        if (command) {
+            const plugin = getPlugin();
             const commandService = plugin.root.inject('command');
             if (commandService) {
-                for (const command of commandService.items) {
-                    // 跳过已经由 Tool 生成的命令
-                    const isFromTool = Array.from(toolCommands.values()).includes(command);
-                    if (!isFromTool) {
-                        const toolFromCmd = commandToTool(command, 'command');
-                        allTools.push(toolFromCmd);
-                    }
-                }
+                commandService.remove(command);
             }
-            // 3. 收集适配器提供的工具
-            for (const [name, context] of plugin.root.contexts) {
-                const adapterValue = context.value;
-                if (adapterValue && typeof adapterValue === 'object' && 'getTools' in adapterValue) {
-                    const adapter = adapterValue;
-                    allTools.push(...adapter.getTools());
+            this.toolCommands.delete(name);
+        }
+        // 移除 item
+        super.remove(tool);
+        return true;
+    }
+    /**
+     * 获取工具
+     */
+    get(name) {
+        return this.byName.get(name);
+    }
+    /**
+     * 获取所有工具
+     */
+    getAll() {
+        return [...this.items];
+    }
+    /**
+     * 根据标签过滤工具
+     */
+    getByTags(tags) {
+        return this.items.filter(tool => tags.some(tag => tool.tags?.includes(tag)));
+    }
+    /**
+     * 执行工具
+     */
+    async execute(name, args, context) {
+        const tool = this.byName.get(name);
+        if (!tool) {
+            throw new Error(`Tool "${name}" not found`);
+        }
+        return tool.execute(args, context);
+    }
+    /**
+     * 将 Command 转换为 Tool
+     */
+    commandToTool(command, pluginName) {
+        return commandToToolFn(command, pluginName);
+    }
+    /**
+     * 收集所有可用工具（包括从 Command 转换的）
+     */
+    collectAll(plugin) {
+        const allTools = [];
+        allTools.push(...this.getAll());
+        const commandService = plugin.root.inject('command');
+        if (commandService) {
+            for (const command of commandService.items) {
+                const isFromTool = Array.from(this.toolCommands.values()).includes(command);
+                if (!isFromTool) {
+                    const toolFromCmd = commandToToolFn(command, 'command');
+                    allTools.push(toolFromCmd);
                 }
             }
-            return allTools;
-        },
-        filterByContext(tools, context) {
-            return tools.filter(tool => canAccessTool(tool, context));
-        },
-    };
-    return {
-        name: 'tool',
-        description: '统一工具服务',
-        value,
-        extensions: {
+        }
+        for (const [name, context] of plugin.root.contexts) {
+            const adapterValue = context.value;
+            if (adapterValue && typeof adapterValue === 'object' && 'getTools' in adapterValue) {
+                const adapter = adapterValue;
+                allTools.push(...adapter.getTools());
+            }
+        }
+        return allTools;
+    }
+    /**
+     * 根据上下文过滤工具
+     */
+    filterByContext(tools, context) {
+        return tools.filter(tool => canAccessTool(tool, context));
+    }
+    /**
+     * 按插件名获取工具
+     */
+    getToolsByPlugin(pluginName) {
+        const result = [];
+        for (const [toolName, pName] of this.#toolPluginMap) {
+            if (pName === pluginName) {
+                const tool = this.byName.get(toolName);
+                if (tool)
+                    result.push(tool);
+            }
+        }
+        return result;
+    }
+    /**
+     * 兼容旧接口：tools Map
+     */
+    get tools() {
+        return this.byName;
+    }
+    /**
+     * 序列化为 JSON
+     */
+    toJSON(pluginName) {
+        const list = pluginName ? this.getByPlugin(pluginName) : this.items;
+        return {
+            name: this.name,
+            icon: this.icon,
+            desc: this.desc,
+            count: list.length,
+            items: list.map(t => ({
+                name: t.name,
+                desc: t.description,
+                platforms: t.platforms,
+                tags: t.tags,
+            })),
+        };
+    }
+    /**
+     * 提供给 Plugin.prototype 的扩展方法
+     */
+    get extensions() {
+        const feature = this;
+        return {
             addTool(tool) {
                 const plugin = getPlugin();
-                const dispose = value.add(tool, plugin.name, true);
+                const toolObj = isZhinTool(tool) ? tool.toTool() : tool;
+                const dispose = feature.addTool(tool, plugin.name, true);
+                plugin.recordFeatureContribution(feature.name, toolObj.name);
                 plugin.onDispose(dispose);
                 return dispose;
             },
             addToolOnly(tool) {
                 const plugin = getPlugin();
-                const dispose = value.add(tool, plugin.name, false);
+                const toolObj = isZhinTool(tool) ? tool.toTool() : tool;
+                const dispose = feature.addTool(tool, plugin.name, false);
+                plugin.recordFeatureContribution(feature.name, toolObj.name);
                 plugin.onDispose(dispose);
                 return dispose;
             },
-        },
-    };
+        };
+    }
 }
 // 导出类型和工具函数
-// 注意：ZhinTool, isZhinTool, ToolInput 已通过 export 关键字直接导出
-export { toolToCommand, commandToTool, canAccessTool, inferPermissionLevel, hasPermissionLevel, PERMISSION_LEVEL_PRIORITY, };
+export { toolToCommand, commandToToolFn as commandToTool, canAccessTool, inferPermissionLevel, hasPermissionLevel, PERMISSION_LEVEL_PRIORITY, };
 //# sourceMappingURL=tool.js.map