tokenfirewall 1.0.2 → 2.0.0

package/dist/router/routingStrategies.js

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fallbackStrategy = fallbackStrategy;
+exports.contextStrategy = contextStrategy;
+exports.costStrategy = costStrategy;
+const contextRegistry_1 = require("../introspection/contextRegistry");
+const pricingRegistry_1 = require("../core/pricingRegistry");
+/**
+ * Fallback routing strategy
+ * Uses predefined fallback map to select next model
+ */
+function fallbackStrategy(context, failureType, fallbackMap) {
+    const { originalModel, attemptedModels } = context;
+    // Get fallback list for this model
+    const fallbacks = fallbackMap[originalModel];
+    if (!fallbacks || fallbacks.length === 0) {
+        return {
+            retry: false,
+            reason: `No fallback models configured for ${originalModel}`
+        };
+    }
+    // Find first fallback that hasn't been attempted
+    const nextModel = fallbacks.find(model => !attemptedModels.includes(model));
+    if (!nextModel) {
+        return {
+            retry: false,
+            reason: "All fallback models have been attempted"
+        };
+    }
+    return {
+        retry: true,
+        nextModel,
+        reason: `Fallback from ${originalModel} due to ${failureType}`
+    };
+}
+/**
+ * Context-based routing strategy
+ * Selects model with larger context window when context overflow occurs
+ */
+function contextStrategy(context, failureType) {
+    const { originalModel, provider, attemptedModels } = context;
+    // Only applicable for context overflow
+    if (failureType !== "context_overflow") {
+        return {
+            retry: false,
+            reason: `Context strategy only applies to context_overflow, got ${failureType}`
+        };
+    }
+    // Get current model's context limit
+    const currentLimit = contextRegistry_1.contextRegistry.getContextLimit(provider, originalModel);
+    if (currentLimit === undefined) {
+        return {
+            retry: false,
+            reason: `No context limit information for ${originalModel}`
+        };
+    }
+    // Find models from same provider with larger context
+    const availableModels = contextRegistry_1.contextRegistry.getModelsForProvider(provider);
+    if (!availableModels || availableModels.length === 0) {
+        return {
+            retry: false,
+            reason: `No alternative models found for provider ${provider}`
+        };
+    }
+    // Filter models with larger context that haven't been attempted
+    const largerContextModels = availableModels
+        .filter((model) => {
+        const limit = contextRegistry_1.contextRegistry.getContextLimit(provider, model);
+        return (limit !== undefined &&
+            limit > currentLimit &&
+            !attemptedModels.includes(model) &&
+            model !== originalModel // Don't suggest the same model
+        );
+    })
+        .sort((a, b) => {
+        const limitA = contextRegistry_1.contextRegistry.getContextLimit(provider, a) || 0;
+        const limitB = contextRegistry_1.contextRegistry.getContextLimit(provider, b) || 0;
+        return limitA - limitB; // Sort ascending (smallest upgrade first)
+    });
+    if (largerContextModels.length === 0) {
+        return {
+            retry: false,
+            reason: "No models with larger context window available"
+        };
+    }
+    const nextModel = largerContextModels[0];
+    const nextLimit = contextRegistry_1.contextRegistry.getContextLimit(provider, nextModel);
+    return {
+        retry: true,
+        nextModel,
+        reason: `Upgrading from ${currentLimit} to ${nextLimit} tokens context`
+    };
+}
+/**
+ * Cost-based routing strategy
+ * Selects cheaper model from same provider
+ */
+function costStrategy(context, failureType) {
+    const { originalModel, provider, attemptedModels } = context;
+    // Get current model's pricing
+    let currentPricing;
+    try {
+        currentPricing = pricingRegistry_1.pricingRegistry.getPricing(provider, originalModel);
+    }
+    catch (error) {
+        return {
+            retry: false,
+            reason: `No pricing information for ${originalModel}`
+        };
+    }
+    // Calculate average cost for current model
+    const currentAvgCost = (currentPricing.input + currentPricing.output) / 2;
+    // Get all models for this provider
+    const providerModels = getProviderModels(provider);
+    if (providerModels.length === 0) {
+        return {
+            retry: false,
+            reason: `No alternative models found for provider ${provider}`
+        };
+    }
+    // Find cheaper models that haven't been attempted
+    const cheaperModels = providerModels
+        .filter((model) => {
+        if (attemptedModels.includes(model) || model === originalModel) {
+            return false;
+        }
+        try {
+            const pricing = pricingRegistry_1.pricingRegistry.getPricing(provider, model);
+            const avgCost = (pricing.input + pricing.output) / 2;
+            return avgCost < currentAvgCost;
+        }
+        catch {
+            return false;
+        }
+    })
+        .sort((a, b) => {
+        const pricingA = pricingRegistry_1.pricingRegistry.getPricing(provider, a);
+        const pricingB = pricingRegistry_1.pricingRegistry.getPricing(provider, b);
+        const avgCostA = (pricingA.input + pricingA.output) / 2;
+        const avgCostB = (pricingB.input + pricingB.output) / 2;
+        return avgCostA - avgCostB; // Sort ascending (cheapest first)
+    });
+    if (cheaperModels.length === 0) {
+        return {
+            retry: false,
+            reason: "No cheaper models available"
+        };
+    }
+    const nextModel = cheaperModels[0];
+    return {
+        retry: true,
+        nextModel,
+        reason: `Switching to cheaper model due to ${failureType}`
+    };
+}
+/**
+ * Helper to get known models for a provider
+ * Uses context registry for dynamic model discovery, falls back to static list
+ */
+function getProviderModels(provider) {
+    // First, try to get models from context registry (dynamic)
+    const registeredModels = contextRegistry_1.contextRegistry.getModelsForProvider(provider);
+    if (registeredModels && registeredModels.length > 0) {
+        return registeredModels;
+    }
+    // Fallback to static list if no models registered
+    // This ensures the router works even without model discovery
+    const knownModels = {
+        openai: [
+            // ===== Flagship / Chat =====
+            "gpt-5",
+            "gpt-5-mini",
+            "gpt-4.1",
+            "gpt-4.1-mini",
+            "gpt-4o",
+            "gpt-4o-mini",
+            // ===== Reasoning =====
+            "o1",
+            "o1-mini",
+            // ===== Image Generation =====
+            "gpt-image-1"
+        ],
+        anthropic: [
+            // ===== Claude 4.5 (Newer Improved) =====
+            "claude-opus-4.5",
+            "claude-sonnet-4.5",
+            "claude-haiku-4.5",
+            // ===== Classic Claude 4 =====
+            "claude-4-opus",
+            "claude-sonnet-4",
+            "claude-haiku-4",
+            // ===== Stable Claude 3.5 Fallback =====
+            "claude-3-5-sonnet-latest",
+            "claude-3-5-haiku-latest"
+        ],
+        gemini: [
+            // ===== Gemini 3 (Latest Generation) =====
+            "gemini-3-pro", // Flagship reasoning - Most capable
+            "gemini-3.1-pro", // Enhanced reasoning - Latest improved 3.x
+            "gemini-3-flash", // Fast multimodal - Optimized for latency
+            "gemini-3-flash-lite", // Cost-efficient flash variant
+            "gemini-3-pro-image", // High-quality image - Nano Banana Pro
+            "gemini-3.1-flash-image", // Latest image model - Nano Banana 2
+            // ===== Gemini 2.5 (Stable Production Tier) =====
+            "gemini-2.5-pro", // Stable reasoning - 2.5 generation flagship
+            "gemini-2.5-flash", // Fast multimodal - Default in many workflows
+            "gemini-2.5-flash-lite", // Cost-efficient - Lighter, cheaper variant
+            "gemini-2.5-flash-image", // Image generation - Nano Banana (Cloud)
+            // ===== Ultra-light / Experimental =====
+            "gemini-nano-banana" // Ultra-light multimodal
+        ],
+        grok: [
+            "grok-3",
+            "grok-2",
+            "grok-2-mini",
+            "grok-vision"
+        ],
+        kimi: [
+            "moonshot-v1-8k",
+            "moonshot-v1-32k",
+            "moonshot-v1-128k"
+        ],
+        meta: [
+            "llama-3.3-70b",
+            "llama-3.1-405b",
+            "llama-3.1-70b",
+            "llama-3.1-8b"
+        ],
+        mistral: [
+            "mistral-large-latest",
+            "mistral-medium-latest",
+            "mistral-small-latest",
+            "mixtral-8x7b",
+            "mixtral-8x22b"
+        ],
+        cohere: [
+            "command-r-plus",
+            "command-r",
+            "command-light"
+        ]
+    };
+    return knownModels[provider.toLowerCase()] || [];
+}

