@danieltmn/tamnora 0.26.0 → 0.27.0

package/harness/packages/core/src/tools/executors.js

@@ -547,6 +547,88 @@ export function showPlanTool(_root, { title, steps } = {}) {
   return `Plan mostrado al usuario${head ? ` ("${head}")` : ''}:\n${lines.join('\n')}`;
 }
 
+const CHART_TYPES = new Set(['bar', 'line', 'pie']);
+const MAX_CHART_LABELS = 24;
+const MAX_CHART_SERIES = 6;
+
+/**
+ * Normaliza los datos de un grafico: labels y series alineados y numericos.
+ * Devuelve null si no queda nada para dibujar.
+ */
+export function normalizeChartSpec({ title, type, labels, series, unit } = {}) {
+  const clean = Array.isArray(labels) ? labels.map((l) => String(l ?? '').trim()).slice(0, MAX_CHART_LABELS) : [];
+  const items = clean.map((l, idx) => l || `#${idx + 1}`);
+  if (!items.length) return null;
+  const n = items.length;
+  const data = (Array.isArray(series) ? series : [])
+    .filter((s) => s && typeof s === 'object' && Array.isArray(s.values))
+    .slice(0, MAX_CHART_SERIES)
+    .map((s, idx) => ({
+      name: String(s.name ?? `Serie ${idx + 1}`).trim().slice(0, 40) || `Serie ${idx + 1}`,
+      values: Array.from({ length: n }, (_, i) => {
+        const v = Number(s.values[i]);
+        return Number.isFinite(v) ? v : 0;
+      }),
+    }));
+  if (!data.length) return null;
+  return {
+    type: CHART_TYPES.has(type) ? type : 'bar',
+    title: String(title ?? '').trim().slice(0, 120),
+    unit: String(unit ?? '').trim().slice(0, 20),
+    labels: items,
+    series: data,
+  };
+}
+
+/**
+ * Muestra un grafico de datos. Solo lectura: el cliente lo dibuja como SVG; el
+ * modelo lo reemite para actualizar los datos.
+ */
+export function showChartTool(_root, args = {}) {
+  const spec = normalizeChartSpec(args);
+  if (!spec) return 'Error: pasá "labels" (categorías) y "series" (con "values" numéricos).';
+  const head = `${spec.type === 'pie' ? 'Torta' : spec.type === 'line' ? 'Líneas' : 'Barras'}${
+    spec.title ? ` ("${spec.title}")` : ''
+  }`;
+  const detail = spec.series.map((s) => `- ${s.name}: ${s.values.join(', ')}`).join('\n');
+  return `Gráfico mostrado al usuario — ${head} · ${spec.labels.join(' | ')}${spec.unit ? ` (${spec.unit})` : ''}:\n${detail}`;
+}
+
+const IMAGE_SIZE = /^\d{2,4}x\d{2,4}$/;
+
+/**
+ * Genera una imagen a partir de un prompt. La generacion es del servidor (el
+ * executor la pide via `onImage`, como `ask_user` espera su formulario): la
+ * imagen se guarda en la casa y la consola la muestra inline.
+ */
+export async function generateImageTool(_root, { prompt, size, model } = {}, { onImage, signal } = {}) {
+  const texto = String(prompt ?? '').replace(/\s+/g, ' ').trim();
+  if (!texto) return 'Error: falta "prompt".';
+  if (typeof onImage !== 'function') {
+    return 'No hay generador de imágenes en este canal: describí la imagen en el texto de la respuesta.';
+  }
+  const opts = {
+    prompt: texto.length > 2000 ? texto.slice(0, 2000).trimEnd() : texto,
+    size: IMAGE_SIZE.test(String(size ?? '')) ? String(size) : undefined,
+    model: String(model ?? '').trim() || undefined,
+    signal,
+  };
+  let image;
+  try {
+    image = await onImage(opts);
+  } catch (error) {
+    return `Error generando la imagen: ${error?.message ?? error}`;
+  }
+  if (!image?.name) return 'Error generando la imagen: el proveedor no devolvió una imagen.';
+  const dims = image.width && image.height ? `${image.width}x${image.height}` : '';
+  return {
+    content: `Imagen generada → capturas/${image.name} (${[dims, image.bytes ? `${Math.round(image.bytes / 1024)} KB` : '']
+      .filter(Boolean)
+      .join(', ')}): "${opts.prompt}"`,
+    meta: { image: { name: image.name, width: image.width, height: image.height, prompt: opts.prompt } },
+  };
+}
+
 /**
  * Captura de pantalla con el navegador headless del sistema. La guarda en la
  * casa (`screenshots/`) y devuelve un `meta.screenshot` para que la consola la
@@ -627,6 +709,8 @@ export const EXECUTORS = {
   ask_user: askUserTool,
   offer_choices: offerChoicesTool,
   show_plan: showPlanTool,
+  show_chart: showChartTool,
+  generate_image: generateImageTool,
   screenshot: screenshotTool,
   console_errors: consoleTool,
 };

package/harness/packages/core/src/tools/labels.js

@@ -56,6 +56,13 @@ export function summarizeToolCall(name, args = {}) {
       return shorten(a.url, 90);
     case 'speak':
       return shorten(a.texto, 90);
+    case 'show_chart': {
+      const tipo = a.type === 'pie' ? 'torta' : a.type === 'line' ? 'líneas' : 'barras';
+      const labels = Array.isArray(a.labels) ? a.labels.length : 0;
+      return [a.title ? shorten(a.title, 40) : '', labels ? `${tipo} · ${labels} datos` : tipo].filter(Boolean).join(' · ');
+    }
+    case 'generate_image':
+      return shorten(a.prompt, 90);
     case 'git_diff':
       return [a.ref ? `vs ${shorten(a.ref, 30)}` : a.staged ? 'staged' : 'unstaged', a.path ? path(a.path) : '']
         .filter(Boolean)

package/harness/packages/core/src/tools/permissions.js

@@ -20,10 +20,12 @@ export const DEFAULT_PERMISSIONS = {
   ask_user: 'allow',
   offer_choices: 'allow',
   show_plan: 'allow',
+  show_chart: 'allow',
   write: 'ask',
   edit: 'ask',
   bash: 'ask',
   git_commit: 'ask',
+  generate_image: 'ask',
 };
 
 function patternToRegExp(pattern) {
@@ -49,6 +51,7 @@ function subjectFor(name, args) {
   if (name === 'bash') return args?.command ?? '';
   if (name === 'git_commit') return args?.message ?? '';
   if (name === 'fetch_url') return args?.url ?? '';
+  if (name === 'generate_image') return args?.prompt ?? '';
   if (name === 'screenshot' || name === 'console_errors' || name === 'preview_url') return args?.url ?? '';
   return args?.path ?? '';
 }

package/harness/packages/core/src/tools/registry.js

@@ -20,10 +20,11 @@ function extensionOf(p) {
  * @param {string[]} [opts.writeExtensions] - si se define, `write`/`edit` solo aceptan estas extensiones (p.ej. ['.md', '.json'])
  * @param {(name:string, args:object)=>Promise<boolean>} [opts.onAsk] - interactive approval
  * @param {(payload:{title:string, questions:object[]})=>Promise<{answers:object,cancelled?:boolean}>} [opts.onQuestion] - interactive form
+ * @param {(payload:{prompt:string,size?:string,model?:string})=>Promise<{name:string,width?:number,height?:number,bytes?:number}>} [opts.onImage] - image generation (server-side)
  * @param {boolean} [opts.yes] - auto-approve 'ask' (non-interactive)
  * @param {AbortSignal} [opts.signal] - cancela las tools de larga duracion (bash, git)
  */
