import anthropic
client = anthropic.Anthropic()

# Basic streaming — tokens arrive as they're generated
with client.messages.stream(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Write a product description for the Sunset Gradient Tee."}]
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

# Streaming with event handling — more control
with client.messages.stream(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Analyse ThreadCo's Q1 sales data."}]
) as stream:
    for event in stream:
        if event.type == "content_block_delta":
            print(event.delta.text, end="", flush=True)
        elif event.type == "message_stop":
            print("

[Stream complete]")

    # Access the final message after streaming
    final = stream.get_final_message()
    print(f"Total tokens: {final.usage.input_tokens} in, {final.usage.output_tokens} out")

import anthropic
client = anthropic.Anthropic()

# The system prompt and brand guide are the same for every product description request
# Marking them with cache_control means they're cached after the first call
BRAND_GUIDE = """ThreadCo Brand Voice Guide

Tone: Friendly, direct, slightly playful. Never corporate.
Sustainability is a feature, not a badge — mention it naturally.
Forbidden words: vibrant, perfect, stylish, must-have, luxurious
No exclamation marks in product copy.
Always mention the material (organic cotton, recycled polyester, etc.)
Always mention where it's made (Portugal, Turkey, etc.)
Two sentences maximum per product description.

... (imagine this is 2,000 words of detailed brand guidelines) ..."""

def describe_product(product_name: str, details: str) -> str:
    resp = client.messages.create(
        model="claude-sonnet-4-6", max_tokens=150,
        system=[
            {
                "type": "text",
                "text": "You are a ThreadCo copywriter."
            },
            {
                "type": "text",
                "text": BRAND_GUIDE,
                "cache_control": {"type": "ephemeral"}  # Cache this block
            }
        ],
        messages=[{"role": "user", "content": f"Write a product description for {product_name}. Details: {details}"}]
    )
    return resp.content[0].text

# First call: full price (brand guide is processed and cached)
describe_product("Sunset Gradient Tee", "Organic cotton, made in Portugal, amber-to-rose gradient")

# Second call: 90% cheaper for the cached brand guide portion
describe_product("Midnight Pocket Tee", "Organic cotton, made in Portugal, navy, single chest pocket")

# At 2,000 product descriptions, prompt caching saves ~$50+ per batch

import anthropic
client = anthropic.Anthropic()

# Prepare batch requests — one per product
products = [
    {"name": "Sunset Gradient Tee", "details": "Organic cotton, amber-to-rose gradient"},
    {"name": "Midnight Pocket Tee", "details": "Organic cotton, navy, chest pocket"},
    {"name": "Wave Print Crop Tee", "details": "Recycled cotton blend, wave pattern"},
    # ... imagine 2,000 products
]

requests = []
for i, product in enumerate(products):
    requests.append({
        "custom_id": f"product-{i}",
        "params": {
            "model": "claude-haiku-4-5-20251001",
            "max_tokens": 150,
            "messages": [{
                "role": "user",
                "content": f"Write a 2-sentence ThreadCo product description for {product['name']}. {product['details']}. Mention sustainability. No exclamation marks."
            }]
        }
    })

# Submit the batch — processes asynchronously
batch = client.batches.create(requests=requests)
print(f"Batch {batch.id} submitted with {len(requests)} requests")
print(f"Status: {batch.processing_status}")

# Check status later (or poll)
# batch = client.batches.retrieve(batch.id)
# Results available via batch.results_url when processing_status == "ended"

import anthropic
client = anthropic.Anthropic()

resp = client.messages.create(
    model="claude-opus-4-6",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000  # How many tokens Claude can spend thinking
    },
    messages=[{
        "role": "user",
        "content": """Review ThreadCo's pricing strategy:
- Current: £28 average price, 42% margin, 500 orders/week
- Competitors: £25-£45 range
- Customer feedback: "good value" but some price sensitivity
- Goal: Increase margin to 50% without losing more than 10% volume

Propose three strategies, model the financial impact of each,
and recommend one with justification."""
    }]
)

# The response contains both thinking blocks and text blocks
for block in resp.content:
    if block.type == "thinking":
        print(f"[Thinking: {len(block.thinking)} chars]")
        # Optionally inspect the thinking for debugging
    elif block.type == "text":
        print(block.text)

import asyncio, anthropic
client = anthropic.Anthropic()

async def execute_tool_async(name: str, input: dict) -> dict:
    """Execute a tool call asynchronously."""
    # In production, this would be an async database query or API call
    await asyncio.sleep(0.1)  # Simulate network latency
    return {"sku": input["sku"], "in_stock": 23}

async def handle_parallel_tools(response) -> list:
    """Execute all tool calls from a response in parallel."""
    tool_calls = [b for b in response.content if b.type == "tool_use"]

    # Run all tool calls concurrently
    tasks = [execute_tool_async(tc.name, tc.input) for tc in tool_calls]
    results = await asyncio.gather(*tasks)

    # Map results back to tool_use_ids
    return [
        {"type": "tool_result", "tool_use_id": tc.id, "content": json.dumps(result)}
        for tc, result in zip(tool_calls, results)
    ]

# When Claude calls 3 stock checks at once, they all execute simultaneously
# Total latency = max(individual latency), not sum(individual latencies)

# ThreadCo — Claude Standing Instructions

## Brand Voice
- Friendly, direct, slightly playful. Never corporate.
- Sustainability is a feature, not a badge. Mention it naturally.
- Forbidden words: vibrant, perfect, stylish, must-have, luxurious
- No exclamation marks in product copy.

## Code Conventions
- TypeScript everywhere. Prefer `const` over `let`.
- All async functions must handle errors explicitly.
- Test files live in __tests__/ next to the source file.

## Review Checklist
When reviewing any pull request, always check:
1. Does it have tests?
2. Are error states handled?
3. Does the UI copy match the brand voice above?