JaatoClient

from jaato import JaatoClient, PluginRegistry

client = JaatoClient()
client.connect()  # Reads JAATO_PROVIDER and MODEL_NAME from env

registry = PluginRegistry(model_name=client.model_name)
registry.discover()
registry.expose_tool("cli")
client.configure_tools(registry)

response = client.send_message(
    "List files in current directory",
    on_output=lambda s, t, m: print(t, end="")
)

# Default: uses JAATO_PROVIDER env var or google_genai
client = JaatoClient()

# Google GenAI (Vertex AI / AI Studio)
client = JaatoClient(provider_name="google_genai")

# Anthropic Claude (API key or OAuth)
client = JaatoClient(provider_name="anthropic")

# GitHub Models (multi-model access)
client = JaatoClient(provider_name="github_models")

# Claude CLI (uses subscription, not API credits)
client = JaatoClient(provider_name="claude_cli")

# Antigravity (Google IDE backend)
client = JaatoClient(provider_name="antigravity")

# Ollama (local models)
client = JaatoClient(provider_name="ollama")

# .env file
JAATO_PROVIDER=anthropic
MODEL_NAME=claude-sonnet-4-20250514

# Or for Ollama
JAATO_PROVIDER=ollama
OLLAMA_MODEL=qwen3:32b

# Reads JAATO_PROVIDER and MODEL_NAME from env
client = JaatoClient()
client.connect()

# Check connection
if client.is_connected:
    print(f"Connected to {client.model_name}")

# Override provider and model in code
client = JaatoClient(provider_name="anthropic")
client.connect(model="claude-sonnet-4-20250514")

# Google GenAI (Vertex AI) with project/location
client = JaatoClient(provider_name="google_genai")
client.connect(
    project="my-gcp-project",
    location="us-central1",
    model="gemini-2.5-flash"
)

# Access runtime for subagent creation
runtime = client.get_runtime()
sub_session = runtime.create_session(
    model="claude-sonnet-4-20250514",
    tools=["cli", "web_search"],
    system_instructions="You are a researcher."
)
sub_response = sub_session.send_message("Research...")

# Access main session directly
main_session = client.get_session()
history = main_session.get_history()

# For providers with OAuth (Anthropic, Antigravity)
client = JaatoClient(provider_name="anthropic")
client.connect()  # Reads MODEL_NAME from env

# Verify auth - triggers browser OAuth if needed
if not client.verify_auth(
    allow_interactive=True,
    on_message=lambda msg: print(f"Auth: {msg}")
):
    print("Authentication failed")
    return

# Now safe to configure tools
client.configure_tools(registry, permission_plugin, ledger)

from jaato import JaatoClient, PluginRegistry
from shared import PermissionPlugin, TokenLedger

client = JaatoClient()
client.connect()  # Reads JAATO_PROVIDER and MODEL_NAME from env

# Setup registry
registry = PluginRegistry(model_name=client.model_name)
registry.discover()
registry.expose_tool("cli")
registry.expose_tool("file_edit")

# Optional: permission control
perm = PermissionPlugin()
perm.initialize({"config_path": "perms.json"})

# Optional: token accounting
ledger = TokenLedger()

# Configure
client.configure_tools(
    registry,
    permission_plugin=perm,
    ledger=ledger
)

from jaato import ToolSchema

# Define custom tool
def get_weather(city: str) -> str:
    return f"Weather in {city}: Sunny, 72F"

tools = [
    ToolSchema(
        name="get_weather",
        description="Get current weather",
        parameters={
            "type": "object",
            "properties": {
                "city": {"type": "string"}
            },
            "required": ["city"]
        }
    )
]

executors = {"get_weather": get_weather}

client.configure_custom_tools(
    tools=tools,
    executors=executors
)

# Output callback
def on_output(source, text, mode):
    """
    source: "model", plugin name, or "system"
    text: output text
    mode: "write" (new) or "append" (continue)
    """
    if mode == "write":
        print(f"\n[{source}]", end=" ")
    print(text, end="")

# Send message
response = client.send_message(
    "What files are in this directory?",
    on_output=on_output
)

