@x12i/ai-gateway 11.0.7 → 11.1.1

package/dist/gateway-provider.js

@@ -1,202 +0,0 @@
-/**
- * Gateway Provider Module
- * Handles provider management
- */
-/**
- * Register a provider with the router
- */
-export function registerProvider(provider, router, logger) {
-    // Get provider name - try multiple methods
-    let providerName = 'unknown';
-    if (typeof provider.getProviderName === 'function') {
-        providerName = provider.getProviderName();
-    }
-    else if (provider.name) {
-        providerName = provider.name;
-    }
-    else if (provider.constructor?.name) {
-        providerName = provider.constructor.name.replace('Provider', '').toLowerCase();
-    }
-    logger.debug('Registering provider', { provider: providerName });
-    // Check if provider has required methods
-    if (!provider || (typeof provider.invoke !== 'function' && typeof provider.aiCall !== 'function')) {
-        logger.error('Provider registration failed: must implement invoke() or aiCall()', {
-            provider: providerName,
-            hasInvoke: typeof provider.invoke === 'function',
-            hasAiCall: typeof provider.aiCall === 'function'
-        });
-        throw new Error('Provider must implement LLMProviderInterface (invoke) or AIProviderInterface (aiCall)');
-    }
-    // Create a ProviderModule wrapper for the provider instance
-    logger.debug('Creating ProviderModule wrapper for provider instance', { provider: providerName });
-    // Ensure provider has invoke method
-    let providerWithInvoke = provider;
-    if (typeof provider.aiCall === 'function' && typeof provider.invoke !== 'function') {
-        logger.debug('Provider uses aiCall, creating invoke wrapper', { provider: providerName });
-        providerWithInvoke = {
-            ...provider,
-            invoke: async (request) => {
-                // Convert LLMRequest to format expected by aiCall
-                return await provider.aiCall(request);
-            }
-        };
-    }
-    // Create ProviderModule wrapper
-    const providerModule = {
-        name: providerName,
-        capabilities: {
-            modes: {
-                sync: true,
-                stream: false,
-                batch: false
-            },
-            operations: ['invoke'],
-            maxConcurrency: 10
-        },
-        execute: async (request) => {
-            return await providerWithInvoke.invoke(request);
-        }
-    };
-    // Register with router using registerProvider
-    try {
-        router.registerProvider(providerModule);
-        logger.info('Provider registered as ProviderModule', {
-            provider: providerName,
-            totalProviders: router.listProviders().length
-        });
-    }
-    catch (error) {
-        logger.error('Failed to register provider with router.registerProvider, trying registry directly', {
-            provider: providerName,
-            error: error instanceof Error ? error.message : String(error)
-        });
-        // Fallback: try to access registry directly
-        try {
-            const registry = router.getProviderRegistry();
-            registry.register(providerModule);
-            logger.info('Provider registered via registry fallback', {
-                provider: providerName,
-                totalProviders: router.listProviders().length
-            });
-        }
-        catch (registryError) {
-            logger.error('Failed to register provider via registry', {
-                provider: providerName,
-                error: registryError instanceof Error ? registryError.message : String(registryError)
-            });
-            throw registryError;
-        }
-    }
-}
-/**
- * Unregister a provider
- */
-export function unregisterProvider(providerName, router, logger) {
-    try {
-        // Try to access registry directly to remove the provider
-        const registry = router.getProviderRegistry();
-        // Since registry doesn't have an unregister method, we'll need to manipulate the map directly
-        // This is a bit hacky but necessary since the API doesn't provide unregister
-        const map = registry.map;
-        if (map && map instanceof Map) {
-            map.delete(providerName);
-            logger.info('Provider unregistered from registry', { provider: providerName });
-        }
-        else {
-            logger.warn('Could not access provider registry map for unregistration', { provider: providerName });
-        }
-    }
-    catch (error) {
-        logger.error('Failed to unregister provider', {
-            provider: providerName,
-            error: error instanceof Error ? error.message : String(error)
-        });
-    }
-}
-/**
- * Get a provider module
- */
-export function getProvider(providerName, router) {
-    try {
-        const registry = router.getProviderRegistry();
-        return registry.get(providerName);
-    }
-    catch (error) {
-        // Fallback to any access if registry access fails
-        return router.getProvider?.(providerName);
-    }
-}
-/**
- * List all registered providers
- */
-export function listProviders(router) {
-    return router.listProviders();
-}
-/**
- * Set default provider
- *
- * NOTE: Router doesn't support changing default provider after initialization.
- * This method is kept for API compatibility but does nothing.
- * Default provider must be set in router config during initialization.
- */
-export function setDefaultProvider(provider, router, logger) {
-    // Router doesn't support changing default provider after initialization
-    // Default provider must be set in router config during initialization
-    logger.warn('setDefaultProvider called but router does not support changing default provider after initialization', {
-        provider,
-        note: 'Default provider must be set in router config during initialization'
-    });
-}
-/**
- * Set fallback chain
- *
- * NOTE: Router doesn't support changing fallback chain after initialization.
- * This method is kept for API compatibility but does nothing.
- * Fallback chain must be set in router config during initialization.
- */
-export function setFallbackChain(chain, router, logger) {
-    // Router doesn't support changing fallback chain after initialization
-    // Fallback chain must be set in router config during initialization
-    logger.warn('setFallbackChain called but router does not support changing fallback chain after initialization', {
-        chain,
-        note: 'Fallback chain must be set in router config during initialization'
-    });
-}
-/**
- * Add request interceptor
- */
-export function addRequestInterceptor(interceptor, router) {
-    router.addRequestInterceptor(interceptor);
-}
-/**
- * Add response interceptor
- */
-export function addResponseInterceptor(interceptor, router) {
-    router.addResponseInterceptor(interceptor);
-}
-/**
- * Check health of a provider
- */
-export async function checkHealth(provider, router) {
-    return router.checkHealth(provider);
-}
-/**
- * Check health of all providers
- */
-export async function checkAllHealth(router) {
-    const providers = listProviders(router);
-    const results = {};
-    for (const provider of providers) {
-        try {
-            results[provider] = await router.checkHealth(provider);
-        }
-        catch (error) {
-            results[provider] = {
-                provider,
-                healthy: false,
-                error: error instanceof Error ? error.message : String(error)
-            };
-        }
-    }
-    return results;
-}

