@x12i/ai-gateway 9.7.9 → 10.0.1

package/dist/gateway-rate-limiter.js

@@ -1,107 +0,0 @@
-/**
- * Gateway Rate Limiter
- *
- * Smart rate limiting for BETWEEN-CALLS (not retries).
- *
- * Two types of rate limiting in the system:
- * 1. RETRY delays (in gateway-retry.ts) - Simple sleep, not smart. Used when retrying after errors.
- * 2. BETWEEN-CALLS rate limiting (this class) - Smart, tracks last call time and only waits if needed.
- *
- * This class handles #2: it tracks when the last API call was made per provider
- * and only waits if necessary to maintain minimum intervals between separate API calls.
- * This prevents unnecessary delays when enough time has already passed.
- */
-import { sleep } from './gateway-retry.js';
-import { DEFAULT_RATE_LIMIT_MIN_INTERVAL_MS } from './gateway-rate-limiter-constants.js';
-/**
- * Smart Rate Limiter (Between-Calls Only)
- *
- * Tracks the last API call time per provider and only waits if necessary.
- * Supports per-provider rate limits with safe defaults.
- *
- * NOTE: This is for BETWEEN-CALLS rate limiting (smart).
- * Retry delays are handled separately in gateway-retry.ts (simple sleep).
- *
- * This ensures minimum intervals between separate API calls regardless of what happens between them.
- */
-export class GatewayRateLimiter {
-    lastCallTimes = new Map(); // provider -> last call timestamp
-    defaultMinIntervalMs;
-    providerIntervals = new Map(); // provider -> min interval
-    logger;
-    constructor(defaultMinIntervalMs = DEFAULT_RATE_LIMIT_MIN_INTERVAL_MS, providerIntervals, logger) {
-        this.defaultMinIntervalMs = defaultMinIntervalMs;
-        this.logger = logger;
-        // Store per-provider intervals
-        if (providerIntervals) {
-            for (const [provider, interval] of Object.entries(providerIntervals)) {
-                this.providerIntervals.set(provider.toLowerCase(), interval);
-            }
-        }
-    }
-    /**
-     * Gets the minimum interval for a specific provider
-     * Falls back to default if provider-specific interval not set
-     */
-    getMinIntervalForProvider(provider) {
-        const providerKey = provider.toLowerCase();
-        return this.providerIntervals.get(providerKey) ?? this.defaultMinIntervalMs;
-    }
-    /**
-     * Waits only if necessary to maintain the minimum interval between calls for a provider
-     * @param provider - Provider name (e.g., 'openai', 'grok')
-     * @returns Promise that resolves when it's safe to make the next call
-     */
-    async waitIfNeeded(provider = 'global') {
-        const minIntervalMs = this.getMinIntervalForProvider(provider);
-        const now = Date.now();
-        const lastCallTime = this.lastCallTimes.get(provider) || 0;
-        const timeSinceLastCall = now - lastCallTime;
-        if (timeSinceLastCall < minIntervalMs) {
-            const waitTime = minIntervalMs - timeSinceLastCall;
-            this.logger?.debug('Rate limiting: waiting before API call', {
-                provider,
-                waitTimeMs: waitTime,
-                timeSinceLastCallMs: timeSinceLastCall,
-                minIntervalMs,
-                usingProviderSpecific: this.providerIntervals.has(provider.toLowerCase())
-            });
-            await sleep(waitTime);
-        }
-        else {
-            this.logger?.verbose('Rate limit OK: enough time has passed', {
-                provider,
-                timeSinceLastCallMs: timeSinceLastCall,
-                minIntervalMs,
-                usingProviderSpecific: this.providerIntervals.has(provider.toLowerCase())
-            });
-        }
-        // Record the call time (after waiting if needed)
-        this.lastCallTimes.set(provider, Date.now());
-    }
-    /**
-     * Records that an API call was made (call this after the API call completes)
-     * This ensures we track the actual call time, accounting for call duration
-     */
-    recordCall(provider = 'global') {
-        this.lastCallTimes.set(provider, Date.now());
-    }
-    /**
-     * Gets the time since the last call for a provider
-     */
-    getTimeSinceLastCall(provider = 'global') {
-        const lastCallTime = this.lastCallTimes.get(provider) || 0;
-        return Date.now() - lastCallTime;
-    }
-    /**
-     * Resets the rate limiter for a provider (useful for testing or reset scenarios)
-     */
-    reset(provider) {
-        if (provider) {
-            this.lastCallTimes.delete(provider);
-        }
-        else {
-            this.lastCallTimes.clear();
-        }
-    }
-}