-export function createToolRegistry({ root, enabled, permissions = {}, onAsk, onQuestion, yes = false, signal, writeExtensions } = {}) {
+export function createToolRegistry({ root, enabled, permissions = {}, onAsk, onQuestion, onImage, yes = false, signal, writeExtensions } = {}) {
   // `enabled` undefined = todas; una lista se respeta tal cual (vacía = ninguna,
   // no "todas": un modo restringido no puede quedar sin tools por un filtro).
   const names = new Set(Array.isArray(enabled) ? enabled : TOOL_NAMES);
@@ -63,7 +64,7 @@ export function createToolRegistry({ root, enabled, permissions = {}, onAsk, onQ
       return `Permiso denegado para "${name}"${detail ? ` (${detail})` : ''}.`;
     }
 
-    return EXECUTORS[name](root, args, { signal, onQuestion });
+    return EXECUTORS[name](root, args, { signal, onQuestion, onImage });
   }
 
   return {

package/harness/packages/core/src/tools/schema.js

@@ -169,6 +169,25 @@ export const TOOL_DEFINITIONS = [
       },
     },
   },
+  {
+    type: 'function',
+    function: {
+      name: 'generate_image',
+      description:
+        'Generate an image from a text prompt with the configured image model and show it to the user in the chat. Use it when the user asks for an image, an illustration, a logo mock or similar. Describe the image in detail in the prompt.',
+      parameters: {
+        type: 'object',
+        properties: {
+          prompt: { type: 'string', description: 'What the image should depict (be detailed)' },
+          size: {
+            type: 'string',
+            description: 'Size like "1024x1024" (default 1024x1024). Common: 1536x1024 (landscape), 1024x1536 (portrait).',
+          },
+        },
+        required: ['prompt'],
+      },
+    },
+  },
   {
     type: 'function',
     function: {
@@ -284,6 +303,40 @@ export const TOOL_DEFINITIONS = [
       },
     },
   },
+  {
+    type: 'function',
+    function: {
+      name: 'show_chart',
+      description:
+        'Show the user a data chart (bar, line or pie) as a visualization in the chat, instead of writing a table or ASCII art. Pass labels (categories) and one or more series of numeric values; for pie, pass a single series of non-negative values. Re-emit it with new data to update the chart. Read-only: it only displays.',
+      parameters: {
+        type: 'object',
+        properties: {
+          title: { type: 'string', description: 'Short chart heading (optional)' },
+          type: { type: 'string', enum: ['bar', 'line', 'pie'], description: 'Chart type (default bar)' },
+          labels: {
+            type: 'array',
+            items: { type: 'string' },
+            description: 'Category labels (x axis / pie slices), 1-24',
+          },
+          series: {
+            type: 'array',
+            description: 'Data series (1-6). For pie only the first series is used.',
+            items: {
+              type: 'object',
+              properties: {
+                name: { type: 'string', description: 'Series name (legend)' },
+                values: { type: 'array', items: { type: 'number' }, description: 'One value per label' },
+              },
+              required: ['values'],
+            },
+          },
+          unit: { type: 'string', description: 'Optional unit for values, e.g. "USD", "%"' },
+        },
+        required: ['labels', 'series'],
+      },
+    },
+  },
   {
     type: 'function',
     function: {

package/harness/packages/core/test/capabilities.test.js

@@ -0,0 +1,51 @@
+// Capacidades por modelo: heuristica por familia + lo que reporta el proveedor.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { modelCapabilities, capabilityText } from '../src/providers/capabilities.js';
+import { normalizeModel } from '../src/providers/utils.js';
+
+test('la heuristica reconoce las familias conocidas', () => {
+  const caps = (id) => modelCapabilities(id);
+  assert.equal(caps('dall-e-3').image, true);
+  assert.equal(caps('gpt-image-1').image, true);
+  assert.equal(caps('gemini-2.5-flash-image-preview').image, true);
+  assert.equal(caps('deepseek-chat').image, false);
+  assert.equal(caps('whisper-1').stt, true);
+  assert.equal(caps('whisper-1').tools, false);
+  assert.equal(caps('tts-1-hd').tts, true);
+  assert.equal(caps('gpt-4o-mini-tts').tts, true);
+  assert.equal(caps('veo-3.0-generate-001').video, true);
+  assert.equal(caps('sora-2').video, true);
+  assert.equal(caps('gpt-4o').vision, true);
+  assert.equal(caps('deepseek-reasoner').reasoning, true);
+  assert.equal(caps('deepseek-chat').tools, true);
+  assert.equal(caps('text-embedding-3-small').tools, false);
+});
+
+test('lo que reporta el proveedor manda sobre la heuristica', () => {
+  // Sin reportar, 'flux-pro' pareceria imagen; reportado sin salida de imagen, no.
+  const reported = modelCapabilities('flux-pro', {
+    architecture: { input_modalities: ['text'], output_modalities: ['text'], modality: 'text->text' },
+    supported_parameters: ['tools', 'reasoning'],
+  });
+  assert.equal(reported.image, false);
+  assert.equal(reported.vision, false);
+  assert.equal(reported.tools, true);
+  assert.equal(reported.reasoning, true);
+
+  assert.equal(modelCapabilities('otro', { output_modalities: ['text', 'image'] }).image, true);
+  assert.equal(modelCapabilities('otro', { output_modalities: ['text', 'video'] }).video, true);
+  assert.equal(modelCapabilities('otro', { output_modalities: ['text', 'audio'] }).tts, true);
+  assert.equal(modelCapabilities('otro', { input_modalities: ['text', 'audio'] }).stt, true);
+  // modality string tipo OpenRouter: text+image->text = ve imagenes
+  assert.equal(modelCapabilities('x', { architecture: { modality: 'text+image->text' } }).vision, true);
+});
+
+test('normalizeModel expone capabilities sin perder el shape de siempre', () => {
+  const model = normalizeModel({ id: 'gpt-4o', context_window: 128000 });
+  assert.equal(model.vision, true);
+  assert.equal(model.context, 128000);
+  assert.equal(model.capabilities.vision, true);
+  assert.equal(model.capabilities.image, false);
+  assert.equal(capabilityText(model.capabilities), 'visión · tools');
+});

package/harness/packages/core/test/mcp-registry.test.js

@@ -1,6 +1,12 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
-import { registryServerToConfig, registryServerToCandidate, normalizeMcpConfig } from '../src/mcp/registry.js';
+import {
+  registryServerToConfig,
+  registryServerToCandidate,
+  normalizeMcpConfig,
+  dedupeRegistryServers,
+  publisherOf,
+} from '../src/mcp/registry.js';
 import { MCP_CATALOG, mcpCatalogEntry } from '../src/mcp/catalog.js';
 
 test('registryServerToConfig maps a remote server to http', () => {
@@ -60,6 +66,62 @@ test('registryServerToCandidate arma una vista liviana sin instalar', () => {
   assert.deepEqual(candidate.args, ['-y', 'remote-filesystem-mcp-server@0.1.2']);
 });
 
+test('registryServerToCandidate expone autor, version, repo y estado oficial', () => {
+  const candidate = registryServerToCandidate({
+    name: 'io.github.firecrawl/firecrawl-mcp-server',
+    title: 'Firecrawl MCP Server',
+    description: 'Scrape',
+    version: '3.21.3',
+    repository: { url: 'https://github.com/firecrawl/firecrawl-mcp-server.git', source: 'github' },
+    packages: [{ registryType: 'npm', identifier: 'firecrawl-mcp', version: '3.21.3' }],
+    _meta: { 'io.modelcontextprotocol.registry/official': { status: 'active', isLatest: true } },
+  });
+  assert.equal(candidate.publisher, 'github.com/firecrawl');
+  assert.equal(candidate.version, '3.21.3');
+  assert.equal(candidate.repository, 'https://github.com/firecrawl/firecrawl-mcp-server.git');
+  assert.equal(candidate.official, true);
+  assert.equal(candidate.status, 'active');
+  assert.equal(candidate.isLatest, true);
+
+  // Sin meta oficial no se muestra como oficial.
+  const plain = registryServerToCandidate({ name: 'com.acme/thing', packages: [] });
+  assert.equal(plain.publisher, 'com.acme');
+  assert.equal(plain.official, false);
+  assert.equal(plain.status, null);
+});
+
+test('publisherOf deriva el autor del namespace del id', () => {
+  assert.equal(publisherOf('io.github.firecrawl/firecrawl-mcp-server'), 'github.com/firecrawl');
+  assert.equal(publisherOf('com.mcparmory/firecrawl'), 'com.mcparmory');
+  assert.equal(publisherOf(''), '');
+});
+
+test('dedupeRegistryServers una entrada por nombre, quedandose con la version vigente', () => {
+  const entry = (name, version, isLatest) => ({
+    server: { name, version },
+    _meta: { 'io.modelcontextprotocol.registry/official': { status: 'active', isLatest } },
+  });
+  const entries = [
+    entry('io.github.firecrawl/firecrawl-mcp-server', '3.20.0', false),
+    entry('com.mcparmory/firecrawl', '1.0.2', false),
+    entry('io.github.firecrawl/firecrawl-mcp-server', '3.21.3', true),
+    entry('com.mcparmory/firecrawl', '1.0.3', true),
+    { server: { name: '' }, _meta: {} },
+    { title: 'sin nombre' },
+  ];
+  const out = dedupeRegistryServers(entries);
+  assert.equal(out.length, 2);
+  // Conserva el orden de la busqueda y la version vigente de cada nombre.
+  assert.equal(out[0].name, 'io.github.firecrawl/firecrawl-mcp-server');
+  assert.equal(out[0].version, '3.21.3');
+  assert.equal(out[1].version, '1.0.3');
+
+  // Sin ninguna marcada isLatest se queda con la primera.
+  const first = dedupeRegistryServers([entry('a/b', '1', false), entry('a/b', '2', false)]);
+  assert.equal(first.length, 1);
+  assert.equal(first[0].version, '1');
+});
+
 test('el catálogo de MCP trae entradas deshabilitadas y copias', () => {
   assert.ok(MCP_CATALOG.length > 0);
   assert.ok(MCP_CATALOG.every((entry) => entry.enabled === false));

package/harness/packages/core/test/providers.test.js

@@ -1,10 +1,12 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
+import http from 'node:http';
 import { Store } from '../src/storage/sqlite.js';
 import { composeProviderSettings } from '../src/config/providers.js';
 import { toOllamaMessages } from '../src/providers/ollama.js';
-import { providerFetch, normalizeModel } from '../src/providers/utils.js';
+import { providerFetch, normalizeModel, apiRoot, joinUrl } from '../src/providers/utils.js';
 import { openaiCompatibleProvider } from '../src/providers/openaiCompatible.js';
+import { listProviderModels } from '../src/providers/index.js';
 import { applyPromptCache } from '../src/providers/cache.js';
 import { isRetryableError } from '../src/providers/resilience.js';
 
@@ -15,6 +17,56 @@ test('normalizeModel reads the context window across provider shapes', () => {
   assert.equal(normalizeModel({ id: 'd' }).context, null);
 });
 
+test('apiRoot recorta el sufijo de endpoint pegado como baseUrl', () => {
+  assert.equal(apiRoot('https://openrouter.ai/api/v1/chat/completions'), 'https://openrouter.ai/api/v1');
+  assert.equal(apiRoot('https://x/v1/images/generations/'), 'https://x/v1');
+  assert.equal(apiRoot('https://x/v1/audio/speech'), 'https://x/v1');
+  assert.equal(apiRoot('https://x/v1/audio/transcriptions'), 'https://x/v1');
+  assert.equal(apiRoot('https://x/v1'), 'https://x/v1');
+  assert.equal(apiRoot(''), '');
+  assert.equal(joinUrl('https://x/v1/chat/completions', '/images/generations'), 'https://x/v1/images/generations');
+});
+
+test('listProviderModels suma la lista manual al catalogo del API y cae a ella si falla', async () => {
+  const server = http.createServer((req, res) => {
+    if (req.url === '/models') {
+      res.end(JSON.stringify({ data: [{ id: 'api-1' }, { id: 'shared' }] }));
+      return;
+    }
+    res.statusCode = 500;
+    res.end('nope');
+  });
+  await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+  const base = `http://127.0.0.1:${server.address().port}`;
+  try {
+    // La lista manual ("modelos") completa al catalogo, sin duplicar ids.
+    const ok = await listProviderModels({
+      providerId: 'stubprov',
+      customProviders: [{ id: 'stubprov', label: 'Stub', baseUrl: base, models: ['shared', 'manual-1'] }],
+    });
+    assert.deepEqual(ok.map((m) => m.id).sort(), ['api-1', 'manual-1', 'shared']);
+
+    // Si el API no lista (500), la lista manual es el catalogo entero.
+    const fallback = await listProviderModels({
+      providerId: 'broken',
+      customProviders: [{ id: 'broken', label: 'Broken', baseUrl: `${base}/broken`, models: ['m1', 'm2'] }],
+    });
+    assert.deepEqual(fallback.map((m) => m.id), ['m1', 'm2']);
+
+    // Sin lista manual, un API caido sigue siendo un error visible.
+    await assert.rejects(
+      () =>
+        listProviderModels({
+          providerId: 'broken2',
+          customProviders: [{ id: 'broken2', label: 'Broken2', baseUrl: `${base}/broken2`, models: [] }],
+        }),
+      /No se pudo listar modelos/
+    );
+  } finally {
+    server.close();
+  }
+});
+
 test('Store persists providers and settings', () => {
   const store = new Store(':memory:');
   try {

package/harness/packages/core/test/skills.test.js

@@ -4,7 +4,7 @@ import { mkdtemp, mkdir, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
 import { parseSkillMarkdown, loadSkills, mergeSkills, buildSkillsPrompt, buildSkillsIndex } from '../src/skills/index.js';
-import { parseSkillRef } from '../src/skills/remote.js';
+import { parseSkillRef, resolveSkillDir, fetchSkillFromGithub } from '../src/skills/remote.js';
 import { SKILLS_CATALOG, skillCatalogEntry } from '../src/skills/catalog.js';
 
 test('parseSkillMarkdown reads frontmatter and body', () => {
@@ -62,6 +62,71 @@ test('parseSkillRef accepts skills.sh URLs, GitHub URLs and ids', () => {
   assert.equal(parseSkillRef('solo-un-slug'), null);
 });
 
+test('resolveSkillDir encuentra la skill en las estructuras reales de los repos', () => {
+  const tree = (paths) => paths.map((p) => ({ type: 'blob', path: p }));
+  // Skill en la raiz.
+  assert.equal(resolveSkillDir(tree(['SKILL.md', 'README.md']), { repo: 'ponytail' }), '');
+  // Skill en una subcarpeta (cloudflare/security-audit-skill): es la unica.
+  assert.equal(
+    resolveSkillDir(tree(['skills/security-audit/SKILL.md', 'skills/security-audit/EXTRA.md']), {
+      repo: 'security-audit-skill',
+    }),
+    'skills/security-audit'
+  );
+  // Slug pedido coincide con la carpeta, aunque este anidada.
+  assert.equal(
+    resolveSkillDir(tree(['skills/frontend-design/SKILL.md', 'skills/api-design/SKILL.md']), {
+      slug: 'frontend-design',
+      repo: 'skills',
+    }),
+    'skills/frontend-design'
+  );
+  // Varias skills y una carpeta se llama como el repo.
+  assert.equal(
+    resolveSkillDir(tree(['skills/ponytail/SKILL.md', 'skills/otra/SKILL.md']), { repo: 'ponytail' }),
+    'skills/ponytail'
+  );
+  // Varias skills y ninguna coincide -> null (el caller lista las opciones).
+  assert.equal(resolveSkillDir(tree(['a/SKILL.md', 'b/SKILL.md']), { repo: 'claude-skills' }), null);
+});
+
+test('fetchSkillFromGithub instala una skill que no esta en la raiz del repo', async () => {
+  const realFetch = globalThis.fetch;
+  const trees = {
+    'cloudflare/security-audit-skill': [
+      { type: 'blob', path: 'README.md' },
+      { type: 'blob', path: 'skills/security-audit/SKILL.md' },
+      { type: 'blob', path: 'skills/security-audit/EXTRA.md' },
+    ],
+    'alirezarezvani/claude-skills': [
+      { type: 'blob', path: 'skills/uno/SKILL.md' },
+      { type: 'blob', path: 'skills/dos/SKILL.md' },
+    ],
+  };
+  globalThis.fetch = async (url) => {
+    const u = String(url);
+    const tree = /\/repos\/([^/]+\/[^/]+)\/git\/trees\//.exec(u);
+    if (tree) return Response.json({ tree: trees[tree[1]] ?? [] });
+    const meta = /\/repos\/([^/]+\/[^/]+)$/.exec(u);
+    if (meta) return Response.json({ default_branch: 'main' });
+    if (u.includes('raw.githubusercontent.com')) return new Response(u.endsWith('SKILL.md') ? '# skill' : 'extra');
+    throw new Error(`url inesperada: ${u}`);
+  };
+  try {
+    const skill = await fetchSkillFromGithub({ owner: 'cloudflare', repo: 'security-audit-skill', slug: null });
+    assert.equal(skill.id, 'security-audit-skill');
+    assert.deepEqual(skill.files.map((f) => f.path).sort(), ['EXTRA.md', 'SKILL.md']);
+
+    // Repo con varias skills y sin slug: el error lista las opciones.
+    await assert.rejects(
+      () => fetchSkillFromGithub({ owner: 'alirezarezvani', repo: 'claude-skills', slug: null }),
+      /El repo tiene 2: uno, dos.*claude-skills\/<slug>/
+    );
+  } finally {
+    globalThis.fetch = realFetch;
+  }
+});
+
 test('buildSkillsPrompt lists enabled skills and is empty without skills', () => {
   assert.equal(buildSkillsPrompt([]), '');
   const text = buildSkillsPrompt([{ id: 'demo', name: 'Demo', description: 'desc', body: 'Hacé X.' }]);

package/harness/packages/core/test/tools.test.js

@@ -15,6 +15,9 @@ import {
   askUserTool,
   offerChoicesTool,
   showPlanTool,
+  showChartTool,
+  normalizeChartSpec,
+  generateImageTool,
 } from '../src/tools/executors.js';
 
 async function makeWorkspace() {
@@ -422,3 +425,63 @@ test('show_plan valida steps y marca el estado', () => {
   assert.match(out, /\[ \] Tres/);
   assert.equal(evaluatePermission('show_plan', {}, {}), 'allow');
 });
+
+test('show_chart valida labels y series numericas', () => {
+  assert.match(showChartTool(null, {}), /Error/);
+  assert.match(showChartTool(null, { labels: ['a'], series: [] }), /Error/);
+
+  const spec = normalizeChartSpec({
+    type: 'line',
+    title: 'Ventas',
+    labels: ['Ene', 'Feb', 'Mar'],
+    series: [{ name: '2025', values: [10, 22, null] }],
+  });
+  assert.equal(spec.type, 'line');
+  assert.deepEqual(spec.series[0].values, [10, 22, 0]);
+  assert.equal(spec.labels.length, 3);
+
+  const out = showChartTool(null, {
+    type: 'pie',
+    labels: ['a', 'b'],
+    series: [{ name: 'S', values: [1, 2] }],
+    unit: 'USD',
+  });
+  assert.match(out, /Torta/);
+  assert.match(out, /1, 2/);
+  assert.match(out, /USD/);
+  assert.equal(evaluatePermission('show_chart', {}, {}), 'allow');
+});
+
+test('generate_image delega en onImage y devuelve meta.image', async () => {
+  assert.match(await generateImageTool(null, { prompt: 'un gato' }), /No hay generador/);
+  assert.match(await generateImageTool(null, {}, { onImage: async () => ({}) }), /Error: falta "prompt"/);
+
+  let pedido = null;
+  const out = await generateImageTool(
+    null,
+    { prompt: '  un gato astronauta  ', size: '500x500' },
+    {
+      onImage: async (req) => {
+        pedido = req;
+        return { name: 'gen-1-abc.png', width: 1024, height: 1024, bytes: 2048 };
+      },
+    }
+  );
+  assert.equal(pedido.prompt, 'un gato astronauta');
+  assert.equal(pedido.size, '500x500');
+  assert.equal(out.meta.image.name, 'gen-1-abc.png');
+  assert.match(out.content, /capturas\/gen-1-abc\.png/);
+
+  // Size con formato raro se descarta (usa la default del generador).
+  const sinSize = await generateImageTool(
+    null,
+    { prompt: 'x', size: 'grande' },
+    { onImage: async (req) => ({ name: 'g.png', width: req.size }) }
+  );
+  assert.equal(sinSize.meta.image.width, undefined);
+
+  const failed = await generateImageTool(null, { prompt: 'x' }, { onImage: async () => { throw new Error('402 pago'); } });
+  assert.match(failed, /^Error generando la imagen: 402 pago/);
+
+  assert.equal(evaluatePermission('generate_image', {}, {}), 'ask');
+});

package/harness/packages/server/public/app.js

@@ -170,6 +170,7 @@ import {
   submitMemory,
   submitProfile,
   submitProvider,
+  syncProviderDefaults,
   submitSchedule,
   submitSkill,
   syncMcpFormFields,
@@ -549,6 +550,7 @@ $('#pf-cancel').addEventListener('click', closeProviderForm);
 $('#pf-close').addEventListener('click', closeProviderForm);
 $('#pf-test').addEventListener('click', testProvider);
 providerForm.addEventListener('submit', submitProvider);
+$('#pf-id')?.addEventListener('input', syncProviderDefaults);
 providerModal.addEventListener('click', (event) => {
   if (event.target === providerModal) closeProviderForm();
 });

package/harness/packages/server/public/cards.js

@@ -4,7 +4,8 @@
 import { api, button, el, icon, state } from './core.js';
 import { toast } from './commands.js';
 import { addMessage, chatInput, paneOf, scrollMessages, sendMessage } from './chat.js';
-import { isFailedToolText, isReadOnlyTool, screenshotName, toolSummary } from './chatFormat.js';
+import { renderChart } from './chart.js';
+import { imageName, isFailedToolText, isReadOnlyTool, toolSummary } from './chatFormat.js';
 import { renderMarkdown } from './markdown.js';
 import { summarizeArgs } from './reconcile.js';
 import { yesInput } from './chrome.js';
@@ -34,13 +35,13 @@ export function renderToolOut(node, text) {
 
 export const toolCardIndex = new Map();
 
-/** Muestra la captura del tool `screenshot` en su tarjeta (clic para ampliar). */
-export function showScreenshot(entry, name) {
+/** Muestra la imagen del tool (`screenshot` o `generate_image`) en su tarjeta (clic para ampliar). */
+export function showScreenshot(entry, name, toolName) {
   if (!entry || !name || entry.shot) return;
   entry.shot = true;
   const img = el('img', 'tool-shot');
   img.loading = 'lazy';
-  img.alt = 'captura de pantalla';
+  img.alt = toolName === 'generate_image' ? 'imagen generada' : 'captura de pantalla';
   img.src = `/api/screenshots/${encodeURIComponent(name)}`;
   img.addEventListener('click', () => window.open(img.src, '_blank'));
   entry.card.appendChild(img);
@@ -60,7 +61,7 @@ export function finishToolCard(entry, data) {
     entry.truncated = true;
     entry.more.hidden = false;
   }
-  if (!failed) showScreenshot(entry, screenshotName(data, preview));
+  if (!failed) showScreenshot(entry, imageName(data, preview), entry.name);
 }
 
 export function ensureToolsToggle(message) {
@@ -134,7 +135,7 @@ export function addToolCard(message, name, args, { callId = null, open = null, r
   ensureToolsToggle(message);
   scrollMessages(paneOf(message));
 
-  const entry = { card, out, glyph, argsEl, more, callId, full: false, truncated: false };
+  const entry = { card, out, glyph, argsEl, more, callId, name, full: false, truncated: false };
   card.addEventListener('toggle', () => {
     if (card.open && entry.truncated && !entry.full) loadFullToolResult(entry, message);
   });
@@ -409,6 +410,21 @@ export function addPlanCard(container, { title, steps } = {}) {
   return card;
 }
 
+/* --- graficos de datos (show_chart) --------------------------------------- */
+
+/** Grafico SVG: el modelo lo reemite para actualizar los datos. */
+export function addChartCard(container, args = {}) {
+  const svg = renderChart(args);
+  if (!svg || !container) return null;
+  const card = el('div', 'chart-card');
+  const figure = el('figure', 'chart-figure');
+  figure.innerHTML = svg;
+  card.appendChild(figure);
+  (container.tools ?? container).appendChild(card);
+  scrollMessages(paneOf(container));
+  return card;
+}
+
 /**
  * Marca del punto de compactación: una línea que corta el historial y, debajo,
  * el resumen que pasa a ser el contexto del modelo. Lo de arriba sigue visible