@orbit-intelligence/orbit-agent 0.3.12 → 0.3.14

package/dist/prompts/system.js

@@ -56,6 +56,11 @@ ${skillsBlock}
 4. Verify. Run the project's checks yourself before claiming success: \`npm test\`, \`node --test dist/tests/*.test.js\`, \`npm run typecheck\`, \`npm run build\` — as applicable. NEVER assume test commands; find them in package.json.
 5. Reflect. After a tool returns, read the result, note in one line what it tells you and what you're doing next, then decide: more work, or final answer. Keep working and iterating until the task is verifiably done — you decide when it is done, not a fixed number of steps. If a step yields unexpected results, adapt and continue.
 
+# Narration order (output protocol)
+- Every message that calls a tool MUST begin with a short narration BEFORE the first tool call, in the same message — one sentence stating what the imminent call will do and why. Never lead a message with a tool call, and never narrate an action in a way that implies you are about to do something you already did.
+- Say the intent, then act. For example: "I'll list the directory to see the layout." then call list_dir. Do not list the directory first and explain afterwards.
+- Batch: when several calls are truly independent, put them in one message instead of one call per round trip. Fewer round trips = faster for the user.
+
 # Tool discipline
 - Explore with glob/grep before reading whole files. Use absolute paths with file tools.
 - run_shell: one focused command per call. Before commands that modify files or system state, give a brief explanation of purpose and impact. Avoid interactive commands that can hang; use non-interactive flags instead.
@@ -65,7 +70,7 @@ ${skillsBlock}
 
 # Output style
 - Be concise and direct. Keep responses short unless the user asks for detail.
-- Show your working across steps: a one-line intent before a tool call and a one-line finding/next step after each tool result. Do not recap the whole session at the end — just give the final answer.
+- Show your working across steps: after a tool result, give a one-line finding/next step. Do not recap the whole session at the end — just give the final answer.
 - Use Markdown for structure. Quote exact paths (path:line) when referring to code.
 - No emojis unless asked. Do not add code explanations unless asked.
 

package/dist/src/cli/run.js

@@ -5,6 +5,7 @@ import { VERSION } from '../version.js';
 import { touchConfig, saveConfig } from '../config/index.js';
 import { EventBus } from '../core/events.js';
 import { buildProviders, resolveCandidates } from '../core/llm/index.js';
+import { resolvePickerRows } from '../tui/picker.js';
 import { AutoRouter } from '../core/llm/router.js';
 import { ContextManager } from '../core/context/context-manager.js';
 import { ToolRegistry } from '../core/tools/registry.js';
@@ -19,7 +20,7 @@ import { createEventLog, appendEvent, readEventLog } from '../session/event-log.
 import { loadProjectContext } from '../core/project-context.js';
 import { createSkillLoaderTool } from '../core/skill-loader.js';
 const THEME_NAMES = ['tokyonight', 'catppuccin-mocha', 'catppuccin-latte', 'nord', 'gruvbox', 'monokai', 'clean-dark'];
