import json
from typing import Literal

from openai import OpenAI

client = OpenAI()


def get_weather(city: str, unit: Literal["c", "f"] = "c") -> dict:
    # 这里用假数据模拟真实天气 API
    # 真实项目里：在这里请求你自己的天气服务，并做好超时/重试/缓存
    fake = {
        "北京": {"temp_c": 15, "condition": "晴"},
        "上海": {"temp_c": 12, "condition": "小雨"},
    }
    data = fake.get(city, {"temp_c": 20, "condition": "多云"})

    if unit == "f":
        temp = data["temp_c"] * 9 / 5 + 32
        return {"city": city, "temperature_f": round(temp, 1), "condition": data["condition"]}

    return {"city": city, "temperature_c": data["temp_c"], "condition": data["condition"]}


TOOLS = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "获取指定城市的天气（示例工具：返回模拟数据）",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string", "description": "城市名称，例如：北京"},
                    "unit": {
                        "type": "string",
                        "enum": ["c", "f"],
                        "description": "温度单位：c=摄氏度，f=华氏度",
                    },
                },
                "required": ["city"],
                "additionalProperties": False,
            },
            # 开启 Structured Outputs：让模型生成的参数严格匹配 JSON Schema
            "strict": True,
        },
    }
]


def call_function(name: str, args: dict) -> str:
    if name == "get_weather":
        result = get_weather(**args)
        return json.dumps(result, ensure_ascii=False)
    raise ValueError(f"Unknown function: {name}")


def main() -> None:
    model = "gpt-4.1-mini"  # 替换成你账号可用的模型

    response = client.responses.create(
        model=model,
        input=[{"role": "user", "content": "北京今天天气怎么样？用摄氏度。"}],
        tools=TOOLS,
    )

    # 持续处理工具调用，直到模型不再要求调用工具
    while True:
        tool_outputs = []
        for item in response.output:
            if getattr(item, "type", None) != "function_call":
                continue

            args = json.loads(item.arguments)
            output = call_function(item.name, args)

            tool_outputs.append(
                {
                    "type": "function_call_output",
                    "call_id": item.call_id,
                    "output": output,  # 注意：这里必须是字符串（建议 JSON 字符串）
                }
            )

        if not tool_outputs:
            break

        response = client.responses.create(
            model=model,
            previous_response_id=response.id,
            input=tool_outputs,
            tools=TOOLS,
        )

    print(response.output_text)


if __name__ == "__main__":
    main()

import ast
import json
from openai import OpenAI

client = OpenAI()


def safe_eval_arith(expr: str) -> float:
    """
    只允许 + - * / () 和数字的安全计算器（示例用，别当完整表达式引擎）。
    """
    node = ast.parse(expr, mode="eval")

    allowed = (
        ast.Expression,
        ast.BinOp,
        ast.UnaryOp,
        ast.Add,
        ast.Sub,
        ast.Mult,
        ast.Div,
        ast.USub,
        ast.UAdd,
        ast.Constant,
        ast.Load,
        ast.Pow,
        ast.Mod,
        ast.FloorDiv,
        ast.LShift,
        ast.RShift,
        ast.BitAnd,
        ast.BitOr,
        ast.BitXor,
        ast.Call,
        ast.Name,
    )

    # 禁用一切函数调用/变量名（上面允许列表里包含了 Call/Name，这里直接拦掉）
    for n in ast.walk(node):
        if not isinstance(n, allowed):
            raise ValueError("Unsupported expression")
        if isinstance(n, (ast.Call, ast.Name)):
            raise ValueError("Calls/names are not allowed")

    def eval_node(n):
        if isinstance(n, ast.Expression):
            return eval_node(n.body)
        if isinstance(n, ast.Constant) and isinstance(n.value, (int, float)):
            return float(n.value)
        if isinstance(n, ast.UnaryOp):
            v = eval_node(n.operand)
            if isinstance(n.op, ast.UAdd):
                return v
            if isinstance(n.op, ast.USub):
                return -v
        if isinstance(n, ast.BinOp):
            a = eval_node(n.left)
            b = eval_node(n.right)
            if isinstance(n.op, ast.Add):
                return a + b
            if isinstance(n.op, ast.Sub):
                return a - b
            if isinstance(n.op, ast.Mult):
                return a * b
            if isinstance(n.op, ast.Div):
                return a / b
        raise ValueError("Unsupported expression")

    return eval_node(node)


def search_stub(query: str) -> dict:
    # 示例：用静态数据模拟搜索。真实项目请接入你自己的搜索/知识库/RAG。
    return {
        "query": query,
        "results": [
            {"title": "Python 官方教程", "hint": "docs.python.org/zh-cn/"},
            {"title": "Real Python 入门", "hint": "realpython.com/"},
        ],
    }


TOOLS = [
    {
        "type": "function",
        "function": {
            "name": "search",
            "description": "搜索资料（示例工具：返回固定结果）",
            "parameters": {
                "type": "object",
                "properties": {"query": {"type": "string"}},
                "required": ["query"],
                "additionalProperties": False,
            },
            "strict": True,
        },
    },
    {
        "type": "function",
        "function": {
            "name": "calculate",
            "description": "计算四则运算表达式（示例工具：安全计算器）",
            "parameters": {
                "type": "object",
                "properties": {"expr": {"type": "string", "description": "例如：123 + 456"}},
                "required": ["expr"],
                "additionalProperties": False,
            },
            "strict": True,
        },
    },
]


def call_tool(name: str, args: dict) -> str:
    if name == "search":
        return json.dumps(search_stub(**args), ensure_ascii=False)
    if name == "calculate":
        value = safe_eval_arith(args["expr"])
        return json.dumps({"expr": args["expr"], "value": value}, ensure_ascii=False)
    raise ValueError(f"Unknown tool: {name}")


def run_agent(task: str) -> str:
    model = "gpt-4.1-mini"  # 替换成你账号可用的模型

    response = client.responses.create(
        model=model,
        input=[
            {
                "role": "system",
                "content": (
                    "你是一个务实的任务型助手。能用工具就用工具，"
                    "需要计算就调用 calculate，需要查资料就调用 search。"
                    "拿到工具结果后，用简短步骤说明你的结论。"
                ),
            },
            {"role": "user", "content": task},
        ],
        tools=TOOLS,
    )

    max_rounds = 8
    for _ in range(max_rounds):
        tool_outputs = []
        for item in response.output:
            if getattr(item, "type", None) != "function_call":
                continue
            args = json.loads(item.arguments)
            out = call_tool(item.name, args)
            tool_outputs.append(
                {"type": "function_call_output", "call_id": item.call_id, "output": out}
            )

        if not tool_outputs:
            return response.output_text.strip()

        response = client.responses.create(
            model=model,
            previous_response_id=response.id,
            input=tool_outputs,
            tools=TOOLS,
        )

    return "任务未在轮次内完成（超时保护触发）。"


if __name__ == "__main__":
    print(run_agent("帮我找两份 Python 入门资料，并计算 123 + 456。"))