chocolatito-code 1.0.0

package/dist/agent/subagent.js

@@ -0,0 +1,116 @@
+import { TOOLS, getAllTools } from "../tools/definitions.js";
+import { executeToolCall } from "../tools/runner.js";
+import { truncateOutput } from "../tools/truncator.js";
+import { isReadOnly } from "../tools/safety.js";
+import { MAX_OUTPUT_TOKENS } from "../config/constants.js";
+import { withRetry } from "./retry.js";
+import { createEngineClient } from "../config/engine.js";
+/**
+ * Subagentes.
+ *
+ * Tres arreglos sobre la version anterior:
+ *
+ *  1. 'explore' y 'plan' recibian TODAS las herramientas, incluidas delete_file,
+ *     write_file y run_command. Un agente que se presenta como "de solo lectura"
+ *     y puede borrar archivos es una trampa: ahora se le entregan solo las
+ *     herramientas de lectura, asi la restriccion es real y no una sugerencia
+ *     en el prompt.
+ *
+ *  2. Si agotaba las iteraciones devolvia "Subagente completo la ejecucion", que
+ *     no dice nada. Todo el trabajo se perdia. Ahora se le pide expresamente un
+ *     resumen de lo averiguado antes de rendirse.
+ *
+ *  3. Sin reintentos: un 429 mataba al subagente y con el la tarea del padre.
+ */
+const READ_ONLY_TYPES = ["explore", "plan"];
+function toolsFor(type) {
+    // Un subagente general hereda tambien las herramientas MCP; uno de solo
+    // lectura no, porque no se puede saber si una herramienta MCP escribe.
+    if (!READ_ONLY_TYPES.includes(type))
+        return getAllTools();
+    return TOOLS.filter((t) => isReadOnly(t.function.name));
+}
+export async function runSubagent(type, prompt, apiKey, baseURL, modelName, cwd = process.cwd()) {
+    const client = createEngineClient(apiKey, "subagent");
+    const roleInstructions = {
+        explore: `Eres un SUBAGENTE EXPLORADOR de Chocolatito Code. Investigas archivos y buscas código, y devuelves un informe conciso con rutas y números de línea concretos. Solo tienes herramientas de lectura: no puedes modificar nada.`,
+        plan: `Eres un SUBAGENTE ARQUITECTO de Chocolatito Code. Analizas el código existente y devuelves un plan paso a paso con los archivos a crear o modificar y por qué. Solo tienes herramientas de lectura: no implementes, planifica.`,
+        general: `Eres un SUBAGENTE DE TRABAJO de Chocolatito Code. Completas la subtarea encomendada con las herramientas necesarias y devuelves el resultado final verificado.`,
+    };
+    const messages = [
+        {
+            role: "system",
+            content: `${roleInstructions[type]}\n\n` +
+                `Directorio de trabajo: ${cwd}\n` +
+                `Sistema: ${process.platform}\n\n` +
+                `Cuando necesites varias lecturas independientes, pidelas todas en el mismo turno: se ejecutan a la vez.\n` +
+                `Responde con hechos que hayas comprobado, citando rutas y lineas. No afirmes nada que no hayas leido.`,
+        },
+        { role: "user", content: prompt },
+    ];
+    const tools = toolsFor(type);
+    const maxIterations = 14;
+    for (let iterations = 0; iterations < maxIterations; iterations++) {
+        // Al acercarse al limite se avisa, para que cierre en vez de que le corten.
+        if (iterations === maxIterations - 2) {
+            messages.push({
+                role: "system",
+                content: "Aviso: te queda 1 iteración. Devuelve ya tu informe con lo que hayas averiguado.",
+            });
+        }
+        let res;
+        try {
+            res = await withRetry(() => client.chat.completions.create({
+                model: modelName,
+                messages,
+                tools,
+                tool_choice: "auto",
+                temperature: 0.1,
+                max_tokens: MAX_OUTPUT_TOKENS,
+            }));
+        }
+        catch (err) {
+            return `Error en subagente (${type}): ${err?.message || String(err)}`;
+        }
+        const message = res.choices[0]?.message;
+        if (!message)
+            break;
+        if (message.tool_calls && message.tool_calls.length > 0) {
+            messages.push(message);
+            // Las llamadas de un subagente explorador son todas de lectura: van a la vez.
+            const results = await Promise.all(message.tool_calls.map(async (tc) => {
+                let args = {};
+                try {
+                    args = JSON.parse(tc.function.arguments);
+                }
+                catch { }
+                const { result } = await executeToolCall(tc.function.name, args, cwd, apiKey, modelName);
+                return { id: tc.id, content: truncateOutput(result, 20_000) };
+            }));
+            for (const r of results) {
+                messages.push({ role: "tool", tool_call_id: r.id, content: r.content });
+            }
+            continue;
+        }
+        if (message.content)
+            return message.content;
+    }
+    // Se agotaron las iteraciones: en vez de tirar el trabajo, se pide el resumen.
+    try {
+        messages.push({
+            role: "user",
+            content: "Se acabaron las iteraciones. Resume AHORA, sin usar herramientas, todo lo que has averiguado.",
+        });
+        const final = await withRetry(() => client.chat.completions.create({
+            model: modelName,
+            messages,
+            temperature: 0.1,
+            max_tokens: MAX_OUTPUT_TOKENS,
+        }));
+        const text = final.choices[0]?.message?.content;
+        if (text)
+            return `[Subagente ${type}: limite de iteraciones alcanzado]\n\n${text}`;
+    }
+    catch { }
+    return `El subagente ${type} agotó sus iteraciones sin llegar a una conclusión. Acota más la subtarea.`;
+}