package/dist/optimixer-manager.d.ts

@@ -1,33 +0,0 @@
-import type { AiMaxTokensActualUsage, AiMaxTokensPredictionResult } from '@x12i/optimixer';
-import type { Activix } from '@x12i/activix';
-import type { Logxer } from '@x12i/logxer';
-import type { ChatRequest, GatewayConfig } from './types.js';
-export type OptimixerGatewayConfig = NonNullable<GatewayConfig['optimixer']>;
-export interface OptimixerManagerConfig {
-    optimixer?: OptimixerGatewayConfig;
-    logger: Logxer;
-    getActivix: () => Promise<Activix | undefined>;
-}
-export type OptimixerMaxTokensContext = {
-    request: ChatRequest;
-    mergedConfig: ChatRequest['config'];
-    messages: Array<{
-        role?: string;
-        content?: unknown;
-    }>;
-};
-export declare class OptimixerManager {
-    private readonly config;
-    private readonly logger;
-    private readonly getActivix;
-    private optimixer?;
-    private initPromise?;
-    private readonly activixCollection;
-    constructor(config: OptimixerManagerConfig);
-    isEnabled(): boolean;
-    private ensureReady;
-    private initialize;
-    predictMaxTokens(ctx: OptimixerMaxTokensContext): Promise<AiMaxTokensPredictionResult | undefined>;
-    completePrediction(requestId: string, actual: AiMaxTokensActualUsage): Promise<void>;
-    shutdown(): Promise<void>;
-}

package/dist/optimixer-manager.js

@@ -1,142 +0,0 @@
-import { Optimixer } from '@x12i/optimixer';
-import { exceptionEvidence, fieldEvidence, GatewayLogCode, gatewayWarnCode } from './gateway-log-diagnostics.js';
-import { resolveActivityTrackingConfig } from './config/activity-tracking-config.js';
-import { estimateMessagesTokenSizes } from './token-estimate.js';
-/** Optimixer bucket key: prefer taskTypeId (template), then identity actionType, else gateway default. */
-function resolveTemplateId(request) {
-    if (request.taskTypeId && String(request.taskTypeId).trim()) {
-        return String(request.taskTypeId).trim();
-    }
-    const identity = request.identity;
-    if (identity?.actionType && String(identity.actionType).trim()) {
-        return String(identity.actionType).trim();
-    }
-    return 'gateway.invoke';
-}
-function toActivixRunContext(identity) {
-    if (!identity)
-        return undefined;
-    return identity;
-}
-export class OptimixerManager {
-    config;
-    logger;
-    getActivix;
-    optimixer;
-    initPromise;
-    activixCollection;
-    constructor(config) {
-        this.config = config.optimixer;
-        this.logger = config.logger;
-        this.getActivix = config.getActivix;
-        this.activixCollection = resolveActivityTrackingConfig().collectionName;
-    }
-    isEnabled() {
-        return this.config?.enabled === true;
-    }
-    async ensureReady() {
-        if (!this.isEnabled())
-            return undefined;
-        if (this.optimixer)
-            return this.optimixer;
-        if (!this.initPromise) {
-            this.initPromise = this.initialize();
-        }
-        await this.initPromise;
-        return this.optimixer;
-    }
-    async initialize() {
-        const activix = await this.getActivix();
-        if (!activix) {
-            gatewayWarnCode(this.logger, GatewayLogCode.OPTIMIXER_ACTIVIX_UNAVAILABLE, undefined, {
-                activixCollection: this.activixCollection,
-                evidence: [fieldEvidence('activixCollection', this.activixCollection)]
-            });
-            return;
-        }
-        try {
-            this.optimixer = await Optimixer.create({
-                activixClient: activix,
-                activixCollection: this.activixCollection,
-                pipelines: { aiMaxTokens: { enabled: true } },
-                ...(typeof this.config?.warmupLimit === 'number' ? { warmupLimit: this.config.warmupLimit } : {})
-            });
-            this.logger.info('Optimixer initialized for adaptive max_tokens', {
-                activixCollection: this.activixCollection,
-                acceptableRisk: this.config?.acceptableRisk ?? 'medium'
-            });
-        }
-        catch (error) {
-            gatewayWarnCode(this.logger, GatewayLogCode.OPTIMIXER_INIT_FAILED, undefined, {
-                error: error instanceof Error ? error.message : String(error),
-                evidence: [
-                    fieldEvidence('activixCollection', this.activixCollection),
-                    ...(error instanceof Error ? [exceptionEvidence(error)] : [])
-                ]
-            });
-            this.optimixer = undefined;
-        }
-    }
-    async predictMaxTokens(ctx) {
-        const optimixer = await this.ensureReady();
-        if (!optimixer)
-            return undefined;
-        const { request, mergedConfig, messages } = ctx;
-        const { inputSize, contextSize } = estimateMessagesTokenSizes(messages);
-        const acceptableRisk = this.config?.acceptableRisk ?? 'medium';
-        const provider = typeof mergedConfig?.provider === 'string' ? mergedConfig.provider : undefined;
-        const model = typeof mergedConfig?.model === 'string' ? mergedConfig.model : undefined;
-        try {
-            return await optimixer.predictAiMaxTokens({
-                templateId: resolveTemplateId(request),
-                inputSize,
-                contextSize,
-                acceptableRisk,
-                runContext: toActivixRunContext(request.identity),
-                ...(provider || model
-                    ? { modelProfile: { ...(provider ? { provider } : {}), ...(model ? { model } : {}) } }
-                    : {})
-            });
-        }
-        catch (error) {
-            gatewayWarnCode(this.logger, GatewayLogCode.OPTIMIXER_PREDICT_FAILED, request.identity, {
-                error: error instanceof Error ? error.message : String(error),
-                aiRequestId: request.aiRequestId,
-                evidence: [
-                    fieldEvidence('aiRequestId', request.aiRequestId),
-                    ...(error instanceof Error ? [exceptionEvidence(error)] : [])
-                ]
-            });
-            return undefined;
-        }
-    }
-    async completePrediction(requestId, actual) {
-        const optimixer = await this.ensureReady();
-        if (!optimixer)
-            return;
-        try {
-            await optimixer.completeAiMaxTokensPrediction({ requestId, actual });
-        }
-        catch (error) {
-            this.logger.warn('Optimixer completeAiMaxTokensPrediction failed (non-blocking)', {
-                requestId,
-                error: error instanceof Error ? error.message : String(error)
-            });
-        }
-    }
-    async shutdown() {
-        const optimixer = this.optimixer;
-        this.optimixer = undefined;
-        this.initPromise = undefined;
-        if (optimixer) {
-            try {
-                await optimixer.close();
-            }
-            catch (error) {
-                this.logger.warn('OptimixerManager shutdown: close failed (non-blocking)', {
-                    error: error instanceof Error ? error.message : String(error)
-                });
-            }
-        }
-    }
-}

