python -m venv venv
source venv/bin/activate
pip install openai pydantic httpx tenacity
export OPENAI_API_KEY="sk-your-key"

# tool_registry.py
from __future__ import annotations
import json
import inspect
from typing import Any, Callable, Awaitable, get_type_hints
from pydantic import BaseModel, Field, create_model
from tenacity import retry, stop_after_attempt, wait_exponential

class ToolSchema(BaseModel):
    name: str
    description: str
    parameters: dict[str, Any]
    func: Callable[..., Any]
    is_async: bool = False
    timeout: float = 30.0
    max_retries: int = 3

class ToolRegistry:
    def __init__(self):
        self._tools: dict[str, ToolSchema] = {}

    def register(
        self,
        name: str | None = None,
        description: str | None = None,
        timeout: float = 30.0,
        max_retries: int = 3,
    ) -> Callable:
        def decorator(func: Callable) -> Callable:
            tool_name = name or func.__name__
            tool_desc = description or func.__doc__ or f"Execute {tool_name}"
            is_coro = inspect.iscoroutinefunction(func)
            schema = self._generate_schema(func)
            self._tools[tool_name] = ToolSchema(
                name=tool_name,
                description=tool_desc,
                parameters=schema,
                func=func,
                is_async=is_coro,
                timeout=timeout,
                max_retries=max_retries,
            )
            return func
        return decorator

    def register_function(
        self,
        func: Callable,
        name: str | None = None,
        description: str | None = None,
        timeout: float = 30.0,
        max_retries: int = 3,
    ) -> None:
        tool_name = name or func.__name__
        tool_desc = description or func.__doc__ or f"Execute {tool_name}"
        is_coro = inspect.iscoroutinefunction(func)
        schema = self._generate_schema(func)
        self._tools[tool_name] = ToolSchema(
            name=tool_name,
            description=tool_desc,
            parameters=schema,
            func=func,
            is_async=is_coro,
            timeout=timeout,
            max_retries=max_retries,
        )

    def _generate_schema(self, func: Callable) -> dict[str, Any]:
        sig = inspect.signature(func)
        hints = get_type_hints(func)
        properties = {}
        required = []
        for param_name, param in sig.parameters.items():
            if param_name == "self":
                continue
            param_type = hints.get(param_name, str)
            json_type = self._python_type_to_json(param_type)
            properties[param_name] = {
                "type": json_type,
                "description": f"The {param_name} parameter",
            }
            if param.default is inspect.Parameter.empty:
                required.append(param_name)
        return {
            "type": "object",
            "properties": properties,
            "required": required,
        }

    def _python_type_to_json(self, python_type) -> str:
        type_map = {
            str: "string",
            int: "integer",
            float: "number",
            bool: "boolean",
            list: "array",
            dict: "object",
        }
        return type_map.get(python_type, "string")

    def get_openai_tools(self) -> list[dict[str, Any]]:
        tools = []
        for tool in self._tools.values():
            tools.append({
                "type": "function",
                "function": {
                    "name": tool.name,
                    "description": tool.description,
                    "parameters": tool.parameters,
                },
            })
        return tools

    def get_tool(self, name: str) -> ToolSchema | None:
        return self._tools.get(name)

    def list_tools(self) -> list[str]:
        return list(self._tools.keys())

# tool_executor.py
from __future__ import annotations
import asyncio
import json
import time
from typing import Any
from tool_registry import ToolRegistry, ToolSchema
from tenacity import retry, stop_after_attempt, wait_exponential

class ToolExecutionResult:
    def __init__(
        self,
        tool_name: str,
        arguments: dict[str, Any],
        result: str,
        success: bool,
        duration_ms: float,
        error: str | None = None,
    ):
        self.tool_name = tool_name
        self.arguments = arguments
        self.result = result
        self.success = success
        self.duration_ms = duration_ms
        self.error = error

