from anthropic import Anthropic
import os

client = Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))

# 定义一个计算器工具
tools = [{
    "name": "calculator",
    "description": "执行数学计算",
    "input_schema": {
        "type": "object",
        "properties": {
            "expression": {
                "type": "string",
                "description": "数学表达式，如 '2 + 2' 或 'sqrt(16)'"
            }
        },
        "required": ["expression"]
    }
}]

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    tools=tools,
    messages=[{
        "role": "user",
        "content": "计算 15 * 23 + 45 的值"
    }]
)

print(response.content)

tool = {
    "name": "工具名称",           # 唯一标识符，字母数字下划线
    "description": "工具描述",      # 描述工具用途，Claude据此决定调用
    "input_schema": {              # 参数规范（JSON Schema）
        "type": "object",
        "properties": {
            "参数名": {
                "type": "类型",
                "description": "参数描述"
            }
        },
        "required": ["必需参数"]
    }
}

# 正确：清晰、小写、下划线分隔
tools = [{
    "name": "get_weather",
    "description": "获取指定城市的天气信息"
}]

# 正确：描述性名称
tools = [{
    "name": "search_database",
    "description": "从数据库搜索用户信息"
}]

# 错误：包含空格或特殊字符
tools = [{
    "name": "get weather",
    "description": "获取天气"
}]

# 错误：名称过于简短
tools = [{
    "name": "calc",
    "description": "计算"
}]

# 描述太模糊 - Claude不知道何时该用
{
    "name": "search",
    "description": "搜索功能"
}

# 描述清晰具体 - 包含使用场景和参数说明
{
    "name": "search_products",
    "description": """在产品数据库中搜索商品。

适用场景：
- 用户询问某类商品的价格或库存
- 用户想找特定品牌或类型的商品
- 用户比较不同商品的规格

返回：商品名称、价格、库存状态、规格参数"""
}

# 完整示例
tools = [{
    "name": "book_flight",
    "description": "预订机票",
    "input_schema": {
        "type": "object",
        "properties": {
            "departure_city": {
                "type": "string",
                "description": "出发城市，如'北京'、'上海'"
            },
            "arrival_city": {
                "type": "string",
                "description": "目的地城市"
            },
            "departure_date": {
                "type": "string",
                "description": "出发日期，格式YYYY-MM-DD",
                "pattern": "^\\d{4}-\\d{2}-\\d{2}$"
            },
            "passengers": {
                "type": "integer",
                "description": "乘客数量",
                "minimum": 1,
                "maximum": 9
            },
            "cabin_class": {
                "type": "string",
                "description": "舱位等级",
                "enum": ["economy", "business", "first"]
            }
        },
        "required": ["departure_city", "arrival_city", "departure_date", "passengers"]
    }
}]

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    tools=tools,
    messages=[{"role": "user", "content": "查一下北京明天天气"}]
)

print(response.stop_reason)
# 输出: "tool_use"

# 检查是否有工具调用
if response.stop_reason == "tool_use":
    for content in response.content:
        if content.type == "tool_use":
            print(f"工具名称: {content.name}")
            print(f"工具输入: {content.input}")
            print(f"工具ID: {content.id}")

# 工具结果可以是字符串
tool_result = {
    "type": "tool_result",
    "tool_use_id": "toolu_xxxxx",
    "content": "晴天，15°C"
}

# 也可以是JSON字符串
tool_result = {
    "type": "tool_result",
    "tool_use_id": "toolu_xxxxx",
    "content": '{"temp": 15, "condition": "晴天"}'
}

# 如果工具执行出错
tool_result = {
    "type": "tool_result",
    "tool_use_id": "toolu_xxxxx",
    "content": "Error: 数据库连接失败"
}

tools = [
    {
        "name": "get_stock_price",
        "description": "获取股票当前价格",
        "input_schema": {
            "type": "object",
            "properties": {
                "symbol": {"type": "string", "description": "股票代码，如AAPL、GOOGL"}
            },
            "required": ["symbol"]
        }
    },
    {
        "name": "calculate_portfolio_value",
        "description": "计算投资组合价值",
        "input_schema": {
            "type": "object",
            "properties": {
                "holdings": {
                    "type": "array",
                    "description": "持仓列表",
                    "items": {
                        "type": "object",
                        "properties": {
                            "symbol": {"type": "string"},
                            "shares": {"type": "integer"}
                        }
                    }
                }
            },
            "required": ["holdings"]
        }
    }
]

# 用户请求：计算投资组合价值
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    tools=tools,
    messages=[{
        "role": "user",
        "content": "我持有 10股苹果、5股谷歌、20股微软，计算我的投资组合总价值"
    }]
)

# Claude可能会：
# 第一轮：调用 get_stock_price 获取 AAPL, GOOGL, MSFT 的价格
# 第二轮：调用 calculate_portfolio_value 计算总价值

def process_message_with_tools(user_message, tools):
    """处理消息，自动处理多轮工具调用"""
    messages = [{"role": "user", "content": user_message}]
    max_iterations = 10  # 防止无限循环
    iteration = 0

    while iteration < max_iterations:
        iteration += 1

        response = client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=1024,
            tools=tools,
            messages=messages
        )

        # 如果不是工具调用，说明是最终响应
        if response.stop_reason != "tool_use":
            return response.content[0].text

        # 处理工具调用
        tool_results = []
        for content in response.content:
            if content.type == "tool_use":
                # 执行工具
                result = execute_tool(content.name, content.input)
                tool_results.append({
                    "type": "tool_result",
                    "tool_use_id": content.id,
                    "content": str(result)
                })

        # 添加到消息历史
        messages.append(response)
        messages.append({
            "role": "user",
            "content": "",  # 空内容，因为有tool_results
            "tool_results": tool_results
        })

    return "达到最大迭代次数"

