Application settings loaded from environment variables.

Platform-agnostic incoming message. Adapters convert platform-specific events to this format.

Own mutable Anthropic stream state and produce serialized SSE events.

Typed metadata for one env-backed admin setting.

Configuration for a provider. Base fields apply to all providers. Provider-specific parameters (e.g. NIM temperature, top_p) are passed by th

Fixed NVIDIA NIM settings (not configurable via env).

Manages multiple message trees: index + async processing. Each new conversation creates a new tree. Replies to existing messages add nod

Persistent storage for conversation snapshots and message IDs. The store reads both the old raw ``trees``/``node_to_tree`` shape and the

A single user prompt/status node in a messaging conversation tree.

Resolve incoming Claude model names to configured provider/model pairs.

Owns Discord SDK lifecycle and inbound event handoff.

Owns Telegram SDK lifecycle and inbound event handoff.

Maintains an ordered, truncatable transcript of parsed CLI events.

Stateful parser for raw text tool calls. Some OpenAI-compatible models emit tool calls as text rather than structured chunks. This parse

Platform-agnostic messaging workflow. It coordinates dependencies and owns stop/clear side effects. Inbound turn intake and queued node

Async iterable mock that yields chunks then optionally raises.

Manages a single persistent Claude Code subprocess.

Own provider instances, model discovery, validation, and cleanup.

Streaming parser for ``<think>...</think>`` tags. Handles partial tags at chunk boundaries by buffering.

Raised when a Responses request cannot be converted deterministically.

NVIDIA NIM provider using official OpenAI client.

Metadata for building :class:`~providers.base.ProviderConfig` and factory wiring.

Runtime aggregate for one ordered messaging conversation tree.

OpenRouter provider using the native Anthropic-compatible messages API.

Drive multi-turn Anthropic-compatible conversations through the server.

Handle Anthropic-compatible Messages requests.

Internal provider model metadata used for gateway model-list shaping.

Raised when the request parameters are invalid.

Start a local proxy server for a product scenario.

LM Studio provider using native Anthropic Messages endpoint.

Persisted conversation trees plus derived lookup helpers.

DeepSeek using ``https://api.deepseek.com`` Chat Completions.

Manages multiple Claude Code sessions for parallel conversation processing. Each new conversation gets its own subprocess. Replies to existi

Ollama provider using native Anthropic Messages API.

Resolve provider models and enforce matrix semantics for product smoke.

Persisted representation of one conversation tree.

A group of config fields rendered together in the admin UI.

Raised when a web_fetch URL is rejected by egress policy (SSRF guard).

A chunk of parsed content.

Llama.cpp provider using native Anthropic Messages endpoint.

Provider policy for Anthropic-to-OpenAI chat request conversion.

Raised when the provider returns a generic API error.

Raised when API key is invalid or missing.

Typed wiring from app settings into messaging platform runtimes.

Track per-upstream content blocks and remapped Anthropic ``index`` field.

Own holdback and failure classification for one provider stream lifecycle.

Provider policy for native Anthropic Messages request construction.

Per-tree async queue processing owned by TreeQueueManager.

Construct recovery events for interrupted native Anthropic streams.

Construct recovery events for interrupted OpenAI-chat streams.

Raised when Anthropic content cannot be converted to OpenAI chat without data loss.

Briefly hold downstream SSE so early stream cutoffs can be retried invisibly.

Allocate and track Anthropic content block indexes.

Strict sliding window limiter. Guarantees: at most ``rate_limit`` acquisitions in any interval of length ``rate_window`` (seconds). Impl

Raised internally when an upstream stream ends without a terminal marker.

Cerebras API at ``https://api.cerebras.ai/v1/chat/completions``.

Async stream mock that records cleanup.

Cloudflare account-scoped AI REST provider.

Codestral host using ``https://codestral.mistral.ai/v1/chat/completions``. Uses a separate Codestral API key from La Plateforme (``MISTRAL_API_KE

Fireworks AI using Anthropic-compatible Messages.

Test double: pin ``provider_id`` for OpenAI vs native routing assertions.

Gemini API using ``https://generativelanguage.googleapis.com/v1beta/openai/``.

Global singleton rate limiter that blocks all requests when a rate limit error is encountered (reactive) and throttles requests (proactiv

Groq API using ``https://api.groq.com/openai/v1/chat/completions``.