AI工具调用统一标准

import openai
from openai import OpenAI

client = OpenAI()

# 1. 定义函数
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "获取指定城市的天气信息",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "城市名称"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "温度单位"
                    }
                },
                "required": ["location"]
            }
        }
    }
]

# 2. 用户提问
messages = [{"role": "user", "content": "北京今天天气怎么样？"}]

# 3. 模型决策并调用函数
response = client.chat.completions.create(
    model="gpt-4-turbo",
    messages=messages,
    tools=tools,
    tool_choice="auto"
)

response_message = response.choices[0].message

# 4. 处理函数调用
tool_calls = response_message.tool_calls
if tool_calls:
    # 5. 执行函数并获取结果
    weather_data = {"temperature": 25, "condition": "晴朗", "humidity": "40%"}
    
    # 6. 将函数执行结果返回给模型
    messages.append(response_message)
    messages.append({
        "role": "tool",
        "tool_call_id": tool_calls[0].id,
        "name": tool_calls[0].function.name,
        "content": str(weather_data)
    })
    
    # 7. 生成最终回答
    second_response = client.chat.completions.create(
        model="gpt-4-turbo",
        messages=messages
    )
    
    print(second_response.choices[0].message.content)

const toolSchema = {
  // 基础信息
  name: "工具名称",
  description: "详细描述",
  version: "1.0.0",
  
  // 参数定义(兼容JSON Schema)
  parameters: {
    type: "object",
    properties: {
      // 参数定义
    },
    required: []
  },
  
  // 返回值定义
  returns: {
    type: "object",
    properties: {
      // 返回值结构
    }
  },
  
  // 平台特定配置
  platforms: {
    openai: {
      // OpenAI特定配置
    },
    anthropic: {
      // Anthropic特定配置
    },
    gemini: {
      // Google Gemini特定配置
    }
  },
  
  // 执行函数(实际实现)
  execute: async (params) => {
    // 工具的实际执行逻辑
    return result;
  }
};

class ToolAdapter {
  constructor(tools) {
    this.tools = tools;
  }
  
  // 转换为OpenAI格式
  toOpenAIFormat() {
    return this.tools.map(tool => ({
      type: "function",
      function: {
        name: tool.name,
        description: tool.description,
        parameters: tool.parameters,
        // 其他OpenAI特定配置
      }
    }));
  }
  
  // 转换为Anthropic格式
  toAnthropicFormat() {
    // Anthropic特定的工具格式转换
  }
  
  // 转换为Google Gemini格式
  toGeminiFormat() {
    // Google特定的工具格式转换
  }
  
  // 执行工具调用
  async executeTool(toolName, params) {
    const tool = this.tools.find(t => t.name === toolName);
    if (!tool) throw new Error(`Tool ${toolName} not found`);
    return await tool.execute(params);
  }
}

class UnifiedToolCaller {
  constructor(platform, platformConfig, tools) {
    this.platform = platform;
    this.config = platformConfig;
    this.adapter = new ToolAdapter(tools);
    this.client = this._initializeClient();
  }
  
  _initializeClient() {
    // 根据platform初始化对应的客户端
    switch(this.platform) {
      case 'openai':
        return new OpenAI(this.config);
      case 'anthropic':
        return new Anthropic(this.config);
      // 其他平台
    }
  }
  
  async process(userInput) {
    // 1. 转换工具为平台特定格式
    const platformTools = this._getPlatformTools();
    
    // 2. 发送请求给LLM
    const response = await this._sendToLLM(userInput, platformTools);
    
    // 3. 处理工具调用
    if (this._hasToolCalls(response)) {
      return await this._handleToolCalls(response, userInput);
    }
    
    // 4. 返回直接回答
    return this._extractResponse(response);
  }
  
  _getPlatformTools() {
    switch(this.platform) {
      case 'openai':
        return this.adapter.toOpenAIFormat();
      // 其他平台
    }
  }
  
  async _sendToLLM(input, tools) {
    // 平台特定的发送方法
  }
  
  _hasToolCalls(response) {
    // 平台特定的工具调用检测
  }
  
  async _handleToolCalls(response, originalInput) {
    // 1. 提取工具调用
    const toolCalls = this._extractToolCalls(response);
    
    // 2. 执行工具调用
    const results = [];
    for (const call of toolCalls) {
      const result = await this.adapter.executeTool(call.name, call.params);
      results.push({ call, result });
    }
    
    // 3. 将工具调用结果返回给LLM
    return await this._sendToolResultsToLLM(originalInput, response, results);
  }
  
  // 其他辅助方法...
}