Provider catalog

Revka talks to more than 50 AI provider back-ends through a single unified Provider trait. This page is the reference catalog: every canonical provider ID, its aliases, base URL, the credential it expects, and which capabilities it supports. Use it to look up the exact default_provider value to put in config.toml, to find the right env var for a key, or to confirm whether a provider supports vision or native tool calling.

If you just want to get a single provider running, start with the Provider quickstart. For the deeper, provider-family guides — cloud APIs, local servers, OAuth/subscription, and China-region endpoints — follow the cross-links in each section below.

revka providers   # print the live provider list from your build

How providers are organized

Providers fall into four implementation categories:

• First-party API providers with custom implementations: anthropic, openai, gemini, bedrock, ollama, openrouter, azure_openai, openai-codex, telnyx, copilot, glm.
• OpenAI-compatible providers that share one implementation (OpenAiCompatibleProvider) — the largest family, covering Groq, Mistral, DeepSeek, xAI, Together, Fireworks, and dozens more.
• CLI subprocess providers that spawn an authenticated local binary instead of hitting an API directly: claude-code, gemini-cli, kilocli. See OAuth & subscription providers.
• Routing / reliability wrappers (RouterProvider, ReliableProvider) that add hint-based dispatch, fallbacks, and retries on top of any primary provider. See Routing, reliability & tuning.

Credential resolution order

Every provider resolves its credential through the same three-step priority chain:

1. Explicit credential from config or CLI (api_key).
2. The provider-specific env var(s) listed in the catalog below (e.g. OPENROUTER_API_KEY).
3. Generic fallbacks: REVKA_API_KEY, then API_KEY.

For resilience chains (reliability.fallback_providers), each fallback provider resolves its credential independently — the primary provider’s explicit key is not reused for fallbacks.

Provider catalog

The capability columns reflect what the named provider implementation supports: Vision (image inputs), Tools (native tool calling), and Local (runs on your own machine). Empty cells mean the capability is not enabled for that provider.

Cloud API providers

Canonical ID	Aliases	Base URL	Auth env var(s)	Tools	Vision
openrouter	—	provider-managed	OPENROUTER_API_KEY	✅	✅
anthropic	—	Anthropic Messages API	ANTHROPIC_OAUTH_TOKEN, ANTHROPIC_API_KEY	✅	✅
openai	—	https://api.openai.com	OPENAI_API_KEY	✅
gemini	google, google-gemini	generativelanguage.googleapis.com/v1beta	GEMINI_API_KEY, GOOGLE_API_KEY	✅	✅
bedrock	aws-bedrock	AWS Converse API	AWS_ACCESS_KEY_ID + AWS_SECRET_ACCESS_KEY (or BEDROCK_API_KEY)	✅
azure_openai	azure-openai, azure	resource/deployment URI	AZURE_OPENAI_API_KEY	✅
groq	—	https://api.groq.com/openai/v1	GROQ_API_KEY	✅
mistral	—	https://api.mistral.ai/v1	MISTRAL_API_KEY	✅
xai	grok	https://api.x.ai	XAI_API_KEY	✅
deepseek	—	https://api.deepseek.com	DEEPSEEK_API_KEY	✅
together	together-ai	https://api.together.xyz	TOGETHER_API_KEY	✅
fireworks	fireworks-ai	https://api.fireworks.ai/inference/v1	FIREWORKS_API_KEY	✅
novita	—	https://api.novita.ai/openai	NOVITA_API_KEY	✅
perplexity	—	https://api.perplexity.ai	PERPLEXITY_API_KEY	✅
cohere	—	https://api.cohere.com/compatibility	COHERE_API_KEY	✅
venice	—	https://api.venice.ai	VENICE_API_KEY
vercel	vercel-ai	https://ai-gateway.vercel.sh/v1	VERCEL_API_KEY	✅
cloudflare	cloudflare-ai	https://gateway.ai.cloudflare.com/v1	CLOUDFLARE_API_KEY	✅
nvidia	nvidia-nim, build.nvidia.com	https://integrate.api.nvidia.com/v1	NVIDIA_API_KEY	✅
synthetic	—	https://api.synthetic.new/openai/v1	SYNTHETIC_API_KEY	✅
opencode	opencode-zen	https://opencode.ai/zen/v1	OPENCODE_API_KEY	✅
opencode-go	—	https://opencode.ai/zen/go/v1	OPENCODE_GO_API_KEY	✅
telnyx	—	https://api.telnyx.com/v2/ai	TELNYX_API_KEY	✅
aihubmix	—	custom	AIHUBMIX_API_KEY	✅
siliconflow	silicon-flow	custom	SILICONFLOW_API_KEY	✅
astrai	—	custom	ASTRAI_API_KEY	✅
avian	—	custom	AVIAN_API_KEY	✅
deepmyst	deep-myst	custom	DEEPMYST_API_KEY	✅
ovhcloud	ovh	custom	OVH_AI_ENDPOINTS_ACCESS_TOKEN	✅

