tokenfirewall 1.0.2 → 2.0.1

package/dist/introspection/contextRegistry.js

@@ -15,21 +15,59 @@ class ContextRegistry {
      */
     initializeContextLimits() {
         // OpenAI context limits
+        // ===== GPT-5 (Latest Flagship) =====
+        this.register("openai", "gpt-5", { tokens: 256000 });
+        this.register("openai", "gpt-5-mini", { tokens: 256000 });
+        // ===== GPT-4.1 Series =====
+        this.register("openai", "gpt-4.1", { tokens: 200000 });
+        this.register("openai", "gpt-4.1-mini", { tokens: 200000 });
+        // ===== GPT-4o (Balanced Multimodal) =====
         this.register("openai", "gpt-4o", { tokens: 128000 });
         this.register("openai", "gpt-4o-mini", { tokens: 128000 });
+        // ===== Reasoning Models =====
+        this.register("openai", "o1", { tokens: 200000 });
+        this.register("openai", "o1-mini", { tokens: 128000 });
+        // ===== Image Generation =====
+        this.register("openai", "gpt-image-1", { tokens: 128000 });
+        // ===== Legacy Models =====
         this.register("openai", "gpt-4-turbo", { tokens: 128000 });
         this.register("openai", "gpt-4", { tokens: 8192 });
         this.register("openai", "gpt-3.5-turbo", { tokens: 16385 });
         this.register("openai", "gpt-3.5-turbo-16k", { tokens: 16385 });
         // Anthropic context limits
+        // ===== Claude 4.5 (Newer Improved) =====
+        this.register("anthropic", "claude-opus-4.5", { tokens: 200000 });
+        this.register("anthropic", "claude-sonnet-4.5", { tokens: 200000 });
+        this.register("anthropic", "claude-haiku-4.5", { tokens: 200000 });
+        // ===== Classic Claude 4 =====
+        this.register("anthropic", "claude-4-opus", { tokens: 200000 });
+        this.register("anthropic", "claude-sonnet-4", { tokens: 200000 });
+        this.register("anthropic", "claude-haiku-4", { tokens: 200000 });
+        // ===== Stable Claude 3.5 Fallback =====
+        this.register("anthropic", "claude-3-5-sonnet-latest", { tokens: 200000 });
+        this.register("anthropic", "claude-3-5-haiku-latest", { tokens: 200000 });
+        // ===== Legacy Models =====
         this.register("anthropic", "claude-3-5-sonnet-20241022", { tokens: 200000 });
         this.register("anthropic", "claude-3-5-haiku-20241022", { tokens: 200000 });
         this.register("anthropic", "claude-3-opus-20240229", { tokens: 200000 });
         this.register("anthropic", "claude-3-sonnet-20240229", { tokens: 200000 });
         this.register("anthropic", "claude-3-haiku-20240307", { tokens: 200000 });
         // Gemini context limits (updated with latest models)
-        this.register("gemini", "gemini-2.5-flash", { tokens: 1048576 });
+        // ===== Gemini 3 (Latest Generation) =====
+        this.register("gemini", "gemini-3-pro", { tokens: 2097152 });
+        this.register("gemini", "gemini-3.1-pro", { tokens: 2097152 });
+        this.register("gemini", "gemini-3-flash", { tokens: 1048576 });
+        this.register("gemini", "gemini-3-flash-lite", { tokens: 1048576 });
+        this.register("gemini", "gemini-3-pro-image", { tokens: 2097152 });
+        this.register("gemini", "gemini-3.1-flash-image", { tokens: 1048576 });
+        // ===== Gemini 2.5 (Stable Production Tier) =====
         this.register("gemini", "gemini-2.5-pro", { tokens: 2097152 });
+        this.register("gemini", "gemini-2.5-flash", { tokens: 1048576 });
+        this.register("gemini", "gemini-2.5-flash-lite", { tokens: 1048576 });
+        this.register("gemini", "gemini-2.5-flash-image", { tokens: 1048576 });
+        // ===== Ultra-light / Experimental =====
+        this.register("gemini", "gemini-nano-banana", { tokens: 524288 });
+        // ===== Legacy Models =====
         this.register("gemini", "gemini-2.0-flash", { tokens: 1048576 });
         this.register("gemini", "gemini-2.0-flash-exp", { tokens: 1048576 });
         this.register("gemini", "gemini-1.5-pro", { tokens: 2097152 });
@@ -54,17 +92,19 @@ class ContextRegistry {
      * Register context limit for a model
      */
     register(provider, model, limit) {
-        if (!this.limits.has(provider)) {
-            this.limits.set(provider, new Map());
+        const normalizedProvider = provider.toLowerCase();
+        if (!this.limits.has(normalizedProvider)) {
+            this.limits.set(normalizedProvider, new Map());
         }
-        this.limits.get(provider).set(model, limit);
+        this.limits.get(normalizedProvider).set(model, limit);
     }
     /**
      * Get context limit for a model
      * Returns undefined if not found (does not throw)
      */
     getContextLimit(provider, model) {
-        const providerLimits = this.limits.get(provider);
+        const normalizedProvider = provider.toLowerCase();
+        const providerLimits = this.limits.get(normalizedProvider);
         if (!providerLimits) {
             return undefined;
         }
@@ -75,7 +115,19 @@ class ContextRegistry {
      * Check if provider is supported
      */
     isProviderSupported(provider) {
-        return this.limits.has(provider);
+        return this.limits.has(provider.toLowerCase());
+    }
+    /**
+     * Get all models for a provider
+     * Returns array of model names
+     */
+    getModelsForProvider(provider) {
+        const normalizedProvider = provider.toLowerCase();
+        const providerLimits = this.limits.get(normalizedProvider);
+        if (!providerLimits) {
+            return [];
+        }
+        return Array.from(providerLimits.keys());
     }
 }
 exports.contextRegistry = new ContextRegistry();

package/dist/logger.d.ts

@@ -1,4 +1,5 @@
 import { NormalizedUsage, CostBreakdown } from "./core/types";
+import { RouterEvent } from "./router/types";
 /**
  * Structured logger for LLM usage and costs
  */
@@ -7,5 +8,9 @@ export declare class Logger {
      * Log usage and cost information
      */
     logUsage(usage: NormalizedUsage, cost: CostBreakdown): void;
+    /**
+     * Log router event (model switching)
+     */
+    logRouterEvent(event: RouterEvent): void;
 }
 export declare const logger: Logger;

package/dist/logger.js

@@ -26,6 +26,16 @@ class Logger {
             },
         }));
     }
+    /**
+     * Log router event (model switching)
+     */
+    logRouterEvent(event) {
+        console.log(`[TOKENFIREWALL ROUTER]\n` +
+            `Original: ${event.originalModel}\n` +
+            `Switched: ${event.nextModel}\n` +
+            `Reason: ${event.reason}\n` +
+            `Attempt: ${event.attempt}/${event.maxRetries}`);
+    }
 }
 exports.Logger = Logger;
 exports.logger = new Logger();

