chocolatito-code 1.0.0

package/dist/tools/listDir.js

@@ -0,0 +1,33 @@
+import fs from "node:fs";
+import path from "node:path";
+import fg from "fast-glob";
+export async function listDir(dirPath = ".", cwd = process.cwd()) {
+    const resolved = path.isAbsolute(dirPath) ? dirPath : path.resolve(cwd, dirPath);
+    if (!fs.existsSync(resolved)) {
+        return `Error: El directorio "${dirPath}" no existe.`;
+    }
+    const entries = await fg(["*"], {
+        cwd: resolved,
+        dot: true,
+        onlyFiles: false,
+        ignore: ["**/node_modules/**", "**/.git/**", "**/dist/**", "**/__pycache__/**"],
+    });
+    if (entries.length === 0) {
+        return `Directorio "${dirPath}" vacío.`;
+    }
+    const formatted = entries
+        .map((name) => {
+        const full = path.join(resolved, name);
+        try {
+            const stat = fs.statSync(full);
+            const type = stat.isDirectory() ? "[DIR] " : "[FILE]";
+            const size = stat.isFile() ? ` (${(stat.size / 1024).toFixed(1)} KB)` : "";
+            return `${type} ${name}${size}`;
+        }
+        catch {
+            return `[?] ${name}`;
+        }
+    })
+        .join("\n");
+    return `Contenido de "${path.relative(cwd, resolved) || "."}":\n${formatted}`;
+}

package/dist/tools/moveCopyFile.d.ts

@@ -0,0 +1 @@
+export declare function moveCopyFile(sourcePath: string, destinationPath: string, operation?: "move" | "copy", cwd?: string): Promise<string>;

package/dist/tools/moveCopyFile.js

@@ -0,0 +1,21 @@
+import fs from "node:fs";
+import path from "node:path";
+export async function moveCopyFile(sourcePath, destinationPath, operation = "move", cwd = process.cwd()) {
+    const resolvedSource = path.isAbsolute(sourcePath) ? sourcePath : path.resolve(cwd, sourcePath);
+    const resolvedDest = path.isAbsolute(destinationPath) ? destinationPath : path.resolve(cwd, destinationPath);
+    if (!fs.existsSync(resolvedSource)) {
+        return `Error: El origen "${sourcePath}" no existe.`;
+    }
+    const destDir = path.dirname(resolvedDest);
+    if (!fs.existsSync(destDir)) {
+        fs.mkdirSync(destDir, { recursive: true });
+    }
+    if (operation === "copy") {
+        fs.cpSync(resolvedSource, resolvedDest, { recursive: true });
+        return `✔ Copiado "${sourcePath}" -> "${destinationPath}" exitosamente.`;
+    }
+    else {
+        fs.renameSync(resolvedSource, resolvedDest);
+        return `✔ Movido/Renombrado "${sourcePath}" -> "${destinationPath}" exitosamente.`;
+    }
+}

package/dist/tools/runCommand.d.ts

@@ -0,0 +1 @@
+export declare function runCommand(command: string, cwd?: string, timeoutMs?: number): Promise<string>;

package/dist/tools/runCommand.js