package/dist/agent/syntaxValidator.d.ts

@@ -0,0 +1,5 @@
+export interface SyntaxCheckResult {
+    valid: boolean;
+    warning?: string;
+}
+export declare function validateFileSyntax(filePath: string, content: string): SyntaxCheckResult;

package/dist/agent/syntaxValidator.js

@@ -0,0 +1,71 @@
+import path from "node:path";
+export function validateFileSyntax(filePath, content) {
+    const ext = path.extname(filePath).toLowerCase();
+    // 1. JSON validation
+    if (ext === ".json") {
+        try {
+            JSON.parse(content);
+            return { valid: true };
+        }
+        catch (err) {
+            return {
+                valid: false,
+                warning: `⚠️ Advertencia de sintaxis JSON: ${err?.message || "JSON inválido"}`,
+            };
+        }
+    }
+    // 2. Matching brackets & braces check for JS/TS/Python
+    if ([".ts", ".js", ".tsx", ".jsx", ".py", ".rs", ".go"].includes(ext)) {
+        const stack = [];
+        const pairs = { "}": "{", "]": "[", ")": "(" };
+        // Ignore comments & strings roughly to avoid false positives
+        let inString = null;
+        let inComment = false;
+        for (let i = 0; i < content.length; i++) {
+            const char = content[i];
+            const nextChar = content[i + 1];
+            // Comments
+            if (!inString) {
+                if (char === "/" && nextChar === "/") {
+                    while (i < content.length && content[i] !== "\n")
+                        i++;
+                    continue;
+                }
+                if (char === "#" && ext === ".py") {
+                    while (i < content.length && content[i] !== "\n")
+                        i++;
+                    continue;
+                }
+            }
+            // Strings
+            if ((char === '"' || char === "'" || char === "`") && content[i - 1] !== "\\") {
+                if (!inString)
+                    inString = char;
+                else if (inString === char)
+                    inString = null;
+                continue;
+            }
+            if (inString)
+                continue;
+            if (["{", "[", "("].includes(char)) {
+                stack.push(char);
+            }
+            else if (["}", "]", ")"].includes(char)) {
+                const expected = pairs[char];
+                if (stack.length === 0 || stack.pop() !== expected) {
+                    return {
+                        valid: false,
+                        warning: `⚠️ Posible desbalance de llaves/paréntesis en "${path.basename(filePath)}" cerca del cierre '${char}'.`,
+                    };
+                }
+            }
+        }
+        if (stack.length > 0 && stack.length < 5) {
+            return {
+                valid: false,
+                warning: `⚠️ Posible llave o paréntesis sin cerrar en "${path.basename(filePath)}" ('${stack.join("', '")}').`,
+            };
+        }
+    }
+    return { valid: true };
+}

