reis-mobile 0.7.3 → 0.9.0

package/bin/reis-mobile.mjs

@@ -10,6 +10,8 @@ import { detectStack } from '../core/detection/stack-detector.mjs';
 import { runDoctor } from '../core/diagnostics/doctor.mjs';
 import { runInit } from '../core/install/init.mjs';
 import { PLUGIN_ROOT } from '../core/paths.mjs';
+import { DEFAULT_TIMEOUT_MS, consult, listProviderModels } from '../core/providers/consult.mjs';
+import { parseProviderList, providerAllowlist, resolveProviders, selectProviders } from '../core/providers/providers.mjs';
 import { loadRegistry, validateRegistry } from '../core/registry/registry.mjs';
 import { releaseContext } from '../core/release/context.mjs';
 import { INTENT_IDS } from '../core/router/intents.mjs';
@@ -30,6 +32,8 @@ Commands:
   debug [problem...]         Route a build or runtime failure and report the toolchain it runs on
   test [request...]          Prepare test routing, git context and toolchain checks (does not run tests)
   release [request...]       Prepare release evidence context (does not build or publish)
+  providers                  List the external model providers and what each one needs
+  consult [question...]      Ask the configured external providers the same question
   agents | skills | stacks   List registered components
   validate                   Validate the plugin's agents, skills and stacks
   update-check               Check npm for a newer reis-mobile release
@@ -44,6 +48,11 @@ Options:
   --scope <scope>   init: Claude Code scope, user (default), project or local
   --uninstall       init: remove the plugin and its marketplace from Claude Code and Codex, and the saved language
   --force           update-check: ignore the cached registry result
+  --providers <ids> providers/consult: comma-separated provider ids (default: every usable one)
+  --model <id>      consult: model for the selected HTTP providers, overriding the configuration
+  --models          providers: ask each provider which models it serves (network request)
+  --file <path>     consult: read the question from a file instead of the arguments
+  --timeout <ms>    consult: give up on a provider after this long (default 120000)
   --lang <en|pt>    Override the saved language for this run
   --json            Machine-readable output
   -v, --version     Print the version
