@evomap/evolver-proxy 2.0.0-beta.0

package/dist/router/modelRouter.d.ts

@@ -0,0 +1,49 @@
+export type Tier = 'cheap' | 'mid' | 'expensive';
+export declare const REASONS: {
+    readonly ROUTER_DISABLED: "router_disabled";
+    readonly HARD_PINNED: "hard_pinned";
+    readonly GENE_HINT: "gene_hint";
+    readonly POST_TOOL_RESULT_SYNTHESIS: "post_tool_result_synthesis";
+    readonly USER_REQUESTED_PLANNING: "user_requested_planning";
+    readonly HIGH_TOOL_USE_DENSITY: "high_tool_use_density";
+    readonly TRIVIAL_LOOKUP: "trivial_lookup";
+    readonly DEFAULT_TIER: "default_tier";
+    readonly ESCALATED_FROM_HISTORY: "escalated_from_history";
+};
+export type Reason = (typeof REASONS)[keyof typeof REASONS];
+export interface RouterFeatures {
+    last_assistant_tool_call_count: number;
+    last_assistant_had_tool_call: boolean;
+    last_user_is_tool_result_only: boolean;
+    user_requested_planning: boolean;
+    user_simple_lookup: boolean;
+    last_assistant_output_tokens: number;
+    last_assistant_stop_reason: 'ToolUse' | 'Stop' | null;
+}
+export interface RouterHistoryEntry {
+    tier: Tier;
+    output_tokens: number;
+    had_tool_call: boolean;
+}
+export interface RouterState {
+    history: readonly RouterHistoryEntry[];
+    pinned: Tier | null;
+}
+export interface RouterConfig {
+    default_tier: Tier;
+    disable: boolean;
+    hard_pin_after_plan: boolean;
+}
+export interface RouterInput {
+    features: RouterFeatures;
+    router_state: RouterState;
+    config: RouterConfig;
+    gene_hint?: Tier | null;
+}
+export interface RouterDecision {
+    tier: Tier;
+    reason: Reason;
+    escalated_from: Tier | null;
+}
+/** Pick a tier for one turn. Precedence: disabled → hard-pin → gene hint → classify (+ history escalation). */
+export declare function pickForTurn(input: RouterInput): RouterDecision;

package/dist/router/modelRouter.js

@@ -0,0 +1,66 @@
+// Multi-tier model router (ported from v1 proxy/router/model_router.js, itself a port of the EvoX Rust
+// model_router.rs). Given stateless per-turn features, it picks a cost tier (cheap/mid/expensive) for an
+// Anthropic /v1/messages turn so cheap turns (summarising tool output, trivial lookups) don't burn the
+// expensive model and planning / high-tool-density turns get it.
+//
+// Field names are snake_case ON PURPOSE: they mirror the Rust router + its JSON fixture, and branch order is
+// a parity invariant (post_tool_result_synthesis must win over high_tool_use_density). Pure + deterministic.
+export const REASONS = {
+    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 = { cheap: 0, mid: 1, expensive: 2 };
+function tierStepUp(tier) {
+    if (tier === 'cheap')
+        return 'mid';
+    return 'expensive'; // mid → expensive; expensive → expensive (clamped)
+}
+/** Parity invariant with model_router.rs:340 — branch ORDER matters. */
+function classify(features, config) {
+    // post_tool_result_synthesis must win over high_tool_use_density: a turn that only summarises 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];
+}
+/** Stalled-turn escalation (model_router.rs:373): last turn produced <50 output tokens with no tool call. */
+function maybeEscalate(base, history) {
+    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 || 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];
+}
+/** Pick a tier for one turn. Precedence: disabled → hard-pin → gene hint → classify (+ history escalation). */
+export function pickForTurn(input) {
+    const { features, router_state, config } = input;
+    if (config.disable)
+        return { tier: config.default_tier, reason: REASONS.ROUTER_DISABLED, escalated_from: null };
+    if (config.hard_pin_after_plan && router_state?.pinned) {
+        return { tier: router_state.pinned, reason: REASONS.HARD_PINNED, escalated_from: null };
+    }
+    if (input.gene_hint)
+        return { tier: input.gene_hint, reason: REASONS.GENE_HINT, escalated_from: null };
+    const [baseTier, baseReason] = classify(features, config);
+    const [escalatedTier, escalatedFrom] = maybeEscalate(baseTier, router_state?.history ?? []);
+    const reason = escalatedFrom !== null ? REASONS.ESCALATED_FROM_HISTORY : baseReason;
+    return { tier: escalatedTier, reason, escalated_from: escalatedFrom };
+}

