agent-mp 0.5.40 → 0.5.42

package/dist/commands/repl.js

@@ -12,7 +12,7 @@ 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, fetchGeminiModels } from '../utils/gemini.js';
-import { loadDeepSeekApiKey, saveDeepSeekApiKey, deleteDeepSeekApiKey, DEEPSEEK_MODELS, fetchDeepSeekModels } from '../utils/deepseek.js';
+import { loadDeepSeekApiKey, saveDeepSeekApiKey, deleteDeepSeekApiKey, fetchDeepSeekModels, DEEPSEEK_DEFAULT_MODELS } 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';
@@ -416,11 +416,16 @@ async function promptDeepseekKeySetup(rl, askFn) {
         }
     }
     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}`)));
+        console.log(chalk.yellow('  No se pudieron cargar modelos de la API — usando defaults.'));
+        DEEPSEEK_DEFAULT_MODELS.forEach((m, i) => console.log(chalk.dim(`    ${i + 1}. ${m}`)));
         const pick = await askFn(`  Modelo [${chosenModel}]: `);
-        if (pick.trim())
+        const num = parseInt(pick.trim());
+        if (!isNaN(num) && num >= 1 && num <= DEEPSEEK_DEFAULT_MODELS.length) {
+            chosenModel = DEEPSEEK_DEFAULT_MODELS[num - 1];
+        }
+        else if (pick.trim()) {
             chosenModel = pick.trim();
+        }
     }
     await saveDeepSeekApiKey({ api_key: resolvedKey, model: chosenModel });
     console.log(chalk.green(`\n  ✓ DeepSeek API key guardada — ${chosenModel}\n`));
@@ -805,7 +810,7 @@ async function cmdModels(roleArg, fi, rl) {
         console.log(chalk.dim('  Fetching DeepSeek models...'));
         models = await fetchDeepSeekModels(deepseekCfg);
         if (!models.length)
-            models = DEEPSEEK_MODELS;
+            models = DEEPSEEK_DEFAULT_MODELS;
     }
     else if (activeProvider === 'qwen') {
         console.log(chalk.dim('  Fetching Qwen models...'));

package/dist/core/engine.js

@@ -237,8 +237,9 @@ async function walkForKeyFiles(root) {
         entry: null,
         controllers: [],
         schemas: [],
+        allSourceFiles: [],
     };
-    const SOURCE_EXT = /\.(ts|tsx|js|jsx|py|go|java|kt|rs|cs)$/;
+    const SOURCE_EXT = /\.(ts|tsx|js|jsx|py|go|java|kt|rs|cs|rb|ex|exs|swift|php|vue|svelte)$/;
     const SKIP_FILE = /\.(test|spec|d)\.[a-z]+$/i;
     const ENTRY_NAMES = new Set([
         'main.ts', 'main.js', 'main.py', 'main.go', 'Main.java',
@@ -255,8 +256,6 @@ async function walkForKeyFiles(root) {
     async function walk(dir, depth) {
         if (depth > 6)
             return;
-        if (result.controllers.length >= 5 && result.schemas.length >= 5 && result.entry)
-            return;
         let entries;
         try {
             entries = await fs.readdir(dir, { withFileTypes: true });
@@ -280,6 +279,8 @@ async function walkForKeyFiles(root) {
                 continue;
             if (SKIP_FILE.test(e.name))
                 continue;
+            // Collect all source files
+            result.allSourceFiles.push(p);
             // entry point detection
             if (!result.entry && (ENTRY_NAMES.has(e.name) || ENTRY_REGEX.test(e.name))) {
                 result.entry = p;
@@ -856,33 +857,66 @@ INSTRUCCIONES GENERALES:
             }
         };
         // Role binaries (agent-orch, agent-impl, etc.) require an interactive TTY and can't
-        // be spawned as subprocesses. Instead, if they have their own Qwen credentials
-        // (~/.agent-<name>/oauth_creds.json from running `agent-<name> --login`), call
-        // the Qwen API directly with those creds. Otherwise skip to fallback.
+        // be spawned as subprocesses. Instead, call the appropriate API directly
+        // (Qwen via oauth_creds.json, DeepSeek via deepseek_key.json).
         const ROLE_BINARIES = new Set(['agent-orch', 'agent-impl', 'agent-rev', 'agent-explorer']);
+        const DEEPSEEK_MODEL_PREFIX = /^deepseek-/;
         const tryRoleBinaryCreds = async (cliName, model) => {
-            const credsPath = path.join(os.homedir(), `.${cliName}`, 'oauth_creds.json');
-            const hasOAuthCreds = await fileExists(credsPath);
-            if (!hasOAuthCreds) {
-                // No role OAuth creds — try global API key config before giving up
+            const roleDir = path.join(os.homedir(), `.${cliName}`);
+            const credsPath = path.join(roleDir, 'oauth_creds.json');
+            const deepseekRoleKeyPath = path.join(roleDir, 'deepseek_key.json');
+            const deepseekGlobalKeyPath = path.join(os.homedir(), '.agent-mp', 'deepseek_key.json');
+            const isDeepSeekModel = DEEPSEEK_MODEL_PREFIX.test(model);
+            const hasQwenCreds = await fileExists(credsPath);
+            const hasDeepSeekCreds = await fileExists(deepseekRoleKeyPath) || await fileExists(deepseekGlobalKeyPath);
+            // Determine primary provider: DeepSeek model with DeepSeek creds -> DeepSeek, else Qwen
+            if (isDeepSeekModel && hasDeepSeekCreds) {
+                const sp = this._startSpinner(`${cliName}  ${model}  (deepseek)`);
+                const onChunk = (delta) => sp.push(delta);
+                try {
+                    log.info(`${cliName}: calling DeepSeek API (${model})`);
+                    const result = await callDeepSeekAPI(rolePrompt, model, onChunk);
+                    sp.stop();
+                    return result;
+                }
+                catch (err) {
+                    sp.stop();
+                    if (err.message?.startsWith('DEEPSEEK_NOT_CONFIGURED')) {
+                        log.warn(`${cliName} DeepSeek not configured — using fallback`);
+                    }
+                    else if (err.message?.startsWith('DEEPSEEK_QUOTA_EXCEEDED')) {
+                        log.warn(`${cliName} DeepSeek quota exhausted — using fallback`);
+                    }
+                    else if (err.message?.startsWith('DEEPSEEK_NO_BALANCE')) {
+                        log.warn(`${cliName} DeepSeek balance insufficient — using fallback`);
+                    }
+                    else {
+                        log.warn(`${cliName} DeepSeek API call failed: ${err.message}`);
+                    }
+                    return null; // don't try Qwen with a DeepSeek model — let caller fallback handle it
+                }
+            }
+            // Qwen path (for non-DeepSeek models only)
+            if (!hasQwenCreds) {
                 const { loadApiKeyConfig } = await import('../utils/qwen-auth.js');
                 const apiKeyCfg = await loadApiKeyConfig();
                 if (!apiKeyCfg) {
-                    log.warn(`${cliName} has no credentials — run: agent-mp setup api-key  or  ${cliName} --login`);
+                    if (!isDeepSeekModel) {
+                        log.warn(`${cliName} has no credentials — run: agent-mp setup api-key  or  ${cliName} --login`);
+                    }
                     return null;
                 }
-                // Fall through: callQwenAPIFromCreds will use the API key config
             }
-            const sp = this._startSpinner(`${cliName}  ${model}`);
-            const onChunk = (delta) => sp.push(delta);
+            const sp2 = this._startSpinner(`${cliName}  ${model}  ${isDeepSeekModel ? '(qwen fallback)' : ''}`);
+            const onChunk2 = (delta) => sp2.push(delta);
             try {
                 log.info(`${cliName}: calling Qwen API with own credentials (${model})`);
-                const result = await callQwenAPIFromCreds(rolePrompt, model, credsPath, onChunk);
-                sp.stop();
+                const result = await callQwenAPIFromCreds(rolePrompt, model, credsPath, onChunk2);
+                sp2.stop();
                 return result;
             }
             catch (err) {
-                sp.stop();
+                sp2.stop();
                 if (err.message?.startsWith('QWEN_AUTH_EXPIRED')) {
                     log.warn(`${cliName} session expired — using fallback`);
                     return null;
@@ -1580,6 +1614,23 @@ INSTRUCCIONES:
                     compSection.push(`### SCHEMA/MODEL: ${rel}\n\`\`\`\n${content}\n\`\`\``);
                 }
             }
