import anthropic
import os

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

# Basic request
message = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Hello, Claude!"}
    ]
)

print(f"Response: {message.content[0].text}")
print(f"Stop reason: {message.stop_reason}")
print(f"Usage: input={message.usage.input_tokens}, output={message.usage.output_tokens}")

message = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=1024,
    system="You are a helpful assistant.",
    messages=[
        {"role": "user", "content": "What is 2+2?"}
    ]
)
print(message.content[0].text)

system_prompt = "You are a helpful coding assistant."
conversation_history = []

def chat(user_input):
    conversation_history.append({"role": "user", "content": user_input})
    
    response = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=2048,
        system=system_prompt,
        messages=conversation_history
    )
    
    assistant_message = response.content[0].text
    conversation_history.append({"role": "assistant", "content": assistant_message})
    return assistant_message

# Multiple turns
print(chat("What is Python?"))
print(chat("How do I write a class?"))
print(chat("Can you show me an example?"))

print("Streaming response:")
with client.messages.stream(
    model="claude-3-5-sonnet-20241022",
    max_tokens=1024,
    system="You are concise.",
    messages=[{"role": "user", "content": "Write a haiku about AI."}]
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)
print()

response = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Extract the name and age from: John is 30 years old."}],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "person_extractor",
            "schema": {
                "type": "object",
                "properties": {
                    "name": {"type": "string"},
                    "age": {"type": "integer"}
                },
                "required": ["name", "age"]
            },
            "strict": True
        }
    }
)

import json
data = json.loads(response.content[0].text)
print(f"Name: {data['name']}, Age: {data['age']}")

import anthropic
import json
from typing import Literal

client = anthropic.Anthropic()

# Test dataset
test_cases = [
    {"input": "Extract the color: The car is red.", "expected_output": "red"},
    {"input": "Extract the color: She wore a blue dress.", "expected_output": "blue"},
    {"input": "Extract the color: The sky is clear.", "expected_output": "no color mentioned"},
]

# Code-based grading (exact match)
def grade_exact_match(output: str, expected: str) -> bool:
    return output.strip().lower() == expected.strip().lower()

# Model-based grading
def grade_with_claude(input_text: str, output: str, expected: str) -> float:
    """Use Claude as a judge: returns score 0-1."""
    rubric = f"""
    Task: Evaluate if the output correctly answers the input query.
    Expected answer: {expected}
    Actual output: {output}
    
    Score 1.0 if correct, 0.5 if partially correct, 0.0 if incorrect.
    Respond with ONLY the number (e.g., 1.0).
    """
    
    response = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=10,
        system="You are an expert evaluator. Score the response accurately.",
        messages=[{"role": "user", "content": rubric}]
    )
    
    try:
        return float(response.content[0].text.strip())
    except:
        return 0.0

# Run evaluation
def evaluate_prompt():
    results = []
    
    for test in test_cases:
        # Get model output
        response = client.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=100,
            system="Extract the color mentioned. If no color, respond 'no color mentioned'.",
            messages=[{"role": "user", "content": test["input"]}]
        )
        
        output = response.content[0].text
        
        # Grade with both methods
        exact_match = grade_exact_match(output, test["expected_output"])
        model_score = grade_with_claude(test["input"], output, test["expected_output"])
        
        results.append({
            "input": test["input"],
            "expected": test["expected_output"],
            "actual": output,
            "exact_match": exact_match,
            "model_score": model_score
        })
    
    # Compute metrics
    accuracy = sum(1 for r in results if r["exact_match"]) / len(results)
    avg_model_score = sum(r["model_score"] for r in results) / len(results)
    
    print(f"Accuracy: {accuracy:.2%}")
    print(f"Average Model Score: {avg_model_score:.2f}")
    print("\nDetailed Results:")
    for r in results:
        print(f"  Input: {r['input']}")
        print(f"  Expected: {r['expected']}, Actual: {r['actual']}")
        print(f"  Match: {r['exact_match']}, Model Score: {r['model_score']}\n")

evaluate_prompt()

# Bad prompt
response = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=200,
    messages=[{"role": "user", "content": "Analyze this text."}]
)

