@danieltmn/tamnora 0.1.0

package/harness/packages/core/src/mcp/index.js

@@ -0,0 +1,167 @@
+// MCP client entry point: picks the transport (HTTP or stdio) and builds a
+// single tool registry from every enabled server.
+
+import { connectMcpHttpServer } from './http.js';
+import { connectMcpStdioServer } from './stdio.js';
+import {
+  qualifiedToolName,
+  mcpToolToDefinition,
+  formatResources,
+  formatPrompts,
+} from './common.js';
+
+export { connectMcpHttpServer } from './http.js';
+export { connectMcpStdioServer } from './stdio.js';
+export {
+  PROTOCOL_VERSION,
+  CLIENT_INFO,
+  qualifiedToolName,
+  mcpToolToDefinition,
+  mcpResultToText,
+  mcpResourceToText,
+  mcpPromptToText,
+  formatResources,
+  formatPrompts,
+} from './common.js';
+
+/** Decide the transport for a server config. */
+export function mcpTransport(server = {}) {
+  if (server.type === 'stdio' || server.command) return 'stdio';
+  if (server.type === 'http' || server.url) return 'http';
+  throw new Error(`MCP: el servidor ${server.id ?? ''} necesita "url" (http) o "command" (stdio)`);
+}
+
+/** Connect to a single MCP server using the right transport. */
+export async function connectMcpServer(server, opts = {}) {
+  return mcpTransport(server) === 'stdio'
+    ? connectMcpStdioServer(server, opts)
+    : connectMcpHttpServer(server, opts);
+}
+
+function syntheticDefinition(name, description, parameters) {
+  return {
+    type: 'function',
+    function: {
+      name,
+      description,
+      parameters: parameters ?? { type: 'object', properties: {} },
+    },
+  };
+}
+
+/**
+ * Connect to every enabled server and build a single registry:
+ *  - OpenAI-schema definitions for the servers' tools, plus a synthetic
+ *    `list_resources` / `read_resource` / `list_prompts` / `get_prompt` pair
+ *    per server that advertises the capability;
+ *  - a router for calls (reconnecting a dead stdio session once).
+ */
+export async function buildMcpRegistry(servers = [], { signal } = {}) {
+  const enabled = servers.filter((s) => s.enabled !== false);
+  const results = await Promise.all(
+    enabled.map(async (server) => {
+      try {
+        return { server, session: await connectMcpServer(server, { signal }) };
+      } catch (error) {
+        return { server, error: error?.message ?? String(error) };
+      }
+    })
+  );
+
+  const map = new Map();
+  const definitions = [];
+  const sessions = [];
+  const errors = [];
+
+  const add = (name, definition, call) => {
+    map.set(name, call);
+    definitions.push(definition);
+  };
+
+  for (const r of results) {
+    if (r.error) {
+      errors.push({ server: r.server, error: r.error });
+      continue;
+    }
+    const { server, session } = r;
+    sessions.push(session);
+    const holder = { server, session };
+
+    const reconnect = async () => {
+      const current = holder.session;
+      if (current.alive && !current.alive()) {
+        try {
+          holder.session = await connectMcpServer(holder.server, { signal });
+        } catch {
+          /* keep the dead session */
+        }
+      }
+      return holder.session;
+    };
+
+    for (const tool of session.tools ?? []) {
+      const name = qualifiedToolName(server.id, tool.name);
+      add(name, mcpToolToDefinition(tool, server, name), async (args) => (await reconnect()).callTool(tool.name, args));
+    }
+
+    if (session.capabilities?.resources || session.resources?.length) {
+      const label = server.name ?? server.id;
+      const listName = qualifiedToolName(server.id, 'list_resources');
+      add(
+        listName,
+        syntheticDefinition(listName, `Lista los recursos MCP del servidor ${label}.`),
+        async () => formatResources(await (await reconnect()).listResources())
+      );
+      const readName = qualifiedToolName(server.id, 'read_resource');
+      add(
+        readName,
+        syntheticDefinition(readName, `Lee un recurso MCP del servidor ${label} a partir de su uri.`, {
+          type: 'object',
+          properties: { uri: { type: 'string', description: 'URI del recurso' } },
+          required: ['uri'],
+        }),
+        async (args) => (await reconnect()).readResource(args.uri)
+      );
+    }
+
+    if (session.capabilities?.prompts || session.prompts?.length) {
+      const label = server.name ?? server.id;
+      const listName = qualifiedToolName(server.id, 'list_prompts');
+      add(
+        listName,
+        syntheticDefinition(listName, `Lista los prompts MCP del servidor ${label}.`),
+        async () => formatPrompts(await (await reconnect()).listPrompts())
+      );
+      const getName = qualifiedToolName(server.id, 'get_prompt');
+      add(
+        getName,
+        syntheticDefinition(getName, `Obtiene un prompt MCP del servidor ${label}.`, {
+          type: 'object',
+          properties: {
+            name: { type: 'string', description: 'Nombre del prompt' },
+            arguments: { type: 'object', description: 'Argumentos del prompt' },
+          },
+          required: ['name'],
+        }),
+        async (args) => (await reconnect()).getPrompt(args.name, args.arguments)
+      );
+    }
+  }
+
+  return {
+    definitions,
+    sessions,
+    errors,
+    resources: sessions.flatMap((s) => s.resources ?? []),
+    prompts: sessions.flatMap((s) => s.prompts ?? []),
+    handles: (name) => map.has(name),
+    call: async (name, args = {}) => {
+      const handler = map.get(name);
+      if (!handler) throw new Error(`Herramienta MCP desconocida: ${name}`);
+      return handler(args);
+    },
+    close: () => {
+      for (const session of sessions) session.close?.();
+    },
+  };
+}