package/dist/agent/tracker.d.ts

@@ -0,0 +1,19 @@
+export declare class TokenTracker {
+    totalPromptTokens: number;
+    totalCompletionTokens: number;
+    cachedPromptTokens: number;
+    addUsage(usage?: {
+        prompt_tokens?: number;
+        completion_tokens?: number;
+        prompt_tokens_details?: {
+            cached_tokens?: number;
+        };
+    }): void;
+    calculateCost(promptTokens?: number, cachedTokens?: number, completionTokens?: number, modelName?: string): {
+        inputCost: number;
+        outputCost: number;
+        totalCost: number;
+        formattedCost: string;
+    };
+    getSummary(modelName?: string): string;
+}

package/dist/agent/tracker.js

@@ -0,0 +1,38 @@
+import { MODEL_PRICING, PRICING } from "../config/constants.js";
+export class TokenTracker {
+    totalPromptTokens = 0;
+    totalCompletionTokens = 0;
+    cachedPromptTokens = 0;
+    addUsage(usage) {
+        if (!usage)
+            return;
+        const prompt = usage.prompt_tokens || 0;
+        const completion = usage.completion_tokens || 0;
+        const cached = usage.prompt_tokens_details?.cached_tokens || 0;
+        this.totalPromptTokens += prompt;
+        this.totalCompletionTokens += completion;
+        this.cachedPromptTokens += cached;
+    }
+    calculateCost(promptTokens = this.totalPromptTokens, cachedTokens = this.cachedPromptTokens, completionTokens = this.totalCompletionTokens, modelName = "deepseek-v4-flash") {
+        const pricing = MODEL_PRICING[modelName] || PRICING;
+        const uncachedPrompt = Math.max(0, promptTokens - cachedTokens);
+        const inputCost = (uncachedPrompt / 1_000_000) * pricing.inputCacheMiss +
+            (cachedTokens / 1_000_000) * pricing.inputCacheHit;
+        const outputCost = (completionTokens / 1_000_000) * pricing.output;
+        const totalCost = inputCost + outputCost;
+        const formattedCost = totalCost < 0.0001
+            ? `$${totalCost.toFixed(5)} USD`
+            : `$${totalCost.toFixed(4)} USD`;
+        return {
+            inputCost,
+            outputCost,
+            totalCost,
+            formattedCost,
+        };
+    }
+    getSummary(modelName = "deepseek-v4-flash") {
+        const { formattedCost } = this.calculateCost(undefined, undefined, undefined, modelName);
+        const totalTokens = this.totalPromptTokens + this.totalCompletionTokens;
+        return `Sesión total: ${totalTokens.toLocaleString()} tokens (Caché: ${this.cachedPromptTokens.toLocaleString()}) | Inversión: ${formattedCost}`;
+    }
+}

package/dist/agent/undoManager.d.ts

@@ -0,0 +1,37 @@
+export interface FileSnapshot {
+    filePath: string;
+    previousContent: string | null;
+}
+export interface Checkpoint {
+    id: string;
+    timestamp: string;
+    description: string;
+    snapshots: FileSnapshot[];
+}
+export declare class UndoManager {
+    private checkpoints;
+    private currentTurnSnapshots;
+    /**
+     * Captures the state of a file before modifying or deleting it
+     */
+    snapshotFile(filePath: string, cwd?: string): void;
+    /**
+     * Finalizes the current turn and saves a rollback checkpoint
+     */
+    commitTurn(description: string): void;
+    /**
+     * Undoes the last turn of modifications
+     */
+    undoLast(): {
+        success: boolean;
+        message: string;
+        restoredFiles: string[];
+    };
+    getHistory(): {
+        id: string;
+        description: string;
+        time: string;
+        fileCount: number;
+    }[];
+}
+export declare const globalUndoManager: UndoManager;

package/dist/agent/undoManager.js