class ToolExecutor:
    def __init__(self, registry: ToolRegistry):
        self.registry = registry
        self.execution_log: list[ToolExecutionResult] = []

    async def execute(
        self, tool_name: str, arguments: dict[str, Any]
    ) -> ToolExecutionResult:
        tool = self.registry.get_tool(tool_name)
        if not tool:
            return ToolExecutionResult(
                tool_name=tool_name,
                arguments=arguments,
                result=f"Error: Unknown tool '{tool_name}'",
                success=False,
                duration_ms=0,
                error=f"Tool '{tool_name}' not found",
            )

        start_time = time.monotonic()
        try:
            if tool.is_async:
                result = await asyncio.wait_for(
                    self._call_with_retry(tool, arguments),
                    timeout=tool.timeout,
                )
            else:
                result = await asyncio.wait_for(
                    asyncio.get_event_loop().run_in_executor(
                        None, lambda: asyncio.run(
                            self._call_sync_with_retry(tool, arguments)
                        )
                    ),
                    timeout=tool.timeout,
                )
            duration = (time.monotonic() - start_time) * 1000
            execution = ToolExecutionResult(
                tool_name=tool_name,
                arguments=arguments,
                result=str(result),
                success=True,
                duration_ms=duration,
            )
        except asyncio.TimeoutError:
            duration = (time.monotonic() - start_time) * 1000
            execution = ToolExecutionResult(
                tool_name=tool_name,
                arguments=arguments,
                result=f"Error: Tool '{tool_name}' timed out after {tool.timeout}s",
                success=False,
                duration_ms=duration,
                error="Timeout",
            )
        except Exception as e:
            duration = (time.monotonic() - start_time) * 1000
            execution = ToolExecutionResult(
                tool_name=tool_name,
                arguments=arguments,
                result=f"Error: {str(e)}",
                success=False,
                duration_ms=duration,
                error=str(e),
            )

        self.execution_log.append(execution)
        return execution

    async def execute_parallel(
        self, calls: list[dict[str, Any]]
    ) -> list[ToolExecutionResult]:
        tasks = [
            self.execute(call["tool"], call["arguments"])
            for call in calls
        ]
        return await asyncio.gather(*tasks)

    async def _call_with_retry(
        self, tool: ToolSchema, arguments: dict[str, Any]
    ) -> str:
        @retry(
            stop=stop_after_attempt(tool.max_retries),
            wait=wait_exponential(multiplier=1, min=0.5, max=10),
        )
        async def _inner():
            return await tool.func(**arguments)
        return await _inner()

    async def _call_sync_with_retry(
        self, tool: ToolSchema, arguments: dict[str, Any]
    ) -> str:
        @retry(
            stop=stop_after_attempt(tool.max_retries),
            wait=wait_exponential(multiplier=1, min=0.5, max=10),
        )
        def _inner():
            return tool.func(**arguments)
        return _inner()

    def get_stats(self) -> dict[str, Any]:
        if not self.execution_log:
            return {"total": 0}
        successes = sum(1 for e in self.execution_log if e.success)
        avg_duration = sum(e.duration_ms for e in self.execution_log) / len(
            self.execution_log
        )
        return {
            "total": len(self.execution_log),
            "successes": successes,
            "failures": len(self.execution_log) - successes,
            "avg_duration_ms": round(avg_duration, 2),
        }

# agent.py
from __future__ import annotations
import json
from openai import AsyncOpenAI
from tool_registry import ToolRegistry
from tool_executor import ToolExecutor

TOOL_AGENT_SYSTEM = """You are a helpful assistant with access to tools.
When you need to use a tool, call the appropriate function.
You can call multiple tools in parallel when needed.
Always explain your reasoning before and after tool calls.
If a tool fails, try an alternative approach."""