package/harness/packages/core/src/mcp/stdio.js

@@ -0,0 +1,218 @@
+// MCP (Model Context Protocol) client over the stdio transport (Node only).
+//
+// Spawns the server as a child process and speaks newline-delimited JSON-RPC
+// 2.0 over its stdin/stdout.
+
+import { spawn } from 'node:child_process';
+import {
+  PROTOCOL_VERSION,
+  CLIENT_INFO,
+  mcpResultToText,
+  mcpResourceToText,
+  mcpPromptToText,
+} from './common.js';
+
+/**
+ * On Windows, bare commands like `npx`/`uvx` are `.cmd` shims that require a
+ * shell. Absolute paths (node.exe, ...) must NOT use a shell or spaces break.
+ */
+function shouldUseShell(server, command) {
+  if (typeof server.shell === 'boolean') return server.shell;
+  if (process.platform !== 'win32') return false;
+  if (/[\\/]/.test(command)) return false;
+  // Ejecutables reales: sin shell (evita el warning DEP0190 de Node).
+  if (/^(node|nodejs|deno|bun|python3?|php)$/i.test(command)) return false;
+  return true;
+}
+
+/**
+ * Launch an MCP stdio server, initialize it and list its tools.
+ *
+ * @param {{id:string, name?:string, command:string, args?:string[], env?:object, cwd?:string, shell?:boolean}} server
+ * @param {{signal?:AbortSignal, timeout?:number}} [opts]
+ */
+export async function connectMcpStdioServer(server, { signal, timeout = 30000 } = {}) {
+  const command = server.command;
+  if (!command) throw new Error(`MCP stdio: falta "command" en el servidor ${server.id ?? ''}`);
+
+  const child = spawn(command, server.args ?? [], {
+    cwd: server.cwd,
+    env: { ...process.env, ...(server.env ?? {}) },
+    stdio: ['pipe', 'pipe', 'pipe'],
+    windowsHide: true,
+    shell: shouldUseShell(server, command),
+  });
+
+  let buffer = '';
+  let closed = false;
+  let toolsStale = false;
+  let rpcId = 0;
+  const pending = new Map();
+  const stderrChunks = [];
+
+  const stderrTail = () => {
+    const text = stderrChunks.join('').trim();
+    return text ? `: ${text.split('\n').slice(-3).join(' ')}` : '';
+  };
+
+  const failAll = (error) => {
+    for (const { reject, timer } of pending.values()) {
+      clearTimeout(timer);
+      reject(error);
+    }
+    pending.clear();
+  };
+
+  child.stdout.setEncoding('utf8');
+  child.stdout.on('data', (chunk) => {
+    buffer += chunk;
+    let index;
+    while ((index = buffer.indexOf('\n')) !== -1) {
+      const line = buffer.slice(0, index).trim();
+      buffer = buffer.slice(index + 1);
+      if (!line) continue;
+      let message;
+      try {
+        message = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (message.id === undefined) {
+        if (message.method === 'notifications/tools/list_changed') toolsStale = true;
+        continue;
+      }
+      const entry = pending.get(message.id);
+      if (!entry) continue;
+      pending.delete(message.id);
+      clearTimeout(entry.timer);
+      if (message.error) entry.reject(new Error(message.error.message ?? 'MCP error'));
+      else entry.resolve(message.result);
+    }
+  });
+
+  child.stderr.setEncoding('utf8');
+  child.stderr.on('data', (chunk) => {
+    stderrChunks.push(chunk);
+    if (stderrChunks.length > 50) stderrChunks.shift();
+  });
+  child.on('exit', (code) => {
+    closed = true;
+    failAll(new Error(`MCP stdio: el proceso de ${server.id ?? command} terminó (code ${code})${stderrTail()}`));
+  });
+  child.on('error', (error) => {
+    closed = true;
+    failAll(error);
+  });
+
+  function send(message) {
+    if (closed) throw new Error('MCP stdio: proceso cerrado');
+    child.stdin.write(`${JSON.stringify(message)}\n`);
+  }
+
+  function request(method, params) {
+    const id = ++rpcId;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        pending.delete(id);
+        reject(new Error(`MCP stdio: timeout en "${method}" (${timeout}ms)`));
+      }, timeout);
+      timer.unref?.();
+      pending.set(id, { resolve, reject, timer });
+      try {
+        send({ jsonrpc: '2.0', id, method, params });
+      } catch (error) {
+        clearTimeout(timer);
+        pending.delete(id);
+        reject(error);
+      }
+    });
+  }
+
+  function notify(method, params) {
+    send({ jsonrpc: '2.0', method, params });
+  }
+
+  function close() {
+    if (closed) return;
+    closed = true;
+    signal?.removeEventListener('abort', close);
+    failAll(new Error('MCP stdio: sesión cerrada'));
+    try {
+      child.stdin.end();
+    } catch {
+      // already closed
+    }
+    if (!child.killed) child.kill();
+  }
+
+  signal?.addEventListener('abort', close, { once: true });
+
+  try {
+    const init = await request('initialize', {
+      protocolVersion: PROTOCOL_VERSION,
+      capabilities: {},
+      clientInfo: CLIENT_INFO,
+    });
+    notify('notifications/initialized', {});
+    const capabilities = init?.capabilities ?? {};
+    const tools = (await request('tools/list', {}))?.tools ?? [];
+
+    let resources = [];
+    if (capabilities.resources) {
+      try {
+        resources = (await request('resources/list', {}))?.resources ?? [];
+      } catch {
+        resources = [];
+      }
+    }
+    let prompts = [];
+    if (capabilities.prompts) {
+      try {
+        prompts = (await request('prompts/list', {}))?.prompts ?? [];
+      } catch {
+        prompts = [];
+      }
+    }
+
+    return {
+      server,
+      transport: 'stdio',
+      capabilities,
+      tools,
+      resources,
+      prompts,
+      stderr: () => stderrChunks.join(''),
+      alive: () => !closed,
+      async callTool(name, args) {
+        const result = await request('tools/call', { name, arguments: args ?? {} });
+        return mcpResultToText(result);
+      },
+      async refreshTools() {
+        if (!toolsStale) return tools;
+        toolsStale = false;
+        const fresh = (await request('tools/list', {}))?.tools;
+        if (Array.isArray(fresh)) {
+          tools.length = 0;
+          tools.push(...fresh);
+        }
+        return tools;
+      },
+      async listResources() {
+        return (await request('resources/list', {}))?.resources ?? resources;
+      },
+      async readResource(uri) {
+        return mcpResourceToText(await request('resources/read', { uri }));
+      },
+      async listPrompts() {
+        return (await request('prompts/list', {}))?.prompts ?? prompts;
+      },
+      async getPrompt(name, args) {
+        return mcpPromptToText(await request('prompts/get', { name, arguments: args ?? {} }));
+      },
+      close,
+    };
+  } catch (error) {
+    close();
+    throw error;
+  }
+}

