Extension directory

Generic OpenAI Responses API engine: streams /v1/responses and maps output items and deltas to inference events, including reasoning summaries, hosted web search, and opaque provider compaction items. Reused as the engine for xAI API-key, OpenRouter, Codex OAuth, and custom OpenAI-compatible providers. Codex exposes GPT-5.6 Sol/Terra/Luna, defaults to Sol, and maps Roder's Ultra effort to the provider's max reasoning value.

Streams the classic OpenAI Chat Completions API (/v1/chat/completions) through a shared stream_chat_completions helper. Not wired into the default host; mainly consumed as a library by other providers such as Xiaomi MiMo.

Maps harness turns to Anthropic Messages API request bodies and streams SSE from api.anthropic.com, translating tool_use content blocks into harness tool-call events. Local context summaries are sent as post-compaction input while older pre-summary history is dropped from the active request. Resolves the API key at call time from config or environment.

Adapts harness turns to the Google Gemini generateContent streaming API with text and tool-call support.

Runs Gemini models on Vertex AI using service-account OAuth (credentials path or inline JSON) with project and location configuration.

Always registers the SuperGrok OAuth engine; when an xAI API key is declared it additionally installs a direct xAI surface built on the OpenAI Responses engine pointed at api.x.ai/v1. Both catalogs default to grok-4.5 with 500k context and high reasoning.

Spawns and manages the Claude Code CLI through the claude-agent-sdk, streaming SDK events into harness inference events. Reuses the CLI session by default so conversation history stays on the Claude Code side. When a paired Claude-in-Chrome extension is detected, it can authorize the CLI's native browser tools and render their activity as hosted tool calls in Roder.

Talks directly to Cursor's AgentService backend APIs for Composer-style agent turns, including fast model variants, Claude Fable 5, reasoning parameters, and stable per-thread conversation ids. Live turns require a Cursor User API key.

Kimi Code provider for Kimi subscription OAuth or API-key auth. The CLI can save keys with roder auth login kimi-code --api-key, and app-server auth status reports configured API-key state.

First-party Fireworks AI provider using account-scoped model ids, offline catalog metadata, model discovery, and the OpenAI-compatible Responses transport.

OpenRouter API-key provider built on the OpenAI Responses engine, with optional HTTP-Referer and X-Title attribution headers.

Two OpenCode subscription providers (Zen and Go) speaking a chat-completions-style HTTP API at opencode.ai, with cached model lists and retry policy.

Poolside Laguna API-key provider using chat completions at inference.poolside.ai/v1 with cached /models discovery.

Hosted roder.cloud inference: prunes requests down to a documented Responses-API subset, exchanges a roder_ API key for short-lived JWTs, and parses edge Responses payloads. Hosted tools are intentionally omitted.

Xiaomi MiMo in both pay-as-you-go and Token Plan billing modes via OpenAI-compatible chat completions, plus matching text-to-speech synthesizer surfaces.

Local policy router for adaptive model selection: when [inference_router] is enabled it scores turn signals and picks a tiered provider, model, and reasoning level from config before each turn.

Posts captured audio to OpenAI transcription endpoints (Whisper-class models) and returns normalized transcripts with metadata.

Google Cloud Speech-to-Text client supporting OAuth access tokens, API keys, or Application Default Credentials, with project and location awareness.

Calls the OpenAI embeddings API (text-embedding-3 family). The default embedding provider for the SQLite memory store when an OpenAI key is present.

Gemini Embedding 2 via the Generative Language API, with separate query and document input modes for retrieval.

ZeroEntropy zembed-1 embeddings with configurable encoding format and latency tier, and query/document retrieval intent.

SQLite-backed project and global memory under {roder_home}/memory, with an optional embedding provider for vector recall. The default memory backend.

Remote Honcho workspace backend: a REST client maps memory scopes to Honcho sessions and peers, and semantic search is delegated to Honcho's hosted retrieval instead of local vectors.

Project knowledge base stored as Markdown files with YAML front matter under {roder_home}/knowledge. Exposes knowledge_* tools and, when recall is enabled, injects matching documents into context (default limit four).

Append-only JSONL event logs per thread under {roder_home}/threads/{thread_id}/, with a thread-index.json for listing, plus archive and restore support. The runtime keeps compaction boundaries and redacted lifecycle extension records so resumes can continue from compact state and flag interrupted turns that need recovery. The default store.

