@evomap/evolver-proxy 2.0.0-beta.0

package/dist/private/privateRuntimeSmokeOptions.js

@@ -0,0 +1,132 @@
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { expandHomePath, parseEnvFile } from '../bin/envFile.js';
+import { resolvePrivateEnterpriseToken } from './adapterLoader.js';
+const CONFIG_FILES = ['.mcp.json', join('.claude', 'settings.json'), join('.codex', 'config.toml')];
+const POINTER_RE = /EVOLVER_ENV_FILE"?\s*[:=]\s*"([^"]+)"/;
+export function resolvePrivateRuntimeSmokeOptions(sourceEnv = process.env, readEnvFileOrDeps) {
+    const deps = normalizeDeps(readEnvFileOrDeps);
+    const env = { ...sourceEnv };
+    const envFilePath = resolveEnvFilePath(env, deps);
+    if (envFilePath) {
+        env['EVOLVER_ENV_FILE'] = envFilePath;
+        try {
+            const parsed = parseEnvFile(readEnvFile(envFilePath, deps));
+            for (const [key, value] of Object.entries(parsed)) {
+                if (key !== 'EVOLVER_ENV_FILE')
+                    env[key] = value;
+            }
+            const insecureMode = insecureSecretFileMode(Object.keys(parsed), readStatMode(envFilePath, deps));
+            if (env['EVOLVER_PRIVATE_SMOKE'] === '1' && insecureMode) {
+                throw new Error(`EVOLVER_ENV_FILE mode ${insecureMode.modeText} exposes secret-like keys [${insecureMode.keys.join(', ')}]; run chmod 600 on the credential store`);
+            }
+        }
+        catch (error) {
+            if (env['EVOLVER_PRIVATE_SMOKE'] === '1') {
+                throw new Error(`failed to load EVOLVER_ENV_FILE for private runtime smoke: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
+    const run = env['EVOLVER_PRIVATE_SMOKE'] === '1';
+    const runSearch = env['EVOLVER_PRIVATE_SMOKE_SEARCH'] === '1';
+    const runReuseResult = env['EVOLVER_PRIVATE_SMOKE_REUSE_RESULT'] === '1';
+    const runPublish = env['EVOLVER_PRIVATE_SMOKE_PUBLISH'] === '1';
+    const hubUrl = env['EVOMAP_HUB_URL']?.trim();
+    const assetId = env['EVOLVER_PRIVATE_SMOKE_ASSET_ID']?.trim();
+    if (run && env['EVOMAP_HUB_MODE']?.trim().toLowerCase() !== 'private') {
+        throw new Error('EVOLVER_PRIVATE_SMOKE requires EVOMAP_HUB_MODE=private');
+    }
+    if (run && !hubUrl) {
+        throw new Error('EVOLVER_PRIVATE_SMOKE requires EVOMAP_HUB_URL pointing at a controlled PHub test-env');
+    }
+    if (run && !resolvePrivateEnterpriseToken(env)) {
+        throw new Error('EVOLVER_PRIVATE_SMOKE requires an enterprise token alias in EVOLVER_ENV_FILE or process env');
+    }
+    if (run && isProductionLikeHubUrl(hubUrl)) {
+        throw new Error('EVOLVER_PRIVATE_SMOKE refuses production-like PHub URL; use a test/staging/dev/local PHub URL');
+    }
+    if (run && runReuseResult && !runSearch && !assetId) {
+        throw new Error('EVOLVER_PRIVATE_SMOKE_REUSE_RESULT=1 requires EVOLVER_PRIVATE_SMOKE_ASSET_ID or EVOLVER_PRIVATE_SMOKE_SEARCH=1');
+    }
+    return {
+        env,
+        run,
+        runSearch,
+        runReuseResult,
+        runPublish,
+    };
+}
+function normalizeDeps(readEnvFileOrDeps) {
+    if (typeof readEnvFileOrDeps === 'function')
+        return { readEnvFile: readEnvFileOrDeps };
+    return readEnvFileOrDeps ?? {};
+}
+function resolveEnvFilePath(env, deps) {
+    const fromEnv = env['EVOLVER_ENV_FILE']?.trim();
+    if (fromEnv)
+        return fromEnv;
+    const root = deps.configRoot ?? process.cwd();
+    const exists = deps.exists ?? existsSync;
+    const readConfig = deps.readConfigFile ?? ((path) => readFileSync(path, 'utf8'));
+    for (const rel of CONFIG_FILES) {
+        const path = join(root, rel);
+        if (!exists(path))
+            continue;
+        try {
+            const match = POINTER_RE.exec(readConfig(path));
+            if (match?.[1])
+                return match[1];
+        }
+        catch {
+            // Ignore unreadable runtime config candidates; the env file itself remains the authoritative smoke input.
+        }
+    }
+    return undefined;
+}
+function readEnvFile(path, deps) {
+    if (deps.readEnvFile)
+        return deps.readEnvFile(path);
+    return readFileSync(expandHomePath(path), 'utf8');
+}
+function readStatMode(path, deps) {
+    if (deps.statMode)
+        return deps.statMode(path);
+    if (deps.readEnvFile)
+        return undefined;
+    try {
+        return statSync(expandHomePath(path)).mode;
+    }
+    catch {
+        return undefined;
+    }
+}
+function insecureSecretFileMode(keys, mode) {
+    if (mode === undefined)
+        return undefined;
+    if ((mode & 0o077) === 0)
+        return undefined;
+    const secretKeys = keys.filter(isSecretKeyName);
+    return secretKeys.length > 0 ? { modeText: (mode & 0o777).toString(8).padStart(3, '0'), keys: secretKeys } : undefined;
+}
+function isSecretKeyName(key) {
+    return /(^|_)(SECRET|TOKEN|PASSWORD|PRIVATE_KEY|API_KEY|NODE_SECRET|IPC_TOKEN)(_|$)/.test(key);
+}
+function isProductionLikeHubUrl(raw) {
+    if (!raw)
+        return false;
+    try {
+        const host = new URL(raw).hostname.toLowerCase();
+        if (isLocalHubHost(host))
+            return false;
+        return !/(^|[-.])(test|staging|stage|dev|local)([-.]|$)/.test(host);
+    }
+    catch {
+        return true;
+    }
+}
+function isLocalHubHost(host) {
+    return host === 'localhost'
+        || host === '::1'
+        || host === '[::1]'
+        || /^127(?:\.\d{1,3}){3}$/.test(host);
+}

package/dist/router/cachePassthrough.d.ts

@@ -0,0 +1,3 @@
+export declare function rewriteModel<T extends {
+    model?: unknown;
+}>(body: T, newModel: string): T;

package/dist/router/cachePassthrough.js

@@ -0,0 +1,13 @@
+// Cache-preserving model rewrite (ported from v1 proxy/router/cache_passthrough.js). Swaps ONLY the top-level
+// `model` string on an Anthropic /v1/messages body, never the `messages`/`system`/`tools` arrays — so every
+// `cache_control: { type: "ephemeral" }` breakpoint the client placed stays intact and the prompt-cache prefix
+// the client established with prior turns keeps hitting. Pure: returns a shallow clone, never mutates input.
+export function rewriteModel(body, newModel) {
+    if (!body || typeof body !== 'object')
+        return body;
+    if (!newModel || typeof newModel !== 'string')
+        return body;
+    if (body.model === newModel)
+        return body;
+    return { ...body, model: newModel };
+}

package/dist/router/features.d.ts

@@ -0,0 +1,9 @@
+import type { RouterFeatures } from './modelRouter.js';
+declare const PLAN_RE: RegExp;
+declare const SIMPLE_LOOKUP_MAX_CHARS = 80;
+/** Loose by design — the handler passes an arbitrary request body; we validate `messages` is an array at use. */
+interface MessagesBody {
+    messages?: unknown;
+}
+export declare function extractFeatures(body: MessagesBody | null | undefined): RouterFeatures;
+export { PLAN_RE, SIMPLE_LOOKUP_MAX_CHARS };

package/dist/router/features.js

@@ -0,0 +1,52 @@
+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) {
+    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) {
+    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');
+}
+export function extractFeatures(body) {
+    const messages = Array.isArray(body?.messages) ? body.messages : [];
+    const lastAssistant = lastMessageOfRole(messages, 'assistant');
+    const toolCallCount = blocksOf(lastAssistant).filter((b) => b && b.type === 'tool_use').length;
+    const tail = messages[messages.length - 1];
+    const tailIsUser = !!(tail && tail.role === 'user');
+    const tailBlocks = blocksOf(tail ?? null);
+    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;
+    // We don't have the real Anthropic response on the request side, but the last assistant message's shape
+    // reconstructs stop_reason deterministically: any tool_use block ⇒ it ended with 'ToolUse'; text-only ⇒ 'Stop'.
+    const stopReason = lastAssistant ? (toolCallCount > 0 ? 'ToolUse' : 'Stop') : null;
+    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,
+    };
+}
+export { PLAN_RE, SIMPLE_LOOKUP_MAX_CHARS };

package/dist/router/index.d.ts

@@ -0,0 +1,6 @@
+export * from './modelRouter.js';
+export * from './features.js';
+export * from './cachePassthrough.js';
+export * from './messagesRoute.js';
+export * from './sseScan.js';
+export * from './providerRoutes.js';

package/dist/router/index.js

@@ -0,0 +1,6 @@
+export * from './modelRouter.js';
+export * from './features.js';
+export * from './cachePassthrough.js';
+export * from './messagesRoute.js';
+export * from './sseScan.js';
+export * from './providerRoutes.js';

package/dist/router/messagesRoute.d.ts

@@ -0,0 +1,138 @@
+import { type Tier, type RouterFeatures } from './modelRouter.js';
+import { type SseUsage } from './sseScan.js';
+export type LlmRoute = '/v1/messages' | '/v1/responses' | '/v1/chat/completions';
+export type LlmWireApi = 'anthropic_messages' | 'openai_responses' | 'openai_chat_completions' | 'gemini_generate_content' | 'ollama_api' | 'vertex_gemini';
+export interface UpstreamResult {
+    status: number;
+    headers?: Record<string, string | undefined>;
+    stream?: unknown | null;
+    text?: () => Promise<string> | string;
+    traceRequestBody?: unknown;
+    transportMetadata?: unknown;
+}
+export interface UpstreamCallOptions {
+    inboundHeaders: Record<string, string | undefined>;
+    upstreamMode: string;
+    method?: string;
+    baseUrl?: string;
+}
+export type AnthropicProxy = (path: string, body: unknown, opts: UpstreamCallOptions) => Promise<UpstreamResult>;
+export interface RouterLogger {
+    log?: (line: string) => void;
+    warn?: (line: string) => void;
+}
+export type LlmUsage = SseUsage;
+export interface LlmTraceAttempt {
+    attempt_index: number;
+    model: string | null;
+    provider: string;
+    upstream_mode: string;
+    status: number | null;
+    error?: string;
+    requestBody?: string;
+    responseBody?: string;
+    body_truncated?: boolean;
+}
+/** One record per /v1/messages turn — the trace material the proxy exists to capture. METADATA ONLY: routing
+ * decision, status, latency, token usage, stop_reason. Prompt/completion content never enters a record. */
+export interface LlmTurnTrace {
+    ts: string;
+    event: 'llm_turn';
+    id: string;
+    request_id: string | null;
+    route: string;
+    provider: string;
+    wire_api: LlmWireApi;
+    client: 'claude-code' | 'cursor' | 'codex' | 'unknown';
+    /** Raw inbound User-Agent header (clipped), kept as a structured field so buyers can fingerprint the client
+     *  beyond the coarse `client` bucket. Omitted when absent. (FIX-10) */
+    user_agent?: string;
+    /** Stable account hash derived from request metadata.user_id/user. For Claude-style
+     *  `user_...__session_<uuid>` values this strips the volatile session suffix. */
+    user_id_hash?: string;
+    /** Normalized reasoning/thinking effort for this turn, derived from the request body across providers:
+     *  Anthropic `thinking` (type/budget_tokens), OpenAI `reasoning.effort`, `output_config.effort`, or metadata.
+     *  Shape: { effort?: 'minimal'|'low'|'medium'|'high'|string, budget_tokens?: number, type?: string }. (FIX-9) */
+    thinking_effort?: ThinkingEffort;
+    session_id: string | null;
+    response_id?: string;
+    previous_response_id?: string;
+    original_model: string | null;
+    chosen_model: string | null;
+    tier: Tier | null;
+    reason: string | null;
+    fallback: string | null;
+    router_enabled: boolean;
+    upstream_mode: string;
+    status: number | null;
+    stream: boolean;
+    /** ms from request arrival to upstream response headers (null if upstream was never reached). */
+    ttfb_ms: number | null;
+    /** ms from request arrival to trace emission (stream end for streams, body parse for JSON). */
+    latency_ms: number;
+    features?: RouterFeatures;
+    usage?: LlmUsage;
+    stop_reason?: string | null;
+    error?: string;
+    requestBody?: string;
+    responseBody?: string;
+    redaction?: string;
+    body_truncated?: boolean;
+    request_headers?: unknown;
+    response_headers?: unknown;
+    transport_metadata?: unknown;
+    attempts?: LlmTraceAttempt[];
+}
+export type TraceSink = (record: LlmTurnTrace) => void;
+export interface MessagesHandlerOptions {
+    anthropicProxy: AnthropicProxy;
+    logger?: RouterLogger;
+    /** Explicit override wins (hermetic tests); else read from env EVOMAP_ROUTER_ENABLED==='1' at construction. */
+    routerEnabled?: boolean;
+    /** Injected env (testability). Default process.env. */
+    env?: NodeJS.ProcessEnv;
+    /** Trace-capture seam: called exactly once per turn. Sink errors are swallowed — capture never breaks serving. */
+    onTrace?: TraceSink;
+    /** Injected clock for latency fields (testability). Default Date.now. */
+    clock?: () => number;
+}
+export interface MessagesRequest {
+    route?: LlmRoute;
+    body: {
+        model?: unknown;
+        messages?: unknown;
+    } & Record<string, unknown>;
+    headers?: Record<string, string | undefined>;
+}
+export interface MessagesResponse {
+    status: number;
+    body?: unknown;
+    stream?: unknown;
+    headers?: Record<string, string>;
+}
+export declare function captureTraceMetadata(value: unknown, env?: NodeJS.ProcessEnv): unknown;
+export declare function resolveTierModels(env?: NodeJS.ProcessEnv): Partial<Record<Tier, string>>;
+interface ClaudeId {
+    family: string;
+    major: number;
+    minor: number;
+}
+export declare function parseClaudeId(modelId: unknown): ClaudeId | null;
+/** Block an intra-family generational DOWNGRADE (opus-4-7 → opus-4-1). Cross-family (opus→haiku) is allowed. */
+export declare function isIntraFamilyDowngrade(chosen: unknown, original: unknown): boolean;
+export declare function resolveBedrockAliases(env?: NodeJS.ProcessEnv): Record<string, string>;
+/** Canonicalize a short Claude ID to its operator-configured Bedrock alias. Unmapped/unknown → unchanged. */
+export declare function canonicalizeForBedrock(modelId: unknown, aliases: Record<string, string>): unknown;
+export declare function supportsAdaptiveThinking(modelId: unknown): boolean;
+export interface ThinkingEffort {
+    effort?: string;
+    budget_tokens?: number;
+    type?: string;
+}
+export declare function extractThinkingEffort(body: unknown): ThinkingEffort | undefined;
+/**
+ * Build the /v1/messages handler. `enabled` (env EVOMAP_ROUTER_ENABLED, or the explicit override) gates the
+ * whole router — when off, the body forwards unmodified (a pure passthrough). Returns {status, body|stream}.
+ */
+export declare function buildMessagesHandler(opts: MessagesHandlerOptions): (req: MessagesRequest) => Promise<MessagesResponse>;
+export {};