# Good prompt with clarity and specificity
response = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=200,
    messages=[{
        "role": "user",
        "content": """Analyze the following customer review for sentiment.
        
Output format: JSON with fields: sentiment (positive/negative/neutral), confidence (0-1), key_phrases (list of strings).

Text: "The product arrived late but works great once I set it up. Would recommend despite shipping issues."
"""
    }]
)

prompt = """
<task>
Extract structured information from a product review.
</task>

<rules>
- Output MUST be valid JSON
- If information is missing, use null
- Sentiment must be one of: positive, negative, neutral
- Confidence is a number 0-1
</rules>

<output_format>
{
  "product_name": string,
  "sentiment": string,
  "confidence": number,
  "pros": [string],
  "cons": [string],
  "rating": number or null
}
</output_format>

<examples>
Input: "Excellent phone! Fast processor, great camera. Battery life is average though."
Output: {
  "product_name": null,
  "sentiment": "positive",
  "confidence": 0.9,
  "pros": ["fast processor", "great camera"],
  "cons": ["average battery life"],
  "rating": null
}
</examples>

<input>
"These shoes are uncomfortable and overpriced. Not worth the hype."
</input>
"""

response = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=500,
    messages=[{"role": "user", "content": prompt}]
)

examples = [
    {
        "input": "The meeting is at 3 PM tomorrow.",
        "output": "DATETIME: 3:00 PM tomorrow"
    },
    {
        "input": "I have 5 apples.",
        "output": "QUANTITY: 5"
    },
    {
        "input": "The sky is blue.",
        "output": "ATTRIBUTE: sky, blue"
    }
]

prompt = "Extract the main entity from this sentence:\n\nThe project deadline is next Friday.\n\nUse examples:\n"
for ex in examples:
    prompt += f"Input: {ex['input']}\nOutput: {ex['output']}\n\n"
prompt += "Now extract: 'The project deadline is next Friday.'"

response = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=100,
    messages=[{"role": "user", "content": prompt}]
)

prompt = """Solve this math problem step-by-step.

Problem: If a train travels at 60 mph for 2.5 hours, how far does it go?

Before answering, think through:
1. What formula do I need?
2. What values do I have?
3. What's the calculation?
4. What's the final answer?
"""

response = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=300,
    temperature=0,  # Deterministic for math
    messages=[{"role": "user", "content": prompt}]
)

{
  "name": "function_name",
  "description": "What this function does",
  "input_schema": {
    "type": "object",
    "properties": {
      "param1": {"type": "string", "description": "..."},
      "param2": {"type": "number", "description": "..."}
    },
    "required": ["param1"]
  }
}

{
  "type": "tool_use",
  "id": "unique_id",
  "name": "tool_name",
  "input": {...}
}

{
  "type": "tool_result",
  "tool_use_id": "id_from_tool_use_block",
  "content": "result string or error"
}

import anthropic
import json

client = anthropic.Anthropic()

# Define tools
tools = [
    {
        "name": "get_weather",
        "description": "Get current weather for a location",
        "input_schema": {
            "type": "object",
            "properties": {
                "location": {"type": "string", "description": "City or coordinates"},
                "units": {"type": "string", "enum": ["celsius", "fahrenheit"], "description": "Temperature units"}
            },
            "required": ["location"]
        }
    },
    {
        "name": "get_time",
        "description": "Get current time for a timezone",
        "input_schema": {
            "type": "object",
            "properties": {
                "timezone": {"type": "string", "description": "Timezone (e.g., 'America/New_York')"}
            },
            "required": ["timezone"]
        }
    }
]

# Simulate tool execution
def execute_tool(name: str, input_data: dict) -> str:
    if name == "get_weather":
        return json.dumps({
            "location": input_data["location"],
            "temperature": 22,
            "condition": "Sunny"
        })
    elif name == "get_time":
        return json.dumps({
            "timezone": input_data["timezone"],
            "time": "14:30:00"
        })
    return "Tool not found"

