@orbit-intelligence/orbit-agent 0.3.13 → 0.3.15

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/sanitize.js

@@ -0,0 +1,47 @@
+/**
+ * Streamed-content sanitizer.
+ *
+ * Some gateway models (gpt-oss family, Qwen cloud variants) leak control
+ * tokens into the visible content stream: `<|start|>functions.list_dir
+ * to=assistant<|message|>{...}` pensieve blocks, dangling `<|...|>` tags,
+ * and boundary boilerplate such as a lone `response` line or "Proceed to
+ * final answer." Strip those before the TUI renders or history commits them
+ * so the user sees the prose, not the plumbing.
+ */
+/** Control-rune tag, e.g. `<|start|>`, `<|message|>`, `<|end|>`. */
+const TAG_RE = /<\|[^|>]*\|>/g;
+/**
+ * Qwen/OSS pensieve header: `<|start|>functions.<name> to=assistant
+ * <|message|>` followed by a mangled JSON echo that model emits verbatim.
+ * Removes the header plus the leading portion of the echoed line up to the
+ * first blank line, which is where the real prose begins in practice.
+ */
+const PENSIVE_RE = /<\|start\|>\n?[\s\S]*?<\|message\|>[ \t]*[^\r\n]*\n/g;
+/** Lone boundary markers some cloud models insert before their answer. */
+const BOUNDARY_LINE_RE = /^[ \t]*(?:response|Proceed to final answer\.?)[ \t]*$/gm;
+/** Collapse 3+ consecutive blank lines down to two (post-strip tidy-up). */
+const BLANK_RUN_RE = /\n{3,}/g;
+/**
+ * Sanitize a single streamed token. idempotent; cheap enough to run per
+ * token. A `<|` opened mid-chunk but closed later is finished by
+ * `sanitizeContent` over the assembled text, so partial matches here are
+ * fine.
+ */
+export function sanitizeToken(text) {
+    let s = text.replace(PENSIVE_RE, '').replace(TAG_RE, '');
+    if (s.includes('response') || s.includes('Proceed to final answer')) {
+        s = s.replace(BOUNDARY_LINE_RE, '');
+    }
+    return s;
+}
+/** Sanitize a fully-assembled message/reasoning blob. */
+export function sanitizeContent(text) {
+    let s = text
+        .replace(PENSIVE_RE, '')
+        .replace(TAG_RE, '')
+        .replace(BOUNDARY_LINE_RE, '')
+        .replace(BLANK_RUN_RE, '\n\n')
+        .replace(/^\n+/, '')
+        .replace(/\n+$/, '');
+    return s;
+}

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);
@@ -73,12 +83,13 @@ export function getProviderSecrets(provider) {
         return { provider, keys: envKeys, source: 'env' };
     const file = readKeysFile();
     const fileKeys = file[provider] ?? [];
-    if (fileKeys.length > 0)
-        return { provider, keys: fileKeys, source: 'file' };
+    const flat = fileKeys.map((k) => (typeof k === 'string' ? k : k.key)).filter(Boolean);
+    if (flat.length > 0)
+        return { provider, keys: flat, source: 'file' };
     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,19 +102,37 @@ 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 });
     }
     return out;
 }
+export function describeProviderKey(provider) {
+    const s = getProviderSecrets(provider);
+    if (!s || !s.keys[0])
+        return { provider, available: false };
+    const named = readKeysFile()[provider]?.find((k) => typeof k === 'object');
+    return {
+        provider,
+        available: true,
+        masked: maskSecret(s.keys[0]),
+        source: s.source,
+        label: named?.name,
+    };
+}
 /**
  * Persist provider keys to the git-ignored keys.json (0600), merging over any
  * existing keys so a re-run of the wizard never wipes other providers.
  */
 export function writeKeys(provider, keys) {
-    const trimmed = keys.map((k) => k.trim()).filter(Boolean);
+    const trimmed = keys
+        .map((k) => {
+        const key = typeof k === 'string' ? k.trim() : { name: k.name.trim() || 'default', key: k.key.trim() };
+        return typeof key === 'string' ? key : { name: key.name, key: key.key };
+    })
+        .filter((k) => (typeof k === 'string' ? k : k.key) !== '');
     if (trimmed.length === 0)
         return 'no keys provided';
     const existing = readKeysFile();
@@ -119,3 +148,42 @@ export function writeKeys(provider, keys) {
         return err.message;
     }
 }
+/** Save (or update by label) a single named key for a provider. */
+export function saveNamedKey(provider, name, key) {
+    const clean = key.trim();
+    if (!clean)
+        return 'no key provided';
+    const label = name.trim() || 'default';
+    const existing = readKeysFile();
+    const list = existing[provider] ?? [];
+    const idx = list.findIndex((k) => typeof k === 'object' && k.name === label);
+    if (idx >= 0)
+        list[idx] = { name: label, key: clean };
+    else
+        list.push({ name: label, key: clean });
+    existing[provider] = list;
+    try {
+        mkdirSync(configDir(), { recursive: true });
+        writeFileSync(keysPath(), JSON.stringify(existing, null, 2), 'utf8');
+        chmodSync(keysPath(), 0o600);
+        invalidateKeysCache();
+        return null;
+    }
+    catch (err) {
+        return err.message;
+    }
+}
+/** Human "masked · source [label]" description for a provider's configured key. */
+export function describeKey(provider) {
+    const envKeys = fromEnv(provider);
+    if (envKeys.length > 0 && envKeys[0])
+        return { masked: maskSecret(envKeys[0]), source: 'env' };
+    const file = readKeysFile();
+    const entries = file[provider] ?? [];
+    const first = entries[0];
+    if (!first)
+        return null;
+    if (typeof first === 'string')
+        return { masked: maskSecret(first), source: 'file' };
+    return { masked: maskSecret(first.key), source: 'file', label: first.name };
+}

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,11 @@ 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
+        ? store.keyEntry
+            ? 8
+            : Math.min(store.pickRows.length, 12) + 3
+        : 0;
     const dockLines = store.dockOpen
         ? store.agents.size === 0
             ? 2
@@ -63,5 +67,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 })] }) }));
 }