import anthropic, json
client = anthropic.Anthropic()

# Define tools as JSON schemas — Claude will call these when needed
tools = [
    {
        "name": "lookup_order",
        "description": "Look up a ThreadCo order by order ID. Returns order status, tracking number, and delivery estimate.",
        "input_schema": {
            "type": "object",
            "properties": {
                "order_id": {
                    "type": "string",
                    "description": "The order ID (e.g., 'ORD-4821')"
                }
            },
            "required": ["order_id"]
        }
    },
    {
        "name": "check_stock",
        "description": "Check current stock level for a product by SKU.",
        "input_schema": {
            "type": "object",
            "properties": {
                "sku": {"type": "string", "description": "Product SKU (e.g., 'SGT-M-BLU')"}
            },
            "required": ["sku"]
        }
    },
    {
        "name": "send_email",
        "description": "Send an email to a customer. Requires human approval before sending.",
        "input_schema": {
            "type": "object",
            "properties": {
                "to": {"type": "string", "description": "Recipient email address"},
                "subject": {"type": "string"},
                "body": {"type": "string"}
            },
            "required": ["to", "subject", "body"]
        }
    }
]

def execute_tool(name: str, input: dict) -> str:
    """Execute a tool call and return the result as a string."""
    if name == "lookup_order":
        # In production, this queries your actual database
        return json.dumps({
            "order_id": input["order_id"],
            "status": "shipped",
            "tracking": "GB12345678",
            "carrier": "Royal Mail",
            "estimated_delivery": "2026-04-17"
        })
    elif name == "check_stock":
        return json.dumps({"sku": input["sku"], "in_stock": 23, "warehouse": "London"})
    else:
        return json.dumps({"error": f"Unknown tool: {name}"})

def chat_with_tools(user_message: str) -> str:
    """Run a conversation with tool use, handling the full loop."""
    messages = [{"role": "user", "content": user_message}]

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

        # If Claude wants to use tools, execute them and continue
        if resp.stop_reason == "tool_use":
            # Add Claude's response (contains tool_use blocks)
            messages.append({"role": "assistant", "content": resp.content})

            # Execute each tool call and add results
            tool_results = []
            for block in resp.content:
                if block.type == "tool_use":
                    result = execute_tool(block.name, block.input)
                    tool_results.append({
                        "type": "tool_result",
                        "tool_use_id": block.id,
                        "content": result
                    })

            messages.append({"role": "user", "content": tool_results})
        else:
            # Claude is done — return the final text response
            return resp.content[0].text

# Usage:
answer = chat_with_tools("Customer #4821 is asking where their order is. Look it up and draft a reply.")
print(answer)

You:
Customer Maya Johnson (order #4821) is asking if she can exchange
her Sunset Gradient Tee (size M) for a size L. Check:
1. Her order status (is it still exchangeable?)
2. Stock for SKU SGT-L-AMB (Sunset Gradient, Large, Amber)
3. If both are good, draft the exchange confirmation email.

Claude's internal process:
Step 1: Call lookup_order("ORD-4821") → Order delivered 3 days ago, within return window
Step 2: Call check_stock("SGT-L-AMB") → 23 in stock
Step 3: Both conditions met → Draft email using send_email tool
        (but waits for human approval before sending)

def execute_tool_safely(name: str, input: dict) -> dict:
    """Execute a tool with proper error handling for Claude."""
    try:
        result = execute_tool(name, input)
        return {"type": "tool_result", "content": result}
    except ValueError as e:
        # Input validation error — tell Claude what was wrong
        return {
            "type": "tool_result",
            "content": json.dumps({
                "error": "invalid_input",
                "message": str(e),
                "hint": "Check the parameter format and try again"
            }),
            "is_error": True  # Tells Claude this is an error, not a result
        }
    except ConnectionError:
        # Service unavailable — Claude should tell the user, not retry endlessly
        return {
            "type": "tool_result",
            "content": json.dumps({
                "error": "service_unavailable",
                "message": "The order database is temporarily unavailable",
                "suggestion": "Inform the customer and offer to follow up"
            }),
            "is_error": True
        }
    except Exception as e:
        # Unexpected error — log it and give Claude a generic message
        print(f"Tool error: {name} — {e}")  # Log for debugging
        return {
            "type": "tool_result",
            "content": json.dumps({"error": "internal_error", "message": "An unexpected error occurred"}),
            "is_error": True
        }

// .vscode/settings.json — add MCP servers for Claude Code
{
  "claude.mcpServers": {
    "threadco-orders": {
      "command": "node",
      "args": ["./mcp-servers/orders-server.js"],
      "description": "Look up ThreadCo order status and tracking info"
    },
    "threadco-stock": {
      "command": "node",
      "args": ["./mcp-servers/stock-server.js"],
      "description": "Check live stock levels by SKU"
    }
  }
}

You (in Claude Code chat):
Customer #4821 is asking where their order is.
Look up the order and draft a reply email.

Claude (uses threadco-orders MCP tool automatically):
Order #4821 — Maya Johnson
Status: Shipped
Carrier: Royal Mail, tracking GB12345678
Estimated delivery: Thursday 17 April

Draft reply:
"Hi Maya, your order shipped yesterday via Royal Mail.
Tracking number: GB12345678 — expected Thursday. Let us know
if it doesn't arrive by Friday and we'll investigate."