For Gemini, Bedrock, and Azure OpenAI setup — including Vertex AI, AWS SigV4 vs. Bearer auth, and Azure resource/deployment config — see Cloud API providers.

China-region providers

These providers route to a Global or CN base URL depending on the alias you choose (or MINIMAX_OAUTH_REGION). See China-region providers for the full alias and region-routing tables.

Canonical ID	Key aliases	Base URL (Global / CN)	Auth env var(s)
zai	z.ai, zai-global, zai-cn	https://api.z.ai/api/coding/paas/v4 / https://open.bigmodel.cn/api/coding/paas/v4	ZAI_API_KEY
glm	zhipu, glm-global, glm-cn, bigmodel	https://api.z.ai/api/paas/v4 / https://open.bigmodel.cn/api/paas/v4	GLM_API_KEY
minimax	minimax-intl, minimax-cn, minimaxi, minimax-oauth	https://api.minimax.io/v1 / https://api.minimaxi.com/v1	MINIMAX_OAUTH_TOKEN, MINIMAX_API_KEY
moonshot	kimi, moonshot-intl, moonshot-cn, kimi-cn	https://api.moonshot.ai/v1 / .cn	MOONSHOT_API_KEY
kimi-code	kimi_coding, kimi_for_coding	https://api.kimi.com/coding/v1	KIMI_CODE_API_KEY, MOONSHOT_API_KEY
qwen	dashscope, qwen-intl, qwen-us, qwen-code, qwen-oauth	region-specific DashScope	DASHSCOPE_API_KEY, QWEN_OAUTH_TOKEN
bailian	aliyun-bailian, aliyun	https://coding.dashscope.aliyuncs.com/v1	BAILIAN_API_KEY, DASHSCOPE_API_KEY
qianfan	baidu	https://qianfan.baidubce.com/v2	QIANFAN_API_KEY
doubao	volcengine, ark, doubao-cn	https://ark.cn-beijing.volces.com/api/v3	ARK_API_KEY, DOUBAO_API_KEY

Note

qwen, qwen-code, bailian, and llamacpp have vision enabled. MiniMax merges system messages into the first user turn (see OpenAI-compatible provider below). venice has no native tool calling — tool calls fall back to prompt injection.

Local & self-hosted providers

Local servers default to a localhost endpoint with optional authentication — you do not need a dummy key. Override the host/port with api_url. See Local, self-hosted & custom endpoints.

Canonical ID	Aliases	Default endpoint	API key
ollama	—	http://localhost:11434 (native /api/chat)	OLLAMA_API_KEY (optional)
llamacpp	llama.cpp	http://localhost:8080/v1	LLAMACPP_API_KEY (optional; vision enabled)
lmstudio	lm-studio	http://localhost:1234/v1	optional (default: lm-studio)
vllm	—	http://localhost:8000/v1	VLLM_API_KEY (optional)
sglang	—	http://localhost:30000/v1	SGLANG_API_KEY (optional)
osaurus	—	http://localhost:1337/v1	OSAURUS_API_KEY (optional; default: osaurus)

OAuth & subscription providers

These reuse a subscription authenticated through a native CLI or an OAuth flow instead of a direct API key. See OAuth & subscription providers.