class ToolUsingAgent:
    def __init__(self, model: str = "gpt-4-turbo-preview"):
        self.client = AsyncOpenAI()
        self.model = model
        self.registry = ToolRegistry()
        self.executor = ToolExecutor(self.registry)
        self.messages: list[dict] = [
            {"role": "system", "content": TOOL_AGENT_SYSTEM}
        ]

    def register(self, name: str = None, description: str = None, **kwargs):
        return self.registry.register(name=name, description=description, **kwargs)

    async def chat(self, user_input: str) -> str:
        self.messages.append({"role": "user", "content": user_input})

        while True:
            tools = self.registry.get_openai_tools()
            response = await self.client.chat.completions.create(
                model=self.model,
                messages=self.messages,
                tools=tools if tools else None,
                temperature=0.0,
            )

            choice = response.choices[0]
            message = choice.message

            if message.tool_calls:
                self.messages.append({
                    "role": "assistant",
                    "content": message.content,
                    "tool_calls": [
                        {
                            "id": tc.id,
                            "type": "function",
                            "function": {
                                "name": tc.function.name,
                                "arguments": tc.function.arguments,
                            },
                        }
                        for tc in message.tool_calls
                    ],
                })

                calls = []
                for tc in message.tool_calls:
                    try:
                        args = json.loads(tc.function.arguments)
                    except json.JSONDecodeError:
                        args = {}
                    calls.append({
                        "tool": tc.function.name,
                        "arguments": args,
                    })

                results = await self.executor.execute_parallel(calls)

                for tc, result in zip(message.tool_calls, results):
                    self.messages.append({
                        "role": "tool",
                        "tool_call_id": tc.id,
                        "content": result.result,
                    })

            elif message.content:
                self.messages.append({
                    "role": "assistant",
                    "content": message.content,
                })
                return message.content

# tools/web.py
import httpx
from tool_registry import ToolRegistry

registry = ToolRegistry()

@registry.register(
    name="web_search",
    description="Search the web for current information",
    timeout=15.0,
    max_retries=2,
)
async def web_search(query: str, num_results: int = 5) -> str:
    async with httpx.AsyncClient() as client:
        response = await client.get(
            "https://api.searchapi.io/api/v1/search",
            params={"q": query, "engine": "google"},
            timeout=10.0,
        )
        data = response.json()
        results = data.get("organic_results", [])[:num_results]
        return "\n".join(
            f"{r['title']}: {r.get('snippet', 'N/A')}"
            for r in results
        )

# tools/calculator.py
import math
from tool_registry import ToolRegistry

calc_registry = ToolRegistry()

@calc_registry.register(
    name="calculate",
    description="Evaluate mathematical expressions",
)
def calculate(expression: str) -> str:
    safe_dict = {
        "sqrt": math.sqrt, "log": math.log, "sin": math.sin,
        "cos": math.cos, "tan": math.tan, "pi": math.pi,
        "e": math.e, "abs": abs, "round": round,
    }
    result = eval(expression, {"__builtins__": {}}, safe_dict)
    return str(result)

# tests/test_tools.py
import pytest
import asyncio
from tool_registry import ToolRegistry
from tool_executor import ToolExecutor

@pytest.fixture
def registry():
    reg = ToolRegistry()
    @reg.register(name="add", description="Add two numbers")
    def add(a: int, b: int) -> int:
        return a + b
    return reg

@pytest.fixture
def executor(registry):
    return ToolExecutor(registry)

def test_tool_registration(registry):
    assert "add" in registry.list_tools()
    tools = registry.get_openai_tools()
    assert len(tools) == 1
    assert tools[0]["function"]["name"] == "add"

@pytest.mark.asyncio
async def test_tool_execution(executor):
    result = await executor.execute("add", {"a": 2, "b": 3})
    assert result.success
    assert result.result == "5"

@pytest.mark.asyncio
async def test_unknown_tool(executor):
    result = await executor.execute("nonexistent", {})
    assert not result.success

@pytest.mark.asyncio
async def test_parallel_execution(executor):
    calls = [
        {"tool": "add", "arguments": {"a": 1, "b": 2}},
        {"tool": "add", "arguments": {"a": 3, "b": 4}},
    ]
    results = await executor.execute_parallel(calls)
    assert len(results) == 2
    assert all(r.success for r in results)

def test_stats(executor):
    stats = executor.get_stats()
    assert stats["total"] == 0

# main.py
import asyncio
from agent import ToolUsingAgent
from tools.web import registry as web_registry
from tools.calculator import calc_registry

async def main():
    agent = ToolUsingAgent()
    agent.registry._tools.update(web_registry._tools)
    agent.registry._tools.update(calc_registry._tools)

    result = await agent.chat("What is the capital of France and what is 2+2?")
    print(f"Answer: {result}")

if __name__ == "__main__":
    asyncio.run(main())