vexi-cli 0.5.5 → 0.9.0

package/dist/providers/manifest.js

@@ -0,0 +1,96 @@
+/**
+ * Remote model manifest — Feature #4.
+ *
+ * Default models drift as providers ship new versions. Hardcoding them in
+ * PROVIDER_INFO means a stale default requires a full Vexi release to fix.
+ * This module lets Vexi pick up refreshed defaults from a small, version-pinned
+ * JSON manifest hosted at vexi.pro, cached locally, with the compiled-in
+ * PROVIDER_INFO defaults as the always-safe fallback.
+ *
+ * Design mirrors the npm update check (src/update): a synchronous read of the
+ * local cache on the hot path, plus a best-effort background refresh that never
+ * blocks startup and swallows all errors.
+ *
+ *   manifest shape:  { "version": 1, "defaults": { "openai": "gpt-4o-mini", … } }
+ */
+import { promises as fs } from 'node:fs';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { VEXI_DIR } from '../config.js';
+const MANIFEST_URL = 'https://vexi.pro/models.json';
+const MANIFEST_CACHE_PATH = join(VEXI_DIR, 'models.json');
+const REFRESH_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24 hours
+const FETCH_TIMEOUT_MS = 1500;
+/** Manifest schema version this Vexi understands. Newer manifests are ignored. */
+const SUPPORTED_MANIFEST_VERSION = 1;
+/** Validate an unknown value as a usable manifest, or return null. */
+function parseManifest(raw) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const obj = raw;
+    if (obj.version !== SUPPORTED_MANIFEST_VERSION)
+        return null;
+    if (!obj.defaults || typeof obj.defaults !== 'object')
+        return null;
+    const defaults = {};
+    for (const [k, v] of Object.entries(obj.defaults)) {
+        if (typeof v === 'string' && v.trim())
+            defaults[k] = v.trim();
+    }
+    return { version: SUPPORTED_MANIFEST_VERSION, defaults };
+}
+/**
+ * Read the locally cached manifest synchronously (hot path). Returns null when
+ * absent, unreadable, malformed, or a version this build doesn't support.
+ */
+function loadCachedManifest() {
+    try {
+        const raw = readFileSync(MANIFEST_CACHE_PATH, 'utf8');
+        return parseManifest(JSON.parse(raw));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Resolve the default model for a provider id: a cached remote override if one
+ * exists, otherwise the compiled-in fallback. Never throws.
+ */
+export function defaultModelFor(id, fallback) {
+    const manifest = loadCachedManifest();
+    return manifest?.defaults[id] ?? fallback;
+}
+/**
+ * Best-effort background refresh of the model manifest. Fire-and-forget from
+ * startup — returns immediately if the cache is fresh, otherwise fetches (max
+ * 1500 ms) and rewrites the cache. All errors are swallowed.
+ */
+export async function refreshManifest() {
+    try {
+        const cacheRaw = await fs.readFile(MANIFEST_CACHE_PATH, 'utf8').catch(() => null);
+        if (cacheRaw) {
+            try {
+                const cache = JSON.parse(cacheRaw);
+                const age = Date.now() - new Date(cache.lastCheck).getTime();
+                if (Number.isFinite(age) && age < REFRESH_INTERVAL_MS)
+                    return; // still fresh
+            }
+            catch {
+                // malformed cache — fall through and refetch
+            }
+        }
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+        const res = await fetch(MANIFEST_URL, { signal: controller.signal }).finally(() => clearTimeout(timer));
+        if (!res.ok)
+            return;
+        const manifest = parseManifest(await res.json());
+        if (!manifest)
+            return;
+        await fs.mkdir(VEXI_DIR, { recursive: true }).catch(() => { });
+        await fs.writeFile(MANIFEST_CACHE_PATH, JSON.stringify({ ...manifest, lastCheck: new Date().toISOString() }), 'utf8').catch(() => { });
+    }
+    catch {
+        // network error, timeout, or bad JSON — silently ignored
+    }
+}

package/dist/providers/manifest.test.js

@@ -0,0 +1,71 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { promises as fs } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+// config.ts derives VEXI_DIR from os.homedir() at import time, and manifest.ts
+// imports VEXI_DIR from it. Mock homedir to a throwaway dir and re-import so the
+// cache path is deterministic on every platform (no reliance on $HOME/$USERPROFILE).
+let home;
+let defaultModelFor;
+let refreshManifest;
+beforeEach(async () => {
+    home = await fs.mkdtemp(join(tmpdir(), 'vexi-manifest-'));
+    vi.resetModules();
+    vi.doMock('node:os', async (importOriginal) => {
+        const actual = await importOriginal();
+        return { ...actual, homedir: () => home };
+    });
+    const mod = await import('./manifest.js');
+    defaultModelFor = mod.defaultModelFor;
+    refreshManifest = mod.refreshManifest;
+});
+afterEach(async () => {
+    vi.doUnmock('node:os');
+    vi.restoreAllMocks();
+    await fs.rm(home, { recursive: true, force: true });
+});
+async function writeCache(obj) {
+    await fs.mkdir(join(home, '.vexi'), { recursive: true });
+    await fs.writeFile(join(home, '.vexi', 'models.json'), JSON.stringify(obj), 'utf8');
+}
+describe('defaultModelFor', () => {
+    it('returns the compiled-in fallback when no cache exists', () => {
+        expect(defaultModelFor('openai', 'gpt-4o-mini')).toBe('gpt-4o-mini');
+    });
+    it('prefers a cached remote override', async () => {
+        await writeCache({ version: 1, defaults: { openai: 'gpt-5-mini' }, lastCheck: new Date().toISOString() });
+        expect(defaultModelFor('openai', 'gpt-4o-mini')).toBe('gpt-5-mini');
+        expect(defaultModelFor('anthropic', 'claude-sonnet-5')).toBe('claude-sonnet-5'); // not overridden → fallback
+    });
+    it('ignores a manifest with an unsupported version', async () => {
+        await writeCache({ version: 99, defaults: { openai: 'from-the-future' }, lastCheck: new Date().toISOString() });
+        expect(defaultModelFor('openai', 'gpt-4o-mini')).toBe('gpt-4o-mini');
+    });
+    it('ignores malformed cache files', async () => {
+        await fs.mkdir(join(home, '.vexi'), { recursive: true });
+        await fs.writeFile(join(home, '.vexi', 'models.json'), 'not json', 'utf8');
+        expect(defaultModelFor('groq', 'llama-3.3-70b-versatile')).toBe('llama-3.3-70b-versatile');
+    });
+});
+describe('refreshManifest', () => {
+    it('fetches and caches a valid manifest, which then feeds defaultModelFor', async () => {
+        vi.stubGlobal('fetch', vi.fn(async () => ({
+            ok: true,
+            json: async () => ({ version: 1, defaults: { deepseek: 'deepseek-v4' } }),
+        })));
+        await refreshManifest();
+        expect(defaultModelFor('deepseek', 'deepseek-chat')).toBe('deepseek-v4');
+    });
+    it('skips the network when the cache is still fresh', async () => {
+        await writeCache({ version: 1, defaults: { openai: 'cached' }, lastCheck: new Date().toISOString() });
+        const fetchSpy = vi.fn();
+        vi.stubGlobal('fetch', fetchSpy);
+        await refreshManifest();
+        expect(fetchSpy).not.toHaveBeenCalled();
+    });
+    it('swallows network errors and leaves the fallback intact', async () => {
+        vi.stubGlobal('fetch', vi.fn(async () => { throw new Error('offline'); }));
+        await expect(refreshManifest()).resolves.toBeUndefined();
+        expect(defaultModelFor('openai', 'gpt-4o-mini')).toBe('gpt-4o-mini');
+    });
+});

package/dist/providers/openai-compat.js

@@ -7,47 +7,218 @@
  * Vexi dependency-free (plain `fetch`, no SDKs).
  */
 import { ProviderError } from './types.js';
+/** Report OpenAI-style `usage` ({prompt_tokens, completion_tokens}) if present. */
+function reportUsage(json, onUsage) {
+    if (!onUsage)
+        return;
+    const u = json.usage;
+    if (u && (u.prompt_tokens || u.completion_tokens)) {
+        onUsage({ inputTokens: u.prompt_tokens ?? 0, outputTokens: u.completion_tokens ?? 0 });
+    }
+}
+/** Translate Vexi's neutral ChatMessage[] into OpenAI chat-completions format. */
+function toOpenAIMessages(messages) {
+    return messages.map((m) => {
+        if (m.role === 'assistant' && m.toolCalls?.length) {
+            return {
+                role: 'assistant',
+                content: m.content || null,
+                tool_calls: m.toolCalls.map((tc) => ({
+                    id: tc.id,
+                    type: 'function',
+                    function: { name: tc.name, arguments: JSON.stringify(tc.arguments) },
+                })),
+            };
+        }
+        if (m.role === 'tool') {
+            return { role: 'tool', tool_call_id: m.toolCallId ?? '', content: m.content };
+        }
+        return { role: m.role, content: m.content };
+    });
+}
 export function createOpenAICompatProvider(opts) {
     return {
         id: opts.id,
         model: opts.model,
-        async stream(messages, onText) {
-            const res = await fetch(`${opts.baseUrl}/chat/completions`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    Authorization: `Bearer ${opts.apiKey}`,
-                    ...opts.extraHeaders,
-                },
-                body: JSON.stringify({
-                    model: opts.model,
-                    messages,
-                    stream: true,
-                }),
-            }).catch((err) => {
-                throw new ProviderError(`Network error: ${err.message}`);
-            });
-            if (!res.ok || !res.body) {
-                const body = await res.text().catch(() => '');
-                throw new ProviderError(`${opts.id} API error (HTTP ${res.status}): ${truncate(body, 300)}`, res.status);
+        supportsTools: opts.supportsTools ?? false,
+        async streamTools(messages, tools, onText, onUsage) {
+            const guard = createStreamTimeoutGuard(opts.id);
+            try {
+                const res = await fetch(`${opts.baseUrl}/chat/completions`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        Authorization: `Bearer ${opts.apiKey}`,
+                        ...opts.extraHeaders,
+                    },
+                    body: JSON.stringify({
+                        model: opts.model,
+                        messages: toOpenAIMessages(messages),
+                        tools: tools.map((t) => ({
+                            type: 'function',
+                            function: { name: t.name, description: t.description, parameters: t.inputSchema },
+                        })),
+                        stream: true,
+                        stream_options: { include_usage: true },
+                        ...opts.extraBody,
+                    }),
+                    signal: guard.signal,
+                }).catch((err) => {
+                    throw guard.wrapNetworkError(err);
+                });
+                if (!res.ok || !res.body) {
+                    const body = await res.text().catch(() => '');
+                    throw new ProviderError(`${opts.id} API error (HTTP ${res.status}): ${truncate(body, 300)}`, res.status);
+                }
+                let full = '';
+                // Streamed tool calls arrive as fragments keyed by their array index;
+                // accumulate id/name/arguments across deltas, then parse at the end.
+                const acc = new Map();
+                try {
+                    for await (const data of sseEvents(res.body)) {
+                        guard.resetIdleTimer();
+                        if (data === '[DONE]')
+                            break;
+                        try {
+                            const json = JSON.parse(data);
+                            const delta = json.choices?.[0]?.delta;
+                            if (delta?.content) {
+                                full += delta.content;
+                                onText(delta.content);
+                            }
+                            if (Array.isArray(delta?.tool_calls)) {
+                                for (const tc of delta.tool_calls) {
+                                    const idx = tc.index ?? 0;
+                                    const cur = acc.get(idx) ?? { id: '', name: '', args: '' };
+                                    if (tc.id)
+                                        cur.id = tc.id;
+                                    if (tc.function?.name)
+                                        cur.name = tc.function.name;
+                                    if (tc.function?.arguments)
+                                        cur.args += tc.function.arguments;
+                                    acc.set(idx, cur);
+                                }
+                            }
+                            reportUsage(json, onUsage);
+                        }
+                        catch {
+                            // Ignore malformed/keep-alive chunks
+                        }
+                    }
+                }
+                catch (e) {
+                    throw guard.wrapStreamError(e);
+                }
+                const toolCalls = [...acc.entries()]
+                    .sort((a, b) => a[0] - b[0])
+                    .map(([idx, c]) => {
+                    let args = {};
+                    try {
+                        args = c.args ? JSON.parse(c.args) : {};
+                    }
+                    catch {
+                        args = {};
+                    }
+                    return { id: c.id || `call_${idx}`, name: c.name, arguments: args };
+                })
+                    .filter((c) => c.name);
+                return { text: full, toolCalls };
+            }
+            finally {
+                guard.dispose();
             }
-            let full = '';
-            for await (const data of sseEvents(res.body)) {
-                if (data === '[DONE]')
-                    break;
+        },
+        async stream(messages, onText, onUsage) {
+            const guard = createStreamTimeoutGuard(opts.id);
+            try {
+                const res = await fetch(`${opts.baseUrl}/chat/completions`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        Authorization: `Bearer ${opts.apiKey}`,
+                        ...opts.extraHeaders,
+                    },
+                    body: JSON.stringify({
+                        model: opts.model,
+                        messages: toOpenAIMessages(messages),
+                        stream: true,
+                        stream_options: { include_usage: true },
+                        ...opts.extraBody,
+                    }),
+                    signal: guard.signal,
+                }).catch((err) => {
+                    throw guard.wrapNetworkError(err);
+                });
+                if (!res.ok || !res.body) {
+                    const body = await res.text().catch(() => '');
+                    throw new ProviderError(`${opts.id} API error (HTTP ${res.status}): ${truncate(body, 300)}`, res.status);
+                }
+                let full = '';
                 try {
-                    const json = JSON.parse(data);
-                    const text = json.choices?.[0]?.delta?.content;
-                    if (text) {
-                        full += text;
-                        onText(text);
+                    for await (const data of sseEvents(res.body)) {
+                        guard.resetIdleTimer();
+                        if (data === '[DONE]')
+                            break;
+                        try {
+                            const json = JSON.parse(data);
+                            const text = json.choices?.[0]?.delta?.content;
+                            if (text) {
+                                full += text;
+                                onText(text);
+                            }
+                            reportUsage(json, onUsage);
+                        }
+                        catch {
+                            // Ignore malformed/keep-alive chunks
+                        }
                     }
                 }
-                catch {
-                    // Ignore malformed/keep-alive chunks
+                catch (e) {
+                    throw guard.wrapStreamError(e);
                 }
+                return full;
             }
-            return full;
+            finally {
+                guard.dispose();
+            }
+        },
+    };
+}
+/** Abort the connection if the server goes silent for this long between chunks. */
+const IDLE_TIMEOUT_MS = 60_000;
+/** Hard ceiling on total stream duration, regardless of activity. */
+const MAX_STREAM_MS = 10 * 60 * 1000;
+/**
+ * Shared guard against hung provider connections: aborts the fetch if no
+ * bytes arrive for IDLE_TIMEOUT_MS, or if the whole stream runs past
+ * MAX_STREAM_MS, so a stalled provider can never freeze the chat loop.
+ */
+export function createStreamTimeoutGuard(providerId) {
+    const controller = new AbortController();
+    let idleTimer;
+    const hardTimer = setTimeout(() => controller.abort(), MAX_STREAM_MS);
+    const resetIdleTimer = () => {
+        clearTimeout(idleTimer);
+        idleTimer = setTimeout(() => controller.abort(), IDLE_TIMEOUT_MS);
+    };
+    resetIdleTimer();
+    return {
+        signal: controller.signal,
+        resetIdleTimer,
+        wrapNetworkError(err) {
+            if (controller.signal.aborted)
+                return new ProviderError(`${providerId} request timed out (no response).`);
+            return new ProviderError(`Network error: ${err.message}`);
+        },
+        wrapStreamError(e) {
+            if (controller.signal.aborted) {
+                return new ProviderError(`${providerId} stream stalled or exceeded the time limit and was aborted.`);
+            }
+            return e;
+        },
+        dispose() {
+            clearTimeout(idleTimer);
+            clearTimeout(hardTimer);
         },
     };
 }

package/dist/providers/openai-compat.test.js

@@ -0,0 +1,66 @@
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { createOpenAICompatProvider } from './openai-compat.js';
+/** Build a fake fetch Response whose body streams the given SSE lines. */
+function sseResponse(lines) {
+    const body = new ReadableStream({
+        start(controller) {
+            const enc = new TextEncoder();
+            for (const l of lines)
+                controller.enqueue(enc.encode(`data: ${l}\n`));
+            controller.close();
+        },
+    });
+    return { ok: true, status: 200, body };
+}
+afterEach(() => vi.restoreAllMocks());
+describe('openai-compat streamTools', () => {
+    it('reassembles a tool call split across streamed deltas', async () => {
+        const chunks = [
+            JSON.stringify({ choices: [{ delta: { content: 'let me edit' } }] }),
+            JSON.stringify({ choices: [{ delta: { tool_calls: [{ index: 0, id: 'call_1', function: { name: 'edit_file' } }] } }] }),
+            JSON.stringify({ choices: [{ delta: { tool_calls: [{ index: 0, function: { arguments: '{"path":"a.ts",' } }] } }] }),
+            JSON.stringify({ choices: [{ delta: { tool_calls: [{ index: 0, function: { arguments: '"old":"x","new":"y"}' } }] } }] }),
+            '[DONE]',
+        ];
+        vi.stubGlobal('fetch', vi.fn(async () => sseResponse(chunks)));
+        const provider = createOpenAICompatProvider({
+            id: 'openai', baseUrl: 'https://x/v1', apiKey: 'k', model: 'gpt', supportsTools: true,
+        });
+        let streamed = '';
+        const { text, toolCalls } = await provider.streamTools([{ role: 'user', content: 'go' }], [{ name: 'edit_file', description: 'd', inputSchema: { type: 'object' } }], (c) => { streamed += c; });
+        expect(streamed).toBe('let me edit');
+        expect(text).toBe('let me edit');
+        expect(toolCalls).toEqual([
+            { id: 'call_1', name: 'edit_file', arguments: { path: 'a.ts', old: 'x', new: 'y' } },
+        ]);
+    });
+    it('returns no tool calls for a plain text answer', async () => {
+        vi.stubGlobal('fetch', vi.fn(async () => sseResponse([
+            JSON.stringify({ choices: [{ delta: { content: 'hi' } }] }),
+            '[DONE]',
+        ])));
+        const provider = createOpenAICompatProvider({
+            id: 'openai', baseUrl: 'https://x/v1', apiKey: 'k', model: 'gpt', supportsTools: true,
+        });
+        const { text, toolCalls } = await provider.streamTools([{ role: 'user', content: 'hi' }], [], () => { });
+        expect(text).toBe('hi');
+        expect(toolCalls).toEqual([]);
+    });
+    it('reports token usage from the final include_usage chunk', async () => {
+        vi.stubGlobal('fetch', vi.fn(async () => sseResponse([
+            JSON.stringify({ choices: [{ delta: { content: 'hi' } }] }),
+            JSON.stringify({ choices: [], usage: { prompt_tokens: 42, completion_tokens: 7 } }),
+            '[DONE]',
+        ])));
+        const provider = createOpenAICompatProvider({ id: 'openai', baseUrl: 'x', apiKey: 'k', model: 'gpt' });
+        let usage = null;
+        await provider.stream([{ role: 'user', content: 'hi' }], () => { }, (u) => { usage = u; });
+        expect(usage).toEqual({ inputTokens: 42, outputTokens: 7 });
+    });
+    it('advertises native tool support via the flag', () => {
+        const p = createOpenAICompatProvider({ id: 'openai', baseUrl: 'x', apiKey: 'k', model: 'gpt', supportsTools: true });
+        expect(p.supportsTools).toBe(true);
+        const noTools = createOpenAICompatProvider({ id: 'minimax', baseUrl: 'x', apiKey: 'k', model: 'm' });
+        expect(noTools.supportsTools).toBe(false);
+    });
+});

package/dist/providers/types.js

@@ -16,9 +16,18 @@ export class ProviderError extends Error {
 }
 /** Human-friendly provider metadata. */
 export const PROVIDER_INFO = {
-    anthropic: { label: 'Anthropic (Claude)', defaultModel: 'claude-sonnet-4-5' },
+    // ── International providers ───────────────────────────────────────────
+    anthropic: { label: 'Anthropic (Claude)', defaultModel: 'claude-sonnet-5' },
     openai: { label: 'OpenAI (GPT)', defaultModel: 'gpt-4o-mini' },
     openrouter: { label: 'OpenRouter', defaultModel: 'openrouter/auto' },
-    groq: { label: 'Groq', defaultModel: 'llama-3.3-70b-versatile' },
-    gemini: { label: 'Google Gemini', defaultModel: 'gemini-2.5-flash' },
+    groq: { label: 'Groq (free tier)', defaultModel: 'llama-3.3-70b-versatile', free: true },
+    gemini: { label: 'Google Gemini (free tier)', defaultModel: 'gemini-2.5-flash', free: true },
+    mistral: { label: 'Mistral AI', defaultModel: 'mistral-small-latest' },
+    cerebras: { label: 'Cerebras (free tier)', defaultModel: 'llama-3.3-70b', free: true },
+    // ── Chinese AI providers ──────────────────────────────────────────────
+    glm: { label: 'Zhipu AI — GLM (free tier)', defaultModel: 'glm-4-flash', free: true },
+    deepseek: { label: 'DeepSeek (free tier)', defaultModel: 'deepseek-chat', free: true },
+    qwen: { label: 'Alibaba Qwen (free tier)', defaultModel: 'qwen-turbo', free: true },
+    moonshot: { label: 'Kimi — Moonshot AI (free tier)', defaultModel: 'moonshot-v1-8k', free: true },
+    minimax: { label: 'MiniMax (free tier)', defaultModel: 'MiniMax-Text-01', free: true },
 };

package/dist/replay/export.js

@@ -16,6 +16,7 @@
 import { promises as fs } from 'node:fs';
 import { join } from 'node:path';
 import { loadSession } from './recorder.js';
+import { escapeHtml } from '../utils/html.js';
 /** UI labels for the generated page, per export language. */
 const LABELS = {
     en: {
@@ -306,10 +307,3 @@ document.getElementById('record').onclick = async () => {
 </html>
 `;
 }
-function escapeHtml(text) {
-    return text
-        .replaceAll('&', '&amp;')
-        .replaceAll('<', '&lt;')
-        .replaceAll('>', '&gt;')
-        .replaceAll('"', '&quot;');
-}

package/dist/skills/index.js

@@ -50,7 +50,7 @@ export function skillsBlock(skills) {
  * Add a skill from a local file path or a URL (GitHub URLs are converted
  * to raw content automatically). Returns the saved skill name.
  */
-export async function addSkill(root, source) {
+export async function addSkill(root, source, opts = {}) {
     let content;
     let name;
     if (/^https?:\/\//i.test(source)) {
@@ -61,14 +61,22 @@ export async function addSkill(root, source) {
         }
         content = await res.text();
         name = skillNameFromUrl(source);
+        content = content.slice(0, MAX_SKILL_SIZE).trim();
+        if (!content)
+            throw new Error('Skill source is empty.');
+        if (opts.confirmRemoteContent) {
+            const proceed = await opts.confirmRemoteContent(content, sanitizeName(name), url);
+            if (!proceed)
+                throw new Error('Skill add cancelled.');
+        }
     }
     else {
         content = await fs.readFile(source, 'utf8');
         name = basename(source, extname(source));
+        content = content.slice(0, MAX_SKILL_SIZE).trim();
+        if (!content)
+            throw new Error('Skill source is empty.');
     }
-    content = content.slice(0, MAX_SKILL_SIZE).trim();
-    if (!content)
-        throw new Error('Skill source is empty.');
     name = sanitizeName(name);
     const dir = skillsDir(root);
     await fs.mkdir(dir, { recursive: true });