@@ -0,0 +1,61 @@
+import { execa } from "execa";
+/**
+ * Ejecucion de comandos de shell.
+ *
+ * Tres fallos que tenia la version anterior:
+ *
+ *  1. Calculaba el shell correcto y luego NO lo usaba: pasaba `shell: true`, que
+ *     en Windows significa cmd.exe. Cualquier comando con sintaxis de PowerShell
+ *     (Get-ChildItem, $variables, tuberias de objetos) fallaba sin motivo
+ *     aparente.
+ *
+ *  2. Timeout fijo de 45 s. Un `npm install`, una compilacion grande o una suite
+ *     de tests se pasan de ahi sin despeinarse, y el comando moria a medias.
+ *
+ *  3. Cuando saltaba el timeout no se decia. El agente veia una salida cortada y
+ *     "Exit code: null", y concluia lo que le parecia. Un comando que no termino
+ *     no es un comando que fallo, y confundirlos lleva a "arreglar" cosas que no
+ *     estaban rotas.
+ */
+const DEFAULT_TIMEOUT_MS = 120_000;
+const MAX_TIMEOUT_MS = 600_000;
+export async function runCommand(command, cwd = process.cwd(), timeoutMs) {
+    const trimmed = command.trim();
+    if (!trimmed)
+        return "Error: comando vacio.";
+    // Las pausas se hacen con la herramienta, no bloqueando un shell.
+    if (/^(start-sleep|sleep)\b/i.test(trimmed)) {
+        return "Aviso: para esperar, usa 'computer_use' con action 'wait' y ms, en vez de bloquear un shell.";
+    }
+    const timeout = Math.min(Math.max(timeoutMs || DEFAULT_TIMEOUT_MS, 1_000), MAX_TIMEOUT_MS);
+    const isWindows = process.platform === "win32";
+    try {
+        const result = await execa(trimmed, {
+            cwd,
+            // Se usa de verdad el shell que toca. En Windows, PowerShell.
+            shell: isWindows ? "powershell.exe" : "/bin/bash",
+            timeout,
+            reject: false,
+            all: false,
+            maxBuffer: 20 * 1024 * 1024,
+            env: { ...process.env, FORCE_COLOR: "0", NO_COLOR: "1" },
+        });
+        const parts = [];
+        if (result.stdout)
+            parts.push(`STDOUT:\n${result.stdout}`);
+        if (result.stderr)
+            parts.push(`STDERR:\n${result.stderr}`);
+        if (result.timedOut) {
+            parts.push(`TIEMPO AGOTADO: el comando seguia corriendo tras ${(timeout / 1000).toFixed(0)}s y se detuvo.\n` +
+                `La salida de arriba esta incompleta y NO significa que el comando fallara. ` +
+                `Si necesita mas tiempo, vuelve a lanzarlo con un 'timeout' mayor (hasta ${MAX_TIMEOUT_MS / 1000}s).`);
+            return parts.join("\n\n");
+        }
+        parts.push(`Exit code: ${result.exitCode}`);
+        const output = parts.join("\n\n");
+        return output || "Comando ejecutado sin salida (código 0).";
+    }
+    catch (error) {
+        return `Error al ejecutar comando: ${error?.message || String(error)}`;
+    }
+}

package/dist/tools/runner.d.ts

@@ -0,0 +1,5 @@
+export declare function executeToolCall(name: string, args: Record<string, any>, cwd?: string, apiKey?: string, modelName?: string): Promise<{
+    result: string;
+    diffText?: string;
+    newCwd?: string;
+}>;

package/dist/tools/runner.js

