@orbit-intelligence/orbit-agent 0.3.12

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

@@ -0,0 +1,228 @@
+export const modelsOf = (spec) => spec.models.map((m) => m.id);
+function r(mode, efforts, def, extra) {
+    return { mode, efforts, default: def, ...extra };
+}
+export const GROQ_CATALOG = [
+    {
+        id: 'openai/gpt-oss-120b',
+        label: 'OpenAI GPT-OSS 120B',
+        reasoning: r('effort', ['low', 'medium', 'high'], 'medium'),
+    },
+    {
+        id: 'openai/gpt-oss-20b',
+        label: 'OpenAI GPT-OSS 20B',
+        reasoning: r('effort', ['low', 'medium', 'high'], 'medium'),
+    },
+    {
+        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: 'qwen/qwen3.6-27b',
+        label: 'Qwen3.6 27B',
+        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: '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' },
+];
+export const GEMINI_CATALOG = [
+    {
+        id: 'gemini-3.8-flash',
+        label: 'Gemini 3.8 Flash',
+        reasoning: r('level', ['low', 'medium', 'high'], 'medium'),
+    },
+    {
+        id: 'gemini-3.7-flash',
+        label: 'Gemini 3.7 Flash',
+        reasoning: r('level', ['low', 'medium', 'high'], 'medium'),
+    },
+    {
+        id: 'gemini-3.6-flash',
+        label: 'Gemini 3.6 Flash',
+        reasoning: r('level', ['minimal', 'low', 'medium', 'high'], 'medium'),
+    },
+    {
+        id: 'gemini-3.5-flash',
+        label: 'Gemini 3.5 Flash',
+        reasoning: r('level', ['minimal', 'low', 'medium', 'high'], 'medium'),
+    },
+    {
+        id: 'gemini-3.1-flash-lite',
+        label: 'Gemini 3.1 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-pro-preview',
+        label: 'Gemini 3.1 Pro',
+        reasoning: r('level', ['low', 'medium', 'high'], 'medium'),
+    },
+    {
+        id: 'gemini-2.5-pro',
+        label: 'Gemini 2.5 Pro',
+        reasoning: r('budget', ['minimal', 'low', 'medium', 'high'], 'medium', {
+            switchable: false,
+        }),
+    },
+    {
+        id: 'gemini-2.5-flash',
+        label: 'Gemini 2.5 Flash',
+        reasoning: r('budget', ['minimal', 'low', 'medium', 'high'], 'medium', {
+            switchable: false,
+        }),
+    },
+    {
+        id: 'gemini-2.5-flash-lite',
+        label: 'Gemini 2.5 Flash-Lite',
+        reasoning: r('budget', ['none', 'minimal', 'low', 'medium', 'high'], 'none', {
+            switchable: true,
+        }),
+    },
+];
+export const OPENROUTER_CATALOG = [
+    // Paid
+    {
+        id: 'anthropic/claude-opus-4.8',
+        label: 'Claude Opus 4.8',
+        reasoning: r('none', ['low', 'medium', 'high'], 'medium', { switchable: false }),
+    },
+    { 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',
+        reasoning: r('effort', ['low', 'medium', 'high'], 'medium'),
+    },
+    {
+        id: 'openai/o4-mini',
+        label: 'OpenAI o4-mini',
+        reasoning: r('effort', ['low', 'medium', 'high'], 'medium'),
+    },
+    {
+        id: 'openai/gpt-oss-120b',
+        label: 'OpenAI GPT-OSS 120B',
+        reasoning: r('effort', ['low', 'medium', 'high'], 'medium'),
+    },
+    {
+        id: 'openai/gpt-oss-20b',
+        label: 'OpenAI GPT-OSS 20B',
+        reasoning: r('effort', ['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: '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: 'qwen/qwen3.7-max',
+        label: 'Qwen3.7 Max',
+        reasoning: r('effort', ['low', 'medium', 'high'], 'medium'),
+    },
+    {
+        id: 'x-ai/grok-build-0.1',
+        label: 'Grok Build 0.1',
+        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: '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,
+        reasoning: r('effort', ['low', 'medium', 'high'], 'medium'),
+    },
+    {
+        id: 'thinkingmachines/inkling-small:free',
+        label: 'Inkling Small (free)',
+        free: true,
+        reasoning: r('effort', ['low', 'medium', 'high'], 'medium'),
+    },
+    { id: 'minimax/minimax-m3:free', label: 'MiniMax M3 (free)', free: true },
+    {
+        id: 'deepseek/deepseek-r1:free',
+        label: 'DeepSeek R1 (free)',
+        free: true,
+        reasoning: r('effort', ['low', 'medium', 'high'], 'high'),
+    },
+    { 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 },
+];
+export const ORBITX_CATALOG = [
+    { id: 'auto', label: 'auto (backend routes across providers)' },
+];
+/**
+ * Models the Orbit X gateway can route (`orbitx/<bare>`). Mirrors the
+ * server-side MODEL_ROUTES table so /model's picker only offers ids that the
+ * backend will actually serve. Order is presentation order.
+ */
+export const ORBITX_SERVE = [
+    'auto',
+    'gemini-3.8-flash',
+    'gemini-3.6-flash',
+    'gemini-3.1-pro-preview',
+    'gemini-2.5-flash',
+    'meta-llama/llama-4-maverick-17b-128e-instruct',
+    'qwen/qwen3-32b',
+    'meta-llama/llama-3.3-70b-versatile',
+    'meta-llama/llama-3.1-8b-instant',
+    'qwen/qwen-2.5-coder-32b-instruct',
+    'qwen/qwen3.7-max',
+    'deepseek/deepseek-v4-flash',
+    'moonshotai/kimi-k2.7-code',
+    'meta-llama/llama-3.3-70b-instruct',
+];
+export const PROVIDER_CATALOGS = [
+    { id: 'orbitx', label: 'Orbit X', requiresSecret: true, supportsCustom: true, models: ORBITX_CATALOG },
+    { 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 },
+];
+/** Find a model entry by bare id across every provider catalog. */
+export function findModel(provider, modelBare) {
+    for (const cat of PROVIDER_CATALOGS) {
+        if (cat.id !== provider)
+            continue;
+        const m = cat.models.find((x) => x.id === modelBare);
+        if (m)
+            return { ...m, provider };
+    }
+    return null;
+}
+/** True if the given entry advertises a reasoning/effort picker. */
+export function modelSupportsReasoning(m) {
+    return !!m.reasoning;
+}

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

@@ -0,0 +1,211 @@
+import { GEMINI_CATALOG } from '../models.js';
+/**
+ * Gemini (Google) native streaming provider.
+ * Uses v1beta generateContent streamGenerateContent with alt=sse, key auth.
+ */
+const GEMINI_ENDPOINT = 'https://generativelanguage.googleapis.com/v1beta/models';
+const GEMINI_MODELS = GEMINI_CATALOG.map((m) => m.id);
+export function createGeminiProvider(apiKey) {
+    return {
+        id: 'gemini',
+        modelCount: GEMINI_MODELS.length,
+        listModels() {
+            return GEMINI_MODELS.map((m) => `gemini/${m}`);
+        },
+        async *stream(llmOpts) {
+            let model = llmOpts.model;
+            if (model.startsWith('gemini/'))
+                model = model.slice(7);
+            if (!model)
+                model = 'gemini-2.5-flash';
+            const contents = toGeminiContents(llmOpts.messages);
+            const body = { contents };
+            const sys = llmOpts.messages.find((m) => m.role === 'system');
+            if (sys)
+                body.systemInstruction = { parts: [{ text: sys.content }] };
+            if (llmOpts.tools?.length) {
+                body.tools = [{
+                        functionDeclarations: llmOpts.tools.map((t) => ({
+                            name: t.function.name,
+                            description: t.function.description,
+                            parameters: t.function.parameters,
+                        })),
+                    }];
+            }
+            const thinkingConfig = geminiThinkingConfig(model, llmOpts.reasoning);
+            const genConfig = {
+                temperature: llmOpts.temperature,
+                maxOutputTokens: llmOpts.maxTokens,
+            };
+            if (thinkingConfig)
+                genConfig.thinkingConfig = thinkingConfig;
+            body.generationConfig = genConfig;
+            const url = `${GEMINI_ENDPOINT}/${model}:streamGenerateContent?alt=sse&key=${encodeURIComponent(apiKey)}`;
+            const res = await fetch(url, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(body),
+                signal: llmOpts.signal,
+            });
+            if (!res.ok) {
+                const text = await res.text().catch(() => 'unknown');
+                throw new Error(`Gemini HTTP ${res.status}: ${text.slice(0, 300)}`);
+            }
+            const reader = res.body?.getReader();
+            if (!reader)
+                throw new Error('No readable body from Gemini');
+            const decoder = new TextDecoder();
+            let buffer = '';
+            let pendingArgs = '';
+            let pendingTool = null;
+            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\n');
+                        if (nl === -1)
+                            break;
+                        const raw = buffer.slice(0, nl);
+                        buffer = buffer.slice(nl + 2);
+                        for (const line of raw.split('\n')) {
+                            if (!line.startsWith('data:'))
+                                continue;
+                            const data = line.slice(5).trim();
+                            if (!data)
+                                continue;
+                            const parsed = jsonSafe(data);
+                            if (!parsed)
+                                continue;
+                            const cand = parsed.candidates?.[0];
+                            if (!cand)
+                                continue;
+                            for (const part of cand.content?.parts ?? []) {
+                                if (typeof part.text === 'string') {
+                                    if (part.thought)
+                                        yield { type: 'reasoning', text: part.text };
+                                    else if (part.text.length > 0)
+                                        yield { type: 'token', text: part.text };
+                                }
+                                if (part.functionCall) {
+                                    if (pendingTool) {
+                                        yield { type: 'tool_call_args', id: pendingTool.id, args: pendingArgs };
+                                        yield { type: 'tool_call_end', id: pendingTool.id, name: pendingTool.name, args: pendingArgs };
+                                    }
+                                    const name = part.functionCall.name ?? '';
+                                    const argsStr = JSON.stringify(part.functionCall.args ?? {});
+                                    pendingTool = { id: `gemini_${Date.now()}_${name}`, name };
+                                    pendingArgs = argsStr;
+                                    yield { type: 'tool_call_start', id: pendingTool.id, name };
+                                }
+                            }
+                            const usage = parsed.usageMetadata;
+                            const reason = cand.finishReason;
+                            if (reason === 'STOP' || reason === 'MAX_TOKENS') {
+                                if (pendingTool) {
+                                    yield { type: 'tool_call_args', id: pendingTool.id, args: pendingArgs };
+                                    yield { type: 'tool_call_end', id: pendingTool.id, name: pendingTool.name, args: pendingArgs };
+                                    pendingTool = null;
+                                }
+                                yield { type: 'done', usage: usage ? {
+                                        inputTokens: usage.promptTokenCount,
+                                        outputTokens: usage.candidatesTokenCount,
+                                    } : undefined };
+                                return;
+                            }
+                            if (parsed.promptFeedback?.blockReason) {
+                                throw new Error(`Gemini blocked: ${parsed.promptFeedback.blockReason}`);
+                            }
+                        }
+                    }
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+            if (pendingTool) {
+                yield { type: 'tool_call_args', id: pendingTool.id, args: pendingArgs };
+                yield { type: 'tool_call_end', id: pendingTool.id, name: pendingTool.name, args: pendingArgs };
+            }
+            yield { type: 'done' };
+        },
+    };
+}
+function toGeminiContents(messages) {
+    const contents = [];
+    for (const m of messages) {
+        const parts = [];
+        if (m.role === 'system')
+            continue;
+        if (m.role === 'assistant') {
+            if (m.content)
+                parts.push({ text: m.content });
+            for (const tc of m.toolCalls ?? []) {
+                let args = {};
+                try {
+                    args = JSON.parse(tc.args);
+                }
+                catch { /* keep {} */ }
+                parts.push({ functionCall: { name: tc.name, args } });
+            }
+            contents.push({ role: 'model', parts });
+            continue;
+        }
+        if (m.toolResults && m.toolResults.length > 0) {
+            for (const r of m.toolResults) {
+                let result;
+                try {
+                    result = JSON.parse(r.content);
+                }
+                catch {
+                    result = { output: r.content };
+                }
+                parts.push({ functionResponse: { name: r.name, response: result } });
+            }
+            contents.push({ role: 'user', parts });
+            continue;
+        }
+        if (m.role === 'user') {
+            parts.push({ text: m.content });
+            contents.push({ role: 'user', parts });
+        }
+    }
+    return contents;
+}
+function jsonSafe(s) {
+    try {
+        return JSON.parse(s);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Translate our reasoning config into Gemini's thinkingConfig.
+ *  - gemini-3.x: `thinkingLevel` (MINIMAL/LOW/MEDIUM/HIGH); thinking is
+ *    mandatory, so "off" degrades to minimal.
+ *  - gemini-2.5: `thinkingBudget` token counts; lite defaults to off, so
+ *    disabling just omits the config.
+ */
+function geminiThinkingConfig(model, reasoning) {
+    if (!reasoning)
+        return undefined;
+    const effort = reasoning.effort ?? 'medium';
+    const disabled = reasoning.enabled === false;
+    if (model.startsWith('gemini-3')) {
+        const level = disabled || effort === 'none' ? 'MINIMAL'
+            : effort === 'high' ? 'HIGH'
+                : effort === 'low' ? 'LOW'
+                    : 'MEDIUM';
+        return { thinkingLevel: level };
+    }
+    if (model.startsWith('gemini-2.5')) {
+        if (disabled || effort === 'none')
+            return undefined; // lite stays off; pro/flash use defaults
+        const budget = effort === 'high' ? 32_768 : effort === 'medium' ? 8_192 : effort === 'low' ? 2_048 : 1_024;
+        return { thinkingBudget: budget };
+    }
+    return undefined;
+}

package/dist/src/core/llm/providers/openai-compat.js

@@ -0,0 +1,31 @@
+import { streamOpenAi } from '../http.js';
+export function createOpenAiProvider(opts) {
+    const [firstModel] = opts.models;
+    return {
+        id: opts.id,
+        modelCount: opts.models.length,
+        listModels() {
+            return opts.models.map((m) => `${opts.id}/${m}`);
+        },
+        async *stream(llmOpts) {
+            // Resolve model: strip provider prefix if present
+            let model = llmOpts.model;
+            if (model.startsWith(`${opts.id}/`))
+                model = model.slice(opts.id.length + 1);
+            if (!model)
+                model = firstModel ?? '';
+            yield* streamOpenAi({
+                baseUrl: opts.baseUrl,
+                apiKey: opts.apiKey,
+                model,
+                messages: llmOpts.messages,
+                tools: llmOpts.tools,
+                temperature: llmOpts.temperature,
+                maxTokens: llmOpts.maxTokens,
+                signal: llmOpts.signal,
+                reasoning: llmOpts.reasoning,
+                reasoningStyle: opts.reasoningStyle,
+            });
+        },
+    };
+}

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

@@ -0,0 +1,125 @@
+import { splitModelId } from './types.js';
+const COOLDOWN_MS = 60_000;
+const MAX_FAILURES = 2;
+export class AutoRouter {
+    providers;
+    strategy;
+    candidates;
+    health = new Map();
+    rrIndex = 0;
+    constructor(providers, candidates, strategy) {
+        this.providers = new Map(Object.entries(providers));
+        this.candidates = candidates.filter(Boolean);
+        this.strategy = strategy;
+    }
+    get candidateList() {
+        return this.candidates;
+    }
+    providerFor(providerId) {
+        return this.providers.get(providerId);
+    }
+    /** Ordered list of candidate model ids for this turn. */
+    order() {
+        if (this.strategy === 'pinned')
+            return this.candidates.slice(0, 1);
+        if (this.strategy === 'round-robin') {
+            const sorted = [...this.candidates];
+            if (sorted.length === 0)
+                return sorted;
+            const rotated = sorted.slice(this.rrIndex % sorted.length).concat(sorted.slice(0, this.rrIndex % sorted.length));
+            this.rrIndex = (this.rrIndex + 1) % sorted.length;
+            return rotated;
+        }
+        // auto / failover: prioritize healthy over cooling-down
+        const now = Date.now();
+        const healthy = this.candidates.filter((c) => !this.isCooling(c, now));
+        const cooling = this.candidates.filter((c) => this.isCooling(c, now));
+        return [...healthy, ...cooling];
+    }
+    isCooling(modelId, now) {
+        const h = this.health.get(modelId);
+        return !!h && h.failures >= MAX_FAILURES && now - h.lastFailureAt < COOLDOWN_MS;
+    }
+    recordFailure(modelId) {
+        const h = this.health.get(modelId) ?? { model: modelId, failures: 0, lastFailureAt: 0 };
+        h.failures++;
+        h.lastFailureAt = Date.now();
+        this.health.set(modelId, h);
+    }
+    recordSuccess(modelId, latencyMs) {
+        const h = this.health.get(modelId) ?? { model: modelId, failures: 0, lastFailureAt: 0 };
+        if (h.failures > 0)
+            h.failures = 0;
+        h.lastLatencyMs = latencyMs;
+        this.health.set(modelId, h);
+    }
+    /** Stream through the router with buffered failover. */
+    async *stream(opts) {
+        const order = this.order();
+        const maxAttempts = Math.max(1, opts.retries ?? 1);
+        const retryDelay = opts.retryDelayMs ?? 500;
+        let lastError;
+        for (const modelId of order) {
+            const { provider, model } = splitModelId(modelId);
+            const prov = this.providerFor(provider);
+            if (!prov)
+                continue;
+            // rr/failover: only one pass over order; but allow multiple attempts per candidate
+            const attempts = this.strategy === 'pinned' ? maxAttempts : 1;
+            for (let attempt = 0; attempt < attempts; attempt++) {
+                const started = Date.now();
+                let firstEventSeen = false;
+                try {
+                    const gen = prov.stream({ ...opts, model });
+                    for await (const ev of gen) {
+                        if (ev.type === 'done') {
+                            this.recordSuccess(modelId, Date.now() - started);
+                            yield ev;
+                            return;
+                        }
+                        // Commit on the FIRST event so every following word streams to
+                        // the user immediately (no token/ms thresholds). Events are only
+                        // withheld until the first one arrives so a hard pre-stream failure
+                        // can still fail over to the next candidate without showing text.
+                        firstEventSeen = true;
+                        yield ev;
+                    }
+                    // stream ended without a `done` event
+                    this.recordSuccess(modelId, Date.now() - started);
+                    return;
+                }
+                catch (err) {
+                    if (err instanceof Error)
+                        lastError = err;
+                    else
+                        lastError = new Error(String(err));
+                    if (firstEventSeen) {
+                        throw err;
+                    }
+                    this.recordFailure(modelId);
+                    if (attempt < attempts - 1) {
+                        await delay(retryDelay);
+                        continue;
+                    }
+                    // move to next candidate
+                    break;
+                }
+            }
+        }
+        throw new Error(lastError
+            ? `All LLM routes failed: ${lastError.message}`
+            : 'All LLM routes failed — check provider keys and connectivity.');
+    }
+    /** Current best route summary for the status bar. */
+    peek() {
+        const first = this.order()[0];
+        if (!first)
+            return null;
+        const { provider, model } = splitModelId(first);
+        const h = this.health.get(first);
+        return { provider, model, strategy: this.strategy, latencyMs: h?.lastLatencyMs };
+    }
+}
+function delay(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}