Tool Selection 是什么？

策略1: 全量注入 (Brute Force)
┌─────────────────────────────────┐
│  将所有工具定义注入 Prompt      │
│  "你有以下工具可用：..."        │
│  LLM 根据描述自行选择          │
└─────────────────────────────────┘
优点: 简单直接    缺点: 工具多了会撑爆上下文

策略2: 检索增强 (RAG-based)
┌─────────────────────────────────┐
│  1. 用户任务 → Embedding查询   │
│  2. 向量数据库检索相关工具     │
│  3. 只注入 Top-K 相关工具      │
└─────────────────────────────────┘
优点: 可扩展    缺点: 检索可能不准

策略3: 分层过滤 (Hierarchical)
┌─────────────────────────────────┐
│  1. 粗筛: 按类别过滤 (文件/网络/计算) │
│  2. 精筛: 按语义相似度排序     │
│  3. 最终: LLM 从候选中选择    │
└─────────────────────────────────┘
优点: 平衡性能和准确性    缺点: 实现复杂

# OpenClaw Skill 定义 (web-scraper.skill.yaml)
name: web-scraper
description: "抓取网页内容并提取结构化信息"
keywords: [scrape, extract, crawl, webpage, html]

# 工具定义
tools:
  - name: fetch_page
    description: "获取网页HTML内容"
    parameters:
      url:
        type: string
        description: "目标URL"
      timeout:
        type: number
        default: 30
        
  - name: extract_content
    description: "从HTML中提取结构化内容"
    parameters:
      html:
        type: string
        description: "HTML内容"
      selector:
        type: string
        description: "CSS选择器"

# 自动激活规则
activation:
  match_pattern: "抓取|爬取|提取.*网页"
  confidence_threshold: 0.7

# OpenClaw 配置：工具选择策略
agent:
  tool_selection:
    strategy: hierarchical  # hierarchical | rag | full
    
    # 分层策略配置
    hierarchical:
      categories:
        - name: web
          keywords: [url, http, webpage, scrape]
          tools: [fetch_page, extract_content, web_search]
        - name: file
          keywords: [file, read, write, save]
          tools: [read_file, write_file, list_dir]
        - name: compute
          keywords: [calculate, compute, math]
          tools: [eval_expr, run_python]
          
    # RAG策略配置
    rag:
      embedding_model: "text-embedding-3-small"
      top_k: 5
      similarity_threshold: 0.6
      
    # 全量注入（工具少时用）
    full:
      max_tools: 20  # 超过20个工具就切换策略

// tool-selector.js
import OpenAI from 'openai';
import { ChromaClient } from 'chromadb';

export class ToolSelector {
  constructor(tools) {
    this.tools = tools; // 所有可用工具
    this.openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
    this.chroma = new ChromaClient();
    this.collection = null;
    this._initialized = false;
  }
  
  async initialize() {
    if (this._initialized) return;
    
    // 1. 创建向量数据库集合
    this.collection = await this.chroma.createCollection({
      name: 'tools',
      metadata: { description: 'Tool descriptions for RAG' }
    });
    
    // 2. 将所有工具的描述向量化并存储
    for (const tool of this.tools) {
      const embedding = await this._getEmbedding(tool.description);
      await this.collection.add({
        ids: [tool.name],
        embeddings: [embedding],
        documents: [JSON.stringify(tool)],
        metadatas: [{ name: tool.name }]
      });
    }
    
    this._initialized = true;
  }
  
  // 根据任务查询相关工具
  async selectTools(task, k = 5) {
    await this.initialize();
    
    // 1. 将任务描述转为向量
    const taskEmbedding = await this._getEmbedding(task);
    
    // 2. 向量检索最相关的工具
    const results = await this.collection.query({
      queryEmbeddings: [taskEmbedding],
      nResults: k
    });
    
    // 3. 返回工具定义
    return results.documents[0].map(doc => JSON.parse(doc));
  }
  