Canonical ID	Aliases	Auth method
claude-code	—	Local Claude Code CLI session (binary path: CLAUDE_CODE_PATH)
gemini-cli	—	Gemini CLI OAuth (~/.gemini/oauth_creds.json); GEMINI_API_KEY fallback
kilocli	kilo	Local KiloCLI session (binary path: KILO_CLI_PATH)
openai-codex	codex	OAuth via revka auth login --provider openai-codex (cached under ~/.revka/auth/)
copilot	github-copilot	GitHub device-code flow; GitHub OAuth token via config or API_KEY fallback

OpenAI-compatible provider (generic)

A single implementation, OpenAiCompatibleProvider, backs every provider that speaks the OpenAI /v1/chat/completions (or /v1/responses) JSON format. It handles Bearer or X-Api-Key auth, a custom User-Agent, vision via base64 images, an optional responses-API fallback on 404, native tool calling using the OpenAI JSON schema, reasoning-effort forwarding, extra HTTP headers, a configurable timeout, a custom API path, and a max-tokens cap.

You almost always select one of the named OpenAI-compatible providers (Groq, Mistral, etc.) by its ID. When you need an endpoint that isn’t registered, use the custom: prefix:

~/.revka/config.toml

default_provider = "custom:https://your-api.example.com/v1"
api_key          = "your-key"
default_model    = "your-model-name"

A few named providers have implementation quirks worth knowing:

• MiniMax sets merge_system_into_user — role: system messages are merged into the first user turn, because the MiniMax API rejects a standalone system role. This affects channel conversations whose system prompts carry delivery guidance.
• GLM and NVIDIA disable the responses-API fallback (no_responses_fallback), so a 404 is surfaced rather than retried against /v1/responses.
• Venice has without_native_tools — tool calls are emulated through prompt injection instead of the native tool API.

See Local, self-hosted & custom endpoints for the full treatment of custom:, api_url, api_path, and extra_headers.

OpenRouter

OpenRouter is the default provider out of the box and gives you access to 200+ models behind one key. Model IDs use the provider/model-name format.

~/.revka/config.toml

default_provider = "openrouter"
default_model    = "anthropic/claude-sonnet-4-6"

Field	Value
Auth env var	OPENROUTER_API_KEY (keys start with sk-or-)
provider_timeout_secs	120 (default)
provider_max_tokens	optional output cap

Caution

OpenRouter’s default provider_max_tokens (65536) can cause 402 errors on some models. If you hit billing/limit errors, set provider_max_tokens to a smaller value in config.toml.

Anthropic

Direct integration with the Anthropic Messages API. Supports native tool calling, vision (base64 inline images), prompt caching (cache_control), SSE streaming, and reasoning-content pass-through.

~/.revka/config.toml

default_provider = "anthropic"
default_model    = "claude-sonnet-4-6-20250514"

One-shot from the CLI:

revka agent -p anthropic --model claude-opus-4-6 -m "Hello"

Field	Value
ANTHROPIC_API_KEY	Standard Anthropic API key (sk-ant-…)
ANTHROPIC_OAUTH_TOKEN	Setup/OAuth token — checked before ANTHROPIC_API_KEY; meant for the auth setup flow, not normal API usage
Default max_tokens	4096 (override with provider_max_tokens)

Caution

The provider automatically omits the temperature field for models in the claude-opus-4-7 line (matched by name prefix, so dated patch releases like claude-opus-4-7-20260601 are also covered), which has deprecated the parameter. If you send temperature to one of these models through another path, Anthropic returns HTTP 400.

OpenAI

Direct integration with the OpenAI Chat Completions API (/v1/chat/completions). Supports native tool calling and reasoning-content handling — the o/o3 family return reasoning_content instead of content, and when content is empty the provider transparently falls back to reasoning_content so callers always receive text.

~/.revka/config.toml

default_provider = "openai"
default_model    = "gpt-4o"
api_url          = "https://api.openai.com"   # optional custom base

Field	Value
OPENAI_API_KEY	API key (sk-…)
api_url / --api-url	Overrides the default base URL
provider_max_tokens	Caps output tokens

See OpenAI temperature compatibility below for which model families accept which temperature values.

Telnyx