package/dist/openrouter-runtime-adapter/create-openrouter-runtime-adapter.d.ts

@@ -1,23 +0,0 @@
-import type { ProviderSDKCallSpec } from '@x12i/ai-provider-interface';
-import type { AIResponse } from '@x12i/ai-providers-router';
-export declare function createOpenRouterRuntimeAdapter(): {
-    provider: string;
-    buildCallSpec(input: {
-        requestId: string;
-        mode: "sync" | "stream";
-        request: Record<string, unknown>;
-        exec?: {
-            timeoutMs?: number;
-            retries?: number;
-            idempotencyKey?: string;
-            signal?: AbortSignal;
-        };
-    }): ProviderSDKCallSpec;
-    parseResponse(input: {
-        requestId: string;
-        request: unknown;
-        execResult: {
-            rawResponse: unknown;
-        };
-    }): AIResponse;
-};

package/dist/openrouter-runtime-adapter/create-openrouter-runtime-adapter.js

@@ -1,31 +0,0 @@
-import { mapGatewayRequestToRuntimeRequestFromRouter, OPENROUTER_RUNTIME_OPERATION, } from './map-gateway-request.js';
-import { parseRuntimeResponseToAIResponse } from './map-runtime-response.js';
-export function createOpenRouterRuntimeAdapter() {
-    return {
-        provider: 'openrouter',
-        buildCallSpec(input) {
-            const runtimeRequest = mapGatewayRequestToRuntimeRequestFromRouter({
-                request: input.request,
-                exec: input.exec,
-            });
-            return {
-                requestId: input.requestId,
-                provider: 'openrouter',
-                mode: input.mode === 'stream' ? 'sync' : input.mode,
-                operation: OPENROUTER_RUNTIME_OPERATION,
-                args: runtimeRequest,
-                exec: input.exec
-                    ? {
-                        timeoutMs: input.exec.timeoutMs,
-                        retries: input.exec.retries,
-                        idempotencyKey: input.exec.idempotencyKey,
-                        signal: input.exec.signal,
-                    }
-                    : undefined,
-            };
-        },
-        parseResponse(input) {
-            return parseRuntimeResponseToAIResponse(input);
-        },
-    };
-}