Tenant-scoped PostgreSQL persistence for threads, context artifacts, and lifecycle extension state over async SQL, configured with a database_url. Built for multi-tenant hosted deployments.

The canonical web_search router: delegates each query to the configured backend (Firecrawl, Perplexity, Tavily, or Parallel) and normalizes results into one response shape.

Firecrawl search API client exposing namespaced search and retrieval tools; also serves as a router backend.

Perplexity raw Search API tools with request-id metadata extraction.

Tavily search API adapter exposing Tavily-backed search tools.

Parallel.ai objective-oriented search with extended tool-argument options for goal-directed queries.

Registers chrome_* tools bound to the Roder browser-extension bridge, letting the agent inspect, control, debug, and record the user's live Chrome session.

Playwright-based browser automation: a background webwright.browser_task executor plus helper tools. Runs a shell preflight for Playwright dependencies and writes artifacts under Roder home.

Connects to configured MCP servers over streamable HTTP, registers their tools, and forwards optional per-thread bearer identity. Offline servers warn in discover mode or fail startup in discover_required mode.

Shells out to git for status, diffs, snapshots, and line metadata, and creates linked git worktrees for workspace forks.

Copy-on-write workspace snapshots by shelling out to a configured rift binary (APFS clonefile, btrfs snapshots, reflinks) behind a narrow CLI adapter with typed errors, since the rift CLI is pre-1.0.

Invokes the configured zero compiler binary for diagnostics, graph inspection, validation, fix plans, and checked ProgramGraph edits (zerolang_edit, zerolang_check, and friends).

An in-process task_ledger.update tool that maintains a validated task snapshot — pending, in_progress, completed, blocked — with optional evidence per item.

A verification_review gate tool for eval and non-interactive coding turns: the model submits structured completion evidence, and status, gap, and skip-reason rules are validated server-side.

Installs the plan-mode policy contributor plus the exit_plan_mode tool the model calls to leave planning and begin execution.

Spawns background shell processes in the workspace (via the unix-local runner when remote), streaming stdout and stderr and tracking a process descriptor for stop and resume.

Background subagent tasks: deserializes task input and delegates to the first registered SubagentDispatcher, so it requires the subagents extension to be installed first.

An in-process dispatcher for child turns against the parent tool registry. Exposes task, bounded agent_swarm fanout, and Codex V2-style agent-control lifecycles with canonical paths, context forks, follow-up turns, mailbox-aware waiting, non-destructive interruption, and role/lane validation before child work starts.

Writes an ASCII bell to stderr for selected notification kinds, throttled to once every two seconds.

Best-effort native OS notifications via notify-rust when the desktop feature is enabled.

Runs commands and file I/O directly against a canonical local workspace root with path-escape guards. No snapshot support.

Starts a long-lived container with the workspace bind-mounted; commands and file ops run through docker exec, and snapshots use docker export.

Fly Sprites sandboxes over HTTP and WebSocket: creates and restores sprites, applies policies, materializes runner manifests, and can deploy a managed remote app-server.

First-party Blaxel Sandboxes provider over the control-plane plus per-sandbox process, filesystem, and preview APIs. It lazily initializes runner-bound threads on first approved workspace tool, routes coding tools into the selected sandbox, supports pause/resume plus durable detach/rejoin, and force-kills remote process groups on cancellation.

Hosted Cloudflare runner via the shared hosted-runner REST client.

Hosted Daytona runner via the shared hosted-runner REST client.

Hosted E2B runner via the shared hosted-runner REST client.

Hosted Modal runner via the shared hosted-runner REST client.

Hosted Runloop runner via the shared hosted-runner REST client.

Hosted Vercel runner via the shared hosted-runner REST client.

Spawns child processes declared in [[process_extensions]] config and speaks newline-delimited JSON-RPC over stdio, bridging the child's declared services (inference engines, event sinks, dispatchers, task executors) into the registry. This is how extensions written in any language plug in.

The shared HTTP client implementing the hosted-runner session protocol (sessions, commands, files) used by the Cloudflare, Daytona, E2B, Modal, Runloop, and Vercel runner crates. Hosted runner commands can carry cancellation leases; Blaxel uses its provider-specific sandbox APIs.

Exports a saved_context_block helper for building disk-sourced context blocks. Distribution metadata references a DiskContextExtension that is not implemented yet, so there is currently no runtime install path.