@danieltmn/tamnora 0.1.0

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

@@ -0,0 +1,19 @@
+import { openaiCompatibleProvider } from './openaiCompatible.js';
+
+// Most commercial providers expose an OpenAI-compatible chat completions API,
+// so they only differ by label and base URL. Adding one is a one-liner.
+function preset(id, label, baseUrl) {
+  return { ...openaiCompatibleProvider, id, label, defaultBaseUrl: baseUrl, requiresKey: true };
+}
+
+export const OPENAI_COMPATIBLE_PRESETS = [
+  preset('deepseek', 'DeepSeek', 'https://api.deepseek.com/v1'),
+  preset('openai', 'OpenAI', 'https://api.openai.com/v1'),
+  preset('groq', 'Groq', 'https://api.groq.com/openai/v1'),
+  preset('mistral', 'Mistral AI', 'https://api.mistral.ai/v1'),
+  preset('xai', 'xAI (Grok)', 'https://api.x.ai/v1'),
+  preset('together', 'Together AI', 'https://api.together.xyz/v1'),
+  preset('fireworks', 'Fireworks AI', 'https://api.fireworks.ai/inference/v1'),
+  preset('cerebras', 'Cerebras', 'https://api.cerebras.ai/v1'),
+  preset('perplexity', 'Perplexity', 'https://api.perplexity.ai'),
+];

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

@@ -0,0 +1,74 @@
+/** Reintentos con backoff exponencial y jitter para llamadas a proveedores. */
+
+export function isAbortError(err) {
+  return Boolean(err && (err.name === 'AbortError' || err.code === 'ABORT_ERR'));
+}
+
+/**
+ * Heuristica de error transitorio: timeouts, 429 y 5xx, y errores de red.
+ * Los AbortError nunca se reintentan.
+ */
+export function isRetryableError(err) {
+  if (!err || isAbortError(err)) return false;
+  const status = err.status ?? err.statusCode ?? err.response?.status;
+  if (status) return status === 408 || status === 409 || status === 425 || status === 429 || status >= 500;
+  const code = String(err.code || '');
+  if (
+    ['ECONNRESET', 'ETIMEDOUT', 'ECONNREFUSED', 'EAI_AGAIN', 'ENOTFOUND', 'UND_ERR_SOCKET', 'UND_ERR_CONNECT_TIMEOUT'].includes(
+      code
+    )
+  ) {
+    return true;
+  }
+  const message = String(err.message || '').toLowerCase();
+  return /timeout|timed out|network|socket|fetch failed|econnreset|temporar|rate limit|overloaded|503|502|529/.test(message);
+}
+
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(resolve, ms);
+    timer.unref?.();
+    if (!signal) return;
+    if (signal.aborted) {
+      clearTimeout(timer);
+      reject(signal.reason ?? new DOMException('Aborted', 'AbortError'));
+      return;
+    }
+    signal.addEventListener(
+      'abort',
+      () => {
+        clearTimeout(timer);
+        reject(signal.reason ?? new DOMException('Aborted', 'AbortError'));
+      },
+      { once: true }
+    );
+  });
+}
+
+/**
+ * Ejecuta `fn` reintentando errores transitorios.
+ *
+ * @param {(attempt:number)=>Promise<any>} fn
+ * @param {object} [opts]
+ * @param {number} [opts.retries=0] - reintentos extra (total = retries + 1 intentos)
+ * @param {number} [opts.baseDelayMs=500]
+ * @param {number} [opts.maxDelayMs=8000]
+ * @param {AbortSignal} [opts.signal]
+ * @param {(err:any)=>boolean} [opts.shouldRetry] - anula la heuristica por intento
+ * @param {(attempt:number, delayMs:number, err:any)=>void} [opts.onRetry]
+ */
+export async function withRetry(fn, opts = {}) {
+  const { retries = 0, baseDelayMs = 500, maxDelayMs = 8000, signal, shouldRetry, onRetry } = opts;
+  for (let attempt = 0; ; attempt++) {
+    try {
+      return await fn(attempt);
+    } catch (err) {
+      if (signal?.aborted || isAbortError(err)) throw err;
+      const retryable = shouldRetry ? shouldRetry(err) : isRetryableError(err);
+      if (attempt >= retries || !retryable) throw err;
+      const delay = Math.min(maxDelayMs, baseDelayMs * 2 ** attempt) * (0.5 + Math.random() * 0.5);
+      onRetry?.(attempt + 1, delay, err);
+      await sleep(delay, signal);
+    }
+  }
+}

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

