User Task
    ↓
Agent reasons about what tools are needed
    ↓
Agent calls appropriate tool(s)
    ↓
Tool returns result to agent
    ↓
Agent reasons about whether task is complete
    ↓
If more tools needed: loop back
If complete: return final answer to user

import anthropic
import json
import requests
import sqlite3
import os

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

# Define the tools
tools = [
    {
        "name": "query_business_database",
        "description": "Query the local business database to find information about Pakistani businesses. Use this when the user asks about specific businesses or business categories.",
        "input_schema": {
            "type": "object",
            "properties": {
                "city": {"type": "string", "description": "Pakistani city name (e.g., Karachi, Lahore, Islamabad)"},
                "category": {"type": "string", "description": "Business category (e.g., restaurant, clinic, retail)"},
                "limit": {"type": "integer", "description": "Maximum number of results to return", "default": 5}
            },
            "required": ["city", "category"]
        }
    },
    {
        "name": "check_website_seo",
        "description": "Check the basic SEO status of a website URL. Returns title, meta description, and mobile speed score.",
        "input_schema": {
            "type": "object",
            "properties": {
                "url": {"type": "string", "description": "Full website URL including https://"}
            },
            "required": ["url"]
        }
    },
    {
        "name": "send_whatsapp_message",
        "description": "Send a WhatsApp message to a Pakistani phone number using WATI API. Use when the user explicitly requests sending a message.",
        "input_schema": {
            "type": "object",
            "properties": {
                "phone_number": {"type": "string", "description": "Pakistani phone number with country code (e.g., 923001234567)"},
                "message": {"type": "string", "description": "Message content to send"}
            },
            "required": ["phone_number", "message"]
        }
    }
]

# Tool execution functions
def query_business_database(city: str, category: str, limit: int = 5):
    """Query SQLite database of Pakistani businesses"""
    conn = sqlite3.connect("businesses.db")
    cursor = conn.cursor()
    cursor.execute(
        "SELECT name, address, phone, rating FROM businesses WHERE city=? AND category=? LIMIT ?",
        (city, category, limit)
    )
    results = cursor.fetchall()
    conn.close()
    return [{"name": r[0], "address": r[1], "phone": r[2], "rating": r[3]} for r in results]

def check_website_seo(url: str):
    """Check basic SEO metrics via PageSpeed Insights API"""
    api_key = os.environ.get("GOOGLE_PSI_API_KEY")
    response = requests.get(
        f"https://www.googleapis.com/pagespeedonline/v5/runPagespeed?url={url}&key={api_key}&strategy=mobile"
    )
    data = response.json()
    return {
        "performance_score": data.get("lighthouseResult", {}).get("categories", {}).get("performance", {}).get("score", 0) * 100,
        "url": url
    }

def send_whatsapp_message(phone_number: str, message: str):
    """Send via WATI API"""
    return {"status": "sent", "phone": phone_number, "preview": message[:50] + "..."}

# Execute tool calls
def execute_tool(tool_name: str, tool_input: dict):
    if tool_name == "query_business_database":
        return query_business_database(**tool_input)
    elif tool_name == "check_website_seo":
        return check_website_seo(**tool_input)
    elif tool_name == "send_whatsapp_message":
        return send_whatsapp_message(**tool_input)

# The agentic loop
def run_tool_agent(user_request: str):
    messages = [{"role": "user", "content": user_request}]

    while True:
        response = client.messages.create(
            model="claude-sonnet-4-6",
            max_tokens=2000,
            tools=tools,
            messages=messages
        )

        if response.stop_reason == "tool_use":
            # Process tool calls
            tool_results = []
            for block in response.content:
                if block.type == "tool_use":
                    print(f"[Agent] Calling tool: {block.name} with {block.input}")
                    result = execute_tool(block.name, block.input)
                    tool_results.append({
                        "type": "tool_result",
                        "tool_use_id": block.id,
                        "content": json.dumps(result)
                    })

            # Add assistant response and tool results to messages
            messages.append({"role": "assistant", "content": response.content})
            messages.append({"role": "user", "content": tool_results})

        elif response.stop_reason == "end_turn":
            # Task complete — extract final text
            for block in response.content:
                if hasattr(block, "text"):
                    return block.text
            break

# Run it
result = run_tool_agent(
    "Find me the top 3 restaurants in DHA Karachi, check if the first one "
    "has a website and if so audit its SEO. Give me a summary."
)
print(result)