chocolatito-code 1.0.0

package/dist/agent/loop.js

@@ -0,0 +1,524 @@
+import chalk from "chalk";
+import process from "node:process";
+import { getAllTools } from "../tools/definitions.js";
+import { executeToolCall } from "../tools/runner.js";
+import { TokenTracker } from "./tracker.js";
+import { renderToolStart, renderToolSuccess, renderToolError, renderDiff, renderFooter, renderError, } from "../ui/renderer.js";
+import { CONTEXT_WINDOW, MAX_OUTPUT_TOKENS, COMPACT_THRESHOLD_TOKENS, } from "../config/constants.js";
+import { withRetry } from "./retry.js";
+import { canRunInParallel } from "../tools/safety.js";
+import { createEngineClient, explicarErrorDelMotor } from "../config/engine.js";
+import { MarkdownStream } from "../ui/markdownStream.js";
+import { checkQuota, recordUsage, mensajeDeCorte, quotaBadge } from "../config/quota.js";
+import { ReasoningStream } from "../ui/reasoningStream.js";
+import { PermissionManager } from "../config/permissions.js";
+import { askToolPermission } from "../ui/permissionPrompt.js";
+import { DynamicSpinner } from "../ui/spinner.js";
+import { globalUndoManager } from "./undoManager.js";
+import { InterruptWatcher, isAbortError } from "../ui/interrupt.js";
+import { HookManager } from "../hooks/manager.js";
+export class AgentLoop {
+    client;
+    currentEspectro;
+    messages = [];
+    tracker;
+    currentCwd = process.cwd();
+    permissions;
+    hooks;
+    apiKey;
+    baseURL;
+    maxIterations = 30;
+    constructor(apiKey, baseURL, initialModel, systemPrompt) {
+        this.apiKey = apiKey;
+        this.baseURL = baseURL;
+        // Un unico sitio construye el cliente: asi la credencial de suscripcion y
+        // las cabeceras propias llegan igual desde las cuatro rutas.
+        this.client = createEngineClient(apiKey, "loop");
+        this.currentEspectro = initialModel;
+        this.tracker = new TokenTracker();
+        this.permissions = new PermissionManager("default", this.currentCwd);
+        this.hooks = new HookManager(this.currentCwd);
+        this.messages.push({
+            role: "system",
+            content: systemPrompt,
+        });
+    }
+    setEspectroModel(model, updatedSystemPrompt) {
+        this.currentEspectro = model;
+        if (updatedSystemPrompt && this.messages.length > 0 && this.messages[0].role === "system") {
+            this.messages[0].content = updatedSystemPrompt;
+        }
+    }
+    getEspectroModel() {
+        return this.currentEspectro;
+    }
+    clearHistory(systemPrompt) {
+        this.messages = [{ role: "system", content: systemPrompt }];
+    }
+    async compactHistory(systemPrompt) {
+        if (this.messages.length <= 4) {
+            return "El historial es breve, no requiere compactación.";
+        }
+        const spinner = new DynamicSpinner();
+        spinner.start("Compactando historial");
+        try {
+            const summaryPrompt = [
+                {
+                    role: "system",
+                    content: "Resume de forma ultra concisa los archivos modificados, decisiones tomadas y contexto clave de la conversación anterior para continuar trabajando.",
+                },
+                ...this.messages.slice(1),
+                {
+                    role: "user",
+                    content: "Genera el resumen ejecutivo del contexto de trabajo hasta el momento.",
+                },
+            ];
+            const res = await this.client.chat.completions.create({
+                model: this.currentEspectro.underlyingModel,
+                messages: summaryPrompt,
+                temperature: 0.1,
+            });
+            const summary = res.choices[0]?.message?.content || "Contexto previo compactado.";
+            spinner.stop();
+            this.messages = [
+                { role: "system", content: systemPrompt },
+                {
+                    role: "user",
+                    content: `[RESUMEN DE CONTEXTO PREVIO COMPACTADO]:\n${summary}`,
+                },
+                {
+                    role: "assistant",
+                    content: "Entendido. He retenido el contexto clave del proyecto y estoy listo para continuar.",
+                },
+            ];
+            return `✔ Memoria optimizada y compactada exitosamente (${summary.length} caracteres de contexto retenidos).`;
+        }
+        catch (err) {
+            spinner.stop();
+            return `Fallo al compactar historial: ${err?.message || String(err)}`;
+        }
+    }
+    lastTurnTokens = 0;
+    async autoCompactIfNeeded() {
+        // La ventana real es de 1.000.000 de tokens. Antes se compactaba a los 16
+        // mensajes o 38k tokens, es decir al 4% de su capacidad: el agente perdia
+        // el hilo constantemente y repetia trabajo ya hecho. Ahora solo se comprime
+        // cuando de verdad se acerca el limite.
+        if (this.lastTurnTokens < COMPACT_THRESHOLD_TOKENS) {
+            return false;
+        }
+        try {
+            const activeSystemPrompt = this.messages[0]?.role === "system" ? this.messages[0].content : "";
+            const toSummarize = this.messages.slice(1, -4);
+            if (toSummarize.length < 4)
+                return false;
+            const spinner = new DynamicSpinner();
+            spinner.start("Auto-optimizando memoria del contexto");
+            const summaryPrompt = [
+                {
+                    role: "system",
+                    content: "Resume de forma ultra concisa los archivos modificados, decisiones tomadas, arquitectura y estado actual del proyecto para continuar trabajando sin perder el hilo.",
+                },
+                ...toSummarize,
+                {
+                    role: "user",
+                    content: "Genera el resumen ejecutivo del contexto de trabajo previo.",
+                },
+            ];
+            const res = await this.client.chat.completions.create({
+                model: this.currentEspectro.underlyingModel,
+                messages: summaryPrompt,
+                temperature: 0.1,
+            });
+            const summary = res.choices[0]?.message?.content || "Contexto previo optimizado.";
+            spinner.stop();
+            const recentMessages = this.messages.slice(-4);
+            this.messages = [
+                { role: "system", content: activeSystemPrompt },
+                {
+                    role: "user",
+                    content: `[RESUMEN DE AUTO-COMPACTACIÓN PREVIA]:\n${summary}`,
+                },
+                {
+                    role: "assistant",
+                    content: "Entendido. He retenido el contexto clave del proyecto y liberado memoria.",
+                },
+                ...recentMessages,
+            ];
+            console.log(chalk.hex("#D97757")("\n⚡ [Auto-Compact]: ") +
+                chalk.gray(`Contexto optimizado automáticamente (${this.messages.length} mensajes limpios) para mantener alta velocidad y mínimo consumo de API.\n`));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async runTask(userPrompt) {
+        // Cuota ANTES de gastar. Si no queda margen, se dice y no se llama al motor:
+        // avisar despues de haber gastado no sirve de nada.
+        const cuota = checkQuota();
+        if (!cuota.allowed) {
+            console.log(chalk.yellow(`\n⏸  ${mensajeDeCorte(cuota)}`) +
+                chalk.gray("\n   Tu trabajo y tu contexto siguen aqui: al liberarse, continuas donde lo dejaste.\n"));
+            return;
+        }
+        // Check and execute auto-compaction if context threshold is exceeded
+        await this.autoCompactIfNeeded();
+        const startTime = Date.now();
+        this.messages.push({
+            role: "user",
+            content: userPrompt,
+        });
+        let iterations = 0;
+        let turnPromptTokens = 0;
+        let turnCachedTokens = 0;
+        let turnCompletionTokens = 0;
+        while (iterations < this.maxIterations) {
+            iterations++;
+            // Near iteration limit notice
+            if (iterations === this.maxIterations - 2) {
+                this.messages.push({
+                    role: "system",
+                    content: "Aviso del sistema: Te quedan 2 iteraciones. Cierra lo que estés haciendo y resume el estado actual del trabajo.",
+                });
+            }
+            const spinner = new DynamicSpinner();
+            spinner.tokenCount = turnCompletionTokens;
+            spinner.start();
+            // Escucha Esc mientras dura la peticion. Se para siempre en el finally.
+            const watcher = new InterruptWatcher();
+            const signal = watcher.start();
+            let stream;
+            try {
+                // Un 429 o un 500 pasajero no deberia costar el turno entero.
+                stream = await withRetry(() => this.client.chat.completions.create({
+                    model: this.currentEspectro.underlyingModel,
+                    messages: this.messages,
+                    tools: getAllTools(),
+                    tool_choice: "auto",
+                    temperature: this.currentEspectro.temperature,
+                    max_tokens: MAX_OUTPUT_TOKENS,
+                    stream: true,
+                    stream_options: { include_usage: true },
+                }, { signal }), {
+                    onRetry: (attempt, delay, reason) => {
+                        spinner.stop();
+                        console.log(chalk.yellow(`\n⟳ El motor respondio ${reason}. Reintento ${attempt} en ${(delay / 1000).toFixed(1)}s...`));
+                        spinner.start();
+                    },
+                });
+            }
+            catch (err) {
+                spinner.stop();
+                watcher.stop();
+                if (isAbortError(err) || watcher.interrupted) {
+                    console.log(chalk.yellow("\n⏸  Interrumpido. Dime como seguir."));
+                    return;
+                }
+                // Un 402 (cuota agotada) o un 401 (licencia caida) no son "fallos del
+                // motor" y ademas no se reintentan nunca: decirlo como tal confunde y
+                // hace que el usuario piense que el producto esta roto.
+                const claro = explicarErrorDelMotor(err);
+                if (claro) {
+                    console.log(chalk.yellow(`
+⏸  ${claro}
+`));
+                    return;
+                }
+                renderError(`Error en el motor tras varios reintentos: ${err?.message || String(err)}`);
+                return;
+            }
+            let content = "";
+            let reasoning = "";
+            const rawToolCalls = [];
+            let isFirstChunk = true;
+            const reasoningStream = new ReasoningStream();
+            const markdown = new MarkdownStream();
+            try {
+                for await (const chunk of stream) {
+                    if (isFirstChunk) {
+                        spinner.stop();
+                        isFirstChunk = false;
+                    }
+                    const delta = chunk.choices?.[0]?.delta;
+                    // Handle real-time reasoning stream
+                    if (delta?.reasoning_content) {
+                        const rText = delta.reasoning_content;
+                        reasoning += rText;
+                        reasoningStream.push(rText);
+                    }
+                    // Handle real-time text streaming
+                    if (delta?.content) {
+                        reasoningStream.flush();
+                        content += delta.content;
+                        markdown.push(delta.content);
+                    }
+                    // Accumulate fragmented tool calls by index tc.index
+                    if (delta?.tool_calls) {
+                        for (const tc of delta.tool_calls) {
+                            const idx = tc.index ?? 0;
+                            if (!rawToolCalls[idx]) {
+                                rawToolCalls[idx] = {
+                                    id: tc.id || "",
+                                    type: "function",
+                                    function: { name: "", arguments: "" },
+                                };
+                            }
+                            if (tc.id)
+                                rawToolCalls[idx].id = tc.id;
+                            if (tc.function?.name)
+                                rawToolCalls[idx].function.name += tc.function.name;
+                            if (tc.function?.arguments)
+                                rawToolCalls[idx].function.arguments += tc.function.arguments;
+                        }
+                    }
+                    // Track streaming usage metrics
+                    if (chunk.usage) {
+                        this.tracker.addUsage(chunk.usage);
+                        turnPromptTokens += chunk.usage.prompt_tokens || 0;
+                        turnCompletionTokens += chunk.usage.completion_tokens || 0;
+                        turnCachedTokens += chunk.usage.prompt_tokens_details?.cached_tokens || 0;
+                    }
+                }
+            }
+            catch (streamErr) {
+                spinner.stop();
+                watcher.stop();
+                reasoningStream.flush();
+                markdown.flush();
+                if (isAbortError(streamErr) || watcher.interrupted) {
+                    // Se conserva lo que ya habia escrito: es trabajo util aunque este a
+                    // medias, y perderlo obliga al usuario a repetir la peticion.
+                    if (content.trim()) {
+                        this.messages.push({ role: "assistant", content });
+                    }
+                    console.log(chalk.yellow("\n⏸  Interrumpido. Dime como seguir."));
+                    return;
+                }
+                const claroStream = explicarErrorDelMotor(streamErr);
+                if (claroStream) {
+                    console.log(chalk.yellow(`
+⏸  ${claroStream}
+`));
+                    return;
+                }
+                renderError(`Error en streaming: ${streamErr?.message || String(streamErr)}`);
+                return;
+            }
+            spinner.stop();
+            reasoningStream.flush();
+            markdown.flush();
+            if (watcher.interrupted) {
+                watcher.stop();
+                if (content.trim())
+                    this.messages.push({ role: "assistant", content });
+                console.log(chalk.yellow("\n⏸  Interrumpido antes de ejecutar las herramientas. Dime como seguir."));
+                return;
+            }
+            // Filter valid accumulated tool calls
+            const toolCalls = rawToolCalls.filter((tc) => tc && tc.function && tc.function.name);
+            if (toolCalls.length > 0) {
+                this.messages.push({
+                    role: "assistant",
+                    content: content || null,
+                    tool_calls: toolCalls,
+                });
+                const toolResults = [];
+                // Las llamadas independientes de solo lectura se lanzan a la vez. Cuando
+                // el modelo pide cuatro lecturas de archivo, hacerlas en serie multiplica
+                // la espera por cuatro sin ganar nada.
+                const names = toolCalls.map((tc) => tc.function.name);
+                const parallel = canRunInParallel(names) &&
+                    !toolCalls.some((tc) => {
+                        let a = {};
+                        try {
+                            a = JSON.parse(tc.function.arguments);
+                        }
+                        catch { }
+                        return this.permissions.requiresConfirmation(tc.function.name, a);
+                    });
+                if (parallel) {
+                    for (const tc of toolCalls) {
+                        let a = {};
+                        try {
+                            a = JSON.parse(tc.function.arguments);
+                        }
+                        catch { }
+                        renderToolStart(tc.function.name, getToolSummary(tc.function.name, a));
+                    }
+                    const settled = await Promise.all(toolCalls.map(async (tc) => {
+                        let a = {};
+                        try {
+                            a = JSON.parse(tc.function.arguments);
+                        }
+                        catch { }
+                        const r = await executeToolCall(tc.function.name, a, this.currentCwd, this.apiKey, this.currentEspectro.underlyingModel);
+                        return { tc, result: r.result };
+                    }));
+                    for (const { tc, result } of settled) {
+                        renderToolSuccess(tc.function.name, result);
+                        toolResults.push({ role: "tool", tool_call_id: tc.id, content: result });
+                    }
+                    toolResults.forEach((r) => this.messages.push(r));
+                    watcher.stop();
+                    if (watcher.interrupted) {
+                        console.log(chalk.yellow("\n⏸  Interrumpido. Dime como seguir."));
+                        return;
+                    }
+                    continue;
+                }
+                for (const tc of toolCalls) {
+                    // Entre herramienta y herramienta se mira si el usuario pidio parar.
+                    // Asi una cadena larga de acciones se puede cortar sin matar la sesion.
+                    if (watcher.interrupted) {
+                        toolResults.push({
+                            role: "tool",
+                            tool_call_id: tc.id,
+                            content: "No ejecutada: el usuario interrumpió la tarea.",
+                        });
+                        continue;
+                    }
+                    const fnName = tc.function.name;
+                    let fnArgs = {};
+                    try {
+                        fnArgs = JSON.parse(tc.function.arguments);
+                    }
+                    catch {
+                        fnArgs = {};
+                    }
+                    // PreToolUse: el usuario puede vetar, autorizar o reescribir los
+                    // argumentos ANTES de que se ejecute nada. Va antes del dialogo de
+                    // permiso porque un veto no deberia ni llegar a preguntarse.
+                    const pre = await this.hooks.run("PreToolUse", { tool_name: fnName, tool_input: fnArgs }, fnName);
+                    if (pre.permissionDecision === "deny") {
+                        renderToolStart(fnName, getToolSummary(fnName, fnArgs));
+                        renderToolError(fnName, pre.permissionDecisionReason || "Bloqueado por un hook.");
+                        toolResults.push({
+                            role: "tool",
+                            tool_call_id: tc.id,
+                            content: `Un hook del proyecto bloqueo esta accion: ${pre.permissionDecisionReason || "sin motivo"}. No la reintentes igual; busca otra via o preguntale al usuario.`,
+                        });
+                        continue;
+                    }
+                    if (pre.updatedInput) {
+                        fnArgs = { ...fnArgs, ...pre.updatedInput };
+                    }
+                    if (pre.systemMessage) {
+                        console.log(chalk.yellow(`\n⚑ ${pre.systemMessage}`));
+                    }
+                    // Modo plan: bloqueo duro, no un dialogo. Lo que el modo promete es
+                    // solo lectura, asi que aqui no hay nada que preguntar.
+                    const bloqueoPlan = this.permissions.isBlockedInPlanMode(fnName, fnArgs);
+                    if (bloqueoPlan) {
+                        renderToolStart(fnName, getToolSummary(fnName, fnArgs));
+                        renderToolError(fnName, bloqueoPlan);
+                        toolResults.push({
+                            role: "tool",
+                            tool_call_id: tc.id,
+                            content: `${bloqueoPlan} Termina el plan y pide al usuario que salga del modo plan para ejecutarlo.`,
+                        });
+                        continue;
+                    }
+                    // Permission gate
+                    const saltaPermiso = pre.permissionDecision === "allow";
+                    if (!saltaPermiso && this.permissions.requiresConfirmation(fnName, fnArgs)) {
+                        watcher.stop();
+                        const permResult = await askToolPermission(fnName, fnArgs, this.currentCwd);
+                        if (!permResult.approved) {
+                            const rejectReason = `El usuario canceló la ejecución de este comando con el mensaje: "${permResult.userFeedback || 'Cancelado'}". Ajusta tu enfoque según sus indicaciones y no reintentes la misma acción sin cambios.`;
+                            renderToolStart(fnName, getToolSummary(fnName, fnArgs));
+                            renderToolError(fnName, permResult.userFeedback || "Acción rechazada por el usuario.");
+                            toolResults.push({
+                                role: "tool",
+                                tool_call_id: tc.id,
+                                content: rejectReason,
+                            });
+                            continue;
+                        }
+                        if (permResult.rememberPattern) {
+                            const pat = fnArgs.command ? fnArgs.command.split(" ")[0] : fnArgs.path || fnName;
+                            this.permissions.saveAllowPattern(pat);
+                        }
+                    }
+                    const summary = getToolSummary(fnName, fnArgs);
+                    renderToolStart(fnName, summary);
+                    const { result, diffText, newCwd } = await executeToolCall(fnName, fnArgs, this.currentCwd, this.apiKey, this.currentEspectro.underlyingModel);
+                    if (newCwd) {
+                        this.currentCwd = newCwd;
+                    }
+                    if (diffText && fnArgs.path) {
+                        renderDiff(fnArgs.path, diffText);
+                    }
+                    renderToolSuccess(fnName, result);
+                    // PostToolUse: sirve para validar lo que acaba de pasar (linters,
+                    // tests, politicas) y devolverle al modelo un aviso accionable.
+                    const post = await this.hooks.run("PostToolUse", { tool_name: fnName, tool_input: fnArgs, tool_response: result.slice(0, 4000) }, fnName);
+                    toolResults.push({
+                        role: "tool",
+                        tool_call_id: tc.id,
+                        content: post.additionalContext ? `${result}\n\n
+[Hook PostToolUse]: ${post.additionalContext}` : result,
+                    });
+                }
+                // Push all tool results in a single turn
+                toolResults.forEach((r) => this.messages.push(r));
+                watcher.stop();
+                if (watcher.interrupted) {
+                    console.log(chalk.yellow("\n⏸  Interrumpido. Dime como seguir."));
+                    return;
+                }
+                continue;
+            }
+            watcher.stop();
+            // If text content was printed, ensure newline and record assistant message
+            if (content.trim()) {
+                process.stdout.write("\n\n");
+                this.messages.push({
+                    role: "assistant",
+                    content,
+                });
+            }
+            break;
+        }
+        const durationMs = Date.now() - startTime;
+        const { formattedCost, totalCost } = this.tracker.calculateCost(turnPromptTokens, turnCachedTokens, turnCompletionTokens, this.currentEspectro.underlyingModel);
+        const approxTotalTokens = turnPromptTokens + turnCompletionTokens;
+        this.lastTurnTokens = approxTotalTokens;
+        // El porcentaje libre se calcula sobre los tokens que ocupa el historial
+        // (el prompt del ultimo turno), no sobre prompt+salida, que contaba doble.
+        const used = turnPromptTokens || approxTotalTokens;
+        const contextPercent = Math.max(1, 100 - Math.round((used / CONTEXT_WINDOW) * 100));
+        globalUndoManager.commitTurn(userPrompt);
+        // Se apunta lo gastado en este turno para las ventanas deslizantes.
+        recordUsage(totalCost);
+        const tras = checkQuota();
+        renderFooter(formattedCost, turnCompletionTokens, turnCachedTokens, this.currentEspectro.name, durationMs, contextPercent, quotaBadge(tras));
+        // Aviso al acercarse, no solo al chocar: quedarse a medias sin previo aviso
+        // es lo que hace que la gente cancele.
+        if (tras.allowed && tras.spentWeekUsd >= tras.config.weeklyBudgetUsd * 0.8) {
+            const queda = Math.max(0, tras.config.weeklyBudgetUsd - tras.spentWeekUsd);
+            console.log(chalk.yellow(`  ⚠ Te queda poca cuota semanal (${((queda / tras.config.weeklyBudgetUsd) * 100).toFixed(0)}%).\n`));
+        }
+    }
+}
+function getToolSummary(name, args) {
+    if (args.tasks && Array.isArray(args.tasks))
+        return `${args.tasks.length} tareas`;
+    if (args.skillName)
+        return args.skillName;
+    if (args.topic)
+        return args.topic;
+    if (args.type)
+        return `${args.type}: "${args.prompt?.slice(0, 30)}..."`;
+    if (args.path)
+        return args.path + (args.startLine ? ` (L${args.startLine}-${args.endLine || ""})` : "");
+    if (args.command)
+        return args.command;
+    if (args.query)
+        return `"${args.query}"`;
+    if (args.dirPath)
+        return args.dirPath;
+    if (args.action)
+        return args.action + (args.url ? ` (${args.url})` : "");
+    return "";
+}

package/dist/agent/mentions.d.ts

@@ -0,0 +1,11 @@
+export interface MentionedFile {
+    mention: string;
+    relativePath: string;
+    content: string;
+    size: number;
+}
+export declare function parseFileMentions(userInput: string, cwd?: string): {
+    cleanPrompt: string;
+    attachedFiles: MentionedFile[];
+};
+export declare function buildPromptWithMentions(userInput: string, attachedFiles: MentionedFile[]): string;

package/dist/agent/mentions.js

@@ -0,0 +1,43 @@
+import fs from "node:fs";
+import path from "node:path";
+import chalk from "chalk";
+export function parseFileMentions(userInput, cwd = process.cwd()) {
+    const mentionRegex = /@([a-zA-Z0-9_\-\.\/\\]+)/g;
+    const attachedFiles = [];
+    let match;
+    while ((match = mentionRegex.exec(userInput)) !== null) {
+        const rawPath = match[1];
+        const resolved = path.isAbsolute(rawPath) ? rawPath : path.resolve(cwd, rawPath);
+        if (fs.existsSync(resolved)) {
+            try {
+                const stat = fs.statSync(resolved);
+                if (stat.isFile()) {
+                    const content = fs.readFileSync(resolved, "utf-8");
+                    attachedFiles.push({
+                        mention: match[0],
+                        relativePath: path.relative(cwd, resolved) || rawPath,
+                        content: content.slice(0, 15_000),
+                        size: stat.size,
+                    });
+                }
+            }
+            catch { }
+        }
+    }
+    if (attachedFiles.length > 0) {
+        console.log(chalk.hex("#A855F7")(`  📎 Adjuntando automáticamente ${attachedFiles.length} archivo(s) referenciado(s) con @:\n` +
+            attachedFiles.map((f) => `     • ${chalk.white(f.relativePath)} (${(f.size / 1024).toFixed(1)} KB)`).join("\n")));
+    }
+    return {
+        cleanPrompt: userInput,
+        attachedFiles,
+    };
+}
+export function buildPromptWithMentions(userInput, attachedFiles) {
+    if (attachedFiles.length === 0)
+        return userInput;
+    const fileBlocks = attachedFiles
+        .map((f) => `\n\n--- CONTENIDO ADJUNTO DE @${f.relativePath} ---\n${f.content}\n--- FIN DE @${f.relativePath} ---`)
+        .join("\n");
+    return `${userInput}\n${fileBlocks}`;
+}

package/dist/agent/retry.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Reintentos con espera exponencial para las llamadas al motor.
+ *
+ * Antes, cualquier hipo de la API (un 429 por limite de ritmo, un 500, una
+ * conexion cortada) abortaba el turno entero con "Error en el motor" y el
+ * usuario perdia el trabajo en curso. Un fallo transitorio no deberia costar
+ * una tarea.
+ */
+export interface RetryOptions {
+    attempts?: number;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+    onRetry?: (attempt: number, delayMs: number, reason: string) => void;
+}
+/** Errores que merece la pena reintentar: transitorios, no de programacion. */
+export declare function isRetryable(err: any): boolean;
+export declare function withRetry<T>(fn: () => Promise<T>, opts?: RetryOptions): Promise<T>;

package/dist/agent/retry.js

@@ -0,0 +1,57 @@
+/**
+ * Reintentos con espera exponencial para las llamadas al motor.
+ *
+ * Antes, cualquier hipo de la API (un 429 por limite de ritmo, un 500, una
+ * conexion cortada) abortaba el turno entero con "Error en el motor" y el
+ * usuario perdia el trabajo en curso. Un fallo transitorio no deberia costar
+ * una tarea.
+ */
+/** Errores que merece la pena reintentar: transitorios, no de programacion. */
+export function isRetryable(err) {
+    const status = err?.status ?? err?.response?.status;
+    if (typeof status === "number") {
+        // 429 limite de ritmo; 5xx problemas del servidor. Un 400/401/403 es culpa
+        // nuestra y reintentar solo hace perder tiempo.
+        return status === 408 || status === 409 || status === 429 || status >= 500;
+    }
+    const code = String(err?.code || "");
+    if (["ECONNRESET", "ETIMEDOUT", "ECONNREFUSED", "EPIPE", "ENOTFOUND", "EAI_AGAIN"].includes(code)) {
+        return true;
+    }
+    const msg = String(err?.message || "").toLowerCase();
+    return (msg.includes("timeout") ||
+        msg.includes("socket hang up") ||
+        msg.includes("network") ||
+        msg.includes("fetch failed") ||
+        msg.includes("terminated"));
+}
+function describe(err) {
+    const status = err?.status ?? err?.response?.status;
+    if (status)
+        return `HTTP ${status}`;
+    if (err?.code)
+        return String(err.code);
+    return String(err?.message || err).slice(0, 120);
+}
+export async function withRetry(fn, opts = {}) {
+    const attempts = opts.attempts ?? 4;
+    const base = opts.baseDelayMs ?? 800;
+    const max = opts.maxDelayMs ?? 15_000;
+    let lastErr;
+    for (let i = 0; i < attempts; i++) {
+        try {
+            return await fn();
+        }
+        catch (err) {
+            lastErr = err;
+            const isLast = i === attempts - 1;
+            if (isLast || !isRetryable(err))
+                throw err;
+            // Espera exponencial con jitter, para no sincronizar reintentos.
+            const delay = Math.min(max, base * Math.pow(2, i)) * (0.7 + Math.random() * 0.6);
+            opts.onRetry?.(i + 1, Math.round(delay), describe(err));
+            await new Promise((r) => setTimeout(r, delay));
+        }
+    }
+    throw lastErr;
+}

package/dist/agent/subagent.d.ts

@@ -0,0 +1,2 @@
+export type SubagentType = "explore" | "plan" | "general";
+export declare function runSubagent(type: SubagentType, prompt: string, apiKey: string, baseURL: string, modelName: string, cwd?: string): Promise<string>;