@evomap/evolver 1.89.7 → 1.89.9

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/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/server/routes.js

@@ -10,6 +10,8 @@ function buildRoutes(store, proxyHandlers, taskMonitor, extensions) {
     sessionHandler,
     messagesHandler,
     responsesHandler,
+    geminiHandler,
+    chatCompletionsHandler,
   } = extensions || {};
   const routes = {
     // -- Mailbox --
@@ -476,6 +478,15 @@ 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;
+  }
 
   return routes;
 }