Everruns SDKs for Rust, Python, TypeScript

The Everruns SDKs are official client libraries for building agent applications. Rust, Python, and TypeScript with a consistent API across all three.

What the SDKs handle for you:

• Consistent API across languages
• Async/await patterns throughout
• SSE streaming with automatic reconnection, heartbeat-based stale detection, and since_id resumption
• Typed models generated from the OpenAPI spec
• Sub-client organization (agents, sessions, messages, events, filesystem, …)

For a hands-on lesson, see Build your first agent or the minimal Run an Agent notebook.

Install

Rust

Requires Rust 1.70+

cargo add everruns-sdk

Python

Requires Python 3.10+

pip install everruns-sdk

TypeScript

Requires Node.js 18+

npm install @everruns/sdk

Authenticate

All SDKs read EVERRUNS_API_KEY from the environment by default. You can also pass it explicitly.

Rust

use everruns_sdk::Client;

let client = Client::from_env()?;          // from env
let client = Client::new("your-api-key");  // explicit

Python

from everruns_sdk import Client

client = Client()                           # from env
client = Client(api_key="your-api-key")     # explicit

TypeScript

import { Client } from "@everruns/sdk";

const client = new Client();                                    // from env
const client = new Client({ apiKey: "your-api-key" });          // explicit

API coverage

Resource	Operations
Agents	Create, list, get, update, upsert, archive, import, export, preview
Sessions	Create, list, get, update, delete, cancel
Messages	Create, list
Events	Poll, stream (SSE)
Capabilities	List, get
LLM Providers	Create, list, get, update, delete, sync models
LLM Models	Create, list, get, update, delete
MCP Servers	Create, list, get, update, delete
Filesystem	List, read, create, update, delete, move, copy, grep, stat
Session Databases	Create, list, get, delete, schema
Images	Upload, list, get, thumbnail, delete
Organizations	Create, list, get, update
Scheduled Tasks	Create, list, get, update, delete, pause, resume, trigger

Error handling

Error type	Description
AuthenticationError	Invalid or missing API key
NotFoundError	Resource not found
RateLimitError	Rate limit exceeded
ApiError	General API error

Rust

use everruns_sdk::Error;

match client.agents().get("invalid-id").await {
    Ok(agent) => println!("Found: {}", agent.name),
    Err(Error::NotFound(msg)) => println!("Not found: {}", msg),
    Err(Error::Authentication(msg)) => println!("Auth error: {}", msg),
    Err(e) => println!("Other error: {}", e),
}

Python

from everruns_sdk import NotFoundError, AuthenticationError

try:
    agent = await client.agents.get("invalid-id")
except NotFoundError as e:
    print(f"Not found: {e}")
except AuthenticationError as e:
    print(f"Auth error: {e}")

TypeScript

import { NotFoundError, AuthenticationError } from "@everruns/sdk";

try {
  const agent = await client.agents.get("invalid-id");
} catch (e) {
  if (e instanceof NotFoundError) {
    console.log(`Not found: ${e.message}`);
  } else if (e instanceof AuthenticationError) {
    console.log(`Auth error: ${e.message}`);
  }
}

Do something

• Build your first agent — guided tutorial.
• Stream events with the SDK — common streaming patterns.
• Handle errors and cancel turns — graceful failure paths.
• Orchestrate multi-agent pipelines — chain agents together.

See also

• API reference — every endpoint, generated from OpenAPI.
• Event Reference — every event type.
• GitHub Repository — source code and examples.

Overview video