@evomap/evolver 1.89.20 → 2.0.0-beta.0

package/src/proxy/router/model_router.js

@@ -1,113 +0,0 @@
-'use strict';
-
-// Phase C of the EvoX multi-tier router. The authoritative algorithm
-// lives in Rust at
-//   evox/crates/evox-agent-core/src/model_router.rs
-// and ships a generated JSON fixture at
-//   evox/crates/evox-agent-core/tests/fixtures/model_router_cases.json
-// A vendored copy of that fixture (test/fixtures/model_router_cases.json)
-// pins this port byte-for-byte; CI diffs against a regenerated copy so
-// silent drift turns red.
-//
-// Why a fresh module under src/proxy/router/ and not a fold into an
-// existing router-ish helper: src/proxy/ has no prior router/classifier
-// concept (mailbox/, sync/, task/, extensions/, lifecycle/ all sit at a
-// different layer). A first-class subdir is the cheapest place to grow
-// the Phase C pieces (cache_passthrough, anthropic egress) without
-// muddying the proxy core.
-
-const REASONS = Object.freeze({
-  ROUTER_DISABLED: 'router_disabled',
-  HARD_PINNED: 'hard_pinned',
-  GENE_HINT: 'gene_hint',
-  POST_TOOL_RESULT_SYNTHESIS: 'post_tool_result_synthesis',
-  USER_REQUESTED_PLANNING: 'user_requested_planning',
-  HIGH_TOOL_USE_DENSITY: 'high_tool_use_density',
-  TRIVIAL_LOOKUP: 'trivial_lookup',
-  DEFAULT_TIER: 'default_tier',
-  ESCALATED_FROM_HISTORY: 'escalated_from_history',
-});
-
-const TIER_ORDER = Object.freeze({ cheap: 0, mid: 1, expensive: 2 });
-
-function tierStepUp(tier) {
-  if (tier === 'cheap') return 'mid';
-  if (tier === 'mid') return 'expensive';
-  return 'expensive';
-}
-
-function classify(features, config) {
-  // Parity invariant with model_router.rs:340 — branch order matters.
-  // post_tool_result_synthesis must win over high_tool_use_density when
-  // both signal: the synthesis turn is just summarising tool output.
-  if (
-    features.last_user_is_tool_result_only &&
-    features.last_assistant_stop_reason === 'ToolUse'
-  ) {
-    return ['cheap', REASONS.POST_TOOL_RESULT_SYNTHESIS];
-  }
-  if (features.user_requested_planning) {
-    return ['expensive', REASONS.USER_REQUESTED_PLANNING];
-  }
-  if (features.last_assistant_tool_call_count > 3) {
-    return ['expensive', REASONS.HIGH_TOOL_USE_DENSITY];
-  }
-  if (features.user_simple_lookup) {
-    return ['cheap', REASONS.TRIVIAL_LOOKUP];
-  }
-  return [config.default_tier, REASONS.DEFAULT_TIER];
-}
-
-function maybeEscalate(base, history) {
-  // Stalled-turn signal from model_router.rs:373: the last decision
-  // produced <50 output tokens with no tool call. Bump one tier up,
-  // never above expensive, and never weaker than what classify chose.
-  if (!history || history.length === 0) return [base, null];
-  const last = history[history.length - 1];
-  const stalled = last.output_tokens < 50 && !last.had_tool_call;
-  if (!stalled) return [base, null];
-  if (last.tier === 'expensive') return [base, null];
-  const target = tierStepUp(last.tier);
-  if (TIER_ORDER[target] > TIER_ORDER[base]) {
-    return [target, last.tier];
-  }
-  return [base, null];
-}
-
-function pickForTurn(input) {
-  const { features, router_state, config } = input;
-  const geneHint = input.gene_hint;
-
-  if (config.disable) {
-    return {
-      tier: config.default_tier,
-      reason: REASONS.ROUTER_DISABLED,
-      escalated_from: null,
-    };
-  }
-  if (config.hard_pin_after_plan && router_state && router_state.pinned) {
-    return {
-      tier: router_state.pinned,
-      reason: REASONS.HARD_PINNED,
-      escalated_from: null,
-    };
-  }
-  if (geneHint) {
-    return {
-      tier: geneHint,
-      reason: REASONS.GENE_HINT,
-      escalated_from: null,
-    };
-  }
-  const [baseTier, baseReason] = classify(features, config);
-  const history = router_state ? router_state.history : [];
-  const [escalatedTier, escalatedFrom] = maybeEscalate(baseTier, history);
-  const reason = escalatedFrom !== null ? REASONS.ESCALATED_FROM_HISTORY : baseReason;
-  return {
-    tier: escalatedTier,
-    reason,
-    escalated_from: escalatedFrom,
-  };
-}
-
-module.exports = { pickForTurn, REASONS };

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 };