@@ -0,0 +1,177 @@
+import { viewFile } from "./viewFile.js";
+import { editFile } from "./editFile.js";
+import { writeFile } from "./writeFile.js";
+import { runCommand } from "./runCommand.js";
+import { listDir } from "./listDir.js";
+import { grepSearch } from "./grepSearch.js";
+import { changeDir } from "./changeDir.js";
+import { findFiles } from "./findFiles.js";
+import { deleteFile } from "./deleteFile.js";
+import { moveCopyFile } from "./moveCopyFile.js";
+import { webFetch } from "./webFetch.js";
+import { getSystemInfo } from "./getSystemInfo.js";
+import { webSearch } from "./webSearch.js";
+import { createImage } from "./createImage.js";
+import { computerUse } from "./computerUse.js";
+import { browserCdp } from "./browserCdp.js";
+import { chromeExtension } from "./browserExtension.js";
+import { truncateOutput } from "./truncator.js";
+import { SkillManager } from "../skills/manager.js";
+import { MemoryManager } from "../memory/manager.js";
+import { runSubagent } from "../agent/subagent.js";
+import { setSessionTasks } from "./todoTool.js";
+import { getEngineBaseUrl } from "../config/constants.js";
+import { globalUndoManager } from "../agent/undoManager.js";
+import { validateFileSyntax } from "../agent/syntaxValidator.js";
+import { fileTracker } from "../agent/fileTracker.js";
+import { mcpManager } from "../mcp/manager.js";
+import fs from "node:fs";
+import path from "node:path";
+const skillManager = new SkillManager();
+const memoryManager = new MemoryManager();
+export async function executeToolCall(name, args, cwd = process.cwd(), apiKey, modelName) {
+    try {
+        let rawResult = "";
+        let diffText;
+        let newCwd;
+        // Las herramientas MCP llegan con el nombre mcp__<servidor>__<herramienta> y
+        // se enrutan al servidor correspondiente antes de mirar las nativas.
+        if (mcpManager.isMcpTool(name)) {
+            return { result: truncateOutput(await mcpManager.callTool(name, args)) };
+        }
+        switch (name) {
+            case "todo_write":
+                rawResult = setSessionTasks(args.tasks || []);
+                break;
+            case "use_skill": {
+                const body = skillManager.loadSkillBody(args.skillName);
+                if (body) {
+                    rawResult = `--- INSTRUCCIONES DEL SKILL "${args.skillName}" ---\n${body}\n--- FIN DEL SKILL ---`;
+                }
+                else {
+                    rawResult = `Error: No se encontró el skill "${args.skillName}". Skills disponibles:\n${skillManager.getSkillPromptListing()}`;
+                }
+                break;
+            }
+            case "save_memory":
+                rawResult = memoryManager.saveMemory(args.topic, args.fact);
+                break;
+            case "read_memory":
+                rawResult = memoryManager.readMemory(args.topic);
+                break;
+            case "spawn_agent": {
+                if (!apiKey) {
+                    rawResult = "Error: API key no disponible para lanzar subagente.";
+                }
+                else {
+                    rawResult = await runSubagent(args.type, args.prompt, apiKey, getEngineBaseUrl(), modelName || "deepseek-v4-flash", cwd);
+                }
+                break;
+            }
+            case "chrome":
+                rawResult = await chromeExtension(args, cwd, apiKey);
+                break;
+            case "browser":
+            case "browser_live":
+                rawResult = await browserCdp(args, cwd, apiKey);
+                break;
+            case "computer_use":
+                rawResult = await computerUse(args, cwd, apiKey);
+                break;
+            case "change_dir": {
+                const res = await changeDir(args.path, cwd);
+                rawResult = res.message;
+                if (res.success)
+                    newCwd = res.newCwd;
+                break;
+            }
+            case "find_files":
+                rawResult = await findFiles(args.pattern, args.searchDirectory || cwd, cwd);
+                break;
+            case "view_file":
+                rawResult = await viewFile(args.path, args.startLine, args.endLine, cwd);
+                // Se registra para que edit_file sepa que este archivo ya se ha visto y
+                // pueda detectar si alguien lo cambia por detras.
+                if (!rawResult.startsWith("Error"))
+                    fileTracker.markRead(args.path, cwd);
+                break;
+            case "edit_file": {
+                const risk = fileTracker.checkBeforeEdit(args.path, cwd);
+                if (risk) {
+                    rawResult = `Edicion bloqueada: ${risk}`;
+                    break;
+                }
+                globalUndoManager.snapshotFile(args.path, cwd);
+                const res = await editFile(args.path, args.oldText, args.newText, cwd);
+                if (res.success)
+                    fileTracker.markWritten(args.path, cwd);
+                rawResult = res.message;
+                diffText = res.diffText;
+                // Post-edit syntax validation
+                if (res.success) {
+                    const resolved = path.isAbsolute(args.path) ? args.path : path.resolve(cwd, args.path);
+                    if (fs.existsSync(resolved)) {
+                        const content = fs.readFileSync(resolved, "utf-8");
+                        const check = validateFileSyntax(args.path, content);
+                        if (!check.valid && check.warning) {
+                            rawResult += `\n${check.warning}`;
+                        }
+                    }
+                }
+                break;
+            }
+            case "write_file": {
+                globalUndoManager.snapshotFile(args.path, cwd);
+                rawResult = await writeFile(args.path, args.content, cwd);
+                fileTracker.markWritten(args.path, cwd);
+                const check = validateFileSyntax(args.path, args.content || "");
+                if (!check.valid && check.warning) {
+                    rawResult += `\n${check.warning}`;
+                }
+                break;
+            }
+            case "create_image":
+                rawResult = await createImage(args.outputPath, args.generatorScript, cwd);
+                break;
+            case "web_search":
+                rawResult = await webSearch(args.query);
+                break;
+            case "delete_file":
+                globalUndoManager.snapshotFile(args.path, cwd);
+                rawResult = await deleteFile(args.path, cwd);
+                break;
+            case "move_copy_file":
+                globalUndoManager.snapshotFile(args.sourcePath, cwd);
+                globalUndoManager.snapshotFile(args.destinationPath, cwd);
+                rawResult = await moveCopyFile(args.sourcePath, args.destinationPath, args.operation || "move", cwd);
+                break;
+            case "run_command":
+                rawResult = await runCommand(args.command, cwd, args.timeout);
+                break;
+            case "list_dir":
+                rawResult = await listDir(args.dirPath || ".", cwd);
+                break;
+            case "grep_search":
+                rawResult = await grepSearch(args.query, args.searchPath || ".", cwd);
+                break;
+            case "web_fetch":
+                rawResult = await webFetch(args.url);
+                break;
+            case "get_system_info":
+                rawResult = await getSystemInfo(cwd);
+                break;
+            default:
+                rawResult = `Error: Herramienta desconocida "${name}".`;
+        }
+        return {
+            result: truncateOutput(rawResult),
+            diffText,
+            newCwd,
+        };
+    }
+    catch (err) {
+        return {
+            result: `Excepción ejecutando ${name}: ${err?.message || String(err)}`,
+        };
+    }
+}

