tokenfirewall 1.0.1

package/dist/introspection/contextRegistry.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Context window registry for LLM models
+ * Maintains static mapping of model -> context limits
+ */
+interface ContextLimit {
+    tokens: number;
+}
+declare class ContextRegistry {
+    private limits;
+    constructor();
+    /**
+     * Initialize known context limits for supported models
+     */
+    private initializeContextLimits;
+    /**
+     * Register context limit for a model
+     */
+    register(provider: string, model: string, limit: ContextLimit): void;
+    /**
+     * Get context limit for a model
+     * Returns undefined if not found (does not throw)
+     */
+    getContextLimit(provider: string, model: string): number | undefined;
+    /**
+     * Check if provider is supported
+     */
+    isProviderSupported(provider: string): boolean;
+}
+export declare const contextRegistry: ContextRegistry;
+export {};

package/dist/introspection/contextRegistry.js

@@ -0,0 +1,81 @@
+"use strict";
+/**
+ * Context window registry for LLM models
+ * Maintains static mapping of model -> context limits
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contextRegistry = void 0;
+class ContextRegistry {
+    constructor() {
+        this.limits = new Map();
+        this.initializeContextLimits();
+    }
+    /**
+     * Initialize known context limits for supported models
+     */
+    initializeContextLimits() {
+        // OpenAI context limits
+        this.register("openai", "gpt-4o", { tokens: 128000 });
+        this.register("openai", "gpt-4o-mini", { tokens: 128000 });
+        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
+        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 });
+        this.register("gemini", "gemini-2.5-pro", { tokens: 2097152 });
+        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 });
+        this.register("gemini", "gemini-1.5-flash", { tokens: 1048576 });
+        this.register("gemini", "gemini-1.0-pro", { tokens: 32768 });
+        // Grok context limits
+        this.register("grok", "grok-beta", { tokens: 131072 });
+        this.register("grok", "grok-vision-beta", { tokens: 131072 });
+        this.register("grok", "grok-2-1212", { tokens: 131072 });
+        this.register("grok", "grok-2-vision-1212", { tokens: 131072 });
+        // Llama models via Grok
+        this.register("grok", "llama-3.1-70b", { tokens: 131072 });
+        this.register("grok", "llama-3.1-8b", { tokens: 131072 });
+        this.register("grok", "llama-3.2-90b-vision", { tokens: 131072 });
+        this.register("grok", "llama-3.3-70b", { tokens: 131072 });
+        // Kimi context limits
+        this.register("kimi", "moonshot-v1-8k", { tokens: 8192 });
+        this.register("kimi", "moonshot-v1-32k", { tokens: 32768 });
+        this.register("kimi", "moonshot-v1-128k", { tokens: 131072 });
+    }
+    /**
+     * Register context limit for a model
+     */
+    register(provider, model, limit) {
+        if (!this.limits.has(provider)) {
+            this.limits.set(provider, new Map());
+        }
+        this.limits.get(provider).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);
+        if (!providerLimits) {
+            return undefined;
+        }
+        const limit = providerLimits.get(model);
+        return limit?.tokens;
+    }
+    /**
+     * Check if provider is supported
+     */
+    isProviderSupported(provider) {
+        return this.limits.has(provider);
+    }
+}
+exports.contextRegistry = new ContextRegistry();

package/dist/introspection/modelLister.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Model information with context limits and budget usage
+ */
+export interface ModelInfo {
+    model: string;
+    contextLimit?: number;
+    budgetUsagePercentage?: number;
+}
+/**
+ * Options for listing available models
+ */
+export interface ListModelsOptions {
+    provider: string;
+    apiKey: string;
+    baseURL?: string;
+    includeBudgetUsage?: boolean;
+    budgetManager?: any;
+}
+/**
+ * List available models for a provider
+ */
+export declare function listAvailableModels(options: ListModelsOptions): Promise<ModelInfo[]>;