package/dist/router/errorDetector.d.ts

@@ -0,0 +1,45 @@
+import { FailureType } from "./types";
+/**
+ * Detects and classifies API failures
+ */
+export declare class ErrorDetector {
+    /**
+     * Detect failure type from error
+     * @param error - The error object
+     * @returns Classified failure type
+     */
+    detectFailureType(error: unknown): FailureType;
+    /**
+     * Check if error is an HTTP error with status code
+     */
+    private isHttpError;
+    /**
+     * Classify HTTP error by status code
+     */
+    private classifyHttpError;
+    /**
+     * Check if error is an API error with response body
+     */
+    private isApiError;
+    /**
+     * Classify API error by response body
+     */
+    private classifyApiError;
+    /**
+     * Classify error by message content
+     */
+    private classifyErrorMessage;
+    /**
+     * Check if error indicates context overflow
+     */
+    private isContextOverflow;
+    /**
+     * Check if error indicates rate limit
+     */
+    private isRateLimit;
+    /**
+     * Check if error indicates model unavailable
+     */
+    private isModelUnavailable;
+}
+export declare const errorDetector: ErrorDetector;

package/dist/router/errorDetector.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorDetector = exports.ErrorDetector = void 0;
+/**
+ * Detects and classifies API failures
+ */
+class ErrorDetector {
+    /**
+     * Detect failure type from error
+     * @param error - The error object
+     * @returns Classified failure type
+     */
+    detectFailureType(error) {
+        // Handle HTTP errors
+        if (this.isHttpError(error)) {
+            return this.classifyHttpError(error);
+        }
+        // Handle API response errors
+        if (this.isApiError(error)) {
+            return this.classifyApiError(error);
+        }
+        // Handle Error objects
+        if (error instanceof Error) {
+            return this.classifyErrorMessage(error.message);
+        }
+        return "unknown";
+    }
+    /**
+     * Check if error is an HTTP error with status code
+     */
+    isHttpError(error) {
+        return (typeof error === "object" &&
+            error !== null &&
+            "status" in error &&
+            typeof error.status === "number");
+    }
+    /**
+     * Classify HTTP error by status code
+     */
+    classifyHttpError(error) {
+        switch (error.status) {
+            case 429:
+                return "rate_limit";
+            case 404:
+                return "model_unavailable";
+            case 403:
+                return "access_denied";
+            case 400:
+                // 400 can be context overflow or other issues
+                return "unknown";
+            default:
+                return "unknown";
+        }
+    }
+    /**
+     * Check if error is an API error with response body
+     */
+    isApiError(error) {
+        return (typeof error === "object" &&
+            error !== null &&
+            "response" in error);
+    }
+    /**
+     * Classify API error by response body
+     */
+    classifyApiError(error) {
+        const data = error.response?.data;
+        if (!data) {
+            return "unknown";
+        }
+        // Check for context overflow indicators
+        if (this.isContextOverflow(data)) {
+            return "context_overflow";
+        }
+        // Check for rate limit indicators
+        if (this.isRateLimit(data)) {
+            return "rate_limit";
+        }
+        // Check for model unavailable indicators
+        if (this.isModelUnavailable(data)) {
+            return "model_unavailable";
+        }
+        return "unknown";
+    }
+    /**
+     * Classify error by message content
+     */
+    classifyErrorMessage(message) {
+        const lowerMessage = message.toLowerCase();
+        // Context overflow patterns
+        if (lowerMessage.includes("context") &&
+            (lowerMessage.includes("length") ||
+                lowerMessage.includes("limit") ||
+                lowerMessage.includes("exceeded") ||
+                lowerMessage.includes("too long"))) {
+            return "context_overflow";
+        }
+        // Rate limit patterns
+        if (lowerMessage.includes("rate limit") ||
+            lowerMessage.includes("too many requests") ||
+            lowerMessage.includes("quota exceeded")) {
+            return "rate_limit";
+        }
+        // Model unavailable patterns
+        if (lowerMessage.includes("model") &&
+            (lowerMessage.includes("not found") ||
+                lowerMessage.includes("unavailable") ||
+                lowerMessage.includes("does not exist"))) {
+            return "model_unavailable";
+        }
+        // Access denied patterns
+        if (lowerMessage.includes("access denied") ||
+            lowerMessage.includes("unauthorized") ||
+            lowerMessage.includes("forbidden")) {
+            return "access_denied";
+        }
+        return "unknown";
+    }
+    /**
+     * Check if error indicates context overflow
+     */
+    isContextOverflow(data) {
+        if (typeof data === "string") {
+            return this.classifyErrorMessage(data) === "context_overflow";
+        }
+        if (typeof data === "object" && data !== null) {
+            const errorMessage = data.error?.message || data.message || "";
+            const errorType = data.error?.type || data.type || "";
+            const errorCode = data.error?.code || data.code || "";
+            return (errorType === "invalid_request_error" &&
+                (errorCode === "context_length_exceeded" ||
+                    errorMessage.toLowerCase().includes("context")));
+        }
+        return false;
+    }
+    /**
+     * Check if error indicates rate limit
+     */
+    isRateLimit(data) {
+        if (typeof data === "string") {
+            return this.classifyErrorMessage(data) === "rate_limit";
+        }
+        if (typeof data === "object" && data !== null) {
+            const errorType = data.error?.type || data.type || "";
+            const errorCode = data.error?.code || data.code || "";
+            return (errorType === "rate_limit_error" ||
+                errorCode === "rate_limit_exceeded" ||
+                errorCode === "429");
+        }
+        return false;
+    }
+    /**
+     * Check if error indicates model unavailable
+     */
+    isModelUnavailable(data) {
+        if (typeof data === "string") {
+            return this.classifyErrorMessage(data) === "model_unavailable";
+        }
+        if (typeof data === "object" && data !== null) {
+            const errorMessage = data.error?.message || data.message || "";
+            const errorCode = data.error?.code || data.code || "";
+            return (errorCode === "model_not_found" ||
+                errorMessage.toLowerCase().includes("model") &&
+                    errorMessage.toLowerCase().includes("not found"));
+        }
+        return false;
+    }
+}
+exports.ErrorDetector = ErrorDetector;
+exports.errorDetector = new ErrorDetector();

