agent-mp 0.5.36 → 0.5.38

package/dist/commands/repl.d.ts

@@ -1,5 +1,7 @@
+import * as readline from 'readline';
 import { CliInfo } from '../types.js';
 import { Session } from '../utils/sessions.js';
+export declare function cmdLogin(rl: readline.Interface): Promise<boolean>;
 /**
  * Shared coordinator setup: detect CLIs, pick coordinator, check auth.
  * Returns { coordinatorCmd, activeCli, installed, rl } or null if setup failed.

package/dist/commands/repl.js

@@ -11,7 +11,8 @@ import { loadAuth, saveAuth, loadCliConfig, saveCliConfig, loadProjectConfig, re
 import { log } from '../utils/logger.js';
 import { AgentEngine, ExitError } from '../core/engine.js';
 import { qwenAuthStatus, QWEN_AGENT_HOME, fetchQwenModels, loadApiKeyConfig, saveApiKeyConfig, fetchApiKeyModels, DEFAULT_API_BASE_URL } from '../utils/qwen-auth.js';
-import { loadGeminiApiKey, saveGeminiApiKey, geminiAuthStatus, deleteGeminiApiKey, GEMINI_MODELS } from '../utils/gemini.js';
+import { loadGeminiApiKey, saveGeminiApiKey, geminiAuthStatus, deleteGeminiApiKey, GEMINI_MODELS, fetchGeminiModels } from '../utils/gemini.js';
+import { loadDeepSeekApiKey, saveDeepSeekApiKey, deleteDeepSeekApiKey, DEEPSEEK_MODELS, fetchDeepSeekModels } from '../utils/deepseek.js';
 import { renderWelcomePanel, renderHelpHint, renderSectionBox, renderMultiSectionBox } from '../ui/theme.js';
 import { FixedInput } from '../ui/input.js';
 import { newSession, saveSession } from '../utils/sessions.js';
@@ -314,33 +315,88 @@ async function promptGeminiKeySetup(rl, askFn) {
         console.log(chalk.red('  API key es requerida.'));
         return false;
     }
-    console.log(chalk.bold('\n  Modelos disponibles:'));
-    GEMINI_MODELS.forEach((m, i) => console.log(chalk.dim(`    ${i + 1}. ${m}`)));
+    console.log(chalk.dim('\n  Fetching available models...'));
+    const tempCfg = { api_key: resolvedKey, model: '' };
+    const models = await fetchGeminiModels(tempCfg);
     const defaultModel = existing?.model ?? 'gemini-2.5-flash';
-    const pick = await askFn(`\n  Modelo [${defaultModel}]: `);
-    const num = parseInt(pick.trim());
     let chosenModel = defaultModel;
-    if (!isNaN(num) && num >= 1 && num <= GEMINI_MODELS.length) {
-        chosenModel = GEMINI_MODELS[num - 1];
+    if (models.length > 0) {
+        console.log(chalk.bold('\n  Modelos disponibles:'));
+        models.forEach((m, i) => console.log(chalk.dim(`    ${i + 1}. ${m}`)));
+        const pick = await askFn(`\n  Modelo [${chosenModel}]: `);
+        const num = parseInt(pick.trim());
+        if (!isNaN(num) && num >= 1 && num <= models.length) {
+            chosenModel = models[num - 1];
+        }
+        else if (pick.trim()) {
+            chosenModel = pick.trim();
+        }
     }
-    else if (pick.trim()) {
-        chosenModel = pick.trim();
+    else {
+        console.log(chalk.yellow('  No se pudieron cargar modelos de la API — usando lista estática.'));
+        GEMINI_MODELS.forEach((m, i) => console.log(chalk.dim(`    ${i + 1}. ${m}`)));
+        const pick = await askFn(`  Modelo [${chosenModel}]: `);
+        if (pick.trim())
+            chosenModel = pick.trim();
     }
     await saveGeminiApiKey({ api_key: resolvedKey, model: chosenModel });
     console.log(chalk.green(`\n  ✓ Gemini API key guardada — ${chosenModel}\n`));
     return true;
 }
-async function cmdLogin(rl) {
+async function promptDeepseekKeySetup(rl, askFn) {
+    const existing = await loadDeepSeekApiKey();
+    if (existing) {
+        console.log(chalk.dim(`  Current: DeepSeek / ${existing.model}`));
+    }
+    const apiKey = await askFn(`  DeepSeek API Key${existing ? ' [Enter to keep]' : ''}: `);
+    const resolvedKey = apiKey.trim() || existing?.api_key || '';
+    if (!resolvedKey) {
+        console.log(chalk.red('  API key es requerida.'));
+        return false;
+    }
+    console.log(chalk.dim('\n  Fetching available models...'));
+    const tempCfg = { api_key: resolvedKey, model: '' };
+    const models = await fetchDeepSeekModels(tempCfg);
+    const defaultModel = existing?.model ?? 'deepseek-chat';
+    let chosenModel = defaultModel;
+    if (models.length > 0) {
+        console.log(chalk.bold('\n  Modelos disponibles:'));
+        models.forEach((m, i) => console.log(chalk.dim(`    ${i + 1}. ${m}`)));
+        const pick = await askFn(`\n  Modelo [${chosenModel}]: `);
+        const num = parseInt(pick.trim());
+        if (!isNaN(num) && num >= 1 && num <= models.length) {
+            chosenModel = models[num - 1];
+        }
+        else if (pick.trim()) {
+            chosenModel = pick.trim();
+        }
+    }
+    else {
+        console.log(chalk.yellow('  No se pudieron cargar modelos de la API — usando lista estática.'));
+        DEEPSEEK_MODELS.forEach((m, i) => console.log(chalk.dim(`    ${i + 1}. ${m}`)));
+        const pick = await askFn(`  Modelo [${chosenModel}]: `);
+        if (pick.trim())
+            chosenModel = pick.trim();
+    }
+    await saveDeepSeekApiKey({ api_key: resolvedKey, model: chosenModel });
+    console.log(chalk.green(`\n  ✓ DeepSeek API key guardada — ${chosenModel}\n`));
+    return true;
+}
+export async function cmdLogin(rl) {
     console.log(chalk.bold.cyan('\n  Configure API Key\n'));
     console.log(chalk.bold('  Proveedor:'));
     console.log(chalk.dim('    1. Qwen / OpenAI-compatible'));
     console.log(chalk.dim('    2. Google Gemini'));
+    console.log(chalk.dim('    3. DeepSeek'));
     console.log('');
     const pick = await ask(rl, '  Elegí [1]: ');
     const choice = pick.trim() || '1';
     if (choice === '2') {
         return promptGeminiKeySetup(rl, (q) => ask(rl, q));
     }
+    if (choice === '3') {
+        return promptDeepseekKeySetup(rl, (q) => ask(rl, q));
+    }
     return promptApiKeySetup(rl, (q) => ask(rl, q));
 }
 async function cmdSetup(rl) {
@@ -676,17 +732,30 @@ async function cmdStatus(fi) {
 }
 async function cmdModels(roleArg, fi, rl) {
     const geminiCfg = await loadGeminiApiKey();
+    const deepseekCfg = await loadDeepSeekApiKey();
     const apiKeyCfg = await loadApiKeyConfig();
     const auth = await loadAuth();
     // Determine active provider from current gCoordinatorCmd
     const isGeminiActive = gCoordinatorCmd.startsWith('gemini-direct');
-    const activeProvider = isGeminiActive ? 'gemini' : (apiKeyCfg?.provider ?? auth.entries[0]?.provider ?? '');
+    const isDeepSeekActive = gCoordinatorCmd.startsWith('deepseek-direct');
+    const activeProvider = isGeminiActive ? 'gemini'
+        : isDeepSeekActive ? 'deepseek'
+            : (apiKeyCfg?.provider ?? auth.entries[0]?.provider ?? '');
     const resume = fi.suspend();
     const cliConfig = await loadCliConfig();
     const currentModel = cliConfig.coordinatorModel ?? '(auto)';
     let models;
     if (isGeminiActive || activeProvider === 'gemini') {
-        models = GEMINI_MODELS;
+        console.log(chalk.dim('  Fetching Gemini models...'));
+        models = await fetchGeminiModels(geminiCfg);
+        if (!models.length)
+            models = GEMINI_MODELS;
+    }
+    else if (isDeepSeekActive || activeProvider === 'deepseek') {
+        console.log(chalk.dim('  Fetching DeepSeek models...'));
+        models = await fetchDeepSeekModels(deepseekCfg);
+        if (!models.length)
+            models = DEEPSEEK_MODELS;
     }
     else if (activeProvider === 'qwen') {
         console.log(chalk.dim('  Fetching Qwen models...'));
@@ -726,6 +795,11 @@ async function cmdModels(roleArg, fi, rl) {
         if (geminiCfg)
             await saveGeminiApiKey({ ...geminiCfg, model: selectedModel });
     }
+    else if (isDeepSeekActive || activeProvider === 'deepseek') {
+        gCoordinatorCmd = `deepseek-direct -m ${selectedModel}`;
+        if (deepseekCfg)
+            await saveDeepSeekApiKey({ ...deepseekCfg, model: selectedModel });
+    }
     else {
         gCoordinatorCmd = buildCmd(activeProvider, selectedModel);
     }
@@ -736,24 +810,29 @@ async function cmdModels(roleArg, fi, rl) {
 /** /provider — switch coordinator provider between configured ones */
 async function cmdProvider(fi, rl) {
     const geminiCfg = await loadGeminiApiKey();
+    const deepseekCfg = await loadDeepSeekApiKey();
     const apiKeyCfg = await loadApiKeyConfig();
     const options = [];
     if (geminiCfg?.api_key)
         options.push({ label: `Google Gemini (${geminiCfg.model})`, value: 'gemini' });
+    if (deepseekCfg?.api_key)
+        options.push({ label: `DeepSeek (${deepseekCfg.model})`, value: 'deepseek' });
     if (apiKeyCfg?.api_key)
         options.push({ label: `${apiKeyCfg.provider} (${apiKeyCfg.model})`, value: apiKeyCfg.provider });
     if (options.length === 0) {
         fi.println(chalk.yellow('  No hay proveedores configurados.'));
-        fi.println(chalk.dim('  Usá /login para configurar Qwen o Google Gemini.'));
+        fi.println(chalk.dim('  Usá /login para configurar Qwen, Gemini o DeepSeek.'));
         return;
     }
     if (options.length === 1) {
         fi.println(chalk.dim(`  Activo: ${options[0].label}`));
-        fi.println(chalk.dim('  Para agregar Google Gemini: /login → elegí opción 2.'));
+        fi.println(chalk.dim('  Para agregar otro: /login'));
         return;
     }
     const resume = fi.suspend();
-    const current = gCoordinatorCmd.startsWith('gemini-direct') ? 'gemini' : (apiKeyCfg?.provider ?? '?');
+    const isGeminiActive = gCoordinatorCmd.startsWith('gemini-direct');
+    const isDeepSeekActive = gCoordinatorCmd.startsWith('deepseek-direct');
+    const current = isGeminiActive ? 'gemini' : isDeepSeekActive ? 'deepseek' : (apiKeyCfg?.provider ?? '?');
     console.log(chalk.bold.cyan(`\n  Cambiar proveedor  [activo: ${current}]\n`));
     options.forEach((o, i) => console.log(chalk.dim(`  ${i + 1}. ${o.label}`)));
     const pick = await ask(rl, chalk.bold('\n  Proveedor # (Enter to keep): '));
@@ -771,10 +850,17 @@ async function cmdProvider(fi, rl) {
     const cliConfig = await loadCliConfig();
     if (chosen.value === 'gemini') {
         gCoordinatorCmd = `gemini-direct -m ${geminiCfg.model}`;
+        cliConfig.coordinatorProvider = 'gemini';
+    }
+    else if (chosen.value === 'deepseek') {
+        gCoordinatorCmd = `deepseek-direct -m ${deepseekCfg.model}`;
+        cliConfig.coordinatorProvider = 'deepseek';
     }
     else {
         gCoordinatorCmd = `qwen-direct -m ${apiKeyCfg.model}`;
+        cliConfig.coordinatorProvider = apiKeyCfg.provider;
     }
+    await saveCliConfig(cliConfig);
     fi.println(chalk.green(`\n  ✓ Proveedor → ${chosen.label}`));
     fi.println(chalk.dim(`  CMD: ${gCoordinatorCmd}`));
     fi.println('');
@@ -859,8 +945,8 @@ function cmdHelp(fi) {
         { key: '/impl <task-id>', value: 'Lanza SOLO implementor — ejecuta plan existente' },
         { key: '/rev <task-id>', value: 'Lanza SOLO reviewer — valida implementación' },
         { key: '/model', value: 'Cambiar modelo del coordinador' },
-        { key: '/provider', value: 'Cambiar proveedor activo (Gemini / Qwen)' },
-        { key: '/login', value: 'Configurar API key (Qwen o Gemini)' },
+        { key: '/provider', value: 'Cambiar proveedor activo (Gemini / DeepSeek / Qwen)' },
+        { key: '/login', value: 'Configurar API key (Qwen, Gemini o DeepSeek)' },
         { key: '/logout', value: 'Logout and clear credentials' },
         { key: '/auth-status', value: 'Show authentication status' },
         { key: '/usage', value: 'Check quota status for all role CLIs' },
@@ -911,21 +997,59 @@ export async function initCoordinator() {
             console.log(chalk.red('  No CLIs detected. Install at least one: qwen, claude, gemini, codex'));
             return null;
         }
-        // Step 2: Pick coordinator
+        // Step 2: Pick coordinator — respect saved preference first
         const auth = await loadAuth();
         const currentAuth = auth.activeProvider;
         let activeCli = installed.find((c) => c.name === currentAuth);
-        // Fast-path: Gemini API key configured
-        const geminiCfg = await loadGeminiApiKey();
-        if (geminiCfg?.api_key) {
-            gCoordinatorCmd = `gemini-direct -m ${geminiCfg.model}`;
-            console.log(chalk.green(`  ✓ Auth: Google Gemini / ${geminiCfg.model}\n`));
-            const syntheticCli = {
-                name: 'gemini',
-                info: { command: 'gemini-direct', modelFlag: '-m', promptFlag: '-p', description: 'Gemini API key' },
-                path: 'gemini-direct',
-            };
-            return { activeCli: syntheticCli, installed, coordinatorCmd: gCoordinatorCmd };
+        // Check saved coordinatorProvider preference
+        const cliConfig = await loadCliConfig();
+        const savedProvider = cliConfig.coordinatorProvider;
+        // Helper: try to activate a specific provider
+        const tryProvider = async (provider) => {
+            if (provider === 'gemini') {
+                const cfg = await loadGeminiApiKey();
+                if (cfg?.api_key) {
+                    return {
+                        syntheticCli: { name: 'gemini', info: { command: 'gemini-direct', modelFlag: '-m', promptFlag: '-p', description: 'Gemini API key' }, path: 'gemini-direct' },
+                        cmd: `gemini-direct -m ${cfg.model}`,
+                    };
+                }
+            }
+            if (provider === 'deepseek') {
+                const cfg = await loadDeepSeekApiKey();
+                if (cfg?.api_key) {
+                    return {
+                        syntheticCli: { name: 'deepseek', info: { command: 'deepseek-direct', modelFlag: '-m', promptFlag: '-p', description: 'DeepSeek API key' }, path: 'deepseek-direct' },
+                        cmd: `deepseek-direct -m ${cfg.model}`,
+                    };
+                }
+            }
+            const apiKeyCfg = await loadApiKeyConfig();
+            if (apiKeyCfg?.api_key && apiKeyCfg.provider === provider) {
+                return {
+                    syntheticCli: { name: apiKeyCfg.provider, info: { command: 'qwen-direct', modelFlag: '-m', promptFlag: '-p', description: 'API key' }, path: 'qwen-direct' },
+                    cmd: `qwen-direct -m ${apiKeyCfg.model}`,
+                };
+            }
+            return null;
+        };
+        // Try saved provider first
+        if (savedProvider) {
+            const saved = await tryProvider(savedProvider);
+            if (saved) {
+                gCoordinatorCmd = saved.cmd;
+                console.log(chalk.green(`  ✓ Auth: ${saved.syntheticCli.name} / ${saved.cmd.match(/-m\s+(\S+)/)?.[1] ?? '?'}\n`));
+                return { activeCli: saved.syntheticCli, installed, coordinatorCmd: gCoordinatorCmd };
+            }
+        }
+        // Fallback: try providers in default order
+        for (const p of ['gemini', 'deepseek']) {
+            const r = await tryProvider(p);
+            if (r) {
+                gCoordinatorCmd = r.cmd;
+                console.log(chalk.green(`  ✓ Auth: ${r.syntheticCli.name} / ${r.cmd.match(/-m\s+(\S+)/)?.[1] ?? '?'}\n`));
+                return { activeCli: r.syntheticCli, installed, coordinatorCmd: gCoordinatorCmd };
+            }
         }
         // Fast-path: Qwen/OpenAI-compatible API key configured
         const apiKeyCfg = await loadApiKeyConfig();
@@ -947,8 +1071,7 @@ export async function initCoordinator() {
         });
         if (doSetup) {
             const askFn = (q) => new Promise((resolve) => rl.question(q, resolve));
-            // Ask provider
-            rl.question('  Provider: 1=Qwen/OpenAI-compatible  2=Google Gemini [1]: ', async () => { });
+            rl.question('  Provider: 1=Qwen/OpenAI-compatible  2=Google Gemini  3=DeepSeek [1]: ', async () => { });
             const providerPick = await new Promise((resolve) => rl.question('  Provider [1]: ', resolve));
             if (providerPick.trim() === '2') {
                 const ok = await promptGeminiKeySetup(rl, askFn);
@@ -965,6 +1088,21 @@ export async function initCoordinator() {
                 };
                 return { coordinatorCmd: gCoordinatorCmd, activeCli: syntheticCli, installed };
             }
+            if (providerPick.trim() === '3') {
+                const ok = await promptDeepseekKeySetup(rl, askFn);
+                if (!ok)
+                    return null;
+                const saved = await loadDeepSeekApiKey();
+                if (!saved)
+                    return null;
+                gCoordinatorCmd = `deepseek-direct -m ${saved.model}`;
+                const syntheticCli = {
+                    name: 'deepseek',
+                    info: { command: 'deepseek-direct', modelFlag: '-m', promptFlag: '-p', description: 'DeepSeek API key' },
+                    path: 'deepseek-direct',
+                };
+                return { coordinatorCmd: gCoordinatorCmd, activeCli: syntheticCli, installed };
+            }
             const ok = await promptApiKeySetup(rl, askFn);
             if (!ok)
                 return null;
@@ -1267,6 +1405,7 @@ export async function runRepl(resumeSession) {
                 await fs.unlink(path.join(QWEN_AGENT_HOME, 'oauth_creds.json')).catch(() => { });
                 await fs.unlink(await getApiKeyConfigPath()).catch(() => { });
                 await deleteGeminiApiKey();
+                await deleteDeepSeekApiKey();
                 const authStore = await loadAuth();
                 authStore.entries = [];
                 delete authStore.activeProvider;

package/dist/core/engine.js

@@ -8,6 +8,7 @@ import { log } from '../utils/logger.js';
 import chalk from 'chalk';
 import { callQwenAPI, callQwenAPIFromCreds } from '../utils/qwen-auth.js';
 import { callGeminiAPI } from '../utils/gemini.js';
+import { callDeepSeekAPI } from '../utils/deepseek.js';
 import * as fs from 'fs/promises';
 /** Thrown when a slash command inside a conversation requests exit */
 export class ExitError extends Error {
@@ -97,6 +98,13 @@ function runCli(cmd, prompt, timeoutMs = 600000, envOverride, onData) {
             .then(output => ({ output, exitCode: 0 }))
             .catch(err => ({ output: `Error: ${err.message}`, exitCode: 1 }));
     }
+    // Si el comando es "deepseek-direct", usar la API directa sin CLI
+    if (cmd.startsWith('deepseek-direct')) {
+        const model = cmd.includes('-m') ? cmd.split('-m')[1]?.trim().split(/\s/)[0] : 'deepseek-chat';
+        return callDeepSeekAPI(prompt, model)
+            .then(output => ({ output, exitCode: 0 }))
+            .catch(err => ({ output: `Error: ${err.message}`, exitCode: 1 }));
+    }
     return new Promise((resolve, reject) => {
         const parts = cmd.trim().split(/\s+/);
         let fullCmd;
@@ -520,6 +528,36 @@ INSTRUCCIONES GENERALES:
                     throw new Error('COORDINATOR_FAILED');
                 }
             }
+            else if (this.getCoordinatorCmd().startsWith('deepseek-direct')) {
+                const model = this.getCoordinatorCmd().match(/(?:-m|--model)\s+(\S+)/)?.[1] || 'deepseek-chat';
+                const sp = this._startSpinner(`coordinador  ${model}`);
+                try {
+                    const result = await callDeepSeekAPI(prompt, model, (c) => sp.push(c));
+                    sp.stop();
+                    return result;
+                }
+                catch (err) {
+                    sp.stop();
+                    const msg = err?.message ?? '';
+                    if (msg.startsWith('DEEPSEEK_NOT_CONFIGURED')) {
+                        console.log(chalk.red('\n  ✗ DeepSeek no configurado.'));
+                        console.log(chalk.yellow('  Ejecutá: /login  y elegí DeepSeek.\n'));
+                    }
+                    else if (msg.startsWith('DEEPSEEK_NO_BALANCE')) {
+                        const detail = msg.replace('DEEPSEEK_NO_BALANCE: ', '');
+                        console.log(chalk.red('\n  ✗ Saldo insuficiente:'));
+                        console.log(chalk.yellow(`  ${detail}\n`));
+                    }
+                    else if (msg.startsWith('DEEPSEEK_QUOTA_EXCEEDED')) {
+                        console.log(chalk.red('\n  ✗ ' + msg.replace('DEEPSEEK_QUOTA_EXCEEDED: ', '')));
+                        console.log(chalk.yellow('  Usá /model para cambiar de modelo o /provider para cambiar de proveedor.\n'));
+                    }
+                    else {
+                        console.log(chalk.red(`\n  ✗ Error DeepSeek: ${msg}`));
+                    }
+                    throw new Error('COORDINATOR_FAILED');
+                }
+            }
             else if (this.getCoordinatorCmd().startsWith('qwen')) {
                 // Use Qwen API directly — avoids the qwen CLI's own OAuth flow
                 // which causes mid-session auth popups and breaks display.

package/dist/index.js

@@ -100,32 +100,14 @@ if (nativeRole) {
         console.log(chalk.dim(`  Version: ${PKG_NAME} --version\n`));
         process.exit(0);
     }
-    // --login: configure API key for this role
+    // --login: multi-provider login (Qwen / Gemini / DeepSeek), same as agent-mp /login
     if (args.includes('--login') || args.includes('login')) {
-        const { saveApiKeyConfig, loadApiKeyConfig, DEFAULT_API_BASE_URL } = await import('./utils/qwen-auth.js');
+        const { cmdLogin } = await import('./commands/repl.js');
         const rl = (await import('readline')).createInterface({ input: process.stdin, output: process.stdout });
-        const ask = (q) => new Promise((res) => rl.question(q, res));
-        const existing = await loadApiKeyConfig();
-        console.log(chalk.bold.cyan(`\n  ${PKG_NAME} — API Key Setup\n`));
-        if (existing) {
-            console.log(chalk.dim(`  Current: ${existing.provider} / ${existing.model}`));
-        }
-        const apiKey = await ask(`  API Key${existing ? ' [Enter to keep]' : ''}: `);
-        const model = await ask(`  Model [${existing?.model ?? 'qwen-plus'}]: `);
+        console.log(chalk.bold.cyan(`\n  ${PKG_NAME} — Login\n`));
+        const ok = await cmdLogin(rl);
         rl.close();
-        const cfg = {
-            provider: existing?.provider ?? 'openai-compatible',
-            api_key: apiKey.trim() || existing?.api_key || '',
-            base_url: DEFAULT_API_BASE_URL,
-            model: model.trim() || existing?.model || 'qwen-plus',
-        };
-        if (!cfg.api_key) {
-            console.log(chalk.red('  API key is required.'));
-            process.exit(1);
-        }
-        await saveApiKeyConfig(cfg);
-        console.log(chalk.green(`\n  ✓ API key saved — ${cfg.provider} / ${cfg.model}\n`));
-        process.exit(0);
+        process.exit(ok ? 0 : 1);
     }
     // --status: show auth status
     if (args.includes('--status') || args.includes('status')) {

package/dist/utils/deepseek.d.ts

@@ -0,0 +1,14 @@
+export interface DeepSeekKeyConfig {
+    api_key: string;
+    model: string;
+}
+export declare function loadDeepSeekApiKey(): Promise<DeepSeekKeyConfig | null>;
+export declare function saveDeepSeekApiKey(cfg: DeepSeekKeyConfig): Promise<void>;
+export declare function deleteDeepSeekApiKey(): Promise<void>;
+export declare function deepseekAuthStatus(): Promise<{
+    authenticated: boolean;
+    model?: string;
+}>;
+export declare function callDeepSeekAPI(prompt: string, model?: string, onData?: (chunk: string) => void): Promise<string>;
+export declare function fetchDeepSeekModels(cfg?: DeepSeekKeyConfig | null): Promise<string[]>;
+export declare const DEEPSEEK_MODELS: string[];

package/dist/utils/deepseek.js

@@ -0,0 +1,107 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import OpenAI from 'openai';
+import { AGENT_HOME } from './config.js';
+const DEEPSEEK_KEY_FILE = path.join(AGENT_HOME, 'deepseek_key.json');
+const DEEPSEEK_BASE_URL = 'https://api.deepseek.com/v1';
+export async function loadDeepSeekApiKey() {
+    try {
+        const content = await fs.readFile(DEEPSEEK_KEY_FILE, 'utf-8');
+        const cfg = JSON.parse(content);
+        if (!cfg.api_key)
+            return null;
+        return cfg;
+    }
+    catch {
+        return null;
+    }
+}
+export async function saveDeepSeekApiKey(cfg) {
+    await fs.mkdir(AGENT_HOME, { recursive: true });
+    await fs.writeFile(DEEPSEEK_KEY_FILE, JSON.stringify(cfg, null, 2), 'utf-8');
+}
+export async function deleteDeepSeekApiKey() {
+    await fs.unlink(DEEPSEEK_KEY_FILE).catch(() => { });
+}
+export async function deepseekAuthStatus() {
+    const cfg = await loadDeepSeekApiKey();
+    if (!cfg?.api_key)
+        return { authenticated: false };
+    return { authenticated: true, model: cfg.model };
+}
+export async function callDeepSeekAPI(prompt, model = 'deepseek-chat', onData) {
+    const cfg = await loadDeepSeekApiKey();
+    if (!cfg?.api_key) {
+        throw new Error('DEEPSEEK_NOT_CONFIGURED: Run /login y elegí DeepSeek');
+    }
+    const useModel = (model && model !== 'deepseek-model') ? model : cfg.model;
+    const client = new OpenAI({
+        apiKey: cfg.api_key,
+        baseURL: DEEPSEEK_BASE_URL,
+    });
+    const MAX_RETRIES = 3;
+    let lastErr;
+    for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+        try {
+            if (!onData) {
+                const completion = await client.chat.completions.create({
+                    model: useModel,
+                    messages: [{ role: 'user', content: prompt }],
+                });
+                return completion.choices[0]?.message?.content ?? '';
+            }
+            let fullText = '';
+            const stream = await client.chat.completions.create({
+                model: useModel,
+                messages: [{ role: 'user', content: prompt }],
+                stream: true,
+            });
+            for await (const chunk of stream) {
+                const delta = chunk.choices[0]?.delta?.content ?? '';
+                if (delta) {
+                    fullText += delta;
+                    onData(delta);
+                }
+            }
+            return fullText;
+        }
+        catch (err) {
+            lastErr = err;
+            const msg = err?.message ?? '';
+            const status = err?.status ?? err?.response?.status;
+            if (status === 429 || msg.includes('429') || msg.includes('rate_limit')) {
+                const delaySecs = 15;
+                if (attempt < MAX_RETRIES) {
+                    onData?.(`\n[DeepSeek 429 — reintentando en ${delaySecs}s...]`);
+                    await new Promise(r => setTimeout(r, delaySecs * 1000));
+                    continue;
+                }
+                throw new Error(`DEEPSEEK_QUOTA_EXCEEDED: Cuota agotada en ${useModel}. Usá /model para cambiar de modelo.`);
+            }
+            // 402 = insufficient balance
+            if (status === 402 || msg.includes('402') || msg.includes('Insufficient Balance')) {
+                throw new Error(`DEEPSEEK_NO_BALANCE: Saldo insuficiente en DeepSeek.\n` +
+                    `  Cargá crédito en https://platform.deepseek.com`);
+            }
+            throw err;
+        }
+    }
+    throw lastErr;
+}
+export async function fetchDeepSeekModels(cfg) {
+    const resolved = cfg ?? await loadDeepSeekApiKey();
+    if (!resolved?.api_key)
+        return [];
+    try {
+        const client = new OpenAI({ apiKey: resolved.api_key, baseURL: DEEPSEEK_BASE_URL });
+        const list = await client.models.list();
+        return list.data.map((m) => m.id).sort();
+    }
+    catch {
+        return [];
+    }
+}
+export const DEEPSEEK_MODELS = [
+    'deepseek-chat',
+    'deepseek-reasoner',
+];

package/dist/utils/gemini.d.ts

@@ -14,4 +14,5 @@ export declare function geminiAuthStatus(): Promise<{
  * When onData is provided, streams response chunks as they arrive.
  */
 export declare function callGeminiAPI(prompt: string, model?: string, onData?: (chunk: string) => void): Promise<string>;
+export declare function fetchGeminiModels(cfg?: GeminiKeyConfig | null): Promise<string[]>;
 export declare const GEMINI_MODELS: string[];

package/dist/utils/gemini.js

@@ -85,11 +85,31 @@ export async function callGeminiAPI(prompt, model = 'gemini-2.5-flash', onData)
     }
     throw lastErr;
 }
+export async function fetchGeminiModels(cfg) {
+    const resolved = cfg ?? await loadGeminiApiKey();
+    if (!resolved?.api_key)
+        return [];
+    try {
+        const res = await fetch(`https://generativelanguage.googleapis.com/v1beta/models?key=${resolved.api_key}`, { signal: AbortSignal.timeout(10000) });
+        if (!res.ok)
+            return [];
+        const data = await res.json();
+        return (data.models ?? [])
+            .map((m) => m.name?.replace(/^models\//, ''))
+            .filter((id) => id && id.startsWith('gemini'))
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
 export const GEMINI_MODELS = [
-    'gemini-flash-latest',
+    'gemini-3.1-pro-preview',
+    'gemini-3-flash-preview',
+    'gemini-3.1-flash-lite-preview',
+    'gemini-2.5-pro',
     'gemini-2.5-flash',
     'gemini-2.0-flash',
-    'gemini-1.5-flash',
-    'gemini-2.5-pro',
     'gemini-1.5-pro',
+    'gemini-1.5-flash',
 ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-mp",
-  "version": "0.5.36",
+  "version": "0.5.38",
   "description": "Deterministic multi-agent CLI orchestrator — plan, code, review",
   "type": "module",
   "main": "./dist/index.js",