@aitherium/shell-cli 1.1.0 → 1.11.1

package/dist/status-banner.js

@@ -0,0 +1,239 @@
+/**
+ * status-banner.ts — Live fleet/backend status for the connect banner AND the
+ * in-TUI welcome header.
+ *
+ * The boxed connect banner (main.ts `showBanner`) prints to the normal terminal
+ * BEFORE the blessed alt-screen takes over, so inside the TUI it scrolls away and
+ * the user is left with a bare "AitherShell · url" header. `gatherStatus()` +
+ * `formatStatusLines()` let the TUI render the same live picture — services up,
+ * which backend (local vs Genesis/cloud), and the orchestrator + reasoning models
+ * actually loaded — right inside the output pane.
+ *
+ * The low-level probe/model helpers live here (rather than main.ts) so both the
+ * connect banner and the TUI share one implementation.
+ */
+import chalk from 'chalk';
+/** Probe a health endpoint, tolerating http↔https and a single cold-start miss. */
+export async function probeHealth(url, timeoutMs = 4000) {
+    const tryFetch = async (u) => {
+        try {
+            const r = await fetch(u, {
+                signal: AbortSignal.timeout(timeoutMs),
+                // @ts-ignore — Node 18+ supports this for self-signed certs
+                ...(u.startsWith('https') ? { dispatcher: undefined } : {}),
+            });
+            return r.ok;
+        }
+        catch {
+            return false;
+        }
+    };
+    if (await tryFetch(url))
+        return true;
+    if (url.startsWith('http://')) {
+        if (await tryFetch(url.replace('http://', 'https://')))
+            return true;
+    }
+    else if (url.startsWith('https://')) {
+        if (await tryFetch(url.replace('https://', 'http://')))
+            return true;
+    }
+    // One lenient retry: heavy compounds can miss a single 4s window at cold connect.
+    await new Promise((r) => setTimeout(r, 500));
+    return tryFetch(url);
+}
+/** Build the health-probe set from the configured endpoints. Remote endpoints
+ *  probe the public authenticated edges they actually use (gateway/identity/mcp)
+ *  instead of 127.0.0.1, which is unreachable from a real remote node. */
+export function buildProbes(config) {
+    const strip = (u) => u.replace(/\/+$/, '');
+    const isRemote = config.requireAuth || !/127\.0\.0\.1|localhost/.test(config.genesisUrl);
+    if (isRemote) {
+        const probes = [
+            { name: 'Gateway', url: `${strip(config.genesisUrl)}/health` },
+            { name: 'Identity', url: `${strip(config.identityUrl)}/health` },
+        ];
+        if (config.mcpUrl)
+            probes.push({ name: 'MCP', url: `${strip(config.mcpUrl)}/health` });
+        const msUrl = process.env.AITHER_LLM_URL;
+        if (msUrl)
+            probes.push({ name: 'MicroScheduler', url: `${strip(msUrl)}/health` });
+        return probes;
+    }
+    const probes = [
+        { name: 'Genesis', url: 'https://127.0.0.1:8001/health' },
+        { name: 'Node', url: 'https://127.0.0.1:8090/health' },
+        { name: 'Pulse', url: 'https://127.0.0.1:8081/health' },
+        { name: 'MicroScheduler', url: 'https://127.0.0.1:8150/health' },
+        { name: 'Identity', url: 'https://127.0.0.1:8115/health' },
+        { name: 'Secrets', url: 'https://127.0.0.1:8111/health' },
+        { name: 'Chronicle', url: 'https://127.0.0.1:8121/health' },
+        { name: 'Strata', url: 'https://127.0.0.1:8136/health' },
+    ];
+    const msUrl = process.env.AITHER_LLM_URL || 'https://127.0.0.1:8150';
+    probes.find(p => p.name === 'MicroScheduler').url = `${msUrl}/health`;
+    return probes;
+}
+/** Friendly location label for an LLM backend id (from the MS snapshot). */
+const _BACKEND_WHERE = {
+    vllm: 'vLLM (local)',
+    vllm_orchestrator: 'vLLM (local)',
+    vllm_coding: 'vLLM (local)',
+    vllm_swap: 'vLLM swap (local)',
+    vllm_reasoning: 'vLLM reasoning (local)',
+    vllm_dgx: 'DGX Spark',
+    vllm_dgx_orch: 'DGX Spark',
+    vllm_dgx_swap: 'DGX Spark (swap)',
+    deepseek_api: 'DeepSeek (cloud)',
+};
+/** Pick the model the orchestrator path is actually serving + where, from the
+ *  MicroScheduler /llm/backends/snapshot. Prefers the local orchestrator vLLM
+ *  and the tuned LoRA (the live default), so the banner names the real model. */
+export function pickServingModel(backends) {
+    const order = ['vllm', 'vllm_orchestrator', 'vllm_coding', 'vllm_dgx'];
+    for (const id of order) {
+        const b = backends[id];
+        if (b?.healthy && Array.isArray(b.models) && b.models.length) {
+            const models = b.models;
+            const model = models.find((m) => /tuned/i.test(m))
+                || models.find((m) => /orchestrator/i.test(m))
+                || models[0];
+            return { model, where: _BACKEND_WHERE[id] || id };
+        }
+    }
+    for (const [id, b] of Object.entries(backends)) {
+        if (b?.healthy && Array.isArray(b.models) && b.models.length) {
+            return { model: b.models[0], where: _BACKEND_WHERE[id] || id };
+        }
+    }
+    return null;
+}
+/** Gather a full live status snapshot. Every sub-fetch degrades to null/empty —
+ *  never throws — so a partial fleet still produces a useful banner. */
+export async function gatherStatus(client, config) {
+    const backend = await client.detectBackend().catch(() => null);
+    const host = (() => {
+        try {
+            return new URL(config.genesisUrl).host;
+        }
+        catch {
+            return config.genesisUrl;
+        }
+    })();
+    const info = {
+        genesisHost: host,
+        online: !!backend && backend.type !== 'unknown',
+        backendType: backend?.type || 'unknown',
+        backendName: backend?.name || 'offline',
+        services: backend?.services,
+        agents: backend?.agents,
+        serviceLines: [],
+    };
+    const probes = buildProbes(config);
+    const [status, reasoning, snapshot, probeResults] = await Promise.all([
+        client.getStatus().catch(() => null),
+        client.get('/reasoning/status').catch(() => null),
+        client.getBackendSnapshot().catch(() => null),
+        Promise.all(probes.map(async (p) => ({ name: p.name, up: await probeHealth(p.url) }))),
+    ]);
+    info.serviceLines = probeResults;
+    // Re-probe anything that looked down with a much more patient timeout. At
+    // launch the fleet is under cold-start load (model warmup + 250+ services), and
+    // heavy compounds — notably SecurityCore serving Identity — routinely miss the
+    // first 4s window and get false-flagged DOWN even though they answer a second
+    // later. This runs only when something looked down, so an all-up fleet stays fast.
+    const downNames = info.serviceLines.filter(s => !s.up).map(s => s.name);
+    if (downNames.length) {
+        await Promise.all(downNames.map(async (name) => {
+            const probe = probes.find(p => p.name === name);
+            if (probe && await probeHealth(probe.url, 9000)) {
+                const sl = info.serviceLines.find(s => s.name === name);
+                if (sl)
+                    sl.up = true;
+            }
+        }));
+    }
+    // A successful /status (or /reasoning, or the MS snapshot) is PROOF we're
+    // connected to a live Genesis — even when detectBackend()'s /health-shape
+    // heuristic mis-classifies it as "unknown/offline" (Genesis minimal-mode health
+    // doesn't carry generation_ready/tracked_services). Trust the live data over the
+    // probe so the header doesn't say "offline" while showing 258 services + models.
+    if (status || reasoning || snapshot) {
+        info.online = true;
+        if (info.backendType === 'unknown')
+            info.backendType = 'genesis';
+        if (!info.backendName || info.backendName === 'offline')
+            info.backendName = 'Genesis';
+    }
+    // The endpoint we're talking to is UP by definition — a concurrent health probe
+    // can still flake (cold-start load, http-vs-https first try, the warmup hammering
+    // the box), which would otherwise show the absurd "DOWN: Genesis".
+    if (info.online) {
+        const connectedNames = info.backendType === 'genesis'
+            ? ['Genesis', 'Gateway']
+            : [info.backendName, 'Gateway'];
+        for (const sl of info.serviceLines) {
+            if (connectedNames.includes(sl.name))
+                sl.up = true;
+        }
+    }
+    if (status) {
+        info.health = status.health || (info.online ? 'healthy' : undefined);
+        info.version = status.version;
+        if (info.services == null)
+            info.services = status.tracked_services ?? status.count;
+    }
+    if (reasoning && !reasoning.error) {
+        const slots = (reasoning.routing?.model_slots || {});
+        info.orchestratorModel = slots.model || reasoning.model;
+        info.reasoningModel = slots.reasoning_model;
+        info.profile = reasoning.display_name || reasoning.active_profile;
+        info.isLocal = !(reasoning.cost_per_1k_tokens > 0);
+    }
+    if (snapshot?.backends) {
+        const pick = pickServingModel(snapshot.backends);
+        if (pick)
+            info.serving = `${pick.model} @ ${pick.where}`;
+    }
+    if (snapshot?.pool) {
+        info.poolFree = snapshot.pool.available_for_user ?? snapshot.pool.available;
+        info.poolTotal = snapshot.pool.total_slots ?? snapshot.pool.total;
+    }
+    return info;
+}
+/** Compact, aligned status lines for the in-TUI welcome (plain strings with
+ *  chalk colour — caller pushes them through surface.outputLine). */
+export function formatStatusLines(info) {
+    const lines = [];
+    const dot = info.online ? chalk.green('●') : chalk.red('●');
+    const healthStr = info.online
+        ? (info.health === 'ok' || info.health === 'healthy' ? chalk.green('healthy') : chalk.yellow(info.health || 'up'))
+        : chalk.red('offline');
+    const head = [
+        `${dot} ${chalk.bold(info.backendName || 'Genesis')} ${chalk.dim('@ ' + info.genesisHost)}`,
+        healthStr + (info.version ? chalk.dim(` v${info.version}`) : ''),
+        info.services != null ? chalk.dim(`${info.services} services`) : null,
+        info.agents != null ? chalk.dim(`${info.agents} agents`) : null,
+        info.poolTotal != null ? chalk.dim(`pool ${info.poolFree ?? '?'}/${info.poolTotal}`) : null,
+    ].filter(Boolean);
+    lines.push('  ' + head.join(chalk.dim(' · ')));
+    if (info.orchestratorModel || info.reasoningModel) {
+        const locTag = info.isLocal === false ? chalk.yellow(' (cloud)') : info.isLocal ? chalk.green(' (local)') : '';
+        const m = [
+            info.orchestratorModel ? `${chalk.dim('orchestrator')} ${chalk.cyan(info.orchestratorModel)}` : null,
+            info.reasoningModel ? `${chalk.dim('reasoning')} ${chalk.cyan(info.reasoningModel)}` : null,
+            info.profile ? chalk.dim(info.profile) + locTag : null,
+        ].filter(Boolean);
+        lines.push('  ' + chalk.bold('Models'.padEnd(8)) + m.join(chalk.dim(' · ')));
+    }
+    if (info.serving) {
+        lines.push('  ' + chalk.bold('Serving'.padEnd(8)) + chalk.cyan(info.serving));
+    }
+    const up = info.serviceLines.filter(s => s.up).map(s => s.name);
+    const dn = info.serviceLines.filter(s => !s.up).map(s => s.name);
+    if (up.length)
+        lines.push('  ' + chalk.dim('UP'.padEnd(8)) + chalk.green(up.join(', ')));
+    if (dn.length)
+        lines.push('  ' + chalk.dim('DOWN'.padEnd(8)) + chalk.red(dn.join(', ')));
+    return lines;
+}

