@evomap/evolver 1.89.8 → 1.89.10

package/src/proxy/router/gemini_route.js

@@ -0,0 +1,154 @@
+'use strict';
+
+// Gemini passthrough handler (format-aware routing, NO translation). A Gemini-shaped request — Google's native
+// `/v1beta/models/<model>:generateContent` | `:streamGenerateContent` path, body `{contents, generationConfig,
+// systemInstruction, tools}` — is forwarded verbatim to the Gemini upstream. The model + action live in the
+// PATH (not the body), so we reconstruct the path (+ query like ?alt=sse) and pass it through. Trace capture
+// mirrors the other providers (usage/finish/stream tee). Point the Gemini CLI/SDK's base URL at the proxy and
+// it works unmodified — no Anthropic/OpenAI conversion (lossy translation is deliberately avoided).
+
+const { createProxyTrace } = require('../trace/extractor');
+
+const GEMINI_RESPONSE_HEADER_ALLOWLIST = new Set([
+  'content-type',
+  'retry-after',
+  'x-request-id',
+]);
+
+function hasGeminiUpstreamCredential() {
+  return !!(process.env.EVOMAP_GEMINI_API_KEY || process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY);
+}
+
+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 && /^gemini upstream /.test(err.message || '')) return err;
+  const out = new Error('gemini 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: 'gemini_fallback',
+      reason: 'upstream_non_json',
+      upstream_status: status,
+      content_type: (headers && headers['content-type']) || '',
+      response_bytes: Buffer.byteLength(raw),
+    }));
+    return { error: raw };
+  }
+}
+
+function copyGeminiResponseHeaders(headers = {}) {
+  const out = {};
+  for (const [name, value] of Object.entries(headers || {})) {
+    const lower = String(name || '').toLowerCase();
+    if (!GEMINI_RESPONSE_HEADER_ALLOWLIST.has(lower) && !lower.startsWith('x-goog-')) 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;
+}
+
+// `<model>:<action>` — the model can contain dots/dashes; the action is the part after the LAST colon
+// (generateContent | streamGenerateContent | countTokens | ...). Returns {model, action} (action '' if absent).
+function parseModelAction(modelAction) {
+  const s = String(modelAction || '');
+  const idx = s.lastIndexOf(':');
+  if (idx === -1) return { model: s, action: '' };
+  return { model: s.slice(0, idx), action: s.slice(idx + 1) };
+}
+
+function buildGeminiHandler({ geminiProxy, logger, traceStore, onTraceQueued } = {}) {
+  if (typeof geminiProxy !== 'function') {
+    throw new Error('buildGeminiHandler requires geminiProxy(path, body, opts)');
+  }
+  const log = logger || console;
+
+  return async ({ body, headers, params, query }) => {
+    const inboundHeaders = headers || {};
+    if (!hasGeminiUpstreamCredential()) {
+      throw Object.assign(new Error('gemini api key required'), { statusCode: 401 });
+    }
+
+    const modelAction = (params && params.modelAction) || '';
+    const { model, action } = parseModelAction(modelAction);
+    // Reconstruct the native Gemini path + query (e.g. ?alt=sse for streaming) and forward verbatim.
+    const qs = query && Object.keys(query).length ? '?' + new URLSearchParams(query).toString() : '';
+    const reqPath = `/v1beta/models/${modelAction}${qs}`;
+
+    let trace = null;
+    try {
+      trace = createProxyTrace({
+        route: `POST /v1beta/models/${modelAction}`,
+        headers: inboundHeaders,
+        body,
+        upstreamMode: 'gemini',
+        originalModel: model,
+        chosenModel: model,
+        store: traceStore,
+        logger: traceStore ? log : null,
+        onTraceQueued,
+      });
+    } catch (_) { /* best-effort trace; never break the request */ }
+
+    let upstream;
+    try {
+      upstream = await geminiProxy(reqPath, body, { inboundHeaders, upstreamMode: 'gemini' });
+    } catch (err) {
+      const wrapped = asUpstreamError(err, upstreamStatus(err));
+      trace?.record({ status: wrapped.statusCode, error: wrapped, upstreamMode: 'gemini', model });
+      throw wrapped;
+    }
+
+    if (upstream.stream) {
+      const forwardHeaders = copyGeminiResponseHeaders(upstream.headers);
+      const ct = upstream.headers && upstream.headers['content-type'];
+      if (ct) forwardHeaders['Content-Type'] = ct;
+      trace?.recordStreamStart({ status: upstream.status, upstreamMode: 'gemini', model, headers: forwardHeaders });
+      return {
+        status: upstream.status,
+        // Tee the Gemini SSE body so the deferred trace captures usageMetadata + finishReason. 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: 'gemini', model });
+        throw wrapped;
+      }
+    }
+    const respBody = responseToBody(raw, upstream.status, upstream.headers, log);
+    trace?.record({ status: upstream.status, responseBody: respBody, upstreamMode: 'gemini', model, headers: upstream.headers });
+    return {
+      status: upstream.status,
+      body: respBody,
+      headers: copyGeminiResponseHeaders(upstream.headers),
+    };
+  };
+}
+
+module.exports = {
+  buildGeminiHandler,
+  copyGeminiResponseHeaders,
+  hasGeminiUpstreamCredential,
+  responseToBody,
+  parseModelAction,
+};

package/src/proxy/router/models_route.js

@@ -0,0 +1,52 @@
+'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

@@ -0,0 +1,103 @@
+'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

@@ -66,7 +66,11 @@ function copyOpenAIResponseHeaders(headers = {}) {
   return out;
 }
 
-function buildResponsesHandler({ openAIProxy, logger, traceStore, onTraceQueued } = {}) {
+// 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)');
   }
@@ -82,7 +86,7 @@ function buildResponsesHandler({ openAIProxy, logger, traceStore, onTraceQueued
     let trace = null;
     try {
       trace = createProxyTrace({
-        route: 'POST /v1/responses',
+        route: traceRoute,
         headers: inboundHeaders,
         body,
         upstreamMode: 'openai',
@@ -96,7 +100,7 @@ function buildResponsesHandler({ openAIProxy, logger, traceStore, onTraceQueued
 
     let upstream;
     try {
-      upstream = await openAIProxy('/responses', body, {
+      upstream = await openAIProxy(upstreamPath, body, {
         inboundHeaders,
         upstreamMode: 'openai',
       });
@@ -151,8 +155,15 @@ function buildResponsesHandler({ openAIProxy, logger, traceStore, onTraceQueued
   };
 }
 
+// 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

@@ -0,0 +1,110 @@
+'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 };

package/src/proxy/server/routes.js

@@ -10,6 +10,12 @@ function buildRoutes(store, proxyHandlers, taskMonitor, extensions) {
     sessionHandler,
     messagesHandler,
     responsesHandler,
+    geminiHandler,
+    chatCompletionsHandler,
+    modelsHandler,
+    ollamaChatHandler,
+    ollamaGenerateHandler,
+    vertexHandler,
   } = extensions || {};
   const routes = {
     // -- Mailbox --
@@ -476,6 +482,31 @@ function buildRoutes(store, proxyHandlers, taskMonitor, extensions) {
   if (responsesHandler) {
     routes['POST /v1/responses'] = responsesHandler;
   }
+  if (geminiHandler) {
+    // Native Gemini path: model + action (generateContent | streamGenerateContent) are one path segment
+    // (`<model>:<action>`), matched as :modelAction and split by the handler.
+    routes['POST /v1beta/models/:modelAction'] = geminiHandler;
+  }
+  if (chatCompletionsHandler) {
+    // OpenAI Chat Completions ingress (cursor's OpenAI mode + generic OpenAI clients) → OpenAI upstream.
+    routes['POST /v1/chat/completions'] = chatCompletionsHandler;
+  }
+  if (modelsHandler) {
+    // Model-list probe (codex/opencode/cursor/SDKs hit it on startup) → routed by anthropic-version header to
+    // the Anthropic or OpenAI upstream's /v1/models, so the probe never 404s.
+    routes['GET /v1/models'] = modelsHandler;
+  }
+  if (ollamaChatHandler) {
+    // Ollama native ingress (local/self-hosted models) → Ollama upstream, NDJSON streaming.
+    routes['POST /api/chat'] = ollamaChatHandler;
+  }
+  if (ollamaGenerateHandler) {
+    routes['POST /api/generate'] = ollamaGenerateHandler;
+  }
+  if (vertexHandler) {
+    // Vertex AI Gemini native path: project/location/model:action across fixed segments + :modelAction.
+    routes['POST /v1/projects/:project/locations/:location/publishers/google/models/:modelAction'] = vertexHandler;
+  }
 
   return routes;
 }