@@ -0,0 +1,95 @@
+import fs from "node:fs";
+import path from "node:path";
+export class UndoManager {
+    checkpoints = [];
+    currentTurnSnapshots = new Map();
+    /**
+     * Captures the state of a file before modifying or deleting it
+     */
+    snapshotFile(filePath, cwd = process.cwd()) {
+        const resolved = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
+        if (this.currentTurnSnapshots.has(resolved))
+            return; // Already captured for this turn
+        if (fs.existsSync(resolved)) {
+            try {
+                const content = fs.readFileSync(resolved, "utf-8");
+                this.currentTurnSnapshots.set(resolved, content);
+            }
+            catch {
+                this.currentTurnSnapshots.set(resolved, null);
+            }
+        }
+        else {
+            this.currentTurnSnapshots.set(resolved, null); // New file to be created
+        }
+    }
+    /**
+     * Finalizes the current turn and saves a rollback checkpoint
+     */
+    commitTurn(description) {
+        if (this.currentTurnSnapshots.size === 0)
+            return;
+        const snapshots = [];
+        this.currentTurnSnapshots.forEach((content, filePath) => {
+            snapshots.push({ filePath, previousContent: content });
+        });
+        this.checkpoints.push({
+            id: `chk_${Date.now()}`,
+            timestamp: new Date().toLocaleTimeString(),
+            description,
+            snapshots,
+        });
+        this.currentTurnSnapshots.clear();
+        // Keep maximum 10 recent checkpoints in memory
+        if (this.checkpoints.length > 10) {
+            this.checkpoints.shift();
+        }
+    }
+    /**
+     * Undoes the last turn of modifications
+     */
+    undoLast() {
+        if (this.checkpoints.length === 0) {
+            return {
+                success: false,
+                message: "No hay acciones previas para deshacer en esta sesión.",
+                restoredFiles: [],
+            };
+        }
+        const checkpoint = this.checkpoints.pop();
+        const restoredFiles = [];
+        for (const snap of checkpoint.snapshots) {
+            try {
+                if (snap.previousContent === null) {
+                    // File was newly created during the turn, delete it
+                    if (fs.existsSync(snap.filePath)) {
+                        fs.unlinkSync(snap.filePath);
+                        restoredFiles.push(`(Eliminado archivo creado) ${path.basename(snap.filePath)}`);
+                    }
+                }
+                else {
+                    // File was modified or deleted, restore original content
+                    fs.writeFileSync(snap.filePath, snap.previousContent, "utf-8");
+                    restoredFiles.push(`(Restaurado) ${path.basename(snap.filePath)}`);
+                }
+            }
+            catch (err) {
+                restoredFiles.push(`(Error restaurando) ${path.basename(snap.filePath)}: ${err?.message}`);
+            }
+        }
+        return {
+            success: true,
+            message: `✔ Deshecho con éxito: "${checkpoint.description}" (${checkpoint.timestamp})`,
+            restoredFiles,
+        };
+    }
+    getHistory() {
+        return this.checkpoints.map((c) => ({
+            id: c.id,
+            description: c.description,
+            time: c.timestamp,
+            fileCount: c.snapshots.length,
+        }));
+    }
+}
+export const globalUndoManager = new UndoManager();

package/dist/config/constants.d.ts