# Multi-turn tool use loop
def chat_with_tools(user_message: str):
    messages = [{"role": "user", "content": user_message}]
    
    print(f"User: {user_message}\n")
    
    while True:
        # Send request with tools
        response = client.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=1024,
            tools=tools,
            messages=messages
        )
        
        # Check if tool use is needed
        if response.stop_reason == "tool_use":
            # Extract all tool use blocks
            tool_uses = [block for block in response.content if block.type == "tool_use"]
            
            # Add assistant response to messages
            messages.append({"role": "assistant", "content": response.content})
            
            # Execute tools and collect results
            tool_results = []
            for tool_use in tool_uses:
                print(f"Tool: {tool_use.name}")
                print(f"Input: {json.dumps(tool_use.input, indent=2)}")
                
                result = execute_tool(tool_use.name, tool_use.input)
                print(f"Result: {result}\n")
                
                tool_results.append({
                    "type": "tool_result",
                    "tool_use_id": tool_use.id,
                    "content": result
                })
            
            # Send tool results back
            messages.append({"role": "user", "content": tool_results})
        
        elif response.stop_reason == "end_turn":
            # Model finished, no more tools
            final_response = next(
                (block.text for block in response.content if hasattr(block, "text")),
                "No response"
            )
            print(f"Assistant: {final_response}")
            break
        
        else:
            print(f"Unexpected stop reason: {response.stop_reason}")
            break

# Test
chat_with_tools("What's the weather in Paris and the time in London?")

# Force tool use
response = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=1024,
    tools=tools,
    tool_choice="required",  # Model must use a tool
    messages=[{"role": "user", "content": "Tell me about Paris."}]
)

# Or force specific tool
response = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=1024,
    tools=tools,
    tool_choice={"type": "tool", "name": "get_weather"},  # Force this tool
    messages=[{"role": "user", "content": "What's the weather?"}]
)

# Parallel tool execution (both tools called in same turn)
def handle_parallel_tools(user_message: str):
    messages = [{"role": "user", "content": user_message}]
    
    response = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=1024,
        tools=tools,
        messages=messages
    )
    
    if response.stop_reason == "tool_use":
        tool_uses = [block for block in response.content if block.type == "tool_use"]
        
        # Execute all tools in parallel
        results = []
        for tool_use in tool_uses:
            result = execute_tool(tool_use.name, tool_use.input)
            results.append({
                "type": "tool_result",
                "tool_use_id": tool_use.id,
                "content": result
            })
        
        # Send all results back at once
        messages.append({"role": "assistant", "content": response.content})
        messages.append({"role": "user", "content": results})
        
        # Continue conversation
        final_response = client.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=1024,
            tools=tools,
            messages=messages
        )
        return final_response

handle_parallel_tools("Get weather in Paris AND time in London")

import anthropic
from typing import List

client = anthropic.Anthropic()

# Simulated document store (in production: vector DB)
documents = [
    {
        "id": "doc1",
        "text": "Python is a high-level programming language. It emphasizes readability.",
        "source": "Python Basics"
    },
    {
        "id": "doc2",
        "text": "JavaScript runs in browsers and enables interactive web pages.",
        "source": "Web Development"
    },
    {
        "id": "doc3",
        "text": "Python has a rich ecosystem of libraries like NumPy, Pandas, TensorFlow.",
        "source": "Python Libraries"
    }
]

def retrieve_documents(query: str, top_k: int = 3) -> List[str]:
    """Simple keyword-based retrieval (BM25-like)."""
    query_terms = query.lower().split()
    scored_docs = []
    
    for doc in documents:
        score = sum(1 for term in query_terms if term in doc["text"].lower())
        if score > 0:
            scored_docs.append((doc, score))
    
    # Sort by score and return top_k
    ranked = sorted(scored_docs, key=lambda x: x[1], reverse=True)
    return [doc["text"] for doc, _ in ranked[:top_k]]

def rag_query(user_query: str) -> str:
    """RAG pipeline: retrieve → pass to Claude → synthesize."""
    
    # Step 1: Retrieve relevant documents
    retrieved_docs = retrieve_documents(user_query, top_k=3)
    context = "\n\n".join([f"[Chunk {i+1}]\n{doc}" for i, doc in enumerate(retrieved_docs)])
    
    # Step 2: Build prompt with context
    system_prompt = """You are a helpful assistant. Answer based on the provided context.
    If context doesn't contain relevant information, say so clearly."""
    
    user_message = f"""Context:
{context}

Question: {user_query}

Answer based on the context above."""
    
    # Step 3: Get response from Claude
    response = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=1024,
        system=system_prompt,
        messages=[{"role": "user", "content": user_message}]
    )
    
    return response.content[0].text

