@evomap/evolver 1.90.0 → 2.0.0-beta.0

package/src/proxy/router/features.js

@@ -1,84 +0,0 @@
-'use strict';
-
-// Stateless feature extraction for the Anthropic /v1/messages request body.
-// Mirrors the field shapes consumed by model_router.js so pickForTurn can
-// classify without per-session state. Phase C's "empty history" mode means
-// last_assistant_output_tokens / last_assistant_stop_reason are always 0 /
-// null; the JS classifier never reads stop_reason anyway (verified in the
-// fixture round-trip; documented in model_router.js).
-
-const PLAN_RE = /\b(plan|design|architect|brainstorm|outline|think through|let'?s think)\b/i;
-const SIMPLE_LOOKUP_MAX_CHARS = 80;
-
-function lastMessageOfRole(messages, role) {
-  if (!Array.isArray(messages)) return null;
-  for (let i = messages.length - 1; i >= 0; i--) {
-    const m = messages[i];
-    if (m && m.role === role) return m;
-  }
-  return null;
-}
-
-function blocksOf(msg) {
-  if (!msg) return [];
-  const c = msg.content;
-  if (typeof c === 'string') return [{ type: 'text', text: c }];
-  return Array.isArray(c) ? c : [];
-}
-
-function tailUserText(messages) {
-  if (!Array.isArray(messages) || messages.length === 0) return '';
-  const tail = messages[messages.length - 1];
-  if (!tail || tail.role !== 'user') return '';
-  return blocksOf(tail)
-    .filter((b) => b && b.type === 'text' && typeof b.text === 'string')
-    .map((b) => b.text)
-    .join('\n');
-}
-
-function extractFeatures(body) {
-  const messages = Array.isArray(body && body.messages) ? body.messages : [];
-
-  const lastAssistant = lastMessageOfRole(messages, 'assistant');
-  const lastAssistantBlocks = blocksOf(lastAssistant);
-  const toolCallCount = lastAssistantBlocks.filter((b) => b && b.type === 'tool_use').length;
-
-  const tail = messages[messages.length - 1];
-  const tailIsUser = !!(tail && tail.role === 'user');
-  const tailBlocks = blocksOf(tail);
-  const lastUserIsToolResultOnly = tailIsUser
-    && tailBlocks.length > 0
-    && tailBlocks.every((b) => b && b.type === 'tool_result');
-
-  const userText = tailUserText(messages);
-  const userRequestedPlanning = userText.length > 0 && PLAN_RE.test(userText);
-  const userSimpleLookup = userText.length > 0
-    && !lastUserIsToolResultOnly
-    && !userRequestedPlanning
-    && userText.trim().length <= SIMPLE_LOOKUP_MAX_CHARS;
-
-  // last_assistant_stop_reason is gated by the classifier's
-  // post_tool_result_synthesis branch (model_router.js parity invariant).
-  // We don't have the real Anthropic response on the request side, but the
-  // shape of the last assistant message lets us reconstruct it deterministically:
-  // an assistant message with any tool_use block must have ended with
-  // stop_reason: 'tool_use' (otherwise the API would not have returned that
-  // block); a text-only assistant message ended with 'end_turn' ('Stop' in the
-  // Rust enum). Only 'ToolUse' is read by the classifier.
-  let stopReason = null;
-  if (lastAssistant) {
-    stopReason = toolCallCount > 0 ? 'ToolUse' : 'Stop';
-  }
-
-  return {
-    last_assistant_tool_call_count: toolCallCount,
-    last_assistant_had_tool_call: toolCallCount > 0,
-    last_user_is_tool_result_only: lastUserIsToolResultOnly,
-    user_requested_planning: userRequestedPlanning,
-    user_simple_lookup: userSimpleLookup,
-    last_assistant_output_tokens: 0,
-    last_assistant_stop_reason: stopReason,
-  };
-}
-
-module.exports = { extractFeatures, PLAN_RE, SIMPLE_LOOKUP_MAX_CHARS };

package/src/proxy/router/gemini_route.js

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