@ryuu-reinzz/ryuu-cli 0.3.1 → 0.4.0

package/CHANGELOG.md

@@ -3,6 +3,38 @@
 Semua perubahan penting pada Ryuu Agent CLI didokumentasikan di sini.
 Project ini mengikuti [Semantic Versioning](https://semver.org/).
 
+## [0.3.2] - 2026-10-30
+
+### Ditambahkan
+
+- **River AI jadi provider bawaan, dan reasoning DeepSeek-nya akhirnya tampil.**
+  River mematikan thinking secara default untuk `DeepSeek-V4.1-Flash-1017` dan
+  `DeepSeek-V4.1-Flash`, sehingga respons hanya berisi `content` dan kotak
+  `◈ reasoning` tidak pernah muncul. Modul baru `src/providers/river.js`
+  mengirim `reasoning_effort` (default `high`) lewat tabel field request
+  `src/providers/vendor-extras.js` yang dibaca klien bersama sebelum setiap
+  request. Prioritas nilai: `RYUU_RIVER_REASONING_EFFORT` → `reasoningEffort` di
+  `config.json` → `RYUU_REASONING_EFFORT` → `capabilities.reasoningEffort`.
+  Level yang tidak didukung model diturunkan ke level aman model itu dan dicatat
+  di log, jadi request tidak pernah gagal karena field ini.
+- **Modul klien per vendor.** `tokenharbor.js` menyusul `river.js` sebagai
+  pemilik default provider-nya; provider kustom tetap memakai template
+  `nvidia.js` tanpa perubahan kode, dan kini bisa membawa field request sendiri
+  lewat `extraBody`/`requestParams` di entri `extraProviders`.
+
+### Diubah
+
+- Provider bawaan menjadi `nvidia`, `tokenharbor`, dan `river`, masing-masing
+  dengan daftar model default-nya sendiri (River: DeepSeek, GLM-5.3,
+  Qwen3.8-27B, Nemotron-3.5-Super-VL). `/model` dan `/provider` menampilkannya
+  tanpa entri `extraProviders`.
+- Entri `extraProviders` lama yang mendeklarasikan ulang provider bawaan dengan
+  base URL yang sama (misalnya `river`) kini diabaikan dengan peringatan, bukan
+  menggagalkan startup. Id bawaan dengan URL berbeda tetap ditolak.
+- `extraProviders` menerima `reasoningEffort`, `thinking`, `extraBody`, dan
+  `requestParams`; nilai-nilainya dibawa bersama pilihan provider sehingga
+  `/provider` tidak menghapusnya.
+
 ## [0.3.1] - 2026-10-29
 
 ### Ditambahkan

package/README.md

@@ -565,7 +565,8 @@ Kuncinya disimpan seperti provider lain, yaitu `providers.myproxy.apiKey`, dan
 bisa diisi lewat `ryuu --settings` setelah provider terdaftar.
 
 - `id`, `name`, dan `baseURL` wajib. `models` boleh kosong saat baru dibuat dan
-  diisi lewat `/addmodel`; `id` tidak boleh menabrak provider bawaan.
+  diisi lewat `/addmodel`; `id` tidak boleh menabrak provider bawaan (`nvidia`,
+  `tokenharbor`, `river`).
 - `capabilities` menentukan apakah agent mengirim tools (`tools`), meminta
   stream (`streaming`), dan menampilkan reasoning bila provider mengirimnya
   (`reasoning`). Jangan menyalakan `tools` untuk endpoint yang tidak mendukung
@@ -578,6 +579,58 @@ bisa diisi lewat `ryuu --settings` setelah provider terdaftar.
   dilaporkan apa adanya (dengan retry terbatas untuk kegagalan sesaat) agar
   kunci dan data tidak berpindah ke provider lain tanpa keputusan Anda.
 
+#### Provider bawaan dan modul klien per vendor (`src/providers/`)
+
+Tiga provider dikenali tanpa entri `extraProviders`: `nvidia`, `tokenharbor`,
+dan `river`. Masing-masing punya modul sendiri di `src/providers/`:
+
+| Modul | Provider | Isi |
+| --- | --- | --- |
+| `nvidia.js` | `nvidia` | Klien Chat Completions bersama (dipakai semua provider OpenAI-compatible), retry, streaming, ekstraksi reasoning. |
+| `tokenharbor.js` | `tokenharbor` | Default provider + pass-through `extraBody`/`requestParams`. |
+| `river.js` | `river` | Menambahkan `reasoning_effort` (lihat di bawah) dan profil reasoning per model. |
+| `vendor-extras.js` | — | Tabel field request per provider; klien bersama bertanya ke sini sebelum setiap request. |
+
+Karena ketiganya bawaan, `extraProviders` **tidak boleh** memakai id yang sama.
+Entri lama untuk `river` yang menunjuk base URL yang sama tetap diterima: entri
+itu diabaikan dengan peringatan, bukan menggagalkan startup, dan descriptor
+bawaan yang dipakai (daftar model, kapabilitas, field vendor). Provider kustom
+lainnya tetap memakai template `nvidia.js` tanpa perubahan kode; field request
+tambahan bisa diberikan lewat `extraBody`/`requestParams` di entrinya:
+
+```json
+{ "id": "myproxy", "baseURL": "https://proxy.example/v1",
+  "extraBody": { "top_k": 40 }, "requestParams": { "reasoning_effort": "high" } }
+```
+
+#### Reasoning DeepSeek di River AI
+
+River mematikan thinking secara default untuk `DeepSeek-V4.1-Flash-1017` dan
+`DeepSeek-V4.1-Flash`: tanpa `reasoning_effort` di body request, respons hanya
+berisi `content`, dan tidak ada teks reasoning untuk ditampilkan. `river.js`
+mengirim field itu otomatis (dokumentasi: <https://docs.river.ai/guides/inference-controls/>):
+
+- Default: `high` untuk kedua model DeepSeek, sehingga reasoning langsung muncul
+  di UI dan di `.ryuu/logs/reasoning/`.
+- Model River lain (`GLM-5.3`, `GLM-5.3-Flash`, `Qwen3.8-27B-FP8`,
+  `Nemotron-3.5-Super-VL-120B`) sudah reasoning secara default dan tidak dipaksa
+  — effort hanya dikirim bila Anda memintanya.
+- Urutan prioritas: env `RYUU_RIVER_REASONING_EFFORT` → `reasoningEffort` di
+  `config.json` → env `RYUU_REASONING_EFFORT` → `capabilities.reasoningEffort`
+  di entri provider.
+- Nilai yang diterima: `none|low|medium|high|xhigh|max` (plus `off`/`on`).
+  Level yang tidak didukung model akan diturunkan ke level aman model itu dan
+  dicatat di log, jadi request tidak gagal.
+
+Contoh mematikan reasoning River lewat `config.json`:
+
+```json
+{ "provider": "river", "reasoningEffort": "none" }
+```
+
+`capabilities.reasoning` hanya label tampilan di `/provider`; reasoning tetap
+ditampilkan selama provider benar-benar mengirim `reasoning_content`.
+
 ## Tool yang tersedia untuk model
 
 Model hanya bisa memanggil tool yang terdaftar di allowlist lokal. Setiap
@@ -839,10 +892,13 @@ src/
     planner.js          prompt sesi, task brief, ekstraksi rencana, ringkasan
     worklog.js          fakta sesi terverifikasi yang dipakai ulang antar langkah dan tugas
   providers/
-    catalog.js          katalog provider + model, kapabilitas, validasi id, extraProviders
+    catalog.js          katalog provider + model (nvidia, tokenharbor, river), kapabilitas, extraProviders
     registry.js         registry provider dinamis (factory per id)
     index.js            pembuatan provider aktif dan resolusi pilihan provider/model
     nvidia.js           klien SDK OpenAI (dipakai semua provider), normalisasi, retry, pemetaan galat
+    tokenharbor.js      provider Token Harbor: default dan pass-through field request
+    river.js            provider River AI: reasoning_effort untuk DeepSeek + profil reasoning per model
+    vendor-extras.js    tabel field request per provider yang dibaca klien bersama
   tools/
     registry.js         allowlist, skema, risiko, antarmuka plugin
     filesystem.js       baca/tulis/edit/pindah/hapus/diff file

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ryuu-reinzz/ryuu-cli",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "Ryuu Agent CLI - an autonomous, approval-gated AI coding agent for your terminal",
   "type": "module",
   "bin": {

package/src/cli/app.js

@@ -8,7 +8,7 @@ import { createLogger } from '../services/logger.js';
 import { buildProjectSummary } from '../tools/project.js';
 import { buildToolRegistry } from '../tools/index.js';
 import { createActiveProvider, selectionFor } from '../providers/index.js';
-import { buildProviders, parseExtraProviders } from '../providers/catalog.js';
+import { buildProviders, parseExtraProviders, PROVIDER_REQUEST_FIELDS } from '../providers/catalog.js';
 import { buildRawConfig } from '../config/load.js';
 import { readSettings } from '../config/settings.js';
 import { Agent } from '../agent/agent.js';
@@ -306,6 +306,14 @@ export async function createApp({
       baseURL: selection.baseURL,
       model: selection.model,
       capabilities: selection.capabilities,
+      // Vendor request overrides (e.g. River's reasoningEffort) come from the
+      // provider that is now active, not from the one left behind.
+      ...Object.fromEntries(
+        PROVIDER_REQUEST_FIELDS.filter((field) => selection[field] !== undefined).map((field) => [
+          field,
+          selection[field],
+        ]),
+      ),
     });
     const persisted = await writeProviderPreference(stateDir, selection.providerId);
     return { ...selection, persisted };

package/src/cli/commands.js

@@ -24,6 +24,7 @@ import {
   writeModelPreference,
 } from '../services/preferences.js';
 import { describeConfig } from '../config/validate.js';
+import { describeReasoning } from '../providers/river.js';
 import { formatDoctor, runDoctor } from '../services/doctor.js';
 import { createUnifiedDiff, diffStats } from '../services/diff.js';
 import { PROVIDER_INFO } from '../services/websearch/providers.js';
@@ -261,12 +262,16 @@ export function createCommands(state) {
   define('status', 'Show provider, model, workspace, limits and the last task result', '/status', async () => {
     const last = state.getLastSummary();
     const running = processes.list({ includeCompleted: false }).filter((proc) => proc.status === 'running');
+    // The reasoning effort that will actually be sent, so a provider that
+    // thinks only when asked (River's DeepSeek models) is visible at a glance.
+    const reasoningLine = describeReasoning(config);
     const lines = [
       `model        ${config.model}`,
       `provider     ${config.providerName || 'NVIDIA Integrate API'} (${currentProviderId()})`,
       `endpoint     ${config.baseURL}`,
       `key          ${config.apiKeyPath || 'providers.nvidia.apiKey'} ${config.apiKey ? 'set (redacted)' : '(not set)'}`,
       `caps         ${capabilityText(config.capabilities)}`,
+      ...(reasoningLine ? [`reasoning    ${reasoningLine}`] : []),
       `workspace    ${workspace.root}`,
       `node         ${process.version} (${process.platform})`,
       `approval     ${config.approvalPolicy}`,

package/src/config/load.js

@@ -86,6 +86,11 @@ export function buildRawConfig(settings = {}, { cwd = process.cwd() } = {}) {
       baseURL: typeof stored.baseURL === 'string' ? stored.baseURL : '',
       model: '',
     };
+    // Per-provider request overrides (River's `reasoningEffort`, a
+    // pass-through `extraBody`, ...) are stored next to the key.
+    for (const field of ['reasoningEffort', 'thinking', 'extraBody', 'requestParams']) {
+      if (stored[field] !== undefined) credentials[id][field] = stored[field];
+    }
   }
   const storedModels = data.providerModel && typeof data.providerModel === 'object' ? data.providerModel : {};
   for (const [id, model] of Object.entries(storedModels)) {

package/src/config/validate.js

@@ -5,6 +5,7 @@ import {
   DEFAULT_PROVIDER_ID,
   MAX_MODEL_ID_LENGTH,
   MODEL_ID_PATTERN,
+  PROVIDER_REQUEST_FIELDS,
   buildProviders,
   isCatalogModel,
   parseExtraProviders,
@@ -142,7 +143,7 @@ export function validateConfig(raw = {}, { requireApiKey = true, cwd = raw.cwd |
   // come from config.json only.
   const providerCredentials =
     raw.providerCredentials && typeof raw.providerCredentials === 'object' ? raw.providerCredentials : {};
-  const extraProviders = parseExtraProviders(raw.extraProviders, issues);
+  const extraProviders = parseExtraProviders(raw.extraProviders, issues, warnings);
   const providers = buildProviders({ credentials: providerCredentials, extras: extraProviders });
 
   const explicitProvider = raw.provider ? String(raw.provider).trim().toLowerCase() : null;
@@ -372,6 +373,15 @@ export function validateConfig(raw = {}, { requireApiKey = true, cwd = raw.cwd |
       apiKey,
       model,
       baseURL,
+      // Per-provider request overrides reach the client through the effective
+      // config: a user provider may declare a vendor field such as River's
+      // reasoningEffort, and `switchProvider` has no entry for it.
+      ...Object.fromEntries(
+        PROVIDER_REQUEST_FIELDS.filter((field) => activeProvider[field] !== undefined).map((field) => [
+          field,
+          activeProvider[field],
+        ]),
+      ),
       workspace,
       logLevel,
       approvalPolicy,

package/src/providers/catalog.js

@@ -38,6 +38,40 @@ export const DEFAULT_BASE_URL = 'https://integrate.api.nvidia.com/v1';
 export const TOKENHARBOR_BASE_URL = 'https://tokenharbor.ai/v1';
 export const TOKENHARBOR_MODEL = 'deepseek-v4.1-flash:free';
 
+export const RIVER_BASE_URL = 'https://api.river.ai/v1';
+export const RIVER_PROVIDER_ID = 'river';
+export const RIVER_DOCS_URL = 'https://docs.river.ai/guides/inference-controls/';
+
+/** River's documented `reasoning_effort` menu, lowest to highest. */
+export const RIVER_REASONING_EFFORTS = ['none', 'low', 'medium', 'high', 'xhigh', 'max'];
+/** Used when thinking is enabled without an explicit level (River's own rule). */
+export const RIVER_DEFAULT_REASONING_EFFORT = 'high';
+
+/** Model ids `/model` offers for River, default first. */
+export const RIVER_MODEL_CATALOG = [
+  'deepseek-ai/DeepSeek-V4.1-Flash-1017',
+  'deepseek-ai/DeepSeek-V4.1-Flash',
+  'zai-org/GLM-5.3-Flash',
+  'GLM-5.3',
+  'Qwen/Qwen3.8-27B-FP8',
+  'nvidia/NVIDIA-Nemotron-3.5-Super-VL-120B-A12B-NVFP4',
+  'nvidia/GLM-5.2-NVFP4',
+  'nvidia/GLM-5.2-NVFP4-262K',
+  'nvidia/Kimi-K2.6-NVFP4',
+  'nvidia/Kimi-K2.6-NVFP4-262K',
+  'nvidia/NVIDIA-Nemotron-3.5-Lightning-30B-A3B-NVFP4',
+  'Qwen/Qwen3.5-9B',
+  'Qwen/Qwen3.5-122B-A10B-FP8',
+  'Qwen/Qwen3.5-397B-A17B-FP8',
+  'Qwen/Qwen3.6-35B-A3B-FP8',
+  'XiaomiMiMo/MiMo-V2.6-Flash-RL',
+  'XiaomiMiMo/MiMo-V2.6-Pro-RL',
+];
+export const RIVER_DEFAULT_MODEL = RIVER_MODEL_CATALOG[0];
+
+/** Per-provider request fields a config.json override may carry verbatim. */
+export const PROVIDER_REQUEST_FIELDS = ['reasoningEffort', 'extraBody', 'requestParams', 'thinking'];
+
 /**
  * Built-in providers, in fallback order for key auto-detection.
  *
@@ -69,6 +103,23 @@ export const BUILTIN_PROVIDERS = [
     capabilities: { streaming: true, tools: true, reasoning: true, multimodal: false },
     docsUrl: 'https://tokenharbor.ai/',
   },
+  {
+    // River keeps thinking off by default for its DeepSeek models, so the
+    // dedicated client (providers/river.js) adds `reasoning_effort` to the
+    // request; without it a DeepSeek answer arrives with no reasoning text.
+    id: 'river',
+    name: 'River AI',
+    apiFormat: 'openai-chat-completions',
+    baseURL: RIVER_BASE_URL,
+    defaultModel: RIVER_DEFAULT_MODEL,
+    models: RIVER_MODEL_CATALOG.map((id) => ({
+      id,
+      name: id,
+      ...(id === RIVER_DEFAULT_MODEL ? { default: true } : {}),
+    })),
+    capabilities: { streaming: true, tools: true, reasoning: true, multimodal: false },
+    docsUrl: RIVER_DOCS_URL,
+  },
 ];
 
 /** config.json path that holds a provider's API key. */
@@ -140,9 +191,42 @@ function normalizeCapabilities(raw, issues, label) {
     }
     out[key] = raw[key];
   }
+  // Vendor extras kept inside capabilities (e.g. River's reasoning effort) are
+  // copied through untouched: the client that knows the field validates it.
+  if (typeof raw.reasoningEffort === 'string' && raw.reasoningEffort.trim()) {
+    out.reasoningEffort = raw.reasoningEffort.trim();
+  }
   return out;
 }
 
+/** Copy the per-provider request overrides the descriptor declares. */
+function mergeRequestFields(entry, raw, label, issues) {
+  for (const field of PROVIDER_REQUEST_FIELDS) {
+    if (raw[field] === undefined) continue;
+    if (field === 'reasoningEffort') {
+      if (typeof raw[field] !== 'string' || !raw[field].trim()) {
+        issues.push(`${label}.reasoningEffort must be a non-empty string`);
+        continue;
+      }
+      entry[field] = raw[field].trim();
+      continue;
+    }
+    if (field === 'thinking') {
+      if (typeof raw[field] !== 'boolean') {
+        issues.push(`${label}.thinking must be true or false`);
+        continue;
+      }
+      entry[field] = raw[field];
+      continue;
+    }
+    if (!raw[field] || typeof raw[field] !== 'object' || Array.isArray(raw[field])) {
+      issues.push(`${label}.${field} must be a JSON object`);
+      continue;
+    }
+    entry[field] = { ...raw[field] };
+  }
+}
+
 /**
  * Parse the `extraProviders` list from config.json.
  *
@@ -154,7 +238,7 @@ function normalizeCapabilities(raw, issues, label) {
  * `providers.myproxy.apiKey`. Invalid entries are reported as config issues
  * instead of being guessed.
  */
-export function parseExtraProviders(value, issues = []) {
+export function parseExtraProviders(value, issues = [], warnings = []) {
   if (value === undefined || value === null || String(value).trim() === '') return [];
   let parsed;
   try {
@@ -180,7 +264,25 @@ export function parseExtraProviders(value, issues = []) {
       issues.push(`${label}.id must match ${PROVIDER_ID_PATTERN}`);
       continue;
     }
-    if (builtinIds.has(id) || extras.some((provider) => provider.id === id)) {
+    if (builtinIds.has(id)) {
+      // A stale entry for a provider that has since become built-in (River,
+      // for example) is dropped instead of failing startup, as long as it
+      // points at the same endpoint; the built-in descriptor then supplies the
+      // models, capabilities and any vendor request fields.
+      const builtin = BUILTIN_PROVIDERS.find((provider) => provider.id === id);
+      const sameUrl =
+        builtin &&
+        String(raw.baseURL || '').trim().replace(/\/+$/, '') === String(builtin.baseURL).trim().replace(/\/+$/, '');
+      if (sameUrl) {
+        warnings.push(
+          `${label} redeclares the built-in provider "${id}" with the same base URL; the built-in provider is used and this entry is ignored.`,
+        );
+        continue;
+      }
+      issues.push(`${label}.id ${JSON.stringify(id)} is already registered`);
+      continue;
+    }
+    if (extras.some((provider) => provider.id === id)) {
       issues.push(`${label}.id ${JSON.stringify(id)} is already registered`);
       continue;
     }
@@ -206,6 +308,11 @@ export function parseExtraProviders(value, issues = []) {
       capabilities: normalizeCapabilities(raw.capabilities, issues, label),
       docsUrl: null,
       source: 'settings',
+      ...(() => {
+        const entry = {};
+        mergeRequestFields(entry, raw, label, issues);
+        return entry;
+      })(),
     });
   }
   if (parsed.length > MAX_EXTRA_PROVIDERS) {
@@ -231,7 +338,7 @@ export function buildProviders({ credentials = {}, extras = [] } = {}) {
     const model = normalizeModelId(stored.model) || base.defaultModel;
     const models = [...base.models];
     if (model && !models.some((entry) => entry.id === model)) models.push({ id: model, name: model });
-    providers.push({
+    const descriptor = {
       ...base,
       baseURL,
       apiKey,
@@ -240,7 +347,25 @@ export function buildProviders({ credentials = {}, extras = [] } = {}) {
       modelPath: modelPathFor(base.id),
       defaultModel: model,
       models,
-    });
+    };
+    // Per-provider request overrides live next to the key
+    // (`providers.<id>.reasoningEffort`, `providers.<id>.extraBody`, ...). They
+    // travel with the descriptor, so `/provider` keeps them and the client
+    // sends them only to that provider.
+    for (const field of PROVIDER_REQUEST_FIELDS) {
+      const value = stored[field];
+      if (value === undefined) continue;
+      if (field === 'reasoningEffort') {
+        if (typeof value === 'string' && value.trim()) descriptor[field] = value.trim();
+        continue;
+      }
+      if (field === 'thinking') {
+        if (typeof value === 'boolean') descriptor[field] = value;
+        continue;
+      }
+      if (value && typeof value === 'object' && !Array.isArray(value)) descriptor[field] = { ...value };
+    }
+    providers.push(descriptor);
   }
   return providers;
 }

package/src/providers/ids.js

@@ -0,0 +1,24 @@
+/**
+ * Provider identifiers and model-id rules.
+ *
+ * These primitives are shared by the provider modules (`nvidia.js`,
+ * `tokenharbor.js`, `river.js`) and by the catalog that assembles them. They
+ * live in their own file so a provider module can be imported by the catalog
+ * without an import cycle.
+ */
+
+/** ID used when nothing else selects a provider. */
+export const DEFAULT_PROVIDER_ID = 'nvidia';
+
+export const PROVIDER_ID_PATTERN = /^[a-z0-9][a-z0-9_-]*$/;
+export const MODEL_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:/-]*$/;
+export const MAX_MODEL_ID_LENGTH = 200;
+
+/**
+ * Per-provider request fields a config.json override may carry verbatim.
+ *
+ * `reasoningEffort` becomes the wire field `reasoning_effort`; `extraBody`
+ * and `requestParams` are merged into the request body as-is; `thinking` is a
+ * boolean shorthand for turning reasoning on or off.
+ */
+export const PROVIDER_REQUEST_FIELDS = ['reasoningEffort', 'extraBody', 'requestParams', 'thinking'];

package/src/providers/index.js

@@ -1,8 +1,13 @@
 import { ProviderError } from '../utils/errors.js';
 import { ProviderRegistry } from './registry.js';
 import { createProvider as createChatCompletionsProvider } from './nvidia.js';
+// Importing a provider module registers its vendor request fields (River's
+// `reasoning_effort`, for example) with vendor-extras.js.
+import './river.js';
+import './tokenharbor.js';
 import {
   DEFAULT_PROVIDER_ID,
+  PROVIDER_REQUEST_FIELDS,
   normalizeModelId,
   normalizeProviderId,
   providerById,
@@ -12,9 +17,14 @@ import {
  * Provider wiring.
  *
  * Every catalog entry speaks the OpenAI Chat Completions protocol, so they all
- * share one client implementation. The registry exists so a new protocol can be
- * added later without touching the agent: register a factory under its id and
- * the selection code will use it.
+ * share one client implementation. The registry exists so a different protocol
+ * can be added later without touching the agent: register a factory under its
+ * id and the selection code will use it.
+ *
+ * A provider that needs request fields the protocol does not define lives in its
+ * own module (`river.js`, `tokenharbor.js`) and registers a builder with
+ * `vendor-extras.js`; the shared client applies it by provider id, so a
+ * `/provider` switch needs no new instance.
  */
 function factory(config, deps) {
   return createChatCompletionsProvider(config, deps);
@@ -78,6 +88,15 @@ export function selectionFor(config, providerId, { model = null } = {}) {
     apiKey: descriptor.apiKey,
     model: chosen,
     capabilities: { ...(descriptor.capabilities || {}) },
+    // Vendor request overrides (River's reasoningEffort, a transparent
+    // extraBody, ...) travel with the selection so switching provider also
+    // switches which fields the client adds to the request body.
+    ...Object.fromEntries(
+      PROVIDER_REQUEST_FIELDS.filter((field) => descriptor[field] !== undefined).map((field) => [
+        field,
+        descriptor[field],
+      ]),
+    ),
   };
 }
 

package/src/providers/nvidia.js

@@ -2,7 +2,8 @@ import OpenAI from 'openai';
 import { CancelledError, ProviderError, isRecoverableError } from '../utils/errors.js';
 import { redact } from '../utils/redaction.js';
 import { toToolArgumentsString } from '../utils/validation.js';
-import { MODEL_ID_PATTERN, MAX_MODEL_ID_LENGTH } from './catalog.js';
+import { MODEL_ID_PATTERN, MAX_MODEL_ID_LENGTH, PROVIDER_REQUEST_FIELDS } from './catalog.js';
+import { applyRequestExtras } from './vendor-extras.js';
 
 const RETRY_BASE_MS = 500;
 const RETRY_MAX_MS = 8000;
@@ -348,6 +349,18 @@ export class NvidiaProvider {
     return this.config.capabilities || null;
   }
 
+  /**
+   * Extra top-level fields to merge into the request body before it is sent.
+   *
+   * The OpenAI Chat Completions protocol defines no vendor fields, so the
+   * builder comes from `vendor-extras.js`, where a provider module registers
+   * itself by id (River's `reasoning_effort`, for example). Registration is by
+   * id because one instance is reused across `/provider` switches.
+   */
+  requestExtras(context = {}) {
+    return applyRequestExtras(this.config, { ...context, logger: this.logger });
+  }
+
   get providerId() {
     return this.config.providerId || null;
   }
@@ -364,7 +377,7 @@ export class NvidiaProvider {
    * Repoint this provider at another provider or model without rebuilding the
    * agent (conversation memory and the worklog stay intact).
    */
-  updateSelection({ providerId, providerName, apiKeyPath, docsUrl = null, baseURL, apiKey, model, capabilities = null } = {}) {
+  updateSelection({ providerId, providerName, apiKeyPath, docsUrl = null, baseURL, apiKey, model, capabilities = null, ...vendor } = {}) {
     if (!apiKey) {
       const path = apiKeyPath || `providers.${providerId || 'unknown'}.apiKey`;
       throw new ProviderError(
@@ -386,6 +399,14 @@ export class NvidiaProvider {
       model: model || this.config.model,
       capabilities: capabilities || this.config.capabilities || null,
     });
+    // Vendor request fields (River's `reasoningEffort`, a pass-through
+    // `extraBody`, ...) belong to the provider that is now active. The values
+    // of the provider left behind are dropped, so a request never carries a
+    // field meant for another endpoint.
+    for (const field of PROVIDER_REQUEST_FIELDS) {
+      delete this.config[field];
+      if (vendor[field] !== undefined) this.config[field] = vendor[field];
+    }
     if (!this.externalClient) this.client = this.#createClient();
     return this;
   }
@@ -441,6 +462,11 @@ export class NvidiaProvider {
       body.tools = tools;
       body.tool_choice = 'auto';
     }
+    // Vendor extensions (e.g. River's `reasoning_effort`, which turns thinking
+    // on for models whose default is off). The base client adds nothing; a
+    // provider-specific subclass overrides requestExtras().
+    const extras = this.requestExtras({ capabilities, streaming });
+    if (extras && typeof extras === 'object') Object.assign(body, extras);
 
     const startedAt = Date.now();
     const effectiveTimeout = Math.max(1000, Number(timeoutMs ?? this.config.requestTimeoutMs) || 1000);

package/src/providers/river.js

@@ -0,0 +1,198 @@
+import { MODEL_ID_PATTERN, MAX_MODEL_ID_LENGTH } from './catalog.js';
+import { RIVER_DEFAULT_REASONING_EFFORT, RIVER_PROVIDER_ID, RIVER_REASONING_EFFORTS } from './catalog.js';
+import { registerRequestExtras, passthroughExtras } from './vendor-extras.js';
+
+export {
+  RIVER_BASE_URL,
+  RIVER_DEFAULT_MODEL,
+  RIVER_DEFAULT_REASONING_EFFORT,
+  RIVER_DOCS_URL,
+  RIVER_MODEL_CATALOG,
+  RIVER_PROVIDER_ID,
+  RIVER_REASONING_EFFORTS,
+} from './catalog.js';
+
+/**
+ * River AI provider.
+ *
+ * River speaks the OpenAI Chat Completions protocol, so it reuses the shared
+ * client (`nvidia.js`) and only adds the vendor fields that protocol does not
+ * define. The client asks `vendor-extras.js` for those fields by provider id,
+ * and this module registers the River builder at import time — no subclass, so
+ * one client instance keeps working across `/provider` switches.
+ *
+ * Why this file exists: River keeps thinking *off by default* for its DeepSeek
+ * models, so a plain Chat Completions request never produces `reasoning_content`
+ * and the CLI has nothing to render. River turns thinking on with a top-level
+ * `reasoning_effort` field (see https://docs.river.ai/guides/inference-controls/),
+ * which the shared client never sent. `riverRequestExtras()` adds it.
+ *
+ * The effort is only sent when the model is documented to accept it, and it is
+ * only forced for models whose documented default is *off*; every other River
+ * model already returns `reasoning_content` by itself.
+ */
+
+/**
+ * Per-model reasoning profile, transcribed from
+ * https://docs.river.ai/guides/inference-controls/ (read 2026-10-30).
+ *
+ * `levels` is the model's accepted `reasoning_effort` menu, `onByDefault` tells
+ * whether it already thinks without the field, and `enable` is the level used to
+ * turn thinking on. A model missing from this table is left untouched: an effort
+ * value an endpoint does not know can fail the whole request.
+ */
+export const RIVER_MODEL_REASONING = {
+  'deepseek-ai/DeepSeek-V4.1-Flash-1017': {
+    levels: ['none', 'low', 'high', 'max'],
+    onByDefault: false,
+    enable: 'high',
+  },
+  'deepseek-ai/DeepSeek-V4.1-Flash': {
+    levels: ['none', 'low', 'high', 'max'],
+    onByDefault: false,
+    enable: 'high',
+  },
+  'zai-org/GLM-5.3-Flash': { levels: ['low', 'high', 'max'], onByDefault: true, enable: 'max' },
+  'GLM-5.3': { levels: ['low', 'high', 'max'], onByDefault: true, enable: 'max' },
+  'Qwen/Qwen3.8-27B-FP8': { levels: ['none', 'low', 'medium', 'xhigh'], onByDefault: true, enable: 'xhigh' },
+  'nvidia/NVIDIA-Nemotron-3.5-Super-VL-120B-A12B-NVFP4': {
+    levels: ['none', 'medium', 'high'],
+    onByDefault: true,
+    enable: 'high',
+  },
+};
+
+/** Environment override for the River reasoning effort. */
+export const RIVER_EFFORT_ENV = 'RYUU_RIVER_REASONING_EFFORT';
+/** Generic environment override, read after the River-specific one. */
+export const REASONING_EFFORT_ENV = 'RYUU_REASONING_EFFORT';
+
+/**
+ * Normalize an effort value.
+ *
+ * Returns one of the documented levels, or null when the value is not a level at
+ * all. "off"/"disabled"/false map to "none" so the same word works in the
+ * environment variable and in config.json.
+ */
+export function normalizeReasoningEffort(value) {
+  if (value === undefined || value === null) return null;
+  if (typeof value === 'boolean') return value ? RIVER_DEFAULT_REASONING_EFFORT : 'none';
+  const text = String(value).trim().toLowerCase().replace(/[\s_]+/g, '-');
+  if (!text) return null;
+  if (['off', 'false', 'no', 'disabled', 'disable'].includes(text)) return 'none';
+  if (['on', 'true', 'yes', 'enabled'].includes(text)) return RIVER_DEFAULT_REASONING_EFFORT;
+  return RIVER_REASONING_EFFORTS.includes(text) ? text : null;
+}
+
+/**
+ * The effort the user asked for, or null when they asked for nothing.
+ *
+ * Precedence: `RYUU_RIVER_REASONING_EFFORT`, `reasoningEffort` from config.json,
+ * `RYUU_REASONING_EFFORT`, then `capabilities.reasoningEffort` — so an official
+ * `river` provider and a hand-written provider entry can both set it.
+ */
+export function resolveRequestedEffort(config = {}, env = process.env) {
+  const candidates = [
+    env?.[RIVER_EFFORT_ENV],
+    config?.reasoningEffort,
+    env?.[REASONING_EFFORT_ENV],
+    config?.capabilities?.reasoningEffort,
+  ];
+  for (const candidate of candidates) {
+    const effort = normalizeReasoningEffort(candidate);
+    if (effort) return effort;
+  }
+  return null;
+}
+
+/** The model's documented profile, or null when it is not a known model. */
+export function reasoningProfileFor(model) {
+  return RIVER_MODEL_REASONING[String(model || '')] || null;
+}
+
+/**
+ * Decide which `reasoning_effort` (if any) to send for a model.
+ *
+ * Returns null when the field must be omitted — the user asked for nothing and
+ * the model already reasons by default, or the requested level is not in the
+ * model's documented menu.
+ */
+export function resolveReasoningEffort(config = {}, { env = process.env, model = null, logger = null } = {}) {
+  const target = String(model || config?.model || '');
+  const profile = reasoningProfileFor(target);
+  const requested = resolveRequestedEffort(config, env);
+  let effort = null;
+  if (requested) {
+    effort = requested;
+  } else if (config?.thinking === false) {
+    effort = 'none';
+  } else if (config?.thinking === true) {
+    effort = profile?.enable || RIVER_DEFAULT_REASONING_EFFORT;
+  } else if (profile && !profile.onByDefault) {
+    effort = profile.enable; // DeepSeek: thinking is off unless asked for
+  }
+  if (!effort || effort === 'none') {
+    // "none" only means something to a model that accepts it; elsewhere an
+    // absent field falls back to the same model default.
+    return effort === 'none' && profile?.levels?.includes('none') ? 'none' : null;
+  }
+  if (profile && !profile.levels.includes(effort)) {
+    logger?.warn('reasoning_effort is not supported by this model; using the provider default', {
+      model: target,
+      requested: effort,
+      supported: profile.levels,
+    });
+    return profile.enable && profile.levels.includes(profile.enable) ? profile.enable : null;
+  }
+  return effort;
+}
+
+/**
+ * River's request-body extension for the shared client.
+ *
+ * Opaque pass-through fields first (a hand-written `extraProviders` entry may
+ * carry `extraBody`/`requestParams`), then the `reasoning_effort` that turns
+ * DeepSeek thinking on.
+ */
+export function riverRequestExtras(config = {}, { logger = null, env = process.env } = {}) {
+  const extras = passthroughExtras(config);
+  const effort = resolveReasoningEffort(config, { model: config.model, logger, env });
+  if (effort) extras.reasoning_effort = effort;
+  return extras;
+}
+
+/** True when a requestExtras() payload carries an explicit reasoning effort. */
+export function hasReasoningEffort(extras) {
+  const value = extras?.reasoning_effort;
+  if (value === undefined || value === null) return false;
+  return !(typeof value === 'string' && !value.trim());
+}
+
+/** Human-readable effort for /status. */
+export function describeEffort(effort) {
+  return !effort || effort === 'none' ? 'off (model default)' : effort;
+}
+
+/**
+ * One line describing the reasoning effort that will be sent, or null when the
+ * provider does not use one (so `/status` stays quiet for them).
+ */
+export function describeReasoning(config = {}, { env = process.env, logger = null } = {}) {
+  const extras = riverRequestExtras(config, { env, logger });
+  if (!hasReasoningEffort(extras)) return null;
+  const effort = extras.reasoning_effort;
+  return effort === 'none'
+    ? 'off (reasoning_effort: none)'
+    : `reasoning_effort: ${effort}`;
+}
+
+/** Sanity check used by tests and `/doctor`: the model id must remain valid. */
+export function isValidRiverModel(model) {
+  return typeof model === 'string' && model.length <= MAX_MODEL_ID_LENGTH && MODEL_ID_PATTERN.test(model);
+}
+
+// The shared client consults this table on every request. Registering at import
+// time keeps the wiring in one place: `providers/index.js` only has to import
+// this module, and any provider with the id "river" gets the extension. The host
+// fallback also covers a hand-written `extraProviders` entry for the same API.
+registerRequestExtras(RIVER_PROVIDER_ID, riverRequestExtras, { hosts: ['api.river.ai'] });

package/src/providers/tokenharbor.js

@@ -0,0 +1,38 @@
+import { TOKENHARBOR_BASE_URL, TOKENHARBOR_MODEL } from './catalog.js';
+import { registerRequestExtras, passthroughExtras } from './vendor-extras.js';
+
+/**
+ * Token Harbor provider.
+ *
+ * It speaks the OpenAI Chat Completions protocol and already returns
+ * `reasoning_content`, so it needs no vendor request field: the module exists
+ * to own the provider's defaults and to be the place a future Token Harbor-only
+ * field would go.
+ *
+ * A user `extraProviders` entry may still carry `extraBody`/`requestParams`; they
+ * are passed through untouched, which makes an unusual gateway reachable without
+ * a code change.
+ */
+
+export const TOKENHARBOR_DOCS_URL = 'https://tokenharbor.ai/';
+
+/** Request-body extension for Token Harbor: only explicit pass-through fields. */
+export function tokenHarborRequestExtras(config = {}) {
+  return passthroughExtras(config);
+}
+
+/** Declared descriptor, kept next to the client like the other provider modules. */
+export function tokenHarborDescriptor() {
+  return {
+    id: 'tokenharbor',
+    name: 'Token Harbor',
+    apiFormat: 'openai-chat-completions',
+    baseURL: TOKENHARBOR_BASE_URL,
+    defaultModel: TOKENHARBOR_MODEL,
+    models: [{ id: TOKENHARBOR_MODEL, name: 'DeepSeek V4.1 Flash Free', default: true }],
+    capabilities: { streaming: true, tools: true, reasoning: true, multimodal: false },
+    docsUrl: TOKENHARBOR_DOCS_URL,
+  };
+}
+
+registerRequestExtras('tokenharbor', tokenHarborRequestExtras);

package/src/providers/vendor-extras.js

@@ -0,0 +1,82 @@
+/**
+ * Provider ids whose request body needs extra fields. Keyed by provider id (and
+ * by API host for a hand-written entry pointing at the same endpoint).
+ *
+ * `passthrough` is the fallback for any provider without a registered builder:
+ * a `extraBody`/`requestParams` object in its config.json entry is copied into
+ * the request verbatim, so an unusual gateway stays reachable without a code
+ * change.
+ */
+
+/** providerId -> { builder, hosts: Set<string> } */
+const builders = new Map();
+
+function hostOf(baseURL) {
+  try {
+    return new URL(String(baseURL || '')).hostname.toLowerCase();
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * Register (or replace) the builder for one provider id.
+ *
+ * `hosts` makes the builder apply to any provider whose base URL uses that host,
+ * which keeps a hand-written `extraProviders` entry for the same vendor working.
+ */
+export function registerRequestExtras(providerId, builder, { hosts = [] } = {}) {
+  if (!providerId || typeof builder !== 'function') return;
+  const list = [].concat(hosts).map((host) => String(host || '').toLowerCase()).filter(Boolean);
+  builders.set(String(providerId), { builder, hosts: new Set(list) });
+}
+
+/** Remove a builder. Mostly useful for tests. */
+export function unregisterRequestExtras(providerId) {
+  builders.delete(String(providerId));
+}
+
+/** The registered builder for a provider id, then fall back to its API host. */
+export function requestExtrasFor(providerId, baseURL = '') {
+  const direct = builders.get(String(providerId || ''));
+  if (direct) return direct.builder;
+  const host = hostOf(baseURL);
+  if (!host) return null;
+  for (const entry of builders.values()) {
+    if (entry.hosts.has(host)) return entry.builder;
+  }
+  return null;
+}
+
+/**
+ * Default builder for providers without one: copy the explicit pass-through
+ * objects a config.json entry may carry. Nothing is guessed, so a plain provider
+ * still sends only the standard Chat Completions fields.
+ */
+export function passthroughExtras(config = {}) {
+  const extras = {};
+  for (const field of ['extraBody', 'requestParams']) {
+    const value = config?.[field];
+    if (value && typeof value === 'object' && !Array.isArray(value)) Object.assign(extras, value);
+  }
+  return extras;
+}
+
+/**
+ * Extra top-level request fields for this provider, or null when it has none.
+ * A builder that throws must never break a request: the failure is swallowed
+ * and the request goes out unchanged.
+ */
+export function applyRequestExtras(config, context = {}) {
+  const builder = requestExtrasFor(config?.providerId, config?.baseURL) || passthroughExtras;
+  try {
+    const extras = builder(config, context);
+    return extras && typeof extras === 'object' && Object.keys(extras).length > 0 ? extras : null;
+  } catch (error) {
+    context.logger?.warn('provider request extras failed; sending the request unchanged', {
+      provider: config?.providerId,
+      message: error?.message || String(error),
+    });
+    return null;
+  }
+}