print(f"\n\nFinal: {response}")

from jaato import Part, Attachment

# Create parts with image
parts = [
    Part.from_text("What's in this image?"),
    Part(inline_data=Attachment(
        mime_type="image/png",
        data=open("image.png", "rb").read()
    ))
]

response = client.send_message_with_parts(
    parts,
    on_output=on_output
)

# One-shot, no tools, no history
result = client.generate("What is 2 + 2?")
print(result)  # "4"

# Get conversation history
history = client.get_history()
for msg in history:
    print(f"{msg.role}: {msg.text[:50]}...")

# Check turn info
turns = client.get_turn_boundaries()
print(f"Conversation has {len(turns)} turns")

# Get per-turn stats
accounting = client.get_turn_accounting()
for turn in accounting:
    print(f"Turn {turn['turn_id']}: "
          f"{turn['tokens']} tokens")

# Revert to earlier turn
client.revert_to_turn(2)

# Clear and start fresh
client.reset_session()

# Reset with custom history
client.reset_session(history=custom_history)

# Check context limits
limit = client.get_context_limit()
usage = client.get_context_usage()

print(f"Limit: {limit} tokens")
print(f"Used: {usage['total_tokens']} tokens")
print(f"Available: {limit - usage['total_tokens']}")

from shared.plugins.gc_truncate import (
    create_plugin as create_gc
)
from shared.plugins.gc import GCConfig

# Create GC plugin
gc_plugin = create_gc()
gc_plugin.initialize({
    "preserve_recent_turns": 10
})

# Configure with threshold (or use JAATO_GC_THRESHOLD env var)
config = GCConfig(
    threshold_percent=75.0,  # overrides env var default
    check_before_send=True
)

client.set_gc_plugin(gc_plugin, config)

# Manual GC
result = client.manual_gc()
print(f"Freed {result.tokens_freed} tokens")

# Check GC history
for gc in client.get_gc_history():
    print(f"GC at turn {gc.turn}: "
          f"{gc.tokens_freed} freed")

# Disable GC
client.remove_gc_plugin()

from shared.plugins.session import (
    create_plugin as create_session
)
from shared.plugins.session import SessionConfig

# Setup session plugin
session = create_session()
session.initialize({
    "storage_path": ".jaato/sessions"
})

config = SessionConfig(
    auto_resume_last=True
)

client.set_session_plugin(session, config)

# ... have conversation ...

# Save session
session_id = client.save_session()
print(f"Saved: {session_id}")

# Later: resume
client.resume_session(session_id)

# List all sessions
for info in client.list_sessions():
    print(f"{info.id}: {info.created_at}")

# Delete old session
client.delete_session(old_session_id)

from jaato_sdk.plugins.model_provider.types import ThinkingConfig

# Check support
if client.supports_thinking():
    # Enable thinking with budget
    client.set_thinking_config(ThinkingConfig(
        enabled=True,
        budget=10000  # Max thinking tokens
    ))

    response = client.send_message(
        "Analyze this complex problem...",
        on_output=on_output
    )

    # Disable thinking
    client.set_thinking_config(ThinkingConfig(enabled=False))

from shared.plugins.thinking import create_plugin as create_thinking

# Create and set thinking plugin
thinking = create_thinking()
thinking.initialize({"default_budget": 8192})
client.set_thinking_plugin(thinking)

# User commands now available:
# /thinking on - enable thinking
# /thinking off - disable thinking
# /thinking budget 16000 - set budget

from shared.plugins.subagent.ui_hooks import AgentUIHooks

class MyUIHooks(AgentUIHooks):
    def on_agent_created(self, agent_id, agent_name, ...):
        print(f"Agent {agent_name} created")

    def on_agent_output(self, agent_id, source, text, mode):
        # Display streaming output
        print(text, end="")

    def on_agent_turn_completed(self, agent_id, turn_number,
                                prompt_tokens, output_tokens, ...):
        print(f"Turn {turn_number}: {output_tokens} tokens")

    def on_agent_context_updated(self, agent_id, total_tokens,
                                 percent_used, ...):
        print(f"Context: {percent_used:.1f}% used")

