zyn-ai 1.3.3 → 1.3.5

package/src/core/prompts.js

@@ -66,7 +66,7 @@ function buildSystemPrompt(cwd, state = {}, options = {}) {
 
   const languageInstructions = language === 'es'
     ? [
-        'Responde siempre en español.',
+        'Responde en el idioma del ultimo mensaje del usuario (si es ambiguo, usa la preferencia de sesion).',
         'Ejecuta la tarea directamente. No des tutoriales ni instrucciones al usuario cuando puedas actuar tú mismo.',
         'Si hace falta, usa herramientas sin pedir permiso extra.',
         'Responde solo con el resultado final o con la siguiente accion concreta.',
@@ -76,15 +76,13 @@ function buildSystemPrompt(cwd, state = {}, options = {}) {
         'No cierres con una conclusion si todavia no has probado nada.',
         'Si una tarea dura demasiado, usa run_command con un timeoutMs adecuado y confirma el resultado real.',
         'Para operaciones de Git usa la herramienta git con action="api" o action="clone".',
-        'Usa exclusivamente tools registradas en "Tool use". No inventes nombres de tools ni aliases.',
-        'Mantente acotado y determinista: entradas claras, salidas claras, sin razonamiento creativo salvo que el usuario lo pida.',
-        'Cuando aplique, entrega resumen ejecutivo corto + riesgos/banderas rojas + siguiente accion concreta.',
-        'Para proyectos, usa combinaciones de tools según la fase: descubrir (list_dir/search_text), leer (read_file/fetch/webfetch), cambiar (write/replace), validar (run_command), documentar (final).',
+        'Para proyectos, usa combinaciones de tools según la fase: descubrir (list_dir/search_text), leer (read_file/fetch/webfetch), cambiar (write/replace), validar (run_command), subir artefactos si hace falta (upload_file), documentar (final).',
+        'Antes de elegir una herramienta revisa su nombre exacto, argumentos requeridos y resultado esperado; usa read/search/list antes de editar y run_command para validar cambios.',
         'No te limites a una sola tool por costumbre; elige la mejor secuencia técnica para el objetivo.',
         'Si el usuario pide logos, mockups o piezas visuales para un proyecto/frontend, usa create_canvas_image cuando corresponda, junto al resto de tools del flujo.',
       ]
     : [
-        'Always respond in English.',
+        'Respond in the language of the user\'s latest message (if ambiguous, use the session preference).',
         'Execute the task directly. Do not give tutorials or instructions when you can act yourself.',
         'Use tools when needed without asking for extra permission.',
         'Reply only with the final result or the next concrete action.',
@@ -94,12 +92,55 @@ function buildSystemPrompt(cwd, state = {}, options = {}) {
         'Do not end with a conclusion if you have not tested anything yet.',
         'If a task takes long, use run_command with an appropriate timeoutMs and verify the real result.',
         'For Git operations use the git tool with action="api" or action="clone".',
-        'Use only tools listed under "Tool use". Never invent tool names or aliases.',
-        'Stay bounded and deterministic: clear inputs, clear outputs, no creative reasoning unless explicitly requested.',
-        'When relevant, provide a short executive summary + obvious red flags + next concrete action.',
-        'For project work, combine tools by phase: discover (list_dir/search_text), read (read_file/fetch/webfetch), change (write/replace), validate (run_command), then report.',
+        'For project work, combine tools by phase: discover (list_dir/search_text), read (read_file/fetch/webfetch), change (write/replace), validate (run_command), upload artifacts if needed (upload_file), then report.',
+        'Before choosing a tool, verify its exact name, required args, and expected result; use read/search/list before editing and run_command to validate changes.',
         'Do not over-focus on a single tool by habit; choose the best technical sequence for the goal.',
         'If the user asks for logos, mockups, or visual assets for a project/frontend, use create_canvas_image when appropriate together with the rest of the workflow.',
+        'Prioritize and reuse explicit user-provided context (requirements, constraints, repo instructions, preferences) across the full task; do not ignore it.',
+      ];
+
+  const toolUseEnforcement = language === 'es'
+    ? [
+        '',
+        '# Formato obligatorio de respuesta',
+        'Solo existen DOS formatos de respuesta. NO inventes otros:',
+        '',
+        'FORMATO 1 — Para USAR una herramienta:',
+        '{"type":"tool","tool":"NOMBRE_EXACTO","args":{"clave":"valor"}}',
+        '',
+        'FORMATO 2 — Para responder AL USUARIO:',
+        '{"type":"final","content":"Tu respuesta aqui"}',
+        '',
+        'REGLAS ESTRICTAS:',
+        '- USA EXCLUSIVAMENTE los nombres de herramientas listados en "# Tool use".',
+        '- NO inventes herramientas como "code_interpreter", "python", "bash", "shell", etc.',
+        '- NO uses formatos como <invoke>, function calls, ni tool_use de otros sistemas.',
+        '- Si una herramienta falla, INTENTA con otra herramienta diferente.',
+        '- Si una herramienta falla 2 VECES seguidas, no la repitas. Cambia de estrategia o usa type=final.',
+        '- LIMITE: Maximo 8 herramientas por turno. Despues de 8 pasos, responde con type=final.',
+        '- Si no puedes completar la tarea, responde con type=final explicando honestamente por que.',
+        '- Cada respuesta debe ser UNICAMENTE el JSON. Sin texto antes ni despues.',
+      ]
+    : [
+        '',
+        '# Strict response format',
+        'Only TWO response formats are allowed. Do NOT use others:',
+        '',
+        'FORMAT 1 — To USE a tool:',
+        '{"type":"tool","tool":"EXACT_NAME","args":{"key":"value"}}',
+        '',
+        'FORMAT 2 — To REPLY to user:',
+        '{"type":"final","content":"Your answer here"}',
+        '',
+        'STRICT RULES:',
+        '- ONLY use tool names listed in "# Tool use".',
+        '- Do NOT invent tools like "code_interpreter", "python", "bash", "shell", etc.',
+        '- Do NOT use <invoke>, function call, or tool_use formats from other systems.',
+        '- If a tool fails, TRY a different tool instead.',
+        '- If a tool fails 2 TIMES in a row, do not repeat it. Change strategy or use type=final.',
+        '- LIMIT: Maximum 8 tools per turn. After 8 steps, respond with type=final.',
+        '- If you cannot complete the task, use type=final and honestly explain why.',
+        '- Each response must be ONLY the JSON. No text before or after.',
       ];
 
   const parts = [
@@ -107,6 +148,7 @@ function buildSystemPrompt(cwd, state = {}, options = {}) {
     '',
     '# Tool use',
     getToolPromptText(),
+    ...toolUseEnforcement,
     '',
     '# Environment',
     `- Working directory: ${cwd}`,
@@ -220,6 +262,9 @@ function classifyParsed(parsed) {
   if (parsed?.type === 'final') {
     return { type: 'final', content: typeof parsed.content === 'string' ? parsed.content : '' };
   }
+  if (parsed?.tool && KNOWN_TOOLS.has(parsed.tool)) {
+    return { type: 'tool', tool: parsed.tool, args: parsed.args ?? {} };
+  }
   return null;
 }
 
@@ -241,6 +286,8 @@ const TOOL_ARG_KEYS = {
   scrape_site: ['url', 'selectors', 'limit', 'headers'],
   web_search: ['query', 'lang', 'limit'],
   web_read: ['url'],
+  upload_file: ['path', 'field', 'name', 'type'],
+  gmail: ['action', 'query', 'maxResults', 'id', 'to', 'subject', 'body'],
   create_canvas_image: ['width', 'height', 'background', 'elements', 'format', 'outputPath'],
   git: ['provider', 'action', 'method', 'path', 'body', 'headers', 'name', 'repoUrl', 'destination', 'branch', 'timeoutMs'],
 };
@@ -252,8 +299,40 @@ const LONG_VALUE_ARG = {
   replace_in_file: 'replace',
 };
 
+
+function extractMalformedFinalContent(text) {
+  const typeMatch = text.match(/(?:["'])type(?:["'])\s*:\s*(?:["'])final(?:["'])/i);
+  if (!typeMatch) return null;
+
+  const contentMatch = text.match(/(?:["'])content(?:["'])\s*:\s*(["'])/i);
+  if (!contentMatch) return null;
+
+  const quote = contentMatch[1];
+  const start = contentMatch.index + contentMatch[0].length;
+  let esc = false;
+
+  for (let i = start; i < text.length; i += 1) {
+    const ch = text[i];
+    if (esc) { esc = false; continue; }
+    if (ch === '\\') { esc = true; continue; }
+    if (ch !== quote) continue;
+
+    const tail = text.slice(i + 1).trim();
+    if (!tail || /^}\s*$/.test(tail) || /^,\s*(["']\w+["']\s*:|})/.test(tail)) {
+      return unescapeJsonString(text.slice(start, i)).trim();
+    }
+  }
+
+  const lastQuote = text.lastIndexOf(quote);
+  if (lastQuote > start) {
+    return unescapeJsonString(text.slice(start, lastQuote)).trim();
+  }
+
+  return null;
+}
+
 function fuzzyExtractTool(text) {
-  const toolMatch = text.match(/"tool"\s*:\s*"(\w+)"/);
+  const toolMatch = text.match(/(?:"|')?tool(?:"|')?\s*:\s*"(\w+)"/i);
   if (!toolMatch) return null;
 
   const tool = toolMatch[1];
@@ -284,32 +363,57 @@ function findStringEnd(text, start) {
   return -1;
 }
 
+function extractArgsContext(text) {
+  const argsMatch = text.match(/(?:"|')?args(?:"|')?\s*:\s*\{/i);
+  if (!argsMatch) return text;
+
+  let depth = 1;
+  let inStr = false;
+  let esc = false;
+  const start = argsMatch.index + argsMatch[0].length - 1;
+
+  for (let i = start + 1; i < text.length; i++) {
+    const ch = text[i];
+    if (esc) { esc = false; continue; }
+    if (ch === '\\' && inStr) { esc = true; continue; }
+    if (ch === '"') { inStr = !inStr; continue; }
+    if (inStr) continue;
+    if (ch === '{') depth++;
+    if (ch === '}') {
+      depth--;
+      if (depth === 0) return text.slice(start, i + 1);
+    }
+  }
+  return text;
+}
+
 function extractLongValueTool(text, tool, longArg) {
+  const context = extractArgsContext(text);
   const args = {};
   const keys = TOOL_ARG_KEYS[tool] || [];
 
   for (const key of keys) {
     if (key === longArg) continue;
-    const m = text.match(new RegExp(`"${key}"\\s*:\\s*"([^"]*?)"`));
+    const m = context.match(new RegExp(`(?:"|')?${key}(?:"|')?\\s*:\\s*"([^"]*?)"`));
     if (m) args[key] = unescapeJsonString(m[1]);
-    const bm = text.match(new RegExp(`"${key}"\\s*:\\s*(true|false|\\d+)`));
+    const bm = context.match(new RegExp(`(?:"|')?${key}(?:"|')?\\s*:\\s*(true|false|\\d+)`));
     if (bm) args[key] = bm[1] === 'true' ? true : bm[1] === 'false' ? false : Number(bm[1]);
   }
 
-  const marker = `"${longArg}"`;
-  const argIdx = text.indexOf(marker);
-  if (argIdx === -1) return null;
+  const longKeyRe = new RegExp(`(?:"|')?${longArg}(?:"|')?\\s*:`);
+  const longMatch = context.match(longKeyRe);
+  if (!longMatch) return null;
 
-  let i = text.indexOf(':', argIdx + marker.length);
-  if (i === -1) return null;
-  i = text.indexOf('"', i);
-  if (i === -1) return null;
-  const valStart = i + 1;
+  const colonPos = context.indexOf(':', longMatch.index + longMatch[0].length - 1);
+  if (colonPos === -1) return null;
+  const quotePos = context.indexOf('"', colonPos);
+  if (quotePos === -1) return null;
+  const valStart = quotePos + 1;
 
-  const valEnd = findStringEnd(text, valStart);
+  const valEnd = findStringEnd(context, valStart);
   if (valEnd === -1 || valEnd <= valStart) return null;
 
-  const value = text.slice(valStart, valEnd);
+  const value = context.slice(valStart, valEnd);
   if (!value.trim()) return null;
 
   args[longArg] = unescapeJsonString(value);
@@ -321,9 +425,9 @@ function extractSimpleArgsTool(text, tool) {
   const keys = TOOL_ARG_KEYS[tool] || [];
 
   for (const key of keys) {
-    const strM = text.match(new RegExp(`"${key}"\\s*:\\s*"([^"]*?)"`));
+    const strM = text.match(new RegExp(`(?:"|')?${key}(?:"|')?\\s*:\\s*"([^"]*?)"`));
     if (strM) { args[key] = unescapeJsonString(strM[1]); continue; }
-    const numM = text.match(new RegExp(`"${key}"\\s*:\\s*(true|false|\\d+)`));
+    const numM = text.match(new RegExp(`(?:"|')?${key}(?:"|')?\\s*:\\s*(true|false|\\d+)`));
     if (numM) {
       const v = numM[1];
       args[key] = v === 'true' ? true : v === 'false' ? false : Number(v);
@@ -355,6 +459,13 @@ function parseAgentResponse(raw) {
   const tool = extractToolJson(text);
   if (tool) return { type: 'tool', tool: tool.tool, args: tool.args ?? {} };
 
+  const malformedFinalContent = extractMalformedFinalContent(text);
+  if (malformedFinalContent !== null) {
+    const embedded = extractToolJson(malformedFinalContent);
+    if (embedded) return { type: 'tool', tool: embedded.tool, args: embedded.args ?? {} };
+    return { type: 'final', content: malformedFinalContent };
+  }
+
   const xmlTool = extractXmlTool(text);
   if (xmlTool) return xmlTool;
 
@@ -364,7 +475,7 @@ function parseAgentResponse(raw) {
   const fuzzy = fuzzyExtractTool(text);
   if (fuzzy) return fuzzy;
 
-  return { type: 'final', content: text || raw.trim() };
+  return { type: 'final', content: text || (raw ? String(raw).trim() : '') };
 }
 
 function sanitizeArgsForModel(parsed) {
@@ -402,11 +513,15 @@ function buildConversationMessages(state, turnMessages, systemPrompt) {
 }
 
 function buildToolResultMessage(parsed, result) {
+  const maxResultChars = 8000;
+  const truncatedResult = typeof result === 'string' && result.length > maxResultChars
+    ? `${result.slice(0, maxResultChars)}\n... [resultado truncado, ${result.length} caracteres totales]`
+    : result;
   return [
     `Herramienta: ${parsed.tool}`,
     `Argumentos: ${JSON.stringify(sanitizeArgsForModel(parsed), null, 2)}`,
     'Resultado:',
-    result,
+    truncatedResult,
     '',
     'Responde con la siguiente accion concreta o con el resultado final.',
   ].join('\n');
@@ -414,9 +529,10 @@ function buildToolResultMessage(parsed, result) {
 
 function buildToolErrorMessage(parsed, errorMessage) {
   return [
-    `La herramienta ${parsed.tool} fallo.`,
+    `La herramienta "${parsed.tool}" NO existe.`,
     `Error: ${errorMessage}`,
-    'Corrige la llamada o explica brevemente el problema si no puedes continuar.',
+    `Las unicas herramientas disponibles son: ${TOOL_DEFINITIONS.map(t => t.name).join(', ')}.`,
+    'Elige UNA de esas herramientas. Usa el formato exacto del nombre. No inventes herramientas.',
   ].join('\n');
 }
 

package/src/i18n.js

@@ -30,7 +30,7 @@ const STRINGS = {
     webUrl: 'Web URL',
     chooseLanguage: 'Choose language from commands: /lang en or /lang es',
     langCurrent: 'Current language',
-    langChanged: 'Language updated',
+    langChanged: 'Updated to language',
     langInvalid: 'Unsupported language. Available: en, es',
     noSavedSessions: 'No saved sessions.',
     noMemory: 'No compacted memory.',
@@ -75,7 +75,7 @@ const STRINGS = {
     webUrl: 'URL web',
     chooseLanguage: 'Elige idioma con /lang en o /lang es',
     langCurrent: 'Idioma actual',
-    langChanged: 'Idioma actualizado',
+    langChanged: 'Actualizado al idioma',
     langInvalid: 'Idioma no soportado. Disponibles: en, es',
     noSavedSessions: 'No hay sesiones guardadas.',
     noMemory: 'Sin memoria compactada.',

package/src/providers/catalog.js

@@ -1,6 +1,6 @@
 const fs = require('fs');
 const path = require('path');
-const { MODELS_FILE, PROVIDERS_FILE, REQUEST_TIMEOUT_MS } = require('../config');
+const { MODELS_FILE, PROVIDERS_FILE, REQUEST_TIMEOUT_MS, SUPPORTED_MODEL_PROVIDERS } = require('../config');
 
 const DEFAULT_HEADERS = {
   'Content-Type': 'application/json',
@@ -108,13 +108,17 @@ function loadExternalModels() {
   if (Array.isArray(raw)) {
     const output = {};
     for (const item of raw) {
-      if (!item?.key) continue;
+      if (!item?.key || !SUPPORTED_MODEL_PROVIDERS.has(item.provider)) continue;
       output[item.key] = item;
     }
     return output;
   }
-  if (raw.models && typeof raw.models === 'object') return raw.models;
-  return raw && typeof raw === 'object' ? raw : {};
+  const rawModels = raw.models && typeof raw.models === 'object'
+    ? raw.models
+    : (raw && typeof raw === 'object' ? raw : {});
+  return Object.fromEntries(
+    Object.entries(rawModels).filter(([, model]) => SUPPORTED_MODEL_PROVIDERS.has(model?.provider)),
+  );
 }
 
 function saveExternalModels(models) {
@@ -165,43 +169,6 @@ function buildModelRecord(providerKey, config, modelId, label, extra = {}) {
   return record;
 }
 
-async function fetchOllamaModels(config) {
-  const baseUrl = normalizeBaseUrl(config.baseUrl || 'http://127.0.0.1:11434');
-  const data = await fetchJson(`${baseUrl}/api/tags`, {
-    headers: config.apiKey ? { Authorization: `Bearer ${config.apiKey}` } : {},
-  });
-  const models = Array.isArray(data?.models) ? data.models : [];
-  return models.map(model => buildModelRecord(
-    'ollama',
-    { ...config, baseUrl },
-    model.name || model.model || model.id,
-    model.name || model.model || model.id,
-    {
-      ollamaModel: model.name || model.model || model.id,
-      raw: model,
-    },
-  )).filter(item => item.modelId);
-}
-
-async function fetchOpenAICompatibleModels(config) {
-  const baseUrl = normalizeBaseUrl(config.baseUrl);
-  if (!baseUrl) throw new Error('Falta baseUrl para openai-compatible');
-  const data = await fetchJson(`${baseUrl}/v1/models`, {
-    headers: config.apiKey ? { Authorization: `Bearer ${config.apiKey}` } : {},
-  });
-  const models = Array.isArray(data?.data) ? data.data : Array.isArray(data?.models) ? data.models : [];
-  return models.map(model => buildModelRecord(
-    'openai-compatible',
-    { ...config, baseUrl },
-    model.id || model.name,
-    model.id || model.name,
-    {
-      openaiModel: model.id || model.name,
-      raw: model,
-    },
-  )).filter(item => item.modelId);
-}
-
 async function fetchZenModels(config) {
   const baseUrl = normalizeBaseUrl(config.baseUrl || 'https://opencode.ai/zen');
   const data = await fetchJson(`${baseUrl}/v1/models`, {
@@ -238,10 +205,27 @@ async function fetchQwenModels(config) {
   ));
 }
 
+
+async function fetchGeminiModels(config) {
+  const models = [
+    { id: 'gemini-flash', label: 'Gemini Flash' },
+  ];
+  return models.map(model => buildModelRecord(
+    'gemini',
+    config,
+    model.id,
+    model.label,
+    {
+      geminiModel: model.id,
+      static: true,
+    },
+  ));
+}
+
 async function fetchProviderModels(providerKey, config = {}) {
   const key = String(providerKey || '').trim();
-  if (key === 'ollama') return fetchOllamaModels(config);
-  if (key === 'openai-compatible') return fetchOpenAICompatibleModels(config);
+  if (!SUPPORTED_MODEL_PROVIDERS.has(key)) throw new Error(`Proveedor no soportado: ${key}`);
+  if (key === 'gemini') return fetchGeminiModels(config);
   if (key === 'zen') return fetchZenModels(config);
   if (key === 'qwen') return fetchQwenModels(config);
   throw new Error(`Proveedor no soportado: ${key}`);