package/dist/router/types.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Type definitions for the Intelligent Model Router
+ */
+/**
+ * Routing strategy types
+ */
+export type RoutingStrategy = "fallback" | "context" | "cost";
+/**
+ * Failure types detected by error detector
+ */
+export type FailureType = "rate_limit" | "context_overflow" | "model_unavailable" | "access_denied" | "unknown";
+/**
+ * Configuration options for model router
+ */
+export interface ModelRouterOptions {
+    /** Routing strategy to use */
+    strategy: RoutingStrategy;
+    /** Map of primary models to fallback models */
+    fallbackMap?: Record<string, string[]>;
+    /** Maximum number of retry attempts (default: 1) */
+    maxRetries?: number;
+}
+/**
+ * Context information about a failed request
+ */
+export interface FailureContext {
+    /** The error that occurred */
+    error: unknown;
+    /** Original model that failed */
+    originalModel: string;
+    /** Request body sent to API */
+    requestBody: any;
+    /** Provider name */
+    provider: string;
+    /** Current retry attempt count */
+    retryCount: number;
+    /** Models already attempted */
+    attemptedModels: string[];
+}
+/**
+ * Decision made by routing strategy
+ */
+export interface RoutingDecision {
+    /** Whether to retry the request */
+    retry: boolean;
+    /** Next model to try (if retry is true) */
+    nextModel?: string;
+    /** Reason for the decision */
+    reason: string;
+}
+/**
+ * Router event for logging
+ */
+export interface RouterEvent {
+    /** Original model that failed */
+    originalModel: string;
+    /** Next model to try */
+    nextModel: string;
+    /** Reason for switching */
+    reason: string;
+    /** Current attempt number */
+    attempt: number;
+    /** Maximum retries allowed */
+    maxRetries: number;
+}

package/dist/router/types.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Type definitions for the Intelligent Model Router
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenfirewall",
-  "version": "1.0.2",
+  "version": "2.0.0",
   "description": "Scalable, adapter-driven LLM cost enforcement middleware for Node.js with model discovery and context intelligence",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",