Connection Recovery

import asyncio
from jaato_sdk import IPCRecoveryClient

async def main():
    # Same facade as IPCClient.session, on the auto-reconnect client.
    # Connect, session creation, and reattachment are handled for you;
    # ask() survives a daemon restart. Credentials resolve from the
    # profile (e.g. a pass:// knob), never an env var.
    async with IPCRecoveryClient.session(
        profile={"model": "...", "provider": "...", "plugins": []},
        on_status_change=lambda st: print(st.state),  # RECONNECTING / CONNECTED
    ) as s:
        print(await s.ask("Long task..."))

asyncio.run(main())

from jaato_sdk.client import (
    IPCRecoveryClient,
    ConnectionState,
)
from jaato_sdk.events import ClientType

client = IPCRecoveryClient(
    "/tmp/jaato.sock",
    client_type=ClientType.TERMINAL,
)

# Check state directly
if client.state == ConnectionState.CONNECTED:
    await client.send_message("Hello!")

# Convenience properties
client.is_connected      # True when CONNECTED
client.is_reconnecting   # True when RECONNECTING
client.is_closed         # True when CLOSED

from jaato_sdk.client import ConnectionState

ConnectionState.DISCONNECTED   # "disconnected"
ConnectionState.CONNECTING     # "connecting"
ConnectionState.CONNECTED      # "connected"
ConnectionState.RECONNECTING   # "reconnecting"
ConnectionState.DISCONNECTING  # "disconnecting"
ConnectionState.CLOSED         # "closed"

from jaato_sdk.client import (
    IPCRecoveryClient,
    ConnectionState,
)
from jaato_sdk.client.recovery import ConnectionStatus
from jaato_sdk.events import ClientType

def on_status(status: ConnectionStatus):
    """Update UI based on connection state."""
    if status.state == ConnectionState.CONNECTED:
        show_status("Connected")
        enable_input()

    elif status.state == ConnectionState.RECONNECTING:
        msg = (
            f"Reconnecting (attempt {status.attempt}"
            f"/{status.max_attempts})"
        )
        if status.next_retry_in is not None:
            msg += f" — retry in {status.next_retry_in:.1f}s"
        show_status(msg)
        disable_input()

    elif status.state == ConnectionState.CONNECTING:
        show_status("Connecting...")

    elif status.state == ConnectionState.CLOSED:
        if status.last_error:
            show_status(f"Disconnected: {status.last_error}")
        else:
            show_status("Disconnected")
        disable_input()

client = IPCRecoveryClient(
    socket_path="/tmp/jaato.sock",
    client_type=ClientType.TERMINAL,   # required
    on_status_change=on_status,
)

from jaato_sdk.client.recovery import (
    ReconnectingError,
    ConnectionClosedError,
)

async def send_with_retry(client, message):
    """Send a message, queuing if reconnecting."""
    while True:
        try:
            await client.send_message(message)
            return
        except ReconnectingError:
            # Wait for reconnection, then retry
            print("Reconnecting — message queued...")
            await wait_for_connected(client)
        except ConnectionClosedError:
            print("Connection closed permanently.")
            raise

async def wait_for_connected(client):
    """Wait until client reconnects."""
    while client.is_reconnecting:
        await asyncio.sleep(0.5)
    if client.is_closed:
        raise ConnectionClosedError()

# The events() iterator automatically reconnects.
# It yields events from the new connection
# seamlessly — no special handling needed.

async for event in client.events():
    # This keeps working across reconnections.
    # You don't need try/except here.
    handle_event(event)

from jaato_sdk.events import ClientType

client = IPCRecoveryClient(
    "/tmp/jaato.sock",
    client_type=ClientType.TERMINAL,
)
await client.connect()

# Create session and track it
# (optionally with an agent profile)
session_id = await client.create_session(
    "work", profile="researcher-claude"
)
client.set_session_id(session_id)

# After reconnection, the client automatically
# sends session.attach with this session_id.
# The server restores conversation history.

# If you have a session ID from a previous run
# (e.g., stored in a config file), you can
# reattach manually:

client = IPCRecoveryClient(
    "/tmp/jaato.sock",
    client_type=ClientType.TERMINAL,
)
await client.connect()

# Attach to existing session
success = await client.attach_session(
    "previous-session-id"
)
if success:
    # Track it for future reconnections
    client.set_session_id("previous-session-id")

{
  "recovery": {
    "enabled": true,
    "max_attempts": 10,
    "base_delay": 1.0,
    "max_delay": 60.0,
    "jitter_factor": 0.3,
    "connection_timeout": 5.0,
    "reattach_session": true
  }
}

from jaato_sdk.client import (
    IPCRecoveryClient,
    RecoveryConfig,
)
from jaato_sdk.events import ClientType

# Custom config
config = RecoveryConfig(
    max_attempts=5,
    base_delay=2.0,
    max_delay=30.0,
)

