from statebase import StateBase, StateBaseError

sb = StateBase(api_key="your-key")

try:
    session = sb.sessions.create(agent_id="chatbot")
except StateBaseError as e:
    print(f"StateBase error: {e.status_code} {e.message}")
    # e.code      -> machine-readable code, e.g. "session_not_found"
    # e.docs      -> link to the relevant docs page
    # e.suggestion-> what to do next

sb = StateBase(
    api_key="your-key",
    max_retries=3,          # default: 3
    backoff_factor=0.5,     # 0.5s, 1s, 2s, 4s...
    jitter=True,            # add randomness to avoid thundering herd
    timeout=30.0,           # per-request timeout in seconds
)

import time
from statebase import RateLimitError, APIError

def with_retry(fn, max_attempts=5):
    for attempt in range(max_attempts):
        try:
            return fn()
        except RateLimitError as e:
            wait = e.retry_after or (2 ** attempt)
            time.sleep(wait)
        except APIError:
            time.sleep(2 ** attempt)
    raise RuntimeError("Exhausted retries")

import uuid

sb.sessions.add_turn(
    session_id=session.id,
    input="Book a flight",
    output="Booked flight #123",
    idempotency_key=str(uuid.uuid4()),
)

try:
    result = call_tool(name, args)
    sb.sessions.update_state(
        session_id=session_id,
        state={"last_tool": "ok"},
        reasoning="Tool succeeded"
    )
except StateBaseError:
    # The tool may or may not have run — roll back to the pre-call checkpoint
    sb.sessions.rollback(session_id=session_id, version=-1)
    raise

import { StateBase, StateBaseError } from '@statebase/client';

const sb = new StateBase({ apiKey: process.env.SB_KEY });

try {
  const session = await sb.sessions.create({ agentId: 'chatbot' });
} catch (err) {
  if (err instanceof StateBaseError && err.retryable) {
    await sb.sessions.create({ agentId: 'chatbot' }); // one retry
  }
}