package/dist/tools/safety.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Clasificacion de herramientas por efecto.
+ *
+ * Sirve para decidir que se puede ejecutar en paralelo. Cuando el modelo pide
+ * cuatro lecturas de archivo a la vez, ejecutarlas en serie multiplica por
+ * cuatro la espera sin ganar nada: ninguna depende de la otra ni modifica el
+ * estado. En cambio dos escrituras seguidas SI pueden pisarse, y el orden
+ * importa, asi que esas van una detras de otra.
+ */
+export declare function isReadOnly(toolName: string): boolean;
+/**
+ * Un lote solo se paraleliza si TODAS sus llamadas son de solo lectura y hay
+ * mas de una. Basta con que una modifique algo para volver al orden estricto:
+ * el modelo suele encadenar "edita y luego ejecuta los tests", y ahi el orden
+ * es el significado.
+ */
+export declare function canRunInParallel(toolNames: string[]): boolean;

package/dist/tools/safety.js

@@ -0,0 +1,33 @@
+/**
+ * Clasificacion de herramientas por efecto.
+ *
+ * Sirve para decidir que se puede ejecutar en paralelo. Cuando el modelo pide
+ * cuatro lecturas de archivo a la vez, ejecutarlas en serie multiplica por
+ * cuatro la espera sin ganar nada: ninguna depende de la otra ni modifica el
+ * estado. En cambio dos escrituras seguidas SI pueden pisarse, y el orden
+ * importa, asi que esas van una detras de otra.
+ */
+/** Herramientas sin efectos secundarios: seguras de lanzar a la vez. */
+const READ_ONLY = new Set([
+    "view_file",
+    "list_dir",
+    "grep_search",
+    "find_files",
+    "get_system_info",
+    "web_fetch",
+    "web_search",
+    "read_memory",
+    "use_skill",
+]);
+export function isReadOnly(toolName) {
+    return READ_ONLY.has(toolName);
+}
+/**
+ * Un lote solo se paraleliza si TODAS sus llamadas son de solo lectura y hay
+ * mas de una. Basta con que una modifique algo para volver al orden estricto:
+ * el modelo suele encadenar "edita y luego ejecuta los tests", y ahi el orden
+ * es el significado.
+ */
+export function canRunInParallel(toolNames) {
+    return toolNames.length > 1 && toolNames.every(isReadOnly);
+}

package/dist/tools/todoTool.d.ts