package/dist/token-estimate.d.ts

@@ -1,12 +0,0 @@
-/**
- * Lightweight token-size estimates for Optimixer predict inputs.
- * Uses a chars/4 heuristic (no tiktoken dependency).
- */
-export declare function estimateTextTokens(text: string): number;
-export declare function estimateMessagesTokenSizes(messages: Array<{
-    role?: string;
-    content?: unknown;
-}>): {
-    inputSize: number;
-    contextSize: number;
-};

package/dist/token-estimate.js

@@ -1,30 +0,0 @@
-/**
- * Lightweight token-size estimates for Optimixer predict inputs.
- * Uses a chars/4 heuristic (no tiktoken dependency).
- */
-export function estimateTextTokens(text) {
-    const trimmed = text.trim();
-    if (!trimmed)
-        return 0;
-    return Math.max(1, Math.ceil(trimmed.length / 4));
-}
-export function estimateMessagesTokenSizes(messages) {
-    let inputSize = 0;
-    let contextSize = 0;
-    for (const message of messages) {
-        const role = typeof message.role === 'string' ? message.role.toLowerCase() : '';
-        const content = typeof message.content === 'string'
-            ? message.content
-            : message.content != null
-                ? JSON.stringify(message.content)
-                : '';
-        const tokens = estimateTextTokens(content);
-        if (role === 'system') {
-            contextSize += tokens;
-        }
-        else {
-            inputSize += tokens;
-        }
-    }
-    return { inputSize, contextSize };
-}

package/dist-cjs/defaults/instructions-blocks.json

