@x12i/ai-gateway 9.7.8 → 10.0.0

package/dist-cjs/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;
-}

package/dist-cjs/optimixer-manager.cjs

@@ -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-cjs/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-cjs/token-estimate.cjs

@@ -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/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;
-};