@orbit-intelligence/orbit-agent 0.3.12

package/dist/src/core/context/context-manager.js

@@ -0,0 +1,167 @@
+import { newMessage } from '../types.js';
+export class ContextManager {
+    messages = [];
+    systemPrompt = '';
+    constructor(systemPrompt = '') {
+        this.systemPrompt = systemPrompt;
+    }
+    setSystemPrompt(prompt) {
+        this.systemPrompt = prompt;
+    }
+    reset() {
+        this.messages = [];
+    }
+    history() {
+        return this.messages;
+    }
+    add(msg) {
+        this.messages.push(msg);
+    }
+    addUser(text) {
+        const msg = newMessage(`u_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`, 'user', text);
+        this.messages.push(msg);
+        return msg;
+    }
+    addAssistant(content, extras) {
+        const msg = newMessage(`a_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`, 'assistant', content);
+        if (extras?.model)
+            msg.model = extras.model;
+        if (extras?.toolCalls)
+            msg.toolCalls = extras.toolCalls;
+        this.messages.push(msg);
+        return msg;
+    }
+    /** Record a tool result against the tool call that produced it. */
+    addToolResult(call, content, isError) {
+        const msg = newMessage(`r_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`, 'tool', content);
+        msg.toolCallId = call.id;
+        msg.toolName = call.name;
+        msg.isError = isError;
+        this.messages.push(msg);
+    }
+    /** Convert to provider wire format, pairing tool results with their calls. */
+    toOutgoing() {
+        const out = [];
+        if (this.systemPrompt)
+            out.push({ role: 'system', content: this.systemPrompt });
+        for (const m of this.messages) {
+            if (m.role === 'user') {
+                out.push({ role: 'user', content: m.content });
+                continue;
+            }
+            if (m.role === 'assistant') {
+                out.push({
+                    role: 'assistant',
+                    content: m.content,
+                    toolCalls: m.toolCalls?.map((tc) => ({ id: tc.id, name: tc.name, args: tc.args })),
+                });
+                continue;
+            }
+            if (m.role === 'tool') {
+                const tr = m;
+                let last = out[out.length - 1];
+                // find the preceding assistant turn
+                let idx = out.length - 1;
+                while (idx >= 0 && out[idx].role !== 'assistant')
+                    idx--;
+                last = out[idx] ?? out[out.length - 1];
+                if (last && tr.toolCallId) {
+                    const existing = last.toolResults ?? [];
+                    last.toolResults = [
+                        ...existing,
+                        { toolCallId: tr.toolCallId, name: tr.toolName ?? '', content: tr.content, isError: tr.isError ?? false },
+                    ];
+                }
+                continue;
+            }
+            // system messages already handled via systemPrompt
+        }
+        return out;
+    }
+    /**
+     * Rough token estimate of the whole conversation (system prompt included).
+     * Hedged: ~4 characters per token, plus 1 token per message for framing.
+     */
+    estimateTokens() {
+        let chars = this.systemPrompt.length;
+        let count = this.systemPrompt ? 1 : 0;
+        for (const m of this.messages) {
+            chars += m.content.length;
+            count++;
+            for (const tc of m.toolCalls ?? []) {
+                chars += tc.name.length + tc.args.length;
+                count++;
+            }
+        }
+        return Math.ceil(chars / 4) + count;
+    }
+    /**
+     * Keep the conversation within `budget` estimated tokens. Adapted from
+     * opencode's compaction strategy: reserve a recent-context budget (25% of
+     * `budget`, clamped to [2000, 15000]) for the newest turns and drop the
+     * older history that exceeds that window.
+     *
+     * The current (most recent) turn is always preserved so the active question
+     * keeps its context. Returns the number of dropped user turns and the token
+     * delta, or zeros when no compaction was needed.
+     */
+    compact(budget) {
+        const tokensBefore = this.estimateTokens();
+        if (tokensBefore <= budget)
+            return { droppedPairs: 0, tokensBefore, tokensAfter: tokensBefore };
+        // Identify complete turn groups: [user, assistant, (tool…)*]
+        const groups = [];
+        let current = [];
+        for (let i = 0; i < this.messages.length; i++) {
+            const m = this.messages[i];
+            if (m.role === 'user' && current.length > 0) {
+                groups.push(current);
+                current = [i];
+            }
+            else {
+                current.push(i);
+            }
+        }
+        if (current.length > 0)
+            groups.push(current);
+        // Nothing to drop when there is a single turn (the current one).
+        if (groups.length <= 1)
+            return { droppedPairs: 0, tokensBefore, tokensAfter: tokensBefore };
+        // Reserve a budget for the newest turns, walking oldest-→-newest.
+        const reserved = Math.min(15_000, Math.max(2_000, Math.floor(budget * 0.25)));
+        const last = groups[groups.length - 1];
+        let keepBegin = last[0];
+        let cumulative = this.estimateRange(last[0], last[last.length - 1]);
+        for (let g = groups.length - 2; g >= 0; g--) {
+            const group = groups[g];
+            const size = this.estimateRange(group[0], group[group.length - 1]);
+            if (cumulative + size <= reserved) {
+                cumulative += size;
+                keepBegin = group[0];
+                continue;
+            }
+            break;
+        }
+        const dropped = this.messages.slice(0, keepBegin).filter((m) => m.role === 'user').length;
+        if (dropped === 0)
+            return { droppedPairs: 0, tokensBefore, tokensAfter: tokensBefore };
+        this.messages.splice(0, keepBegin);
+        const tokensAfter = this.estimateTokens();
+        return { droppedPairs: dropped, tokensBefore, tokensAfter };
+    }
+    /** Character-based token estimate for messages[indexA..indexB], inclusive. */
+    estimateRange(indexA, indexB) {
+        let chars = 0;
+        let count = 0;
+        for (let i = indexA; i <= indexB && i < this.messages.length; i++) {
+            const m = this.messages[i];
+            chars += m.content.length;
+            count++;
+            for (const tc of m.toolCalls ?? []) {
+                chars += tc.name.length + tc.args.length;
+                count++;
+            }
+        }
+        return Math.ceil(chars / 4) + count;
+    }
+}

