@lov3kaizen/agentsea-gateway 0.5.1

package/dist/index.d.ts

@@ -0,0 +1,759 @@
+import { EventEmitter } from 'events';
+import { Hono } from 'hono';
+import { ServerType } from '@hono/node-server';
+
+interface ChatMessage {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string | ContentPart[] | null;
+    name?: string;
+    tool_calls?: ToolCall[];
+    tool_call_id?: string;
+}
+interface ContentPart {
+    type: 'text' | 'image_url';
+    text?: string;
+    image_url?: {
+        url: string;
+        detail?: 'auto' | 'low' | 'high';
+    };
+}
+interface ToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+interface Tool {
+    type: 'function';
+    function: {
+        name: string;
+        description?: string;
+        parameters?: Record<string, unknown>;
+    };
+}
+interface ChatCompletionRequest {
+    model: string;
+    messages: ChatMessage[];
+    temperature?: number;
+    max_tokens?: number;
+    top_p?: number;
+    frequency_penalty?: number;
+    presence_penalty?: number;
+    stop?: string | string[];
+    stream?: boolean;
+    tools?: Tool[];
+    tool_choice?: 'none' | 'auto' | 'required' | {
+        type: 'function';
+        function: {
+            name: string;
+        };
+    };
+    response_format?: {
+        type: 'text' | 'json_object';
+    };
+    seed?: number;
+    user?: string;
+    _gateway?: GatewayRequestMetadata;
+}
+interface GatewayRequestMetadata {
+    tenantId?: string;
+    requestId?: string;
+    routingHint?: string;
+    preferredProvider?: string;
+    excludeProviders?: string[];
+    maxCost?: number;
+    maxLatency?: number;
+    cachePolicy?: 'default' | 'no-cache' | 'force-cache';
+    tags?: Record<string, string>;
+}
+interface ChatCompletionResponse {
+    id: string;
+    object: 'chat.completion';
+    created: number;
+    model: string;
+    choices: ChatCompletionChoice[];
+    usage: UsageInfo;
+    system_fingerprint?: string;
+    _gateway?: GatewayResponseMetadata;
+}
+interface ChatCompletionChoice {
+    index: number;
+    message: ChatMessage;
+    finish_reason: 'stop' | 'length' | 'tool_calls' | 'content_filter' | null;
+    logprobs?: unknown;
+}
+interface UsageInfo {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+}
+interface GatewayResponseMetadata {
+    provider: string;
+    originalModel: string;
+    latencyMs: number;
+    cost: number;
+    cached: boolean;
+    cacheKey?: string;
+    retries: number;
+    routingDecision?: RoutingDecision;
+}
+interface ChatCompletionChunk {
+    id: string;
+    object: 'chat.completion.chunk';
+    created: number;
+    model: string;
+    choices: ChatCompletionChunkChoice[];
+    system_fingerprint?: string;
+    usage?: UsageInfo;
+}
+interface ChatCompletionChunkChoice {
+    index: number;
+    delta: Partial<ChatMessage>;
+    finish_reason: 'stop' | 'length' | 'tool_calls' | 'content_filter' | null;
+    logprobs?: unknown;
+}
+interface ProviderConfig {
+    name: string;
+    apiKey?: string;
+    baseUrl?: string;
+    models: string[];
+    timeout?: number;
+    maxRetries?: number;
+    headers?: Record<string, string>;
+    metadata?: Record<string, unknown>;
+}
+interface ProviderHealth {
+    status: 'healthy' | 'degraded' | 'unhealthy';
+    latencyMs: number;
+    lastCheck: Date;
+    errorRate: number;
+    consecutiveFailures: number;
+}
+interface ModelInfo {
+    id: string;
+    provider: string;
+    contextWindow: number;
+    maxOutputTokens: number;
+    inputPricePerMillion: number;
+    outputPricePerMillion: number;
+    capabilities: ModelCapabilities;
+}
+interface ModelCapabilities {
+    streaming: boolean;
+    tools: boolean;
+    vision: boolean;
+    json_mode: boolean;
+    system_prompts: boolean;
+}
+type RoutingStrategy = 'round-robin' | 'failover' | 'cost-optimized' | 'latency-optimized' | 'load-balanced' | 'conditional';
+interface RoutingDecision {
+    provider: string;
+    model: string;
+    reason: string;
+    alternatives: Array<{
+        provider: string;
+        model: string;
+        score: number;
+    }>;
+    timestamp: Date;
+}
+interface RouterConfig {
+    strategy: RoutingStrategy;
+    fallbackChain?: string[];
+    weights?: Record<string, number>;
+    rules?: RoutingRule[];
+}
+interface RoutingRule {
+    condition: (request: ChatCompletionRequest) => boolean;
+    route: string;
+    reason: string;
+}
+interface CacheConfig {
+    enabled: boolean;
+    ttl: number;
+    maxEntries: number;
+    type: 'exact' | 'semantic';
+    similarityThreshold?: number;
+}
+interface CacheEntry {
+    key: string;
+    response: ChatCompletionResponse;
+    createdAt: Date;
+    expiresAt: Date;
+    hits: number;
+    metadata: Record<string, unknown>;
+}
+interface CacheStats {
+    hits: number;
+    misses: number;
+    hitRate: number;
+    size: number;
+    evictions: number;
+}
+interface RateLimitConfig {
+    requestsPerMinute?: number;
+    requestsPerHour?: number;
+    requestsPerDay?: number;
+    tokensPerMinute?: number;
+    tokensPerDay?: number;
+    maxConcurrent?: number;
+}
+interface RateLimitResult {
+    allowed: boolean;
+    remaining: number;
+    reset: Date;
+    limit: number;
+    retryAfter?: number;
+}
+interface TelemetryConfig {
+    metrics?: boolean;
+    tracing?: boolean;
+    logging?: {
+        level: 'debug' | 'info' | 'warn' | 'error';
+        redact?: string[];
+    };
+}
+interface GatewayMetrics {
+    requests: {
+        total: number;
+        successful: number;
+        failed: number;
+        cached: number;
+    };
+    latency: {
+        avg: number;
+        p50: number;
+        p95: number;
+        p99: number;
+    };
+    tokens: {
+        input: number;
+        output: number;
+        total: number;
+    };
+    cost: {
+        total: number;
+        byProvider: Record<string, number>;
+        byModel: Record<string, number>;
+    };
+    cache: {
+        hits: number;
+        misses: number;
+        hitRate: number;
+    };
+    providers: Record<string, ProviderHealth>;
+}
+interface GatewayConfig {
+    providers: ProviderConfig[];
+    routing?: RouterConfig;
+    cache?: CacheConfig;
+    rateLimit?: RateLimitConfig | {
+        default: RateLimitConfig;
+        perTenant?: boolean;
+    };
+    telemetry?: TelemetryConfig;
+    auth?: AuthConfig;
+    server?: ServerConfig;
+}
+interface AuthConfig {
+    type: 'api-key' | 'jwt' | 'none';
+    keys?: string[];
+    jwtSecret?: string;
+    validateTenant?: (tenantId: string) => Promise<boolean>;
+}
+interface ServerConfig {
+    port?: number;
+    host?: string;
+    cors?: {
+        origin?: string | string[];
+        methods?: string[];
+        headers?: string[];
+    };
+    basePath?: string;
+}
+declare class GatewayError extends Error {
+    code: string;
+    statusCode: number;
+    provider?: string | undefined;
+    retryable: boolean;
+    constructor(message: string, code: string, statusCode?: number, provider?: string | undefined, retryable?: boolean);
+}
+declare class ProviderError extends GatewayError {
+    originalError?: Error | undefined;
+    constructor(message: string, provider: string, originalError?: Error | undefined, retryable?: boolean);
+}
+declare class RateLimitError extends GatewayError {
+    retryAfter: number;
+    constructor(message: string, retryAfter: number, provider?: string);
+}
+declare class AuthenticationError extends GatewayError {
+    constructor(message: string);
+}
+declare class ValidationError extends GatewayError {
+    constructor(message: string);
+}
+
+declare abstract class Provider {
+    readonly name: string;
+    readonly config: ProviderConfig;
+    protected health: ProviderHealth;
+    constructor(config: ProviderConfig);
+    abstract chat(request: ChatCompletionRequest): Promise<ChatCompletionResponse>;
+    abstract chatStream(request: ChatCompletionRequest): AsyncGenerator<ChatCompletionChunk, void, unknown>;
+    supportsModel(model: string): boolean;
+    abstract getModelInfo(model: string): ModelInfo | null;
+    getModels(): string[];
+    getHealth(): ProviderHealth;
+    healthCheck(): Promise<ProviderHealth>;
+    protected updateHealth(success: boolean, latencyMs: number): void;
+    isHealthy(): boolean;
+    isAvailable(): boolean;
+}
+interface ProviderOptions {
+    apiKey?: string;
+    baseUrl?: string;
+    models?: string[];
+    timeout?: number;
+    maxRetries?: number;
+    headers?: Record<string, string>;
+}
+
+interface ProviderWithModels {
+    provider: Provider;
+    models: string[];
+}
+declare class ProviderRegistry {
+    private providers;
+    private modelToProvider;
+    private healthCheckInterval;
+    constructor(providers?: Provider[]);
+    register(provider: Provider): void;
+    unregister(name: string): boolean;
+    get(name: string): Provider | undefined;
+    getAll(): Provider[];
+    getNames(): string[];
+    getProvidersForModel(model: string): Provider[];
+    getProviderForModel(model: string): Provider | undefined;
+    hasModel(model: string): boolean;
+    getAllModels(): string[];
+    getModelInfo(model: string): ModelInfo | null;
+    getHealthStatus(): Record<string, ProviderHealth>;
+    getHealthyProviders(): Provider[];
+    getAvailableProviders(): Provider[];
+    checkHealth(): Promise<Record<string, ProviderHealth>>;
+    startHealthChecks(intervalMs?: number): void;
+    stopHealthChecks(): void;
+    get size(): number;
+}
+
+interface RoutingStrategyInterface {
+    readonly name: RoutingStrategy;
+    route(request: ChatCompletionRequest, registry: ProviderRegistry, context?: RoutingContext): RoutingDecision;
+}
+interface RoutingContext {
+    excludeProviders?: string[];
+    preferredProvider?: string;
+    maxCost?: number;
+    maxLatency?: number;
+    previousAttempts?: Array<{
+        provider: string;
+        model: string;
+        error?: string;
+    }>;
+}
+interface ModelMapping {
+    [model: string]: Array<{
+        provider: string;
+        model: string;
+    }>;
+}
+declare const DEFAULT_MODEL_MAPPINGS: ModelMapping;
+declare const VIRTUAL_MODELS: readonly ["best", "cheapest", "fastest"];
+type VirtualModel = (typeof VIRTUAL_MODELS)[number];
+declare class Router {
+    private strategy;
+    private modelMappings;
+    private fallbackChain;
+    constructor(strategy: RoutingStrategyInterface, config?: {
+        modelMappings?: ModelMapping;
+        fallbackChain?: string[];
+    });
+    route(request: ChatCompletionRequest, registry: ProviderRegistry, context?: RoutingContext): RoutingDecision;
+    isVirtualModel(model: string): model is VirtualModel;
+    private routeVirtualModel;
+    private routeBest;
+    private routeCheapest;
+    private routeFastest;
+    getEquivalentModels(model: string): Array<{
+        provider: string;
+        model: string;
+    }>;
+    setStrategy(strategy: RoutingStrategyInterface): void;
+    getStrategyName(): RoutingStrategy;
+    getFallbackChain(): string[];
+}
+declare function createRouterConfig(options: Partial<RouterConfig>): RouterConfig;
+
+interface RoundRobinConfig {
+    weights?: Record<string, number>;
+}
+declare class RoundRobinStrategy implements RoutingStrategyInterface {
+    readonly name: "round-robin";
+    private currentIndex;
+    private weights;
+    constructor(config?: RoundRobinConfig);
+    route(request: ChatCompletionRequest, registry: ProviderRegistry, context?: RoutingContext): RoutingDecision;
+    reset(): void;
+}
+
+interface FailoverConfig {
+    chain: string[];
+    modelMappings?: Record<string, Record<string, string>>;
+}
+declare class FailoverStrategy implements RoutingStrategyInterface {
+    readonly name: "failover";
+    private chain;
+    private modelMappings;
+    constructor(config: FailoverConfig);
+    route(request: ChatCompletionRequest, registry: ProviderRegistry, context?: RoutingContext): RoutingDecision;
+    getNextProvider(currentProvider: string): string | null;
+    getChain(): string[];
+    setChain(chain: string[]): void;
+}
+
+interface CostOptimizedConfig {
+    maxCostPerRequest?: number;
+    preferLocal?: boolean;
+    qualityThreshold?: number;
+    fallbackOnBudget?: 'cheapest' | 'error';
+}
+declare class CostOptimizedStrategy implements RoutingStrategyInterface {
+    readonly name: "cost-optimized";
+    private config;
+    constructor(config?: CostOptimizedConfig);
+    route(request: ChatCompletionRequest, registry: ProviderRegistry, context?: RoutingContext): RoutingDecision;
+    setConfig(config: Partial<CostOptimizedConfig>): void;
+    getConfig(): CostOptimizedConfig;
+}
+
+interface LatencyOptimizedConfig {
+    maxLatencyMs?: number;
+    warmupRequests?: number;
+    adaptiveRouting?: boolean;
+}
+interface LatencyStats {
+    count: number;
+    total: number;
+    min: number;
+    max: number;
+    avg: number;
+    p95: number;
+    samples: number[];
+}
+declare class LatencyOptimizedStrategy implements RoutingStrategyInterface {
+    readonly name: "latency-optimized";
+    private config;
+    private latencyStats;
+    private readonly maxSamples;
+    constructor(config?: LatencyOptimizedConfig);
+    route(request: ChatCompletionRequest, registry: ProviderRegistry, context?: RoutingContext): RoutingDecision;
+    recordLatency(provider: string, latencyMs: number): void;
+    getStats(provider: string): LatencyStats | undefined;
+    getAllStats(): Record<string, LatencyStats>;
+    clearStats(): void;
+    setConfig(config: Partial<LatencyOptimizedConfig>): void;
+}
+
+interface GatewayEvents {
+    'request:start': (event: {
+        requestId: string;
+        model: string;
+        provider?: string;
+    }) => void;
+    'request:complete': (event: {
+        requestId: string;
+        provider: string;
+        model: string;
+        latencyMs: number;
+        cost: number;
+        cached: boolean;
+        tokens: {
+            input: number;
+            output: number;
+        };
+    }) => void;
+    'request:error': (event: {
+        requestId: string;
+        provider?: string;
+        error: Error;
+    }) => void;
+    'provider:unhealthy': (provider: string) => void;
+    'provider:healthy': (provider: string) => void;
+}
+declare class Gateway extends EventEmitter {
+    private readonly _config;
+    private readonly registry;
+    private readonly router;
+    private readonly healthMonitor;
+    private readonly cache;
+    private readonly logger;
+    private metrics;
+    readonly chat: {
+        completions: {
+            create: (request: ChatCompletionRequest) => Promise<ChatCompletionResponse | AsyncGenerator<ChatCompletionChunk>>;
+        };
+    };
+    constructor(config: GatewayConfig);
+    createCompletion(request: ChatCompletionRequest): Promise<ChatCompletionResponse | AsyncGenerator<ChatCompletionChunk>>;
+    private createNonStreamingCompletion;
+    private createStreamingCompletion;
+    private validateRequest;
+    private createProvider;
+    private createRouter;
+    private createInitialMetrics;
+    private updateMetrics;
+    private updateCacheHitRate;
+    getMetrics(): GatewayMetrics;
+    getConfig(): GatewayConfig;
+    getRegistry(): ProviderRegistry;
+    getRouter(): Router;
+    checkHealth(): Promise<Record<string, boolean>>;
+    shutdown(): void;
+}
+
+type CircuitState = 'closed' | 'open' | 'half-open';
+interface CircuitBreakerConfig {
+    failureThreshold: number;
+    successThreshold: number;
+    timeout: number;
+    volumeThreshold?: number;
+}
+interface HealthMonitorConfig {
+    checkInterval: number;
+    unhealthyThreshold: number;
+    degradedThreshold: number;
+    circuitBreaker?: CircuitBreakerConfig;
+}
+declare class CircuitBreaker {
+    private readonly providerName;
+    private readonly config;
+    private state;
+    private failures;
+    private successes;
+    private lastFailure;
+    private nextAttempt;
+    constructor(providerName: string, config: CircuitBreakerConfig);
+    isAllowed(): boolean;
+    recordSuccess(): void;
+    recordFailure(): void;
+    private trip;
+    reset(): void;
+    getState(): CircuitState;
+    getStatus(): {
+        providerName: string;
+        state: CircuitState;
+        failures: number;
+        nextAttempt: Date | null;
+        lastFailure: Date | null;
+    };
+}
+declare class HealthMonitor extends EventEmitter {
+    private readonly config;
+    private healthHistory;
+    private circuitBreakers;
+    private readonly maxHistorySize;
+    constructor(config: HealthMonitorConfig);
+    recordHealth(providerName: string, health: ProviderHealth): void;
+    recordRequest(providerName: string, success: boolean, _latencyMs: number): void;
+    isRequestAllowed(providerName: string): boolean;
+    private getOrCreateCircuitBreaker;
+    getHistory(providerName: string): ProviderHealth[];
+    getAverageLatency(providerName: string): number;
+    getErrorRate(providerName: string): number;
+    getCircuitStatus(providerName: string): ReturnType<CircuitBreaker['getStatus']> | null;
+    getAllCircuitStatuses(): Record<string, ReturnType<CircuitBreaker['getStatus']>>;
+    resetCircuit(providerName: string): void;
+    clear(): void;
+}
+
+interface OpenAIProviderOptions extends ProviderOptions {
+    organization?: string;
+    project?: string;
+}
+declare class OpenAIProvider extends Provider {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly organization?;
+    private readonly project?;
+    private readonly timeout;
+    constructor(options?: OpenAIProviderOptions);
+    chat(request: ChatCompletionRequest): Promise<ChatCompletionResponse>;
+    chatStream(request: ChatCompletionRequest): AsyncGenerator<ChatCompletionChunk, void, unknown>;
+    getModelInfo(model: string): ModelInfo | null;
+    private makeRequest;
+    private transformRequest;
+    private transformResponse;
+    private transformChunk;
+    private parseError;
+    private wrapError;
+}
+
+interface AnthropicProviderOptions extends ProviderOptions {
+    anthropicBeta?: string[];
+}
+declare class AnthropicProvider extends Provider {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly timeout;
+    private readonly anthropicBeta?;
+    constructor(options?: AnthropicProviderOptions);
+    chat(request: ChatCompletionRequest): Promise<ChatCompletionResponse>;
+    chatStream(request: ChatCompletionRequest): AsyncGenerator<ChatCompletionChunk, void, unknown>;
+    getModelInfo(model: string): ModelInfo | null;
+    private makeRequest;
+    private transformToAnthropic;
+    private extractSystemPrompt;
+    private transformMessage;
+    private transformFromAnthropic;
+    private transformStreamEvent;
+    private parseError;
+    private wrapError;
+}
+
+interface GoogleProviderOptions extends ProviderOptions {
+    projectId?: string;
+    location?: string;
+}
+declare class GoogleProvider extends Provider {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly timeout;
+    constructor(options?: GoogleProviderOptions);
+    chat(request: ChatCompletionRequest): Promise<ChatCompletionResponse>;
+    chatStream(request: ChatCompletionRequest): AsyncGenerator<ChatCompletionChunk, void, unknown>;
+    getModelInfo(model: string): ModelInfo | null;
+    private makeRequest;
+    private transformToGemini;
+    private transformMessages;
+    private transformFromGemini;
+    private transformStreamChunk;
+    private parseError;
+    private wrapError;
+}
+
+interface HTTPServerOptions extends ServerConfig {
+    gateway: Gateway;
+}
+declare function createHTTPServer(options: HTTPServerOptions): Hono;
+declare function startServer(app: Hono, options: {
+    port?: number;
+    host?: string;
+}): ServerType;
+
+interface MetricsConfig {
+    prefix?: string;
+    labels?: string[];
+    histogramBuckets?: {
+        latency?: number[];
+        tokens?: number[];
+    };
+}
+interface HistogramData {
+    count: number;
+    sum: number;
+    buckets: Map<number, number>;
+}
+declare class MetricsCollector {
+    private readonly prefix;
+    private counters;
+    private gauges;
+    private histograms;
+    private readonly latencyBuckets;
+    private readonly tokenBuckets;
+    constructor(config?: MetricsConfig);
+    getTokenBuckets(): number[];
+    incrementCounter(name: string, value?: number, labels?: Record<string, string>): void;
+    setGauge(name: string, value: number, labels?: Record<string, string>): void;
+    recordHistogram(name: string, value: number, labels?: Record<string, string>, buckets?: number[]): void;
+    recordRequest(data: {
+        provider: string;
+        model: string;
+        status: 'success' | 'error';
+        latencyMs: number;
+        inputTokens: number;
+        outputTokens: number;
+        cost: number;
+        cached: boolean;
+    }): void;
+    getCounter(name: string, labels?: Record<string, string>): number;
+    getGauge(name: string, labels?: Record<string, string>): number;
+    getHistogram(name: string, labels?: Record<string, string>): HistogramData | undefined;
+    getSummary(): GatewayMetrics;
+    toPrometheusFormat(): string;
+    reset(): void;
+    private formatKey;
+    private sumCountersByLabel;
+    private sumAllCounters;
+    private getCostByLabel;
+    private aggregateHistograms;
+    private calculatePercentile;
+}
+
+declare const MODEL_PRICING: Record<string, {
+    input: number;
+    output: number;
+}>;
+declare const MODEL_CONTEXT_WINDOWS: Record<string, number>;
+declare const MODEL_MAX_OUTPUT: Record<string, number>;
+declare function calculateCost(model: string, usage: UsageInfo): number;
+declare function estimateCost(model: string, estimatedInputTokens: number, estimatedOutputTokens: number): number;
+declare function getModelPricing(model: string): {
+    input: number;
+    output: number;
+} | null;
+declare function getModelInfo(model: string, provider: string): ModelInfo;
+declare function getModelCapabilities(model: string, provider: string): ModelInfo['capabilities'];
+declare function findCheapestModel(models: string[], _requiredCapabilities?: Partial<ModelInfo['capabilities']>): string | null;
+declare function sortModelsByCost(models: string[], direction?: 'asc' | 'desc'): string[];
+
+declare function countTokens(text: string): number;
+declare function countMessageTokens(messages: Array<{
+    role: string;
+    content: unknown;
+}>): number;
+declare function estimateRequestTokens(messages: Array<{
+    role: string;
+    content: unknown;
+}>, tools?: Array<{
+    function: {
+        name: string;
+        description?: string;
+        parameters?: unknown;
+    };
+}>): number;
+declare function truncateToTokenLimit(text: string, maxTokens: number): string;
+declare function freeEncoder(): void;
+
+declare function hashRequest(request: {
+    model: string;
+    messages: Array<{
+        role: string;
+        content: unknown;
+    }>;
+    temperature?: number;
+    max_tokens?: number;
+    tools?: unknown[];
+    tool_choice?: unknown;
+}): string;
+declare function generateId(prefix?: string): string;
+declare function generateRequestId(): string;
+declare function generateCacheKey(provider: string, model: string, requestHash: string): string;
+declare function hash(str: string): string;
+declare function createSystemFingerprint(config: {
+    version: string;
+    providers: string[];
+}): string;
+
+export { AnthropicProvider, type AnthropicProviderOptions, type AuthConfig, AuthenticationError, type CacheConfig, type CacheEntry, type CacheStats, type ChatCompletionChoice, type ChatCompletionChunk, type ChatCompletionChunkChoice, type ChatCompletionRequest, type ChatCompletionResponse, type ChatMessage, CircuitBreaker, type CircuitBreakerConfig, type CircuitState, type ContentPart, type CostOptimizedConfig, CostOptimizedStrategy, DEFAULT_MODEL_MAPPINGS, type FailoverConfig, FailoverStrategy, Gateway, type GatewayConfig, GatewayError, type GatewayEvents, type GatewayMetrics, type GatewayRequestMetadata, type GatewayResponseMetadata, GoogleProvider, type GoogleProviderOptions, type HTTPServerOptions, HealthMonitor, type HealthMonitorConfig, type HistogramData, type LatencyOptimizedConfig, LatencyOptimizedStrategy, MODEL_CONTEXT_WINDOWS, MODEL_MAX_OUTPUT, MODEL_PRICING, MetricsCollector, type MetricsConfig, type ModelCapabilities, type ModelInfo, type ModelMapping, OpenAIProvider, type OpenAIProviderOptions, Provider, type ProviderConfig, ProviderError, type ProviderHealth, type ProviderOptions, ProviderRegistry, type ProviderWithModels, type RateLimitConfig, RateLimitError, type RateLimitResult, type RoundRobinConfig, RoundRobinStrategy, Router, type RouterConfig, type RoutingContext, type RoutingDecision, type RoutingRule, type RoutingStrategy, type RoutingStrategyInterface, type ServerConfig, type TelemetryConfig, type Tool, type ToolCall, type UsageInfo, VIRTUAL_MODELS, ValidationError, type VirtualModel, calculateCost, countMessageTokens, countTokens, createHTTPServer, createRouterConfig, createSystemFingerprint, estimateCost, estimateRequestTokens, findCheapestModel, freeEncoder, generateCacheKey, generateId, generateRequestId, getModelCapabilities, getModelInfo, getModelPricing, hash, hashRequest, sortModelsByCost, startServer, truncateToTokenLimit };