@@ -1,61 +0,0 @@
-{
-  "system-context": "You are performing the following task: {{taskDescription}}. Follow the instructions provided and respond according to the specified output format. Never ask follow-up questions.",
-  
-  "input": {
-    "inputLabel": "INPUT:",
-    "inputPrefix": "INPUT DATA (process this now):",
-    "defaultPromptTemplate": "{{input}}",
-    "inputRecognitionRule": "The user message below is the complete input to process. It has already been provided. Do not ask for more input.",
-    "emptyInputHandling": "If input appears empty or minimal (e.g., 'No emails here', 'none', 'empty'), this IS valid input. Process it and return the success schema with empty arrays/values where appropriate.",
-    "testInputHandling": "Even if input contains words like 'test', 'invalid', 'placeholder', or 'example', treat it as real input. Reply in Markdown. Return your entire answer inside a single ```markdown fenced block.",
-    "inputLocationClarifier": "The user's message below is your input data. Please process it now. Reply in Markdown. Return your entire answer inside a single ```markdown fenced block."
-  },
-  
-  "errorSchemas": {
-    "instructions-error": {
-      "type": "object",
-      "additionalProperties": false,
-      "properties": {
-        "error": {
-          "type": "string",
-          "description": "What is wrong with the instructions that prevents completion."
-        },
-        "errorType": {
-          "type": "string",
-          "enum": ["bad-instructions", "missing-context", "bad-context"]
-        },
-        "suggestion": {
-          "type": "string",
-          "description": "How to fix the instruction issue."
-        }
-      },
-      "required": ["error", "errorType"]
-    },
-    "prompt-error": {
-      "type": "object",
-      "additionalProperties": false,
-      "properties": {
-        "error": {
-          "type": "string",
-          "description": "What is wrong with the input that prevents completion."
-        },
-        "errorType": {
-          "type": "string",
-          "enum": ["missing-input", "bad-input"]
-        },
-        "suggestion": {
-          "type": "string",
-          "description": "How to fix the input issue."
-        }
-      },
-      "required": ["error", "errorType"]
-    }
-  },
-  
-  "reinforcement": {
-    "emptyIsSuccess": "Empty results (e.g., items: []) are SUCCESS cases, not errors.",
-    "inputAlreadyProvided": "The input has been provided in the user message. Process it immediately.",
-    "noConversation": "You are not having a conversation. Reply in Markdown. Return your entire answer inside a single ```markdown fenced block.",
-    "failureIndicators": "If you write prose text outside the fenced block, you have FAILED. If you ask a question, you have FAILED. If you explain anything outside the ```markdown fenced block, you have FAILED."
-  }
-}

package/dist-cjs/defaults/model-config.json

@@ -1,15 +0,0 @@
-{
-  "defaultEngine": "openrouter",
-  "defaultModel": "cheap",
-  "temperature": 0.7,
-  "topP": 1.0,
-  "frequencyPenalty": 0.0,
-  "presencePenalty": 0.0,
-  "rateLimit": {
-    "defaultMinIntervalMs": 500,
-    "enabled": true
-  },
-  "retry": {
-    "throttlingDelay": 5000
-  }
-}

package/dist-cjs/gateway-instructions.cjs

@@ -1,62 +0,0 @@
-/**
- * Gateway Instructions Module
- * Handles instructions block resolution from inline config only (no content registry).
- */
-import { InstructionNotFoundError } from './instruction-errors.js';
-function getNestedString(blocks, dotPath) {
-    const parts = dotPath.split('.');
-    let cur = blocks;
-    for (const p of parts) {
-        if (cur == null || typeof cur !== 'object')
-            return undefined;
-        cur = cur[p];
-    }
-    return typeof cur === 'string' ? cur : undefined;
-}
-/**
- * Resolves nested instructionsBlocks (e.g., "input.inputRecognitionRule")
- * Supports dot notation for nested object access in defaultInstructionsBlocks,
- * then flat keys in merged overrides.
- */
-export async function resolveNestedInstructionsBlock(blockPath, _agentId, _taskTypeId, context) {
-    return resolveInstructionsBlock(blockPath, _agentId, _taskTypeId, context);
-}
-/**
- * Resolves instructionsBlocks from config overrides, request overrides, nested defaults, or flat defaults.
- */
-export async function resolveInstructionsBlock(blockName, agentId, taskTypeId, context) {
-    const { config, logger, defaultInstructionsBlocks, instructionsBlockOverrides, requestInstructionsBlocks } = context;
-    logger.verbose('Resolving instructionsBlock', {
-        blockName,
-        agentId,
-        taskTypeId,
-        hasConfigOverride: !!config.instructionsBlocks?.[blockName]
-    });
-    const configOverride = config.instructionsBlocks?.[blockName];
-    if (typeof configOverride === 'string' && configOverride.trim()) {
-        logger.debug('Using per-call config override for instructionsBlock', { blockName, agentId });
-        return configOverride;
-    }
-    const fromRequest = requestInstructionsBlocks?.[blockName];
-    if (typeof fromRequest === 'string' && fromRequest.trim()) {
-        logger.debug('Using request.config.instructionsBlocks for instructionsBlock', { blockName, agentId });
-        return fromRequest;
-    }
-    const fromGateway = instructionsBlockOverrides[blockName];
-    if (typeof fromGateway === 'string' && fromGateway.trim()) {
-        logger.debug('Using gateway instructionsBlocks override for instructionsBlock', { blockName, agentId });
-        return fromGateway;
-    }
-    const nested = getNestedString(defaultInstructionsBlocks, blockName);
-    if (nested?.trim()) {
-        logger.debug('Using nested defaultInstructionsBlocks for instructionsBlock', { blockName, agentId });
-        return nested;
-    }
-    throw new InstructionNotFoundError(blockName, 'instructions-blocks', `InstructionsBlock "${blockName}" not found. Provide it via packaged defaults, gateway instructionsBlocks, or request.config.instructionsBlocks.`, blockName);
-}
-/**
- * Pre-parse instructions string for stable hashing (taskTypeId). No external resolution.
- */
-export function getPreParsedInstructions(instructions) {
-    return instructions ?? '';
-}