# Test RAG
print(rag_query("What can I do with Python?"))
print("\n---\n")
print(rag_query("How does JavaScript work?"))

from collections import Counter
import math

def bm25_score(doc_text: str, query_terms: List[str]) -> float:
    """Simple BM25-like scoring."""
    doc_terms = doc_text.lower().split()
    score = 0
    for term in query_terms:
        count = doc_terms.count(term)
        score += math.log(1 + count)
    return score

def retrieve_hybrid(query: str, top_k: int = 5):
    """Hybrid retrieval: BM25 + semantic (simulated vector)."""
    query_terms = query.lower().split()
    
    results = []
    for doc in documents:
        # BM25 score
        bm25 = bm25_score(doc["text"], query_terms)
        
        # Simulated vector similarity (0-1)
        # In production: actual embedding cosine similarity
        vector_sim = 0.8 if any(term in doc["text"].lower() for term in query_terms) else 0.2
        
        # Combine scores (weighted average)
        combined = 0.4 * bm25 / 10 + 0.6 * vector_sim  # Normalize BM25
        results.append((doc, combined))
    
    # Rank and return
    ranked = sorted(results, key=lambda x: x[1], reverse=True)
    return [doc["text"] for doc, _ in ranked[:top_k]]

docs = retrieve_hybrid("Python programming language", top_k=2)
print("Retrieved documents (hybrid):")
for i, doc in enumerate(docs, 1):
    print(f"{i}. {doc[:80]}...")

response = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=8000,
    thinking={
        "type": "enabled",
        "budget_tokens": 5000  # Max thinking tokens
    },
    messages=[{
        "role": "user",
        "content": "Solve: If a train leaves NYC at 9 AM going 60 mph, and another leaves Boston at 10 AM going 50 mph, when do they meet?"
    }]
)

# Extract thinking and response
for block in response.content:
    if block.type == "thinking":
        print(f"Thinking: {block.thinking}")
    elif block.type == "text":
        print(f"Answer: {block.text}")

import base64

# Load image as base64
with open("chart.png", "rb") as f:
    image_data = base64.standard_b64encode(f.read()).decode("utf-8")

response = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=1024,
    messages=[{
        "role": "user",
        "content": [
            {
                "type": "image",
                "source": {
                    "type": "base64",
                    "media_type": "image/png",
                    "data": image_data
                }
            },
            {
                "type": "text",
                "text": "What trends do you see in this chart?"
            }
        ]
    }]
)

print(response.content[0].text)

system_prompt = """You are an expert analyst. Answer questions about the provided documents accurately."""

# Long context to cache (e.g., a large document)
cached_document = """
[Large document with thousands of tokens...]
Company History: Founded in 1990, specialized in cloud infrastructure.
Product Features: Load balancing, auto-scaling, monitoring, security.
Pricing: $99/month basic, $299/month pro, custom enterprise.
[... continues for many tokens ...]
"""

# Request with caching
response = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=1024,
    system=[
        {
            "type": "text",
            "text": system_prompt
        },
        {
            "type": "text",
            "text": cached_document,
            "cache_control": {"type": "ephemeral"}  # Cache this content
        }
    ],
    messages=[{
        "role": "user",
        "content": "What is the pricing for the basic plan?"
    }]
)

# Check cache usage
print(f"Input tokens (new): {response.usage.input_tokens}")
print(f"Cache creation tokens: {response.usage.cache_creation_input_tokens}")
print(f"Cache read tokens: {response.usage.cache_read_input_tokens}")

# Second request reuses cache
response2 = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=1024,
    system=[
        {
            "type": "text",
            "text": system_prompt
        },
        {
            "type": "text",
            "text": cached_document,
            "cache_control": {"type": "ephemeral"}
        }
    ],
    messages=[{
        "role": "user",
        "content": "What are the main product features?"
    }]
)