package/dist/openrouter-runtime-adapter/create-openrouter-runtime-provider.d.ts

@@ -1,10 +0,0 @@
-import { type OpenRouterRuntime } from '@x12i/openrouter-runtime';
-import type { ProviderModule } from '@x12i/ai-provider-interface';
-import type { Logxer } from '@x12i/logxer';
-export type OpenRouterRuntimeProviderOptions = {
-    apiKey: string;
-    logger?: Logxer;
-    runtime?: OpenRouterRuntime;
-    debugOpenRouterBody?: boolean;
-};
-export declare function createOpenRouterRuntimeProvider(options: OpenRouterRuntimeProviderOptions): ProviderModule;

package/dist/openrouter-runtime-adapter/create-openrouter-runtime-provider.js

@@ -1,152 +0,0 @@
-import { createOpenRouterRuntime, RuntimeConfigError, OpenRouterHttpError, } from '@x12i/openrouter-runtime';
-import { OPENROUTER_RUNTIME_OPERATION } from './map-gateway-request.js';
-import { throwMappedOpenRouterHttpError, throwMappedRuntimeConfigError, throwMappedRuntimeResponseErrors, } from './map-runtime-errors.js';
-import { redactRawOpenRouterPayload } from './map-trace.js';
-function hasOwn(obj, key) {
-    return Object.prototype.hasOwnProperty.call(obj, key);
-}
-function summarizeStreamValue(value) {
-    if (value == null || ['boolean', 'number', 'string'].includes(typeof value))
-        return value;
-    if (Array.isArray(value))
-        return `[array:${value.length}]`;
-    return `[${typeof value}]`;
-}
-function collectStreamFields(value, path = 'body', depth = 0, out = []) {
-    if (out.length >= 20 || depth > 8 || value == null || typeof value !== 'object')
-        return out;
-    if (Array.isArray(value)) {
-        for (let i = 0; i < value.length && out.length < 20; i += 1) {
-            collectStreamFields(value[i], `${path}[${i}]`, depth + 1, out);
-        }
-        return out;
-    }
-    for (const [key, child] of Object.entries(value)) {
-        const childPath = `${path}.${key}`;
-        if (key === 'stream') {
-            out.push({ path: childPath, value: summarizeStreamValue(child) });
-            if (out.length >= 20)
-                return out;
-        }
-        collectStreamFields(child, childPath, depth + 1, out);
-    }
-    return out;
-}
-function summarizeServerTools(serverTools) {
-    if (!serverTools)
-        return undefined;
-    const out = {};
-    for (const [key, value] of Object.entries(serverTools)) {
-        if (Array.isArray(value)) {
-            out[key] = value.map((item) => item.mode).join(',');
-            continue;
-        }
-        if (value && typeof value === 'object' && 'mode' in value && typeof value.mode === 'string') {
-            out[key] = value.mode;
-        }
-    }
-    return Object.keys(out).length ? out : undefined;
-}
-function summarizeCompiledTools(compiled) {
-    const tools = Array.isArray(compiled.body.tools) ? compiled.body.tools : [];
-    const toolTypes = tools
-        .map((tool) => (tool && typeof tool === 'object' && 'type' in tool ? String(tool.type) : undefined))
-        .filter((type) => typeof type === 'string');
-    return {
-        apiMode: compiled.apiMode,
-        toolCount: tools.length,
-        toolTypes,
-        bodyKeys: Object.keys(compiled.body),
-        hasTopLevelStream: hasOwn(compiled.body, 'stream'),
-        topLevelStream: compiled.body.stream,
-        streamFields: collectStreamFields(compiled.body),
-    };
-}
-function shouldDebugOpenRouterBody(options) {
-    if (options.debugOpenRouterBody === true)
-        return true;
-    const env = process.env.AI_GATEWAY_DEBUG_OPENROUTER_BODY?.toLowerCase();
-    return env === '1' || env === 'true' || env === 'yes';
-}
-export function createOpenRouterRuntimeProvider(options) {
-    const debugOpenRouterBody = shouldDebugOpenRouterBody(options);
-    const runtime = options.runtime ??
-        createOpenRouterRuntime({
-            apiKey: options.apiKey,
-            defaults: {
-                retry: { enabled: false },
-                onPolicyViolation: 'throw',
-            },
-            logger: options.logger
-                ? {
-                    debug: (event, data) => options.logger?.debug(event, data),
-                    info: (event, data) => options.logger?.info(event, data),
-                    warn: (event, data) => options.logger?.warn(event, data),
-                    error: (event, data) => options.logger?.error(event, data),
-                }
-                : undefined,
-            hooks: options.logger
-                ? {
-                    beforeOpenRouterRequest: (compiled) => {
-                        const summary = summarizeCompiledTools(compiled);
-                        options.logger?.debug('OpenRouter runtime compiled request before fetch', {
-                            ...summary,
-                            url: compiled.url,
-                        });
-                        if (debugOpenRouterBody) {
-                            const redactedBody = redactRawOpenRouterPayload(compiled.body);
-                            options.logger?.debug('OpenRouter runtime compiled request body before fetch', {
-                                apiMode: compiled.apiMode,
-                                url: compiled.url,
-                                body: redactedBody,
-                                bodyJson: JSON.stringify(redactedBody, null, 2),
-                            });
-                        }
-                    },
-                }
-                : undefined,
-        });
-    return {
-        name: 'openrouter',
-        capabilities: {
-            modes: { sync: true, stream: false, batch: false },
-            operations: [OPENROUTER_RUNTIME_OPERATION],
-            maxConcurrency: 10,
-        },
-        async execute(spec) {
-            if (spec.operation !== OPENROUTER_RUNTIME_OPERATION) {
-                throw new Error(`Unsupported OpenRouter runtime operation: ${spec.operation}`);
-            }
-            const runtimeRequest = spec.args;
-            const rawOverrideKeys = runtimeRequest.rawOpenRouterOverrides
-                ? Object.keys(runtimeRequest.rawOpenRouterOverrides)
-                : [];
-            const rawOverrides = runtimeRequest.rawOpenRouterOverrides ?? {};
-            const rawOverrideHasStream = hasOwn(rawOverrides, 'stream');
-            options.logger?.debug('OpenRouter runtime request server tools', {
-                requestId: spec.requestId,
-                model: runtimeRequest.model,
-                apiMode: runtimeRequest.apiMode,
-                serverTools: summarizeServerTools(runtimeRequest.serverTools),
-                rawOverrideKeys,
-                rawOverrideHasStream,
-                rawOverrideStream: rawOverrides.stream,
-                rawOverridesToolsPresent: Object.prototype.hasOwnProperty.call(rawOverrides, 'tools'),
-            });
-            try {
-                const response = await runtime.run(runtimeRequest);
-                if (response.status !== 'completed') {
-                    throwMappedRuntimeResponseErrors(response);
-                }
-                return { rawResponse: response };
-            }
-            catch (err) {
-                if (err instanceof RuntimeConfigError)
-                    throwMappedRuntimeConfigError(err);
-                if (err instanceof OpenRouterHttpError)
-                    throwMappedOpenRouterHttpError(err);
-                throw err;
-            }
-        },
-    };
-}

