durar-ai 2026.4.4

package/docs/providers/minimax.md

@@ -0,0 +1,281 @@
+---
+summary: "Use MiniMax models in Durar"
+read_when:
+  - You want MiniMax models in Durar
+  - You need MiniMax setup guidance
+title: "MiniMax"
+---
+
+# MiniMax
+
+Durar's MiniMax provider defaults to **MiniMax M2.7**.
+
+MiniMax also provides:
+
+- bundled speech synthesis via T2A v2
+- bundled image understanding via `MiniMax-VL-01`
+- bundled `web_search` through the MiniMax Coding Plan search API
+
+Provider split:
+
+- `minimax`: API-key text provider, plus bundled image generation, image understanding, speech, and web search
+- `minimax-portal`: OAuth text provider, plus bundled image generation and image understanding
+
+## Model lineup
+
+- `MiniMax-M2.7`: default hosted reasoning model.
+- `MiniMax-M2.7-highspeed`: faster M2.7 reasoning tier.
+- `image-01`: image generation model (generate and image-to-image editing).
+
+## Image generation
+
+The MiniMax plugin registers the `image-01` model for the `image_generate` tool. It supports:
+
+- **Text-to-image generation** with aspect ratio control.
+- **Image-to-image editing** (subject reference) with aspect ratio control.
+- Up to **9 output images** per request.
+- Up to **1 reference image** per edit request.
+- Supported aspect ratios: `1:1`, `16:9`, `4:3`, `3:2`, `2:3`, `3:4`, `9:16`, `21:9`.
+
+To use MiniMax for image generation, set it as the image generation provider:
+
+```json5
+{
+  agents: {
+    defaults: {
+      imageGenerationModel: { primary: "minimax/image-01" },
+    },
+  },
+}
+```
+
+The plugin uses the same `MINIMAX_API_KEY` or OAuth auth as the text models. No additional configuration is needed if MiniMax is already set up.
+
+Both `minimax` and `minimax-portal` register `image_generate` with the same
+`image-01` model. API-key setups use `MINIMAX_API_KEY`; OAuth setups can use
+the bundled `minimax-portal` auth path instead.
+
+When onboarding or API-key setup writes explicit `models.providers.minimax`
+entries, Durar materializes `MiniMax-M2.7` and
+`MiniMax-M2.7-highspeed` with `input: ["text", "image"]`.
+
+The built-in bundled MiniMax text catalog itself stays text-only metadata until
+that explicit provider config exists. Image understanding is exposed separately
+through the plugin-owned `MiniMax-VL-01` media provider.
+
+## Image understanding
+
+The MiniMax plugin registers image understanding separately from the text
+catalog:
+
+- `minimax`: default image model `MiniMax-VL-01`
+- `minimax-portal`: default image model `MiniMax-VL-01`
+
+That is why automatic media routing can use MiniMax image understanding even
+when the bundled text-provider catalog still shows text-only M2.7 chat refs.
+
+## Web search
+
+The MiniMax plugin also registers `web_search` through the MiniMax Coding Plan
+search API.
+
+- Provider id: `minimax`
+- Structured results: titles, URLs, snippets, related queries
+- Preferred env var: `MINIMAX_CODE_PLAN_KEY`
+- Accepted env alias: `MINIMAX_CODING_API_KEY`
+- Compatibility fallback: `MINIMAX_API_KEY` when it already points at a coding-plan token
+- Region reuse: `plugins.entries.minimax.config.webSearch.region`, then `MINIMAX_API_HOST`, then MiniMax provider base URLs
+- Search stays on provider id `minimax`; OAuth CN/global setup can still steer region indirectly through `models.providers.minimax-portal.baseUrl`
+
+Config lives under `plugins.entries.minimax.config.webSearch.*`.
+See [MiniMax Search](/tools/minimax-search).
+
+## Choose a setup
+
+### MiniMax OAuth (Coding Plan) - recommended
+
+**Best for:** quick setup with MiniMax Coding Plan via OAuth, no API key required.
+
+Authenticate with the explicit regional OAuth choice:
+
+```bash
+Durar onboard --auth-choice minimax-global-oauth
+# or
+Durar onboard --auth-choice minimax-cn-oauth
+```
+
+Choice mapping:
+
+- `minimax-global-oauth`: International users (`api.minimax.io`)
+- `minimax-cn-oauth`: Users in China (`api.minimaxi.com`)
+
+See the MiniMax plugin package README in the Durar repo for details.
+
+### MiniMax M2.7 (API key)
+
+**Best for:** hosted MiniMax with Anthropic-compatible API.
+
+Configure via CLI:
+
+- Interactive onboarding:
+
+```bash
+Durar onboard --auth-choice minimax-global-api
+# or
+Durar onboard --auth-choice minimax-cn-api
+```
+
+- `minimax-global-api`: International users (`api.minimax.io`)
+- `minimax-cn-api`: Users in China (`api.minimaxi.com`)
+
+```json5
+{
+  env: { MINIMAX_API_KEY: "sk-..." },
+  agents: { defaults: { model: { primary: "minimax/MiniMax-M2.7" } } },
+  models: {
+    mode: "merge",
+    providers: {
+      minimax: {
+        baseUrl: "https://api.minimax.io/anthropic",
+        apiKey: "${MINIMAX_API_KEY}",
+        api: "anthropic-messages",
+        models: [
+          {
+            id: "MiniMax-M2.7",
+            name: "MiniMax M2.7",
+            reasoning: true,
+            input: ["text", "image"],
+            cost: { input: 0.3, output: 1.2, cacheRead: 0.06, cacheWrite: 0.375 },
+            contextWindow: 204800,
+            maxTokens: 131072,
+          },
+          {
+            id: "MiniMax-M2.7-highspeed",
+            name: "MiniMax M2.7 Highspeed",
+            reasoning: true,
+            input: ["text", "image"],
+            cost: { input: 0.6, output: 2.4, cacheRead: 0.06, cacheWrite: 0.375 },
+            contextWindow: 204800,
+            maxTokens: 131072,
+          },
+        ],
+      },
+    },
+  },
+}
+```
+
+On the Anthropic-compatible streaming path, Durar now disables MiniMax
+thinking by default unless you explicitly set `thinking` yourself. MiniMax's
+streaming endpoint emits `reasoning_content` in OpenAI-style delta chunks
+instead of native Anthropic thinking blocks, which can leak internal reasoning
+into visible output if left enabled implicitly.
+
+### MiniMax M2.7 as fallback (example)
+
+**Best for:** keep your strongest latest-generation model as primary, fail over to MiniMax M2.7.
+Example below uses Opus as a concrete primary; swap to your preferred latest-gen primary model.
+
+```json5
+{
+  env: { MINIMAX_API_KEY: "sk-..." },
+  agents: {
+    defaults: {
+      models: {
+        "anthropic/claude-opus-4-6": { alias: "primary" },
+        "minimax/MiniMax-M2.7": { alias: "minimax" },
+      },
+      model: {
+        primary: "anthropic/claude-opus-4-6",
+        fallbacks: ["minimax/MiniMax-M2.7"],
+      },
+    },
+  },
+}
+```
+
+## Configure via `Durar configure`
+
+Use the interactive config wizard to set MiniMax without editing JSON:
+
+1. Run `Durar configure`.
+2. Select **Model/auth**.
+3. Choose a **MiniMax** auth option.
+4. Pick your default model when prompted.
+
+Current MiniMax auth choices in the wizard/CLI:
+
+- `minimax-global-oauth`
+- `minimax-cn-oauth`
+- `minimax-global-api`
+- `minimax-cn-api`
+
+## Configuration options
+
+- `models.providers.minimax.baseUrl`: prefer `https://api.minimax.io/anthropic` (Anthropic-compatible); `https://api.minimax.io/v1` is optional for OpenAI-compatible payloads.
+- `models.providers.minimax.api`: prefer `anthropic-messages`; `openai-completions` is optional for OpenAI-compatible payloads.
+- `models.providers.minimax.apiKey`: MiniMax API key (`MINIMAX_API_KEY`).
+- `models.providers.minimax.models`: define `id`, `name`, `reasoning`, `contextWindow`, `maxTokens`, `cost`.
+- `agents.defaults.models`: alias models you want in the allowlist.
+- `models.mode`: keep `merge` if you want to add MiniMax alongside built-ins.
+
+## Notes
+
+- Model refs follow the auth path:
+  - API-key setup: `minimax/<model>`
+  - OAuth setup: `minimax-portal/<model>`
+- Default chat model: `MiniMax-M2.7`
+- Alternate chat model: `MiniMax-M2.7-highspeed`
+- On `api: "anthropic-messages"`, Durar injects
+  `thinking: { type: "disabled" }` unless thinking is already explicitly set in
+  params/config.
+- `/fast on` or `params.fastMode: true` rewrites `MiniMax-M2.7` to
+  `MiniMax-M2.7-highspeed` on the Anthropic-compatible stream path.
+- Onboarding and direct API-key setup write explicit model definitions with
+  `input: ["text", "image"]` for both M2.7 variants
+- The bundled provider catalog currently exposes the chat refs as text-only
+  metadata until explicit MiniMax provider config exists
+- Coding Plan usage API: `https://api.minimaxi.com/v1/api/openplatform/coding_plan/remains` (requires a coding plan key).
+- Durar normalizes MiniMax coding-plan usage to the same `% left` display
+  used by other providers. MiniMax's raw `usage_percent` / `usagePercent`
+  fields are remaining quota, not consumed quota, so Durar inverts them.
+  Count-based fields win when present. When the API returns `model_remains`,
+  Durar prefers the chat-model entry, derives the window label from
+  `start_time` / `end_time` when needed, and includes the selected model name
+  in the plan label so coding-plan windows are easier to distinguish.
+- Usage snapshots treat `minimax`, `minimax-cn`, and `minimax-portal` as the
+  same MiniMax quota surface, and prefer stored MiniMax OAuth before falling
+  back to Coding Plan key env vars.
+- Update pricing values in `models.json` if you need exact cost tracking.
+- Referral link for MiniMax Coding Plan (10% off): [https://platform.minimax.io/subscribe/coding-plan?code=DbXJTRClnb&source=link](https://platform.minimax.io/subscribe/coding-plan?code=DbXJTRClnb&source=link)
+- See [/concepts/model-providers](/concepts/model-providers) for provider rules.
+- Use `Durar models list` to confirm the current provider id, then switch with
+  `Durar models set minimax/MiniMax-M2.7` or
+  `Durar models set minimax-portal/MiniMax-M2.7`.
+
+## Troubleshooting
+
+### "Unknown model: minimax/MiniMax-M2.7"
+
+This usually means the **MiniMax provider isn’t configured** (no matching
+provider entry and no MiniMax auth profile/env key found). A fix for this
+detection is in **2026.1.12**. Fix by:
+
+- Upgrading to **2026.1.12** (or run from source `main`), then restarting the gateway.
+- Running `Durar configure` and selecting a **MiniMax** auth option, or
+- Adding the matching `models.providers.minimax` or
+  `models.providers.minimax-portal` block manually, or
+- Setting `MINIMAX_API_KEY`, `MINIMAX_OAUTH_TOKEN`, or a MiniMax auth profile
+  so the matching provider can be injected.
+
+Make sure the model id is **case‑sensitive**:
+
+- API-key path: `minimax/MiniMax-M2.7` or `minimax/MiniMax-M2.7-highspeed`
+- OAuth path: `minimax-portal/MiniMax-M2.7` or
+  `minimax-portal/MiniMax-M2.7-highspeed`
+
+Then recheck with:
+
+```bash
+Durar models list
+```

package/docs/providers/mistral.md

@@ -0,0 +1,68 @@
+---
+summary: "Use Mistral models and Voxtral transcription with Durar"
+read_when:
+  - You want to use Mistral models in Durar
+  - You need Mistral API key onboarding and model refs
+title: "Mistral"
+---
+
+# Mistral
+
+Durar supports Mistral for both text/image model routing (`mistral/...`) and
+audio transcription via Voxtral in media understanding.
+Mistral can also be used for memory embeddings (`memorySearch.provider = "mistral"`).
+
+## CLI setup
+
+```bash
+Durar onboard --auth-choice mistral-api-key
+# or non-interactive
+Durar onboard --mistral-api-key "$MISTRAL_API_KEY"
+```
+
+## Config snippet (LLM provider)
+
+```json5
+{
+  env: { MISTRAL_API_KEY: "sk-..." },
+  agents: { defaults: { model: { primary: "mistral/mistral-large-latest" } } },
+}
+```
+
+## Built-in LLM catalog
+
+Durar currently ships this bundled Mistral catalog:
+
+| Model ref                        | Input       | Context | Max output | Notes                    |
+| -------------------------------- | ----------- | ------- | ---------- | ------------------------ |
+| `mistral/mistral-large-latest`   | text, image | 262,144 | 16,384     | Default model            |
+| `mistral/mistral-medium-2508`    | text, image | 262,144 | 8,192      | Mistral Medium 3.1       |
+| `mistral/mistral-small-latest`   | text, image | 128,000 | 16,384     | Smaller multimodal model |
+| `mistral/pixtral-large-latest`   | text, image | 128,000 | 32,768     | Pixtral                  |
+| `mistral/codestral-latest`       | text        | 256,000 | 4,096      | Coding                   |
+| `mistral/devstral-medium-latest` | text        | 262,144 | 32,768     | Devstral 2               |
+| `mistral/magistral-small`        | text        | 128,000 | 40,000     | Reasoning-enabled        |
+
+## Config snippet (audio transcription with Voxtral)
+
+```json5
+{
+  tools: {
+    media: {
+      audio: {
+        enabled: true,
+        models: [{ provider: "mistral", model: "voxtral-mini-latest" }],
+      },
+    },
+  },
+}
+```
+
+## Notes
+
+- Mistral auth uses `MISTRAL_API_KEY`.
+- Provider base URL defaults to `https://api.mistral.ai/v1`.
+- Onboarding default model is `mistral/mistral-large-latest`.
+- Media-understanding default audio model for Mistral is `voxtral-mini-latest`.
+- Media transcription path uses `/v1/audio/transcriptions`.
+- Memory embeddings path uses `/v1/embeddings` (default model: `mistral-embed`).

package/docs/providers/models.md

@@ -0,0 +1,56 @@
+---
+summary: "Model providers (LLMs) supported by Durar"
+read_when:
+  - You want to choose a model provider
+  - You want quick setup examples for LLM auth + model selection
+title: "Model Provider Quickstart"
+---
+
+# Model Providers
+
+Durar can use many LLM providers. Pick one, authenticate, then set the default
+model as `provider/model`.
+
+## Quick start (two steps)
+
+1. Authenticate with the provider (usually via `Durar onboard`).
+2. Set the default model:
+
+```json5
+{
+  agents: { defaults: { model: { primary: "anthropic/claude-opus-4-6" } } },
+}
+```
+
+## Supported providers (starter set)
+
+- [Anthropic (API + Claude CLI)](/providers/anthropic)
+- [Amazon Bedrock](/providers/bedrock)
+- [BytePlus (International)](/concepts/model-providers#byteplus-international)
+- [Chutes](/providers/chutes)
+- [Cloudflare AI Gateway](/providers/cloudflare-ai-gateway)
+- [Fireworks](/providers/fireworks)
+- [GLM models](/providers/glm)
+- [MiniMax](/providers/minimax)
+- [Mistral](/providers/mistral)
+- [Moonshot AI (Kimi + Kimi Coding)](/providers/moonshot)
+- [OpenAI (API + Codex)](/providers/openai)
+- [OpenCode (Zen + Go)](/providers/opencode)
+- [OpenRouter](/providers/openrouter)
+- [Qianfan](/providers/qianfan)
+- [Qwen](/providers/qwen)
+- [StepFun](/providers/stepfun)
+- [Synthetic](/providers/synthetic)
+- [Vercel AI Gateway](/providers/vercel-ai-gateway)
+- [Venice (Venice AI)](/providers/venice)
+- [xAI](/providers/xai)
+- [Z.AI](/providers/zai)
+
+## Additional bundled provider variants
+
+- `anthropic-vertex` - implicit Anthropic on Google Vertex support when Vertex credentials are available; no separate onboarding auth choice
+- `copilot-proxy` - local VS Code Copilot Proxy bridge; use `Durar onboard --auth-choice copilot-proxy`
+- `google-gemini-cli` - unofficial Gemini CLI OAuth flow; requires a local `gemini` install (`brew install gemini-cli` or `npm install -g @google/gemini-cli`); default model `google-gemini-cli/gemini-3.1-pro-preview`; use `Durar onboard --auth-choice google-gemini-cli` or `Durar models auth login --provider google-gemini-cli --set-default`
+
+For the full provider catalog (xAI, Groq, Mistral, etc.) and advanced configuration,
+see [Model providers](/concepts/model-providers).

package/docs/providers/moonshot.md

@@ -0,0 +1,224 @@
+---
+summary: "Configure Moonshot K2 vs Kimi Coding (separate providers + keys)"
+read_when:
+  - You want Moonshot K2 (Moonshot Open Platform) vs Kimi Coding setup
+  - You need to understand separate endpoints, keys, and model refs
+  - You want copy/paste config for either provider
+title: "Moonshot AI"
+---
+
+# Moonshot AI (Kimi)
+
+Moonshot provides the Kimi API with OpenAI-compatible endpoints. Configure the
+provider and set the default model to `moonshot/kimi-k2.5`, or use
+Kimi Coding with `kimi/kimi-code`.
+
+Current Kimi K2 model IDs:
+
+[//]: # "moonshot-kimi-k2-ids:start"
+
+- `kimi-k2.5`
+- `kimi-k2-thinking`
+- `kimi-k2-thinking-turbo`
+- `kimi-k2-turbo`
+
+[//]: # "moonshot-kimi-k2-ids:end"
+
+```bash
+Durar onboard --auth-choice moonshot-api-key
+# or
+Durar onboard --auth-choice moonshot-api-key-cn
+```
+
+Kimi Coding:
+
+```bash
+Durar onboard --auth-choice kimi-code-api-key
+```
+
+Note: Moonshot and Kimi Coding are separate providers. Keys are not interchangeable, endpoints differ, and model refs differ (Moonshot uses `moonshot/...`, Kimi Coding uses `kimi/...`).
+
+Kimi web search uses the Moonshot plugin too:
+
+```bash
+Durar configure --section web
+```
+
+Choose **Kimi** in the web-search section to store
+`plugins.entries.moonshot.config.webSearch.*`.
+
+## Config snippet (Moonshot API)
+
+```json5
+{
+  env: { MOONSHOT_API_KEY: "sk-..." },
+  agents: {
+    defaults: {
+      model: { primary: "moonshot/kimi-k2.5" },
+      models: {
+        // moonshot-kimi-k2-aliases:start
+        "moonshot/kimi-k2.5": { alias: "Kimi K2.5" },
+        "moonshot/kimi-k2-thinking": { alias: "Kimi K2 Thinking" },
+        "moonshot/kimi-k2-thinking-turbo": { alias: "Kimi K2 Thinking Turbo" },
+        "moonshot/kimi-k2-turbo": { alias: "Kimi K2 Turbo" },
+        // moonshot-kimi-k2-aliases:end
+      },
+    },
+  },
+  models: {
+    mode: "merge",
+    providers: {
+      moonshot: {
+        baseUrl: "https://api.moonshot.ai/v1",
+        apiKey: "${MOONSHOT_API_KEY}",
+        api: "openai-completions",
+        models: [
+          // moonshot-kimi-k2-models:start
+          {
+            id: "kimi-k2.5",
+            name: "Kimi K2.5",
+            reasoning: false,
+            input: ["text", "image"],
+            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+            contextWindow: 262144,
+            maxTokens: 262144,
+          },
+          {
+            id: "kimi-k2-thinking",
+            name: "Kimi K2 Thinking",
+            reasoning: true,
+            input: ["text"],
+            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+            contextWindow: 262144,
+            maxTokens: 262144,
+          },
+          {
+            id: "kimi-k2-thinking-turbo",
+            name: "Kimi K2 Thinking Turbo",
+            reasoning: true,
+            input: ["text"],
+            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+            contextWindow: 262144,
+            maxTokens: 262144,
+          },
+          {
+            id: "kimi-k2-turbo",
+            name: "Kimi K2 Turbo",
+            reasoning: false,
+            input: ["text"],
+            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+            contextWindow: 256000,
+            maxTokens: 16384,
+          },
+          // moonshot-kimi-k2-models:end
+        ],
+      },
+    },
+  },
+}
+```
+
+## Kimi Coding
+
+```json5
+{
+  env: { KIMI_API_KEY: "sk-..." },
+  agents: {
+    defaults: {
+      model: { primary: "kimi/kimi-code" },
+      models: {
+        "kimi/kimi-code": { alias: "Kimi" },
+      },
+    },
+  },
+}
+```
+
+## Kimi web search
+
+Durar also ships **Kimi** as a `web_search` provider, backed by Moonshot web
+search.
+
+Interactive setup can prompt for:
+
+- the Moonshot API region:
+  - `https://api.moonshot.ai/v1`
+  - `https://api.moonshot.cn/v1`
+- the default Kimi web-search model (defaults to `kimi-k2.5`)
+
+Config lives under `plugins.entries.moonshot.config.webSearch`:
+
+```json5
+{
+  plugins: {
+    entries: {
+      moonshot: {
+        config: {
+          webSearch: {
+            apiKey: "sk-...", // or use KIMI_API_KEY / MOONSHOT_API_KEY
+            baseUrl: "https://api.moonshot.ai/v1",
+            model: "kimi-k2.5",
+          },
+        },
+      },
+    },
+  },
+  tools: {
+    web: {
+      search: {
+        provider: "kimi",
+      },
+    },
+  },
+}
+```
+
+## Notes
+
+- Moonshot model refs use `moonshot/<modelId>`. Kimi Coding model refs use `kimi/<modelId>`.
+- Current Kimi Coding default model ref is `kimi/kimi-code`. Legacy `kimi/k2p5` remains accepted as a compatibility model id.
+- Kimi web search uses `KIMI_API_KEY` or `MOONSHOT_API_KEY`, and defaults to `https://api.moonshot.ai/v1` with model `kimi-k2.5`.
+- Native Moonshot endpoints (`https://api.moonshot.ai/v1` and
+  `https://api.moonshot.cn/v1`) advertise streaming usage compatibility on the
+  shared `openai-completions` transport. Durar now keys that off endpoint
+  capabilities, so compatible custom provider ids targeting the same native
+  Moonshot hosts inherit the same streaming-usage behavior.
+- Override pricing and context metadata in `models.providers` if needed.
+- If Moonshot publishes different context limits for a model, adjust
+  `contextWindow` accordingly.
+- Use `https://api.moonshot.ai/v1` for the international endpoint, and `https://api.moonshot.cn/v1` for the China endpoint.
+- Onboarding choices:
+  - `moonshot-api-key` for `https://api.moonshot.ai/v1`
+  - `moonshot-api-key-cn` for `https://api.moonshot.cn/v1`
+
+## Native thinking mode (Moonshot)
+
+Moonshot Kimi supports binary native thinking:
+
+- `thinking: { type: "enabled" }`
+- `thinking: { type: "disabled" }`
+
+Configure it per model via `agents.defaults.models.<provider/model>.params`:
+
+```json5
+{
+  agents: {
+    defaults: {
+      models: {
+        "moonshot/kimi-k2.5": {
+          params: {
+            thinking: { type: "disabled" },
+          },
+        },
+      },
+    },
+  },
+}
+```
+
+Durar also maps runtime `/think` levels for Moonshot:
+
+- `/think off` -> `thinking.type=disabled`
+- any non-off thinking level -> `thinking.type=enabled`
+
+When Moonshot thinking is enabled, `tool_choice` must be `auto` or `none`. Durar normalizes incompatible `tool_choice` values to `auto` for compatibility.

package/docs/providers/nvidia.md

@@ -0,0 +1,58 @@
+---
+summary: "Use NVIDIA's OpenAI-compatible API in Durar"
+read_when:
+  - You want to use NVIDIA models in Durar
+  - You need NVIDIA_API_KEY setup
+title: "NVIDIA"
+---
+
+# NVIDIA
+
+NVIDIA provides an OpenAI-compatible API at `https://integrate.api.nvidia.com/v1` for Nemotron and NeMo models. Authenticate with an API key from [NVIDIA NGC](https://catalog.ngc.nvidia.com/).
+
+## CLI setup
+
+Export the key once, then run onboarding and set an NVIDIA model:
+
+```bash
+export NVIDIA_API_KEY="nvapi-..."
+Durar onboard --auth-choice skip
+Durar models set nvidia/nvidia/llama-3.1-nemotron-70b-instruct
+```
+
+If you still pass `--token`, remember it lands in shell history and `ps` output; prefer the env var when possible.
+
+## Config snippet
+
+```json5
+{
+  env: { NVIDIA_API_KEY: "nvapi-..." },
+  models: {
+    providers: {
+      nvidia: {
+        baseUrl: "https://integrate.api.nvidia.com/v1",
+        api: "openai-completions",
+      },
+    },
+  },
+  agents: {
+    defaults: {
+      model: { primary: "nvidia/nvidia/llama-3.1-nemotron-70b-instruct" },
+    },
+  },
+}
+```
+
+## Model IDs
+
+| Model ref                                            | Name                                     | Context | Max output |
+| ---------------------------------------------------- | ---------------------------------------- | ------- | ---------- |
+| `nvidia/nvidia/llama-3.1-nemotron-70b-instruct`      | NVIDIA Llama 3.1 Nemotron 70B Instruct   | 131,072 | 4,096      |
+| `nvidia/meta/llama-3.3-70b-instruct`                 | Meta Llama 3.3 70B Instruct              | 131,072 | 4,096      |
+| `nvidia/nvidia/mistral-nemo-minitron-8b-8k-instruct` | NVIDIA Mistral NeMo Minitron 8B Instruct | 8,192   | 2,048      |
+
+## Notes
+
+- OpenAI-compatible `/v1` endpoint; use an API key from NVIDIA NGC.
+- Provider auto-enables when `NVIDIA_API_KEY` is set.
+- The bundled catalog is static; costs default to `0` in source.