@@ -0,0 +1,77 @@
+/** API de DeepSeek directa. La usa quien trae su propia clave. */
+export declare const DIRECT_ENGINE_URL = "https://api.deepseek.com";
+/**
+ * Proxy propio para los suscriptores.
+ *
+ * En modo suscripcion el cliente NO tiene clave de DeepSeek: manda su clave de
+ * licencia y el proxy, que si guarda la clave maestra, reenvia la peticion. Por
+ * eso la clave maestra nunca viaja dentro del programa que se reparte.
+ */
+export declare const MANAGED_ENGINE_URL: string;
+/**
+ * A donde se habla.
+ *
+ * Estaba fijo en el codigo, asi que apuntar al proxy exigia recompilar y
+ * republicar. Ahora manda, por orden: la variable de entorno (para pruebas), lo
+ * guardado en ~/.chocolatitorc, y si no, el destino que corresponda al modo.
+ */
+export declare function getEngineBaseUrl(): string;
+/**
+ * Compatibilidad: se conserva el nombre antiguo, pero ya no es una constante
+ * congelada al importar. Se resuelve en cada uso.
+ */
+export declare const ENGINE_BASE_URL: string;
+/**
+ * Modelo multimodal usado como "ojos" del agente.
+ * El motor principal es de texto, asi que las capturas se traducen a texto con
+ * este modelo antes de llegar al bucle. Se puede sobrescribir con la variable de
+ * entorno CHOCOLATITO_VISION_MODEL.
+ */
+export declare const VISION_MODEL: string;
+/**
+ * Ventana de contexto real de los modelos V4: 1.000.000 de tokens.
+ *
+ * Antes el proyecto asumia 64.000 y compactaba el historial cada 16 mensajes.
+ * Con una ventana 15 veces mayor, eso significaba tirar a la basura casi todo el
+ * contexto util cada pocos turnos: el agente se olvidaba de lo que acababa de
+ * hacer y repetia trabajo. Era el mayor lastre de calidad del proyecto.
+ */
+export declare const CONTEXT_WINDOW = 1000000;
+/** Limite de salida por respuesta. Sin esto el SDK usa un maximo bajo. */
+export declare const MAX_OUTPUT_TOKENS = 16384;
+/**
+ * Umbral de auto-compactacion: solo cuando de verdad se acerca el limite.
+ * Se deja margen suficiente para una respuesta larga y las herramientas.
+ */
+export declare const COMPACT_THRESHOLD_TOKENS: number;
+export interface EspectroModel {
+    id: string;
+    name: string;
+    description: string;
+    underlyingModel: string;
+    effortLevel: string;
+    /** Temperatura del muestreo para este nivel. */
+    temperature: number;
+}
+/**
+ * Los alias antiguos 'deepseek-chat' y 'deepseek-reasoner' resuelven HOY los dos
+ * a deepseek-v4-flash. Es decir: los cuatro niveles de esfuerzo corrian
+ * exactamente el mismo modelo y el nivel "MAX" no aportaba nada.
+ * Ahora los niveles altos usan deepseek-v4-pro, que si es mas capaz.
+ */
+export declare const ESPECTRO_MODELS: Record<string, EspectroModel>;
+export declare const DEFAULT_ESPECTRO: EspectroModel;
+export interface ModelPricing {
+    inputCacheMiss: number;
+    inputCacheHit: number;
+    output: number;
+}
+/**
+ * USD por millón de tokens, tarifa estándar (fuera del descuento de horario
+ * valle). Los valores anteriores estaban tomados de la generación V3 y
+ * subestimaban el gasto real entre 3 y 4 veces.
+ */
+export declare const MODEL_PRICING: Record<string, ModelPricing>;
+export declare const PRICING: ModelPricing;
+export declare const CONFIG_FILE_NAME = ".chocolatitorc";
+export declare const RULES_FILE_NAME = "CHOCOLATITO.md";

package/dist/config/constants.js