@@ -59,6 +68,11 @@ const OPTIONS = {
   scope: { type: 'string' },
   uninstall: { type: 'boolean' },
   force: { type: 'boolean' },
+  providers: { type: 'string' },
+  model: { type: 'string' },
+  models: { type: 'boolean' },
+  file: { type: 'string' },
+  timeout: { type: 'string' },
   lang: { type: 'string' },
   json: { type: 'boolean' },
   version: { type: 'boolean', short: 'v' },
@@ -75,6 +89,8 @@ const COMMANDS = {
   debug: commandDebug,
   test: commandTest,
   release: commandRelease,
+  providers: commandProviders,
+  consult: commandConsult,
   agents: (options) => commandList('agents', options),
   skills: (options) => commandList('skills', options),
   stacks: (options) => commandList('stacks', options),
@@ -109,7 +125,7 @@ async function main(argv) {
   return (await command({ ...options, dir: project.projectDir, project, prompt: rest.join(' ') })) ?? 0;
 }
 
-const PROJECT_COMMANDS = new Set(['detect', 'doctor', 'route', 'review', 'debug', 'test', 'release']);
+const PROJECT_COMMANDS = new Set(['detect', 'doctor', 'route', 'review', 'debug', 'test', 'release', 'providers', 'consult']);
 
 async function commandUpdateCheck({ force, json }) {
   const result = await checkForUpdate({ force });
@@ -300,6 +316,112 @@ async function commandRelease({ dir, project, prompt, json, lang }) {
   return 0;
 }
 
+/**
+ * External providers and what each one still needs. No network call: an executable on PATH
+ * or a credential in the environment is what decides `ready`, so `providers` and `doctor`
+ * stay offline. `--models` is the one exception, and asks the provider itself rather than
+ * shipping a model id that goes stale.
+ */
+async function commandProviders({ project, all, json, models, providers: requested, model, timeout }) {
+  const allow = providerAllowlist(project.config);
+  const resolution = await resolveProviders({ allow, model });
+  const requestedIds = parseProviderList(requested);
+  for (const warning of resolution.warnings) console.error(`! ${warning}`);
+
+  if (models) {
+    const selected = selectProviders(resolution.providers, requestedIds, { requireModel: false });
+    const catalogs = await listProviderModels({ providers: selected, timeoutMs: parseTimeout(timeout, 30_000) });
+    if (json) return print({ models: catalogs, configPath: resolution.configPath });
+    for (const catalog of catalogs) {
+      const summary = catalog.status === 'ok' ? `${catalog.models.length} model(s)` : `${catalog.status} · ${catalog.error}`;
+      console.log(`${catalog.provider.padEnd(14)}${summary}`);
+      for (const id of catalog.models) console.log(`  · ${id}`);
+    }
+    return catalogs.some((catalog) => catalog.status === 'ok') ? 0 : 1;
+  }
+
+  if (json) return print({ providers: resolution.providers, configPath: resolution.configPath, projectConfig: project.config?.path ?? null });
+
+  printProject(project);
+  const shown = all ? resolution.providers : resolution.providers.filter((provider) => provider.selectable);
+  for (const provider of shown) {
+    const model = provider.model ? `model ${provider.model} (${provider.modelSource})` : provider.kind === 'cli' ? 'own model' : 'no model';
+    console.log(`${provider.id.padEnd(14)}${PROVIDER_SYMBOLS[provider.status]} ${provider.status.padEnd(9)}${model.padEnd(34)}${provider.detail}`);
+  }
+  const usable = resolution.providers.filter((provider) => provider.runnable);
+  console.log(
+    usable.length
+      ? `\n${usable.length} provider(s) ready: reis-mobile consult --providers ${usable.map((provider) => provider.id).join(',')} -- "<question>"`
+      : '\nNo provider is ready. Install the Codex or Gemini CLI, or set an API key and a model (reis-mobile providers --all).',
+  );
+  console.log(`Config      ${resolution.configPath}`);
+  return 0;
+}
+
+const PROVIDER_SYMBOLS = { ready: '✓', local: '-', missing: '-', disabled: '-', blocked: '✗' };
+
+/**
+ * Asks the selected providers the same question. The core performs the call so no API key
+ * reaches the conversation, and both the question and every answer go through the redaction
+ * layer on the way through.
+ */
+async function commandConsult({ dir, project, json, providers: requested, model, timeout, file, prompt, lang }) {
+  const question = file ? await readFile(file, 'utf8') : prompt || (await readStdin());
+  if (!question.trim()) {
+    console.error('consult needs a question. Pass it as an argument, with --file <path>, or on stdin.');
+    return 1;
+  }
+
+  const allow = providerAllowlist(project.config);
+  const resolution = await resolveProviders({ allow, model });
+  for (const warning of resolution.warnings) console.error(`! ${warning}`);
+  const selected = selectProviders(resolution.providers, parseProviderList(requested));
+  if (!selected.length) {
+    console.error('No external provider is ready. Run `reis-mobile providers --all` to see what each one needs.');
+    return 1;
+  }
+
+  const detection = await detectStack(dir);
+  const language = await resolveLanguage({ flag: lang });
+  const answers = await consult({ prompt: question, providers: selected, timeoutMs: parseTimeout(timeout, DEFAULT_TIMEOUT_MS) });
+  const answered = answers.results.filter((result) => result.status === 'ok');
+
+  if (json) {
+    print({ stack: detection.stack, language, projectConfig: project.config?.path ?? null, ...answers });
+    return answered.length ? 0 : 1;
+  }
+
+  printProject(project);
+  console.log(`Stack       ${detection.stack}`);
+  printLanguage(language);
+  console.log(`Question    ${answers.prompt.chars} chars${answers.prompt.redacted ? ' (secrets masked)' : ''}`);
+  for (const result of answers.results) {
+    const heading = `${result.provider}${result.model ? ` · ${result.model}` : ''} · ${result.status} · ${(result.durationMs / 1000).toFixed(1)}s`;
+    console.log(`\n--- ${heading} ---`);
+    console.log(result.status === 'ok' ? result.text : `! ${result.error}`);
+  }
+  console.log(
+    answered.length
+      ? '\nExternal answers are an outside opinion: they do not know this project. Verify every claim in the code.'
+      : '\nNo provider answered.',
+  );
+  return answered.length ? 0 : 1;
+}
+
+function parseTimeout(value, fallback) {
+  if (value === undefined) return fallback;
+  const timeout = Number(value);
+  if (!Number.isFinite(timeout) || timeout <= 0) throw new Error(`--timeout must be a positive number of milliseconds, got ${JSON.stringify(value)}`);
+  return timeout;
+}
+
+async function readStdin() {
+  if (process.stdin.isTTY) return '';
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  return Buffer.concat(chunks).toString('utf8');
+}
+
 async function commandList(kind, { json }) {
   const registry = await loadRegistry();
   const items = registry[kind];

package/commands/consult.md

@@ -0,0 +1,95 @@
+---
+description: Second opinion from external providers — builds a stack-aware briefing, sends it through the provider layer and reconciles every outside claim against the code
+argument-hint: "[--providers a,b] [--model <id>] [--files a,b] <question>"
+allowed-tools: ["Bash(node:*)", "Read", "Grep", "Glob", "Write"]
+---
+
+# reis-mobile consult
+
+Arguments received: `$ARGUMENTS`
+
+Use this command when a mobile decision or finding deserves a model that does not share this session's blind spots: a migration you are unsure about, a diagnosis you cannot confirm, a trade-off where you suspect you are anchored. For a question the code answers on its own, answer it directly and say why a consult was not worth it.
+
+**This sends project context to a third party.** Everything in the briefing leaves the session, including the excerpts of the files you include. Name the providers that will receive it before sending, and never include a credential, a store key or a `.env` value.
+
+## 1. Parse the arguments
+
+| Flag | Default | Effect |
+|---|---|---|
+| `--providers a,b` | every ready provider | Explicit provider ids, from step 2. |
+| `--model <id>` | per-provider configuration | Model for the selected HTTP providers. |
+| `--files a,b` | files named in the question | Extra files to include in the briefing. |
+| `--timeout <ms>` | 120000 | How long to wait for each provider. |
+
+Whatever remains is the question, as free text. Without a question, explain the usage and stop.
+
+## 2. Check who can answer
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/bin/reis-mobile.mjs" providers --dir "$PWD" --all
+```
+
+`ready` providers can be used now. `missing` ones state the executable or the credential they need, `local` needs a server running, `disabled` is off in the user config and `blocked` is not in the `providers:` allowlist of `.reis-mobile/config.yaml` — a team decision, which you do not work around. With no ready provider, show what each one needs and stop.
+
+## 3. Route the question and gather the evidence
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/bin/reis-mobile.mjs" route --dir "$PWD" -- "<question>"
+```
+
+Use the `Language` line for everything the user reads (`en` English, `pt` Brazilian Portuguese; `-` means the language of the request). Read the selected agent and skills as `/reis-mobile:review` does, then resolve the paths in the question and in `--files` and read them. External providers receive content, never paths: they cannot open your repository.
+
+**Form your own position first.** Write it down before sending anything. A consult that starts without one turns into agreement with whatever comes back.
+
+## 4. Write the briefing
+
+```bash
+mkdir -p ".reis-mobile/consults/<NNN-question-slug>"
+```
+
+`NNN` is sequential within `.reis-mobile/consults/`. Write `briefing.md` in that folder with the Write tool, self-contained:
+
+```text
+QUESTION: <question>
+STACK: <detected stack, variant and platforms>
+LANGUAGE: <language — answer in it>
+CODE: <the relevant excerpts, with file:line for each>
+CONSTRAINTS: <versions, SDK targets, deadlines or rules that limit the answer>
+
+You do not have access to this repository: everything you need is above.
+Answer in at most 500 words: your recommendation, the evidence in the excerpts that
+supports it, what it costs, and what would change your mind. Say explicitly when the
+excerpts are not enough to decide.
+```
+
+## 5. Consult
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/bin/reis-mobile.mjs" consult --dir "$PWD" \
+  --file ".reis-mobile/consults/<id>/briefing.md" \
+  [--providers <ids>] [--model <id>] [--timeout <ms>]
+```
+
+The CLI performs the call, so no API key passes through this conversation; the question is masked by the redaction layer on the way out and every answer on the way in. Each block is headed by the provider, its model, its status and its duration. A `no-model`, `timeout`, `unavailable` or `error` status is information to report, not a failure to retry blindly — retry once at most, and only for `timeout`.
+
+## 6. Reconcile against the code
+
+External answers do not know this project and have no reis-mobile skills. For every claim that matters:
+
+- confirm it in the code and cite `file:line`;
+- mark as **unverifiable** what the excerpts cannot settle;
+- mark as **wrong** what the code contradicts, with the evidence.
+
+A claim that only repeats the briefing back adds nothing. Do not adopt a recommendation because several providers agree: they may share a training bias that your code does not.
+
+## 7. Report
+
+In this order:
+
+1. **Decision** — your recommendation, with the reason, in one paragraph.
+2. **Where the providers agreed with you** and where they did not, naming each one.
+3. **Confirmed claims** with `file:line`, then **unverifiable** and **wrong** ones.
+4. **Action plan**, if the decision implies work.
+5. The briefing path and the providers that received it.
+
+Do not apply any code change: a consult ends in a recommendation. Implementing it is a new request.

package/commands/debate.md

@@ -1,7 +1,7 @@
 ---
 description: Structured debate between the mobile specialists — each agent defends its perspective, rebuts the others, and lead-mobile decides
-argument-hint: "[--rounds N] [--agents a,b,c] [--external] <question>"
-allowed-tools: ["Bash(node:*)", "Bash(command:*)", "Bash(mkdir:*)", "Bash(codex:*)", "Bash(gemini:*)", "Agent", "Read", "Write", "Grep", "Glob"]
+argument-hint: "[--rounds N] [--agents a,b,c] [--external] [--providers a,b] <question>"
+allowed-tools: ["Bash(node:*)", "Bash(mkdir:*)", "Agent", "Read", "Write", "Grep", "Glob"]
 ---
 
 # reis-mobile debate
@@ -16,7 +16,8 @@ Use this command for architecture decisions with real trade-offs, not for routin
 |---|---|---|
 | `--rounds N` | 2 | Number of rounds, from 1 to 3. Above 3, warn and use 3. |
 | `--agents a,b,c` | automatic | Explicit participants, using the names from the table in step 3. |
-| `--external` | off | Adds Codex and Gemini to the debate, when installed. |
+| `--external` | off | Adds every ready external provider to the debate. |
+| `--providers a,b` | every ready one | Explicit provider ids; implies `--external`. |
 
 Whatever remains is the question, as free text. Without a question, explain the usage and stop.
 
@@ -98,23 +99,26 @@ Ground every claim in file:line. Do not write what you have not verified.
 Write your position to: .reis-mobile/debates/<id>/rounds/r1_<agent>.md
 ```
 
-### 5.1 External providers (only with `--external`)
+### 5.1 External providers (only with `--external` or `--providers`)
 
-Check before calling, and carry on without them if they are missing — their absence is informative, not an error:
+Ask the core which providers can answer, instead of probing for executables yourself:
 
 ```bash
-command -v codex >/dev/null 2>&1 && echo codex
-command -v gemini >/dev/null 2>&1 && echo gemini
+node "${CLAUDE_PLUGIN_ROOT}/bin/reis-mobile.mjs" providers --dir "$PWD" --all
 ```
 
-If present, call them in parallel with the agents, writing to `r1_codex.md` and `r1_gemini.md`:
+`ready` providers can be used now; `missing`, `local`, `disabled` and `blocked` state what each one needs, and `blocked` means the repository's `providers:` allowlist excludes it — a team decision you do not work around. With no ready provider, carry on with the agents alone: their absence is informative, not an error. State at the opening who joined and who was missing.
+
+Write the same briefing you gave the agents to `rounds/r<N>_briefing.md` with the Write tool — a file, so nothing depends on shell quoting — and send it:
 
 ```bash
-codex exec --full-auto "<briefing>"
-printf '%s' "<briefing>" | gemini -p "" -o text --approval-mode yolo
+node "${CLAUDE_PLUGIN_ROOT}/bin/reis-mobile.mjs" consult --dir "$PWD" \
+  --file ".reis-mobile/debates/<id>/rounds/r<N>_briefing.md" [--providers <ids>]
 ```
 
-They do not have the plugin skills and do not know the project: give the entire context in the briefing and treat the output as an outside opinion, to be checked against the code before it enters the synthesis. State at the opening who joined and who was missing.
+The CLI performs the call, so no API key passes through this conversation, and the briefing is masked by the redaction layer before it leaves the process. Write each answer to `rounds/r<N>_<provider>.md` with the Write tool, keeping the provider id and the status from the output header. Treat a `timeout`, `error` or `no-model` status as a participant that did not answer this round.
+
+They do not have the plugin skills and do not know the project: the briefing carries the entire context, and the output is an outside opinion to be checked against the code before it enters the synthesis. In round 2 they receive the others' positions exactly as the agents do.
 
 ## 6. Round 2 — rebuttal
 

package/commands/reis-mobile.md

@@ -1,6 +1,6 @@
 ---
-description: reis-mobile entry point — lists the commands or forwards to doctor, project, review, debug, test, release, debate or the right agent from a free-form request
-argument-hint: "[doctor | project | review | debug | test | release | debate | free-form request]"
+description: reis-mobile entry point — lists the commands or forwards to doctor, project, review, debug, test, release, debate, consult or the right agent from a free-form request
+argument-hint: "[doctor | project | review | debug | test | release | debate | consult | free-form request]"
 allowed-tools: ["Bash(node:*)", "Bash(git:*)", "Read", "Grep", "Glob", "Edit", "Write"]
 ---
 
@@ -26,6 +26,7 @@ Reply only with this list. The only thing to run is `node "${CLAUDE_PLUGIN_ROOT}
 /reis-mobile:test [request]          Runs, writes, audits or fixes tests using the project's test setup
 /reis-mobile:release [request]       Audits store readiness with evidence and a go/no-go verdict
 /reis-mobile:debate <question>       Debate between the specialists, with a decision by lead-mobile
+/reis-mobile:consult <question>      Second opinion from the configured external providers, checked against the code
 /reis-mobile <free-form request>     Forwards the request to the agent and skills for the detected stack
 ```
 
@@ -52,6 +53,10 @@ Read `${CLAUDE_PLUGIN_ROOT}/commands/debug.md` and follow all of it, treating th
 
 Read `${CLAUDE_PLUGIN_ROOT}/commands/debate.md` and follow all of it, treating the rest of the arguments (without the word `debate`) as `$ARGUMENTS`.
 
+## `consult [options] <question>`
+
+Read `${CLAUDE_PLUGIN_ROOT}/commands/consult.md` and follow all of it, treating the rest of the arguments (without the word `consult`) as `$ARGUMENTS`. This entry point has the same behavior as `/reis-mobile:consult`.
+
 ## `test [request]`
 
 Read `${CLAUDE_PLUGIN_ROOT}/commands/test.md` and follow all of it, treating the rest of the arguments (without the word `test`) as `$ARGUMENTS`. This entry point has the same behavior as `/reis-mobile:test`.

package/commands/review.md

@@ -51,3 +51,5 @@ Confirm every finding in the code before reporting it. Do not modify files: this
 Answer in the format defined by the agent (Summary, Critical, Bugs, Architecture, Security, Performance, Maintainability, Suggested changes), translating the headings when the language is not English. On the first line of the Summary, state the stack, the agent and the skills used, so the routing is visible.
 
 If the router emitted warnings (lines starting with `!`), mention them in the Summary.
+
+When the user wants a finding cross-checked by a model outside this session, point them at `/reis-mobile:consult <question>`: it builds the briefing, sends it to the configured providers and reconciles every outside claim against the code. A review never sends project context to a third party on its own.

package/core/config/project.mjs

@@ -5,7 +5,7 @@ import { parseYamlSubset } from '../registry/frontmatter.mjs';
 
 export const PROJECT_CONFIG = join('.reis-mobile', 'config.yaml');
 
-const KNOWN_KEYS = new Set(['app']);
+const KNOWN_KEYS = new Set(['app', 'providers']);
 
 /**
  * Finds the nearest `.reis-mobile/config.yaml`, starting at `dir` and walking up, so a

package/core/diagnostics/doctor.mjs

@@ -4,8 +4,10 @@ import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { promisify } from 'node:util';
 
+import { findProjectConfig } from '../config/project.mjs';
 import { createProbe } from '../detection/project-probe.mjs';
 import { detectStack } from '../detection/stack-detector.mjs';
+import { providerAllowlist, resolveProviders } from '../providers/providers.mjs';
 
 const run = promisify(execFile);
 const TOOL_TIMEOUT_MS = 30_000;
@@ -47,8 +49,9 @@ export async function runDoctor({ projectDir = process.cwd(), all = false, platf
   const tools = TOOLS.filter((tool) => all || tool.relevant(context));
   const toolChecks = await Promise.all(tools.map((tool) => checkTool(tool, platform)));
   const projectChecks = await checkProject(probe, detection, files);
+  const providerChecks = await checkProviders(detection.projectDir, all);
 
-  const checks = [...toolChecks, ...projectChecks];
+  const checks = [...toolChecks, ...projectChecks, ...providerChecks];
   const warnings = checks.filter((check) => check.status === 'warning').length;
 
   return {
@@ -85,6 +88,25 @@ async function checkTool(tool, platform) {
   }
 }
 
+/**
+ * External model providers, resolved from PATH and the environment only: `doctor` makes no
+ * network call, so a reachable provider is never confirmed here, just a configured one.
+ */
+async function checkProviders(projectDir, all) {
+  const { providers } = await resolveProviders({ allow: providerAllowlist(findProjectConfig(projectDir)) });
+  const shown = all ? providers : providers.filter((provider) => provider.status === 'ready');
+  if (!shown.length) {
+    return [{ id: 'providers', label: 'Providers', section: 'integrations', status: 'info', detail: 'none configured (reis-mobile providers --all)' }];
+  }
+  return shown.map((provider) => ({
+    id: `provider-${provider.id}`,
+    label: provider.label,
+    section: 'integrations',
+    status: provider.status === 'ready' ? 'ok' : 'info',
+    detail: `${provider.status} · ${provider.model ? `model ${provider.model}` : provider.kind === 'cli' ? 'own model' : 'no model'}`,
+  }));
+}
+
 async function checkAndroidSdk() {
   const candidates = [
     process.env.ANDROID_HOME,

package/core/providers/catalog.mjs

@@ -0,0 +1,168 @@
+// External model providers reis-mobile can ask for a second opinion.
+//
+// A provider is data, not code paths spread across commands: the catalog says how to reach
+// it, which credential proves it is usable and where its model catalog lives. Nothing here
+// carries a default model id — a provider is the only authority on its own catalog, and a
+// hardcoded id becomes wrong the day it is retired. `providers --models` asks instead.
+
+const JSON_HEADERS = { 'content-type': 'application/json' };
+
+/** OpenAI, OpenRouter and any other `/chat/completions` endpoint share this shape. */
+function openAiCompatible({ id, label, docs, keys, modelEnv, baseEnv, defaultBase, headers = {} }) {
+  const base = (env) => trimTrailingSlash(env[baseEnv] || defaultBase);
+  const auth = (env) => ({ authorization: `Bearer ${credential(env, keys)}`, ...headers });
+  return {
+    id,
+    label,
+    kind: 'http',
+    docs,
+    keys,
+    modelEnv,
+    needsModel: true,
+    base,
+    chat: ({ prompt, model, env }) => ({
+      url: `${base(env)}/chat/completions`,
+      init: {
+        method: 'POST',
+        headers: { ...JSON_HEADERS, ...auth(env) },
+        body: JSON.stringify({ model, messages: [{ role: 'user', content: prompt }] }),
+      },
+    }),
+    readChat: (body) => body?.choices?.[0]?.message?.content ?? '',
+    catalog: ({ env }) => ({ url: `${base(env)}/models`, init: { headers: auth(env) } }),
+    readCatalog: (body) => (body?.data ?? []).map((item) => item?.id).filter(Boolean),
+  };
+}
+
+export const PROVIDERS = [
+  {
+    id: 'codex',
+    label: 'Codex CLI',
+    kind: 'cli',
+    docs: 'https://developers.openai.com/codex/cli',
+    command: 'codex',
+    // `--sandbox read-only` because a second opinion never needs to write, and
+    // `--skip-git-repo-check` because the call runs in a temporary directory, not a repository.
+    // Verified against `codex exec --help` (codex-cli 0.155.1); the prompt is an argument.
+    argv: ({ prompt }) => ['exec', '--sandbox', 'read-only', '--skip-git-repo-check', prompt],
+    stdin: () => undefined,
+    version: ['--version'],
+  },
+  {
+    id: 'gemini-cli',
+    label: 'Gemini CLI',
+    kind: 'cli',
+    docs: 'https://github.com/google-gemini/gemini-cli',
+    command: 'gemini',
+    // `-p ""` plus the briefing on stdin, as `--prompt` is appended to stdin input, and
+    // `--approval-mode plan`, the read-only mode (`gemini --help`, gemini-cli 0.34.0).
+    argv: () => ['-p', '', '-o', 'text', '--approval-mode', 'plan'],
+    stdin: ({ prompt }) => prompt,
+    version: ['--version'],
+  },
+  openAiCompatible({
+    id: 'openai',
+    label: 'OpenAI',
+    docs: 'https://platform.openai.com/docs/api-reference',
+    keys: ['OPENAI_API_KEY'],
+    modelEnv: 'OPENAI_MODEL',
+    baseEnv: 'OPENAI_BASE_URL',
+    defaultBase: 'https://api.openai.com/v1',
+  }),
+  openAiCompatible({
+    id: 'openrouter',
+    label: 'OpenRouter',
+    docs: 'https://openrouter.ai/docs',
+    keys: ['OPENROUTER_API_KEY'],
+    modelEnv: 'OPENROUTER_MODEL',
+    baseEnv: 'OPENROUTER_BASE_URL',
+    defaultBase: 'https://openrouter.ai/api/v1',
+    headers: { 'x-title': 'reis-mobile' },
+  }),
+  {
+    id: 'gemini',
+    label: 'Gemini API',
+    kind: 'http',
+    docs: 'https://ai.google.dev/gemini-api/docs',
+    keys: ['GEMINI_API_KEY', 'GOOGLE_API_KEY'],
+    modelEnv: 'GEMINI_MODEL',
+    needsModel: true,
+    base: geminiBase,
+    chat: ({ prompt, model, env }) => ({
+      url: `${geminiBase(env)}/models/${encodeURIComponent(model)}:generateContent`,
+      init: {
+        method: 'POST',
+        headers: { ...JSON_HEADERS, 'x-goog-api-key': credential(env, ['GEMINI_API_KEY', 'GOOGLE_API_KEY']) },
+        body: JSON.stringify({ contents: [{ role: 'user', parts: [{ text: prompt }] }] }),
+      },
+    }),
+    readChat: (body) =>
+      (body?.candidates?.[0]?.content?.parts ?? [])
+        .map((part) => part?.text)
+        .filter(Boolean)
+        .join(''),
+    catalog: ({ env }) => ({
+      url: `${geminiBase(env)}/models`,
+      init: { headers: { 'x-goog-api-key': credential(env, ['GEMINI_API_KEY', 'GOOGLE_API_KEY']) } },
+    }),
+    readCatalog: (body) => (body?.models ?? []).map((item) => String(item?.name ?? '').replace(/^models\//, '')).filter(Boolean),
+  },
+  {
+    id: 'ollama',
+    label: 'Ollama',
+    kind: 'http',
+    docs: 'https://github.com/ollama/ollama/blob/main/docs/api.md',
+    // No credential: a local server is either running or it is not, and only a request tells.
+    keys: [],
+    local: true,
+    modelEnv: 'OLLAMA_MODEL',
+    needsModel: true,
+    base: ollamaBase,
+    chat: ({ prompt, model, env }) => ({
+      url: `${ollamaBase(env)}/api/chat`,
+      init: {
+        method: 'POST',
+        headers: JSON_HEADERS,
+        body: JSON.stringify({ model, messages: [{ role: 'user', content: prompt }], stream: false }),
+      },
+    }),
+    readChat: (body) => body?.message?.content ?? '',
+    catalog: ({ env }) => ({ url: `${ollamaBase(env)}/api/tags`, init: {} }),
+    readCatalog: (body) => (body?.models ?? []).map((item) => item?.name).filter(Boolean),
+  },
+];
+
+export const PROVIDER_IDS = PROVIDERS.map((provider) => provider.id);
+
+export function findProvider(id) {
+  return PROVIDERS.find((provider) => provider.id === id) ?? null;
+}
+
+export function unknownProviderMessage(id) {
+  return `Unknown provider "${id}". Use one of: ${PROVIDER_IDS.join(', ')}`;
+}
+
+/** The endpoint a provider is reached at, so `providers` can show where a call would go. */
+export function providerEndpoint(provider, env = process.env) {
+  return provider.kind === 'cli' ? provider.command : provider.base(env);
+}
+
+function geminiBase(env) {
+  return trimTrailingSlash(env.GEMINI_BASE_URL || 'https://generativelanguage.googleapis.com/v1beta');
+}
+
+/** `OLLAMA_HOST` is commonly set without a scheme (`127.0.0.1:11434`). */
+function ollamaBase(env) {
+  const host = (env.OLLAMA_HOST || '').trim();
+  if (!host) return 'http://127.0.0.1:11434';
+  return trimTrailingSlash(/^https?:\/\//.test(host) ? host : `http://${host}`);
+}
+
+function credential(env, keys) {
+  for (const key of keys) if (env[key]) return env[key];
+  return '';
+}
+
+function trimTrailingSlash(value) {
+  return String(value).replace(/\/+$/, '');
+}