def execute_tool(tool_name, tool_input):
    """执行工具并返回结果"""
    # 这里实现实际的工具逻辑
    pass

import signal

class TimeoutError(Exception):
    pass

def timeout_handler(signum, frame):
    raise TimeoutError("工具执行超时")

def execute_tool_with_timeout(tool_name, tool_input, timeout=30):
    """带超时的工具执行"""
    signal.signal(signal.SIGALRM, timeout_handler)
    signal.alarm(timeout)

    try:
        result = execute_tool(tool_name, tool_input)
        signal.alarm(0)  # 取消闹钟
        return result
    except TimeoutError:
        return f"Error: 工具执行超过{timeout}秒"

import requests
from typing import Dict, Any

class WebSearchTool:
    """网页搜索工具"""

    def __init__(self, api_key: str = None):
        self.api_key = api_key or os.environ.get("SEARCH_API_KEY")
        self.base_url = "https://api.search.com/v1/search"

    def search(self, query: str, num_results: int = 5) -> str:
        """搜索网页并返回结果"""
        if not self.api_key:
            return "Error: 未配置搜索API密钥"

        try:
            response = requests.get(
                self.base_url,
                params={
                    "q": query,
                    "num": num_results,
                    "apikey": self.api_key
                },
                timeout=10
            )
            data = response.json()

            results = []
            for item in data.get("results", []):
                results.append(f"标题: {item['title']}\n链接: {item['url']}\n摘要: {item['snippet']}\n")

            return "\n".join(results) if results else "未找到结果"
        except Exception as e:
            return f"Error: 搜索失败 - {str(e)}"

search_tool = WebSearchTool()

tools = [{
    "name": "web_search",
    "description": "搜索互联网获取最新信息",
    "input_schema": {
        "type": "object",
        "properties": {
            "query": {"type": "string", "description": "搜索关键词"},
            "num_results": {"type": "integer", "description": "返回结果数量", "default": 5}
        },
        "required": ["query"]
    }
}]

# 好的命名：动词_名词，清晰表达功能
tools = [
    {"name": "get_user_info"},
    {"name": "search_products"},
    {"name": "calculate_shipping"},
    {"name": "send_email"},
    {"name": "create_task"},
]

# 差的命名：过于简短或模糊
tools = [
    {"name": "user"},      # 名词，不知道做什么
    {"name": "do"},        # 太模糊
    {"name": "search"},    # 搜索什么？
]

# 好的描述：具体、包含使用场景
{
    "name": "get_order_status",
    "description": """获取订单配送状态。

触发场景：
- 用户询问"我的订单到哪了"
- 用户提供订单号查询进度
- 用户想确认预计送达时间

返回：订单状态、当前位置、预计送达时间"""
}

# 差的描述：过于笼统
{
    "name": "get_order_status",
    "description": "获取订单状态"
}

def safe_execute_tool(tool_name, tool_input):
    """安全的工具执行，带错误处理"""
    try:
        result = execute_tool(tool_name, tool_input)
        return {"success": True, "result": result}
    except Exception as e:
        return {
            "success": False,
            "error": str(e),
            "error_type": type(e).__name__
        }

# 在处理工具调用时
for content in response.content:
    if content.type == "tool_use":
        result = safe_execute_tool(content.name, content.input)

        if result["success"]:
            tool_results.append({
                "type": "tool_result",
                "tool_use_id": content.id,
                "content": str(result["result"])
            })
        else:
            tool_results.append({
                "type": "tool_result",
                "tool_use_id": content.id,
                "content": f"Error: {result['error']}"
            })

# 所有工具都传，让Claude自己判断
tools = [get_weather, search_db, send_email, create_calendar_event, ...]
# 问题：工具太多，Claude选择错误率增加

# 只传递相关的工具
relevant_tools = [get_weather, get_time]  # 用户问天气时只给天气工具

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    tools=relevant_tools,
    messages=messages
)

# 或在系统提示词中指定使用场景
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    system="""你是一个天气助手。

当用户询问天气时，使用get_weather工具。
当用户询问时间时，使用get_time工具。
不要使用其他工具。""",
    tools=[get_weather, get_time],
    messages=messages
)

def process_with_max_tools(user_message, tools, max_calls=5):
    """处理消息，最多调用工具N次"""
    messages = [{"role": "user", "content": user_message}]
    tool_call_count = 0

    while tool_call_count < max_calls:
        response = client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=1024,
            tools=tools,
            messages=messages
        )

        if response.stop_reason != "tool_use":
            return response.content[0].text

        # 处理工具调用
        tool_results = []
        for content in response.content:
            if content.type == "tool_use":
                tool_call_count += 1
                result = execute_tool(content.name, content.input)
                tool_results.append({
                    "type": "tool_result",
                    "tool_use_id": content.id,
                    "content": str(result)
                })

        messages.append(response)
        messages.append({"role": "user", "content": "", "tool_results": tool_results})

    return "处理超时，请简化您的问题"

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    tools=[{"name": "calc", "description": "计算", "input_schema": {...}}],
    messages=[{"role": "user", "content": "计算 2+2"}]
)
print(response.stop_reason)

# 你的代码在这里