@evomap/evolver 1.90.0 → 2.0.0-beta.1

package/src/proxy/router/models_route.js

@@ -1,52 +0,0 @@
-'use strict';
-
-// GET /v1/models — model-list probe passthrough (format-aware routing, no translation). Many clients (codex,
-// opencode, cursor in OpenAI mode, OpenAI/Anthropic SDKs) hit GET /v1/models on startup to validate the endpoint
-// and list models; without a route they get a 404 and may fail to initialize or fall back. Route by the client's
-// intended provider: Anthropic clients send the `anthropic-version` header → Anthropic /v1/models; everyone else
-// → OpenAI /v1/models (the convention's home). Forwarded verbatim to the native upstream, no body, no translation.
-// Not traced: it is a metadata probe, not an LLM call.
-
-function detectModelsProvider(headers = {}) {
-  const lower = {};
-  for (const [k, v] of Object.entries(headers || {})) lower[String(k).toLowerCase()] = v;
-  // anthropic-version (and anthropic-beta) are sent by every Anthropic SDK request and by nothing else.
-  if (lower['anthropic-version'] || lower['anthropic-beta']) return 'anthropic';
-  return 'openai';
-}
-
-function buildModelsHandler({ anthropicProxy, openAIProxy, logger } = {}) {
-  if (typeof anthropicProxy !== 'function' || typeof openAIProxy !== 'function') {
-    throw new Error('buildModelsHandler requires anthropicProxy(path,body,opts) + openAIProxy(path,body,opts)');
-  }
-  const log = logger || console;
-
-  return async ({ headers }) => {
-    const inboundHeaders = headers || {};
-    const provider = detectModelsProvider(inboundHeaders);
-    const [proxyFn, reqPath, mode] = provider === 'anthropic'
-      ? [anthropicProxy, '/v1/models', 'anthropic']
-      : [openAIProxy, '/models', 'openai'];
-
-    let up;
-    try {
-      up = await proxyFn(reqPath, null, { method: 'GET', inboundHeaders, upstreamMode: mode });
-    } catch (err) {
-      const status = Number(err && err.statusCode) || 502;
-      return { status, body: { error: (err && err.message) || 'models upstream request failed' } };
-    }
-
-    let raw = '';
-    try { raw = up.text ? await up.text() : ''; } catch { raw = ''; }
-    let body;
-    try {
-      body = raw ? JSON.parse(raw) : {};
-    } catch {
-      log.warn?.(JSON.stringify({ event: 'models_fallback', reason: 'upstream_non_json', upstream_status: up.status }));
-      body = { error: raw };
-    }
-    return { status: up.status, body };
-  };
-}
-
-module.exports = { buildModelsHandler, detectModelsProvider };

package/src/proxy/router/ollama_route.js