package/dist/openrouter-runtime-adapter/register-openrouter-runtime.d.ts

@@ -1,10 +0,0 @@
-import type { LLMProviderRouter } from '@x12i/ai-providers-router';
-import type { Logxer } from '@x12i/logxer';
-import type { GatewayOpenRouterRuntimeConfig } from '../types.js';
-export type RegisterOpenRouterRuntimeOptions = {
-    apiKey: string;
-    logger?: Logxer;
-    runtimeConfig?: GatewayOpenRouterRuntimeConfig;
-};
-export declare function registerOpenRouterRuntime(router: LLMProviderRouter, options: RegisterOpenRouterRuntimeOptions): void;
-export { shouldUseOpenRouterRuntime, resolveOpenRouterRuntimeDefaults } from './should-use-openrouter-runtime.js';

package/dist/openrouter-runtime-adapter/register-openrouter-runtime.js

@@ -1,19 +0,0 @@
-import { createOpenRouterRuntimeAdapter } from './create-openrouter-runtime-adapter.js';
-import { createOpenRouterRuntimeProvider } from './create-openrouter-runtime-provider.js';
-export function registerOpenRouterRuntime(router, options) {
-    const { apiKey, logger, runtimeConfig } = options;
-    const provider = createOpenRouterRuntimeProvider({
-        apiKey,
-        logger,
-        debugOpenRouterBody: runtimeConfig?.debugOpenRouterBody,
-    });
-    router.registerProvider(provider);
-    const adapter = createOpenRouterRuntimeAdapter();
-    router.getAdapterRegistry().register(adapter);
-    logger?.info('Registered OpenRouter runtime provider and adapter', {
-        provider: 'openrouter',
-        runtimeEnabled: true,
-        debugOpenRouterBody: runtimeConfig?.debugOpenRouterBody,
-    });
-}
-export { shouldUseOpenRouterRuntime, resolveOpenRouterRuntimeDefaults } from './should-use-openrouter-runtime.js';

