@x12i/ai-gateway 9.7.8 → 10.0.0

package/dist-cjs/instruction-optimizer.cjs

@@ -4,6 +4,7 @@
  * Uses AI to analyze and fix poorly-written instructions.
  * This is a meta-feature that uses the AI Gateway (via router) to improve AI instructions.
  */
+import { MaxTokensRequiredError } from './instruction-errors.js';
 /**
  * The meta-instructions used to fix other instructions
  * Loaded from instructions-audit.md
@@ -128,6 +129,9 @@ export async function optimizeInstructions(gateway, originalInstructions, option
     if (enforceJsonOutput) {
         additionalContext += '\n\nIMPORTANT: The fixed instructions MUST include strict JSON-only output enforcement rules.';
     }
+    if (typeof internalConfig?.maxTokens !== 'number' || internalConfig.maxTokens <= 0) {
+        throw new MaxTokensRequiredError('maxTokens must be set in internalSystemActions.instructionOptimization for optimizeInstructions');
+    }
     const aiRequestId = `optimize-instructions-${Date.now()}`;
     const identity = {
         ...options.identity,
@@ -149,7 +153,7 @@ export async function optimizeInstructions(gateway, originalInstructions, option
             model,
             provider,
             temperature: internalConfig?.temperature ?? 0.3, // Use internal config or default
-            maxTokens: internalConfig?.maxTokens ?? 4000 // Use internal config or default
+            maxTokens: internalConfig?.maxTokens
         },
         // Use JSON output type to ensure we get structured response
         primaryObjectType: {

package/dist-cjs/message-builder.cjs

@@ -5,137 +5,12 @@
  */
 import { parseTemplate } from './template-parser.js';
 import { mergeGatewayAndRequestTemplateRenderOptions } from './template-render-merge.js';
-import { resolveNestedInstructionsBlock } from './gateway-instructions.js';
 // Type guard
 // AIRequest is distinguished by having primaryObjectType or objectTypes
 // ChatRequest does not have these fields
 function isAIRequest(request) {
     return 'primaryObjectType' in request || ('objectTypes' in request && Array.isArray(request.objectTypes));
 }