@@ -1,103 +0,0 @@
-'use strict';
-
-// Ollama native passthrough (local/self-hosted model server). Native paths POST /api/chat and /api/generate are
-// forwarded verbatim to the Ollama upstream (EVOMAP_OLLAMA_BASE_URL, default 127.0.0.1:11434). Format-aware, no
-// translation: an Ollama-shaped request goes to Ollama. Streaming is newline-delimited JSON (NDJSON), not SSE —
-// the trace tee scans it the same way. apiPath is fixed per registration (/api/chat vs /api/generate). Ollama is
-// typically auth-less; an optional bearer (EVOMAP_OLLAMA_API_KEY) covers a remote/protected instance.
-
-const { createProxyTrace } = require('../trace/extractor');
-
-function upstreamStatus(err, fallback = 502) {
-  const status = Number(err && err.statusCode);
-  return Number.isFinite(status) ? status : fallback;
-}
-
-function asUpstreamError(err, fallback = 502) {
-  if (err && err.statusCode && /^ollama upstream /.test(err.message || '')) return err;
-  const out = new Error('ollama upstream request failed');
-  out.statusCode = upstreamStatus(err, fallback);
-  out.cause = err;
-  return out;
-}
-
-function responseToBody(raw, status, headers, log) {
-  if (!raw) return {};
-  try {
-    return JSON.parse(raw);
-  } catch {
-    log.warn?.(JSON.stringify({
-      event: 'ollama_fallback',
-      reason: 'upstream_non_json',
-      upstream_status: status,
-      content_type: (headers && headers['content-type']) || '',
-      response_bytes: Buffer.byteLength(raw),
-    }));
-    return { error: raw };
-  }
-}
-
-function buildOllamaHandler({ ollamaProxy, logger, traceStore, onTraceQueued, apiPath = '/api/chat' } = {}) {
-  if (typeof ollamaProxy !== 'function') {
-    throw new Error('buildOllamaHandler requires ollamaProxy(path, body, opts)');
-  }
-  const log = logger || console;
-
-  return async ({ body, headers }) => {
-    const inboundHeaders = headers || {};
-    const originalModel = body && typeof body.model === 'string' ? body.model : null;
-
-    let trace = null;
-    try {
-      trace = createProxyTrace({
-        route: `POST ${apiPath}`,
-        headers: inboundHeaders,
-        body,
-        upstreamMode: 'ollama',
-        originalModel,
-        chosenModel: originalModel,
-        store: traceStore,
-        logger: traceStore ? log : null,
-        onTraceQueued,
-      });
-    } catch (_) { /* best-effort trace; never break the request */ }
-
-    let upstream;
-    try {
-      upstream = await ollamaProxy(apiPath, body, { inboundHeaders, upstreamMode: 'ollama' });
-    } catch (err) {
-      const wrapped = asUpstreamError(err, upstreamStatus(err));
-      trace?.record({ status: wrapped.statusCode, error: wrapped, upstreamMode: 'ollama', model: originalModel });
-      throw wrapped;
-    }
-
-    if (upstream.stream) {
-      const forwardHeaders = {};
-      const ct = upstream.headers && upstream.headers['content-type'];
-      if (ct) forwardHeaders['Content-Type'] = ct;
-      trace?.recordStreamStart({ status: upstream.status, upstreamMode: 'ollama', model: originalModel, headers: forwardHeaders });
-      return {
-        status: upstream.status,
-        // Tee the NDJSON body so the deferred trace captures the final chunk's eval counts + done_reason. Bytes unchanged.
-        stream: trace ? trace.observeStream(upstream.stream) : upstream.stream,
-        headers: forwardHeaders,
-      };
-    }
-
-    let raw = '';
-    if (upstream.text) {
-      try {
-        raw = await upstream.text();
-      } catch (err) {
-        const wrapped = asUpstreamError(err, upstreamStatus(err));
-        trace?.record({ status: wrapped.statusCode, error: wrapped, upstreamMode: 'ollama', model: originalModel });
-        throw wrapped;
-      }
-    }
-    const respBody = responseToBody(raw, upstream.status, upstream.headers, log);
-    trace?.record({ status: upstream.status, responseBody: respBody, upstreamMode: 'ollama', model: originalModel, headers: upstream.headers });
-    return { status: upstream.status, body: respBody };
-  };
-}
-
-module.exports = { buildOllamaHandler, responseToBody };

package/src/proxy/router/responses_route.js