+            // Read ALL source files for function-level documentation
+            const MAX_SOURCE_FILE = 2000;
+            const MAX_TOTAL_SOURCE = 20000;
+            let totalSourceRead = 0;
+            const alreadyRead = new Set([found.entry, ...found.controllers, ...found.schemas].filter(Boolean));
+            for (const srcFile of found.allSourceFiles) {
+                if (totalSourceRead >= MAX_TOTAL_SOURCE)
+                    break;
+                if (alreadyRead.has(srcFile))
+                    continue;
+                const content = await readFileSafe(srcFile, MAX_SOURCE_FILE);
+                if (content) {
+                    const rel = path.relative(compDir, srcFile);
+                    compSection.push(`### SOURCE: ${rel}\n\`\`\`\n${content}\n\`\`\``);
+                    totalSourceRead += content.length;
+                }
+            }
             // Only add the component if we read at least the manifest or one source file
             if (manifestFound || found.entry || found.controllers.length > 0 || found.schemas.length > 0) {
                 sections.push(compSection.join('\n\n'));
@@ -1774,7 +1825,7 @@ Lo concreto: acceso a hosts externos, herramientas requeridas, secrets esperados
 (scripts reales: package.json scripts, Makefile targets, run.sh, mvnw, gradlew, etc.)
 
 
-────── NIVEL 1  (.agent/context/<componente>/architecture.md, 100-220 lineas) ──────
+────── NIVEL 1  (.agent/context/<componente>/architecture.md, 150-400 lineas) ──────
 
 # <componente> — Arquitectura
 
@@ -1806,6 +1857,44 @@ src/
 ├── ...   → ...
 \`\`\`
 
+## Flujo interno y funciones
+
+REGLAS:
+- Lee cada archivo fuente del componente (no solo entry/controller, TODOS los .ts/.js/.py/.go/.java/.rs/.rb/.ex/.cs que haya).
+- Por cada archivo, lista sus funciones exportadas y las internas importantes.
+- NO escribas el codigo completo — solo descripcion resumida de que hace.
+- Para cada funcion, indica con que se conecta (mismo archivo, otro modulo, API externa, BD).
+- Inclui un ejemplo concreto de datos de entrada y salida.
+
+### <ruta/archivo.ext>
+| Funcion | Que hace | Recibe (ejemplo) | Devuelve (ejemplo) | Conecta con |
+|---------|----------|-------------------|---------------------|-------------|
+| nombreFunc | 1-linea que hace | {campo: valor, ...} | {campo: valor, ...} | modulo.func(), this.otra(), API externa |
+
+#### Conecta con — leyenda
+| Notacion | Significado |
+|---|---|
+| \`this.func()\` | Mismo archivo |
+| \`Modulo.func()\` | Otro archivo del componente |
+| \`@comp/Otro.func()\` | Otro componente del proyecto |
+| \`HTTP POST /api/x\` | Llamada HTTP externa |
+| \`DB: tabla.columna\` | Base de datos |
+| \`COLA: nombre\` | Mensajeria / eventos |
+
+### Grafo de dependencias (obligatorio)
+Diagrama ASCII que muestre como se llaman las funciones entre si.
+Usa nombres reales de funciones, no de archivos.
+\`\`\`text
+controlador.createUser(req)
+  │
+  ├──> UserService.validate(data)      ── mismo archivo
+  │     └──> UserModel.findByEmail(e)   ── DB
+  │
+  ├──> UserModel.create(user)           ── DB: users.insert
+  │
+  └──> EmailService.sendWelcome(email)  ── @notification/EmailService.send()
+\`\`\`
+
 ## Endpoints / Rutas / Pantallas
 - Backend (api): tabla con metodo, ruta, auth, proposito.
 - Frontend (web): tabla con ruta de pagina, proposito, datos que consume.

package/dist/utils/deepseek.d.ts

@@ -10,5 +10,5 @@ export declare function deepseekAuthStatus(): Promise<{
     model?: string;
 }>;
 export declare function callDeepSeekAPI(prompt: string, model?: string, onData?: (chunk: string) => void): Promise<string>;
+export declare const DEEPSEEK_DEFAULT_MODELS: string[];
 export declare function fetchDeepSeekModels(cfg?: DeepSeekKeyConfig | null): Promise<string[]>;
-export declare const DEEPSEEK_MODELS: string[];

package/dist/utils/deepseek.js

@@ -35,6 +35,7 @@ export async function callDeepSeekAPI(prompt, model = 'deepseek-chat', onData) {
         throw new Error('DEEPSEEK_NOT_CONFIGURED: Run /login y elegí DeepSeek');
     }
     const useModel = (model && model !== 'deepseek-model') ? model : cfg.model;
+    const isV4 = useModel.startsWith('deepseek-v4');
     const client = new OpenAI({
         apiKey: cfg.api_key,
         baseURL: DEEPSEEK_BASE_URL,
@@ -43,21 +44,26 @@ export async function callDeepSeekAPI(prompt, model = 'deepseek-chat', onData) {
     let lastErr;
     for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
         try {
+            const baseParams = {
+                model: useModel,
+                messages: [{ role: 'user', content: prompt }],
+            };
+            if (isV4) {
+                baseParams.reasoning_effort = 'high';
+                baseParams.extra_body = { thinking: { type: 'enabled' } };
+            }
             if (!onData) {
-                const completion = await client.chat.completions.create({
-                    model: useModel,
-                    messages: [{ role: 'user', content: prompt }],
-                });
+                const completion = await client.chat.completions.create(baseParams);
                 return completion.choices[0]?.message?.content ?? '';
             }
             let fullText = '';
             const stream = await client.chat.completions.create({
-                model: useModel,
-                messages: [{ role: 'user', content: prompt }],
+                ...baseParams,
                 stream: true,
+                stream_options: { include_usage: true },
             });
             for await (const chunk of stream) {
-                const delta = chunk.choices[0]?.delta?.content ?? '';
+                const delta = chunk.choices?.[0]?.delta?.content ?? '';
                 if (delta) {
                     fullText += delta;
                     onData(delta);
@@ -88,6 +94,7 @@ export async function callDeepSeekAPI(prompt, model = 'deepseek-chat', onData) {
     }
     throw lastErr;
 }
+export const DEEPSEEK_DEFAULT_MODELS = ['deepseek-chat', 'deepseek-reasoner'];
 export async function fetchDeepSeekModels(cfg) {
     const resolved = cfg ?? await loadDeepSeekApiKey();
     if (!resolved?.api_key)
@@ -101,7 +108,3 @@ export async function fetchDeepSeekModels(cfg) {
         return [];
     }
 }
-export const DEEPSEEK_MODELS = [
-    'deepseek-chat',
-    'deepseek-reasoner',
-];

package/package.json

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