vexi-cli 0.5.5 → 0.9.0

package/dist/memory/index.js

@@ -14,6 +14,7 @@
  *   never forgets previous decisions — even across sessions.
  */
 import { join } from 'node:path';
+import { z } from 'zod';
 import { readJson, writeJsonAtomic } from '../utils/fs-atomic.js';
 /** Messages that always stay in the context verbatim. */
 export const KEEP_RECENT = 10;
@@ -90,14 +91,12 @@ export async function compressIntoMemory(provider, memory, oldMessages) {
             },
         ], () => { });
         const parsed = extractJson(raw);
-        if (!parsed || typeof parsed.summary !== 'string' || !Array.isArray(parsed.decisions)) {
+        if (!parsed)
             return memory;
-        }
         return {
             version: 1,
             summary: parsed.summary.trim(),
             decisions: parsed.decisions
-                .filter((d) => typeof d === 'string')
                 .map((d) => d.trim())
                 .filter(Boolean)
                 .slice(0, 20),
@@ -109,14 +108,20 @@ export async function compressIntoMemory(provider, memory, oldMessages) {
         return memory; // never let compression break the session
     }
 }
-/** Extract the first JSON object from a model reply (tolerates fences/prose). */
+const MemoryJsonSchema = z.object({
+    summary: z.string(),
+    decisions: z.array(z.string()),
+});
+/** Extract and validate the first JSON object from a model reply (tolerates fences/prose). */
 function extractJson(text) {
     const start = text.indexOf('{');
     const end = text.lastIndexOf('}');
     if (start === -1 || end <= start)
         return null;
     try {
-        return JSON.parse(text.slice(start, end + 1));
+        const parsed = JSON.parse(text.slice(start, end + 1));
+        const result = MemoryJsonSchema.safeParse(parsed);
+        return result.success ? result.data : null;
     }
     catch {
         return null;

package/dist/onboarding.js

@@ -0,0 +1,105 @@
+/**
+ * Interactive onboarding flow for `vexi setup`.
+ *
+ * The IO interface is injected so tests can drive the prompts without
+ * touching stdin/stdout. The optional discoverFn and saveFn are also
+ * injected for testability.
+ */
+import { saveConfig } from './config.js';
+import { identifyFromUrl, discoverModels } from './endpoint.js';
+export { loadConfig, saveConfig } from './config.js';
+/**
+ * Run the interactive setup wizard.
+ *
+ * Steps:
+ * 1. Ask for the API endpoint URL
+ * 2. Identify the provider from the URL
+ * 3. Ask for the API key
+ * 4. Discover available models (or ask for a manual entry on failure)
+ * 5. Let the user choose a model (or enter one manually)
+ * 6. Save config and return it
+ */
+export async function runOnboarding(io, discoverFn = discoverModels, saveFn = saveConfig) {
+    io.write('');
+    io.write('Welcome to Vexi setup. Let\'s configure your AI provider.');
+    io.write('');
+    // Step 1: URL
+    const rawUrl = await io.prompt('Paste your API endpoint URL (e.g. https://openrouter.ai/api/v1): ');
+    if (!rawUrl.trim()) {
+        throw new Error('No URL provided. Run `vexi setup` again to configure.');
+    }
+    // Step 2: Identify
+    let identity;
+    try {
+        identity = identifyFromUrl(rawUrl.trim());
+    }
+    catch {
+        throw new Error(`Could not parse URL "${rawUrl}". Please check the URL and try again.`);
+    }
+    io.write(`  Detected provider: ${identity.displayName}`);
+    io.write(`  Base URL:          ${identity.baseUrl}`);
+    io.write('');
+    // Step 3: API key
+    const apiKey = await io.prompt(`Enter your ${identity.displayName} API key: `);
+    if (!apiKey.trim()) {
+        throw new Error('No API key provided. Run `vexi setup` again to configure.');
+    }
+    // Step 4: Discover models
+    let models = [];
+    try {
+        models = await discoverFn(identity, apiKey.trim());
+        if (models.length === 0) {
+            io.write('  No models returned by /models endpoint.');
+        }
+        else {
+            io.write(`  Found ${models.length} model(s).`);
+        }
+    }
+    catch (err) {
+        io.write(`  Warning: could not fetch models — ${err.message}`);
+    }
+    io.write('');
+    // Step 5: Choose or enter model
+    let model;
+    if (models.length > 0) {
+        io.write('Available models:');
+        models.slice(0, 20).forEach((m, i) => io.write(`  ${String(i + 1).padStart(2)}. ${m}`));
+        if (models.length > 20) {
+            io.write(`  ... and ${models.length - 20} more`);
+        }
+        io.write('');
+        const choice = await io.prompt(`Enter a number (1-${Math.min(20, models.length)}) or type a model ID directly: `);
+        const num = parseInt(choice.trim(), 10);
+        if (!isNaN(num) && num >= 1 && num <= models.length) {
+            model = models[num - 1];
+        }
+        else if (choice.trim()) {
+            model = choice.trim();
+        }
+        else {
+            model = models[0];
+        }
+    }
+    else {
+        const manualModel = await io.prompt('Enter the model ID to use (e.g. gpt-4o): ');
+        if (!manualModel.trim()) {
+            throw new Error('No model specified. Run `vexi setup` again to configure.');
+        }
+        model = manualModel.trim();
+    }
+    io.write('');
+    io.write(`  Using model: ${model}`);
+    io.write('');
+    // Step 6: Save
+    const config = {
+        provider: identity.provider,
+        displayName: identity.displayName,
+        baseUrl: identity.baseUrl,
+        apiKey: apiKey.trim(),
+        model,
+    };
+    await saveFn(config);
+    io.write(`Configuration saved. You can now run: vexi`);
+    io.write('');
+    return config;
+}

package/dist/onboarding.test.js

@@ -0,0 +1,76 @@
+import { describe, it, expect, vi } from 'vitest';
+import { runOnboarding } from './onboarding.js';
+function makeIO(answers) {
+    const lines = [];
+    let callIndex = 0;
+    const io = {
+        prompt: async (_q) => answers[callIndex++] ?? '',
+        write: (line) => lines.push(line),
+    };
+    return { io, lines };
+}
+describe('runOnboarding', () => {
+    it('happy path: discovers models and saves config', async () => {
+        const { io } = makeIO([
+            'https://openrouter.ai/api/v1', // URL
+            'sk-or-test', // API key
+            '1', // pick model #1
+        ]);
+        const discoverFn = vi.fn().mockResolvedValue(['openai/gpt-4o', 'mistralai/mistral-7b']);
+        const saveFn = vi.fn().mockResolvedValue(undefined);
+        const config = await runOnboarding(io, discoverFn, saveFn);
+        expect(config.provider).toBe('openrouter');
+        expect(config.displayName).toBe('OpenRouter');
+        expect(config.baseUrl).toBe('https://openrouter.ai/api/v1');
+        expect(config.apiKey).toBe('sk-or-test');
+        expect(config.model).toBe('openai/gpt-4o');
+        expect(discoverFn).toHaveBeenCalledWith(expect.objectContaining({ provider: 'openrouter' }), 'sk-or-test');
+        expect(saveFn).toHaveBeenCalledWith(config);
+    });
+    it('falls back to manual model entry when /models fails', async () => {
+        const { io } = makeIO([
+            'https://api.groq.com/openai/v1', // URL
+            'gsk_test', // API key
+            'llama-3.3-70b-versatile', // manual model entry
+        ]);
+        const discoverFn = vi.fn().mockRejectedValue(new Error('HTTP 401. Enter the model ID manually.'));
+        const saveFn = vi.fn().mockResolvedValue(undefined);
+        const config = await runOnboarding(io, discoverFn, saveFn);
+        expect(config.model).toBe('llama-3.3-70b-versatile');
+        expect(saveFn).toHaveBeenCalledWith(config);
+    });
+    it('throws when no URL is provided', async () => {
+        const { io } = makeIO(['']); // empty URL
+        await expect(runOnboarding(io, vi.fn(), vi.fn())).rejects.toThrow('No URL provided');
+    });
+    it('throws when no API key is provided', async () => {
+        const { io } = makeIO([
+            'https://openrouter.ai/api/v1', // valid URL
+            '', // empty API key
+        ]);
+        const discoverFn = vi.fn().mockResolvedValue([]);
+        await expect(runOnboarding(io, discoverFn, vi.fn())).rejects.toThrow('No API key provided');
+    });
+    it('accepts a typed model id directly instead of a number', async () => {
+        const { io } = makeIO([
+            'https://api.openai.com/v1',
+            'sk-test',
+            'o3-mini', // typed directly, not a list number
+        ]);
+        const discoverFn = vi.fn().mockResolvedValue(['gpt-4o', 'gpt-4o-mini']);
+        const saveFn = vi.fn().mockResolvedValue(undefined);
+        const config = await runOnboarding(io, discoverFn, saveFn);
+        expect(config.model).toBe('o3-mini');
+    });
+    it('defaults to first model when empty choice given', async () => {
+        const { io } = makeIO([
+            'https://api.openai.com/v1',
+            'sk-test',
+            '', // empty → default to first
+        ]);
+        const discoverFn = vi.fn().mockResolvedValue(['gpt-4o', 'gpt-4o-mini']);
+        const saveFn = vi.fn().mockResolvedValue(undefined);
+        const config = await runOnboarding(io, discoverFn, saveFn);
+        expect(config.model).toBe('gpt-4o');
+    });
+});

package/dist/providers/anthropic.js

@@ -4,56 +4,195 @@
  * so it gets its own small client instead of the OpenAI-compatible one.
  */
 import { ProviderError } from './types.js';
-import { sseEvents, truncate } from './openai-compat.js';
-const ANTHROPIC_API = 'https://api.anthropic.com/v1/messages';
+import { sseEvents, truncate, createStreamTimeoutGuard } from './openai-compat.js';
+const ANTHROPIC_BASE = 'https://api.anthropic.com/v1';
 const ANTHROPIC_VERSION = '2023-06-01';
-export function createAnthropicProvider(apiKey, model) {
+/**
+ * Accumulate token usage from an Anthropic SSE event. Input tokens arrive in
+ * `message_start`; output tokens accumulate in `message_delta`. Returns the
+ * running total (mutated in place).
+ */
+function accumulateUsage(json, usage) {
+    if (json.type === 'message_start' && json.message?.usage) {
+        usage.inputTokens = json.message.usage.input_tokens ?? usage.inputTokens;
+    }
+    else if (json.type === 'message_delta' && json.usage) {
+        usage.outputTokens = json.usage.output_tokens ?? usage.outputTokens;
+    }
+}
+/** Translate Vexi's neutral ChatMessage[] into Anthropic's content-block format. */
+function toAnthropicMessages(chat) {
+    return chat.map((m) => {
+        if (m.role === 'assistant' && m.toolCalls?.length) {
+            const blocks = [];
+            if (m.content)
+                blocks.push({ type: 'text', text: m.content });
+            for (const tc of m.toolCalls) {
+                blocks.push({ type: 'tool_use', id: tc.id, name: tc.name, input: tc.arguments });
+            }
+            return { role: 'assistant', content: blocks };
+        }
+        if (m.role === 'tool') {
+            // Tool results are carried on a user-role turn in Anthropic's API.
+            return {
+                role: 'user',
+                content: [{ type: 'tool_result', tool_use_id: m.toolCallId ?? '', content: m.content }],
+            };
+        }
+        return { role: m.role, content: m.content };
+    });
+}
+export function createAnthropicProvider(apiKey, model, baseUrl) {
+    const messagesEndpoint = `${baseUrl ?? ANTHROPIC_BASE}/messages`;
     return {
         id: 'anthropic',
         model,
-        async stream(messages, onText) {
+        supportsTools: true,
+        async streamTools(messages, tools, onText, onUsage) {
+            const system = messages.filter((m) => m.role === 'system').map((m) => m.content).join('\n\n');
+            const chat = messages.filter((m) => m.role !== 'system');
+            const usage = { inputTokens: 0, outputTokens: 0 };
+            const guard = createStreamTimeoutGuard('anthropic');
+            try {
+                const res = await fetch(messagesEndpoint, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'x-api-key': apiKey,
+                        'anthropic-version': ANTHROPIC_VERSION,
+                    },
+                    body: JSON.stringify({
+                        model,
+                        max_tokens: 8192,
+                        ...(system ? { system } : {}),
+                        messages: toAnthropicMessages(chat),
+                        tools: tools.map((t) => ({ name: t.name, description: t.description, input_schema: t.inputSchema })),
+                        stream: true,
+                    }),
+                    signal: guard.signal,
+                }).catch((err) => {
+                    throw guard.wrapNetworkError(err);
+                });
+                if (!res.ok || !res.body) {
+                    const body = await res.text().catch(() => '');
+                    throw new ProviderError(`anthropic API error (HTTP ${res.status}): ${truncate(body, 300)}`, res.status);
+                }
+                let full = '';
+                const toolCalls = [];
+                // tool_use blocks stream their arguments as partial_json fragments,
+                // keyed by content-block index; accumulate then parse at block stop.
+                const partials = new Map();
+                try {
+                    for await (const data of sseEvents(res.body)) {
+                        guard.resetIdleTimer();
+                        try {
+                            const json = JSON.parse(data);
+                            if (json.type === 'content_block_start' && json.content_block?.type === 'tool_use') {
+                                partials.set(json.index, { id: json.content_block.id, name: json.content_block.name, json: '' });
+                            }
+                            else if (json.type === 'content_block_delta') {
+                                if (json.delta?.type === 'text_delta') {
+                                    full += json.delta.text;
+                                    onText(json.delta.text);
+                                }
+                                else if (json.delta?.type === 'input_json_delta') {
+                                    const p = partials.get(json.index);
+                                    if (p)
+                                        p.json += json.delta.partial_json ?? '';
+                                }
+                            }
+                            else if (json.type === 'content_block_stop') {
+                                const p = partials.get(json.index);
+                                if (p) {
+                                    let args = {};
+                                    try {
+                                        args = p.json ? JSON.parse(p.json) : {};
+                                    }
+                                    catch {
+                                        args = {};
+                                    }
+                                    toolCalls.push({ id: p.id, name: p.name, arguments: args });
+                                    partials.delete(json.index);
+                                }
+                            }
+                            accumulateUsage(json, usage);
+                        }
+                        catch {
+                            // Ignore malformed/keep-alive chunks
+                        }
+                    }
+                }
+                catch (e) {
+                    throw guard.wrapStreamError(e);
+                }
+                if (onUsage)
+                    onUsage(usage);
+                return { text: full, toolCalls };
+            }
+            finally {
+                guard.dispose();
+            }
+        },
+        async stream(messages, onText, onUsage) {
             // Anthropic takes the system prompt as a top-level field
             const system = messages
                 .filter((m) => m.role === 'system')
                 .map((m) => m.content)
                 .join('\n\n');
             const chat = messages.filter((m) => m.role !== 'system');
-            const res = await fetch(ANTHROPIC_API, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'x-api-key': apiKey,
-                    'anthropic-version': ANTHROPIC_VERSION,
-                },
-                body: JSON.stringify({
-                    model,
-                    max_tokens: 8192,
-                    ...(system ? { system } : {}),
-                    messages: chat,
-                    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(`anthropic API error (HTTP ${res.status}): ${truncate(body, 300)}`, res.status);
-            }
-            let full = '';
-            for await (const data of sseEvents(res.body)) {
+            const usage = { inputTokens: 0, outputTokens: 0 };
+            const guard = createStreamTimeoutGuard('anthropic');
+            try {
+                const res = await fetch(messagesEndpoint, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'x-api-key': apiKey,
+                        'anthropic-version': ANTHROPIC_VERSION,
+                    },
+                    body: JSON.stringify({
+                        model,
+                        max_tokens: 8192,
+                        ...(system ? { system } : {}),
+                        messages: chat,
+                        stream: true,
+                    }),
+                    signal: guard.signal,
+                }).catch((err) => {
+                    throw guard.wrapNetworkError(err);
+                });
+                if (!res.ok || !res.body) {
+                    const body = await res.text().catch(() => '');
+                    throw new ProviderError(`anthropic API error (HTTP ${res.status}): ${truncate(body, 300)}`, res.status);
+                }
+                let full = '';
                 try {
-                    const json = JSON.parse(data);
-                    if (json.type === 'content_block_delta' && json.delta?.type === 'text_delta') {
-                        const text = json.delta.text;
-                        full += text;
-                        onText(text);
+                    for await (const data of sseEvents(res.body)) {
+                        guard.resetIdleTimer();
+                        try {
+                            const json = JSON.parse(data);
+                            if (json.type === 'content_block_delta' && json.delta?.type === 'text_delta') {
+                                const text = json.delta.text;
+                                full += text;
+                                onText(text);
+                            }
+                            accumulateUsage(json, usage);
+                        }
+                        catch {
+                            // Ignore malformed/keep-alive chunks
+                        }
                     }
                 }
-                catch {
-                    // Ignore malformed/keep-alive chunks
+                catch (e) {
+                    throw guard.wrapStreamError(e);
                 }
+                if (onUsage)
+                    onUsage(usage);
+                return full;
+            }
+            finally {
+                guard.dispose();
             }
-            return full;
         },
     };
 }

package/dist/providers/detect.js

@@ -14,13 +14,28 @@
  * interactive fallback.
  */
 export const PROVIDER_PATTERNS = [
+    // ── Distinctive prefixes (safe auto-detect) ───────────────────────────
     { provider: 'anthropic', pattern: /^sk-ant-/ },
     { provider: 'openrouter', pattern: /^sk-or-/ },
     { provider: 'groq', pattern: /^gsk_/ },
     { provider: 'gemini', pattern: /^AIza/ },
-    // OpenAI: classic `sk-...` and new project keys `sk-proj-...`,
-    // excluding the Anthropic / OpenRouter prefixes above.
-    { provider: 'openai', pattern: /^sk-(?!ant-|or-)/ },
+    { provider: 'cerebras', pattern: /^csk-/ },
+    // Zhipu AI (GLM): <32-char-lowercase-hex>.<alphanumeric>
+    // e.g. b277fbf3dc1045c79229ff3c65a6f89b.fZ3rWjaTnH6UW6rm
+    { provider: 'glm', pattern: /^[0-9a-f]{32}\.[A-Za-z0-9]+$/ },
+    // ── OpenAI project keys (`sk-proj-...`) are distinctive ───────────────
+    { provider: 'openai', pattern: /^sk-proj-/ },
+    // ── Ambiguous `sk-` prefix ────────────────────────────────────────────
+    // DeepSeek and Moonshot (Kimi) also start with `sk-`, just like classic
+    // OpenAI keys. Matching both patterns makes detectProvider() return null
+    // (ambiguous) so the user gets the interactive provider-selection prompt
+    // instead of silently mis-routing to the wrong API.
+    { provider: 'deepseek', pattern: /^sk-[a-z0-9]{32}$/ }, // sk- + 32 lowercase alphanum
+    { provider: 'moonshot', pattern: /^sk-[A-Za-z0-9]{43,}$/ }, // sk- + 43+ mixed alphanum
+    // Classic OpenAI keys (`sk-` without `proj-`, not matching deepseek/moonshot shapes):
+    { provider: 'openai', pattern: /^sk-(?!proj-|ant-|or-)/ },
+    // Qwen (DashScope), Mistral, MiniMax have no distinctive key prefix →
+    // they always fall back to the interactive provider-selection list.
 ];
 /**
  * Sanitize a pasted API key: trim whitespace/newlines and strip

package/dist/providers/index.js

@@ -5,27 +5,50 @@
 import { PROVIDER_INFO } from './types.js';
 import { createAnthropicProvider } from './anthropic.js';
 import { createOpenAICompatProvider } from './openai-compat.js';
+import { defaultModelFor } from './manifest.js';
+export { refreshManifest } from './manifest.js';
 export { detectProvider, sanitizeKey, PROVIDER_PATTERNS } from './detect.js';
 export { PROVIDER_INFO, ProviderError } from './types.js';
 /** Base URLs for the OpenAI-compatible providers. */
 const BASE_URLS = {
+    // ── International ────────────────────────────────────────────────────
     openai: 'https://api.openai.com/v1',
     openrouter: 'https://openrouter.ai/api/v1',
     groq: 'https://api.groq.com/openai/v1',
-    // Gemini's OpenAI-compatibility endpoint
     gemini: 'https://generativelanguage.googleapis.com/v1beta/openai',
+    mistral: 'https://api.mistral.ai/v1',
+    cerebras: 'https://api.cerebras.ai/v1',
+    // ── Chinese AI ───────────────────────────────────────────────────────
+    glm: 'https://open.bigmodel.cn/api/paas/v4', // Zhipu AI — GLM-4-Flash free
+    deepseek: 'https://api.deepseek.com/v1', // DeepSeek V3 — very cheap, free credits
+    qwen: 'https://dashscope-intl.aliyuncs.com/compatible-mode/v1', // Alibaba Qwen — international
+    moonshot: 'https://api.moonshot.cn/v1', // Kimi — free quota on signup
+    minimax: 'https://api.minimax.chat/v1', // MiniMax-Text-01 — free tier
 };
+/**
+ * Provider ids whose APIs reliably support native function-calling. Others
+ * (and unknown URL-based endpoints) fall back to the text `vexi-tool` protocol.
+ */
+const NATIVE_TOOL_PROVIDERS = new Set([
+    'anthropic', 'openai', 'openrouter', 'groq', 'gemini', 'mistral',
+    'cerebras', 'deepseek', 'qwen', 'moonshot', 'glm',
+]);
+/** Whether native function-calling should be used for a given provider id. */
+export function providerSupportsNativeTools(id) {
+    return NATIVE_TOOL_PROVIDERS.has(id);
+}
 export function createProvider(id, apiKey, model) {
-    const resolvedModel = model ?? PROVIDER_INFO[id].defaultModel;
+    const info = PROVIDER_INFO[id];
+    if (!info) {
+        throw new Error(`Unknown provider "${id}". Run \`vexi config reset\` to reconfigure.`);
+    }
+    // Prefer an explicit model, then a remote-manifest default, then the compiled-in default.
+    const resolvedModel = model ?? defaultModelFor(id, info.defaultModel);
     if (id === 'anthropic') {
         return createAnthropicProvider(apiKey, resolvedModel);
     }
     const extraHeaders = id === 'openrouter'
-        ? {
-            // OpenRouter attribution headers (optional but recommended)
-            'HTTP-Referer': 'https://github.com/Elomami1976/vexi',
-            'X-Title': 'Vexi',
-        }
+        ? { 'HTTP-Referer': 'https://vexi.pro', 'X-Title': 'Vexi' }
         : undefined;
     return createOpenAICompatProvider({
         id,
@@ -33,5 +56,35 @@ export function createProvider(id, apiKey, model) {
         apiKey,
         model: resolvedModel,
         extraHeaders,
+        supportsTools: providerSupportsNativeTools(id),
+    });
+}
+/**
+ * Create a provider from a VexiConfig produced by `vexi setup`.
+ * When config.baseUrl is set, uses it directly (URL-based routing).
+ * Falls back to the ProviderId-based createProvider for old configs.
+ */
+export function createProviderFromConfig(config) {
+    if (!config.baseUrl) {
+        // Old-style config: route by ProviderId
+        return createProvider(config.provider, config.apiKey, config.model);
+    }
+    const model = config.model ?? defaultModelFor(config.provider, 'gpt-4o');
+    if (config.provider === 'anthropic') {
+        return createAnthropicProvider(config.apiKey, model, config.baseUrl);
+    }
+    const extraHeaders = config.provider === 'openrouter'
+        ? { 'HTTP-Referer': 'https://vexi.pro', 'X-Title': 'Vexi' }
+        : undefined;
+    // Z.ai GLM-5 models support reasoning_effort for extended thinking
+    const extraBody = model.startsWith('z-ai/glm-5') ? { reasoning_effort: 'high' } : undefined;
+    return createOpenAICompatProvider({
+        id: config.provider,
+        baseUrl: config.baseUrl,
+        apiKey: config.apiKey,
+        model,
+        extraHeaders,
+        extraBody,
+        supportsTools: providerSupportsNativeTools(config.provider),
     });
 }