@@ -1,170 +0,0 @@
-'use strict';
-
-const { createProxyTrace } = require('../trace/extractor');
-
-const OPENAI_RESPONSE_HEADER_ALLOWLIST = new Set([
-  'openai-processing-ms',
-  'openai-version',
-  'retry-after',
-  'x-request-id',
-]);
-
-function hasOpenAIUpstreamCredential() {
-  if (process.env.EVOMAP_OPENAI_API_KEY || process.env.OPENAI_API_KEY) return true;
-  return false;
-}
-
-function upstreamStatus(err, fallback = 502) {
-  const status = Number(err && err.statusCode);
-  return Number.isFinite(status) ? status : fallback;
-}
-
-function safeOpenAIConfigDiagnostic(err) {
-  const message = err && typeof err.message === 'string' ? err.message : '';
-  if (message.startsWith('[proxy] EVOMAP_OPENAI_BASE_URL ')) return message;
-  return '';
-}
-
-function asUpstreamError(err, fallback = 502) {
-  if (err && err.statusCode && /^openai upstream /.test(err.message || '')) return err;
-  const diagnostic = safeOpenAIConfigDiagnostic(err);
-  const message = diagnostic
-    ? `openai upstream request failed: ${diagnostic}`
-    : 'openai upstream request failed';
-  const out = new Error(message);
-  out.statusCode = upstreamStatus(err, fallback);
-  out.cause = err;
-  return out;
-}
-
-function responseToBody(raw, status, headers, log) {
-  if (!raw) return {};
-  try {
-    return JSON.parse(raw);
-  } catch {
-    log.warn?.(JSON.stringify({
-      event: 'openai_responses_fallback',
-      reason: 'upstream_non_json',
-      upstream_status: status,
-      content_type: headers && headers['content-type'] || '',
-      response_bytes: Buffer.byteLength(raw),
-    }));
-    return { error: raw };
-  }
-}
-
-function copyOpenAIResponseHeaders(headers = {}) {
-  const out = {};
-  for (const [name, value] of Object.entries(headers || {})) {
-    const lower = String(name || '').toLowerCase();
-    if (!OPENAI_RESPONSE_HEADER_ALLOWLIST.has(lower) && !lower.startsWith('x-ratelimit-')) continue;
-    if (value === undefined || value === null) continue;
-    const headerValue = Array.isArray(value) ? value.join(', ') : String(value);
-    if (/[\r\n]/.test(headerValue)) continue;
-    out[lower] = headerValue;
-  }
-  return out;
-}
-
-// Generic OpenAI passthrough handler. `upstreamPath` selects the OpenAI endpoint (/responses for codex's
-// Responses API, /chat/completions for the Chat Completions API used by cursor's OpenAI mode + generic OpenAI
-// clients). Both share the same upstream, auth, header allow-list, trace, and stream tee — the only difference
-// is the path + the trace route label. No translation: each OpenAI dialect goes to its native OpenAI endpoint.
-function buildResponsesHandler({ openAIProxy, logger, traceStore, onTraceQueued, upstreamPath = '/responses', traceRoute = 'POST /v1/responses' } = {}) {
-  if (typeof openAIProxy !== 'function') {
-    throw new Error('buildResponsesHandler requires openAIProxy(path, body, opts)');
-  }
-  const log = logger || console;
-
-  return async ({ body, headers }) => {
-    const inboundHeaders = headers || {};
-    if (!hasOpenAIUpstreamCredential()) {
-      throw Object.assign(new Error('openai api key required'), { statusCode: 401 });
-    }
-
-    const originalModel = body && typeof body.model === 'string' ? body.model : null;
-    let trace = null;
-    try {
-      trace = createProxyTrace({
-        route: traceRoute,
-        headers: inboundHeaders,
-        body,
-        upstreamMode: 'openai',
-        originalModel,
-        chosenModel: originalModel,
-        store: traceStore,
-        logger: traceStore ? log : null,
-        onTraceQueued,
-      });
-    } catch (_) { /* best-effort trace; never break the request */ }
-
-    let upstream;
-    try {
-      upstream = await openAIProxy(upstreamPath, body, {
-        inboundHeaders,
-        upstreamMode: 'openai',
-      });
-    } catch (err) {
-      const wrapped = asUpstreamError(err, upstreamStatus(err));
-      trace?.record({ status: wrapped.statusCode, error: wrapped, upstreamMode: 'openai', model: originalModel });
-      throw wrapped;
-    }
-
-    if (upstream.stream) {
-      const forwardHeaders = copyOpenAIResponseHeaders(upstream.headers);
-      const ct = upstream.headers && upstream.headers['content-type'];
-      if (ct) forwardHeaders['Content-Type'] = ct;
-      trace?.recordStreamStart({
-        status: upstream.status,
-        upstreamMode: 'openai',
-        model: originalModel,
-        headers: forwardHeaders,
-      });
-      return {
-        status: upstream.status,
-        // Tee the codex SSE body so the deferred trace captures usage + response.id from response.completed.
-        // Bytes forward unchanged; emits once on stream end/cancel/error.
-        stream: trace ? trace.observeStream(upstream.stream) : upstream.stream,
-        headers: forwardHeaders,
-      };
-    }
-
-    let raw = '';
-    if (upstream.text) {
-      try {
-        raw = await upstream.text();
-      } catch (err) {
-        const wrapped = asUpstreamError(err, upstreamStatus(err));
-        trace?.record({ status: wrapped.statusCode, error: wrapped, upstreamMode: 'openai', model: originalModel });
-        throw wrapped;
-      }
-    }
-    const respBody = responseToBody(raw, upstream.status, upstream.headers, log);
-    trace?.record({
-      status: upstream.status,
-      responseBody: respBody,
-      upstreamMode: 'openai',
-      model: originalModel,
-      headers: upstream.headers,
-    });
-    return {
-      status: upstream.status,
-      body: respBody,
-      headers: copyOpenAIResponseHeaders(upstream.headers),
-    };
-  };
-}
-
-// OpenAI Chat Completions ingress (cursor's OpenAI mode + generic OpenAI clients). Same OpenAI upstream as the
-// Responses handler, just the /chat/completions endpoint — point an OpenAI-Chat client's base URL at the proxy.
-function buildChatCompletionsHandler(opts = {}) {
-  return buildResponsesHandler({ ...opts, upstreamPath: '/chat/completions', traceRoute: 'POST /v1/chat/completions' });
-}
-
-module.exports = {
-  buildResponsesHandler,
-  buildChatCompletionsHandler,
-  copyOpenAIResponseHeaders,
-  hasOpenAIUpstreamCredential,
-  responseToBody,
-};

package/src/proxy/router/vertex_route.js