package/dist/router/modelRouter.d.ts

@@ -0,0 +1,33 @@
+import { ModelRouterOptions, FailureContext, RoutingDecision, RoutingStrategy } from "./types";
+/**
+ * Intelligent Model Router
+ * Handles automatic retries and model switching on failures
+ */
+export declare class ModelRouter {
+    private strategy;
+    private fallbackMap;
+    private maxRetries;
+    constructor(options: ModelRouterOptions);
+    /**
+     * Validate router configuration
+     */
+    private validateOptions;
+    /**
+     * Handle a failed request and decide on retry strategy
+     * @param context - Context about the failed request
+     * @returns Routing decision
+     */
+    handleFailure(context: FailureContext): RoutingDecision;
+    /**
+     * Select and execute routing strategy
+     */
+    private selectStrategy;
+    /**
+     * Get maximum retries configured
+     */
+    getMaxRetries(): number;
+    /**
+     * Get current strategy
+     */
+    getStrategy(): RoutingStrategy;
+}

package/dist/router/modelRouter.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelRouter = void 0;
+const errorDetector_1 = require("./errorDetector");
+const routingStrategies_1 = require("./routingStrategies");
+/**
+ * Intelligent Model Router
+ * Handles automatic retries and model switching on failures
+ */
+class ModelRouter {
+    constructor(options) {
+        this.strategy = options.strategy;
+        this.fallbackMap = options.fallbackMap || {};
+        this.maxRetries = options.maxRetries ?? 1;
+        this.validateOptions();
+    }
+    /**
+     * Validate router configuration
+     */
+    validateOptions() {
+        if (this.maxRetries < 0) {
+            throw new Error("TokenFirewall Router: maxRetries must be non-negative");
+        }
+        if (this.maxRetries > 5) {
+            console.warn("TokenFirewall Router: maxRetries > 5 may cause excessive API calls");
+        }
+        if (this.strategy === "fallback") {
+            if (Object.keys(this.fallbackMap).length === 0) {
+                throw new Error("TokenFirewall Router: fallback strategy requires fallbackMap configuration. " +
+                    "Provide at least one fallback mapping or use a different strategy.");
+            }
+            // Validate fallback map structure
+            for (const [model, fallbacks] of Object.entries(this.fallbackMap)) {
+                if (!Array.isArray(fallbacks) || fallbacks.length === 0) {
+                    throw new Error(`TokenFirewall Router: fallbackMap for "${model}" must be a non-empty array`);
+                }
+                // Validate each fallback model name
+                for (const fallbackModel of fallbacks) {
+                    if (typeof fallbackModel !== 'string' || fallbackModel.trim() === '') {
+                        throw new Error(`TokenFirewall Router: fallbackMap for "${model}" contains invalid model name (empty or whitespace)`);
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Handle a failed request and decide on retry strategy
+     * @param context - Context about the failed request
+     * @returns Routing decision
+     */
+    handleFailure(context) {
+        // Check if max retries exceeded
+        if (context.retryCount >= this.maxRetries) {
+            return {
+                retry: false,
+                reason: `Max retries (${this.maxRetries}) exceeded`
+            };
+        }
+        // Detect failure type
+        const failureType = errorDetector_1.errorDetector.detectFailureType(context.error);
+        // Select routing strategy
+        const decision = this.selectStrategy(context, failureType);
+        // Validate decision
+        if (decision.retry && !decision.nextModel) {
+            throw new Error("TokenFirewall Router: Invalid decision - retry=true but no nextModel specified");
+        }
+        // Prevent retrying same model
+        if (decision.retry && context.attemptedModels.includes(decision.nextModel)) {
+            return {
+                retry: false,
+                reason: `Model ${decision.nextModel} has already been attempted`
+            };
+        }
+        // Prevent switching back to original model (circular retry)
+        if (decision.retry && decision.nextModel === context.originalModel && context.retryCount > 0) {
+            return {
+                retry: false,
+                reason: `Cannot switch back to original model ${context.originalModel}`
+            };
+        }
+        return decision;
+    }
+    /**
+     * Select and execute routing strategy
+     */
+    selectStrategy(context, failureType) {
+        switch (this.strategy) {
+            case "fallback":
+                return (0, routingStrategies_1.fallbackStrategy)(context, failureType, this.fallbackMap);
+            case "context":
+                return (0, routingStrategies_1.contextStrategy)(context, failureType);
+            case "cost":
+                return (0, routingStrategies_1.costStrategy)(context, failureType);
+            default:
+                throw new Error(`TokenFirewall Router: Unknown strategy "${this.strategy}"`);
+        }
+    }
+    /**
+     * Get maximum retries configured
+     */
+    getMaxRetries() {
+        return this.maxRetries;
+    }
+    /**
+     * Get current strategy
+     */
+    getStrategy() {
+        return this.strategy;
+    }
+}
+exports.ModelRouter = ModelRouter;

package/dist/router/routingStrategies.d.ts

@@ -0,0 +1,16 @@
+import { FailureContext, RoutingDecision, FailureType } from "./types";
+/**
+ * Fallback routing strategy
+ * Uses predefined fallback map to select next model
+ */
+export declare function fallbackStrategy(context: FailureContext, failureType: FailureType, fallbackMap: Record<string, string[]>): RoutingDecision;
+/**
+ * Context-based routing strategy
+ * Selects model with larger context window when context overflow occurs
+ */
+export declare function contextStrategy(context: FailureContext, failureType: FailureType): RoutingDecision;
+/**
+ * Cost-based routing strategy
+ * Selects cheaper model from same provider
+ */
+export declare function costStrategy(context: FailureContext, failureType: FailureType): RoutingDecision;