  // 调用LLM进行最终选择（可选）
  async selectToolsWithLLM(task, context = '') {
    // 先检索候选工具
    const candidates = await this.selectTools(task, 10);
    
    // 用LLM进行精细选择
    const prompt = `
Task: ${task}
Context: ${context}

Available tools:
${candidates.map((t, i) => `${i + 1}. ${t.name}: ${t.description}`).join('\n')}

Based on the task, which tools are needed? Return a JSON array of tool names.
Only select tools that are directly relevant to completing the task.
`;
    
    const response = await this.openai.chat.completions.create({
      model: 'gpt-4-turbo-preview',
      messages: [{ role: 'user', content: prompt }],
      response_format: { type: 'json_object' }
    });
    
    const selectedNames = JSON.parse(response.choices[0].message.content).tools;
    return candidates.filter(t => selectedNames.includes(t.name));
  }
  
  async _getEmbedding(text) {
    const response = await this.openai.embeddings.create({
      model: 'text-embedding-3-small',
      input: text
    });
    return response.data[0].embedding;
  }
}

// 使用示例
const tools = [
  {
    name: 'web_search',
    description: 'Search the web for information',
    parameters: { query: 'string' }
  },
  {
    name: 'write_file',
    description: 'Write content to a file',
    parameters: { path: 'string', content: 'string' }
  },
  {
    name: 'read_file',
    description: 'Read content from a file',
    parameters: { path: 'string' }
  }
];

const selector = new ToolSelector(tools);
const selected = await selector.selectTools('搜索最新的AI新闻并保存');
console.log('Selected tools:', selected.map(t => t.name));

# smart-assistant.skill.yaml
name: smart-assistant
description: 智能助手，根据任务自动选择工具

# 定义所有可能的工具
tools:
  - name: web_search
    description: "搜索网络获取信息"
    keywords: [search, 搜索, 查找, 查询]
    
  - name: generate_image
    description: "生成AI图片"
    keywords: [image, 图片, 生成, 画图, dalle]
    
  - name: write_code
    description: "生成或执行代码"
    keywords: [code, 代码, 编程, python, javascript]
    
  - name: send_message
    description: "发送消息到其他平台"
    keywords: [send, 发送, message, 消息, discord, feishu]

runtime:
  type: node
  entrypoint: assistant.js

---
const { ToolSelector } = require('./tool-selector');

module.exports = async function(context) {
  const userTask = context.message.content;
  
  // 智能选择工具
  const selector = new ToolSelector(context.skill.tools);
  const selectedTools = await selector.selectTools(userTask, 3);
  
  // 返回给LLM，让它使用选中的工具
  return {
    inject_tools: selectedTools,
    reply: `我为你选择了 ${selectedTools.length} 个工具：${selectedTools.map(t => t.name).join(', ')}`
  };
};

// fallback-strategy.js
export class FallbackToolSelector {
  constructor(tools) {
    this.tools = tools;
    this.failureCounts = new Map(); // 记录工具失败次数
  }
  
  async executeWithFallback(task, primaryTool, alternatives = []) {
    try {
      // 尝试主工具
      return await this._executeTool(primaryTool, task);
    } catch (err) {
      console.warn(`Tool ${primaryTool.name} failed:`, err.message);
      
      // 记录失败
      this.failureCounts.set(
        primaryTool.name,
        (this.failureCounts.get(primaryTool.name) || 0) + 1
      );
      
      // 如果失败次数过多，禁用该工具
      if (this.failureCounts.get(primaryTool.name) >= 3) {
        console.error(`Tool ${primaryTool.name} disabled due to repeated failures`);
      }
      
      // 尝试替代工具
      for (const altTool of alternatives) {
        try {
          console.log(`Trying fallback tool: ${altTool.name}`);
          return await this._executeTool(altTool, task);
        } catch (altErr) {
          console.warn(`Fallback tool ${altTool.name} also failed:`, altErr.message);
        }
      }
      
      // 所有工具都失败了
      throw new Error(`All tools failed for task: ${task}`);
    }
  }
  
  async _executeTool(tool, task) {
    // 模拟工具执行
    console.log(`Executing tool: ${tool.name} with task: ${task}`);
    // ... 实际执行逻辑
    return { success: true, result: `Executed ${tool.name}` };
  }
}

// 使用示例
const selector = new FallbackToolSelector([
  { name: 'brave_search', type: 'search' },
  { name: 'google_search', type: 'search' },
  { name: 'ddg_search', type: 'search' }
]);

const result = await selector.executeWithFallback(
  '搜索AI新闻',
  { name: 'brave_search' },
  [{ name: 'google_search' }, { name: 'ddg_search' }]
);