package/dist-cjs/gateway-provider-auto-register.cjs

@@ -1,159 +0,0 @@
-/**
- * Gateway Provider Auto-Registration Module
- * Automatically registers providers based on environment variables
- */
-const PROVIDER_CONFIGS = [
-    {
-        name: 'openai',
-        packageName: '@x12i/ai-provider-openai',
-        className: 'OpenAIProvider',
-        envVar: 'OPENAI_API_KEY'
-    },
-    {
-        name: 'grok',
-        packageName: '@x12i/ai-provider-grok',
-        className: 'GrokProvider',
-        envVar: 'GROK_API_KEY'
-    },
-    {
-        name: 'anthropic',
-        packageName: '@x12i/ai-provider-anthropic',
-        className: 'AnthropicProvider',
-        envVar: 'ANTHROPIC_API_KEY',
-        optional: true // Optional - may not be installed
-    },
-    {
-        name: 'google',
-        packageName: '@x12i/ai-provider-google',
-        className: 'GoogleProvider',
-        envVar: 'GOOGLE_API_KEY',
-        optional: true // Optional - may not be installed
-    },
-    {
-        name: 'cohere',
-        packageName: '@x12i/ai-provider-cohere',
-        className: 'CohereProvider',
-        envVar: 'COHERE_API_KEY',
-        optional: true // Optional - may not be installed
-    },
-    {
-        name: 'mistral',
-        packageName: '@x12i/ai-provider-mistral',
-        className: 'MistralProvider',
-        envVar: 'MISTRAL_API_KEY',
-        optional: true // Optional - may not be installed
-    }
-];
-/**
- * Auto-registers providers based on environment variables
- * Only registers providers that:
- * 1. Have their API key set in environment variables
- * 2. Have their provider package installed
- *
- * @param router - LLM provider router instance
- * @param logger - Logger instance
- * @returns Array of provider names that were successfully registered
- */
-export async function autoRegisterProviders(router, logger) {
-    const registeredProviders = [];
-    logger.debug('Auto-registering providers from environment variables');
-    for (const providerConfig of PROVIDER_CONFIGS) {
-        const apiKey = process.env[providerConfig.envVar];
-        // Skip if API key is not set
-        if (!apiKey) {
-            if (!providerConfig.optional) {
-                logger.debug(`Skipping ${providerConfig.name} provider: ${providerConfig.envVar} not set`);
-            }
-            continue;
-        }
-        try {
-            // Dynamically import the provider package
-            // Use dynamic import() for ES module compatibility
-            let ProviderClass;
-            try {
-                const providerModule = await import(providerConfig.packageName);
-                ProviderClass = providerModule[providerConfig.className] || providerModule.default;
-                if (!ProviderClass) {
-                    logger.debug(`Provider class ${providerConfig.className} not found in ${providerConfig.packageName}`);
-                    continue;
-                }
-            }
-            catch (importError) {
-                if (!providerConfig.optional) {
-                    logger.warn(`Failed to import ${providerConfig.packageName}`, {
-                        error: importError instanceof Error ? importError.message : String(importError),
-                        note: `Install it with: npm install ${providerConfig.packageName}`
-                    });
-                }
-                continue;
-            }
-            // Instantiate the provider
-            const provider = new ProviderClass({
-                apiKey: apiKey
-            });
-            // Get provider name for both module creation and logging
-            const providerName = typeof provider.getProviderName === 'function'
-                ? provider.getProviderName()
-                : providerConfig.name;
-            // Register with router as ProviderModule
-            const providerModule = {
-                name: providerName,
-                capabilities: {
-                    modes: {
-                        sync: true,
-                        stream: false,
-                        batch: false
-                    },
-                    operations: ['invoke'],
-                    maxConcurrency: 10
-                },
-                execute: async (request) => {
-                    // Use aiCall if available, otherwise assume invoke
-                    if (typeof provider.aiCall === 'function') {
-                        return await provider.aiCall(request);
-                    }
-                    else if (typeof provider.invoke === 'function') {
-                        return await provider.invoke(request);
-                    }
-                    else {
-                        throw new Error(`Provider ${providerName} has neither aiCall nor invoke method`);
-                    }
-                }
-            };
-            router.registerProvider(providerModule);
-            registeredProviders.push(providerName);
-            logger.info(`Auto-registered provider: ${providerName}`, {
-                provider: providerName,
-                envVar: providerConfig.envVar,
-                hasApiKey: !!apiKey
-            });
-        }
-        catch (error) {
-            logger.error(`Failed to auto-register ${providerConfig.name} provider`, {
-                provider: providerConfig.name,
-                package: providerConfig.packageName,
-                error: error instanceof Error ? error.message : String(error),
-                stack: error instanceof Error ? error.stack : undefined
-            });
-            // Continue with other providers even if one fails
-        }
-    }
-    if (registeredProviders.length === 0) {
-        logger.warn('No providers were auto-registered. Make sure API keys are set in environment variables:', {
-            requiredEnvVars: PROVIDER_CONFIGS
-                .filter(p => !p.optional)
-                .map(p => p.envVar),
-            optionalEnvVars: PROVIDER_CONFIGS
-                .filter(p => p.optional)
-                .map(p => p.envVar),
-            openRouter: 'Set OPENROUTER_API_KEY for OpenRouter (default route when set). PREFER_OPENROUTER=false prefers direct provider keys when present; OpenRouter is still used when a requested provider has no key.',
-            note: 'You can still manually register providers using gateway.register(provider)'
-        });
-    }
-    else {
-        logger.info(`Auto-registered ${registeredProviders.length} provider(s)`, {
-            providers: registeredProviders
-        });
-    }
-    return registeredProviders;
-}

package/dist-cjs/gateway-provider-auto-register.d.ts

@@ -1,17 +0,0 @@
-/**
- * Gateway Provider Auto-Registration Module
- * Automatically registers providers based on environment variables
- */
-import type { LLMProviderRouter } from '@x12i/ai-providers-router';
-import type { Logxer } from '@x12i/logxer';
-/**
- * Auto-registers providers based on environment variables
- * Only registers providers that:
- * 1. Have their API key set in environment variables
- * 2. Have their provider package installed
- *
- * @param router - LLM provider router instance
- * @param logger - Logger instance
- * @returns Array of provider names that were successfully registered
- */
-export declare function autoRegisterProviders(router: LLMProviderRouter, logger: Logxer): Promise<string[]>;