@x12i/ai-gateway 9.2.0 → 9.3.4

package/dist-cjs/gateway-meta.cjs

@@ -1,14 +1,11 @@
-"use strict";
 /**
  * Gateway Meta Operations Module
  * Handles meta operations like instruction optimization and testing
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.testInstructions = testInstructions;
 /**
  * Test instructions by running them and analyzing the response
  */
-async function testInstructions(instructions, testInput, expectedSchema, options, config, gateway, logger) {
+export async function testInstructions(instructions, testInput, expectedSchema, options, config, gateway, logger) {
     // Get internal system action config (instruction audit)
     const internalConfig = config.internalSystemActions?.instructionAudit;
     const defaultEngine = config.defaultEngine || 'openai';

package/dist-cjs/gateway-mode.cjs

@@ -0,0 +1,75 @@
+/**
+ * Gateway operational mode (prod vs dev/debug) and default model resolution.
+ */
+import { gatewayLogDebug, withActivityIdentity } from './gateway-log-meta.js';
+export const CODE_DEFAULT_MODEL = 'gpt-5-nano';
+/**
+ * Operational mode: `GatewayConfig.mode` overrides `process.env.mode` / `MODE`.
+ * Only `prod` allows silent default-model substitution; all other values are strict.
+ */
+export function getGatewayOperationalMode(config) {
+    if (config?.mode) {
+        return config.mode;
+    }
+    const raw = (process.env.mode ?? process.env.MODE ?? '').toLowerCase();
+    if (raw === 'prod')
+        return 'prod';
+    if (raw === 'dev')
+        return 'dev';
+    return 'debug';
+}
+export function isProdGatewayMode(mode) {
+    return mode === 'prod';
+}
+/**
+ * Parse `provider/model` or bare model id (OpenRouter ids may contain multiple slashes).
+ */
+export function parseModelProviderSpec(spec) {
+    const trimmed = spec.trim();
+    if (!trimmed) {
+        return { model: CODE_DEFAULT_MODEL };
+    }
+    const slash = trimmed.indexOf('/');
+    if (slash === -1) {
+        return { model: trimmed };
+    }
+    const first = trimmed.slice(0, slash);
+    const rest = trimmed.slice(slash + 1);
+    if (rest.includes('/') && (first === 'openrouter' || first === 'open-router')) {
+        return { provider: 'openrouter', model: trimmed };
+    }
+    return { provider: first, model: rest };
+}
+/**
+ * Default model priority: AI_GATEWAY_DEFAULT_MODEL → model-config.json → code constant.
+ */
+export function resolveGatewayDefaultModel(defaultModelConfig, gatewayDefaultEngine) {
+    const envSpec = process.env.AI_GATEWAY_DEFAULT_MODEL?.trim();
+    if (envSpec) {
+        const parsed = parseModelProviderSpec(envSpec);
+        return { model: parsed.model, provider: parsed.provider, source: 'env' };
+    }
+    const jsonModel = typeof defaultModelConfig?.defaultModel === 'string' ? defaultModelConfig.defaultModel : undefined;
+    if (jsonModel) {
+        const parsed = parseModelProviderSpec(jsonModel);
+        const jsonEngine = typeof defaultModelConfig?.defaultEngine === 'string'
+            ? defaultModelConfig.defaultEngine
+            : gatewayDefaultEngine;
+        return {
+            model: parsed.model,
+            provider: parsed.provider ?? jsonEngine,
+            source: 'model-config.json'
+        };
+    }
+    return {
+        model: CODE_DEFAULT_MODEL,
+        provider: gatewayDefaultEngine,
+        source: 'code'
+    };
+}
+export function warnDefaultModelSubstitution(logger, identity, details) {
+    logger.warn('Gateway substituted default model for request', withActivityIdentity(identity, {
+        ...details,
+        debugKind: gatewayLogDebug.anomaly
+    }));
+}

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

@@ -0,0 +1,40 @@
+/**
+ * Gateway operational mode (prod vs dev/debug) and default model resolution.
+ */
+import type { Logxer } from '@x12i/logxer';
+import type { ActivityIdentity, GatewayConfig } from './types.js';
+export type GatewayOperationalMode = 'prod' | 'debug' | 'dev';
+export type GatewayDefaultModelSource = 'env' | 'model-config.json' | 'code';
+export type DefaultModelSubstitutionReason = 'no_model_provided' | 'model_resolution_failed' | 'ai_tools_unavailable';
+export declare const CODE_DEFAULT_MODEL = "gpt-5-nano";
+export type ResolvedGatewayDefault = {
+    model: string;
+    provider?: string;
+    source: GatewayDefaultModelSource;
+};
+/**
+ * Operational mode: `GatewayConfig.mode` overrides `process.env.mode` / `MODE`.
+ * Only `prod` allows silent default-model substitution; all other values are strict.
+ */
+export declare function getGatewayOperationalMode(config?: Pick<GatewayConfig, 'mode'>): GatewayOperationalMode;
+export declare function isProdGatewayMode(mode: GatewayOperationalMode): boolean;
+/**
+ * Parse `provider/model` or bare model id (OpenRouter ids may contain multiple slashes).
+ */
+export declare function parseModelProviderSpec(spec: string): {
+    provider?: string;
+    model: string;
+};
+/**
+ * Default model priority: AI_GATEWAY_DEFAULT_MODEL → model-config.json → code constant.
+ */
+export declare function resolveGatewayDefaultModel(defaultModelConfig?: Record<string, unknown>, gatewayDefaultEngine?: string): ResolvedGatewayDefault;
+export declare function warnDefaultModelSubstitution(logger: Logxer, identity: Partial<ActivityIdentity> | undefined, details: {
+    reason: DefaultModelSubstitutionReason;
+    mode: GatewayOperationalMode;
+    defaultSource: GatewayDefaultModelSource;
+    defaultProvider?: string;
+    defaultModel: string;
+    originalProvider?: string;
+    originalModel?: string;
+}): void;

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

@@ -1,43 +1,7 @@
-"use strict";
 /**
  * Gateway Provider Auto-Registration Module
  * Automatically registers providers based on environment variables
  */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.autoRegisterProviders = autoRegisterProviders;
 const PROVIDER_CONFIGS = [
     {
         name: 'openai',
@@ -90,7 +54,7 @@ const PROVIDER_CONFIGS = [
  * @param logger - Logger instance
  * @returns Array of provider names that were successfully registered
  */
-async function autoRegisterProviders(router, logger) {
+export async function autoRegisterProviders(router, logger) {
     const registeredProviders = [];
     logger.debug('Auto-registering providers from environment variables');
     for (const providerConfig of PROVIDER_CONFIGS) {
@@ -107,7 +71,7 @@ async function autoRegisterProviders(router, logger) {
             // Use dynamic import() for ES module compatibility
             let ProviderClass;
             try {
-                const providerModule = await Promise.resolve(`${providerConfig.packageName}`).then(s => __importStar(require(s)));
+                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}`);

package/dist-cjs/gateway-provider.cjs

@@ -1,23 +1,11 @@
-"use strict";
 /**
  * Gateway Provider Module
  * Handles provider management
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerProvider = registerProvider;
-exports.unregisterProvider = unregisterProvider;
-exports.getProvider = getProvider;
-exports.listProviders = listProviders;
-exports.setDefaultProvider = setDefaultProvider;
-exports.setFallbackChain = setFallbackChain;
-exports.addRequestInterceptor = addRequestInterceptor;
-exports.addResponseInterceptor = addResponseInterceptor;
-exports.checkHealth = checkHealth;
-exports.checkAllHealth = checkAllHealth;
 /**
  * Register a provider with the router
  */
-function registerProvider(provider, router, logger) {
+export function registerProvider(provider, router, logger) {
     // Get provider name - try multiple methods
     let providerName = 'unknown';
     if (typeof provider.getProviderName === 'function') {
@@ -103,7 +91,7 @@ function registerProvider(provider, router, logger) {
 /**
  * Unregister a provider
  */
-function unregisterProvider(providerName, router, logger) {
+export function unregisterProvider(providerName, router, logger) {
     try {
         // Try to access registry directly to remove the provider
         const registry = router.getProviderRegistry();
@@ -128,7 +116,7 @@ function unregisterProvider(providerName, router, logger) {
 /**
  * Get a provider module
  */
-function getProvider(providerName, router) {
+export function getProvider(providerName, router) {
     try {
         const registry = router.getProviderRegistry();
         return registry.get(providerName);
@@ -141,7 +129,7 @@ function getProvider(providerName, router) {
 /**
  * List all registered providers
  */
-function listProviders(router) {
+export function listProviders(router) {
     return router.listProviders();
 }
 /**
@@ -151,7 +139,7 @@ function listProviders(router) {
  * This method is kept for API compatibility but does nothing.
  * Default provider must be set in router config during initialization.
  */
-function setDefaultProvider(provider, router, logger) {
+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', {
@@ -166,7 +154,7 @@ function setDefaultProvider(provider, router, logger) {
  * This method is kept for API compatibility but does nothing.
  * Fallback chain must be set in router config during initialization.
  */
-function setFallbackChain(chain, router, logger) {
+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', {
@@ -177,25 +165,25 @@ function setFallbackChain(chain, router, logger) {
 /**
  * Add request interceptor
  */
-function addRequestInterceptor(interceptor, router) {
+export function addRequestInterceptor(interceptor, router) {
     router.addRequestInterceptor(interceptor);
 }
 /**
  * Add response interceptor
  */
-function addResponseInterceptor(interceptor, router) {
+export function addResponseInterceptor(interceptor, router) {
     router.addResponseInterceptor(interceptor);
 }
 /**
  * Check health of a provider
  */
-async function checkHealth(provider, router) {
+export async function checkHealth(provider, router) {
     return router.checkHealth(provider);
 }
 /**
  * Check health of all providers
  */
-async function checkAllHealth(router) {
+export async function checkAllHealth(router) {
     const providers = listProviders(router);
     const results = {};
     for (const provider of providers) {

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

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

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

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Gateway Rate Limiter
  *
@@ -12,10 +11,8 @@
  * and only waits if necessary to maintain minimum intervals between separate API calls.
  * This prevents unnecessary delays when enough time has already passed.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GatewayRateLimiter = void 0;
-const gateway_retry_js_1 = require("./gateway-retry.cjs");
-const gateway_rate_limiter_constants_js_1 = require("./gateway-rate-limiter-constants.cjs");
+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)
  *
@@ -27,12 +24,12 @@ const gateway_rate_limiter_constants_js_1 = require("./gateway-rate-limiter-cons
  *
  * This ensures minimum intervals between separate API calls regardless of what happens between them.
  */
-class GatewayRateLimiter {
+export class GatewayRateLimiter {
     lastCallTimes = new Map(); // provider -> last call timestamp
     defaultMinIntervalMs;
     providerIntervals = new Map(); // provider -> min interval
     logger;
-    constructor(defaultMinIntervalMs = gateway_rate_limiter_constants_js_1.DEFAULT_RATE_LIMIT_MIN_INTERVAL_MS, providerIntervals, logger) {
+    constructor(defaultMinIntervalMs = DEFAULT_RATE_LIMIT_MIN_INTERVAL_MS, providerIntervals, logger) {
         this.defaultMinIntervalMs = defaultMinIntervalMs;
         this.logger = logger;
         // Store per-provider intervals
@@ -69,7 +66,7 @@ class GatewayRateLimiter {
                 minIntervalMs,
                 usingProviderSpecific: this.providerIntervals.has(provider.toLowerCase())
             });
-            await (0, gateway_retry_js_1.sleep)(waitTime);
+            await sleep(waitTime);
         }
         else {
             this.logger?.verbose('Rate limit OK: enough time has passed', {
@@ -108,4 +105,3 @@ class GatewayRateLimiter {
         }
     }
 }
-exports.GatewayRateLimiter = GatewayRateLimiter;

package/dist-cjs/gateway-retry.cjs

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Gateway Retry Module
  * Handles retry logic for network and server errors
@@ -6,17 +5,10 @@
  * NOTE: Retry delays use SIMPLE SLEEP (not smart rate limiting).
  * Between-calls rate limiting is handled separately in gateway-rate-limiter.ts (smart).
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isNetworkError = isNetworkError;
-exports.extractHttpStatusCode = extractHttpStatusCode;
-exports.isRetryableHttpError = isRetryableHttpError;
-exports.isRetryableError = isRetryableError;
-exports.sleep = sleep;
-exports.invokeWithRetry = invokeWithRetry;
 /**
  * Determines if an error is a network error (fetch failed, DNS, connectivity)
  */
-function isNetworkError(error) {
+export function isNetworkError(error) {
     const message = error.message.toLowerCase();
     const networkPatterns = [
         'fetch failed',
@@ -35,7 +27,7 @@ function isNetworkError(error) {
 /**
  * Extracts HTTP status code from error message or error object properties
  */
-function extractHttpStatusCode(error) {
+export function extractHttpStatusCode(error) {
     // Try to extract from error message
     const statusMatch = error.message.match(/\b(4\d{2}|5\d{2})\b/);
     if (statusMatch) {
@@ -59,7 +51,7 @@ function extractHttpStatusCode(error) {
  * Retryable: 429 (throttling), 5xx (server errors)
  * Non-retryable: 4xx except 429 (client errors)
  */
-function isRetryableHttpError(error, statusCode) {
+export function isRetryableHttpError(error, statusCode) {
     // 429 (throttling) is retryable
     if (statusCode === 429) {
         return true;
@@ -74,7 +66,7 @@ function isRetryableHttpError(error, statusCode) {
 /**
  * Determines if an error should be retried
  */
-function isRetryableError(error) {
+export function isRetryableError(error) {
     // Network errors are always retryable
     if (isNetworkError(error)) {
         return true;
@@ -94,14 +86,14 @@ function isRetryableError(error) {
 /**
  * Sleep helper for retry delays
  */
-function sleep(ms) {
+export function sleep(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
 /**
  * Invokes router with retry logic for network and server errors
  * Returns response and retry metadata
  */
-async function invokeWithRetry(routerRequest, retryConfig, jobId, router, logger, hooks) {
+export async function invokeWithRetry(routerRequest, retryConfig, jobId, router, logger, hooks) {
     const maxRetries = retryConfig.maxRetries ?? 3;
     const initialDelay = retryConfig.initialDelay ?? 1000;
     const maxDelay = retryConfig.maxDelay ?? 30000;