package/dist/src/core/events.js

@@ -0,0 +1,23 @@
+export class EventBus {
+    listeners = new Map();
+    on(name, handler) {
+        const set = this.listeners.get(name) ?? new Set();
+        set.add(handler);
+        this.listeners.set(name, set);
+        return () => set.delete(handler);
+    }
+    emit(name, ...args) {
+        const set = this.listeners.get(name);
+        if (!set)
+            return;
+        for (const h of set) {
+            try {
+                h(...args);
+            }
+            catch (err) {
+                // never let a listener break the loop
+                console.error(`[events] listener for ${String(name)} failed:`, err);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,207 @@
+export async function* streamOpenAi(opts) {
+    const { baseUrl, apiKey, model, messages, tools, temperature, maxTokens, signal, reasoning } = opts;
+    const reasoningStyle = opts.reasoningStyle ?? 'object';
+    // Build flat message list for OpenAI format
+    const flatMsgs = [];
+    for (const m of messages) {
+        const msg = { role: m.role };
+        if (m.role === 'assistant' && m.toolCalls?.length) {
+            msg.content = m.content || '';
+            msg.tool_calls = m.toolCalls.map((tc) => ({
+                id: tc.id,
+                type: 'function',
+                function: { name: tc.name, arguments: tc.args },
+            }));
+        }
+        else {
+            msg.content = m.content;
+        }
+        flatMsgs.push(msg);
+        if (m.toolResults?.length) {
+            for (const r of m.toolResults) {
+                flatMsgs.push({
+                    role: 'tool',
+                    tool_call_id: r.toolCallId,
+                    name: r.name,
+                    content: r.content,
+                });
+            }
+        }
+    }
+    const body = {
+        model,
+        messages: flatMsgs,
+        stream: true,
+        stream_options: { include_usage: true },
+    };
+    if (tools?.length)
+        body.tools = tools;
+    if (temperature != null)
+        body.temperature = temperature;
+    if (maxTokens != null)
+        body.max_tokens = maxTokens;
+    if (reasoning)
+        appendReasoning(body, model, reasoning, reasoningStyle);
+    const headers = { 'Content-Type': 'application/json' };
+    // Auth-less gateways (e.g. a self-hosted Orbit X without ORBITX_TOKEN set)
+    // accept requests with no key; only send Authorization when one exists.
+    if (apiKey)
+        headers.Authorization = `Bearer ${apiKey}`;
+    const res = await fetch(`${baseUrl}/chat/completions`, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(body),
+        signal,
+    });
+    if (!res.ok) {
+        const text = await res.text().catch(() => 'unknown error');
+        throw new Error(friendlyHttpError(res.status, text, String(body.model ?? model)));
+    }
+    const reader = res.body?.getReader();
+    if (!reader)
+        throw new Error('No readable body from LLM');
+    const decoder = new TextDecoder();
+    let buffer = '';
+    const toolAcc = new Map();
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            // Process complete lines (each data: line is one SSE event from OpenAI/Groq/OpenRouter)
+            let nl;
+            while ((nl = buffer.indexOf('\n')) >= 0) {
+                const raw = buffer.slice(0, nl);
+                buffer = buffer.slice(nl + 1);
+                if (!raw.startsWith('data:'))
+                    continue;
+                const data = raw.slice(5).trim();
+                if (!data)
+                    continue;
+                if (data === '[DONE]') {
+                    if (toolAcc.size > 0) {
+                        for (const [, tc] of toolAcc) {
+                            yield { type: 'tool_call_start', id: tc.id, name: tc.name };
+                            yield { type: 'tool_call_args', id: tc.id, args: tc.args };
+                            yield { type: 'tool_call_end', id: tc.id, name: tc.name, args: tc.args };
+                        }
+                    }
+                    yield { type: 'done' };
+                    return;
+                }
+                const parsed = jsonSafe(data);
+                if (!parsed)
+                    continue;
+                const choices = (parsed.choices ?? []);
+                const choice = choices[0];
+                const delta = choice?.delta ?? {};
+                // Reasoning / thinking
+                const reasoning = delta.reasoning_content ?? delta.reasoning ?? delta.thinking;
+                if (typeof reasoning === 'string' && reasoning.length > 0) {
+                    yield { type: 'reasoning', text: reasoning };
+                }
+                // Content token
+                const content = typeof delta.content === 'string' ? delta.content : '';
+                if (content.length > 0)
+                    yield { type: 'token', text: content };
+                // Tool calls
+                if (Array.isArray(delta.tool_calls)) {
+                    for (const tc of delta.tool_calls) {
+                        const idx = typeof tc.index === 'number' ? tc.index : 0;
+                        const acc = toolAcc.get(idx) ?? { id: '', name: '', args: '' };
+                        if (tc.id)
+                            acc.id = tc.id;
+                        if (tc.function?.name)
+                            acc.name = tc.function.name;
+                        if (typeof tc.function?.arguments === 'string')
+                            acc.args += tc.function.arguments;
+                        toolAcc.set(idx, acc);
+                    }
+                }
+                // Finish
+                const reason = choice?.finish_reason;
+                if (reason === 'tool_calls' || reason === 'stop') {
+                    // Surface tool calls whenever they were accumulated, regardless of
+                    // the finish reason (some gateways send 'stop' after tool deltas).
+                    if (toolAcc.size > 0) {
+                        for (const [, tc] of toolAcc) {
+                            yield { type: 'tool_call_start', id: tc.id, name: tc.name };
+                            yield { type: 'tool_call_args', id: tc.id, args: tc.args };
+                            yield { type: 'tool_call_end', id: tc.id, name: tc.name, args: tc.args };
+                        }
+                    }
+                    const usage = parsed.usage;
+                    yield { type: 'done', usage: usage ? {
+                            inputTokens: usage.prompt_tokens ?? 0,
+                            outputTokens: usage.completion_tokens ?? 0,
+                        } : undefined };
+                    return;
+                }
+            }
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    yield { type: 'done' };
+}
+function jsonSafe(s) {
+    try {
+        return JSON.parse(s);
+    }
+    catch {
+        return null;
+    }
+}
+function appendReasoning(body, model, reasoning, style) {
+    if (style === 'effort') {
+        // Groq: top-level `reasoning_effort`. `none` is valid for qwen3 family.
+        const effort = reasoning.enabled === false ? 'none' : (reasoning.effort ?? 'medium');
+        body.reasoning_effort = groqEffortValue(model, effort);
+        return;
+    }
+    // OpenRouter / Orbit X style: `reasoning: { effort }`.
+    if (reasoning.enabled === false) {
+        body.reasoning = { enabled: false };
+    }
+    else {
+        body.reasoning = { effort: reasoning.effort ?? 'medium' };
+    }
+}
+/** qwen3-family on Groq only accepts none/default; map our levels to them. */
+function groqEffortValue(model, effort) {
+    const isQwen = model.includes('qwen3') || model.startsWith('qwen/qwen3');
+    if (isQwen)
+        return effort === 'none' ? 'none' : 'default';
+    return effort;
+}
+/**
+ * Surface upstream HTTP failures in a way the user can act on. Orbit X's
+ * public backend returns `503 {"error":{"message":"no provider keys
+ * configured on this service","type":"not_configured"}}` when no upstream
+ * keys are set — turn that into an explicit, actionable message instead of
+ * a generic "route failed".
+ */
+function friendlyHttpError(status, bodyText, model) {
+    let message = '';
+    try {
+        const parsed = JSON.parse(bodyText);
+        message = parsed.error?.message ?? '';
+    }
+    catch { /* non-JSON body */ }
+    if (status === 503 && message.toLowerCase().includes('no provider keys configured')) {
+        return 'Orbit X: the backend service has no upstream provider keys configured (503 not_configured). ' +
+            'Contact the service owner or configure keys on the Orbit X server — the client is fine. ' +
+            `Model "${model}" could not be reached.`;
+    }
+    if ((status === 401 || status === 403) && message) {
+        return `Provider rejected the API key (HTTP ${status}): ${message.slice(0, 300)}`;
+    }
+    if (status === 404) {
+        return `Provider returned HTTP 404 — is the model id "${model}" valid? ${message.slice(0, 200)}`;
+    }
+    if (message)
+        return `LLM HTTP ${status}: ${message.slice(0, 300)}`;
+    return `LLM HTTP ${status}: ${bodyText.slice(0, 300)}`;
+}

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

@@ -0,0 +1,93 @@
+import { getProviderSecrets } from './secrets.js';
+import { createOpenAiProvider } from './providers/openai-compat.js';
+import { createGeminiProvider } from './providers/gemini.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',
+};
+/**
+ * Build providers available in the current environment.
+ * Provider keys come ONLY from env or the git-ignored keys.json — never config.
+ * Orbit X's token is read through the same secrets layer so it never lands in
+ * config.json (the wizard persists it via `writeKeys('orbitx', …)`). The Orbit X
+ * provider is always built in orbitx mode; a token is optional — open gateways
+ * (no ORBITX_TOKEN set server-side) accept requests without one.
+ */
+export function buildProviders(config) {
+    const providers = {};
+    // Orbit X token: secrets layer first, legacy config.token as a back-compat fallback.
+    const orbitxSec = getProviderSecrets('orbitx');
+    const orbitxKey = (orbitxSec?.keys[0] ?? '') ||
+        config.orbitx.token ||
+        process.env.ORBITX_TOKEN ||
+        process.env.ORBITX_API_KEY ||
+        '';
+    if (config.provider === 'orbitx') {
+        providers.orbitx = createOpenAiProvider({
+            id: 'orbitx',
+            baseUrl: `${config.orbitx.url}/v1`,
+            apiKey: orbitxKey,
+            models: modelsOf(PROVIDER_CATALOGS.find((p) => p.id === 'orbitx')),
+        });
+    }
+    for (const [id, baseUrl] of Object.entries(ENDPOINTS)) {
+        const sec = getProviderSecrets(id);
+        if (!sec || sec.keys.length === 0 || sec.keys[0] === undefined)
+            continue;
+        const spec = PROVIDER_CATALOGS.find((p) => p.id === id);
+        providers[id] = createOpenAiProvider({
+            id,
+            baseUrl,
+            apiKey: sec.keys[0],
+            models: spec ? modelsOf(spec) : [],
+            reasoningStyle: id === 'groq' ? 'effort' : 'object',
+        });
+    }
+    const geminiSec = getProviderSecrets('gemini');
+    if (geminiSec && geminiSec.keys[0]) {
+        providers.gemini = createGeminiProvider(geminiSec.keys[0]);
+    }
+    return providers;
+}
+/** Candidate model ids (provider-prefixed) for the router. */
+export async function resolveCandidates(config, providers) {
+    const candidates = [];
+    // Orbit X mode → list the backend's routable models (primary + fallbacks
+    // first, then the curated serve table) so the TUI's /model picker has real
+    // choices; the backend does its own internal auto-routing + failover.
+    if (config.provider === 'orbitx' && providers.orbitx) {
+        const pushBare = (id) => {
+            if (!id)
+                return;
+            const bare = id.split('/').slice(1).join('/') || 'auto';
+            const full = `orbitx/${bare}`;
+            if (!candidates.includes(full))
+                candidates.push(full);
+        };
+        pushBare(config.model.primary);
+        for (const fb of config.model.fallback)
+            pushBare(fb);
+        for (const bare of ORBITX_SERVE)
+            pushBare(bare);
+        return candidates;
+    }
+    const push = (id) => {
+        const provId = id.split('/')[0];
+        if (providers[provId] && !candidates.includes(id))
+            candidates.push(id);
+    };
+    push(config.model.primary);
+    for (const fb of config.model.fallback)
+        push(fb);
+    // If nothing configured resolved, fall back to any available provider models.
+    if (candidates.length === 0) {
+        for (const name of Object.keys(providers)) {
+            const prov = providers[name];
+            for (const m of await prov.listModels())
+                push(m);
+        }
+    }
+    return candidates;
+}