@@ -0,0 +1,8 @@
+export interface TaskItem {
+    id?: string;
+    text: string;
+    status: "pending" | "in_progress" | "completed";
+}
+export declare function setSessionTasks(tasks: TaskItem[]): string;
+export declare function getSessionTasks(): TaskItem[];
+export declare function renderTaskList(tasks: TaskItem[]): string;

package/dist/tools/todoTool.js

@@ -0,0 +1,27 @@
+import chalk from "chalk";
+let sessionTasks = [];
+export function setSessionTasks(tasks) {
+    sessionTasks = tasks;
+    return renderTaskList(sessionTasks);
+}
+export function getSessionTasks() {
+    return sessionTasks;
+}
+export function renderTaskList(tasks) {
+    if (tasks.length === 0)
+        return "No hay tareas registradas.";
+    const lines = [];
+    lines.push(chalk.bold.hex("#D97757")("● Tareas del proyecto"));
+    tasks.forEach((t) => {
+        if (t.status === "completed") {
+            lines.push(`  ⎿  ${chalk.green("☒")} ${chalk.gray.strikethrough(t.text)}`);
+        }
+        else if (t.status === "in_progress") {
+            lines.push(`  ⎿  ${chalk.bold.hex("#D97757")("▸")} ${chalk.bold.white(t.text)}`);
+        }
+        else {
+            lines.push(`  ⎿  ${chalk.gray("☐")} ${chalk.gray(t.text)}`);
+        }
+    });
+    return lines.join("\n");
+}

package/dist/tools/toolDefsComputer.d.ts

@@ -0,0 +1,13 @@
+import type { ChatCompletionTool } from "openai/resources/chat/completions";
+/**
+ * Definiciones de las herramientas de control de ordenador y navegador.
+ *
+ * Estan separadas del resto porque son las que mas contexto ocupan y las que
+ * mas importa redactar con cuidado: la descripcion de la herramienta es lo unico
+ * que el modelo lee antes de decidir como actuar. Si aqui no queda claro que
+ * primero hay que mirar y luego actuar, el agente vuelve a inventarse
+ * coordenadas.
+ */
+export declare const BROWSER_TOOL: ChatCompletionTool;
+export declare const COMPUTER_USE_TOOL: ChatCompletionTool;
+export declare const CHROME_TOOL: ChatCompletionTool;

package/dist/tools/toolDefsComputer.js

