Providers and gateways

Nib talks to models through four wire protocols. Almost every provider, gateway and local server speaks at least one of them, which is how one runtime covers so many models.

When a provider speaks more than one, Nib prefers the one that preserves the most: Responses for OpenAI and xAI, Messages for Anthropic, Z.ai, Moonshot and MiniMax, and generateContent for Gemini.

ProvidersCopy Anchor Link

A dash in the key prefix column means the key format isn't distinctive. Pick the provider yourself, or paste the key as a .env line with its variable name.

Cloud platformsCopy Anchor Link

Azure OpenAI, Amazon Bedrock and Google Vertex AI aren't available yet: Nib doesn't support how they authenticate (Microsoft Entra ID for Azure, AWS SigV4 request signing for Bedrock, Google Application Default Credentials for Vertex), so it doesn't offer them as providers and no model picker lists their models.

GatewaysCopy Anchor Link

A gateway gives you many models behind one key. Nib treats each gateway as a provider and reads its model list, so you pick models by their gateway slug.

Other OpenAI-compatible gateways (Portkey, Cloudflare AI Gateway, Helicone, and so on) work as a custom endpoint: give Nib the base URL and any extra headers the gateway needs.

Local modelsCopy Anchor Link

No key is required for local runtimes. Nib lists the runtime's models and picks one the same way as for any provider (see Models and effort).

Auto-detectionCopy Anchor Link

In the app you can paste a key, a .env line or a base URL into one field. Nib works out the provider from its shape alone; nothing is sent while it does:

1. Recognize. A key's prefix (sk-ant-, sk-or-, AIza, …) names the provider; the longest matching prefix wins, and a prefix several providers share offers each of them. In a .env line such as OPENAI_API_KEY=…, the variable name decides. If Nib can't place a key, you pick the provider.
2. Base URLs. A base URL becomes a custom OpenAI-compatible endpoint. If its host belongs to a provider Nib knows, Nib treats it as that provider.
3. Keys you already have. Provider keys set in your environment variables are offered too.
4. Check. Once the key is saved, one real call checks it and tells you whether the provider answered, refused the key, is out of credit or failed.
5. Models. The model list comes from the endpoint, with details from Nib's model catalog (context window, pricing, capabilities).
6. Pick. Nib chooses a main model and a small model for auxiliary work, as described in Models and effort.

You can override every result. Auto-detection only fills in a configuration; nothing is hidden.

Per-model-family adaptersCopy Anchor Link

The protocol is only half the story. Models from different labs were trained with different tool conventions, and they behave best when the harness speaks their dialect. Nib keeps a profile per model family and adapts to it.

Edit formatCopy Anchor Link

Write is available to every family. Fuzzy matching for Edit goes through a ladder (exact; line endings and typographic characters folded; trailing whitespace ignored; indentation ignored; block anchored by its first and last lines) and reports which tier it used, so a near miss doesn't silently edit the wrong place.

Reasoning round-tripCopy Anchor Link

Reasoning models return state that must be sent back on the next turn: Anthropic thinking signatures, OpenAI encrypted reasoning, Gemini thought signatures, and reasoning_content from DeepSeek, Kimi and GLM. Dropping it causes errors on some providers and a quiet loss of quality on others. Nib stores this state opaquely with each message and replays it byte-exact to the same model. When you switch models mid-session, it sends a safe projection instead and notes the change.

Other adaptationsCopy Anchor Link

• Tool names and descriptions. GPT models plan with update_plan, current Claude models without a progress tool, and others with TodoWrite. Hooks and permission rules always see the canonical name.
• Deferred tools. GPT models get every tool up front; other models load rarely needed tools with ToolSearch. See Tools.
• Strict schemas. On OpenAI, tool schemas are sent in strict mode, with optional fields made nullable and mapped back.
• Broken tool calls. Open models sometimes emit malformed JSON or tool calls embedded in text (Hermes, Qwen, GLM, MiniMax and Kimi markup). Nib repairs JSON, coerces types against the schema, and extracts text-embedded calls before giving up.
• Parallel calls. Turned off for runtimes that don't support them.
• System prompts. Dynamic context goes where each provider handles it best: a mid-conversation system message on Claude, a developer item on OpenAI, a system reminder elsewhere.

Caching and costCopy Anchor Link

Nib keeps the system prompt and tool list byte-stable across turns so providers can cache them. It sets the cache key each provider understands (prompt_cache_key on OpenAI, the session id on OpenRouter, a conversation header on xAI) and places Anthropic cache breakpoints automatically. Cost is computed per turn from the model's pricing, counting cache reads and writes separately. /cost in the CLI shows the running total.

Retries and fallbacksCopy Anchor Link

Transient errors (rate limits, overloaded servers, dropped streams) are retried with backoff, and the UI tells you what happened: "Rate limited by Anthropic — retrying in 8 s." If a request fails because the endpoint rejects a parameter, Nib learns from the error and retries without it. You can configure a fallback model (fallbackModel in settings); Nib stays on one route as long as it works, to keep the cache warm.

Environment variablesCopy Anchor Link

The CLI and daemon pick up keys from these variables:

ANTHROPIC_API_KEY  OPENAI_API_KEY      GEMINI_API_KEY     GOOGLE_API_KEY
OPENROUTER_API_KEY AI_GATEWAY_API_KEY  XAI_API_KEY        DEEPSEEK_API_KEY
ZAI_API_KEY        ZHIPU_API_KEY       MOONSHOT_API_KEY   KIMI_API_KEY
MINIMAX_API_KEY    DASHSCOPE_API_KEY   MIMO_API_KEY       MISTRAL_API_KEY
GROQ_API_KEY       CEREBRAS_API_KEY    TOGETHER_API_KEY   FIREWORKS_API_KEY
DEEPINFRA_API_KEY  NOVITA_API_KEY      SILICONFLOW_API_KEY

In the desktop app, keys you paste are stored in the OS keychain instead.