-/**
- * Builds input recognition rules
- */
-async function buildInputRecognitionRules(request, config, options) {
-    const { defaultInstructionsBlocks, instructionsBlockOverrides, logger } = config;
-    if (!options.includeInputRecognition || !isAIRequest(request)) {
-        return '';
-    }
-    const rules = [];
-    // Add input recognition rules
-    // Try direct access first (faster, more reliable), then fallback to resolver
-    const rulePaths = [
-        'input.inputRecognitionRule',
-        'input.emptyInputHandling',
-        'input.testInputHandling',
-        'input.inputLocationClarifier'
-    ];
-    const requestInstructionsBlocks = isAIRequest(request) && request.config?.instructionsBlocks
-        ? request.config.instructionsBlocks
-        : undefined;
-    const blockContext = {
-        defaultInstructionsBlocks,
-        instructionsBlockOverrides,
-        requestInstructionsBlocks,
-        config: {},
-        logger
-    };
-    for (const rulePath of rulePaths) {
-        try {
-            // Try direct access to nested structure first
-            const pathParts = rulePath.split('.');
-            let rule;
-            if (pathParts.length === 2) {
-                const [parent, child] = pathParts;
-                const parentObj = defaultInstructionsBlocks[parent];
-                if (parentObj && typeof parentObj === 'object' && !Array.isArray(parentObj)) {
-                    rule = parentObj[child];
-                    if (rule && typeof rule === 'string') {
-                        logger.debug('Resolved rule via direct access', {
-                            rulePath,
-                            valueLength: rule.length
-                        });
-                    }
-                }
-            }
-            // If direct access didn't work, try merged inline overrides / nested defaults
-            if (!rule) {
-                rule = await resolveNestedInstructionsBlock(rulePath, request.agentId || '', request.taskTypeId, blockContext);
-            }
-            if (rule && typeof rule === 'string' && rule.trim() !== '') {
-                rules.push(rule);
-            }
-        }
-        catch (error) {
-            logger.debug('Failed to resolve input rule', {
-                rulePath,
-                error: error instanceof Error ? error.message : String(error)
-            });
-        }
-    }
-    return rules.join('\n\n');
-}
-/**
- * Builds reinforcement rules
- */
-async function buildReinforcementRules(request, config, options) {
-    const { defaultInstructionsBlocks, instructionsBlockOverrides, logger } = config;
-    if (!options.includeReinforcement || !isAIRequest(request)) {
-        return '';
-    }
-    const rules = [];
-    // Add reinforcement rules
-    // Try direct access first (faster, more reliable), then fallback to resolver
-    const rulePaths = [
-        'reinforcement.emptyIsSuccess',
-        'reinforcement.inputAlreadyProvided',
-        'reinforcement.noConversation',
-        'reinforcement.failureIndicators'
-    ];
-    const requestInstructionsBlocks = isAIRequest(request) && request.config?.instructionsBlocks
-        ? request.config.instructionsBlocks
-        : undefined;
-    const blockContext = {
-        defaultInstructionsBlocks,
-        instructionsBlockOverrides,
-        requestInstructionsBlocks,
-        config: {},
-        logger
-    };
-    for (const rulePath of rulePaths) {
-        try {
-            // Try direct access to nested structure first
-            const pathParts = rulePath.split('.');
-            let rule;
-            if (pathParts.length === 2) {
-                const [parent, child] = pathParts;
-                const parentObj = defaultInstructionsBlocks[parent];
-                if (parentObj && typeof parentObj === 'object' && !Array.isArray(parentObj)) {
-                    rule = parentObj[child];
-                    if (rule && typeof rule === 'string') {
-                        logger.debug('Resolved rule via direct access', {
-                            rulePath,
-                            valueLength: rule.length
-                        });
-                    }
-                }
-            }
-            // If direct access didn't work, try merged inline overrides / nested defaults
-            if (!rule) {
-                rule = await resolveNestedInstructionsBlock(rulePath, request.agentId || '', request.taskTypeId, blockContext);
-            }
-            if (rule && typeof rule === 'string' && rule.trim() !== '') {
-                rules.push(rule);
-            }
-        }
-        catch (error) {
-            logger.debug('Failed to resolve reinforcement rule', {
-                rulePath,
-                error: error instanceof Error ? error.message : String(error)
-            });
-        }
-    }
-    return rules.join('\n\n');
-}
 /**
  * Builds user message (prompt + input)
  */
@@ -369,10 +244,9 @@ async function hasFlexMdContract(instructionsText, complianceLevel = 'L0') {
  * Main function to build messages
  */
 export async function buildMessages(request, config, options = {}) {
-    const { useSystemContextFallback = true, includeInputRecognition = true, includeReinforcement = true, parsedSnapshot } = options;
+    const { parsedSnapshot } = options;
     const { logger } = config;
     const messages = [];
-    let usingSystemContext = false;
     // Step 1: Instructions as template text (parsed with full memory context)
     let instructionsText = '';
     // Extract memory context from options
@@ -403,27 +277,14 @@ export async function buildMessages(request, config, options = {}) {
         instructionsText = await parseTemplate(instructionsText, request.workingMemory, undefined, // taskConfig removed - no longer used
         shortTermMemory, experienceMemory, knowledgeMemory, templateRenderOptions, logger);
     }
-    // Step 4: Add input recognition rules
-    const inputRules = await buildInputRecognitionRules(request, config, options);
-    if (inputRules) {
-        instructionsText = `${instructionsText}\n\n${inputRules}`;
-    }
-    // Step 5: Add reinforcement rules
-    const reinforcementRules = await buildReinforcementRules(request, config, options);
-    if (reinforcementRules) {
-        instructionsText = `${instructionsText}\n\n${reinforcementRules}`;
-    }
-    // Step 6: Add system message
-    // CRITICAL: We must have instructions - this is a bad request if we don't
+    // Instructions must be provided explicitly — no packaged block injection
     if (!instructionsText || instructionsText.trim() === '') {
         const errorMessage = 'No instructions available - cannot proceed without clear instructions. This is a bad request.';
         logger.error(errorMessage, {
             jobId: request.identity.jobId,
             agentId: request.agentId,
             hasRequestInstructions: !!request.instructions,
-            instructionType: typeof request.instructions,
-            usedSystemContextFallback: usingSystemContext,
-            systemContextFallbackEnabled: useSystemContextFallback
+            instructionType: typeof request.instructions
         });
         throw new Error(errorMessage);
     }
@@ -515,8 +376,6 @@ export async function buildMessages(request, config, options = {}) {
     });
     return {
         messages,
-        metadata: {
-            usingSystemContext
-        }
+        metadata: {}
     };
 }

