blyuecode 0.1.17 → 0.3.0

package/dist/core/mcp.js

@@ -0,0 +1,333 @@
+// Minimal MCP client — stdio + HTTP/SSE transports, JSON-RPC 2.0.
+// Spec: https://spec.modelcontextprotocol.io/
+//
+// No external dependencies. Uses Node 20's global fetch for SSE.
+//
+// Usage:
+//   const client = new McpClient(name, config);
+//   await client.connect();
+//   const tools = await client.listTools();
+//   const result = await client.callTool('read_file', { path: '...' });
+//   await client.close();
+import { spawn } from 'child_process';
+import { EventEmitter } from 'events';
+// ──────────────────────────────────────────────────────────────
+// Stdio transport — newline-delimited JSON-RPC over child stdin/stdout
+// ──────────────────────────────────────────────────────────────
+class StdioTransport extends EventEmitter {
+    proc;
+    buf = '';
+    lastStderr = '';
+    get stderrTail() { return this.lastStderr; }
+    constructor(cfg) {
+        super();
+        this.proc = spawn(cfg.command, cfg.args ?? [], {
+            cwd: cfg.cwd,
+            env: { ...process.env, ...(cfg.env ?? {}) },
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        this.proc.stdout?.on('data', (chunk) => {
+            this.buf += chunk.toString('utf8');
+            let idx;
+            while ((idx = this.buf.indexOf('\n')) >= 0) {
+                const line = this.buf.slice(0, idx).trim();
+                this.buf = this.buf.slice(idx + 1);
+                if (!line)
+                    continue;
+                try {
+                    const msg = JSON.parse(line);
+                    this.emit('message', msg);
+                }
+                catch {
+                    // Not JSON — ignore (some servers log to stdout, which is rude
+                    // but happens; stderr is the correct channel for logs).
+                }
+            }
+        });
+        this.proc.stderr?.on('data', (chunk) => {
+            // Servers log readiness banners and diagnostics to stderr — that's
+            // the MCP spec's designated log channel. Never treat stderr as an
+            // error: it would kill the in-flight initialize request. Keep the
+            // last few KB around for debugging, but do nothing else with it.
+            this.lastStderr = (this.lastStderr + chunk.toString('utf8')).slice(-4096);
+        });
+        this.proc.on('error', (err) => this.emit('error', err));
+        this.proc.on('exit', () => this.emit('close'));
+    }
+    send(msg) {
+        if (!this.proc.stdin || this.proc.stdin.destroyed) {
+            throw new Error('stdio transport closed');
+        }
+        this.proc.stdin.write(JSON.stringify(msg) + '\n');
+    }
+    close() {
+        try {
+            this.proc.stdin?.end();
+            this.proc.kill('SIGTERM');
+            // SIGKILL fallback if it doesn't die within 2s.
+            setTimeout(() => {
+                if (this.proc.exitCode === null)
+                    this.proc.kill('SIGKILL');
+            }, 2000).unref?.();
+        }
+        catch {
+            // already dead
+        }
+    }
+}
+// ──────────────────────────────────────────────────────────────
+// SSE transport — POST for sends, GET text/event-stream for receives
+//
+// MCP's HTTP+SSE transport (2024-11-05 spec):
+//   1. GET url -> text/event-stream, server sends an `endpoint` event
+//      with the POST URL to use for requests.
+//   2. POST JSON-RPC requests to that endpoint; responses come back on
+//      the SSE stream as `message` events.
+// ──────────────────────────────────────────────────────────────
+class SseTransport extends EventEmitter {
+    cfg;
+    postUrl = null;
+    abort = null;
+    closed = false;
+    constructor(cfg) {
+        super();
+        this.cfg = cfg;
+        void this.start();
+    }
+    async start() {
+        try {
+            this.abort = new AbortController();
+            const res = await fetch(this.cfg.url, {
+                headers: {
+                    Accept: 'text/event-stream',
+                    ...(this.cfg.headers ?? {}),
+                },
+                signal: this.abort.signal,
+            });
+            if (!res.ok || !res.body) {
+                throw new Error(`SSE connect failed: HTTP ${res.status}`);
+            }
+            const reader = res.body.getReader();
+            const decoder = new TextDecoder();
+            let buf = '';
+            while (!this.closed) {
+                const { value, done } = await reader.read();
+                if (done)
+                    break;
+                buf += decoder.decode(value, { stream: true });
+                let idx;
+                while ((idx = buf.indexOf('\n\n')) >= 0) {
+                    const rawEvent = buf.slice(0, idx);
+                    buf = buf.slice(idx + 2);
+                    this.parseEvent(rawEvent);
+                }
+            }
+            this.emit('close');
+        }
+        catch (err) {
+            if (!this.closed)
+                this.emit('error', err);
+        }
+    }
+    parseEvent(raw) {
+        let event = 'message';
+        let data = '';
+        for (const line of raw.split('\n')) {
+            if (line.startsWith('event:'))
+                event = line.slice(6).trim();
+            else if (line.startsWith('data:'))
+                data += line.slice(5).trim();
+        }
+        if (!data)
+            return;
+        if (event === 'endpoint') {
+            // Server tells us where to POST. Relative URLs are resolved against
+            // the SSE endpoint's origin.
+            try {
+                this.postUrl = new URL(data, this.cfg.url).toString();
+            }
+            catch {
+                this.postUrl = data;
+            }
+            return;
+        }
+        if (event === 'message') {
+            try {
+                const msg = JSON.parse(data);
+                this.emit('message', msg);
+            }
+            catch {
+                // ignore malformed
+            }
+        }
+    }
+    send(msg) {
+        if (!this.postUrl) {
+            throw new Error('SSE transport not ready — no endpoint event received yet');
+        }
+        void fetch(this.postUrl, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                ...(this.cfg.headers ?? {}),
+            },
+            body: JSON.stringify(msg),
+        }).catch((err) => this.emit('error', err));
+    }
+    close() {
+        this.closed = true;
+        this.abort?.abort();
+    }
+}
+// ──────────────────────────────────────────────────────────────
+// Client
+// ──────────────────────────────────────────────────────────────
+export class McpClient {
+    name;
+    cfg;
+    transport = null;
+    nextId = 1;
+    pending = new Map();
+    connected = false;
+    serverInfo = null;
+    cachedTools = null;
+    constructor(name, cfg) {
+        this.name = name;
+        this.cfg = cfg;
+    }
+    get autoAllow() {
+        return this.cfg.autoAllow === true;
+    }
+    get info() {
+        return this.serverInfo;
+    }
+    async connect() {
+        if (this.connected)
+            return;
+        this.transport =
+            'command' in this.cfg
+                ? new StdioTransport(this.cfg)
+                : new SseTransport(this.cfg);
+        this.transport.on('message', (msg) => this.handleMessage(msg));
+        this.transport.on('error', (err) => {
+            // Route transport errors to any in-flight request so they don't hang.
+            for (const [, p] of this.pending) {
+                clearTimeout(p.timer);
+                p.reject(err);
+            }
+            this.pending.clear();
+        });
+        this.transport.on('close', () => {
+            this.connected = false;
+        });
+        // Handshake
+        const result = (await this.request('initialize', {
+            protocolVersion: '2024-11-05',
+            capabilities: { tools: {} },
+            clientInfo: { name: 'blyue', version: '0.2.0' },
+        }));
+        this.serverInfo = result?.serverInfo ?? null;
+        // Spec requires this notification after initialize.
+        this.notify('notifications/initialized', {});
+        this.connected = true;
+    }
+    async listTools() {
+        if (this.cachedTools)
+            return this.cachedTools;
+        const res = (await this.request('tools/list', {}));
+        this.cachedTools = res?.tools ?? [];
+        return this.cachedTools;
+    }
+    async callTool(name, args) {
+        const res = (await this.request('tools/call', {
+            name,
+            arguments: args,
+        }));
+        return res;
+    }
+    async close() {
+        for (const [, p] of this.pending) {
+            clearTimeout(p.timer);
+            p.reject(new Error('client closed'));
+        }
+        this.pending.clear();
+        this.transport?.close();
+        this.transport = null;
+        this.connected = false;
+        this.cachedTools = null;
+    }
+    // ────────────────────────────────────────────
+    handleMessage(msg) {
+        if ('id' in msg && msg.id !== undefined) {
+            const p = this.pending.get(msg.id);
+            if (!p)
+                return;
+            this.pending.delete(msg.id);
+            clearTimeout(p.timer);
+            if (msg.error) {
+                p.reject(new Error(`${msg.error.code}: ${msg.error.message}`));
+            }
+            else {
+                p.resolve(msg.result);
+            }
+            return;
+        }
+        // Notifications from server (e.g. tools/list_changed) — currently ignored.
+    }
+    request(method, params) {
+        if (!this.transport)
+            throw new Error('not connected');
+        const id = this.nextId++;
+        const timeoutMs = ('timeoutMs' in this.cfg ? this.cfg.timeoutMs : undefined) ?? 60_000;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`MCP request "${method}" timed out after ${timeoutMs}ms`));
+            }, timeoutMs);
+            this.pending.set(id, { resolve, reject, timer });
+            try {
+                this.transport.send({ jsonrpc: '2.0', id, method, params });
+            }
+            catch (err) {
+                clearTimeout(timer);
+                this.pending.delete(id);
+                reject(err);
+            }
+        });
+    }
+    notify(method, params) {
+        if (!this.transport)
+            return;
+        this.transport.send({ jsonrpc: '2.0', method, params });
+    }
+}
+// ──────────────────────────────────────────────────────────────
+// Config load / save
+// ──────────────────────────────────────────────────────────────
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
+import { homedir } from 'os';
+import { join, dirname } from 'path';
+export function mcpConfigPath() {
+    return join(homedir(), '.blyue', 'mcp.json');
+}
+export function loadMcpConfig() {
+    const p = mcpConfigPath();
+    if (!existsSync(p))
+        return { servers: {} };
+    try {
+        const raw = readFileSync(p, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (!parsed.servers || typeof parsed.servers !== 'object') {
+            return { servers: {} };
+        }
+        return parsed;
+    }
+    catch (err) {
+        throw new Error(`Failed to parse ${p}: ${err.message}`);
+    }
+}
+export function saveMcpConfig(cfg) {
+    const p = mcpConfigPath();
+    mkdirSync(dirname(p), { recursive: true });
+    writeFileSync(p, JSON.stringify(cfg, null, 2) + '\n', 'utf8');
+}

package/dist/core/mcpRegistry.js

@@ -0,0 +1,188 @@
+// MCP registry — holds all connected MCP clients as a module-level
+// singleton so the tools layer can merge their tool defs into the LLM's
+// tool list without threading state through the agent.
+//
+// Lifecycle:
+//   1. index.tsx calls initMcpRegistry() once after config load
+//   2. tools.ts calls getMcpToolDefsSync() every agent-loop iteration
+//   3. agent calls executeTool() → falls through to executeMcpTool()
+//      for names prefixed mcp__<server>__<tool>
+import { McpClient, loadMcpConfig, } from './mcp.js';
+import { permissions } from './permission.js';
+const servers = new Map();
+let cachedDefs = [];
+let initPromise = null;
+let initialized = false;
+/**
+ * Called once on app startup, after config is loaded.
+ * Never throws — a bad MCP server is logged and skipped so the TUI
+ * still boots. (Failing closed here would make a typo in mcp.json
+ * brick the whole app.)
+ */
+export async function initMcpRegistry() {
+    if (initPromise)
+        return initPromise;
+    initPromise = (async () => {
+        let cfg;
+        try {
+            cfg = loadMcpConfig();
+        }
+        catch {
+            initialized = true;
+            return;
+        }
+        const entries = Object.entries(cfg.servers || {});
+        if (entries.length === 0) {
+            initialized = true;
+            return;
+        }
+        await Promise.all(entries.map(async ([name, serverCfg]) => {
+            const client = new McpClient(name, serverCfg);
+            try {
+                await client.connect();
+                const tools = await client.listTools();
+                servers.set(name, { client, tools });
+            }
+            catch (err) {
+                servers.set(name, {
+                    client,
+                    tools: [],
+                    error: err.message,
+                });
+                try {
+                    await client.close();
+                }
+                catch { }
+            }
+        }));
+        rebuildDefs();
+        initialized = true;
+    })();
+    return initPromise;
+}
+function rebuildDefs() {
+    const defs = [];
+    for (const [serverName, state] of servers) {
+        if (state.error)
+            continue;
+        for (const t of state.tools) {
+            defs.push({
+                type: 'function',
+                function: {
+                    name: `mcp__${serverName}__${t.name}`,
+                    description: t.description ||
+                        `MCP tool "${t.name}" from server "${serverName}".`,
+                    parameters: t.schema || { type: 'object', properties: {} },
+                },
+            });
+        }
+    }
+    cachedDefs = defs;
+}
+/** Synchronous — safe to call every iteration of the agent loop. */
+export function getMcpToolDefsSync() {
+    return cachedDefs;
+}
+export function isMcpTool(name) {
+    return typeof name === 'string' && name.startsWith('mcp__');
+}
+export function parseMcpToolName(fullName) {
+    if (!isMcpTool(fullName))
+        return null;
+    const rest = fullName.slice('mcp__'.length);
+    const idx = rest.indexOf('__');
+    if (idx < 0)
+        return null;
+    return { server: rest.slice(0, idx), tool: rest.slice(idx + 2) };
+}
+/**
+ * Executes an MCP tool call. Routes through the permission broker
+ * unless the server is marked autoAllow:true in mcp.json.
+ */
+export async function executeMcpTool(fullName, args) {
+    const parsed = parseMcpToolName(fullName);
+    if (!parsed)
+        return `Error: not an MCP tool: ${fullName}`;
+    const state = servers.get(parsed.server);
+    if (!state)
+        return `Error: MCP server "${parsed.server}" not registered`;
+    if (state.error) {
+        return `Error: MCP server "${parsed.server}" failed to connect: ${state.error}`;
+    }
+    const { client } = state;
+    const alreadyAllowed = permissions.isAlwaysAllowed(fullName);
+    if (!client.autoAllow && !alreadyAllowed) {
+        const argSummary = safeJson(args).slice(0, 400);
+        const answer = await permissions.ask({
+            tool: fullName,
+            title: `MCP · ${parsed.server}`,
+            body: [
+                `Tool: ${parsed.tool}`,
+                `Args: ${argSummary || '(none)'}`,
+            ],
+            danger: 'medium',
+        });
+        if (answer === 'no')
+            return `Denied by user: ${fullName}`;
+    }
+    try {
+        const result = await client.callTool(parsed.tool, args || {});
+        return formatResult(result);
+    }
+    catch (err) {
+        return `MCP error: ${err.message}`;
+    }
+}
+function formatResult(result) {
+    if (!result || !Array.isArray(result.content)) {
+        return safeJson(result);
+    }
+    const parts = [];
+    for (const c of result.content) {
+        if (c.type === 'text')
+            parts.push(c.text);
+        else if (c.type === 'image')
+            parts.push(`[image ${c.mimeType}, ${c.data.length} base64 chars]`);
+        else if (c.type === 'resource')
+            parts.push(c.resource.text ??
+                `[resource ${c.resource.uri}${c.resource.blob ? ', blob' : ''}]`);
+    }
+    const text = parts.join('\n');
+    return result.isError ? `ERROR: ${text}` : text;
+}
+function safeJson(v) {
+    try {
+        return JSON.stringify(v);
+    }
+    catch {
+        return String(v);
+    }
+}
+export function listMcpServers() {
+    const out = [];
+    for (const [name, state] of servers) {
+        out.push({
+            name,
+            autoAllow: state.client.autoAllow,
+            toolCount: state.tools.length,
+            toolNames: state.tools.map((t) => t.name),
+            error: state.error,
+        });
+    }
+    return out;
+}
+export function isMcpReady() {
+    return initialized;
+}
+export async function closeAllMcp() {
+    for (const [, state] of servers) {
+        try {
+            await state.client.close();
+        }
+        catch { }
+    }
+    servers.clear();
+    cachedDefs = [];
+    initPromise = null;
+    initialized = false;
+}

package/dist/core/models.js

@@ -0,0 +1,150 @@
+// Universal model fetcher — works with any OpenAI-compatible /v1/models
+// endpoint: OpenAI, OpenRouter, Groq, xAI (Grok), Ollama, LM Studio,
+// llama.cpp, vLLM, together, deepseek, etc.
+const CACHE_TTL_MS = 5 * 60 * 1000;
+let cache = null;
+function currentBaseUrl() {
+    const raw = process.env.OPENAI_BASE_URL ||
+        process.env.OPENAI_API_BASE ||
+        'https://api.openai.com/v1';
+    // Strip trailing slash for consistent concat.
+    return raw.replace(/\/+$/, '');
+}
+function currentApiKey() {
+    return process.env.OPENAI_API_KEY || process.env.API_KEY || '';
+}
+function providerLabel(baseUrl) {
+    const u = baseUrl.toLowerCase();
+    if (u.includes('openrouter'))
+        return 'OpenRouter';
+    if (u.includes('api.x.ai'))
+        return 'xAI';
+    if (u.includes('groq.com'))
+        return 'Groq';
+    if (u.includes('api.openai.com'))
+        return 'OpenAI';
+    if (u.includes('api.deepseek.com'))
+        return 'DeepSeek';
+    if (u.includes('api.together'))
+        return 'Together';
+    if (u.includes('localhost') || u.includes('127.0.0.1'))
+        return 'local';
+    // Fall back to the hostname.
+    try {
+        return new URL(baseUrl).host;
+    }
+    catch {
+        return 'provider';
+    }
+}
+export function currentProviderLabel() {
+    return providerLabel(currentBaseUrl());
+}
+/**
+ * Non-chat models we should hide from the picker. Conservative — better
+ * to show a couple of extras than to hide something the user wants.
+ */
+function isChatModel(id) {
+    const l = id.toLowerCase();
+    const block = [
+        'embed',
+        'embedding',
+        'whisper',
+        '-tts',
+        'tts-',
+        'dall-e',
+        'dalle',
+        'moderation',
+        'realtime',
+        'transcribe',
+        '-audio',
+        'audio-',
+        'image-',
+        '-vision-preview',
+        'davinci',
+        'babbage',
+        'curie',
+        'ada-',
+    ];
+    return !block.some((b) => l.includes(b));
+}
+function parseNumber(v) {
+    if (v === undefined)
+        return undefined;
+    const n = typeof v === 'string' ? parseFloat(v) : v;
+    return Number.isFinite(n) ? n : undefined;
+}
+/**
+ * Fetches the model list from the current provider. Cached for 5 minutes
+ * per base URL, so reopening /model is instant but "new models" surface
+ * within one cache window.
+ */
+export async function fetchModels(opts) {
+    const baseUrl = currentBaseUrl();
+    const url = baseUrl + '/models';
+    if (!opts?.force &&
+        cache &&
+        cache.url === url &&
+        Date.now() - cache.at < CACHE_TTL_MS) {
+        return cache.models;
+    }
+    const headers = { Accept: 'application/json' };
+    const key = currentApiKey();
+    if (key)
+        headers.Authorization = `Bearer ${key}`;
+    let res;
+    try {
+        res = await fetch(url, { headers });
+    }
+    catch (err) {
+        throw new Error(`Could not reach ${url}: ${err.message}. ` +
+            `Is the provider reachable and the base URL correct?`);
+    }
+    if (!res.ok) {
+        throw new Error(`${url} returned HTTP ${res.status} ${res.statusText}. ` +
+            `Check your API key and base URL in /settings.`);
+    }
+    const body = (await res.json());
+    const raw = Array.isArray(body) ? body : body.data ?? [];
+    const models = raw
+        .map((m) => {
+        const id = m.id || m.name;
+        if (!id)
+            return null;
+        const prompt = parseNumber(m.pricing?.prompt);
+        const completion = parseNumber(m.pricing?.completion);
+        const isFree = prompt !== undefined &&
+            completion !== undefined &&
+            prompt === 0 &&
+            completion === 0;
+        return {
+            id,
+            contextLength: m.context_length ?? m.context_window,
+            ownedBy: m.owned_by,
+            pricing: prompt !== undefined && completion !== undefined
+                ? { prompt, completion }
+                : undefined,
+            isFree,
+        };
+    })
+        .filter((m) => m !== null)
+        .filter((m) => isChatModel(m.id));
+    // Sort: free first, then alphabetical. (OpenRouter returns them in
+    // arbitrary order; this makes the useful ones surface at the top.)
+    models.sort((a, b) => {
+        if (!!a.isFree !== !!b.isFree)
+            return a.isFree ? -1 : 1;
+        return a.id.localeCompare(b.id);
+    });
+    cache = { at: Date.now(), url, models };
+    return models;
+}
+export function clearModelCache() {
+    cache = null;
+}
+/**
+ * Returns the current model ID — from config/env.
+ */
+export function currentModelId() {
+    return process.env.MODEL || '';
+}

package/dist/core/tools.js

@@ -5,6 +5,7 @@ import { promisify } from 'util';
 import { tmpdir } from 'os';
 import { join } from 'path';
 import { hasN8n } from './config.js';
+import { getMcpToolDefsSync, executeMcpTool, isMcpTool } from './mcpRegistry.js';
 import { permissions } from './permission.js';
 import { lineDiff, compactDiff } from './diff.js';
 import { isBlocked } from './sandbox.js';
@@ -86,7 +87,8 @@ const N8N_TOOLS = [
     { type: 'function', function: { name: 'n8n_deactivate_workflow', description: 'Deactivate n8n workflow', parameters: { type: 'object', properties: { id: { type: 'string' } }, required: ['id'] } } },
 ];
 export function getToolDefs() {
-    return hasN8n() ? [...BASE_TOOLS, ...N8N_TOOLS] : [...BASE_TOOLS];
+    const base = hasN8n() ? [...BASE_TOOLS, ...N8N_TOOLS] : [...BASE_TOOLS];
+    return [...base, ...getMcpToolDefsSync()];
 }
 export const toolDefs = BASE_TOOLS;
 const DANGER_PATTERNS = [
@@ -242,6 +244,8 @@ export async function executeTool(name, args) {
             case 'n8n_deactivate_workflow':
                 return await n8nDeactivateWorkflow(args.id);
             default:
+                if (isMcpTool(name))
+                    return executeMcpTool(name, args);
                 return 'Unknown tool: ' + name;
         }
     }

package/dist/index.js

@@ -8,6 +8,7 @@ import { Banner } from './ui/Banner.js';
 import { Consent, hasConsented } from './ui/Consent.js';
 import { loadConfig, applyConfig } from './core/config.js';
 import { loadSession } from './core/session.js';
+import { initMcpRegistry } from './core/mcpRegistry.js';
 const App = () => {
     const [ready, setReady] = useState(false);
     const [resumedCount, setResumedCount] = useState(0);
@@ -18,6 +19,7 @@ const App = () => {
         const existing = loadConfig();
         if (existing) {
             applyConfig(existing);
+            void initMcpRegistry();
             const hist = loadSession();
             setResumedCount(hist ? hist.length : 0);
             setReady(true);

package/dist/ui/Chat.js

@@ -16,6 +16,7 @@ import { useSlowColor } from './useSlowColor.js';
 import { pastelAt } from './pastel.js';
 import { bumpActivity } from './activity.js';
 import { theme } from './theme.js';
+import { getConfig, saveConfig, applyConfig } from '../core/config.js';
 let nextId = 0;
 const mkItem = (kind, text) => ({ kind, text, id: nextId++ });
 const HistoryLine = ({ item }) => {
@@ -100,9 +101,9 @@ export const Chat = ({ resumedCount = 0 }) => {
         bumpActivity();
         if (permReq)
             return;
-        if (key.ctrl && inputChar === 'p')
+        if (key.ctrl && inputChar === 'l')
             setOverlay('model');
-        if (key.ctrl && inputChar === 's')
+        if (key.ctrl && inputChar === 'o')
             setOverlay('settings');
     });
     const flush = (kind, text) => {
@@ -169,8 +170,8 @@ export const Chat = ({ resumedCount = 0 }) => {
             setHistory((h) => [
                 ...h,
                 mkItem('tool', 'Commands:'),
-                mkItem('tool', '  /model     switch model            (Ctrl+P)'),
-                mkItem('tool', '  /settings  open settings           (Ctrl+S)'),
+                mkItem('tool', '  /model     switch model            (Ctrl+L)'),
+                mkItem('tool', '  /settings  open settings           (Ctrl+O)'),
                 mkItem('tool', '  /compact   summarize history to free context'),
                 mkItem('tool', '  /debug     show last request to provider'),
                 mkItem('tool', '  /clear     clear session and permissions'),
@@ -227,10 +228,17 @@ export const Chat = ({ resumedCount = 0 }) => {
     };
     const handleModelSelect = (id) => {
         process.env.MODEL = id;
+        try {
+            const cfg = getConfig();
+            const next = { ...cfg, model: id };
+            saveConfig(next);
+            applyConfig(next);
+        }
+        catch { }
         setCurrentModel(id);
         setOverlay('none');
         setAgent(new Agent());
-        setHistory((h) => [...h, mkItem('tool', `model → ${id}`)]);
+        setHistory((h) => [...h, mkItem('tool', 'model → ' + id)]);
     };
     if (permReq) {
         return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: history, children: (item) => _jsx(HistoryLine, { item: item }, item.id) }), _jsx(Box, { marginTop: 1, children: _jsx(PermissionPrompt, { req: permReq }) }), _jsx(Box, { marginTop: 1, children: _jsx(InputBar, { value: "", onChange: () => { }, onSubmit: () => { }, loading: false, mascotState: "permission", awaitingPermission: true }) })] }));

package/dist/ui/ModelPicker.js

@@ -1,22 +1,39 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useState, useEffect } from 'react';
 import { Box, Text, useInput, useStdout } from 'ink';
-import { fetchFreeModels } from '../core/freeModels.js';
+import { fetchModels, currentProviderLabel, } from '../core/models.js';
 import { theme } from './theme.js';
 export const ModelPicker = ({ current, onSelect, onCancel }) => {
     const { stdout } = useStdout();
     const width = Math.max(40, stdout?.columns ?? 60);
+    const provider = currentProviderLabel();
     const [models, setModels] = useState([]);
     const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
     const [idx, setIdx] = useState(0);
     const [filter, setFilter] = useState('');
     useEffect(() => {
-        fetchFreeModels(process.env.OPENAI_API_KEY).then((m) => {
+        let cancelled = false;
+        setLoading(true);
+        setError(null);
+        fetchModels()
+            .then((m) => {
+            if (cancelled)
+                return;
             setModels(m);
             const found = m.findIndex((x) => x.id === current);
             setIdx(found >= 0 ? found : 0);
             setLoading(false);
+        })
+            .catch((err) => {
+            if (cancelled)
+                return;
+            setError(err.message);
+            setLoading(false);
         });
+        return () => {
+            cancelled = true;
+        };
     }, [current]);
     const filtered = filter
         ? models.filter((m) => m.id.toLowerCase().includes(filter.toLowerCase()))
@@ -24,9 +41,9 @@ export const ModelPicker = ({ current, onSelect, onCancel }) => {
     useInput((input, key) => {
         if (key.escape)
             return onCancel();
-        if (key.upArrow)
+        if (key.upArrow && filtered.length)
             setIdx((i) => (i - 1 + filtered.length) % filtered.length);
-        if (key.downArrow)
+        if (key.downArrow && filtered.length)
             setIdx((i) => (i + 1) % filtered.length);
         if (key.return && filtered[idx])
             onSelect(filtered[idx].id);
@@ -40,18 +57,26 @@ export const ModelPicker = ({ current, onSelect, onCancel }) => {
     });
     const inner = width - 4;
     const maxVisible = 12;
-    const start = Math.max(0, Math.min(idx - 6, filtered.length - maxVisible));
+    const start = Math.max(0, Math.min(idx - 6, Math.max(0, filtered.length - maxVisible)));
     const visible = filtered.slice(start, start + maxVisible);
-    const topLabel = filter ? `filter: ${filter}` : 'free models';
-    const topPad = Math.max(1, inner - topLabel.length - 4);
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: [_jsx(Text, { color: theme.muted, children: '╭─ ' }), _jsx(Text, { color: theme.accent, bold: true, children: topLabel }), _jsx(Text, { color: theme.muted, children: ' ' + '─'.repeat(topPad) + '╮' })] }), loading ? (_jsxs(Text, { children: [_jsx(Text, { color: theme.muted, children: '│ ' }), _jsx(Text, { color: theme.muted, children: "loading catalog\u2026" })] })) : visible.length === 0 ? (_jsxs(Text, { children: [_jsx(Text, { color: theme.muted, children: '│ ' }), _jsx(Text, { color: theme.error, children: "no matches" })] })) : (visible.map((m, i) => {
+    const label = filter ? `filter: ${filter}` : `${provider} models`;
+    const topPad = Math.max(1, inner - label.length - 4);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: [_jsx(Text, { color: theme.muted, children: '╭─ ' }), _jsx(Text, { color: theme.accent, bold: true, children: label }), _jsx(Text, { color: theme.muted, children: ' ' + '─'.repeat(topPad) + '╮' })] }), loading ? (_jsxs(Text, { children: [_jsx(Text, { color: theme.muted, children: '│ ' }), _jsxs(Text, { color: theme.muted, children: ["fetching ", provider, " catalog\u2026"] })] })) : error ? (_jsxs(Text, { children: [_jsx(Text, { color: theme.muted, children: '│ ' }), _jsxs(Text, { color: theme.error, children: ["\u2717 ", error.slice(0, inner - 6)] })] })) : visible.length === 0 ? (_jsxs(Text, { children: [_jsx(Text, { color: theme.muted, children: '│ ' }), _jsx(Text, { color: theme.error, children: "no matches" })] })) : (visible.map((m, i) => {
                 const realIdx = start + i;
                 const active = realIdx === idx;
                 const isCurrent = m.id === current;
-                const ctx = m.context >= 1000 ? `${Math.round(m.context / 1000)}k` : `${m.context}`;
-                const label = m.id.length > inner - 10 ? m.id.slice(0, inner - 13) + '…' : m.id;
-                const right = `${ctx}`;
-                const pad = Math.max(1, inner - label.length - right.length - 4);
-                return (_jsxs(Text, { children: [_jsx(Text, { color: theme.muted, children: '│ ' }), _jsx(Text, { color: active ? theme.accent : theme.muted, bold: active, children: active ? '❯ ' : '  ' }), _jsx(Text, { color: active ? theme.text : theme.muted, bold: active, children: label }), _jsx(Text, { color: theme.muted, children: ' '.repeat(pad) }), _jsx(Text, { color: theme.muted, children: right }), isCurrent && _jsx(Text, { color: theme.accent, children: " \u2713" })] }, m.id));
+                const ctx = m.contextLength
+                    ? m.contextLength >= 1000
+                        ? `${Math.round(m.contextLength / 1000)}k`
+                        : `${m.contextLength}`
+                    : '';
+                const freeTag = m.isFree ? 'FREE' : '';
+                // Right side:  ctx + free badge
+                const right = [ctx, freeTag].filter(Boolean).join(' · ');
+                const label0 = m.id.length > inner - 10
+                    ? m.id.slice(0, inner - 13) + '…'
+                    : m.id;
+                const pad = Math.max(1, inner - label0.length - right.length - 4);
+                return (_jsxs(Text, { children: [_jsx(Text, { color: theme.muted, children: '│ ' }), _jsx(Text, { color: active ? theme.accent : theme.muted, bold: active, children: active ? '❯ ' : '  ' }), _jsx(Text, { color: active ? theme.text : theme.muted, bold: active, children: label0 }), _jsx(Text, { color: theme.muted, children: ' '.repeat(pad) }), _jsx(Text, { color: theme.muted, children: right }), isCurrent && _jsx(Text, { color: theme.accent, children: " \u2713" })] }, m.id));
             })), _jsx(Text, { children: _jsx(Text, { color: theme.muted, children: '╰' + '─'.repeat(inner) + '╯' }) }), _jsx(Text, { color: theme.muted, children: "\u2191\u2193 move \u00B7 type to filter \u00B7 \u21B5 select \u00B7 esc cancel" })] }));
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blyuecode",
-  "version": "0.1.17",
+  "version": "0.3.0",
   "description": "BLYUE Code — a coding agent by Lumen",
   "type": "module",
   "license": "MIT",