client = IPCRecoveryClient(
    socket_path="/tmp/jaato.sock",
    client_type=ClientType.TERMINAL,   # required
    config=config,
)

# Or load from config files automatically
from jaato_sdk.client import get_recovery_config

config = get_recovery_config(
    workspace_path="/path/to/project"
)
client = IPCRecoveryClient(
    socket_path="/tmp/jaato.sock",
    client_type=ClientType.TERMINAL,   # required
    config=config,
)

import asyncio
import jaato

async def main():
    # Same facade as IPCRecoveryClient, over WebSocket. Reconnection,
    # session creation, and reattachment are handled for you; ask()
    # survives a daemon restart or a dropped socket.
    async with jaato.session(
        mode="ws",
        url="wss://host:8080",
        token="...",                 # bearer token (or ?token= in the url)
        recovery=True,               # → WSRecoveryClient
        ca="/etc/jaato/dev-ca.pem",  # trust a self-signed wss:// cert
        on_status_change=lambda st: print(st.state),  # RECONNECTING / CONNECTED
    ) as s:
        print(await s.ask("Long task..."))

asyncio.run(main())

from jaato_sdk import WSRecoveryClient
from jaato_sdk.events import ClientType

client = WSRecoveryClient(
    url="wss://host:8080",
    token="...",
    client_type=ClientType.API,
    ca="/etc/jaato/dev-ca.pem",   # or ssl=<ssl.SSLContext>
    on_status_change=lambda st: print(st.state),
)
# Same connection-lifecycle API as IPCRecoveryClient:
# connect() / create_session() / send_message() / events().

// Raw WebSocket reconnect (no SDK). With @jaato/sdk, `recovery: {}` does all of
// this for you; this shows the underlying frames.

class JaatoWebClient {
  private ws: WebSocket | null = null;
  private sessionId: string | null = null;
  private workspacePath: string | null = null; // the session's own workspace
  private reconnectAttempt = 0;
  private maxAttempts = 10;

  // url carries the bearer token: wss://<host>/?token=<token>
  // For a self-signed dev wss://, trust the dev CA out-of-band
  // (e.g. NODE_EXTRA_CA_CERTS), never by disabling verification.
  connect(url: string) {
    this.ws = new WebSocket(url);

    this.ws.onmessage = (e) => {
      const frame = JSON.parse(e.data);
      switch (frame.type) {
        case "connected": // unprompted greeting — only now is it safe to send
          this.reconnectAttempt = 0;
          if (this.sessionId) this.reattach();
          break;
        case "session.list": // find the session's workspace, then select + attach
          this.workspacePath =
            frame.sessions.find((s) => s.id === this.sessionId)?.workspace_path;
          this.send({ type: "workspace.select", name: this.workspacePath });
          this.send({ type: "command.execute",
                      command: "session.attach", args: [this.sessionId] });
          break;
        case "error": // recoverable "Session not found" while the ~15s cold
          if (frame.recoverable) this.reattach(); // restore settles — resend
          break;
      }
    };

    this.ws.onclose = () => this.scheduleReconnect(url);
  }

  // A fresh connection gets its own workspace, so the session created on an
  // earlier connection isn't reachable until we select its workspace. List
  // sessions to find its workspace_path; the handler above does select + attach.
  private reattach() {
    this.send({ type: "command.execute", command: "session.list", args: [] });
  }

  private scheduleReconnect(url: string) {
    if (this.reconnectAttempt >= this.maxAttempts) return; // give up

    const delay = Math.min(60_000, 1000 * Math.pow(2, this.reconnectAttempt));
    this.reconnectAttempt++;
    setTimeout(() => this.connect(url), delay);
  }

  private send(frame: unknown) {
    this.ws?.send(JSON.stringify(frame));
  }
}

# Imports
from jaato_sdk.client import (
    IPCRecoveryClient,
    ConnectionState,
    RecoveryConfig,
    get_recovery_config,
)
from jaato_sdk.client.recovery import (
    ConnectionStatus,
    ReconnectingError,
    ConnectionClosedError,
    IncompatibleServerError,
)
from jaato_sdk.events import ClientType

# States
ConnectionState.DISCONNECTED
ConnectionState.CONNECTING
ConnectionState.CONNECTED
ConnectionState.RECONNECTING
ConnectionState.DISCONNECTING
ConnectionState.CLOSED

# Key methods
client.connect()           # Start connection
client.disconnect()        # Temporary disconnect
client.close()             # Permanent close
client.set_session_id(id)  # Track for recovery
client.send_message(text)  # Send (raises on down)
client.events()            # Auto-reconnecting stream

# Properties
client.state               # ConnectionState
client.is_connected        # bool
client.is_reconnecting     # bool
client.is_closed           # bool
client.session_id          # str | None