package/dist/router/providerRoutes.d.ts

@@ -0,0 +1,42 @@
+import type { AnthropicProxy, MessagesResponse, RouterLogger, TraceSink } from './messagesRoute.js';
+import { type Tier } from './modelRouter.js';
+export interface ProviderRouteRequest {
+    body: Record<string, unknown>;
+    headers?: Record<string, string | undefined>;
+    params?: Record<string, string>;
+    query?: Record<string, string>;
+}
+export type ProviderRouteHandler = (req: ProviderRouteRequest) => Promise<MessagesResponse>;
+export interface ProviderRouteOptions {
+    anthropicProxy: AnthropicProxy;
+    openAIProxy: AnthropicProxy;
+    geminiProxy: AnthropicProxy;
+    ollamaProxy: AnthropicProxy;
+    vertexProxy: AnthropicProxy;
+    logger?: RouterLogger;
+    onTrace?: TraceSink;
+    clock?: () => number;
+    env?: NodeJS.ProcessEnv;
+}
+export declare const OPENAI_RESPONSE_HEADER_ALLOWLIST: Set<string>;
+export declare const GEMINI_RESPONSE_HEADER_ALLOWLIST: Set<string>;
+type OpenAIRoute = '/v1/responses' | '/v1/chat/completions';
+export declare function copyOpenAIResponseHeaders(headers?: Record<string, string | undefined>): Record<string, string>;
+export declare function copyGeminiResponseHeaders(headers?: Record<string, string | undefined>): Record<string, string>;
+export declare function resolveOpenAITierModels(env?: NodeJS.ProcessEnv, route?: OpenAIRoute): Partial<Record<Tier, string>>;
+export declare function parseModelAction(modelAction: string): {
+    model: string;
+    action: string;
+};
+export declare function detectModelsProvider(headers?: Record<string, string | undefined>): 'anthropic' | 'openai';
+export declare function vertexBaseUrl(location: string, env?: NodeJS.ProcessEnv): string;
+export declare function buildOpenAIResponsesHandler(opts: Pick<ProviderRouteOptions, 'openAIProxy' | 'logger' | 'onTrace' | 'clock' | 'env'>): ProviderRouteHandler;
+export declare function buildOpenAIChatCompletionsHandler(opts: Pick<ProviderRouteOptions, 'openAIProxy' | 'logger' | 'onTrace' | 'clock' | 'env'>): ProviderRouteHandler;
+export declare function buildGeminiHandler(opts: Pick<ProviderRouteOptions, 'geminiProxy' | 'logger' | 'onTrace' | 'clock' | 'env'>): ProviderRouteHandler;
+export declare function buildOllamaHandler(opts: Pick<ProviderRouteOptions, 'ollamaProxy' | 'logger' | 'onTrace' | 'clock' | 'env'> & {
+    apiPath: '/api/chat' | '/api/generate';
+}): ProviderRouteHandler;
+export declare function buildVertexHandler(opts: Pick<ProviderRouteOptions, 'vertexProxy' | 'logger' | 'onTrace' | 'clock' | 'env'>): ProviderRouteHandler;
+export declare function buildModelsHandler(opts: Pick<ProviderRouteOptions, 'anthropicProxy' | 'openAIProxy' | 'logger'>): ProviderRouteHandler;
+export declare function buildProviderRoutes(opts: ProviderRouteOptions): Record<string, ProviderRouteHandler>;
+export {};