package/dist-cjs/message-builder.d.ts

@@ -8,17 +8,11 @@ import type { TemplateRenderOptions } from '@x12i/rendrix';
 import type { Logxer } from '@x12i/logxer';
 type Request = ChatRequest | AIRequest;
 export interface MessageBuilderConfig {
-    defaultInstructionsBlocks: Record<string, any>;
-    /** Flat block overrides from gateway `instructionsBlocks` (merged at init). */
-    instructionsBlockOverrides: Record<string, string>;
     logger: Logxer;
     /** From packaged defaults + gateway `templateRendering`; merged per request with `templateRenderOptions`. */
     templateRendering?: TemplateRenderOptions;
 }
 export interface BuildMessagesOptions {
-    useSystemContextFallback?: boolean;
-    includeInputRecognition?: boolean;
-    includeReinforcement?: boolean;
     parsedSnapshot?: any;
     shortTermMemory?: Record<string, any>;
     experienceMemory?: Record<string, any>;

package/dist-cjs/types.d.ts

@@ -398,9 +398,10 @@ export interface GatewayConfig extends Omit<RouterConfig, 'defaultEngine' | 'log
         prefer?: boolean;
     };
     /**
-     * Operational mode override (`process.env.mode` / `MODE` when omitted).
-     * - `prod`: unresolved models fall back to {@link AI_GATEWAY_DEFAULT_MODEL} / packaged default (with Logxer warn).
-     * - `dev` / `debug`: unresolved models throw {@link ModelResolutionError} from `@x12i/ai-tools`.
+     * Operational mode override (`process.env.mode` / `MODE` when omitted; default `debug`).
+     * Downstream hosts (ai-skills, ai-tasks, graph-engine) should expose this to their clients.
+     * - `dev` / `debug`: unresolved profile/model names throw {@link ModelResolutionError} from `@x12i/ai-tools` when catalog resolution is enabled.
+     * - `prod`: same strict resolution — every invoke must include an explicit `model`; the gateway never substitutes a packaged or env default.
      */
     mode?: 'dev' | 'debug' | 'prod';
     /**
@@ -421,70 +422,24 @@ export interface GatewayConfig extends Omit<RouterConfig, 'defaultEngine' | 'log
         costIncludeBreakdown?: boolean;
     };
     /**
-     * Adaptive `max_tokens` via @x12i/optimixer (embedded Activix mode).
-     * When enabled, the gateway predicts completion budget before each LLM call unless
-     * the caller explicitly sets `maxTokens` on the request / modelConfig / gateway config.
-     */
-    optimixer?: {
-        /** @default false */
-        enabled?: boolean;
-        acceptableRisk?: 'very-low' | 'low' | 'medium' | 'high' | number;
-        /** Cap predicted max tokens with flex-md model limit when available. @default true */
-        useFlexMdCeiling?: boolean;
-        /** Passed to Optimixer warmup on create. */
-        warmupLimit?: number;
-    };
-    /**
-     * InstructionsBlocks overrides
-     * Key: block name, Value: block content
-     */
-    instructionsBlocks?: Record<string, string>;
-    /**
-     * Default temperature for LLM requests
+     * Default temperature for LLM requests when not set on the invoke request.
+     * @default 0.7 — see {@link GATEWAY_DEFAULT_TEMPERATURE} in `@x12i/ai-gateway`.
      */
     temperature?: number;
     /**
-     * Other LLM config options
+     * Gateway-wide completion budget. Merged when the invoke does not set `maxTokens` on
+     * `request.config` / `modelConfig` (lower priority than per-request values).
+     * Every invoke must end up with a positive `maxTokens` after merge — no code default.
      */
     maxTokens?: number;
     topP?: number;
     frequencyPenalty?: number;
     presencePenalty?: number;
     /**
-     * Retry configuration for network and server errors
+     * Retry configuration for network and server errors on provider invoke.
+     * Defaults: {@link GATEWAY_DEFAULT_RETRY}. Override per request via `request.retry` or `request.config.retry`.
      */
     retry?: RetryConfig;