print(f"\nSecond request:")
print(f"Cache read tokens (reused): {response2.usage.cache_read_input_tokens}")
# Expected: much lower cost due to cache hit

# Upload a document
import os

with open("report.pdf", "rb") as f:
    file_response = client.beta.files.upload(
        file=(os.path.basename("report.pdf"), f, "application/pdf"),
        betas=["files-api-2025-04-14"]
    )

file_id = file_response.id
print(f"Uploaded file: {file_id}")

# Use file in message
response = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=2048,
    messages=[{
        "role": "user",
        "content": [
            {
                "type": "document",
                "source": {
                    "type": "file",
                    "file_id": file_id
                },
                "title": "Q1 Report"
            },
            {
                "type": "text",
                "text": "Summarize the key financial metrics."
            }
        ]
    }],
    betas=["files-api-2025-04-14"]
)

print(response.content[0].text)

# Cleanup
client.beta.files.delete(file_id, betas=["files-api-2025-04-14"])

# MCP servers are typically implemented in languages with good stdlib support
# Here's a conceptual example of what an MCP server provides

mcp_server_tools = [
    {
        "name": "get_user_by_id",
        "description": "Retrieve user information by ID",
        "input_schema": {
            "type": "object",
            "properties": {
                "user_id": {"type": "integer", "description": "User ID"}
            },
            "required": ["user_id"]
        }
    },
    {
        "name": "create_task",
        "description": "Create a new task for a user",
        "input_schema": {
            "type": "object",
            "properties": {
                "user_id": {"type": "integer"},
                "title": {"type": "string"},
                "description": {"type": "string"},
                "due_date": {"type": "string", "format": "date"}
            },
            "required": ["user_id", "title"]
        }
    }
]

mcp_resources = [
    {
        "uri": "database://users",
        "name": "Users Table",
        "description": "All user records",
        "mimeType": "application/json"
    },
    {
        "uri": "database://tasks",
        "name": "Tasks Table",
        "description": "All tasks",
        "mimeType": "application/json"
    }
]

# Claude would interact with this MCP server
# to call tools and access resources

# In production, configure MCP servers in Claude Code settings
# The MCP client proxy handles the protocol

# Within Claude conversation, tools from MCP server become available
response = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=1024,
    tools=[
        # MCP tools are injected here by Claude Code harness
        # Example MCP tool from server:
        {
            "name": "get_user_by_id",
            "description": "Retrieve user information by ID",
            "input_schema": {
                "type": "object",
                "properties": {
                    "user_id": {"type": "integer"}
                },
                "required": ["user_id"]
            }
        }
    ],
    messages=[{
        "role": "user",
        "content": "Tell me about user 123."
    }]
)

# Claude calls tool, server executes, result returned

{
  "mcp_servers": {
    "filesystem": {
      "command": "node",
      "args": ["./mcp-servers/filesystem.js"],
      "env": {
        "ALLOWED_PATHS": "/project/src,/project/docs"
      }
    },
    "database": {
      "command": "python",
      "args": ["./mcp-servers/database.py"],
      "env": {
        "DB_URL": "postgresql://localhost:5432/mydb"
      }
    }
  },
  "hooks": {
    "SessionStart": "node .claude/hooks/token-monitor.cjs",
    "PreToolUse": "node .claude/hooks/tool-validator.cjs",
    "PostToolUse": "node .claude/hooks/result-logger.cjs"
  }
}

import anthropic
import concurrent.futures

client = anthropic.Anthropic()

def research_topic(topic: str) -> str:
    """Research subtask: get info on topic."""
    response = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=500,
        messages=[{
            "role": "user",
            "content": f"Research and summarize: {topic}"
        }]
    )
    return response.content[0].text