package/harness/packages/core/src/providers/index.js

@@ -0,0 +1,119 @@
+import { openrouterProvider } from './openrouter.js';
+import { openaiCompatibleProvider } from './openaiCompatible.js';
+import { ollamaProvider } from './ollama.js';
+import { OPENAI_COMPATIBLE_PRESETS } from './presets.js';
+import { envValue } from '../env.js';
+
+export const PROVIDERS = [
+  openrouterProvider,
+  ...OPENAI_COMPATIBLE_PRESETS,
+  openaiCompatibleProvider,
+  ollamaProvider,
+];
+
+/** Lightweight metadata for the settings UI. */
+export const PROVIDER_META = PROVIDERS.map(({ id, label, defaultBaseUrl, requiresKey }) => ({
+  id,
+  label,
+  defaultBaseUrl,
+  requiresKey,
+}));
+
+/**
+ * Build an adapter from a user-defined custom provider
+ * ({ id, label, baseUrl, models: string[] }).
+ */
+export function createCustomProvider(def) {
+  return {
+    ...openaiCompatibleProvider,
+    id: def.id,
+    label: def.label || def.baseUrl,
+    defaultBaseUrl: def.baseUrl,
+    requiresKey: true,
+    custom: true,
+    manualModels: def.models ?? [],
+  };
+}
+
+export function getProvider(id, customProviders = []) {
+  const builtIn = PROVIDERS.find((p) => p.id === id);
+  if (builtIn) return builtIn;
+  const def = customProviders.find((c) => c.id === id);
+  if (def) return createCustomProvider(def);
+  return openrouterProvider;
+}
+
+/**
+ * Resolve a provider adapter plus its runtime config, falling back to
+ * environment defaults (e.g. a bundled OpenRouter key).
+ */
+export function resolveProviderRuntime({
+  providerId = 'openrouter',
+  apiKey = '',
+  baseUrl = '',
+  providerApiKey,
+  providerBaseUrl,
+  customProviders = [],
+  siteUrl,
+  siteName,
+} = {}) {
+  const provider = getProvider(providerId, customProviders);
+  const keyInput = apiKey || providerApiKey || '';
+  const baseUrlInput = baseUrl || providerBaseUrl || '';
+  const envKey =
+    provider.id === 'openrouter'
+      ? envValue(['OPENROUTER_API_KEY', 'VITE_OPENROUTER_API_KEY'], '')
+      : '';
+  const resolvedKey = keyInput || envKey;
+
+  return {
+    provider,
+    config: {
+      apiKey: resolvedKey,
+      baseUrl: baseUrlInput || provider.defaultBaseUrl,
+      siteUrl: siteUrl ?? envValue(['SITE_URL', 'VITE_SITE_URL'], 'https://tamnora.com'),
+      siteName: siteName ?? envValue(['SITE_NAME', 'VITE_SITE_NAME'], 'Tamnora Chat'),
+    },
+  };
+}
+
+function manualModel(model) {
+  if (typeof model === 'string') return { id: model, label: model, vision: false };
+  const id = model.id ?? model.name ?? '';
+  return { id, label: model.label ?? id, vision: Boolean(model.vision) };
+}
+
+export async function listProviderModels(settings = {}) {
+  const { provider, config } = resolveProviderRuntime(settings);
+  const manual = settings.providerModels?.[provider.id];
+  if (manual?.length) return manual.map(manualModel).filter((m) => m.id);
+  if (provider.manualModels?.length) {
+    return provider.manualModels.map(manualModel).filter((m) => m.id);
+  }
+  return provider.listModels(config);
+}
+
+/**
+ * Test a provider's connection by fetching its model list.
+ * If the endpoint is unavailable but a manual model list exists, it still
+ * reports success (the chat endpoint may work while /models does not).
+ */
+export async function testProviderConnection(settings = {}) {
+  const { provider, config } = resolveProviderRuntime(settings);
+  const manual = settings.providerModels?.[provider.id] ?? [];
+  try {
+    const models = await provider.listModels(config);
+    return { ok: true, count: models.length, source: 'api', models };
+  } catch (error) {
+    const message = error?.message ?? String(error);
+    if (manual.length) {
+      return { ok: true, count: manual.length, source: 'manual', note: message };
+    }
+    return { ok: false, error: message };
+  }
+}
+
+export async function streamChat(settings, params) {
+  const { provider, config } = resolveProviderRuntime(settings);
+  return provider.streamChat(config, params);
+}