-const PROVIDER_IDS = ['orbitx', 'groq', 'gemini', 'openrouter', 'openai'];
+const PROVIDER_IDS = ['orbitx', 'groq', 'gemini', 'openrouter', 'openai', 'anthropic', 'grok', 'deepseek', 'ollama'];
 export async function main(argv) {
     let args;
     try {
@@ -175,6 +176,7 @@ export async function main(argv) {
     const permissions = new PermissionManager(cfg.permissions, {
         ask: (prompt) => app.ask(prompt),
     });
+    let app = null;
     let agent = makeAgent(cfg, router, bus, context, registry, permissions, systemPrompt, cwd);
     function rebuild() {
         return rebuildPipeline(cfg, bus).then((next) => {
@@ -183,6 +185,9 @@ export async function main(argv) {
             agent = makeAgent(cfg, router, bus, context, registry, permissions, systemPrompt, cwd);
             emitRoute(bus, router, cfg);
             saveConfig(cfg);
+            // Keep the TUI's model list + picker rows in sync with the new route.
+            app?.setModels(router.order());
+            void app?.refreshModelPicker();
         });
     }
     const onCommand = async (cmd) => {
@@ -236,18 +241,21 @@ export async function main(argv) {
     bus.on('onError', (err) => {
         appendEvent(session.id, { level: 'error', type: 'error', data: { message: err.message } });
     });
-    const app = new TuiApp({
+    app = new TuiApp({
         config: cfg,
         bus,
         onSubmit: (text) => submitQueued(text),
         onCommand,
         version: VERSION,
         models: router.order(),
+        pickRows: () => resolvePickerRows(),
     });
     app.store.skills = project.skills.map((s) => ({ name: s.name, summary: s.summary }));
     const resumeMessages = session.messages.filter((m) => m.role !== 'tool');
     if (resumeMessages.length > 0)
         app.store.messages = resumeMessages;
+    // Warm the grouped overlay rows once at startup so /model opens instantly.
+    void app.refreshModelPicker();
     function makeAgent(config, r, evBus, ctx, reg, perms, sys, wd) {
         return new Orchestrator({
             bus: evBus,

package/dist/src/config/config-schema.js

@@ -4,7 +4,17 @@ import { z } from 'zod';
  * Provider keys are NEVER stored here — they live in env vars or the
  * git-ignored keys.json (0600 perms). Read via core/llm/secrets.ts.
  */
-export const providerNames = ['orbitx', 'groq', 'gemini', 'openrouter', 'openai'];
+export const providerNames = [
+    'orbitx',
+    'groq',
+    'gemini',
+    'openrouter',
+    'openai',
+    'anthropic',
+    'grok',
+    'deepseek',
+    'ollama',
+];
 export const effortLevels = ['none', 'minimal', 'low', 'medium', 'high'];
 export const reasoningDefault = { enabled: true, effort: 'medium' };
 export const routerStrategies = ['auto', 'failover', 'round-robin', 'pinned'];

package/dist/src/core/agent/agent-loop.js

@@ -149,6 +149,11 @@ export class AgentLoop {
                     return { turns: this.turnCount, error: err?.message ?? String(err) };
                 }
             }
+            // The narration is fully streamed and tools haven't executed yet. Let the
+            // TUI reveal the whole message (snap the typewriter to the end) so the
+            // text sits above the tool rows BEFORE the tools start running — the
+            // user should see "intent first, then action".
+            bus.emit('onAssistantGenerationDone', asstMsg);
             asstMsg.streaming = false;
             asstMsg.reasoningOpen = (asstMsg.reasoning?.length ?? 0) > 0;
             asstMsg.toolCalls = toolCalls;

package/dist/src/core/llm/http.js

@@ -155,6 +155,19 @@ function jsonSafe(s) {
     }
 }
 function appendReasoning(body, model, reasoning, style) {
+    if (style === 'deepseek') {
+        // DeepSeek: `thinking:{type}` toggles the chain-of-thought stream;
+        // `reasoning_effort` (low/high/max) controls reasoning depth in newer
+        // v4 models. Our minimal/low → low, medium → high, high → high.
+        if (reasoning.enabled === false) {
+            body.thinking = { type: 'disabled' };
+            return;
+        }
+        body.thinking = { type: 'enabled' };
+        const effort = reasoning.effort ?? 'medium';
+        body.reasoning_effort = effort === 'high' ? 'high' : effort === 'minimal' || effort === 'low' ? 'low' : 'high';
+        return;
+    }
     if (style === 'effort') {
         // Groq: top-level `reasoning_effort`. `none` is valid for qwen3 family.
         const effort = reasoning.enabled === false ? 'none' : (reasoning.effort ?? 'medium');

package/dist/src/core/llm/index.js

@@ -1,11 +1,21 @@
 import { getProviderSecrets } from './secrets.js';
 import { createOpenAiProvider } from './providers/openai-compat.js';
 import { createGeminiProvider } from './providers/gemini.js';
+import { createAnthropicProvider } from './providers/anthropic.js';
+import { createOllamaProvider } from './providers/ollama.js';
 import { PROVIDER_CATALOGS, ORBITX_SERVE, modelsOf } from './models.js';
 export { PROVIDER_CATALOGS as PROVIDER_SPECS, ORBITX_SERVE, modelsOf };
 const ENDPOINTS = {
     groq: 'https://api.groq.com/openai/v1',
     openrouter: 'https://openrouter.ai/api/v1',
+    openai: 'https://api.openai.com/v1',
+    grok: 'https://api.x.ai/v1',
+    deepseek: 'https://api.deepseek.com',
+};
+const REASONING_STYLES = {
+    groq: 'effort',
+    grok: 'effort',
+    deepseek: 'deepseek',
 };
 /**
  * Build providers available in the current environment.
@@ -42,13 +52,19 @@ export function buildProviders(config) {
             baseUrl,
             apiKey: sec.keys[0],
             models: spec ? modelsOf(spec) : [],
-            reasoningStyle: id === 'groq' ? 'effort' : 'object',
+            reasoningStyle: REASONING_STYLES[id] ?? 'object',
         });
     }
     const geminiSec = getProviderSecrets('gemini');
     if (geminiSec && geminiSec.keys[0]) {
         providers.gemini = createGeminiProvider(geminiSec.keys[0]);
     }
+    const anthropicSec = getProviderSecrets('anthropic');
+    if (anthropicSec && anthropicSec.keys[0]) {
+        providers.anthropic = createAnthropicProvider(anthropicSec.keys[0]);
+    }
+    // Local Ollama is always offered: no key required, auto-detects the server.
+    providers.ollama = createOllamaProvider();
     return providers;
 }
 /** Candidate model ids (provider-prefixed) for the router. */
@@ -89,5 +105,11 @@ export async function resolveCandidates(config, providers) {
                 push(m);
         }
     }
+    // Always surface local Ollama models so /model can switch to them from any
+    // provider. listModels() returns [] fast when the server is unreachable.
+    if (providers.ollama) {
+        for (const m of await providers.ollama.listModels())
+            push(m);
+    }
     return candidates;
 }

package/dist/src/core/llm/models.js

@@ -6,32 +6,38 @@ export const GROQ_CATALOG = [
     {
         id: 'openai/gpt-oss-120b',
         label: 'OpenAI GPT-OSS 120B',
-        reasoning: r('effort', ['low', 'medium', 'high'], 'medium'),
+        reasoning: r('effort', ['minimal', 'low', 'medium', 'high'], 'medium'),
     },
     {
         id: 'openai/gpt-oss-20b',
         label: 'OpenAI GPT-OSS 20B',
-        reasoning: r('effort', ['low', 'medium', 'high'], 'medium'),
+        reasoning: r('effort', ['minimal', 'low', 'medium', 'high'], 'medium'),
     },
     {
-        id: 'qwen/qwen3-32b',
-        label: 'Qwen3 32B',
+        id: 'openai/gpt-oss-safeguard-20b',
+        label: 'OpenAI GPT-OSS Safeguard 20B',
+        reasoning: r('effort', ['minimal', 'low', 'medium', 'high'], 'medium'),
+    },
+    {
+        id: 'qwen/qwen3.8-27b',
+        label: 'Qwen3.8 27B',
         reasoning: r('effort', ['none', 'low', 'medium', 'high'], 'none', {
             paramValue: { none: 'none', low: 'default', medium: 'default', high: 'default' },
         }),
     },
     {
-        id: 'qwen/qwen3.6-27b',
-        label: 'Qwen3.6 27B',
+        id: 'qwen/qwen3-32b',
+        label: 'Qwen3 32B',
         reasoning: r('effort', ['none', 'low', 'medium', 'high'], 'none', {
             paramValue: { none: 'none', low: 'default', medium: 'default', high: 'default' },
         }),
     },
-    { id: 'meta-llama/llama-4-maverick-17b-128e-instruct', label: 'Llama 4 Maverick 17B' },
+    { id: 'minimaxai/minimax-m2.7', label: 'MiniMax M2.7' },
     { id: 'meta-llama/llama-4-scout-17b-16e-instruct', label: 'Llama 4 Scout 17B' },
-    { id: 'meta-llama/llama-3.3-70b-versatile', label: 'Llama 3.3 70B' },
-    { id: 'meta-llama/llama-3.1-8b-instant', label: 'Llama 3.1 8B' },
-    { id: 'moonshotai/kimi-k2-instruct-0905', label: 'Kimi K2 Instruct' },
+    { id: 'meta-llama/llama-3.3-70b-versatile', label: 'Llama 3.3 70B Versatile' },
+    { id: 'meta-llama/llama-3.1-8b-instant', label: 'Llama 3.1 8B Instant' },
+    { id: 'groq/compound', label: 'Groq Compound (router)' },
+    { id: 'groq/compound-mini', label: 'Groq Compound Mini (router)' },
 ];
 export const GEMINI_CATALOG = [
     {
@@ -55,14 +61,14 @@ export const GEMINI_CATALOG = [
         reasoning: r('level', ['minimal', 'low', 'medium', 'high'], 'medium'),
     },
     {
-        id: 'gemini-3.1-flash-lite',
-        label: 'Gemini 3.1 Flash-Lite',
+        id: 'gemini-3.5-flash-lite',
+        label: 'Gemini 3.5 Flash-Lite',
         reasoning: r('level', ['minimal', 'low', 'medium', 'high'], 'minimal'),
     },
     {
-        id: 'gemini-3-pro-preview',
-        label: 'Gemini 3 Pro',
-        reasoning: r('level', ['low', 'high'], 'high'),
+        id: 'gemini-3.1-flash-lite',
+        label: 'Gemini 3.1 Flash-Lite',
+        reasoning: r('level', ['minimal', 'low', 'medium', 'high'], 'minimal'),
     },
     {
         id: 'gemini-3.1-pro-preview',
@@ -96,90 +102,196 @@ export const OPENROUTER_CATALOG = [
     {
         id: 'anthropic/claude-opus-4.8',
         label: 'Claude Opus 4.8',
-        reasoning: r('none', ['low', 'medium', 'high'], 'medium', { switchable: false }),
+        reasoning: r('effort', ['low', 'medium', 'high'], 'medium'),
     },
-    { id: 'anthropic/claude-sonnet-4.7', label: 'Claude Sonnet 4.7' },
-    { id: 'anthropic/claude-haiku-4.5', label: 'Claude Haiku 4.5' },
     {
-        id: 'openai/o3',
-        label: 'OpenAI o3',
+        id: 'anthropic/claude-sonnet-5',
+        label: 'Claude Sonnet 5',
         reasoning: r('effort', ['low', 'medium', 'high'], 'medium'),
     },
     {
-        id: 'openai/o4-mini',
-        label: 'OpenAI o4-mini',
+        id: 'anthropic/claude-sonnet-4.6',
+        label: 'Claude Sonnet 4.6',
+        reasoning: r('effort', ['low', 'medium', 'high'], 'medium'),
+    },
+    {
+        id: 'anthropic/claude-opus-5',
+        label: 'Claude Opus 5',
+        reasoning: r('effort', ['low', 'medium', 'high'], 'high'),
+    },
+    { id: 'anthropic/claude-haiku-4.5', label: 'Claude Haiku 4.5' },
+    {
+        id: 'openai/gpt-5.5',
+        label: 'GPT-5.5',
         reasoning: r('effort', ['low', 'medium', 'high'], 'medium'),
     },
     {
         id: 'openai/gpt-oss-120b',
         label: 'OpenAI GPT-OSS 120B',
-        reasoning: r('effort', ['low', 'medium', 'high'], 'medium'),
+        reasoning: r('effort', ['minimal', 'low', 'medium', 'high'], 'medium'),
     },
     {
         id: 'openai/gpt-oss-20b',
         label: 'OpenAI GPT-OSS 20B',
-        reasoning: r('effort', ['low', 'medium', 'high'], 'medium'),
+        reasoning: r('effort', ['minimal', 'low', 'medium', 'high'], 'medium'),
     },
     { id: 'google/gemini-3.5-flash', label: 'Gemini 3.5 Flash' },
-    { id: 'google/gemini-3-pro-preview', label: 'Gemini 3 Pro' },
-    { id: 'google/gemini-2.5-pro', label: 'Gemini 2.5 Pro' },
+    { id: 'google/gemini-3-flash-preview', label: 'Gemini 3 Flash (preview)' },
+    { id: 'google/gemini-3.1-flash-lite', label: 'Gemini 3.1 Flash-Lite' },
+    { id: 'google/gemini-2.5-flash', label: 'Gemini 2.5 Flash' },
+    { id: 'google/gemini-2.5-flash-lite', label: 'Gemini 2.5 Flash-Lite' },
+    { id: 'google/gemini-3.1-pro-preview', label: 'Gemini 3.1 Pro' },
     {
         id: 'deepseek/deepseek-v4-pro',
         label: 'DeepSeek V4 Pro',
         reasoning: r('effort', ['low', 'medium', 'high'], 'medium'),
     },
-    { id: 'deepseek/deepseek-v4-flash', label: 'DeepSeek V4 Flash' },
     {
-        id: 'deepseek/deepseek-r1',
-        label: 'DeepSeek R1',
-        reasoning: r('effort', ['low', 'medium', 'high'], 'high'),
+        id: 'deepseek/deepseek-v4-flash',
+        label: 'DeepSeek V4 Flash',
+        reasoning: r('effort', ['low', 'medium', 'high'], 'medium'),
     },
     {
-        id: 'qwen/qwen3.7-max',
-        label: 'Qwen3.7 Max',
-        reasoning: r('effort', ['low', 'medium', 'high'], 'medium'),
+        id: 'x-ai/grok-4.3',
+        label: 'Grok 4.3',
+        reasoning: r('effort', ['none', 'low', 'medium', 'high'], 'none'),
+    },
+    {
+        id: 'x-ai/grok-4.6',
+        label: 'Grok 4.6',
+        reasoning: r('effort', ['low', 'medium', 'high'], 'high'),
     },
     {
-        id: 'x-ai/grok-build-0.1',
-        label: 'Grok Build 0.1',
+        id: 'minimax/minimax-m3',
+        label: 'MiniMax M3',
         reasoning: r('effort', ['low', 'medium', 'high'], 'medium'),
     },
-    { id: 'x-ai/grok-4.3', label: 'Grok 4.3' },
-    { id: 'minimax/minimax-m3', label: 'MiniMax M3' },
+    { id: 'moonshotai/kimi-k3', label: 'Kimi K3' },
     { id: 'nvidia/nemotron-3-ultra', label: 'NVIDIA Nemotron 3 Ultra' },
-    { id: 'moonshotai/kimi-k2.7-code', label: 'Kimi K2.7 Code' },
-    { id: 'mistralai/mistral-medium-3-5', label: 'Mistral Medium 3.5' },
-    // Free (`:free` tiers)
-    { id: 'openrouter/free', label: 'Auto — free router', free: true },
     {
-        id: 'thinkingmachines/inkling:free',
-        label: 'Inkling (free)',
-        free: true,
+        id: 'z-ai/glm-5.2',
+        label: 'GLM 5.2',
         reasoning: r('effort', ['low', 'medium', 'high'], 'medium'),
     },
+    { id: 'tencent/hy3', label: 'Tencent Hunyuan 3' },
+    { id: 'stepfun/step-3.7-flash', label: 'Step 3.7 Flash' },
+    { id: 'xiaomi/mimo-v2.5', label: 'Xiaomi MiMo V2.5' },
+    // Free (`:free` tiers)
     {
-        id: 'thinkingmachines/inkling-small:free',
-        label: 'Inkling Small (free)',
+        id: 'openai/gpt-oss-120b:free',
+        label: 'GPT-OSS 120B (free)',
         free: true,
-        reasoning: r('effort', ['low', 'medium', 'high'], 'medium'),
+        reasoning: r('effort', ['minimal', 'low', 'medium', 'high'], 'medium'),
     },
-    { id: 'minimax/minimax-m3:free', label: 'MiniMax M3 (free)', free: true },
     {
-        id: 'deepseek/deepseek-r1:free',
-        label: 'DeepSeek R1 (free)',
+        id: 'openai/gpt-oss-20b:free',
+        label: 'GPT-OSS 20B (free)',
         free: true,
-        reasoning: r('effort', ['low', 'medium', 'high'], 'high'),
+        reasoning: r('effort', ['minimal', 'low', 'medium', 'high'], 'medium'),
     },
-    { id: 'openai/gpt-oss-120b:free', label: 'GPT-OSS 120B (free)', free: true },
-    { id: 'openai/gpt-oss-20b:free', label: 'GPT-OSS 20B (free)', free: true },
-    { id: 'nvidia/nemotron-3-ultra:free', label: 'Nemotron 3 Ultra (free)', free: true },
-    { id: 'nvidia/nemotron-3-super:free', label: 'Nemotron 3 Super (free)', free: true },
-    { id: 'nvidia/nemotron-3.5-lightning:free', label: 'Nemotron 3.5 Light (free)', free: true },
     { id: 'google/gemma-4-31b:free', label: 'Gemma 4 31B (free)', free: true },
-    { id: 'google/gemma-4-26b-a4b:free', label: 'Gemma 4 26B (free)', free: true },
-    { id: 'cohere/north-mini-code:free', label: 'North Mini Code (free)', free: true },
     { id: 'meta-llama/llama-3.3-70b-instruct:free', label: 'Llama 3.3 70B (free)', free: true },
     { id: 'meta-llama/llama-3.1-8b-instruct:free', label: 'Llama 3.1 8B (free)', free: true },
+    { id: 'minimax/minimax-m3:free', label: 'MiniMax M3 (free)', free: true },
+    { id: 'nvidia/nemotron-3-ultra:free', label: 'Nemotron 3 Ultra (free)', free: true },
+];
+export const ANTHROPIC_CATALOG = [
+    {
+        id: 'claude-fable-5-1',
+        label: 'Claude Fable 5.1',
+        reasoning: r('budget', ['low', 'medium', 'high'], 'high', { switchable: false }),
+    },
+    {
+        id: 'claude-opus-5',
+        label: 'Claude Opus 5',
+        reasoning: r('budget', ['low', 'medium', 'high'], 'high', { switchable: false }),
+    },
+    {
+        id: 'claude-sonnet-5',
+        label: 'Claude Sonnet 5',
+        reasoning: r('budget', ['low', 'medium', 'high'], 'medium', { switchable: false }),
+    },
+    {
+        id: 'claude-haiku-4-5',
+        label: 'Claude Haiku 4.5',
+        reasoning: r('budget', ['low', 'medium', 'high'], 'low', { switchable: true }),
+    },
+    {
+        id: 'claude-sonnet-4-6',
+        label: 'Claude Sonnet 4.6 (legacy)',
+        reasoning: r('budget', ['low', 'medium', 'high'], 'medium', { switchable: true }),
+    },
+    {
+        id: 'claude-opus-4-8',
+        label: 'Claude Opus 4.8 (legacy)',
+        reasoning: r('budget', ['low', 'medium', 'high'], 'medium', { switchable: true }),
+    },
+];
+export const GROK_CATALOG = [
+    {
+        id: 'grok-4.6',
+        label: 'Grok 4.6',
+        reasoning: r('effort', ['low', 'medium', 'high'], 'high'),
+    },
+    {
+        id: 'grok-4.5',
+        label: 'Grok 4.5',
+        reasoning: r('effort', ['low', 'medium', 'high'], 'medium'),
+    },
+    {
+        id: 'grok-4.3',
+        label: 'Grok 4.3',
+        reasoning: r('effort', ['none', 'low', 'medium', 'high'], 'none'),
+    },
+    {
+        id: 'grok-4.20-reasoning',
+        label: 'Grok 4.20 Reasoning',
+        reasoning: r('effort', ['low', 'medium', 'high'], 'high'),
+    },
+    { id: 'grok-4.20-non-reasoning', label: 'Grok 4.20 (non-reasoning)' },
+    { id: 'grok-3-mini', label: 'Grok 3 Mini' },
+];
+export const DEEPSEEK_CATALOG = [
+    {
+        id: 'deepseek-v4-pro',
+        label: 'DeepSeek V4 Pro (0813)',
+        reasoning: r('deepseek', ['low', 'medium', 'high'], 'medium'),
+    },
+    {
+        id: 'deepseek-flash',
+        label: 'DeepSeek V4 Flash (0731)',
+        reasoning: r('deepseek', ['low', 'medium', 'high'], 'low'),
+    },
+    {
+        id: 'deepseek-v4-flash-vision-exp',
+        label: 'DeepSeek V4 Flash Vision (exp)',
+        reasoning: r('deepseek', ['low', 'medium', 'high'], 'low'),
+    },
+];
+export const OPENAI_CATALOG = [
+    {
+        id: 'gpt-5.6',
+        label: 'GPT-5.6',
+        reasoning: r('effort', ['low', 'medium', 'high'], 'medium'),
+    },
+    {
+        id: 'gpt-5.5',
+        label: 'GPT-5.5',
+        reasoning: r('effort', ['low', 'medium', 'high'], 'medium'),
+    },
+    { id: 'gpt-4o', label: 'GPT-4o (legacy)' },
+];
+export const OLLAMA_CATALOG = [
+    { id: 'llama3.2', label: 'Llama 3.2' },
+    { id: 'llama3.1', label: 'Llama 3.1' },
+    { id: 'qwen3', label: 'Qwen3' },
+    { id: 'qwen3:32b', label: 'Qwen3 32B' },
+    { id: 'qwen3-vl:8b', label: 'Qwen3 VL 8B' },
+    { id: 'gemma4', label: 'Gemma 4' },
+    { id: 'gemma3', label: 'Gemma 3' },
+    { id: 'mistral', label: 'Mistral' },
+    { id: 'gpt-oss:20b', label: 'GPT-OSS 20B' },
+    { id: 'deepseek-r1', label: 'DeepSeek R1' },
 ];
 export const ORBITX_CATALOG = [
     { id: 'auto', label: 'auto (backend routes across providers)' },
@@ -210,6 +322,11 @@ export const PROVIDER_CATALOGS = [
     { id: 'groq', label: 'Groq', requiresSecret: true, supportsCustom: false, models: GROQ_CATALOG },
     { id: 'gemini', label: 'Google Gemini', requiresSecret: true, supportsCustom: false, models: GEMINI_CATALOG },
     { id: 'openrouter', label: 'OpenRouter', requiresSecret: true, supportsCustom: true, models: OPENROUTER_CATALOG },
+    { id: 'openai', label: 'OpenAI', requiresSecret: true, supportsCustom: true, models: OPENAI_CATALOG },
+    { id: 'anthropic', label: 'Anthropic', requiresSecret: true, supportsCustom: false, models: ANTHROPIC_CATALOG },
+    { id: 'grok', label: 'xAI Grok', requiresSecret: true, supportsCustom: false, models: GROK_CATALOG },
+    { id: 'deepseek', label: 'DeepSeek', requiresSecret: true, supportsCustom: false, models: DEEPSEEK_CATALOG },
+    { id: 'ollama', label: 'Ollama (local)', requiresSecret: false, supportsCustom: true, models: OLLAMA_CATALOG },
 ];
 /** Find a model entry by bare id across every provider catalog. */
 export function findModel(provider, modelBare) {

package/dist/src/core/llm/providers/anthropic.js

@@ -0,0 +1,237 @@
+import { ANTHROPIC_CATALOG } from '../models.js';
+/**
+ * Anthropic native streaming provider (Messages API).
+ * HTTP: POST https://api.anthropic.com/v1/messages with `x-api-key` +
+ * `anthropic-version` headers, SSE stream.
+ *
+ * Event mapping:
+ *   text block          → token
+ *   thinking block      → reasoning
+ *   tool_use block      → tool_call_start / tool_call_args / tool_call_end
+ */
+const ANTHROPIC_ENDPOINT = 'https://api.anthropic.com/v1/messages';
+const ANTHROPIC_VERSION = '2023-06-01';
+const DEFAULT_MAX_TOKENS = 8192;
+const THINKING_BUDGET = { low: 2048, medium: 8192, high: 32768 };
+const ANTHROPIC_MODELS = ANTHROPIC_CATALOG.map((m) => m.id);
+export function createAnthropicProvider(apiKey) {
+    return {
+        id: 'anthropic',
+        modelCount: ANTHROPIC_MODELS.length,
+        listModels() {
+            return ANTHROPIC_MODELS.map((m) => `anthropic/${m}`);
+        },
+        async *stream(llmOpts) {
+            let model = llmOpts.model;
+            if (model.startsWith('anthropic/'))
+                model = model.slice('anthropic/'.length);
+            if (!model)
+                model = 'claude-sonnet-5';
+            const body = {
+                model,
+                max_tokens: llmOpts.maxTokens ?? DEFAULT_MAX_TOKENS,
+                messages: toAnthropicMessages(llmOpts.messages),
+                stream: true,
+            };
+            const sys = llmOpts.messages.find((m) => m.role === 'system');
+            if (sys?.content)
+                body.system = sys.content;
+            if (llmOpts.tools?.length)
+                body.tools = llmOpts.tools.map(toAnthropicTool);
+            if (llmOpts.temperature != null)
+                body.temperature = llmOpts.temperature;
+            const thinking = anthropicThinkingConfig(llmOpts.reasoning);
+            if (thinking)
+                body.thinking = thinking;
+            const res = await fetch(ANTHROPIC_ENDPOINT, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-api-key': apiKey,
+                    'anthropic-version': ANTHROPIC_VERSION,
+                },
+                body: JSON.stringify(body),
+                signal: llmOpts.signal,
+            });
+            if (!res.ok) {
+                const text = await res.text().catch(() => 'unknown');
+                throw new Error(`Anthropic HTTP ${res.status}: ${text.slice(0, 300)}`);
+            }
+            const reader = res.body?.getReader();
+            if (!reader)
+                throw new Error('No readable body from Anthropic');
+            const usage = { input: 0, output: 0 };
+            const blocks = new Map();
+            let sentDone = false;
+            const decoder = new TextDecoder();
+            let buffer = '';
+            let eventType = '';
+            try {
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    buffer += decoder.decode(value, { stream: true });
+                    while (true) {
+                        const nl = buffer.indexOf('\n');
+                        if (nl === -1)
+                            break;
+                        const line = buffer.slice(0, nl);
+                        buffer = buffer.slice(nl + 1);
+                        if (line.startsWith('event:')) {
+                            eventType = line.slice(6).trim();
+                            continue;
+                        }
+                        if (!line.startsWith('data:'))
+                            continue;
+                        const data = line.slice(5).trim();
+                        if (!data)
+                            continue;
+                        const parsed = jsonSafe(data);
+                        if (!parsed)
+                            continue;
+                        for (const ev of handleAnthropicEvent(parsed, eventType, blocks, usage)) {
+                            yield ev;
+                            if (ev.type === 'done')
+                                sentDone = true;
+                        }
+                    }
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+            if (!sentDone)
+                yield { type: 'done', usage: { inputTokens: usage.input, outputTokens: usage.output } };
+        },
+    };
+}
+function toAnthropicMessages(messages) {
+    const out = [];
+    for (const m of messages) {
+        if (m.role === 'system')
+            continue;
+        if (m.role === 'assistant') {
+            const blocks = [];
+            if (m.content)
+                blocks.push({ type: 'text', text: m.content });
+            for (const tc of m.toolCalls ?? []) {
+                blocks.push({ type: 'tool_use', id: tc.id, name: tc.name, input: safeJson(tc.args) });
+            }
+            out.push({ role: 'assistant', content: blocks });
+            continue;
+        }
+        if (m.toolResults && m.toolResults.length > 0) {
+            const blocks = [];
+            for (const r of m.toolResults) {
+                blocks.push({ type: 'tool_result', tool_use_id: r.toolCallId, content: r.content });
+            }
+            out.push({ role: 'user', content: blocks });
+            continue;
+        }
+        out.push({ role: 'user', content: m.content });
+    }
+    return out;
+}
+function toAnthropicTool(t) {
+    return {
+        name: t.function.name,
+        description: t.function.description,
+        input_schema: t.function.parameters ?? { type: 'object', properties: {} },
+    };
+}
+function anthropicThinkingConfig(reasoning) {
+    if (!reasoning)
+        return undefined;
+    const effort = reasoning.effort ?? 'medium';
+    if (reasoning.enabled === false || effort === 'none')
+        return { type: 'disabled' };
+    return { type: 'enabled', budget_tokens: THINKING_BUDGET[effort] ?? THINKING_BUDGET['medium'] };
+}
+/**
+ * Handle a single Anthropic SSE data payload, mutating block/usage state and
+ * returning the StreamEvents to surface. Empty for non-generating events.
+ */
+function* handleAnthropicEvent(parsed, _eventType, blocks, usage) {
+    const evt = parsed.type;
+    if (evt === 'message_start') {
+        const msg = parsed.message;
+        usage.input = msg?.usage?.input_tokens ?? 0;
+        usage.output = msg?.usage?.output_tokens ?? 0;
+        return;
+    }
+    if (evt === 'content_block_start') {
+        const index = parsed.index ?? 0;
+        const block = parsed.content_block;
+        const type = block?.type;
+        if (type === 'tool_use') {
+            const id = block?.id ?? `claude_${Date.now()}_${block?.name ?? 'tool'}`;
+            blocks.set(index, { kind: 'tool_use', id, name: block?.name ?? '', args: '' });
+            yield { type: 'tool_call_start', id, name: block?.name ?? '' };
+        }
+        else if (type === 'text' || type === 'thinking') {
+            blocks.set(index, { kind: type, id: '', name: '', args: '' });
+        }
+        return;
+    }
+    if (evt === 'content_block_delta') {
+        const index = parsed.index ?? 0;
+        const delta = parsed.delta;
+        const dtype = delta?.type;
+        if (dtype === 'text_delta' && typeof delta?.text === 'string') {
+            yield { type: 'token', text: delta.text };
+        }
+        else if (dtype === 'thinking_delta' && typeof delta?.thinking === 'string') {
+            yield { type: 'reasoning', text: delta.thinking };
+        }
+        else if (dtype === 'input_json_delta' && typeof delta?.partial_json === 'string') {
+            const block = blocks.get(index);
+            if (block && block.kind === 'tool_use') {
+                block.args += delta.partial_json;
+                if (block.id)
+                    yield { type: 'tool_call_args', id: block.id, args: delta.partial_json };
+            }
+        }
+        return;
+    }
+    if (evt === 'content_block_stop') {
+        const index = parsed.index ?? 0;
+        const block = blocks.get(index);
+        if (block && block.kind === 'tool_use') {
+            yield { type: 'tool_call_end', id: block.id, name: block.name, args: block.args };
+        }
+        blocks.delete(index);
+        return;
+    }
+    if (evt === 'message_delta') {
+        const mdUsage = parsed.usage;
+        if (mdUsage?.output_tokens != null)
+            usage.output = mdUsage.output_tokens;
+        return;
+    }
+    if (evt === 'message_stop') {
+        yield { type: 'done', usage: { inputTokens: usage.input, outputTokens: usage.output } };
+        return;
+    }
+    if (evt === 'error') {
+        const err = parsed.error;
+        throw new Error(`Anthropic: ${err?.message ?? JSON.stringify(parsed.error) ?? 'stream error'}`);
+    }
+}
+function safeJson(s) {
+    try {
+        const v = JSON.parse(s);
+        return v && typeof v === 'object' ? v : {};
+    }
+    catch {
+        return {};
+    }
+}
+function jsonSafe(s) {
+    try {
+        return JSON.parse(s);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/src/core/llm/providers/ollama.js

@@ -0,0 +1,86 @@
+import { streamOpenAi } from '../http.js';
+import { OLLAMA_CATALOG } from '../models.js';
+/**
+ * Ollama (local, OpenAI-compatible) provider.
+ *
+ * No API key: Ollama accepts both a dummy key and an empty Authorization.
+ * Default base http://127.0.0.1:11434 (Android/Termux), overridable via the
+ * OLLAMA_HOST env var. Installed models are discovered by probing
+ * GET /api/tags (async, short-cached, fast-fail when the server is down).
+ */
+export const OLLAMA_DEFAULT_BASE = 'http://127.0.0.1:11434';
+const TAGS_CACHE_MS = 5000;
+const TAGS_TIMEOUT_MS = 4000;
+let tagsCache = null;
+export function ollamaBaseUrl(explicit) {
+    return (explicit?.trim() || process.env.OLLAMA_HOST?.trim() || OLLAMA_DEFAULT_BASE).replace(/\/+$/, '');
+}
+async function probeTags(baseUrl) {
+    const now = Date.now();
+    if (tagsCache && now - tagsCache.at < TAGS_CACHE_MS)
+        return tagsCache.names;
+    try {
+        const ctrl = new AbortController();
+        const timer = setTimeout(() => ctrl.abort(new Error('ollama probe timed out')), TAGS_TIMEOUT_MS);
+        const res = await fetch(`${baseUrl}/api/tags`, { signal: ctrl.signal });
+        clearTimeout(timer);
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status}`);
+        const json = (await res.json());
+        const names = dedupeStable((json.models ?? []).map((m) => m.name).filter(Boolean));
+        tagsCache = { at: Date.now(), names };
+        return names;
+    }
+    catch {
+        tagsCache = { at: Date.now(), names: [] };
+        return [];
+    }
+}
+/** Collapse `foo:latest` → `foo` while preserving distinct non-latest tags. */
+function dedupeStable(list) {
+    const seen = new Set();
+    const out = [];
+    for (const n of list) {
+        const clean = n.endsWith(':latest') ? n.slice(0, n.length - 7) : n;
+        if (!seen.has(clean)) {
+            seen.add(clean);
+            out.push(clean);
+        }
+    }
+    return out;
+}
+export function createOllamaProvider(opts = {}) {
+    const baseUrl = ollamaBaseUrl(opts.baseUrl);
+    const catalog = opts.models && opts.models.length > 0 ? opts.models : OLLAMA_CATALOG.map((m) => m.id);
+    return {
+        id: 'ollama',
+        modelCount: catalog.length,
+        async listModels() {
+            const names = await probeTags(baseUrl);
+            // Empty when the server is unreachable so routing/pickers don't list
+            // phantom models; the static catalog is only a wizard fallback.
+            return names.map((n) => `ollama/${n}`);
+        },
+        async *stream(llmOpts) {
+            let model = llmOpts.model;
+            if (model.startsWith('ollama/'))
+                model = model.slice('ollama/'.length);
+            if (!model)
+                model = catalog[0] ?? 'llama3.2';
+            yield* streamOpenAi({
+                baseUrl: `${baseUrl}/v1`,
+                apiKey: '',
+                model,
+                messages: llmOpts.messages,
+                tools: llmOpts.tools,
+                temperature: llmOpts.temperature,
+                maxTokens: llmOpts.maxTokens,
+                signal: llmOpts.signal,
+                reasoning: llmOpts.reasoning,
+                // Modern Ollama accepts `thinking` + `reasoning_effort` in the OpenAI
+                // endpoint; unknown extra keys are ignored by older builds.
+                reasoningStyle: 'deepseek',
+            });
+        },
+    };
+}

package/dist/src/core/llm/secrets.js

@@ -12,6 +12,10 @@ const ENV_LABELS = {
     groq: ['GROQ_API_KEY'],
     gemini: ['GEMINI_API_KEY'],
     openrouter: ['OPENROUTER_API_KEY'],
+    openai: ['OPENAI_API_KEY'],
+    anthropic: ['ANTHROPIC_API_KEY'],
+    grok: ['XAI_API_KEY', 'GROK_API_KEY'],
+    deepseek: ['DEEPSEEK_API_KEY'],
 };
 // The setup wizard calls providers three times in quick succession; don't
 // re-read + re-parse + re-chmod the keys file on every lookup.
@@ -65,7 +69,13 @@ function fromEnv(provider) {
     return keys;
 }
 export function isImportableDirectly(p) {
-    return p === 'groq' || p === 'gemini' || p === 'openrouter' || p === 'openai';
+    return (p === 'groq' ||
+        p === 'gemini' ||
+        p === 'openrouter' ||
+        p === 'openai' ||
+        p === 'anthropic' ||
+        p === 'grok' ||
+        p === 'deepseek');
 }
 export function getProviderSecrets(provider) {
     const envKeys = fromEnv(provider);
@@ -78,7 +88,7 @@ export function getProviderSecrets(provider) {
     return null;
 }
 export function hasAnySecrets() {
-    for (const p of ['orbitx', 'groq', 'gemini', 'openrouter']) {
+    for (const p of ['orbitx', 'groq', 'gemini', 'openrouter', 'openai', 'anthropic', 'grok', 'deepseek']) {
         if (getProviderSecrets(p))
             return true;
     }
@@ -91,7 +101,7 @@ export function maskSecret(key) {
 }
 export function describeProvidersAvailable() {
     const out = [];
-    for (const p of ['orbitx', 'groq', 'gemini', 'openrouter']) {
+    for (const p of ['orbitx', 'groq', 'gemini', 'openrouter', 'openai', 'anthropic', 'grok', 'deepseek']) {
         const s = getProviderSecrets(p);
         if (s && s.keys[0])
             out.push({ provider: p, masked: maskSecret(s.keys[0]), source: s.source });

package/dist/src/core/orchestration/runtime.js

@@ -10,6 +10,7 @@ const FORWARDED_EVENTS = [
     'onToolStart',
     'onToolUpdate',
     'onToolEnd',
+    'onAssistantGenerationDone',
     'onAssistantEnd',
     'onError',
     'onRoute',

package/dist/src/setup/wizard.js

@@ -252,7 +252,13 @@ function contentLines(state, theme, width) {
             lines.push('');
             PROVIDER_SPECS.forEach((p, i) => {
                 const av = describeProvidersAvailable().some((a) => a.provider === p.id);
-                const flag = p.id === 'orbitx' ? ' free · auto-routes Groq/Gemini/OpenRouter' : av ? ' ✓ available' : ` ${dimSgr}(keys not set)${reset}`;
+                const flag = p.id === 'orbitx'
+                    ? ' free · auto-routes Groq/Gemini/OpenRouter'
+                    : p.id === 'ollama'
+                        ? ' local · auto-detect http://127.0.0.1:11434'
+                        : av
+                            ? ' ✓ available'
+                            : ` ${dimSgr}(keys not set)${reset}`;
                 if (i === state.providerSelected)
                     lines.push(`${accentSgr}▸ ${p.label}${reset}${dimSgr}${flag}${reset}`);
                 else

package/dist/src/tui/InkApp.js

@@ -33,7 +33,7 @@ export function InkApp({ controller }) {
     const theme = store.theme ?? buildTheme('tokyonight');
     const menuing = store.input.currentBuffer().startsWith('/');
     const menuLines = menuing ? store.slashMatches().length + 1 : 0;
-    const modelLines = store.modelPicker.open ? Math.min(store.models.length, 10) + 1 : 0;
+    const modelLines = store.modelPicker.open ? Math.min(store.pickRows.length, 12) + 3 : 0;
     const dockLines = store.dockOpen
         ? store.agents.size === 0
             ? 2
@@ -63,5 +63,5 @@ export function InkApp({ controller }) {
             revealChars: store.revealChars,
         });
     }
-    return (_jsx(StoreContext.Provider, { value: store, children: _jsxs(Box, { width: cols, height: bodyRows, flexDirection: "column", overflow: "hidden", children: [_jsx(Header, { width: cols }), _jsx(Text, { dimColor: true, children: 'Tip: /help for commands · /theme to switch' }), _jsx(Transcript, { rows: msgRows, viewport: viewport }), working && _jsx(WorkingStatus, {}), store.pendingAsk && _jsx(PermissionModal, { cols: cols }), store.dockOpen && _jsx(AgentDock, { width: cols, height: dockLines }), menuing && _jsx(SlashMenu, { width: cols }), store.modelPicker.open && _jsx(ModelPicker, { width: cols }), _jsx(Box, { height: 1, children: _jsx(Text, { dimColor: true, wrap: "truncate-end", children: '─'.repeat(Math.max(1, cols)) }) }), _jsx(Composer, {}), _jsx(StatusLine, { width: cols })] }) }));
+    return (_jsx(StoreContext.Provider, { value: store, children: _jsxs(Box, { width: cols, height: bodyRows, flexDirection: "column", overflow: "hidden", children: [_jsx(Header, { width: cols }), _jsx(Text, { dimColor: true, children: 'Tip: /help for commands · /theme to switch' }), _jsx(Transcript, { rows: msgRows, viewport: viewport }), working && _jsx(WorkingStatus, {}), store.pendingAsk && _jsx(PermissionModal, { cols: cols }), store.dockOpen && _jsx(AgentDock, { width: cols, height: dockLines }), menuing && _jsx(SlashMenu, { width: cols }), store.modelPicker.open && _jsx(ModelPicker, { height: modelLines }), _jsx(Box, { height: 1, children: _jsx(Text, { dimColor: true, wrap: "truncate-end", children: '─'.repeat(Math.max(1, cols)) }) }), _jsx(Composer, {}), _jsx(StatusLine, { width: cols })] }) }));
 }

package/dist/src/tui/app.js

@@ -4,6 +4,7 @@ import { providerNames } from '../config/config-schema.js';
 import { makeTheme, THEME_NAMES } from './themes/index.js';
 import { AppStore, ASK_OPTIONS } from './store.js';
 import { InkApp } from './InkApp.js';
+import { findPickerIndex, isPickerHeader } from './picker.js';
 export class TuiApp {
     store = new AppStore();
     theme;
@@ -13,6 +14,7 @@ export class TuiApp {
     config;
     bus;
     models;
+    pickBuilder = null;
     instance = null;
     done = false;
     /** Last dispatched key (sig + timestamp) for de-duping keyboard repeats. */
@@ -26,6 +28,7 @@ export class TuiApp {
         this.onCommand = opts.onCommand ?? (async () => null);
         this.version = opts.version;
         this.models = opts.models ?? [];
+        this.pickBuilder = opts.pickRows ?? null;
         this.theme = makeTheme(opts.config.theme);
         this.store.version = opts.version;
         this.store.cwd = process.cwd();
@@ -79,6 +82,46 @@ export class TuiApp {
     getMessages() {
         return this.store.messages;
     }
+    /** Push the current routed model list (after rebuild) into the app/UI. */
+    setModels(list) {
+        this.models = [...list];
+        this.store.models = [...list];
+    }
+    /** Rebuild the grouped picker rows (e.g. after a provider/model switch). */
+    async refreshModelPicker() {
+        if (!this.pickBuilder)
+            return;
+        try {
+            const rows = await this.pickBuilder();
+            this.store.pickRows = rows;
+            if (rows.length === 0)
+                this.store.modelPicker.index = 0;
+            else if (this.store.modelPicker.index >= rows.length)
+                this.store.modelPicker.index = rows.length - 1;
+        }
+        catch {
+            this.store.pickRows = [];
+        }
+    }
+    /** Open the /model overlay, refreshing rows first so the list is current. */
+    async openModelPicker() {
+        await this.refreshModelPicker();
+        const store = this.store;
+        if (store.pickRows.length === 0 && store.models.length > 0) {
+            // Fallback when no builder: derive item rows from the routed models.
+            const seen = new Set();
+            for (const m of store.models) {
+                const provider = m.split('/')[0] ?? 'orbitx';
+                if (seen.has(m))
+                    continue;
+                seen.add(m);
+                store.pickRows.push({ kind: 'item', label: m, id: m, provider });
+            }
+        }
+        store.modelPicker.index = findPickerIndex(store.pickRows, store.route?.model, this.config.model.primary);
+        store.modelPicker.open = true;
+        store.refresh();
+    }
     ask(prompt) {
         return new Promise((resolve) => {
             this.store.pendingAsk = { prompt, index: 0, resolve };
@@ -126,6 +169,13 @@ export class TuiApp {
         });
         this.bus.on('onToolUpdate', (call) => this.applyToolState(call));
         this.bus.on('onToolEnd', (call) => this.applyToolState(call));
+        // Narration for this message is fully streamed and tools have not run yet.
+        // Flush the reveal so the text is fully visible above the tool rows before
+        // the tools start — users see the intent, then the action.
+        this.bus.on('onAssistantGenerationDone', () => {
+            this.store.revealAll();
+            this.store.refresh();
+        });
         this.bus.on('onAssistantEnd', (msg) => {
             this.store.streaming = false;
             this.store.cancelArmed = false;
@@ -469,8 +519,8 @@ export class TuiApp {
     }
     handleModelPickerKey(input, key) {
         const store = this.store;
-        const list = store.models;
-        if (list.length === 0) {
+        const rows = store.pickRows;
+        if (rows.length === 0) {
             store.modelPicker.open = false;
             store.refresh();
             return;
@@ -481,26 +531,53 @@ export class TuiApp {
             return;
         }
         if (key.upArrow || (key.tab && key.shift)) {
-            store.modelPicker.index = (store.modelPicker.index - 1 + list.length) % list.length;
+            store.modelPicker.index = this.movePickerIndex(store.modelPicker.index, -1);
             store.refresh();
             return;
         }
         if (key.downArrow || key.tab) {
-            store.modelPicker.index = (store.modelPicker.index + 1) % list.length;
+            store.modelPicker.index = this.movePickerIndex(store.modelPicker.index, 1);
             store.refresh();
             return;
         }
         if (key.return) {
-            const chosen = list[store.modelPicker.index];
+            const row = rows[store.modelPicker.index];
+            if (!row || isPickerHeader(row)) {
+                store.modelPicker.open = false;
+                store.refresh();
+                return;
+            }
             store.modelPicker.open = false;
             store.refresh();
-            if (chosen)
-                void this.switchModel(chosen);
+            void this.selectPickerModel(row);
             return;
         }
         if (input && !key.ctrl && !key.meta)
             store.refresh();
     }
+    /** Step over the row list, skipping non-selectable header rows. */
+    movePickerIndex(index, delta) {
+        const rows = this.store.pickRows;
+        if (rows.length === 0)
+            return 0;
+        let i = index;
+        for (let steps = 0; steps < rows.length; steps++) {
+            i = (i + delta + rows.length) % rows.length;
+            const row = rows[i];
+            if (row && !isPickerHeader(row))
+                return i;
+        }
+        return index;
+    }
+    async selectPickerModel(item) {
+        // Switching provider first lets the same Enter pick a model from a
+        // provider that isn't active (e.g. gemini model while on openrouter).
+        const currentProvider = this.store.route?.provider;
+        if (item.provider !== currentProvider) {
+            await this.switchProvider(item.provider);
+        }
+        await this.switchModel(item.id);
+    }
     handleTabAutocomplete() {
         const buf = this.store.input.currentBuffer();
         const token = buf.split(/\s+/)[0] ?? '';
@@ -571,7 +648,7 @@ export class TuiApp {
                         `/clear           clear the conversation`,
                         `/help            show this help`,
                         `/model [id]      pick a model (bare: interactive selector)`,
-                        `/provider <id>   switch provider (orbitx · groq · gemini · openrouter)`,
+                        `/provider <id>   switch provider (orbitx · groq · gemini · openrouter · openai · anthropic · grok · deepseek · ollama)`,
                         `/plan <task>     plan first: propose a plan, approve with /run`,
                         `/run             execute the proposed plan`,
                         `/reject          discard the proposed plan`,
@@ -663,9 +740,7 @@ export class TuiApp {
             }
             case 'model':
                 if (!arg) {
-                    this.store.modelPicker.open = true;
-                    this.store.modelPicker.index = Math.max(0, this.models.findIndex((m) => m === this.store.route?.model || m.endsWith(`/${this.config.model.primary}`)));
-                    this.store.refresh();
+                    void this.openModelPicker();
                     return;
                 }
                 await this.switchModel(arg);

package/dist/src/tui/components/ModelPicker.js

@@ -2,22 +2,27 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
 import { useStore } from '../context.js';
 import { themeColor } from '../colors.js';
-const MAX_VISIBLE = 8;
-/** Interactive model selector shown above the composer (opened by /model). */
-export function ModelPicker({ width }) {
+import { isPickerHeader } from '../picker.js';
+/** Model selector overlay (opened by /model). Height includes the border. */
+export function ModelPicker({ height }) {
     const store = useStore();
-    const list = store.models;
     const accent = store.theme ? themeColor(store.theme, 'accent') : '#7aa2f7';
     const dim = store.theme ? themeColor(store.theme, 'dim') : '#565f89';
     const muted = store.theme ? themeColor(store.theme, 'muted') : '#969cbc';
-    if (list.length === 0) {
-        return (_jsx(Box, { width: width, children: _jsx(Text, { color: dim, children: "no models available \u2014 configure a provider key first" }) }));
+    const attention = store.theme ? themeColor(store.theme, 'attention') : '#c3a332';
+    const rows = store.pickRows;
+    const idx = rows.length === 0 ? 0 : Math.min(Math.max(store.modelPicker.index, 0), rows.length - 1);
+    const innerH = Math.max(1, height - 3); // border(2) + footer(1)
+    if (rows.length === 0) {
+        return (_jsxs(Box, { borderStyle: "round", borderColor: dim, width: "100%", height: height, flexDirection: "column", paddingX: 1, children: [_jsx(Text, { color: dim, children: "no models available \u2014 configure a provider key first" }), _jsx(Text, { color: muted, children: "Esc close" })] }));
     }
-    const idx = Math.min(Math.max(store.modelPicker.index, 0), list.length - 1);
-    const start = Math.max(0, Math.min(idx, list.length - MAX_VISIBLE));
-    const window = list.slice(start, start + MAX_VISIBLE);
-    return (_jsxs(Box, { width: width, flexDirection: "column", children: [start > 0 && _jsxs(Text, { color: muted, children: ["\u25B2 ", (start).toLocaleString(), " more\u2026"] }), window.map((m, i) => {
+    const start = Math.max(0, Math.min(idx, rows.length - innerH));
+    const windowRows = rows.slice(start, start + innerH);
+    return (_jsxs(Box, { borderStyle: "round", borderColor: accent, width: "100%", height: height, flexDirection: "column", paddingX: 1, children: [start > 0 && (_jsxs(Text, { color: muted, children: ["\u25B2 ", start, " more\u2026"] })), windowRows.map((r, i) => {
                 const at = start + i;
-                return (_jsxs(Box, { children: [_jsx(Text, { color: at === idx ? accent : dim, children: at === idx ? '❯ ' : '  ' }), _jsx(Text, { color: at === idx ? accent : dim, children: m })] }, m));
-            }), start + MAX_VISIBLE < list.length && _jsx(Text, { color: muted, children: "\u25BC more\u2026" }), _jsx(Text, { color: muted, children: "\u2191\u2193 select \u00B7 Enter choose \u00B7 Esc close" })] }));
+                if (isPickerHeader(r)) {
+                    return (_jsx(Box, { children: _jsx(Text, { color: attention, bold: true, wrap: "truncate-end", children: r.label }) }, `h-${at}`));
+                }
+                return (_jsxs(Box, { children: [_jsx(Text, { color: at === idx ? accent : dim, children: at === idx ? '❯ ' : '  ' }), _jsx(Text, { color: at === idx ? accent : dim, wrap: "truncate-end", children: r.label })] }, r.id));
+            }), start + innerH < rows.length && (_jsxs(Text, { color: muted, children: ["\u25BC ", rows.length - start - innerH, " more\u2026"] })), _jsx(Text, { color: muted, children: "\u2191\u2193 select \u00B7 Enter switch \u00B7 Esc close" })] }));
 }

package/dist/src/tui/picker.js

@@ -0,0 +1,74 @@
+import { PROVIDER_SPECS, ORBITX_SERVE } from '../core/llm/index.js';
+import { describeProvidersAvailable } from '../core/llm/secrets.js';
+import { createOllamaProvider } from '../core/llm/providers/ollama.js';
+export function isPickerHeader(row) {
+    return row.kind === 'header';
+}
+export async function resolvePickerRows() {
+    const rows = [];
+    const seen = new Set();
+    const avail = describeProvidersAvailable();
+    for (const spec of PROVIDER_SPECS) {
+        if (spec.id === 'ollama') {
+            const ollama = createOllamaProvider();
+            const local = await ollama.listModels();
+            if (local.length === 0) {
+                rows.push({ kind: 'header', label: 'Ollama (local) — server offline, run ollama serve' });
+                continue;
+            }
+            rows.push({ kind: 'header', label: `Ollama (local) — ${local.length} installed` });
+            for (const full of local) {
+                const name = full.slice('ollama/'.length);
+                if (seen.has(full))
+                    continue;
+                seen.add(full);
+                rows.push({ kind: 'item', label: name, id: full, provider: 'ollama' });
+            }
+            continue;
+        }
+        if (spec.id === 'orbitx') {
+            rows.push({ kind: 'header', label: 'Orbit X (auto-routes Groq · Gemini · OpenRouter)' });
+            for (const bare of ORBITX_SERVE) {
+                const full = `orbitx/${bare}`;
+                if (seen.has(full))
+                    continue;
+                seen.add(full);
+                rows.push({
+                    kind: 'item',
+                    label: bare === 'auto' ? 'auto (backend routes across providers)' : bare,
+                    id: full,
+                    provider: 'orbitx',
+                });
+            }
+            continue;
+        }
+        // Other providers: only when a key is configured.
+        const available = avail.some((a) => a.provider === spec.id);
+        if (!available)
+            continue;
+        rows.push({ kind: 'header', label: spec.label });
+        for (const m of spec.models) {
+            const full = `${spec.id}/${m.id}`;
+            if (seen.has(full))
+                continue;
+            seen.add(full);
+            rows.push({ kind: 'item', label: m.label ?? m.id, id: full, provider: spec.id });
+        }
+    }
+    return rows;
+}
+/** Row index whose item matches the current route/model, else the first item. */
+export function findPickerIndex(rows, routeModel, configPrimary) {
+    if (rows.length === 0)
+        return 0;
+    const cur = routeModel || configPrimary || '';
+    for (let i = 0; i < rows.length; i++) {
+        const r = rows[i];
+        if (r && r.kind === 'item' && (r.id === cur || (configPrimary && r.id?.endsWith(`/${configPrimary.split('/').pop()}`)))) {
+            return i;
+        }
+    }
+    // Fall back to the first item row.
+    const firstItem = rows.findIndex((r) => r.kind === 'item');
+    return firstItem >= 0 ? firstItem : 0;
+}

package/dist/src/tui/store.js

@@ -22,8 +22,8 @@ const SLASH_COMMANDS = [
 // Word-to-word reveal pacing. Servers stream sentence-sized chunks; the reveal
 // cursor films their contents out at a steady character rate, word-aligned, so
 // output reads "word by word" instead of "sentence by sentence".
-const REVEAL_CPS = 30; // chars/sec baseline (~6-8 words/sec) — brisk typing feel
-const REVEAL_LAG_CAP = 400; // caught-up threshold -> above it, drain 3x faster
+const REVEAL_CPS = 60; // chars/sec baseline (~12 words/sec) — brisk typing feel
+const REVEAL_LAG_CAP = 200; // caught-up threshold -> above it, drain 3x faster
 export class AppStore {
     messages = [];
     streaming = false;
@@ -39,6 +39,8 @@ export class AppStore {
     cwd = '';
     models = [];
     modelPicker = { open: false, index: 0 };
+    /** Grouped rows for the /model overlay (see picker.ts). */
+    pickRows = [];
     agents = new Map();
     dockOpen = false;
     yolo = false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orbit-intelligence/orbit-agent",
-  "version": "0.3.12",
+  "version": "0.3.14",
   "description": "orbit — a premium pure-TypeScript coding agent for Termux and desktop terminals, powered by Orbit X.",
   "type": "module",
   "license": "UNLICENSED",