@@ -0,0 +1,200 @@
+// Shared streaming parsers for provider adapters.
+//
+// OpenAI-compatible providers (OpenRouter, OpenAI, Groq, Ollama's /v1,
+// llama.cpp server, vLLM, ...) speak SSE with `choices[0].delta`.
+// Ollama's native endpoint speaks NDJSON with `message` objects.
+
+/**
+ * Extract a readable message from an error payload that may arrive as a plain
+ * string or as an object (`message`, `data.message`, serialized `data`).
+ * (openbridge-style tolerance: errors come in many shapes per provider.)
+ */
+export function providerErrorMessage(payload) {
+  const err = typeof payload === 'string' ? payload : (payload?.error ?? payload);
+  if (typeof err === 'string' && err) return err;
+  if (err && typeof err === 'object') {
+    if (typeof err.message === 'string' && err.message) return err.message;
+    const data = err.data;
+    if (data && typeof data.message === 'string' && data.message) return data.message;
+    if (data && typeof data === 'object' && Object.keys(data).length) {
+      try {
+        return JSON.stringify(data);
+      } catch {
+        // fall through
+      }
+    }
+  }
+  if (typeof payload?.message === 'string' && payload.message) return payload.message;
+  if (err && typeof err === 'object' && Object.keys(err).length) {
+    try {
+      return JSON.stringify(err);
+    } catch {
+      // fall through
+    }
+  }
+  return 'error';
+}
+
+/**
+ * Parse an OpenAI-compatible SSE stream.
+ * @returns {Promise<{content:string, reasoning:string, toolCalls:object[], usage:object|null}>}
+ */
+export async function readOpenAISSE(response, { onEvent } = {}) {
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder('utf-8');
+  let partial = '';
+  let content = '';
+  let reasoning = '';
+  const toolCalls = [];
+  let serverError = null;
+  let usage = null;
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    partial += decoder.decode(value, { stream: true });
+    const lines = partial.split('\n');
+    partial = lines.pop();
+
+    for (const line of lines) {
+      const trimmed = line.replace(/^data: /, '').trim();
+      if (!trimmed || trimmed === '[DONE]') continue;
+      let parsed;
+      try {
+        parsed = JSON.parse(trimmed);
+      } catch {
+        continue;
+      }
+      if (parsed.error) {
+        serverError = providerErrorMessage(parsed);
+        continue;
+      }
+      if (parsed.usage) usage = normalizeUsage(parsed.usage);
+      const delta = parsed.choices?.[0]?.delta;
+      if (!delta) continue;
+
+      if (delta.content) {
+        content += delta.content;
+        onEvent?.({ type: 'text', delta: delta.content, full: content });
+      }
+      if (delta.reasoning) {
+        reasoning += delta.reasoning;
+        onEvent?.({ type: 'reasoning', delta: delta.reasoning, full: reasoning });
+      }
+      if (delta.tool_calls) {
+        for (const tc of delta.tool_calls) {
+          const idx = tc.index ?? 0;
+          if (!toolCalls[idx]) {
+            toolCalls[idx] = {
+              id: tc.id,
+              type: tc.type ?? 'function',
+              function: { name: '', arguments: '' },
+            };
+          }
+          if (tc.id) toolCalls[idx].id = tc.id;
+          if (tc.function?.name) toolCalls[idx].function.name += tc.function.name;
+          if (tc.function?.arguments) toolCalls[idx].function.arguments += tc.function.arguments;
+        }
+        onEvent?.({ type: 'tool_calls', toolCalls: toolCalls.filter(Boolean) });
+      }
+    }
+  }
+
+  if (serverError) throw new Error(serverError);
+  return finalize({ content, reasoning, toolCalls, usage });
+}
+
+/**
+ * Parse Ollama's native NDJSON stream (`/api/chat`).
+ * @returns {Promise<{content:string, reasoning:string, toolCalls:object[], usage:object|null}>}
+ */
+export async function readNDJSON(response, { onEvent } = {}) {
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder('utf-8');
+  let partial = '';
+  let content = '';
+  let reasoning = '';
+  const toolCalls = [];
+  let serverError = null;
+  let usage = null;
+
+  const handleLine = (line) => {
+    if (!line.trim()) return;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      return;
+    }
+    if (parsed.error) {
+      serverError = providerErrorMessage(parsed);
+      return;
+    }
+    if (parsed.prompt_eval_count != null || parsed.eval_count != null) {
+      usage = normalizeUsage({
+        prompt_tokens: parsed.prompt_eval_count,
+        completion_tokens: parsed.eval_count,
+      });
+    }
+    const message = parsed.message;
+    if (!message) return;
+
+    if (message.content) {
+      content += message.content;
+      onEvent?.({ type: 'text', delta: message.content, full: content });
+    }
+    const reasoningDelta = message.thinking ?? message.reasoning;
+    if (reasoningDelta) {
+      reasoning += reasoningDelta;
+      onEvent?.({ type: 'reasoning', delta: reasoningDelta, full: reasoning });
+    }
+    if (Array.isArray(message.tool_calls)) {
+      message.tool_calls.forEach((tc, i) => toolCalls.push(normalizeOllamaToolCall(tc, i)));
+      onEvent?.({ type: 'tool_calls', toolCalls });
+    }
+  };
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    partial += decoder.decode(value, { stream: true });
+    const lines = partial.split('\n');
+    partial = lines.pop();
+    for (const line of lines) handleLine(line);
+  }
+  if (partial.trim()) handleLine(partial);
+
+  if (serverError) throw new Error(serverError);
+  return finalize({ content, reasoning, toolCalls, usage });
+}
+
+function normalizeOllamaToolCall(tc, index) {
+  const name = tc.function?.name ?? tc.name ?? '';
+  const rawArgs = tc.function?.arguments ?? tc.arguments ?? {};
+  const args = typeof rawArgs === 'string' ? rawArgs : JSON.stringify(rawArgs);
+  return {
+    id: tc.id ?? `ollama_call_${index ?? 0}_${name}`,
+    type: 'function',
+    function: { name, arguments: args },
+  };
+}
+
+/** Normalize provider usage payloads to `{prompt_tokens, completion_tokens, total_tokens}`. */
+export function normalizeUsage(raw) {
+  if (!raw || typeof raw !== 'object') return null;
+  const prompt = Number(raw.prompt_tokens ?? raw.prompt_eval_count ?? 0) || 0;
+  const completion = Number(raw.completion_tokens ?? raw.eval_count ?? 0) || 0;
+  const total = Number(raw.total_tokens ?? 0) || prompt + completion;
+  return { prompt_tokens: prompt, completion_tokens: completion, total_tokens: total };
+}
+
+function finalize({ content, reasoning, toolCalls, usage }) {
+  const calls = toolCalls.filter(Boolean);
+  // Some reasoning models respond only through `reasoning` and close with
+  // empty content; use it as a fallback to avoid false "empty response" errors.
+  if (!content && reasoning.trim()) content = reasoning.trim();
+  if (!content && calls.length === 0) {
+    throw new Error('La respuesta del modelo llegó vacía.');
+  }
+  return { content, reasoning, toolCalls: calls, usage: usage ?? null };
+}

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