package/harness/packages/core/src/providers/ollama.js

@@ -0,0 +1,76 @@
+import { readNDJSON } from './stream.js';
+import { joinUrl, providerError, sortModels } from './utils.js';
+
+const OLLAMA_BASE_URL = 'http://localhost:11434';
+
+function toOllamaModel(model) {
+  const id = model.name ?? model.model ?? '';
+  const family = model.details?.family ?? '';
+  const vision = /vision|llava|bakllava|moondream/i.test(`${id} ${family}`);
+  return { id, label: id, vision, context: null };
+}
+
+/**
+ * Ollama takes images as a sibling `images` array of base64 (no data URL
+ * prefix) rather than OpenAI-style `image_url` content parts. Normalize any
+ * OpenAI-shaped multimodal message so the same history works across providers.
+ */
+export function toOllamaMessages(messages = []) {
+  return messages.map((message) => {
+    if (!Array.isArray(message.content)) return message;
+    const texts = [];
+    const images = [];
+    for (const part of message.content) {
+      if (part?.type === 'text') texts.push(part.text ?? '');
+      else if (part?.type === 'image_url') {
+        const url = part.image_url?.url ?? '';
+        const comma = url.indexOf(',');
+        if (url.startsWith('data:') && comma !== -1) images.push(url.slice(comma + 1));
+        else if (url) images.push(url);
+      }
+    }
+    const out = { ...message, content: texts.join('\n') };
+    if (images.length) out.images = images;
+    return out;
+  });
+}
+
+/**
+ * Ollama adapter (local models). Uses the native `/api/chat` and `/api/tags`
+ * endpoints, which stream NDJSON rather than SSE. No API key required.
+ */
+export const ollamaProvider = {
+  id: 'ollama',
+  label: 'Ollama (local)',
+  defaultBaseUrl: OLLAMA_BASE_URL,
+  requiresKey: false,
+
+  async listModels({ baseUrl }) {
+    const res = await fetch(joinUrl(baseUrl, '/api/tags'));
+    if (!res.ok) throw new Error(`No se pudo conectar con Ollama (HTTP ${res.status})`);
+    const data = await res.json();
+    return sortModels((data.models ?? []).map(toOllamaModel).filter((m) => m.id));
+  },
+
+  async streamChat({ baseUrl }, { model, messages, tools, signal, onEvent }) {
+    const body = { model, messages: toOllamaMessages(messages), stream: true };
+    if (tools?.length) body.tools = tools;
+
+    const res = await fetch(joinUrl(baseUrl, '/api/chat'), {
+      method: 'POST',
+      signal,
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+    });
+
+    if (!res.ok) {
+      throw await providerError(res, {
+        providerLabel: 'Ollama',
+        model,
+        hasTools: Boolean(tools?.length),
+      });
+    }
+
+    return readNDJSON(res, { onEvent });
+  },
+};