@@ -0,0 +1,146 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+/** API de DeepSeek directa. La usa quien trae su propia clave. */
+export const DIRECT_ENGINE_URL = "https://api.deepseek.com";
+/**
+ * Proxy propio para los suscriptores.
+ *
+ * En modo suscripcion el cliente NO tiene clave de DeepSeek: manda su clave de
+ * licencia y el proxy, que si guarda la clave maestra, reenvia la peticion. Por
+ * eso la clave maestra nunca viaja dentro del programa que se reparte.
+ */
+export const MANAGED_ENGINE_URL = process.env.CHOCOLATITO_PROXY_URL?.trim() ||
+    "https://chocolatito-proxy.chocolatito.workers.dev/v1";
+function rc() {
+    try {
+        const p = path.join(os.homedir(), ".chocolatitorc");
+        if (!fs.existsSync(p))
+            return {};
+        return JSON.parse(fs.readFileSync(p, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * A donde se habla.
+ *
+ * Estaba fijo en el codigo, asi que apuntar al proxy exigia recompilar y
+ * republicar. Ahora manda, por orden: la variable de entorno (para pruebas), lo
+ * guardado en ~/.chocolatitorc, y si no, el destino que corresponda al modo.
+ */
+export function getEngineBaseUrl() {
+    const env = process.env.CHOCOLATITO_ENGINE_URL?.trim();
+    if (env)
+        return env;
+    const cfg = rc();
+    if (typeof cfg.engineUrl === "string" && cfg.engineUrl.trim())
+        return cfg.engineUrl.trim();
+    return cfg.managed === true ? MANAGED_ENGINE_URL : DIRECT_ENGINE_URL;
+}
+/**
+ * Compatibilidad: se conserva el nombre antiguo, pero ya no es una constante
+ * congelada al importar. Se resuelve en cada uso.
+ */
+export const ENGINE_BASE_URL = getEngineBaseUrl();
+/**
+ * Modelo multimodal usado como "ojos" del agente.
+ * El motor principal es de texto, asi que las capturas se traducen a texto con
+ * este modelo antes de llegar al bucle. Se puede sobrescribir con la variable de
+ * entorno CHOCOLATITO_VISION_MODEL.
+ */
+export const VISION_MODEL = process.env.CHOCOLATITO_VISION_MODEL?.trim() || "deepseek-v4-flash-vision-exp";
+/**
+ * Ventana de contexto real de los modelos V4: 1.000.000 de tokens.
+ *
+ * Antes el proyecto asumia 64.000 y compactaba el historial cada 16 mensajes.
+ * Con una ventana 15 veces mayor, eso significaba tirar a la basura casi todo el
+ * contexto util cada pocos turnos: el agente se olvidaba de lo que acababa de
+ * hacer y repetia trabajo. Era el mayor lastre de calidad del proyecto.
+ */
+export const CONTEXT_WINDOW = 1_000_000;
+/** Limite de salida por respuesta. Sin esto el SDK usa un maximo bajo. */
+export const MAX_OUTPUT_TOKENS = 16_384;
+/**
+ * Umbral de auto-compactacion: solo cuando de verdad se acerca el limite.
+ * Se deja margen suficiente para una respuesta larga y las herramientas.
+ */
+export const COMPACT_THRESHOLD_TOKENS = Math.floor(CONTEXT_WINDOW * 0.75);
+/**
+ * Los alias antiguos 'deepseek-chat' y 'deepseek-reasoner' resuelven HOY los dos
+ * a deepseek-v4-flash. Es decir: los cuatro niveles de esfuerzo corrian
+ * exactamente el mismo modelo y el nivel "MAX" no aportaba nada.
+ * Ahora los niveles altos usan deepseek-v4-pro, que si es mas capaz.
+ */
+export const ESPECTRO_MODELS = {
+    "1.0": {
+        id: "1.0",
+        name: "Espectro 1.0 (Ágil)",
+        description: "Ultra rápido, ideal para tareas cotidianas y código directo",
+        underlyingModel: "deepseek-v4-flash",
+        effortLevel: "Normal",
+        temperature: 0.1,
+    },
+    "1.5": {
+        id: "1.5",
+        name: "Espectro 1.5 (Avanzado)",
+        description: "Alta precisión con balance de velocidad para refactorización",
+        underlyingModel: "deepseek-v4-flash",
+        effortLevel: "Alto",
+        temperature: 0.3,
+    },
+    "2.0": {
+        id: "2.0",
+        name: "Espectro 2.0 (Razonamiento Pro)",
+        description: "Modelo Pro para lógica compleja, bugs difíciles y arquitectura",
+        underlyingModel: "deepseek-v4-pro",
+        effortLevel: "Extendido",
+        temperature: 0.1,
+    },
+    "2.5": {
+        id: "2.5",
+        name: "Espectro 2.5 MAX (Máxima Potencia)",
+        description: "Modelo Pro con exploración amplia para proyectos enteros",
+        underlyingModel: "deepseek-v4-pro",
+        effortLevel: "Máximo",
+        temperature: 0.35,
+    },
+};
+export const DEFAULT_ESPECTRO = ESPECTRO_MODELS["1.0"];
+/**
+ * USD por millón de tokens, tarifa estándar (fuera del descuento de horario
+ * valle). Los valores anteriores estaban tomados de la generación V3 y
+ * subestimaban el gasto real entre 3 y 4 veces.
+ */
+export const MODEL_PRICING = {
+    "deepseek-v4-flash": {
+        inputCacheMiss: 0.44,
+        inputCacheHit: 0.014,
+        output: 1.32,
+    },
+    "deepseek-v4-pro": {
+        inputCacheMiss: 1.32,
+        inputCacheHit: 0.044,
+        output: 3.96,
+    },
+    "deepseek-v4-flash-vision-exp": {
+        inputCacheMiss: 0.44,
+        inputCacheHit: 0.014,
+        output: 1.32,
+    },
+    // Alias heredados, por si alguna sesión guardada los referencia.
+    "deepseek-chat": {
+        inputCacheMiss: 0.44,
+        inputCacheHit: 0.014,
+        output: 1.32,
+    },
+    "deepseek-reasoner": {
+        inputCacheMiss: 0.44,
+        inputCacheHit: 0.014,
+        output: 1.32,
+    },
+};
+export const PRICING = MODEL_PRICING["deepseek-v4-flash"];
+export const CONFIG_FILE_NAME = ".chocolatitorc";
+export const RULES_FILE_NAME = "CHOCOLATITO.md";

package/dist/config/engine.d.ts

@@ -0,0 +1,49 @@
+import OpenAI from "openai";
+/**
+ * QUIEN HABLA CON EL MOTOR Y COMO SE IDENTIFICA
+ *
+ * Habia tres sitios construyendo su propio cliente de OpenAI con la clave y la
+ * URL, sin nada mas. Eso dejaba tres agujeros para el modelo de suscripcion:
+ *
+ *  1. La licencia no viajaba. El CLI mandaba `Authorization: Bearer <clave de
+ *     DeepSeek>` y punto; la licencia se quedaba en el archivo de configuracion.
+ *     Un proxy que la esperase habria respondido 401 a todos los suscriptores.
+ *
+ *  2. El proxy no podia distinguir de que ruta venia el gasto. El bucle, los
+ *     subagentes, la vision y la compactacion llegaban con cuerpos casi
+ *     indistinguibles, asi que era imposible decirle al usuario en que se le fue
+ *     la cuota, ni limitar una ruta concreta.
+ *
+ *  3. Nada impedia usar el proxy como API generica barata. Es un endpoint
+ *     compatible con OpenAI: sin una marca propia obligatoria, apuntar ahi
+ *     cualquier otro cliente da el mismo servicio por el mismo precio.
+ */
+export type EngineRoute = "loop" | "subagent" | "vision" | "compact";
+/** Version del paquete instalado, para versionar el contrato con el proxy. */
+export declare function clientVersion(): string;
+/**
+ * La credencial que se manda en el Bearer.
+ *
+ * En suscripcion es la clave de licencia: el cliente no tiene clave de DeepSeek
+ * y no debe tenerla, porque la maestra vive en el proxy. Con clave propia se
+ * manda la del usuario, como siempre.
+ */
+export declare function engineCredential(fallbackApiKey: string): string;
+/**
+ * Cabeceras propias en cada peticion.
+ *
+ * Van en TODAS las rutas para que el proxy pueda atribuir el gasto, rechazar
+ * clientes de version incompatible y distinguir a Chocolatito Code de un SDK
+ * cualquiera apuntando al mismo endpoint.
+ */
+export declare function engineHeaders(route: EngineRoute): Record<string, string>;
+/** Cliente del motor ya configurado. Es el unico sitio donde se construye. */
+export declare function createEngineClient(apiKey: string, route: EngineRoute): OpenAI;
+/**
+ * Traduce un error del motor a algo que el usuario entienda.
+ *
+ * Sin esto, el proxy diciendo "se te acabo la cuota" (402) llega a pantalla como
+ * "Error en el motor tras varios reintentos: 402 ...", que ademas miente: un 402
+ * no se reintenta nunca.
+ */
+export declare function explicarErrorDelMotor(err: any): string | null;