Anthropic Provider

from shared import load_provider, ProviderConfig

provider = load_provider("anthropic")

# Initialize with API key
provider.initialize(ProviderConfig(
    api_key="sk-ant-...",  # or from ANTHROPIC_API_KEY env
))

# Connect to a model
provider.connect("claude-sonnet-4-20250514")

# Start chatting
provider.create_session(
    system_instruction="You are helpful."
)
response = provider.send_message("Hello!")
print(response.text)

provider.initialize(ProviderConfig(
    api_key="sk-ant-...",
    extra={
        'enable_thinking': True,
        'thinking_budget': 10000
    }
))

# Response includes reasoning
response = provider.send_message("Complex question")
print(f"Thinking: {response.thinking}")
print(f"Answer: {response.text}")

provider.initialize(ProviderConfig(
    api_key="sk-ant-...",
    extra={
        'enable_thinking': True,
        'thinking_budget': 15000  # More tokens for complex tasks
    }
))

response = provider.send_message(
    "Explain the trade-offs between microservices and monolith"
)

# Check if thinking is present
if response.has_thinking:
    print("=== Claude's reasoning ===")
    print(response.thinking)
    print()

print("=== Final answer ===")
print(response.text)

=== Claude's reasoning ===
Let me think through the key trade-offs:

For microservices:
- Pros: Independent deployment, technology flexibility...
- Cons: Distributed systems complexity, network latency...

For monolith:
- Pros: Simpler to develop initially, no network overhead...
- Cons: Deployment coupling, scaling limitations...

I should structure this by category: development, deployment,
scaling, and operations...

=== Final answer ===
Here are the key trade-offs between microservices and monolith architectures:
...

provider.initialize(ProviderConfig(
    api_key="sk-ant-...",
    extra={
        'enable_caching': True
    }
))

Without caching:
  100K tokens × $3.00/MTok = $0.30 per request

With caching:
  First request: $0.375 (1.25x write cost)
  Subsequent:    $0.03  (0.1x read cost)

After 2 requests: 75% savings
After 10 requests: 90% savings

from jaato import ToolSchema

tools = [
    ToolSchema(name='search', description='...', parameters={...}),
    ToolSchema(name='execute', description='...', parameters={...}),
    ToolSchema(name='read_file', description='...', parameters={...}),
    # ... many more tools
]

provider.create_session(
    system_instruction="You are an AI assistant...",
    tools=tools  # Tools and system cached automatically
)

from jaato import ToolSchema, ToolResult

# Define tool with standard ToolSchema
tools = [ToolSchema(
    name='get_weather',
    description='Get current weather for a location',
    parameters={
        "type": "object",
        "properties": {
            "location": {"type": "string", "description": "City name"}
        },
        "required": ["location"]
    }
)]

# Create session with tools
provider.create_session(
    system_instruction="You are a weather assistant.",
    tools=tools
)

# Model may request tool use
response = provider.send_message("What's the weather in Tokyo?")

if response.function_calls:
    fc = response.function_calls[0]
    print(f"Tool: {fc.name}, Args: {fc.args}")
    # Tool: get_weather, Args: {'location': 'Tokyo'}

    # Send result back
    result = ToolResult(
        call_id=fc.id,
        name=fc.name,
        result={"temp": 22, "condition": "sunny"}
    )
    response = provider.send_tool_results([result])
    print(response.text)
    # "The weather in Tokyo is 22°C and sunny!"

# Option 1: API Key (uses API credits)
ANTHROPIC_API_KEY=sk-ant-api03-...

# Option 2: OAuth Token (uses subscription)
ANTHROPIC_AUTH_TOKEN=sk-ant-oat01-...

# Option 3: PKCE OAuth - no env var needed

from shared.plugins.model_provider.anthropic import oauth_login

# Trigger browser-based OAuth
token = oauth_login(
    on_message=lambda msg: print(msg)
)
# Opens browser, user logs in
# Token is automatically saved

# Or via JaatoClient
client = JaatoClient(provider_name="anthropic")
client.connect(None, None, "claude-sonnet-4-20250514")
client.verify_auth(allow_interactive=True)

# Install Claude CLI
npm install -g @anthropic-ai/claude-code

# Get OAuth token
claude setup-token

# Token saved to ~/.claude/settings.json

from shared.plugins.model_provider.anthropic.errors import (
    APIKeyNotFoundError,
    APIKeyInvalidError,
    RateLimitError,
    OverloadedError,
)

try:
    provider.initialize(config)
    provider.send_message("Hello")
except APIKeyNotFoundError:
    print("Set ANTHROPIC_API_KEY environment variable")
except APIKeyInvalidError:
    print("Check your API key at console.anthropic.com")
except RateLimitError:
    print("Too many requests, retry later")
except OverloadedError:
    print("Anthropic API is busy, retry in a moment")

from shared import load_provider, ProviderConfig

provider = load_provider("anthropic")
provider.initialize(ProviderConfig(
    api_key="sk-ant-...",  # Or use ANTHROPIC_API_KEY env
    extra={
        'enable_caching': True,     # 90% cost reduction
        'enable_thinking': True,    # Reasoning traces
        'thinking_budget': 15000,   # Max thinking tokens
    }
))

provider.connect("claude-sonnet-4-20250514")

# Create session
provider.create_session(
    system_instruction="You are a helpful assistant.",
    tools=[...]  # Optional tools
)

# Chat
response = provider.send_message("Explain quantum computing")
print(f"Thinking: {response.thinking}")
print(f"Answer: {response.text}")

# .env
ANTHROPIC_API_KEY=sk-ant-api03-...
JAATO_PROVIDER=anthropic
MODEL_NAME=claude-sonnet-4-20250514