package/harness/packages/core/src/providers/openaiCompatible.js

@@ -0,0 +1,57 @@
+import { readOpenAISSE } from './stream.js';
+import { joinUrl, authHeaders, providerError, normalizeModel, sortModels } from './utils.js';
+
+/**
+ * Generic adapter for any OpenAI-compatible chat completions API
+ * (OpenAI, Groq, DeepSeek, Together, llama.cpp, vLLM, LM Studio, ...).
+ */
+export const openaiCompatibleProvider = {
+  id: 'openai-compatible',
+  label: 'OpenAI-compatible',
+  defaultBaseUrl: 'https://api.openai.com/v1',
+  requiresKey: true,
+
+  async listModels({ baseUrl, apiKey, headers }) {
+    const res = await fetch(joinUrl(baseUrl, '/models'), {
+      headers: authHeaders({ apiKey, headers }),
+    });
+    if (!res.ok) throw new Error(`No se pudo listar modelos (HTTP ${res.status})`);
+    const data = await res.json();
+    const list = data.data ?? data.models ?? [];
+    return sortModels(list.map(normalizeModel).filter((m) => m.id));
+  },
+
+  async streamChat({ baseUrl, apiKey, headers }, { model, messages, tools, signal, onEvent }) {
+    const body = { model, messages, stream: true };
+    if (tools?.length) body.tools = tools;
+
+    return requestStream({
+      url: joinUrl(baseUrl, '/chat/completions'),
+      headers: authHeaders({ apiKey, headers }),
+      providerLabel: 'OpenAI-compatible',
+      model,
+      body,
+      signal,
+      onEvent,
+    });
+  },
+};
+
+export async function requestStream({ url, headers, providerLabel, model, body, signal, onEvent }) {
+  const res = await fetch(url, {
+    method: 'POST',
+    signal,
+    headers: { ...headers, 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+  });
+
+  if (!res.ok) {
+    throw await providerError(res, {
+      providerLabel,
+      model,
+      hasTools: Boolean(body.tools?.length),
+    });
+  }
+
+  return readOpenAISSE(res, { onEvent });
+}

package/harness/packages/core/src/providers/openrouter.js

@@ -0,0 +1,57 @@
+import { requestStream } from './openaiCompatible.js';
+import { joinUrl, normalizeModel, sortModels } from './utils.js';
+
+const OPENROUTER_BASE_URL = 'https://openrouter.ai/api/v1';
+
+function openrouterHeaders({ apiKey, siteUrl, siteName, headers = {} }) {
+  return {
+    Authorization: `Bearer ${apiKey}`,
+    'HTTP-Referer': siteUrl ?? 'https://tamnora.com',
+    'X-Title': siteName ?? 'Tamnora Chat',
+    ...headers,
+  };
+}
+
+/**
+ * OpenRouter adapter. Only exposes free models, matching the app's original
+ * behavior (`:free` suffix or zero prompt/completion pricing).
+ */
+export const openrouterProvider = {
+  id: 'openrouter',
+  label: 'OpenRouter',
+  defaultBaseUrl: OPENROUTER_BASE_URL,
+  requiresKey: true,
+
+  async listModels({ apiKey, siteUrl, siteName }) {
+    const res = await fetch(joinUrl(OPENROUTER_BASE_URL, '/models'), {
+      headers: openrouterHeaders({ apiKey, siteUrl, siteName }),
+    });
+    if (!res.ok) throw new Error(`No se pudo listar modelos (HTTP ${res.status})`);
+    const { data } = await res.json();
+    return sortModels(
+      (data ?? [])
+        .filter(
+          (m) =>
+            m.id?.endsWith(':free') ||
+            (m.pricing?.prompt === '0' && m.pricing?.completion === '0')
+        )
+        .map(normalizeModel)
+        .filter((m) => m.id)
+    );
+  },
+
+  async streamChat(ctx, { model, messages, tools, signal, onEvent }) {
+    const body = { model, messages, stream: true };
+    if (tools?.length) body.tools = tools;
+
+    return requestStream({
+      url: joinUrl(OPENROUTER_BASE_URL, '/chat/completions'),
+      headers: openrouterHeaders(ctx),
+      providerLabel: 'OpenRouter',
+      model,
+      body,
+      signal,
+      onEvent,
+    });
+  },
+};