@@ -0,0 +1,205 @@
+/**
+ * Definiciones de las herramientas de control de ordenador y navegador.
+ *
+ * Estan separadas del resto porque son las que mas contexto ocupan y las que
+ * mas importa redactar con cuidado: la descripcion de la herramienta es lo unico
+ * que el modelo lee antes de decidir como actuar. Si aqui no queda claro que
+ * primero hay que mirar y luego actuar, el agente vuelve a inventarse
+ * coordenadas.
+ */
+export const BROWSER_TOOL = {
+    type: "function",
+    function: {
+        name: "browser",
+        description: "Controla Chrome en SEGUNDO PLANO por el protocolo DevTools: no mueve el raton del usuario ni necesita que la ventana este delante. " +
+            "Es la herramienta correcta para cualquier cosa que ocurra dentro de una pagina web (Google Flow, YouTube, paneles, formularios). " +
+            "FLUJO OBLIGATORIO: 'snapshot' para ver que elementos hay -> 'click'/'type' usando el numero de ref que devuelve -> 'snapshot' otra vez para confirmar. " +
+            "Nunca hagas clic sin haber hecho antes un snapshot.",
+        parameters: {
+            type: "object",
+            properties: {
+                action: {
+                    type: "string",
+                    enum: [
+                        "attach",
+                        "tabs",
+                        "select_tab",
+                        "new_tab",
+                        "navigate",
+                        "snapshot",
+                        "click",
+                        "type",
+                        "press",
+                        "select_option",
+                        "scroll",
+                        "screenshot",
+                        "get_text",
+                        "eval",
+                        "wait_for",
+                        "console",
+                        "close",
+                    ],
+                    description: "attach: conecta con Chrome. tabs/select_tab: lista y cambia de pestana. snapshot: LEE la pagina y numera los elementos accionables. " +
+                        "click/type: actua sobre un ref del snapshot. wait_for: espera un selector, un texto o unos ms. screenshot: captura y la describe con el modelo de vision.",
+                },
+                url: { type: "string", description: "URL para navigate o new_tab." },
+                ref: {
+                    type: "integer",
+                    description: "Numero del elemento devuelto por snapshot. Es la forma preferente de actuar.",
+                },
+                selector: { type: "string", description: "Selector CSS, solo si no tienes un ref." },
+                text: { type: "string", description: "Texto a escribir (type) o a esperar (wait_for)." },
+                submit: { type: "boolean", description: "Si es true, pulsa Enter despues de escribir." },
+                keys: { type: "string", description: 'Tecla para press (ej. "Enter", "Escape", "Control+A").' },
+                value: { type: "string", description: "Valor para select_option." },
+                script: { type: "string", description: "JavaScript a evaluar en la pagina." },
+                match: { type: "string", description: "Texto del titulo o URL para select_tab." },
+                filter: { type: "string", description: "Filtra el snapshot por texto. Uselo en paginas con muchos elementos." },
+                max: { type: "integer", description: "Maximo de elementos del snapshot (por defecto 60)." },
+                direction: { type: "string", enum: ["up", "down"], description: "Direccion del scroll." },
+                amount: { type: "integer", description: "Cantidad de scroll." },
+                timeout: { type: "integer", description: "Tiempo limite en ms." },
+                ms: { type: "integer", description: "Milisegundos de espera para wait_for sin selector." },
+                outputPath: { type: "string", description: "Ruta donde guardar la captura." },
+                question: { type: "string", description: "Pregunta concreta para el analisis visual de la captura." },
+                analyze: { type: "boolean", description: "false para no gastar tokens de vision en la captura." },
+                useSystemProfile: {
+                    type: "boolean",
+                    description: "true usa el perfil real de Chrome del usuario (exige que Chrome este cerrado la primera vez). " +
+                        "false, por defecto, usa el perfil propio del agente, donde se inicia sesion en Google una sola vez.",
+                },
+                profileDirectory: { type: "string", description: 'Perfil concreto de Chrome (ej. "Profile 1").' },
+            },
+            required: ["action"],
+        },
+    },
+};
+export const COMPUTER_USE_TOOL = {
+    type: "function",
+    function: {
+        name: "computer_use",
+        description: "Controla aplicaciones de ESCRITORIO de Windows. Para paginas web usa siempre 'browser', que es mas fiable. " +
+            "REGLA DE ORO: nunca hagas clic en una coordenada que no te haya dado antes una herramienta. " +
+            "FLUJO CORRECTO: 'list_windows' para saber que hay abierto -> 'ui_snapshot' con la ventana objetivo para listar sus controles reales -> " +
+            "'ui_click' / 'ui_type' con el numero de ref. Eso actua en segundo plano, sin mover el raton ni robar el foco al usuario. " +
+            "Solo si el arbol de accesibilidad no ve el control (lienzos, juegos, imagenes) recurre a 'screenshot' con 'window' y luego a 'find_element'. " +
+            "Las coordenadas siempre son pixeles fisicos de pantalla.",
+        parameters: {
+            type: "object",
+            properties: {
+                action: {
+                    type: "string",
+                    enum: [
+                        "list_windows",
+                        "ui_snapshot",
+                        "ui_click",
+                        "ui_type",
+                        "ui_focus",
+                        "find_element",
+                        "screenshot",
+                        "click",
+                        "left_click",
+                        "double_click",
+                        "triple_click",
+                        "right_click",
+                        "middle_click",
+                        "mouse_move",
+                        "left_click_drag",
+                        "scroll",
+                        "type",
+                        "key",
+                        "wait",
+                        "cursor_position",
+                        "focus_window",
+                        "get_active_window",
+                        "open_app",
+                    ],
+                    description: "list_windows: inventario de ventanas. ui_snapshot: lista los controles reales de una ventana con su ref. " +
+                        "ui_click/ui_type/ui_focus: actuan sobre un ref sin tocar el raton. find_element: busca un control por texto y, si hace falta, lo localiza con vision. " +
+                        "screenshot: captura una ventana concreta (aunque este tapada) y la describe. click/type/key: entrada real, solo como ultimo recurso.",
+                },
+                window: {
+                    type: "string",
+                    description: 'Ventana objetivo por titulo o proceso (ej. "chrome", "Blender", "Calculadora"). ' +
+                        "Casi todas las acciones deberian llevarla: sin ella se actua sobre lo que este delante, que es como se acaba escribiendo en la ventana equivocada.",
+                },
+                mode: {
+                    type: "string",
+                    enum: ["background", "foreground"],
+                    description: "background (por defecto): manda el evento a la ventana sin traerla al frente. foreground: mueve el raton real, solo si el modo de fondo no funciona.",
+                },
+                ref: { type: "integer", description: "Numero de control devuelto por ui_snapshot." },
+                query: { type: "string", description: "Texto del control a buscar en find_element." },
+                filter: { type: "string", description: "Filtra ui_snapshot o list_windows por texto." },
+                max: { type: "integer", description: "Maximo de controles en ui_snapshot (por defecto 120)." },
+                coordinate: {
+                    type: "array",
+                    items: { type: "integer" },
+                    description: "[x, y] en pixeles fisicos. Solo con coordenadas que te haya dado ui_snapshot o find_element.",
+                },
+                x: { type: "integer", description: "Coordenada X en pixeles fisicos." },
+                y: { type: "integer", description: "Coordenada Y en pixeles fisicos." },
+                start_coordinate: { type: "array", items: { type: "integer" }, description: "[x, y] de inicio del arrastre." },
+                text: { type: "string", description: "Texto a escribir." },
+                keys: { type: "string", description: 'Tecla o atajo (ej. "Return", "Escape", "ctrl+s", "alt+Tab").' },
+                repeat: { type: "integer", description: "Veces que repetir la tecla." },
+                direction: { type: "string", enum: ["up", "down", "left", "right"], description: "Direccion del scroll." },
+                amount: { type: "integer", description: "Cantidad de scroll." },
+                ms: { type: "integer", description: "Milisegundos de espera." },
+                outputPath: { type: "string", description: "Ruta donde guardar la captura." },
+                question: { type: "string", description: "Pregunta concreta para el analisis visual de la captura." },
+                analyze: { type: "boolean", description: "false para guardar la captura sin gastar tokens de vision." },
+                appName: { type: "string", description: "Aplicacion o URL a lanzar con open_app." },
+            },
+            required: ["action"],
+        },
+    },
+};
+export const CHROME_TOOL = {
+    type: "function",
+    function: {
+        name: "chrome",
+        description: "PREFERENTE para cualquier pagina web. Controla el Chrome REAL del usuario desde dentro, mediante la extension de Chocolatito Code. " +
+            "Usa sus sesiones ya iniciadas (Google Flow, Gmail, paneles) y trabaja EN SEGUNDO PLANO de verdad: " +
+            "no mueve el raton, no cambia de pestana visible y no roba el foco, asi que el usuario puede seguir jugando o trabajando. " +
+            "La pestana en la que trabajas se agrupa en un grupo naranja 'Chocolatito Code' y muestra un aviso flotante. " +
+            "FLUJO OBLIGATORIO: 'snapshot' para leer la pagina -> 'click'/'type' con el ref -> 'snapshot' para verificar. " +
+            "Al terminar, llama a 'done' para retirar el aviso.",
+        parameters: {
+            type: "object",
+            properties: {
+                action: {
+                    type: "string",
+                    enum: [
+                        "status", "tabs", "open", "select_tab", "navigate", "snapshot",
+                        "click", "type", "press", "get_text", "eval", "wait_for",
+                        "screenshot", "notice", "close_tab", "done",
+                    ],
+                    description: "status: comprueba que la extension esta conectada. tabs: lista las pestanas del usuario. " +
+                        "open: abre una pestana nueva SIN quitarle la pantalla al usuario. select_tab: elige una ya abierta. " +
+                        "snapshot: LEE la pagina y numera los elementos. click/type: actuan sobre un ref. " +
+                        "wait_for: espera un texto o unos ms. screenshot: captura la pestana aunque no este visible y la describe. " +
+                        "notice: cambia el texto del aviso flotante. close_tab: cierra una pestaña que abriste. done: cierra el trabajo y quita el aviso.",
+                },
+                url: { type: "string", description: "URL para open o navigate." },
+                tabId: { type: "integer", description: "Pestana concreta; por defecto, en la que se esta trabajando." },
+                ref: { type: "integer", description: "Numero de elemento devuelto por snapshot." },
+                text: { type: "string", description: "Texto a escribir (type) o a esperar (wait_for)." },
+                submit: { type: "boolean", description: "true para pulsar Enter despues de escribir." },
+                replace: { type: "boolean", description: "false para anadir al final en vez de sustituir." },
+                keys: { type: "string", description: 'Tecla para press (ej. "Enter", "Escape").' },
+                match: { type: "string", description: "Texto del titulo o URL para select_tab." },
+                filter: { type: "string", description: "Filtra el snapshot. Uselo en paginas con muchos elementos." },
+                max: { type: "integer", description: "Maximo de elementos del snapshot (por defecto 60)." },
+                script: { type: "string", description: "JavaScript a evaluar en la pagina." },
+                ms: { type: "integer", description: "Milisegundos de espera." },
+                timeout: { type: "integer", description: "Tiempo limite en ms." },
+                question: { type: "string", description: "Pregunta concreta para el analisis visual de la captura." },
+                analyze: { type: "boolean", description: "false para no gastar tokens de vision." },
+                outputPath: { type: "string", description: "Ruta donde guardar la captura." },
+                note: { type: "string", description: "Texto inicial del aviso flotante al abrir la pestana." },
+            },
+            required: ["action"],
+        },
+    },
+};