-    /**
-     * Rate limiting configuration
-     * Smart rate limiting that tracks when the last API call was made
-     * and only waits if necessary to maintain minimum intervals between calls.
-     * Applied automatically to all provider calls via router interceptors.
-     */
-    rateLimit?: {
-        /**
-         * Enable rate limiting
-         * @default true
-         */
-        enabled?: boolean;
-        /**
-         * Default minimum interval in milliseconds between API calls (used if provider-specific not set)
-         * @default 500
-         */
-        defaultMinIntervalMs?: number;
-        /**
-         * Per-provider minimum intervals in milliseconds
-         * Key: provider name (e.g., 'openai', 'grok')
-         * Value: minimum milliseconds between calls for that provider
-         *
-         * @example
-         * {
-         *   openai: 500,  // 500ms between OpenAI calls
-         *   grok: 1000,   // 1 second between Grok calls
-         *   anthropic: 300  // 300ms between Anthropic calls
-         * }
-         */
-        providerIntervals?: Record<string, number>;
-    };
     /**
      * Default task configuration for template rendering
      * @deprecated taskConfig is no longer used by Rendrix 3.0.0+
@@ -744,6 +699,10 @@ interface BaseLLMRequest extends Omit<LLMRequest, 'messages' | 'input' | 'reques
      * Merged the same way as `smartInput`; `templateRenderOptions.smartInputRenderOptions` wins when both are set.
      */
     smartInputRenderOptions?: SmartInputRenderOptions;
+    /**
+     * Per-request retry overrides (merged over gateway `retry` and {@link GATEWAY_DEFAULT_RETRY}).
+     */
+    retry?: RetryConfig;
     /**
      * Messages array - Optional, can be used instead of instructions/prompt
      * If provided, will be appended as-is after built messages; instructions template text is still parsed for the system message when present
@@ -1089,7 +1048,7 @@ export interface EnhancedLLMResponse<TContent = unknown> extends Omit<AIResponse
         usage?: GatewayTraceUsageSummary;
         /**
          * Merged gateway/router generation config actually used for the invocation (after
-         * {@link mergeConfig}: modelConfig / request.config / defaults / flex-md maxTokens).
+         * {@link mergeConfig}: modelConfig / request.config / gateway maxTokens).
          * Only populated when diagnostics trace mode is enabled.
          */
         mergedRouterConfig?: GatewayTraceMergedConfig;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@x12i/ai-gateway",
-  "version": "9.7.8",
+  "version": "10.0.0",
   "description": "AI Gateway - Unified interface for LLM provider routing and management",
   "type": "module",
   "exports": {
@@ -43,10 +43,9 @@
   "dependencies": {
     "@x12i/activix": "^8.5.0",
     "@x12i/ai-providers-router": "^4.9.2",
-    "@x12i/ai-tools": "^2.2.0",
+    "@x12i/ai-tools": "^2.3.0",
     "@x12i/flex-md": "^4.8.0",
     "@x12i/logxer": "^4.6.0",
-    "@x12i/optimixer": "^2.4.4",
     "@x12i/rendrix": "^4.3.0"
   },
   "devDependencies": {

package/dist/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/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/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/gateway-instructions.js

@@ -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/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/gateway-rate-limiter-constants.js

@@ -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/gateway-rate-limiter.d.ts

@@ -1,56 +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 type { Logxer } from '@x12i/logxer';
-/**
- * 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 declare class GatewayRateLimiter {
-    private lastCallTimes;
-    private defaultMinIntervalMs;
-    private providerIntervals;
-    private logger?;
-    constructor(defaultMinIntervalMs?: number, providerIntervals?: Record<string, number>, logger?: Logxer);
-    /**
-     * Gets the minimum interval for a specific provider
-     * Falls back to default if provider-specific interval not set
-     */
-    private getMinIntervalForProvider;
-    /**
-     * 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
-     */
-    waitIfNeeded(provider?: string): Promise<void>;
-    /**
-     * 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?: string): void;
-    /**
-     * Gets the time since the last call for a provider
-     */
-    getTimeSinceLastCall(provider?: string): number;
-    /**
-     * Resets the rate limiter for a provider (useful for testing or reset scenarios)
-     */
-    reset(provider?: string): void;
-}