# Set hooks on client
client.set_ui_hooks(MyUIHooks())
client.set_terminal_width(120)

# Or set full presentation context
from jaato import PresentationContext, ClientType
client.set_presentation_context(PresentationContext(
    content_width=120,
    client_type=ClientType.TERMINAL,
))

# List available commands
commands = client.get_user_commands()
for name, cmd in commands.items():
    print(f"/{name}: {cmd.description}")

# Execute a command
result, share = client.execute_user_command(
    "todo_list",
    args={"filter": "pending"}
)

print(result)

# If share is True, add result to conversation
if share:
    client.send_message(
        f"Command result: {result}",
        on_output=on_output
    )

import threading
from jaato import JaatoClient, CancelledException

client = JaatoClient()
client.connect()  # Reads JAATO_PROVIDER and MODEL_NAME from env
# ... configure tools ...

# Enable streaming for mid-generation cancellation
client.set_streaming_enabled(True)

# Cancel after 10 seconds
def cancel_after_timeout():
    time.sleep(10)
    if client.is_processing:
        print("Timeout - stopping...")
        client.stop()

timer = threading.Thread(target=cancel_after_timeout)
timer.start()

try:
    response = client.send_message(
        "Write a very long essay...",
        on_output=lambda s, t, m: print(t, end="")
    )
    print(f"\n\nFinished normally")
except CancelledException:
    print(f"\n\nRequest was cancelled")
finally:
    timer.join()

# With streaming enabled, tokens arrive
# incrementally via the on_output callback
client.set_streaming_enabled(True)

def on_output(source, text, mode):
    # mode="write" for new block
    # mode="append" for continuation
    print(text, end="", flush=True)

response = client.send_message(
    "Count from 1 to 100",
    on_output=on_output
)
# Output appears token-by-token!

# Prevent 429 errors by limiting request rate
# Example: max 2 requests per second
AI_REQUEST_INTERVAL=0.5

# Retry configuration (reactive)
AI_RETRY_ATTEMPTS=5
AI_RETRY_BASE_DELAY=1.0
AI_RETRY_MAX_DELAY=30.0

# Route retry messages to a queue
# (for rich UIs that don't want console spam)
session = client.get_session()
session.set_retry_callback(
    lambda msg, attempt, max_att, delay:
        status_queue.put({
            "type": "retry",
            "message": msg,
            "attempt": attempt,
            "max_attempts": max_att,
            "delay": delay
        })
)

# Revert to console output
session.set_retry_callback(None)

Request Flow:
┌──────────────┐    ┌──────────────┐    ┌──────────────┐
│   Request    │───>│ RequestPacer │───>│  API Call    │
│              │    │ (proactive)  │    │              │
└──────────────┘    │ waits if     │    └──────┬───────┘
                    │ interval not │           │
                    │ elapsed      │           v
                    └──────────────┘    ┌──────────────┐
                                        │  429 Error?  │
                                        │  with_retry  │
                                        │  (reactive)  │
                                        └──────────────┘

# Provider selection (choose one)
JAATO_PROVIDER=anthropic
MODEL_NAME=claude-sonnet-4-20250514

# Anthropic credentials
ANTHROPIC_API_KEY=sk-ant-api03-...

# Google GenAI credentials (if using google_genai)
# GOOGLE_GENAI_API_KEY=AIza...
# Or for Vertex AI:
# JAATO_GOOGLE_PROJECT=my-gcp-project
# JAATO_GOOGLE_LOCATION=us-central1

# GitHub Models credentials (if using github_models)
# GITHUB_TOKEN=ghp_...

# Ollama (if using ollama)
# OLLAMA_HOST=http://localhost:11434

# General settings
AI_USE_CHAT_FUNCTIONS=1
JAATO_PARALLEL_TOOLS=true
JAATO_DEFERRED_TOOLS=true
JAATO_GC_THRESHOLD=80.0

# Rate limiting
AI_REQUEST_INTERVAL=0.5
AI_RETRY_ATTEMPTS=5