vexi-cli 0.5.4 → 0.8.0

package/dist/i18n/index.js

@@ -12,13 +12,13 @@
 export const SUPPORTED_LANGS = ['en', 'ar', 'es', 'pt', 'fr'];
 const en = {
     welcome: 'Welcome to Vexi — your AI coding agent in the terminal.',
-    firstRunIntro: 'First run: Vexi needs an API key (Anthropic, OpenAI, OpenRouter, Groq or Gemini).\nIt is stored locally in ~/.vexi/config.json — no login, no server, no telemetry.',
+    firstRunIntro: 'First run: Vexi needs an API key.\nSupported: Anthropic · OpenAI · OpenRouter · Groq · Gemini · GLM · Mistral · Cerebras · DeepSeek · Qwen · Kimi · MiniMax\nIf auto-detection picks the wrong provider, just re-enter your key and select from the list.\nStored locally in ~/.vexi/config.json — no login, no server, no telemetry.',
     enterApiKey: 'Paste your API key',
     detectedProvider: 'Provider detected: {provider}',
     detectFailed: 'Could not auto-detect the provider for this key.',
     selectProvider: 'Select your provider',
     configSaved: 'Saved to {path} (readable only by your OS user).',
-    chatHint: 'Type your message. Commands: /help /model /clear /exit',
+    chatHint: 'Type your message. Commands: /help /model /clear /undo /redo /history /push /exit',
     thinking: 'Thinking…',
     goodbye: 'Goodbye! 👋',
     invalidKey: 'The API key was rejected by the provider (unauthorized).',
@@ -26,7 +26,7 @@ const en = {
     apiError: 'API error: {message}',
     emptyKey: 'No key entered.',
     historyCleared: 'Conversation history cleared.',
-    helpText: '/help    show this help\n/model   switch model (e.g. /model gpt-4o)\n/memory  show compressed project memory\n/clear   clear conversation history\n/exit    quit Vexi',
+    helpText: '/help     show this help\n/model    switch model (e.g. /model gpt-4o)\n/memory   show compressed project memory\n/clear    clear conversation history\n/undo     revert last AI file edit\n/redo     re-apply last undone edit\n/history  list recent AI file edits\n/push     stage, commit and push to git (/push --only to skip commit)\n/exit     quit Vexi',
     modelSwitched: 'Model switched to {model}',
     configReset: 'Configuration deleted. Run `vexi` to set up again.',
     configResetNone: 'No configuration found.',
@@ -59,16 +59,24 @@ const en = {
     learnPreview: 'Learned from {sessions} sessions ({signals} corrections found):',
     learnApplyHint: 'Looks right? Save it with: vexi learn --apply',
     learnApplied: 'Learned style saved: {path} — now injected into every session.',
+    undoNone: 'Nothing to undo — no file snapshots in this session.',
+    undoDone: 'Reverted: {files}',
+    redoNone: 'Nothing to redo.',
+    redoDone: 'Re-applied: {files}',
+    historyNone: 'No file snapshots yet — make some AI edits first.',
+    historyHeader: 'Recent AI file edits (newest first):',
+    cleanDone: 'Cleaned {count} old snapshot session(s).',
+    snapshotNoSession: 'No active Vexi session found. Run `vexi` first to start a session.',
 };
 const es = {
     welcome: 'Bienvenido a Vexi — tu agente de programación con IA en la terminal.',
-    firstRunIntro: 'Primer uso: Vexi necesita una clave API (Anthropic, OpenAI, OpenRouter, Groq o Gemini).\nSe guarda localmente en ~/.vexi/config.json — sin registro, sin servidor, sin telemetría.',
+    firstRunIntro: 'Primer uso: Vexi necesita una clave API.\nCompatibles (varios son gratuitos): Anthropic · OpenAI · OpenRouter · Groq · Gemini · GLM · Mistral · Cerebras\nGuardada en ~/.vexi/config.json — sin registro, sin servidor, sin telemetría.',
     enterApiKey: 'Pega tu clave API',
     detectedProvider: 'Proveedor detectado: {provider}',
     detectFailed: 'No se pudo detectar automáticamente el proveedor de esta clave.',
     selectProvider: 'Selecciona tu proveedor',
     configSaved: 'Guardado en {path} (solo legible por tu usuario del sistema).',
-    chatHint: 'Escribe tu mensaje. Comandos: /help /model /clear /exit',
+    chatHint: 'Escribe tu mensaje. Comandos: /help /model /clear /push /exit',
     thinking: 'Pensando…',
     goodbye: '¡Hasta luego! 👋',
     invalidKey: 'El proveedor rechazó la clave API (no autorizada).',
@@ -76,7 +84,7 @@ const es = {
     apiError: 'Error de API: {message}',
     emptyKey: 'No se introdujo ninguna clave.',
     historyCleared: 'Historial de conversación borrado.',
-    helpText: '/help    mostrar esta ayuda\n/model   cambiar modelo (p. ej. /model gpt-4o)\n/memory  ver la memoria comprimida del proyecto\n/clear   borrar historial de conversación\n/exit    salir de Vexi',
+    helpText: '/help    mostrar esta ayuda\n/model   cambiar modelo (p. ej. /model gpt-4o)\n/memory  ver la memoria comprimida del proyecto\n/clear   borrar historial de conversación\n/push    confirmar y enviar cambios a git\n/exit    salir de Vexi',
     modelSwitched: 'Modelo cambiado a {model}',
     configReset: 'Configuración eliminada. Ejecuta `vexi` para configurar de nuevo.',
     configResetNone: 'No se encontró configuración.',
@@ -109,16 +117,24 @@ const es = {
     learnPreview: 'Aprendido de {sessions} sesiones ({signals} correcciones encontradas):',
     learnApplyHint: '¿Se ve bien? Guárdalo con: vexi learn --apply',
     learnApplied: 'Estilo aprendido guardado: {path} — ahora se inyecta en cada sesión.',
+    undoNone: 'Nada que deshacer — no hay instantáneas de archivos en esta sesión.',
+    undoDone: 'Revertido: {files}',
+    redoNone: 'Nada que rehacer.',
+    redoDone: 'Reaplicado: {files}',
+    historyNone: 'Aún no hay instantáneas de archivos — haz ediciones con IA primero.',
+    historyHeader: 'Ediciones de archivos recientes de la IA (más recientes primero):',
+    cleanDone: 'Se eliminaron {count} sesión(es) de instantáneas antiguas.',
+    snapshotNoSession: 'No se encontró ninguna sesión activa de Vexi. Ejecuta `vexi` primero.',
 };
 const pt = {
     welcome: 'Bem-vindo ao Vexi — seu agente de programação com IA no terminal.',
-    firstRunIntro: 'Primeira execução: o Vexi precisa de uma chave de API (Anthropic, OpenAI, OpenRouter, Groq ou Gemini).\nEla é guardada localmente em ~/.vexi/config.json — sem login, sem servidor, sem telemetria.',
+    firstRunIntro: 'Primeira execução: o Vexi precisa de uma chave de API.\nCompatíveis (vários gratuitos): Anthropic · OpenAI · OpenRouter · Groq · Gemini · GLM · Mistral · Cerebras\nGuardada em ~/.vexi/config.json — sem login, sem servidor, sem telemetria.',
     enterApiKey: 'Cole sua chave de API',
     detectedProvider: 'Provedor detectado: {provider}',
     detectFailed: 'Não foi possível detectar automaticamente o provedor desta chave.',
     selectProvider: 'Selecione seu provedor',
     configSaved: 'Salvo em {path} (legível apenas pelo seu usuário do sistema).',
-    chatHint: 'Digite sua mensagem. Comandos: /help /model /clear /exit',
+    chatHint: 'Digite sua mensagem. Comandos: /help /model /clear /push /exit',
     thinking: 'Pensando…',
     goodbye: 'Até logo! 👋',
     invalidKey: 'O provedor rejeitou a chave de API (não autorizada).',
@@ -126,7 +142,7 @@ const pt = {
     apiError: 'Erro de API: {message}',
     emptyKey: 'Nenhuma chave inserida.',
     historyCleared: 'Histórico de conversa apagado.',
-    helpText: '/help    mostrar esta ajuda\n/model   trocar modelo (ex.: /model gpt-4o)\n/memory  ver a memória comprimida do projeto\n/clear   apagar histórico de conversa\n/exit    sair do Vexi',
+    helpText: '/help    mostrar esta ajuda\n/model   trocar modelo (ex.: /model gpt-4o)\n/memory  ver a memória comprimida do projeto\n/clear   apagar histórico de conversa\n/push    confirmar e enviar mudanças ao git\n/exit    sair do Vexi',
     modelSwitched: 'Modelo alterado para {model}',
     configReset: 'Configuração excluída. Execute `vexi` para configurar novamente.',
     configResetNone: 'Nenhuma configuração encontrada.',
@@ -159,16 +175,24 @@ const pt = {
     learnPreview: 'Aprendido de {sessions} sessões ({signals} correções encontradas):',
     learnApplyHint: 'Parece certo? Salve com: vexi learn --apply',
     learnApplied: 'Estilo aprendido salvo: {path} — agora é injetado em cada sessão.',
+    undoNone: 'Nada a desfazer — sem instantâneos de arquivos nesta sessão.',
+    undoDone: 'Revertido: {files}',
+    redoNone: 'Nada a refazer.',
+    redoDone: 'Reaplicado: {files}',
+    historyNone: 'Ainda não há instantâneos de arquivos — faça edições com IA primeiro.',
+    historyHeader: 'Edições de arquivos recentes da IA (mais recentes primeiro):',
+    cleanDone: 'Foram removidas {count} sessão(ões) de instantâneos antigas.',
+    snapshotNoSession: 'Nenhuma sessão ativa do Vexi encontrada. Execute `vexi` primeiro.',
 };
 const fr = {
     welcome: 'Bienvenue dans Vexi — votre agent de codage IA dans le terminal.',
-    firstRunIntro: 'Première utilisation : Vexi a besoin d\'une clé API (Anthropic, OpenAI, OpenRouter, Groq ou Gemini).\nElle est stockée localement dans ~/.vexi/config.json — sans compte, sans serveur, sans télémétrie.',
+    firstRunIntro: 'Première utilisation : Vexi a besoin d\'une clé API.\nCompatibles (plusieurs gratuits) : Anthropic · OpenAI · OpenRouter · Groq · Gemini · GLM · Mistral · Cerebras\nStockée dans ~/.vexi/config.json — sans compte, sans serveur, sans télémétrie.',
     enterApiKey: 'Collez votre clé API',
     detectedProvider: 'Fournisseur détecté : {provider}',
     detectFailed: 'Impossible de détecter automatiquement le fournisseur de cette clé.',
     selectProvider: 'Sélectionnez votre fournisseur',
     configSaved: 'Enregistré dans {path} (lisible uniquement par votre utilisateur système).',
-    chatHint: 'Tapez votre message. Commandes : /help /model /clear /exit',
+    chatHint: 'Tapez votre message. Commandes : /help /model /clear /push /exit',
     thinking: 'Réflexion…',
     goodbye: 'À bientôt ! 👋',
     invalidKey: 'La clé API a été rejetée par le fournisseur (non autorisée).',
@@ -176,7 +200,7 @@ const fr = {
     apiError: 'Erreur API : {message}',
     emptyKey: 'Aucune clé saisie.',
     historyCleared: 'Historique de conversation effacé.',
-    helpText: '/help    afficher cette aide\n/model   changer de modèle (ex. /model gpt-4o)\n/memory  voir la mémoire compressée du projet\n/clear   effacer l\'historique de conversation\n/exit    quitter Vexi',
+    helpText: '/help    afficher cette aide\n/model   changer de modèle (ex. /model gpt-4o)\n/memory  voir la mémoire compressée du projet\n/clear   effacer l\'historique de conversation\n/push    valider et pousser les modifications git\n/exit    quitter Vexi',
     modelSwitched: 'Modèle changé pour {model}',
     configReset: 'Configuration supprimée. Lancez `vexi` pour reconfigurer.',
     configResetNone: 'Aucune configuration trouvée.',
@@ -209,6 +233,14 @@ const fr = {
     learnPreview: 'Appris de {sessions} sessions ({signals} corrections trouvées) :',
     learnApplyHint: 'Ça vous convient ? Enregistrez avec : vexi learn --apply',
     learnApplied: 'Style appris enregistré : {path} — désormais injecté dans chaque session.',
+    undoNone: 'Rien à annuler — aucun instantané de fichier dans cette session.',
+    undoDone: 'Rétabli : {files}',
+    redoNone: 'Rien à rétablir.',
+    redoDone: 'Réappliqué : {files}',
+    historyNone: 'Pas encore d\'instantanés de fichiers — effectuez d\'abord des modifications avec l\'IA.',
+    historyHeader: 'Modifications de fichiers récentes de l\'IA (plus récentes en premier) :',
+    cleanDone: '{count} session(s) d\'instantanés ancienne(s) supprimée(s).',
+    snapshotNoSession: 'Aucune session Vexi active trouvée. Exécutez `vexi` d\'abord.',
 };
 const STRINGS = {
     en,

package/dist/mcp/client.js

@@ -9,6 +9,8 @@
  */
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { z } from 'zod';
+import { VERSION } from '../version.js';
 import { loadMcpConfig } from './config.js';
 export class McpManager {
     connections = [];
@@ -26,7 +28,7 @@ export class McpManager {
                     env: { ...process.env, ...server.env },
                     stderr: 'ignore',
                 });
-                const client = new Client({ name: 'vexi', version: '0.5.0' });
+                const client = new Client({ name: 'vexi', version: VERSION });
                 await client.connect(transport);
                 const { tools } = await client.listTools();
                 for (const tool of tools) {
@@ -46,12 +48,16 @@ export class McpManager {
         }
         return { connected, failed };
     }
+    static ArgsSchema = z.record(z.string(), z.unknown());
     /** Call a tool on a connected server; returns the text result. */
     async callTool(server, tool, args) {
         const connection = this.connections.find((c) => c.name === server);
         if (!connection)
             throw new Error(`MCP server "${server}" is not connected.`);
-        const result = await connection.client.callTool({ name: tool, arguments: args });
+        const parsed = McpManager.ArgsSchema.safeParse(args);
+        if (!parsed.success)
+            throw new Error(`Invalid tool arguments: ${parsed.error.message}`);
+        const result = await connection.client.callTool({ name: tool, arguments: parsed.data });
         const content = Array.isArray(result.content) ? result.content : [];
         const text = content
             .map((c) => (c.type === 'text' ? (c.text ?? '') : `[${c.type}]`))

package/dist/mcp/server.js

@@ -23,8 +23,9 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { z } from 'zod';
+import { VERSION } from '../version.js';
 import { loadConfig } from '../config.js';
-import { createProvider } from '../providers/index.js';
+import { createProviderFromConfig } from '../providers/index.js';
 import { scanProject, projectSummary } from '../scanner/index.js';
 import { loadMemory, memoryBlock } from '../memory/index.js';
 import { listSessions } from '../replay/recorder.js';
@@ -32,7 +33,7 @@ import { gatherSource, buildExplainMessages } from '../explain/index.js';
 import { SUPPORTED_LANGS } from '../i18n/index.js';
 export async function runMcpServer() {
     const root = process.cwd();
-    const server = new McpServer({ name: 'vexi', version: '0.5.0' });
+    const server = new McpServer({ name: 'vexi', version: VERSION });
     // ── Resources ──────────────────────────────────────────────────────────
     server.registerResource('project-map', 'vexi://project', {
         title: 'Project map',
@@ -92,7 +93,7 @@ export async function runMcpServer() {
             };
         }
         try {
-            const provider = createProvider(config.provider, config.apiKey, config.model);
+            const provider = createProviderFromConfig(config);
             const source = await gatherSource(path);
             const markdown = await provider.stream(buildExplainMessages(source, language), () => { });
             return { content: [{ type: 'text', text: markdown }] };

package/dist/memory/compress.test.js

@@ -0,0 +1,52 @@
+import { describe, it, expect } from 'vitest';
+import { compressIntoMemory, KEEP_RECENT, COMPRESS_INTERVAL } from './index.js';
+function makeMessages(n) {
+    return Array.from({ length: n }, (_, i) => ({
+        role: (i % 2 === 0 ? 'user' : 'assistant'),
+        content: `message ${i}`,
+    }));
+}
+const failingProvider = {
+    id: 'openai',
+    model: 'gpt-4o',
+    stream: async () => { throw new Error('provider failure'); },
+};
+const emptyMemory = {
+    version: 1,
+    summary: '',
+    decisions: [],
+    updatedAt: '',
+    compressedCount: 0,
+};
+describe('Fix 1: maybeCompress data-loss guard', () => {
+    it('returns original memory unchanged when provider.stream throws', async () => {
+        const messages = makeMessages(KEEP_RECENT + COMPRESS_INTERVAL + 2);
+        const original = { ...emptyMemory, summary: 'prior summary' };
+        const result = await compressIntoMemory(failingProvider, original, messages);
+        expect(result).toBe(original); // same reference — not mutated, not replaced
+        expect(result.summary).toBe('prior summary');
+    });
+    it('returns original memory when provider returns malformed JSON', async () => {
+        const badProvider = {
+            id: 'openai',
+            model: 'gpt-4o',
+            stream: async () => 'this is not json at all',
+        };
+        const original = { ...emptyMemory, decisions: ['keep this'] };
+        const result = await compressIntoMemory(badProvider, original, makeMessages(4));
+        expect(result).toBe(original);
+        expect(result.decisions).toEqual(['keep this']);
+    });
+    it('returns updated memory when provider returns valid JSON', async () => {
+        const goodProvider = {
+            id: 'openai',
+            model: 'gpt-4o',
+            stream: async () => '{"summary":"new summary","decisions":["decision A"]}',
+        };
+        const original = { ...emptyMemory };
+        const result = await compressIntoMemory(goodProvider, original, makeMessages(4));
+        expect(result).not.toBe(original);
+        expect(result.summary).toBe('new summary');
+        expect(result.decisions).toEqual(['decision A']);
+    });
+});

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

@@ -5,9 +5,10 @@
  */
 import { ProviderError } from './types.js';
 import { sseEvents, truncate } from './openai-compat.js';
-const ANTHROPIC_API = 'https://api.anthropic.com/v1/messages';
+const ANTHROPIC_BASE = 'https://api.anthropic.com/v1';
 const ANTHROPIC_VERSION = '2023-06-01';
-export function createAnthropicProvider(apiKey, model) {
+export function createAnthropicProvider(apiKey, model, baseUrl) {
+    const messagesEndpoint = `${baseUrl ?? ANTHROPIC_BASE}/messages`;
     return {
         id: 'anthropic',
         model,
@@ -18,7 +19,7 @@ export function createAnthropicProvider(apiKey, model) {
                 .map((m) => m.content)
                 .join('\n\n');
             const chat = messages.filter((m) => m.role !== 'system');
-            const res = await fetch(ANTHROPIC_API, {
+            const res = await fetch(messagesEndpoint, {
                 method: 'POST',
                 headers: {
                     'Content-Type': 'application/json',

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

@@ -9,23 +9,31 @@ 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
 };
 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.`);
+    }
+    const resolvedModel = model ?? 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,
@@ -35,3 +43,31 @@ export function createProvider(id, apiKey, model) {
         extraHeaders,
     });
 }
+/**
+ * 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 ?? '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,
+    });
+}

package/dist/providers/openai-compat.js

@@ -23,6 +23,7 @@ export function createOpenAICompatProvider(opts) {
                     model: opts.model,
                     messages,
                     stream: true,
+                    ...opts.extraBody,
                 }),
             }).catch((err) => {
                 throw new ProviderError(`Network error: ${err.message}`);