package/dist/introspection/modelLister.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listAvailableModels = listAvailableModels;
+const contextRegistry_1 = require("./contextRegistry");
+/**
+ * List available models for a provider
+ */
+async function listAvailableModels(options) {
+    const { provider, apiKey, baseURL, includeBudgetUsage, budgetManager } = options;
+    const providerLower = provider.toLowerCase();
+    let models = [];
+    try {
+        switch (providerLower) {
+            case "openai":
+                models = await listOpenAIModels(apiKey, baseURL);
+                break;
+            case "anthropic":
+                models = await listAnthropicModels();
+                break;
+            case "gemini":
+                models = await listGeminiModels(apiKey, baseURL);
+                break;
+            case "grok":
+                models = await listGrokModels(apiKey, baseURL);
+                break;
+            case "kimi":
+                models = await listKimiModels(apiKey, baseURL);
+                break;
+            default:
+                console.warn(`TokenFirewall: Provider "${provider}" not supported for model listing`);
+                return [];
+        }
+    }
+    catch (error) {
+        console.warn(`TokenFirewall: Failed to list models for ${provider}:`, error);
+        return [];
+    }
+    return enrichModelsWithMetadata(providerLower, models, includeBudgetUsage, budgetManager);
+}
+/**
+ * Enrich model list with context limits and budget usage
+ */
+function enrichModelsWithMetadata(provider, models, includeBudgetUsage, budgetManager) {
+    let budgetPercentage;
+    if (includeBudgetUsage && budgetManager) {
+        const status = budgetManager.getStatus();
+        budgetPercentage = status ? status.percentageUsed : undefined;
+    }
+    return models.map((model) => {
+        const contextLimit = contextRegistry_1.contextRegistry.getContextLimit(provider, model);
+        const info = {
+            model,
+        };
+        if (contextLimit !== undefined) {
+            info.contextLimit = contextLimit;
+        }
+        if (budgetPercentage !== undefined) {
+            info.budgetUsagePercentage = budgetPercentage;
+        }
+        return info;
+    });
+}
+// Remove the circular dependency function
+// function getBudgetUsagePercentage(): number | undefined {
+//   try {
+//     const { getBudgetStatus } = require("../index");
+//     const status = getBudgetStatus();
+//     return status ? status.percentageUsed : undefined;
+//   } catch {
+//     return undefined;
+//   }
+// }
+/**
+ * Fetch with timeout
+ */
+async function fetchWithTimeout(url, options, timeoutMs = 10000) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const response = await fetch(url, {
+            ...options,
+            signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        return response;
+    }
+    catch (error) {
+        clearTimeout(timeoutId);
+        if (error instanceof Error && error.name === 'AbortError') {
+            throw new Error('Request timeout');
+        }
+        throw error;
+    }
+}
+/**
+ * List OpenAI models
+ */
+async function listOpenAIModels(apiKey, baseURL) {
+    const url = baseURL || "https://api.openai.com/v1/models";
+    const response = await fetchWithTimeout(url, {
+        method: "GET",
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`OpenAI API error: ${response.status}`);
+    }
+    const data = (await response.json());
+    if (!data.data || !Array.isArray(data.data)) {
+        return [];
+    }
+    return data.data.map((model) => model.id);
+}
+/**
+ * List Anthropic models
+ * Note: Anthropic does not provide a models endpoint
+ */
+async function listAnthropicModels() {
+    console.warn("TokenFirewall: Anthropic does not provide a model listing API");
+    return [
+        "claude-3-5-sonnet-20241022",
+        "claude-3-5-haiku-20241022",
+        "claude-3-opus-20240229",
+        "claude-3-sonnet-20240229",
+        "claude-3-haiku-20240307",
+    ];
+}
+/**
+ * List Gemini models
+ */
+async function listGeminiModels(apiKey, baseURL) {
+    const url = baseURL || `https://generativelanguage.googleapis.com/v1beta/models?key=${apiKey}`;
+    const response = await fetchWithTimeout(url, {
+        method: "GET",
+    });
+    if (!response.ok) {
+        throw new Error(`Gemini API error: ${response.status}`);
+    }
+    const data = (await response.json());
+    if (!data.models || !Array.isArray(data.models)) {
+        return [];
+    }
+    return data.models
+        .filter((model) => model.name.includes("gemini"))
+        .map((model) => {
+        const parts = model.name.split("/");
+        return parts[parts.length - 1];
+    });
+}
+/**
+ * List Grok models
+ */
+async function listGrokModels(apiKey, baseURL) {
+    const url = baseURL || "https://api.x.ai/v1/models";
+    const response = await fetchWithTimeout(url, {
+        method: "GET",
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`Grok API error: ${response.status}`);
+    }
+    const data = (await response.json());
+    if (!data.data || !Array.isArray(data.data)) {
+        return [];
+    }
+    return data.data.map((model) => model.id);
+}
+/**
+ * List Kimi models
+ */
+async function listKimiModels(apiKey, baseURL) {
+    const url = baseURL || "https://api.moonshot.cn/v1/models";
+    const response = await fetchWithTimeout(url, {
+        method: "GET",
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`Kimi API error: ${response.status}`);
+    }
+    const data = (await response.json());
+    if (!data.data || !Array.isArray(data.data)) {
+        return [];
+    }
+    return data.data.map((model) => model.id);
+}