Telnyx AI inference via an OpenAI-compatible endpoint at /v2/ai/chat/completions, giving access to 50+ models — GPT-4o, Claude, Llama, Mistral — through a single Telnyx key.

~/.revka/config.toml

default_provider = "telnyx"
default_model    = "openai/gpt-4o"

Field	Value
Auth env var	TELNYX_API_KEY (keys start with KEY-)
Base URL	https://api.telnyx.com/v2/ai
HTTP timeout	120 seconds

Model IDs use the provider/model format, for example openai/gpt-4o or anthropic.claude-sonnet-4-6.

API key mismatch detection

Before constructing a provider, Revka checks the resolved key’s prefix against the selected provider and raises a readable error if they clearly don’t match — for example an sk-ant- key paired with the openai provider. This is a guardrail against a common copy-paste mistake.

Key prefix	Likely provider
sk-ant-	anthropic
sk-or-	openrouter
sk-	openai
gsk_	groq
pplx-	perplexity
xai-	xai
nvapi-	nvidia
KEY-	telnyx

Note

The check is skipped for custom: providers and for any provider given a custom api_url, so custom endpoints can use any key format without a false warning. If you are intentionally proxying (say) an Anthropic key to a non-Anthropic gateway, point at it with custom: or set api_url to silence the check.

Secret scrubbing in error messages

When a provider API call fails, the error body may echo back part of the request — including a key. Revka scrubs token-like patterns from every provider error before it reaches a log file or a chat reply, and truncates the message to 500 characters.

Scrubbed patterns include keys starting with sk-, xoxb-, xoxp-, ghp_, gho_, ghu_, and github_pat_. If a key leaks into an upstream error body, you’ll see [REDACTED] in its place. This is automatic for all providers — no configuration required.

OpenAI temperature compatibility

OpenAI model families have different temperature requirements. The openai provider adjusts the value automatically (via adjust_temperature_for_model()), but the table is useful when you hit a temperature error or are choosing a model.

• Reasoning models (o-series, gpt-5 base variants): accept only temperature=1.0.
• Standard models (gpt-3.5, gpt-4, gpt-4o, gpt-4.1, chat-latest variants): accept the full 0.0–2.0 range.

Family / model	Temperature behavior
o1, o3, o3-mini, o4-mini (and dated variants)	Requires temperature=1.0
gpt-5, gpt-5-mini, gpt-5-nano (and dated variants)	Requires temperature=1.0
gpt-5.1-chat-latest, gpt-5.2-chat-latest, gpt-5.3-chat-latest	Requires temperature=1.0
gpt-3.5-turbo, gpt-4, gpt-4-turbo, gpt-4o, gpt-4o-mini, gpt-4.1 (all variants)	Accepts 0.0–2.0
gpt-5-chat-latest, gpt-5.2, gpt-5.4 (and dated variants)	Accepts 0.0–2.0

Tip

Revka’s global default_temperature lives in config.toml and defaults to 0.7. gemini-cli and kilocli accept only 0.7 or 1.0 and error on other values; claude-code clamps any other value to the nearest of 0.7/1.0 (only non-finite values error).

Verify a provider

revka doctor models --provider <id>   # probe one provider: ok / auth-error / error
revka models refresh --provider <id>  # pull the live model catalog
revka doctor                          # validate the resolved provider, key, and model

revka doctor models reports ok with a model count when a provider is reachable and the key is valid, auth-error when the credential is wrong, and a connectivity error when the endpoint is unreachable. Some providers (e.g. copilot) don’t support live model discovery and show as skipped.

Next steps

Provider quickstart Pick a provider, set the key, and run your first chat.

Cloud API providers Gemini (incl. Vertex AI), AWS Bedrock, and Azure OpenAI setup.

Local, self-hosted & custom endpoints Ollama, llama.cpp, vLLM, SGLang, and the custom: prefix.

OAuth & subscription providers claude-code, openai-codex, gemini-cli, Copilot, MiniMax & Qwen OAuth.

China-region providers GLM, MiniMax, Qwen/DashScope, Moonshot/Kimi region routing.

Routing, reliability & tuning Model routes, fallback chains, timeouts, and key-mismatch detection.