@evomap/evolver 1.89.9 → 1.89.11

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/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

@@ -12,6 +12,10 @@ function buildRoutes(store, proxyHandlers, taskMonitor, extensions) {
     responsesHandler,
     geminiHandler,
     chatCompletionsHandler,
+    modelsHandler,
+    ollamaChatHandler,
+    ollamaGenerateHandler,
+    vertexHandler,
   } = extensions || {};
   const routes = {
     // -- Mailbox --
@@ -82,14 +86,17 @@ function buildRoutes(store, proxyHandlers, taskMonitor, extensions) {
     },
 
     'POST /asset/submit': async ({ body }) => {
-      if (!body.assets && !body.asset_id) {
-        throw Object.assign(new Error('assets or asset_id is required'), { statusCode: 400 });
+      // The publish path builds a bundle from full asset objects; a bare
+      // asset_id is not a valid input here (Bugbot #256 Medium — route used to
+      // accept asset_id the handler then ignored).
+      if (!body.assets && !body.asset) {
+        throw Object.assign(new Error('assets (array) or asset (single object) is required'), { statusCode: 400 });
       }
-      const result = store.send({
-        type: 'asset_submit',
-        payload: body,
-        priority: body.priority || 'normal',
-      });
+      // Publish synchronously via the signed Gene+Capsule bundle path
+      // (POST /a2a/publish). The old `asset_submit` mailbox dispatch is gated
+      // off at the Hub (A2A_MAILBOX_ASSET_SUBMIT_ENABLED), so it silently
+      // failed; the Hub now enforces bundles. Returns the per-asset Hub result.
+      const result = await proxyHandlers.assetPublish(body);
       return { body: result };
     },
 
@@ -487,6 +494,22 @@ function buildRoutes(store, proxyHandlers, taskMonitor, extensions) {
     // 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;
 }