package/dist-cjs/gateway-instructions.d.ts

@@ -1,30 +0,0 @@
-/**
- * Gateway Instructions Module
- * Handles instructions block resolution from inline config only (no content registry).
- */
-import type { Logxer } from '@x12i/logxer';
-export interface InstructionsContext {
-    defaultInstructionsBlocks: Record<string, any>;
-    /** Flat overrides from gateway `instructionsBlocks` (merged at init). */
-    instructionsBlockOverrides: Record<string, string>;
-    /** Per-request flat overrides from `request.config.instructionsBlocks`. */
-    requestInstructionsBlocks?: Record<string, string>;
-    config: {
-        instructionsBlocks?: Record<string, any>;
-    };
-    logger: Logxer;
-}
-/**
- * Resolves nested instructionsBlocks (e.g., "input.inputRecognitionRule")
- * Supports dot notation for nested object access in defaultInstructionsBlocks,
- * then flat keys in merged overrides.
- */
-export declare function resolveNestedInstructionsBlock(blockPath: string, _agentId: string, _taskTypeId: string | undefined, context: InstructionsContext): Promise<string>;
-/**
- * Resolves instructionsBlocks from config overrides, request overrides, nested defaults, or flat defaults.
- */
-export declare function resolveInstructionsBlock(blockName: string, agentId: string, taskTypeId: string | undefined, context: InstructionsContext): Promise<string>;
-/**
- * Pre-parse instructions string for stable hashing (taskTypeId). No external resolution.
- */
-export declare function getPreParsedInstructions(instructions: string | undefined): string;

package/dist-cjs/gateway-rate-limiter-constants.cjs

@@ -1,16 +0,0 @@
-/**
- * Rate Limiter Constants
- *
- * Default values for rate limiting configuration.
- * These defaults ensure the system works safely even if config is missing.
- */
-/**
- * Default minimum interval between API calls (in milliseconds)
- * Used when rateLimit.defaultMinIntervalMs is not specified
- */
-export const DEFAULT_RATE_LIMIT_MIN_INTERVAL_MS = 500;
-/**
- * Default enabled state for rate limiting
- * Used when rateLimit.enabled is not specified
- */
-export const DEFAULT_RATE_LIMIT_ENABLED = true;

package/dist-cjs/gateway-rate-limiter-constants.d.ts

@@ -1,16 +0,0 @@
-/**
- * Rate Limiter Constants
- *
- * Default values for rate limiting configuration.
- * These defaults ensure the system works safely even if config is missing.
- */
-/**
- * Default minimum interval between API calls (in milliseconds)
- * Used when rateLimit.defaultMinIntervalMs is not specified
- */
-export declare const DEFAULT_RATE_LIMIT_MIN_INTERVAL_MS = 500;
-/**
- * Default enabled state for rate limiting
- * Used when rateLimit.enabled is not specified
- */
-export declare const DEFAULT_RATE_LIMIT_ENABLED = true;

package/dist-cjs/gateway-rate-limiter.cjs