package/dist/tui/controller.d.ts

@@ -0,0 +1,3 @@
+import { type StreamRenderer } from '../renderer.js';
+import type { TuiSurface } from './screen.js';
+export declare function createTuiRenderer(surface: TuiSurface, sessionId?: string, prompt?: string): StreamRenderer;

package/dist/tui/controller.js

@@ -0,0 +1,310 @@
+/**
+ * TUI stream renderer — same shape as the plain `createStreamRenderer`, but
+ * routes events into the blessed 3-pane surface instead of stdout.
+ *
+ *   • TRACE pane  ← pipeline telemetry + tool results (formatters.formatTrace)
+ *   • OUTPUT pane ← answer segments, tokens, then a markdown re-render on complete
+ *   • STATUS line ← agent · model · E{effort} · {stage} · elapsed (composed live)
+ */
+import chalk from 'chalk';
+import { renderMarkdown, stripOsc8, autoOpenImagesFromText } from '../renderer.js';
+import { formatStatus, formatTrace, statusUpdate } from '../formatters.js';
+export function createTuiRenderer(surface, sessionId, prompt) {
+    let content = '';
+    let tokenStreamed = false;
+    let eagerActive = false;
+    let completePrinted = false;
+    let terminalSeen = false; // complete/error/timeout/interrupt reached us
+    let answerCheckpoint = null; // OUTPUT offset where the answer text begins
+    const traceEvents = [];
+    const toolCalls = [];
+    const thinking = [];
+    const errors = [];
+    let model = '';
+    let agent = '';
+    let effort = '';
+    let tier = '';
+    let stage = '';
+    const startedAt = new Date().toISOString();
+    const startTime = Date.now();
+    function pushStatus() {
+        const elapsed = `${((Date.now() - startTime) / 1000).toFixed(0)}s`;
+        const bits = [agent || 'aither', model || '…', effort ? `E${effort}` : '', tier, stage, elapsed]
+            .filter(Boolean).join(' · ');
+        surface.setStatus(bits);
+    }
+    function header(kind, reason) {
+        const r = reason ? chalk.dim(`  (${reason})`) : '';
+        if (kind === 'continuation')
+            return chalk.cyan('↳ Continuing') + r;
+        if (kind === 'refinement')
+            return chalk.cyan('↻ Refining') + r;
+        return chalk.cyan('💬 Initial') + r;
+    }
+    /** Summarize a tool_result into the TRACE pane (keeps OUTPUT answer-only). */
+    function traceToolResult(result) {
+        const name = result.tool || 'tool';
+        const ok = result.success !== false;
+        const icon = ok ? chalk.green('✓') : chalk.red('✗');
+        if (ok && result.output) {
+            try {
+                const parsed = JSON.parse(result.output);
+                if (Array.isArray(parsed.results) && parsed.results.length) {
+                    surface.traceLine(`  ${icon} ${chalk.bold(name)} — ${parsed.results.length} results`);
+                    parsed.results.slice(0, 3).forEach((r, i) => surface.traceLine(chalk.dim(`     ${i + 1}. ${String(r.title || r.url || 'result').slice(0, 50)}`)));
+                }
+                else if (parsed.content) {
+                    surface.traceLine(`  ${icon} ${chalk.bold(name)} ${chalk.dim(String(parsed.title || '').slice(0, 40))}`);
+                }
+                else {
+                    surface.traceLine(`  ${icon} ${chalk.bold(name)} ${chalk.dim(JSON.stringify(parsed).slice(0, 60))}`);
+                }
+            }
+            catch {
+                surface.traceLine(`  ${icon} ${chalk.bold(name)} ${chalk.dim(String(result.output).replace(/\s+/g, ' ').slice(0, 60))}`);
+            }
+        }
+        else if (!ok) {
+            surface.traceLine(`  ${icon} ${chalk.bold(name)} ${chalk.red(String(result.output || result.error || 'error').slice(0, 50))}`);
+        }
+        else {
+            surface.traceLine(`  ${icon} ${name}`);
+        }
+    }
+    return {
+        onEvent(event) {
+            traceEvents.push(event);
+            const d = event.data || {};
+            const su = statusUpdate(event);
+            if (su.agent)
+                agent = su.agent;
+            const _realModel = (m) => typeof m === 'string' && m && m !== 'auto' && m !== 'unknown';
+            if (_realModel(su.model))
+                model = su.model;
+            // Generic capture: any event that carries a real model id (model_select,
+            // llm_route, llm_done, plan) sets it — so the footer isn't 'unknown'.
+            else if (_realModel(d.model))
+                model = d.model;
+            else if (_realModel(d.model_used))
+                model = d.model_used;
+            if (su.effort)
+                effort = su.effort;
+            if (su.tier)
+                tier = su.tier;
+            const st = formatStatus(event);
+            if (st)
+                stage = st;
+            pushStatus();
+            switch (event.type) {
+                case 'session_start':
+                    if (d.agent)
+                        agent = d.agent;
+                    if (d.model && d.model !== 'auto' && d.model !== 'unknown')
+                        model = d.model;
+                    break;
+                case 'answer_segment':
+                    eagerActive = true;
+                    surface.outputLine(header(d.kind || 'initial', d.reason));
+                    tokenStreamed = false;
+                    break;
+                case 'token': {
+                    const t = d.t || d.token || '';
+                    if (t) {
+                        if (answerCheckpoint == null)
+                            answerCheckpoint = surface.markCheckpoint();
+                        surface.appendOutput(t);
+                        content += t;
+                        tokenStreamed = true;
+                    }
+                    break;
+                }
+                case 'segment_end':
+                    surface.appendOutput('\n');
+                    break;
+                case 'partial':
+                    if (!tokenStreamed && d.content) {
+                        if (answerCheckpoint == null)
+                            answerCheckpoint = surface.markCheckpoint();
+                        surface.appendOutput(String(d.content));
+                    }
+                    break;
+                case 'message':
+                case 'answer':
+                case 'final_answer': {
+                    const text = d.answer || d.content || d.message || '';
+                    if (!eagerActive && !tokenStreamed && text) {
+                        if (answerCheckpoint == null)
+                            answerCheckpoint = surface.markCheckpoint();
+                        surface.appendOutput(String(text));
+                        content += String(text);
+                    }
+                    else if (text) {
+                        // The grounded follow-up answer (ran tools + gathered context) arrives
+                        // here AFTER the eager fast-pass streamed. It supersedes that throwaway
+                        // preview — capture it so `complete` re-renders the authoritative answer
+                        // (replaceOutputFrom) instead of leaving the weak first pass on screen.
+                        // Matches renderer.ts (the plain REPL) which does `content = data.answer`.
+                        content = String(text);
+                    }
+                    break;
+                }
+                case 'thinking': {
+                    const thought = d.thought || d.content || '';
+                    if (thought)
+                        thinking.push(String(thought));
+                    break;
+                }
+                case 'tool_call': {
+                    const tools = d.tools || d.tool_calls || [];
+                    for (const tool of tools) {
+                        const name = tool.name || tool.function?.name || 'tool';
+                        const args = tool.args || tool.arguments;
+                        toolCalls.push({ name, args: args || {}, timestamp: Date.now() });
+                        let arg = '';
+                        if (args) {
+                            const key = args.query || args.url || args.task || args.prompt || args.path || args.code;
+                            arg = key ? chalk.dim(` → ${String(key).slice(0, 60)}`) : '';
+                        }
+                        surface.traceLine(chalk.yellow(`  ⚡ ${name}`) + arg);
+                    }
+                    break;
+                }
+                case 'tool_result':
+                    for (const r of (d.results || []))
+                        traceToolResult(r);
+                    break;
+                case 'artifact_delivered': {
+                    const fn = d.filename || d.file || d.path || 'artifact';
+                    const idx = d.index != null ? ` (/get ${d.index})` : '';
+                    surface.outputLine(chalk.cyan(`📦 ${fn}`) + chalk.dim(idx));
+                    break;
+                }
+                case 'clarification_needed':
+                case 'approval_required': {
+                    const q = Array.isArray(d.questions)
+                        ? d.questions.map((x) => (typeof x === 'string' ? x : x.question || x.text || '?')).join('  •  ')
+                        : (d.action || d.message || '');
+                    surface.outputLine(chalk.yellow(`⏸ ${event.type === 'approval_required' ? 'Approval' : 'Clarify'}: `) + q);
+                    break;
+                }
+                case 'image_gen_complete':
+                    surface.outputLine(chalk.green('✓ image: ') + chalk.dim(d.url || d.path || ''));
+                    break;
+                case 'error':
+                case 'llm_error': {
+                    terminalSeen = true;
+                    const msg = d.message || d.error || 'error';
+                    errors.push(String(msg));
+                    surface.outputLine(chalk.red('✗ ' + msg));
+                    {
+                        const line = formatTrace(event);
+                        if (line)
+                            surface.traceLine(line);
+                    }
+                    surface.finishTraceTurn('error');
+                    break;
+                }
+                case 'stream_timeout':
+                case 'stream_interrupted': {
+                    // The transport died mid-turn (backend/LB restart, network reset) or
+                    // went silent past the chunk timeout. Without this case the turn was
+                    // stamped ✓ done and the grounded follow-up answer vanished — say so.
+                    terminalSeen = true;
+                    const why = event.type === 'stream_timeout'
+                        ? `no data for ${Math.round((Number(d.timeout_ms) || 120000) / 1000)}s`
+                        : String(d.error || 'connection lost');
+                    errors.push(`stream ${event.type === 'stream_timeout' ? 'timeout' : 'interrupted'}: ${why}`);
+                    surface.outputLine(chalk.yellow(`⚠ stream ${event.type === 'stream_timeout' ? 'timed out' : 'interrupted'} — ${why}`));
+                    surface.outputLine(chalk.dim('  The backend connection dropped mid-turn (Genesis/LB restart?) — any text above is partial.'));
+                    surface.finishTraceTurn('error');
+                    break;
+                }
+                case 'llm_done':
+                case 'llm_end':
+                    if (_realModel(d.model_used))
+                        model = d.model_used;
+                    else if (_realModel(d.model))
+                        model = d.model;
+                    {
+                        const line = formatTrace(event);
+                        if (line)
+                            surface.traceLine(line);
+                    }
+                    break;
+                case 'complete':
+                case 'done': {
+                    terminalSeen = true;
+                    if (completePrinted)
+                        break;
+                    completePrinted = true;
+                    // Don't let a terminal 'unknown'/'auto' clobber the model we already saw.
+                    if (d.model && d.model !== 'unknown' && d.model !== 'auto')
+                        model = d.model;
+                    // Defensive: if the terminal event itself carries the authoritative
+                    // answer (and no separate `answer` event landed), prefer it over the
+                    // eager fast-pass so the grounded result is what gets rendered.
+                    {
+                        const fin = d.answer || d.response || d.content || '';
+                        if (fin)
+                            content = String(fin);
+                    }
+                    // Replace the streamed raw answer with a markdown render (code blocks
+                    // etc.). stripOsc8: blessed can't render OSC-8 hyperlinks (they show as
+                    // raw `]8;;…`), so flatten them to plain text in the TUI.
+                    if (content && answerCheckpoint != null) {
+                        surface.replaceOutputFrom(answerCheckpoint, '\n' + stripOsc8(renderMarkdown(content)).replace(/\n$/, ''));
+                    }
+                    else if (content && answerCheckpoint == null) {
+                        surface.outputLine(stripOsc8(renderMarkdown(content)).replace(/\n$/, ''));
+                    }
+                    const ms = d.duration_ms != null ? `${(Number(d.duration_ms) / 1000).toFixed(1)}s` : '';
+                    surface.outputLine(chalk.dim(`── ${[agent, model, ms].filter(Boolean).join(' · ')}`));
+                    autoOpenImagesFromText(content); // pop generated images in the OS viewer
+                    surface.finishTraceTurn('done');
+                    break;
+                }
+                case 'heartbeat':
+                case 'keepalive':
+                case 'debug':
+                case 'thinking_end':
+                    break;
+                default: {
+                    const line = formatTrace(event);
+                    if (line)
+                        surface.traceLine(line);
+                }
+            }
+        },
+        getContent() { return content; },
+        finish(aborted) {
+            surface.appendOutput('\n');
+            if (aborted) {
+                surface.finishTraceTurn('error');
+            }
+            else if (!terminalSeen) {
+                // Stream EOF'd with no complete/error/timeout event at all — a clean
+                // TCP close from a backend that died mid-turn looks exactly like this.
+                // Marking it ✓ done hid the loss; flag it so the user knows to resend.
+                surface.outputLine(chalk.yellow('⚠ stream ended before completion — the connection closed mid-turn.'));
+                surface.outputLine(chalk.dim('  Any text above is partial (the refined answer never arrived).'));
+                errors.push('stream ended before completion (no terminal event)');
+                surface.finishTraceTurn('error');
+            }
+            else {
+                surface.finishTraceTurn('done'); // fallback: stamp the thread if no terminal event fired
+            }
+            stage = '';
+            pushStatus();
+            surface.render();
+        },
+        getTrace() { return traceEvents; },
+        getSessionProfile() {
+            return {
+                session_id: sessionId || '', prompt: prompt || '', started_at: startedAt,
+                duration_ms: Date.now() - startTime, event_count: traceEvents.length,
+                model, agent, events: traceEvents, tool_calls: toolCalls,
+                thinking_traces: thinking, context_sources: {}, errors,
+            };
+        },
+    };
+}

package/dist/tui/repl-tui.d.ts

@@ -0,0 +1,3 @@
+import type { GenesisClient } from '../client.js';
+import type { ShellConfig } from '../config.js';
+export declare function startTuiRepl(client: GenesisClient, config: ShellConfig): Promise<void>;