@@ -0,0 +1,66 @@
+// Shared helpers for provider adapters.
+
+export function joinUrl(baseUrl, path) {
+  return `${String(baseUrl).replace(/\/+$/, '')}${path}`;
+}
+
+export function authHeaders({ apiKey, headers = {} }) {
+  const result = { ...headers };
+  if (apiKey) result.Authorization = `Bearer ${apiKey}`;
+  return result;
+}
+
+/**
+ * Build a descriptive error from a failed provider response, detecting the
+ * common "model does not support tools" case.
+ */
+export async function providerError(response, { providerLabel, model, hasTools }) {
+  let detail = '';
+  try {
+    const body = await response.json();
+    detail = body?.error?.message ?? body?.error?.data?.message ?? body?.message ?? '';
+    if (!detail && typeof body?.error === 'string') detail = body.error;
+    if (!detail && body?.error && typeof body.error === 'object') {
+      try {
+        detail = JSON.stringify(body.error.data ?? body.error);
+      } catch {
+        detail = '';
+      }
+    }
+  } catch {
+    try {
+      detail = await response.text();
+    } catch {
+      detail = '';
+    }
+  }
+  // Cap the tail (openbridge-style): long provider dumps hide the real cause.
+  if (detail) detail = String(detail).trim().slice(-400);
+
+  if ((response.status === 400 || response.status === 422) && hasTools) {
+    return new Error(
+      `El modelo "${model}" no soporta herramientas (tools) en ${providerLabel}. ` +
+        'Desactívalas o elegí un modelo compatible con function calling.'
+    );
+  }
+
+  const suffix = detail ? `: ${detail}` : ': ' + response.statusText;
+  return new Error(`${providerLabel} error ${response.status}${suffix}`);
+}
+
+export function normalizeModel(model) {
+  const id = model.id ?? model.name ?? model.model ?? '';
+  const label = model.name ?? model.label ?? model.model ?? id;
+  const modality = model.architecture?.modality ?? model.modality ?? '';
+  const vision =
+    (typeof modality === 'string' && modality.includes('image')) ||
+    (Array.isArray(model.input_modalities) && model.input_modalities.includes('image'));
+  const context =
+    Number(model.context_length ?? model.context_length_tokens ?? model.max_context_length ?? model.context ?? 0) ||
+    null;
+  return { id, label, vision, context };
+}
+
+export function sortModels(models) {
+  return [...models].sort((a, b) => a.label.localeCompare(b.label));
+}