@@ -1,107 +0,0 @@
-/**
- * Gateway Rate Limiter
- *
- * Smart rate limiting for BETWEEN-CALLS (not retries).
- *
- * Two types of rate limiting in the system:
- * 1. RETRY delays (in gateway-retry.ts) - Simple sleep, not smart. Used when retrying after errors.
- * 2. BETWEEN-CALLS rate limiting (this class) - Smart, tracks last call time and only waits if needed.
- *
- * This class handles #2: it tracks when the last API call was made per provider
- * and only waits if necessary to maintain minimum intervals between separate API calls.
- * This prevents unnecessary delays when enough time has already passed.
- */
-import { sleep } from './gateway-retry.js';
-import { DEFAULT_RATE_LIMIT_MIN_INTERVAL_MS } from './gateway-rate-limiter-constants.js';
-/**
- * Smart Rate Limiter (Between-Calls Only)
- *
- * Tracks the last API call time per provider and only waits if necessary.
- * Supports per-provider rate limits with safe defaults.
- *
- * NOTE: This is for BETWEEN-CALLS rate limiting (smart).
- * Retry delays are handled separately in gateway-retry.ts (simple sleep).
- *
- * This ensures minimum intervals between separate API calls regardless of what happens between them.
- */
-export class GatewayRateLimiter {
-    lastCallTimes = new Map(); // provider -> last call timestamp
-    defaultMinIntervalMs;
-    providerIntervals = new Map(); // provider -> min interval
-    logger;
-    constructor(defaultMinIntervalMs = DEFAULT_RATE_LIMIT_MIN_INTERVAL_MS, providerIntervals, logger) {
-        this.defaultMinIntervalMs = defaultMinIntervalMs;
-        this.logger = logger;
-        // Store per-provider intervals
-        if (providerIntervals) {
-            for (const [provider, interval] of Object.entries(providerIntervals)) {
-                this.providerIntervals.set(provider.toLowerCase(), interval);
-            }
-        }
-    }
-    /**
-     * Gets the minimum interval for a specific provider
-     * Falls back to default if provider-specific interval not set
-     */
-    getMinIntervalForProvider(provider) {
-        const providerKey = provider.toLowerCase();
-        return this.providerIntervals.get(providerKey) ?? this.defaultMinIntervalMs;
-    }
-    /**
-     * Waits only if necessary to maintain the minimum interval between calls for a provider
-     * @param provider - Provider name (e.g., 'openai', 'grok')
-     * @returns Promise that resolves when it's safe to make the next call
-     */
-    async waitIfNeeded(provider = 'global') {
-        const minIntervalMs = this.getMinIntervalForProvider(provider);
-        const now = Date.now();
-        const lastCallTime = this.lastCallTimes.get(provider) || 0;
-        const timeSinceLastCall = now - lastCallTime;
-        if (timeSinceLastCall < minIntervalMs) {
-            const waitTime = minIntervalMs - timeSinceLastCall;
-            this.logger?.debug('Rate limiting: waiting before API call', {
-                provider,
-                waitTimeMs: waitTime,
-                timeSinceLastCallMs: timeSinceLastCall,
-                minIntervalMs,
-                usingProviderSpecific: this.providerIntervals.has(provider.toLowerCase())
-            });
-            await sleep(waitTime);
-        }
-        else {
-            this.logger?.verbose('Rate limit OK: enough time has passed', {
-                provider,
-                timeSinceLastCallMs: timeSinceLastCall,
-                minIntervalMs,
-                usingProviderSpecific: this.providerIntervals.has(provider.toLowerCase())
-            });
-        }
-        // Record the call time (after waiting if needed)
-        this.lastCallTimes.set(provider, Date.now());
-    }
-    /**
-     * Records that an API call was made (call this after the API call completes)
-     * This ensures we track the actual call time, accounting for call duration
-     */
-    recordCall(provider = 'global') {
-        this.lastCallTimes.set(provider, Date.now());
-    }
-    /**
-     * Gets the time since the last call for a provider
-     */
-    getTimeSinceLastCall(provider = 'global') {
-        const lastCallTime = this.lastCallTimes.get(provider) || 0;
-        return Date.now() - lastCallTime;
-    }
-    /**
-     * Resets the rate limiter for a provider (useful for testing or reset scenarios)
-     */
-    reset(provider) {
-        if (provider) {
-            this.lastCallTimes.delete(provider);
-        }
-        else {
-            this.lastCallTimes.clear();
-        }
-    }
-}