tokenfirewall 1.0.2 → 2.0.0

package/dist/core/pricingRegistry.js

@@ -13,16 +13,64 @@ class PricingRegistry {
      * Initialize default pricing for supported providers
      */
     initializeDefaultPricing() {
+        // =========================
         // OpenAI pricing (per 1M tokens)
+        // =========================
+        // ===== GPT-5 (Latest Flagship) =====
+        this.register("openai", "gpt-5", { input: 5.0, output: 15.0 });
+        this.register("openai", "gpt-5-mini", { input: 1.5, output: 5.0 });
+        // ===== GPT-4.1 Series =====
+        this.register("openai", "gpt-4.1", { input: 3.0, output: 12.0 });
+        this.register("openai", "gpt-4.1-mini", { input: 0.8, output: 3.0 });
+        // ===== GPT-4o (Balanced Multimodal) =====
         this.register("openai", "gpt-4o", { input: 2.5, output: 10.0 });
         this.register("openai", "gpt-4o-mini", { input: 0.15, output: 0.6 });
+        // ===== Reasoning Models =====
+        this.register("openai", "o1", { input: 6.0, output: 18.0 });
+        this.register("openai", "o1-mini", { input: 2.0, output: 6.0 });
+        // ===== Image Generation =====
+        this.register("openai", "gpt-image-1", { input: 5.0, output: 0.0 });
+        // ===== Legacy Models =====
         this.register("openai", "gpt-4-turbo", { input: 10.0, output: 30.0 });
         this.register("openai", "gpt-3.5-turbo", { input: 0.5, output: 1.5 });
+        // =========================
         // Anthropic pricing (per 1M tokens)
+        // =========================
+        // ===== Claude 4.5 (Newer Improved) =====
+        this.register("anthropic", "claude-opus-4.5", { input: 17.0, output: 85.0 });
+        this.register("anthropic", "claude-sonnet-4.5", { input: 4.0, output: 20.0 });
+        this.register("anthropic", "claude-haiku-4.5", { input: 1.2, output: 6.0 });
+        // ===== Classic Claude 4 =====
+        this.register("anthropic", "claude-4-opus", { input: 15.0, output: 75.0 });
+        this.register("anthropic", "claude-sonnet-4", { input: 3.0, output: 15.0 });
+        this.register("anthropic", "claude-haiku-4", { input: 1.0, output: 5.0 });
+        // ===== Stable Claude 3.5 Fallback =====
+        this.register("anthropic", "claude-3-5-sonnet-latest", { input: 3.0, output: 15.0 });
+        this.register("anthropic", "claude-3-5-haiku-latest", { input: 0.8, output: 4.0 });
+        // ===== Legacy Models =====
         this.register("anthropic", "claude-3-5-sonnet-20241022", { input: 3.0, output: 15.0 });
         this.register("anthropic", "claude-3-5-haiku-20241022", { input: 0.8, output: 4.0 });
         this.register("anthropic", "claude-3-opus-20240229", { input: 15.0, output: 75.0 });
+        // =========================
         // Google Gemini pricing (per 1M tokens)
+        // =========================
+        // ===== Gemini 3 (Latest Generation) =====
+        this.register("gemini", "gemini-3-pro", { input: 3.5, output: 14.0 });
+        this.register("gemini", "gemini-3.1-pro", { input: 4.0, output: 16.0 });
+        this.register("gemini", "gemini-3-flash", { input: 0.35, output: 1.5 });
+        this.register("gemini", "gemini-3-flash-lite", { input: 0.15, output: 0.6 });
+        // ===== Image Models (Nano Banana Series) =====
+        this.register("gemini", "gemini-3-pro-image", { input: 5.0, output: 0.0 });
+        this.register("gemini", "gemini-3.1-flash-image", { input: 0.75, output: 0.0 });
+        // ===== Gemini 2.5 (Stable Production Tier) =====
+        this.register("gemini", "gemini-2.5-pro", { input: 2.5, output: 10.0 });
+        this.register("gemini", "gemini-2.5-flash", { input: 0.30, output: 1.2 });
+        this.register("gemini", "gemini-2.5-flash-lite", { input: 0.10, output: 0.4 });
+        // Image-capable 2.5
+        this.register("gemini", "gemini-2.5-flash-image", { input: 0.5, output: 0.0 });
+        // ===== Ultra-light / Experimental =====
+        this.register("gemini", "gemini-nano-banana", { input: 0.05, output: 0.2 });
+        // ===== Legacy Models =====
         this.register("gemini", "gemini-2.0-flash-exp", { input: 0.0, output: 0.0 });
         this.register("gemini", "gemini-1.5-pro", { input: 1.25, output: 5.0 });
         this.register("gemini", "gemini-1.5-flash", { input: 0.075, output: 0.3 });
@@ -45,17 +93,19 @@ class PricingRegistry {
      * Register pricing for a provider and model
      */
     register(provider, model, pricing) {
-        if (!this.pricing.has(provider)) {
-            this.pricing.set(provider, new Map());
+        const normalizedProvider = provider.toLowerCase();
+        if (!this.pricing.has(normalizedProvider)) {
+            this.pricing.set(normalizedProvider, new Map());
         }
-        this.pricing.get(provider).set(model, pricing);
+        this.pricing.get(normalizedProvider).set(model, pricing);
     }
     /**
      * Get pricing for a specific provider and model
      * @throws Error if pricing not found
      */
     getPricing(provider, model) {
-        const providerPricing = this.pricing.get(provider);
+        const normalizedProvider = provider.toLowerCase();
+        const providerPricing = this.pricing.get(normalizedProvider);
         if (!providerPricing) {
             throw new Error(`TokenFirewall: No pricing found for provider "${provider}"`);
         }
@@ -69,7 +119,8 @@ class PricingRegistry {
      * Check if pricing exists for a provider and model
      */
     hasPricing(provider, model) {
-        return this.pricing.get(provider)?.has(model) ?? false;
+        const normalizedProvider = provider.toLowerCase();
+        return this.pricing.get(normalizedProvider)?.has(model) ?? false;
     }
 }
 exports.pricingRegistry = new PricingRegistry();

package/dist/index.d.ts

@@ -3,6 +3,8 @@ import { BudgetManager } from "./core/budgetManager";
 import { patchGlobalFetch } from "./interceptors/fetchInterceptor";
 import { patchProvider } from "./interceptors/sdkInterceptor";
 import { listAvailableModels, ModelInfo, ListModelsOptions } from "./introspection/modelLister";
+import { ModelRouter } from "./router/modelRouter";
+import { ModelRouterOptions } from "./router/types";
 /**
  * Create and configure a budget guard
  * @param options - Budget configuration options
@@ -37,6 +39,17 @@ export declare function registerPricing(provider: string, model: string, pricing
  * @param contextLimit - Context window size in tokens
  */
 export declare function registerContextLimit(provider: string, model: string, contextLimit: number): void;
+/**
+ * Register multiple models for a provider at once
+ * Useful for dynamic model discovery or custom provider setup
+ * @param provider - Provider name
+ * @param models - Array of model configurations
+ */
+export declare function registerModels(provider: string, models: Array<{
+    name: string;
+    contextLimit?: number;
+    pricing?: ModelPricing;
+}>): void;
 /**
  * Get current budget status
  * @returns Budget status or null if no budget guard is active
@@ -60,6 +73,16 @@ export declare function exportBudgetState(): {
 export declare function importBudgetState(state: {
     totalSpent: number;
 }): void;
+/**
+ * Create and configure a model router for automatic retries and fallbacks
+ * @param options - Router configuration options
+ * @returns Model router instance
+ */
+export declare function createModelRouter(options: ModelRouterOptions): ModelRouter;
+/**
+ * Disable model router
+ */
+export declare function disableModelRouter(): void;
 /**
  * List available models for a provider with context limits and budget usage
  * @param options - Provider configuration and options
@@ -69,3 +92,12 @@ export declare function listModels(options: Omit<ListModelsOptions, 'budgetManag
 export { listAvailableModels };
 export type { BudgetGuardOptions, ProviderAdapter, ModelPricing, NormalizedUsage, CostBreakdown, BudgetStatus, ModelInfo, ListModelsOptions, } from "./core/types";
 export type { ModelInfo as ModelInfoType, ListModelsOptions as ListModelsOptionsType } from "./introspection/modelLister";
+export type { ModelRouterOptions, RoutingStrategy, FailureType, FailureContext, RoutingDecision, RouterEvent } from "./router/types";
+/**
+ * Model configuration for bulk registration
+ */
+export interface ModelConfig {
+    name: string;
+    contextLimit?: number;
+    pricing?: ModelPricing;
+}

package/dist/index.js

@@ -5,10 +5,13 @@ exports.createBudgetGuard = createBudgetGuard;
 exports.registerAdapter = registerAdapter;
 exports.registerPricing = registerPricing;
 exports.registerContextLimit = registerContextLimit;
+exports.registerModels = registerModels;
 exports.getBudgetStatus = getBudgetStatus;
 exports.resetBudget = resetBudget;
 exports.exportBudgetState = exportBudgetState;
 exports.importBudgetState = importBudgetState;
+exports.createModelRouter = createModelRouter;
+exports.disableModelRouter = disableModelRouter;
 exports.listModels = listModels;
 const budgetManager_1 = require("./core/budgetManager");
 const pricingRegistry_1 = require("./core/pricingRegistry");
@@ -20,7 +23,9 @@ Object.defineProperty(exports, "patchProvider", { enumerable: true, get: functio
 const modelLister_1 = require("./introspection/modelLister");
 Object.defineProperty(exports, "listAvailableModels", { enumerable: true, get: function () { return modelLister_1.listAvailableModels; } });
 const contextRegistry_1 = require("./introspection/contextRegistry");
+const modelRouter_1 = require("./router/modelRouter");
 let globalBudgetManager = null;
+let globalModelRouter = null;
 /**
  * Create and configure a budget guard
  * @param options - Budget configuration options
@@ -51,22 +56,22 @@ function registerAdapter(adapter) {
  */
 function registerPricing(provider, model, pricing) {
     // Validate inputs
-    if (!provider || typeof provider !== 'string') {
+    if (!provider || typeof provider !== 'string' || provider.trim() === '') {
         throw new Error('TokenFirewall: Provider must be a non-empty string');
     }
-    if (!model || typeof model !== 'string') {
+    if (!model || typeof model !== 'string' || model.trim() === '') {
         throw new Error('TokenFirewall: Model must be a non-empty string');
     }
     if (!pricing || typeof pricing !== 'object') {
         throw new Error('TokenFirewall: Pricing must be an object');
     }
-    if (typeof pricing.input !== 'number' || pricing.input < 0 || !isFinite(pricing.input)) {
-        throw new Error('TokenFirewall: Pricing input must be a non-negative number');
+    if (typeof pricing.input !== 'number' || pricing.input < 0 || !isFinite(pricing.input) || isNaN(pricing.input)) {
+        throw new Error('TokenFirewall: Pricing input must be a non-negative finite number');
     }
-    if (typeof pricing.output !== 'number' || pricing.output < 0 || !isFinite(pricing.output)) {
-        throw new Error('TokenFirewall: Pricing output must be a non-negative number');
+    if (typeof pricing.output !== 'number' || pricing.output < 0 || !isFinite(pricing.output) || isNaN(pricing.output)) {
+        throw new Error('TokenFirewall: Pricing output must be a non-negative finite number');
     }
-    pricingRegistry_1.pricingRegistry.register(provider, model, pricing);
+    pricingRegistry_1.pricingRegistry.register(provider.toLowerCase(), model, pricing);
 }
 /**
  * Register custom context limit for a provider and model
@@ -76,16 +81,47 @@ function registerPricing(provider, model, pricing) {
  */
 function registerContextLimit(provider, model, contextLimit) {
     // Validate inputs
-    if (!provider || typeof provider !== 'string') {
+    if (!provider || typeof provider !== 'string' || provider.trim() === '') {
         throw new Error('TokenFirewall: Provider must be a non-empty string');
     }
-    if (!model || typeof model !== 'string') {
+    if (!model || typeof model !== 'string' || model.trim() === '') {
         throw new Error('TokenFirewall: Model must be a non-empty string');
     }
-    if (typeof contextLimit !== 'number' || contextLimit <= 0 || !isFinite(contextLimit)) {
-        throw new Error('TokenFirewall: Context limit must be a positive number');
+    if (typeof contextLimit !== 'number' || contextLimit <= 0 || !isFinite(contextLimit) || isNaN(contextLimit)) {
+        throw new Error('TokenFirewall: Context limit must be a positive finite number');
+    }
+    contextRegistry_1.contextRegistry.register(provider.toLowerCase(), model, { tokens: contextLimit });
+}
+/**
+ * Register multiple models for a provider at once
+ * Useful for dynamic model discovery or custom provider setup
+ * @param provider - Provider name
+ * @param models - Array of model configurations
+ */
+function registerModels(provider, models) {
+    // Validate inputs
+    if (!provider || typeof provider !== 'string' || provider.trim() === '') {
+        throw new Error('TokenFirewall: Provider must be a non-empty string');
+    }
+    if (!Array.isArray(models) || models.length === 0) {
+        throw new Error('TokenFirewall: Models must be a non-empty array');
+    }
+    // Normalize provider name to lowercase
+    const normalizedProvider = provider.toLowerCase();
+    // Register each model
+    for (const model of models) {
+        if (!model.name || typeof model.name !== 'string' || model.name.trim() === '') {
+            throw new Error('TokenFirewall: Each model must have a valid name');
+        }
+        // Register context limit if provided
+        if (model.contextLimit !== undefined) {
+            registerContextLimit(normalizedProvider, model.name, model.contextLimit);
+        }
+        // Register pricing if provided
+        if (model.pricing !== undefined) {
+            registerPricing(normalizedProvider, model.name, model.pricing);
+        }
     }
-    contextRegistry_1.contextRegistry.register(provider, model, { tokens: contextLimit });
 }
 /**
  * Get current budget status
@@ -120,6 +156,24 @@ function importBudgetState(state) {
     }
     globalBudgetManager.importState(state);
 }
+/**
+ * Create and configure a model router for automatic retries and fallbacks
+ * @param options - Router configuration options
+ * @returns Model router instance
+ */
+function createModelRouter(options) {
+    const router = new modelRouter_1.ModelRouter(options);
+    globalModelRouter = router;
+    (0, fetchInterceptor_1.setModelRouter)(router);
+    return router;
+}
+/**
+ * Disable model router
+ */
+function disableModelRouter() {
+    globalModelRouter = null;
+    (0, fetchInterceptor_1.setModelRouter)(null);
+}
 /**
  * List available models for a provider with context limits and budget usage
  * @param options - Provider configuration and options

package/dist/interceptors/fetchInterceptor.d.ts

@@ -1,8 +1,13 @@
 import { BudgetManager } from "../core/budgetManager";
+import { ModelRouter } from "../router/modelRouter";
 /**
  * Set the budget manager for fetch interception
  */
 export declare function setBudgetManager(manager: BudgetManager | null): void;
+/**
+ * Set the model router for fetch interception
+ */
+export declare function setModelRouter(router: ModelRouter | null): void;
 /**
  * Patch global fetch to intercept LLM API calls
  */

package/dist/interceptors/fetchInterceptor.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setBudgetManager = setBudgetManager;
+exports.setModelRouter = setModelRouter;
 exports.patchGlobalFetch = patchGlobalFetch;
 exports.unpatchGlobalFetch = unpatchGlobalFetch;
 const registry_1 = require("../registry");
@@ -8,6 +9,7 @@ const costEngine_1 = require("../core/costEngine");
 const logger_1 = require("../logger");
 let isPatched = false;
 let budgetManager = null;
+let modelRouter = null;
 const originalFetch = globalThis.fetch;
 /**
  * Set the budget manager for fetch interception
@@ -15,6 +17,12 @@ const originalFetch = globalThis.fetch;
 function setBudgetManager(manager) {
     budgetManager = manager;
 }
+/**
+ * Set the model router for fetch interception
+ */
+function setModelRouter(router) {
+    modelRouter = router;
+}
 /**
  * Patch global fetch to intercept LLM API calls
  */
@@ -23,44 +31,287 @@ function patchGlobalFetch() {
         return;
     }
     const interceptedFetch = async function (input, init) {
-        const response = await originalFetch(input, init);
-        // Try to clone response for tracking (may fail for some responses)
-        let clonedResponse;
+        // If router is enabled, wrap request with retry logic
+        if (modelRouter) {
+            return await fetchWithRetry(input, init);
+        }
+        // Otherwise, use standard fetch with tracking
+        return await standardFetch(input, init);
+    };
+    globalThis.fetch = interceptedFetch;
+    isPatched = true;
+}
+/**
+ * Standard fetch with cost tracking (no retry)
+ */
+async function standardFetch(input, init) {
+    const response = await originalFetch(input, init);
+    // Try to clone response for tracking (may fail for some responses)
+    let clonedResponse;
+    try {
+        clonedResponse = response.clone();
+    }
+    catch (error) {
+        // If cloning fails, just return original response without tracking
+        console.warn('TokenFirewall: Failed to clone response for tracking');
+        return response;
+    }
+    // Process response and track budget BEFORE returning
+    try {
+        const responseData = await clonedResponse.json();
+        // Try to process with adapter registry
+        const normalizedUsage = registry_1.adapterRegistry.process(responseData);
+        if (normalizedUsage) {
+            // Calculate cost
+            const cost = (0, costEngine_1.calculateCost)(normalizedUsage);
+            // Track budget if manager exists - MUST await to enforce blocking
+            if (budgetManager) {
+                await budgetManager.track(cost.totalCost);
+            }
+            // Log usage
+            logger_1.logger.logUsage(normalizedUsage, cost);
+        }
+    }
+    catch (error) {
+        // If it's a budget error, re-throw it
+        if (error instanceof Error && error.message.includes('TokenFirewall: Budget exceeded')) {
+            throw error;
+        }
+        // Otherwise, not JSON or not an LLM response - ignore silently
+    }
+    return response;
+}
+/**
+ * Fetch with automatic retry and model switching
+ */
+async function fetchWithRetry(input, init) {
+    // Check if streaming is enabled - router doesn't support streaming yet
+    if (init?.body) {
         try {
-            clonedResponse = response.clone();
+            const body = JSON.parse(init.body);
+            if (body.stream === true) {
+                console.warn('TokenFirewall Router: Streaming requests are not supported by the router. ' +
+                    'Falling back to standard fetch without retry logic.');
+                return await standardFetch(input, init);
+            }
         }
-        catch (error) {
-            // If cloning fails, just return original response without tracking
-            console.warn('TokenFirewall: Failed to clone response for tracking');
-            return response;
+        catch {
+            // Body is not JSON, continue normally
         }
-        // Process response and track budget BEFORE returning
+    }
+    const attemptedModels = [];
+    let retryCount = 0;
+    let lastError;
+    let currentInit = init;
+    let currentInput = input;
+    // Extract original model and provider from request
+    const { originalModel, provider } = extractModelInfo(input, init);
+    if (originalModel) {
+        attemptedModels.push(originalModel);
+    }
+    while (retryCount <= (modelRouter?.getMaxRetries() || 0)) {
         try {
-            const responseData = await clonedResponse.json();
-            // Try to process with adapter registry
-            const normalizedUsage = registry_1.adapterRegistry.process(responseData);
-            if (normalizedUsage) {
-                // Calculate cost
-                const cost = (0, costEngine_1.calculateCost)(normalizedUsage);
-                // Track budget if manager exists - MUST await to enforce blocking
-                if (budgetManager) {
-                    await budgetManager.track(cost.totalCost);
+            // Make the request
+            const response = await standardFetch(currentInput, currentInit);
+            // Check if response indicates an error
+            if (!response.ok) {
+                // Clone and read error response safely
+                let errorData = {};
+                try {
+                    const clonedResponse = response.clone();
+                    errorData = await clonedResponse.json();
+                }
+                catch {
+                    // Response is not JSON or already consumed
                 }
-                // Log usage
-                logger_1.logger.logUsage(normalizedUsage, cost);
+                // Throw proper Error instance with structured data
+                const errorObj = {
+                    status: response.status,
+                    response: { data: errorData }
+                };
+                throw new Error(JSON.stringify(errorObj));
             }
+            return response;
         }
         catch (error) {
-            // If it's a budget error, re-throw it
-            if (error instanceof Error && error.message.includes('TokenFirewall: Budget exceeded')) {
+            lastError = error;
+            // If no router or no model info, throw immediately
+            if (!modelRouter || !originalModel || !provider) {
+                throw error;
+            }
+            // Parse error if it's a JSON string
+            let parsedError = error;
+            if (error instanceof Error && error.message.startsWith('{')) {
+                try {
+                    parsedError = JSON.parse(error.message);
+                }
+                catch {
+                    // Keep original error
+                }
+            }
+            // Get routing decision
+            const decision = modelRouter.handleFailure({
+                error: parsedError,
+                originalModel,
+                requestBody: currentInit?.body ? (() => {
+                    try {
+                        return JSON.parse(currentInit.body);
+                    }
+                    catch {
+                        return {};
+                    }
+                })() : {},
+                provider,
+                retryCount,
+                attemptedModels
+            });
+            // If no retry, throw the error
+            if (!decision.retry || !decision.nextModel) {
                 throw error;
             }
-            // Otherwise, not JSON or not an LLM response - ignore silently
+            // Log the routing event
+            logger_1.logger.logRouterEvent({
+                originalModel,
+                nextModel: decision.nextModel,
+                reason: decision.reason,
+                attempt: retryCount + 1,
+                maxRetries: modelRouter.getMaxRetries()
+            });
+            // Update request with new model
+            attemptedModels.push(decision.nextModel);
+            const updated = updateRequestModel(currentInput, currentInit, decision.nextModel, provider);
+            currentInput = updated.input;
+            currentInit = updated.init;
+            retryCount++;
         }
-        return response;
-    };
-    globalThis.fetch = interceptedFetch;
-    isPatched = true;
+    }
+    // Max retries exceeded
+    throw new Error(`TokenFirewall: Max routing retries exceeded. Last error: ${lastError}`);
+}
+/**
+ * Extract model and provider information from request
+ */
+function extractModelInfo(input, init) {
+    try {
+        // Parse URL to detect provider
+        const url = typeof input === 'string' ? input : (input instanceof Request ? input.url : String(input));
+        let provider = null;
+        let model = null;
+        if (url.includes('api.openai.com')) {
+            provider = 'openai';
+        }
+        else if (url.includes('api.anthropic.com')) {
+            provider = 'anthropic';
+        }
+        else if (url.includes('generativelanguage.googleapis.com')) {
+            provider = 'gemini';
+            // Gemini model is in URL: /models/{model}:generateContent
+            const match = url.match(/\/models\/([^:]+):/);
+            if (match) {
+                model = match[1];
+            }
+        }
+        else if (url.includes('api.x.ai')) {
+            provider = 'grok';
+        }
+        else if (url.includes('api.moonshot.cn')) {
+            provider = 'kimi';
+        }
+        else {
+            // Unknown provider - try to extract from URL hostname
+            try {
+                const urlObj = new URL(url);
+                const hostname = urlObj.hostname;
+                // Use first part of hostname as provider (e.g., api.example.com -> example)
+                const parts = hostname.split('.');
+                if (parts.length >= 2) {
+                    provider = parts[parts.length - 2]; // Get domain name
+                }
+            }
+            catch {
+                provider = 'unknown';
+            }
+        }
+        // Extract model from request body (for non-Gemini providers)
+        if (!model) {
+            let body = null;
+            // Get body from init or Request object
+            if (init?.body) {
+                body = typeof init.body === 'string' ? init.body : null;
+            }
+            else if (input instanceof Request && input.body) {
+                // Note: Request.body is a ReadableStream, we can't read it here without consuming it
+                // So we skip body parsing for Request objects without explicit init.body
+                body = null;
+            }
+            if (body) {
+                try {
+                    const bodyObj = JSON.parse(body);
+                    model = bodyObj.model || null;
+                }
+                catch {
+                    // Body is not JSON or doesn't have model field
+                }
+            }
+        }
+        return { originalModel: model, provider };
+    }
+    catch {
+        return { originalModel: null, provider: null };
+    }
+}
+/**
+ * Update request with new model (handles both URL and body)
+ */
+function updateRequestModel(input, init, newModel, provider) {
+    let newInput = input;
+    let newInit = init;
+    // Get the URL string
+    const url = typeof input === 'string' ? input : (input instanceof Request ? input.url : String(input));
+    // Update URL for Gemini (model is in URL path)
+    if (provider === 'gemini') {
+        const newUrl = url.replace(/\/models\/[^:]+:/, `/models/${newModel}:`);
+        // If input was a Request object, we need to create a new Request with updated URL
+        if (input instanceof Request) {
+            // Clone the request with new URL
+            newInput = new Request(newUrl, {
+                method: input.method,
+                headers: input.headers,
+                body: init?.body || null,
+                mode: input.mode,
+                credentials: input.credentials,
+                cache: input.cache,
+                redirect: input.redirect,
+                referrer: input.referrer,
+                integrity: input.integrity
+            });
+        }
+        else {
+            newInput = newUrl;
+        }
+    }
+    // Update body for other providers (model is in request body)
+    if (init?.body) {
+        try {
+            const body = JSON.parse(init.body);
+            body.model = newModel;
+            newInit = {
+                ...init,
+                body: JSON.stringify(body)
+            };
+        }
+        catch {
+            // Body is not JSON, log warning
+            console.warn(`TokenFirewall Router: Cannot update model in non-JSON request body. ` +
+                `Model switching may not work correctly.`);
+        }
+    }
+    else if (input instanceof Request && provider !== 'gemini') {
+        // Request object without explicit init.body - we can't modify it
+        console.warn(`TokenFirewall Router: Cannot update model in Request object without explicit body. ` +
+            `Model switching may not work correctly.`);
+    }
+    return { input: newInput, init: newInit };
 }
 /**
  * Restore original fetch

package/dist/introspection/contextRegistry.d.ts

@@ -25,6 +25,11 @@ declare class ContextRegistry {
      * Check if provider is supported
      */
     isProviderSupported(provider: string): boolean;
+    /**
+     * Get all models for a provider
+     * Returns array of model names
+     */
+    getModelsForProvider(provider: string): string[];
 }
 export declare const contextRegistry: ContextRegistry;
 export {};