def parallel_research(main_topic: str, subtopics: list) -> dict:
    """Execute research in parallel, synthesize results."""
    
    # Parallelize
    with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
        futures = {
            executor.submit(research_topic, subtopic): subtopic
            for subtopic in subtopics
        }
        
        results = {}
        for future in concurrent.futures.as_completed(futures):
            subtopic = futures[future]
            results[subtopic] = future.result()
    
    # Synthesize
    synthesis_prompt = f"""
Given these research summaries on {main_topic}:
{chr(10).join(f'{topic}: {result}' for topic, result in results.items())}

Create a comprehensive summary combining all insights.
"""
    
    synthesis = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=1024,
        messages=[{"role": "user", "content": synthesis_prompt}]
    )
    
    return {
        "subtopic_results": results,
        "synthesis": synthesis.content[0].text
    }

# Execute
result = parallel_research("AI Safety", ["Alignment", "Robustness", "Interpretability"])
print(result["synthesis"])

def chain_workflow(initial_data: str) -> str:
    """Execute tasks sequentially with data flow."""
    
    # Step 1: Analyze
    response1 = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=500,
        messages=[{
            "role": "user",
            "content": f"Analyze this data and identify patterns:\n{initial_data}"
        }]
    )
    analysis = response1.content[0].text
    
    # Step 2: Plan (uses analysis output)
    response2 = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=500,
        messages=[{
            "role": "user",
            "content": f"Based on this analysis:\n{analysis}\n\nCreate an action plan."
        }]
    )
    plan = response2.content[0].text
    
    # Step 3: Implement (uses plan output)
    response3 = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=1000,
        messages=[{
            "role": "user",
            "content": f"Implement this plan with code:\n{plan}"
        }]
    )
    implementation = response3.content[0].text
    
    return implementation

result = chain_workflow("Sales data: 10% growth, high churn in Q2")
print(result)

def router_agent(issue: str) -> str:
    """Route issue to appropriate handler."""
    
    # Step 1: Classify
    classifier = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=100,
        system="Classify issue as: TECHNICAL, BUSINESS, URGENT, OTHER. Respond with only the category.",
        messages=[{"role": "user", "content": issue}]
    )
    category = classifier.content[0].text.strip()
    
    # Step 2: Route and handle
    if category == "TECHNICAL":
        handler_prompt = "You are a technical expert. Solve this technical issue:\n"
    elif category == "BUSINESS":
        handler_prompt = "You are a business analyst. Address this business concern:\n"
    elif category == "URGENT":
        handler_prompt = "This is urgent. Provide immediate action items:\n"
    else:
        handler_prompt = "Address this general inquiry:\n"
    
    response = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=1024,
        messages=[{"role": "user", "content": handler_prompt + issue}]
    )
    
    return response.content[0].text

result = router_agent("Our database is down and customers can't access their accounts!")
print(result)

{
  "name": "calculate_revenue",
  "description": "Calculate total revenue for a given period and product category",
  "input_schema": {
    "type": "object",
    "properties": {
      "start_date": {"type": "string", "format": "date", "description": "ISO 8601 date"},
      "end_date": {"type": "string", "format": "date"},
      "category": {"type": "string", "enum": ["electronics", "clothing", "food"], "description": "Product category"}
    },
    "required": ["start_date", "end_date", "category"]
  }
}

if error_occurred:
    tool_result = {
        "type": "tool_result",
        "tool_use_id": use_id,
        "content": f"Error: Database connection failed. Retrying...",
        "is_error": True
    }
else:
    tool_result = {
        "type": "tool_result",
        "tool_use_id": use_id,
        "content": json.dumps({"revenue": 12345, "units": 500})
    }

def loop_agent(goal: str, max_iterations: int = 10) -> str:
    state = {"goal": goal, "steps": [], "current_info": ""}
    
    for i in range(max_iterations):
        # Perceive & Plan
        response = client.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=1024,
            tools=tools,
            system=f"Goal: {goal}\nProgress so far: {state['current_info']}",
            messages=[{"role": "user", "content": "What's the next step?"}]
        )
        
        # Check if done
        if response.stop_reason == "end_turn":
            return response.content[0].text
        
        # Act (execute tool)
        if response.stop_reason == "tool_use":
            tool_use = next(b for b in response.content if b.type == "tool_use")
            result = execute_tool(tool_use.name, tool_use.input)
            state["steps"].append((tool_use.name, result))
            state["current_info"] += f"\nStep {i+1}: {tool_use.name} → {result}"
    
    return "Max iterations reached"