package/dist/logger.d.ts

@@ -0,0 +1,11 @@
+import { NormalizedUsage, CostBreakdown } from "./core/types";
+/**
+ * Structured logger for LLM usage and costs
+ */
+export declare class Logger {
+    /**
+     * Log usage and cost information
+     */
+    logUsage(usage: NormalizedUsage, cost: CostBreakdown): void;
+}
+export declare const logger: Logger;

package/dist/logger.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = exports.Logger = void 0;
+/**
+ * Structured logger for LLM usage and costs
+ */
+class Logger {
+    /**
+     * Log usage and cost information
+     */
+    logUsage(usage, cost) {
+        const timestamp = new Date().toISOString();
+        console.log(JSON.stringify({
+            timestamp,
+            provider: usage.provider,
+            model: usage.model,
+            tokens: {
+                input: usage.inputTokens,
+                output: usage.outputTokens,
+                total: usage.totalTokens,
+            },
+            cost: {
+                input: cost.inputCost.toFixed(6),
+                output: cost.outputCost.toFixed(6),
+                total: cost.totalCost.toFixed(6),
+            },
+        }));
+    }
+}
+exports.Logger = Logger;
+exports.logger = new Logger();

package/dist/registry.d.ts

@@ -0,0 +1,18 @@
+import { ProviderAdapter, NormalizedUsage } from "./core/types";
+/**
+ * Adapter registry - manages provider detection and normalization
+ */
+declare class AdapterRegistry {
+    private adapters;
+    /**
+     * Register a custom adapter
+     */
+    register(adapter: ProviderAdapter): void;
+    /**
+     * Detect and normalize a response using registered adapters
+     * @returns NormalizedUsage or null if no adapter matches
+     */
+    process(response: unknown, request?: unknown): NormalizedUsage | null;
+}
+export declare const adapterRegistry: AdapterRegistry;
+export {};

package/dist/registry.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adapterRegistry = void 0;
+const adapters_1 = require("./adapters");
+/**
+ * Adapter registry - manages provider detection and normalization
+ */
+class AdapterRegistry {
+    constructor() {
+        this.adapters = [...adapters_1.adapters];
+    }
+    /**
+     * Register a custom adapter
+     */
+    register(adapter) {
+        this.adapters.push(adapter);
+    }
+    /**
+     * Detect and normalize a response using registered adapters
+     * @returns NormalizedUsage or null if no adapter matches
+     */
+    process(response, request) {
+        for (const adapter of this.adapters) {
+            try {
+                if (adapter.detect(response)) {
+                    return adapter.normalize(response, request);
+                }
+            }
+            catch (error) {
+                // If normalize throws, log warning and try next adapter
+                console.warn(`TokenFirewall: Adapter "${adapter.name}" failed to normalize response:`, error);
+                continue;
+            }
+        }
+        return null;
+    }
+}
+exports.adapterRegistry = new AdapterRegistry();

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "tokenfirewall",
+  "version": "1.0.1",
+  "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",
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "llm",
+    "cost",
+    "budget",
+    "openai",
+    "anthropic",
+    "gemini",
+    "grok",
+    "middleware",
+    "token-tracking",
+    "cost-control",
+    "model-discovery"
+  ],
+  "author": "Ruthwik",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Ruthwik000/tokenfirewall.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Ruthwik000/tokenfirewall/issues"
+  },
+  "homepage": "https://github.com/Ruthwik000/tokenfirewall#readme",
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=16.0.0"
+  }
+}