@@ -1,110 +0,0 @@
-'use strict';
-
-// Vertex AI Gemini passthrough (enterprise GCP). Same Gemini request/response body as the AI Studio route, but
-// the native Vertex path — POST /v1/projects/<project>/locations/<location>/publishers/google/models/<model>:
-// generateContent | :streamGenerateContent — a region-specific upstream (<location>-aiplatform.googleapis.com),
-// and OAuth Bearer auth (EVOMAP_VERTEX_ACCESS_TOKEN). Forwarded verbatim, no translation. Trace reuses the Gemini
-// shape (usageMetadata + candidates[].finishReason), so only the path + base + auth differ from the AI Studio route.
-
-const { createProxyTrace } = require('../trace/extractor');
-const { parseModelAction } = require('./gemini_route');
-
-function upstreamStatus(err, fallback = 502) {
-  const status = Number(err && err.statusCode);
-  return Number.isFinite(status) ? status : fallback;
-}
-
-function asUpstreamError(err, fallback = 502) {
-  if (err && err.statusCode && /^vertex /.test(err.message || '')) return err;
-  const out = new Error('vertex upstream request failed');
-  out.statusCode = upstreamStatus(err, fallback);
-  out.cause = err;
-  return out;
-}
-
-function responseToBody(raw, status, headers, log) {
-  if (!raw) return {};
-  try {
-    return JSON.parse(raw);
-  } catch {
-    log.warn?.(JSON.stringify({
-      event: 'vertex_fallback', reason: 'upstream_non_json', upstream_status: status,
-      content_type: (headers && headers['content-type']) || '', response_bytes: Buffer.byteLength(raw),
-    }));
-    return { error: raw };
-  }
-}
-
-// Region-specific Vertex base. EVOMAP_VERTEX_BASE_URL overrides (e.g. the global aiplatform endpoint); otherwise
-// derive <location>-aiplatform.googleapis.com. `global` uses the un-prefixed host.
-function vertexBaseUrl(location) {
-  const override = (process.env.EVOMAP_VERTEX_BASE_URL || '').trim();
-  if (override) return override.replace(/\/+$/, '');
-  const loc = String(location || '').trim();
-  if (!loc || loc === 'global') return 'https://aiplatform.googleapis.com';
-  return `https://${loc}-aiplatform.googleapis.com`;
-}
-
-function buildVertexHandler({ vertexProxy, logger, traceStore, onTraceQueued } = {}) {
-  if (typeof vertexProxy !== 'function') {
-    throw new Error('buildVertexHandler requires vertexProxy(path, body, opts)');
-  }
-  const log = logger || console;
-
-  return async ({ body, headers, params, query }) => {
-    const inboundHeaders = headers || {};
-    const project = (params && params.project) || '';
-    const location = (params && params.location) || '';
-    const modelAction = (params && params.modelAction) || '';
-    const { model } = parseModelAction(modelAction);
-    const baseUrl = vertexBaseUrl(location);
-    const qs = query && Object.keys(query).length ? '?' + new URLSearchParams(query).toString() : '';
-    const reqPath = `/v1/projects/${project}/locations/${location}/publishers/google/models/${modelAction}${qs}`;
-
-    let trace = null;
-    try {
-      trace = createProxyTrace({
-        route: `POST /v1/projects/${project}/locations/${location}/publishers/google/models/${modelAction}`,
-        headers: inboundHeaders, body, upstreamMode: 'vertex', originalModel: model, chosenModel: model,
-        store: traceStore, logger: traceStore ? log : null, onTraceQueued,
-      });
-    } catch (_) { /* best-effort trace */ }
-
-    let upstream;
-    try {
-      upstream = await vertexProxy(reqPath, body, { baseUrl, inboundHeaders, upstreamMode: 'vertex' });
-    } catch (err) {
-      const wrapped = asUpstreamError(err, upstreamStatus(err));
-      trace?.record({ status: wrapped.statusCode, error: wrapped, upstreamMode: 'vertex', model });
-      throw wrapped;
-    }
-
-    if (upstream.stream) {
-      const forwardHeaders = {};
-      const ct = upstream.headers && upstream.headers['content-type'];
-      if (ct) forwardHeaders['Content-Type'] = ct;
-      trace?.recordStreamStart({ status: upstream.status, upstreamMode: 'vertex', model, headers: forwardHeaders });
-      return {
-        status: upstream.status,
-        stream: trace ? trace.observeStream(upstream.stream) : upstream.stream,
-        headers: forwardHeaders,
-      };
-    }
-
-    let raw = '';
-    if (upstream.text) {
-      try {
-        raw = await upstream.text();
-      } catch (err) {
-        const wrapped = asUpstreamError(err, upstreamStatus(err));
-        trace?.record({ status: wrapped.statusCode, error: wrapped, upstreamMode: 'vertex', model });
-        throw wrapped;
-      }
-    }
-    const respBody = responseToBody(raw, upstream.status, upstream.headers, log);
-    trace?.record({ status: upstream.status, responseBody: respBody, upstreamMode: 'vertex', model, headers: upstream.headers });
-    return { status: upstream.status, body: respBody };
-  };
-}
-
-module.exports = { buildVertexHandler, vertexBaseUrl };