package/dist/tools/truncator.d.ts

@@ -0,0 +1,11 @@
+export declare const MAX_TOOL_OUTPUT_CHARS = 60000;
+/**
+ * Recorta la salida de una herramienta conservando el PRINCIPIO Y EL FINAL.
+ *
+ * La version anterior cortaba por el medio y tiraba todo lo que venia despues.
+ * En la salida de un comando eso es justo lo peor: el mensaje de error, el
+ * resumen de los tests y el codigo de salida estan al final. El agente veia
+ * 25.000 caracteres de compilacion y se perdia la linea que decia por que habia
+ * fallado.
+ */
+export declare function truncateOutput(output: string, maxChars?: number): string;

package/dist/tools/truncator.js

@@ -0,0 +1,24 @@
+export const MAX_TOOL_OUTPUT_CHARS = 60_000;
+/**
+ * Recorta la salida de una herramienta conservando el PRINCIPIO Y EL FINAL.
+ *
+ * La version anterior cortaba por el medio y tiraba todo lo que venia despues.
+ * En la salida de un comando eso es justo lo peor: el mensaje de error, el
+ * resumen de los tests y el codigo de salida estan al final. El agente veia
+ * 25.000 caracteres de compilacion y se perdia la linea que decia por que habia
+ * fallado.
+ */
+export function truncateOutput(output, maxChars = MAX_TOOL_OUTPUT_CHARS) {
+    if (!output || output.length <= maxChars) {
+        return output;
+    }
+    // Dos tercios al principio (contexto de lo que se hizo) y un tercio al final
+    // (donde suele estar el desenlace).
+    const headChars = Math.floor(maxChars * 0.65);
+    const tailChars = maxChars - headChars;
+    const head = output.slice(0, headChars);
+    const tail = output.slice(output.length - tailChars);
+    const omitted = output.length - maxChars;
+    return (`${head}\n\n[... ${omitted.toLocaleString()} caracteres omitidos del medio ` +
+        `para proteger el contexto; se conserva el final ...]\n\n${tail}`);
+}