@x12i/ai-gateway 9.6.3 → 9.6.5

package/dist/index.d.ts

@@ -34,9 +34,10 @@ export { normalizeToActivixCostShape } from '@x12i/activix';
 export { ActivityManager, ensureGatewayRequestIdentity } from './activity-manager.js';
 export { OptimixerManager } from './optimixer-manager.js';
 export type { ActivityIdentity } from './types.js';
-export { activityIdentityToLogMeta, withActivityIdentity, gatewayLogDebug } from './gateway-log-meta.js';
-export { createLogxer, DebugLogAbstract } from '@x12i/logxer';
-export type { Logxer, LogMeta, RuntimeIdentity } from '@x12i/logxer';
+export { activityIdentityToLogContext, activityIdentityToLogMeta, withActivityIdentity, withGatewayLogContext, gatewayLogDebug } from './gateway-log-meta.js';
+export { createGatewayLogger, GATEWAY_LOG_ENV_PREFIX } from './logger-factory.js';
+export { createLogxer, DebugLogAbstract, runWithLogContext, getStationRuntimeIdentity, mergeRuntimeIdentity } from '@x12i/logxer';
+export type { Logxer, LogMeta, RuntimeIdentity, LogRuntimeContext, GetJobLogsInput, GetJobLogsResult, QueryableLogLine } from '@x12i/logxer';
 export { runtimeObjects } from './runtime-objects.js';
 export type { ActivixQueryableClient, LogxerQueryableClient, PackageRuntimeObjects, RuntimeObjects } from './runtime-objects.js';
 export { GatewayRateLimiter } from './gateway-rate-limiter.js';

package/dist/index.js

@@ -29,9 +29,10 @@ export { Activix } from '@x12i/activix';
 export { normalizeToActivixCostShape } from '@x12i/activix';
 export { ActivityManager, ensureGatewayRequestIdentity } from './activity-manager.js';
 export { OptimixerManager } from './optimixer-manager.js';
-export { activityIdentityToLogMeta, withActivityIdentity, gatewayLogDebug } from './gateway-log-meta.js';
+export { activityIdentityToLogContext, activityIdentityToLogMeta, withActivityIdentity, withGatewayLogContext, gatewayLogDebug } from './gateway-log-meta.js';
+export { createGatewayLogger, GATEWAY_LOG_ENV_PREFIX } from './logger-factory.js';
 // Re-export logging (@x12i/logxer)
-export { createLogxer, DebugLogAbstract } from '@x12i/logxer';
+export { createLogxer, DebugLogAbstract, runWithLogContext, getStationRuntimeIdentity, mergeRuntimeIdentity } from '@x12i/logxer';
 // Runtime observability surface (leaf package: no downstream runtime objects)
 export { runtimeObjects } from './runtime-objects.js';
 // Export rate limiter

package/dist/logger-factory.d.ts

@@ -4,6 +4,8 @@
  * Creates and configures logxer instances for the gateway
  */
 import { type Logxer } from '@x12i/logxer';
+/** Stable ERC 2.0 env prefix — controls `AI_GATEWAY_LOGS_LEVEL`, etc. */
+export declare const GATEWAY_LOG_ENV_PREFIX = "AI_GATEWAY";
 /**
  * Creates a logger instance based on configuration
  *

package/dist/logger-factory.js

@@ -3,16 +3,14 @@
  *
  * Creates and configures logxer instances for the gateway
  */
-import { createLogxer } from '@x12i/logxer';
-function resolveDefaultRuntimeIdentity(packageName) {
-    const service = process.env.AI_GATEWAY_LOG_SERVICE ?? packageName ?? 'AI_GATEWAY';
-    if (!service)
-        return undefined;
-    return {
-        service,
-        env: process.env.NODE_ENV,
+import { createLogxer, getStationRuntimeIdentity, mergeRuntimeIdentity } from '@x12i/logxer';
+/** Stable ERC 2.0 env prefix — controls `AI_GATEWAY_LOGS_LEVEL`, etc. */
+export const GATEWAY_LOG_ENV_PREFIX = 'AI_GATEWAY';
+function resolveGatewayRuntimeIdentity(packageName) {
+    return mergeRuntimeIdentity(getStationRuntimeIdentity(), {
+        service: process.env.AI_GATEWAY_LOG_SERVICE ?? packageName ?? GATEWAY_LOG_ENV_PREFIX,
         version: process.env.npm_package_version
-    };
+    });
 }
 /**
  * Creates a logger instance based on configuration
@@ -28,13 +26,12 @@ export function createGatewayLogger(config) {
         return createNoOpLogger();
     }
     return createLogxer({
-        packageName: config.packageName || 'AI_GATEWAY',
-        envPrefix: config.packageName || 'AI_GATEWAY',
+        packageName: config.packageName || GATEWAY_LOG_ENV_PREFIX,
+        envPrefix: GATEWAY_LOG_ENV_PREFIX,
         debugNamespace: 'ai-gateway'
     }, {
-        logLevel: 'info',
-        logFormat: 'json',
-        runtimeIdentity: resolveDefaultRuntimeIdentity(config.packageName)
+        // Level/format/sinks: ERC 2.0 env discovery (`AI_GATEWAY_LOGS_LEVEL`, host-level format, …).
+        runtimeIdentity: resolveGatewayRuntimeIdentity(config.packageName)
     });
 }
 function createNoOpLogger() {

package/dist/openrouter-routing.d.ts

@@ -0,0 +1,12 @@
+/**
+ * OpenRouter API key and gateway-level "prefer OpenRouter" flag.
+ * Provider/model routing (openrouter vs vendor) is resolved by @x12i/ai-tools in mergeConfig.
+ */
+import type { GatewayConfig } from './types.js';
+export declare function resolveOpenRouterApiKey(config?: GatewayConfig): string | undefined;
+/**
+ * When true, pass `routeViaOpenRouter: true` into ai-tools resolveModel (prefer OpenRouter even with direct keys).
+ * Default: true when OPENROUTER_API_KEY is set. `USE_OPENROUTER=false` turns this off; ai-tools still falls back
+ * when a vendor API key is missing.
+ */
+export declare function resolvePreferOpenRouter(config?: GatewayConfig): boolean;

package/dist/openrouter-routing.js

@@ -0,0 +1,27 @@
+/**
+ * OpenRouter API key and gateway-level "prefer OpenRouter" flag.
+ * Provider/model routing (openrouter vs vendor) is resolved by @x12i/ai-tools in mergeConfig.
+ */
+export function resolveOpenRouterApiKey(config = {}) {
+    const explicit = config.openrouter?.apiKey;
+    if (typeof explicit === 'string' && explicit.trim() && !explicit.startsWith('ENV.')) {
+        return explicit.trim();
+    }
+    const env = process.env.OPENROUTER_API_KEY?.trim();
+    return env || undefined;
+}
+/**
+ * When true, pass `routeViaOpenRouter: true` into ai-tools resolveModel (prefer OpenRouter even with direct keys).
+ * Default: true when OPENROUTER_API_KEY is set. `USE_OPENROUTER=false` turns this off; ai-tools still falls back
+ * when a vendor API key is missing.
+ */
+export function resolvePreferOpenRouter(config = {}) {
+    if (config.openRouter?.enabled === true)
+        return true;
+    if (config.openRouter?.enabled === false)
+        return false;
+    const env = process.env.USE_OPENROUTER;
+    if (env === 'false' || env === '0')
+        return false;
+    return !!resolveOpenRouterApiKey(config);
+}

package/dist/runtime-objects.d.ts

@@ -1,25 +1,8 @@
 import type { Logxer } from '@x12i/logxer';
 import type { Activix, ActivixQueryableClient } from '@x12i/activix';
 export type { ActivixQueryableClient } from '@x12i/activix';
-export type LogxerQueryableClient = {
-    getJobLogs(input: {
-        jobId: string;
-        graphId?: string;
-        nodeId?: string;
-        limit?: number;
-    }): Promise<{
-        jobId: string;
-        lines: Array<{
-            ts?: number | string;
-            level?: 'debug' | 'info' | 'warn' | 'error';
-            scope?: string;
-            packageName?: string;
-            nodeId?: string;
-            message: string;
-            data?: unknown;
-        }>;
-    }>;
-};
+export type { GetJobLogsInput, GetJobLogsResult } from '@x12i/logxer';
+export type LogxerQueryableClient = Pick<Logxer, 'getJobLogs'>;
 export type PackageRuntimeObjects = {
     name: string;
     activixClient?: ActivixQueryableClient;

package/dist/types.d.ts

@@ -375,10 +375,13 @@ export interface GatewayConfig extends Omit<RouterConfig, 'defaultEngine' | 'log
         apiKey: string;
     };
     /**
-     * Enable OpenRouter mode. When omitted, the gateway uses process.env.USE_OPENROUTER or enables when a key is set.
+     * OpenRouter preference (not a hard off-switch when {@link openrouter}.apiKey or OPENROUTER_API_KEY is set).
+     * - `enabled: true` or omitted with OPENROUTER_API_KEY: prefer OpenRouter even when direct provider keys exist.
+     * - `enabled: false` or USE_OPENROUTER=false: use direct providers when their API keys exist; OpenRouter still used as fallback when a requested provider has no key.
      */
     openRouter?: {
         enabled?: boolean;
+        prefer?: boolean;
     };
     /**
      * Operational mode override (`process.env.mode` / `MODE` when omitted).

package/dist-cjs/ai-tools-client.cjs

@@ -1,14 +1,26 @@
 /**
  * Lazy @x12i/ai-tools catalog + cost calculator bootstrap.
  */
-import { AiModelsCatalogClient, CostCalculator } from '@x12i/ai-tools';
+import { AiModelsCatalogClient, CostCalculator, isEffectiveOpenRouterTransport, loadOpenRouterRoutingEnv, resolveModelVendorFromResolution } from '@x12i/ai-tools';
 import { gatewayLogDebug, withActivityIdentity } from './gateway-log-meta.js';
+import { resolvePreferOpenRouter } from './openrouter-routing.js';
 let sharedClientPromise = null;
 let sharedConfigKey;
 let bootstrapFailedLogged = false;
 function configKey(config) {
     return `${config.aiTools?.cacheTtlMs ?? ''}:${config.aiTools?.costIncludeBreakdown ?? ''}:${config.aiTools?.bundledOnly ?? ''}`;
 }
+/**
+ * Per-invoke resolver options: ai-tools decides OpenRouter vs direct from env + optional gateway prefer override.
+ */
+export function buildModelResolverOptions(config, routingEnv) {
+    const env = routingEnv ?? loadOpenRouterRoutingEnv();
+    const prefer = resolvePreferOpenRouter(config);
+    return {
+        routingEnv: env,
+        ...(prefer ? { routeViaOpenRouter: true } : {}),
+    };
+}
 /**
  * Returns catalog + calculator, or null when disabled or bootstrap fails.
  */
@@ -34,33 +46,43 @@ export function resetAiToolsClientForTests() {
 }
 async function bootstrapAiTools(config, logger) {
     try {
+        const routingEnv = loadOpenRouterRoutingEnv();
         const catalog = new AiModelsCatalogClient({
             cacheTtlMs: config.aiTools?.cacheTtlMs,
-            ...(config.aiTools?.bundledOnly ? { bundledOnly: true } : {})
+            ...(config.aiTools?.bundledOnly ? { bundledOnly: true } : {}),
+            resolverOptions: { routingEnv },
         });
         const calculator = new CostCalculator(catalog, {
-            includeBreakdown: config.aiTools?.costIncludeBreakdown === true
+            includeBreakdown: config.aiTools?.costIncludeBreakdown === true,
         });
         logger.debug('ai-tools catalog client ready', {
-            debugKind: gatewayLogDebug.state
+            debugKind: gatewayLogDebug.state,
         });
-        return { catalog, calculator };
+        return { catalog, calculator, routingEnv };
     }
     catch (error) {
         if (!bootstrapFailedLogged) {
             bootstrapFailedLogged = true;
             logger.warn('ai-tools catalog bootstrap failed; model resolution and catalog cost calculation disabled', withActivityIdentity(undefined, {
                 error: error instanceof Error ? error.message : String(error),
-                debugKind: gatewayLogDebug.anomaly
+                debugKind: gatewayLogDebug.anomaly,
             }));
         }
         return null;
     }
 }
 /**
- * Map catalog resolution to router config provider/model fields.
+ * Map catalog resolution to router `{ provider, model }` (agnostic to openrouter vs vendor input).
  */
-export function applyModelResolution(merged, resolution, gatewayDefaultEngine) {
+export function applyModelResolution(merged, resolution, gatewayDefaultEngine, inputModel) {
+    const ref = resolveModelVendorFromResolution(resolution, inputModel ?? merged.model ?? '', {
+        asOpenRouter: resolution.routedViaOpenRouter,
+    });
+    if (ref) {
+        merged.provider = ref.provider;
+        merged.model = ref.model;
+        return;
+    }
     if (resolution.routedViaOpenRouter) {
         merged.provider = 'openrouter';
         merged.model = resolution.modelId;
@@ -81,3 +103,27 @@ export function applyModelResolution(merged, resolution, gatewayDefaultEngine) {
         merged.provider = gatewayDefaultEngine;
     }
 }
+/**
+ * Router invoke flags after mergeConfig + ai-tools resolution (OpenRouter vs direct transport).
+ */
+export function applyOpenRouterInvokePolicy(merged, options) {
+    if (!options.openRouterApiKey?.trim())
+        return;
+    const routingEnv = options.routingEnv ?? loadOpenRouterRoutingEnv();
+    const viaOpenRouter = options.resolution?.routedViaOpenRouter === true ||
+        (options.resolution?.routedViaOpenRouter !== false &&
+            isEffectiveOpenRouterTransport(routingEnv, {
+                provider: merged.provider,
+                modelId: merged.model,
+                routeViaOpenRouter: options.preferOpenRouter ? true : undefined,
+            }));
+    if (viaOpenRouter) {
+        merged.allowOpenRouterProxy = true;
+        if (merged.provider && merged.provider !== 'openrouter') {
+            merged.providerProxy = 'openrouter';
+        }
+    }
+    else {
+        merged.allowOpenRouterProxy = false;
+    }
+}

package/dist-cjs/ai-tools-client.d.ts

@@ -1,13 +1,18 @@
 /**
  * Lazy @x12i/ai-tools catalog + cost calculator bootstrap.
  */
-import { AiModelsCatalogClient, CostCalculator, type ModelResolutionSuccess } from '@x12i/ai-tools';
+import { AiModelsCatalogClient, CostCalculator, type ModelResolutionSuccess, type ModelResolverOptions, type OpenRouterRoutingConfig } from '@x12i/ai-tools';
 import type { Logxer } from '@x12i/logxer';
 import type { ChatRequest, GatewayConfig } from './types.js';
 export type AiToolsClientBundle = {
     catalog: AiModelsCatalogClient;
     calculator: CostCalculator;
+    routingEnv: OpenRouterRoutingConfig;
 };
+/**
+ * Per-invoke resolver options: ai-tools decides OpenRouter vs direct from env + optional gateway prefer override.
+ */
+export declare function buildModelResolverOptions(config: GatewayConfig, routingEnv?: OpenRouterRoutingConfig): ModelResolverOptions;
 /**
  * Returns catalog + calculator, or null when disabled or bootstrap fails.
  */
@@ -15,6 +20,25 @@ export declare function getAiToolsClient(config: GatewayConfig, logger: Logxer):
 /** Reset singleton (tests). */
 export declare function resetAiToolsClientForTests(): void;
 /**
- * Map catalog resolution to router config provider/model fields.
+ * Map catalog resolution to router `{ provider, model }` (agnostic to openrouter vs vendor input).
+ */
+export declare function applyModelResolution(merged: NonNullable<ChatRequest['config']>, resolution: ModelResolutionSuccess, gatewayDefaultEngine?: string, inputModel?: string): void;
+type RouterConfigSlice = {
+    provider?: string;
+    model?: string;
+    allowOpenRouterProxy?: boolean;
+    providerProxy?: string;
+};
+type ModelResolutionMeta = {
+    routedViaOpenRouter?: boolean;
+};
+/**
+ * Router invoke flags after mergeConfig + ai-tools resolution (OpenRouter vs direct transport).
  */
-export declare function applyModelResolution(merged: NonNullable<ChatRequest['config']>, resolution: ModelResolutionSuccess, gatewayDefaultEngine?: string): void;
+export declare function applyOpenRouterInvokePolicy(merged: RouterConfigSlice, options: {
+    openRouterApiKey?: string;
+    preferOpenRouter?: boolean;
+    routingEnv?: OpenRouterRoutingConfig;
+    resolution?: ModelResolutionMeta;
+}): void;
+export {};

package/dist-cjs/gateway-config.cjs

@@ -5,6 +5,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { fileURLToPath } from 'url';
+import { resolveOpenRouterApiKey, resolvePreferOpenRouter, } from './openrouter-routing.js';
 /** Resolve current module directory across ESM/CJS builds. */
 function getModuleDir() {
     if (typeof __dirname !== 'undefined') {
@@ -193,16 +194,19 @@ export function initializeGatewayComponents(config) {
         routerConfig.autoDiscover = config.autoDiscover;
     if (config.usageTracker !== undefined)
         routerConfig.usageTracker = config.usageTracker;
-    // OpenRouter: enable when key is set and not explicitly disabled (so consumers get a working default without registering providers).
-    // Prefer explicit config from consumer (e.g. ai-skills) to avoid env-loading timing; fall back to process.env.
-    const explicitOpenRouterKey = config.openrouter?.apiKey;
-    const isExplicitKey = typeof explicitOpenRouterKey === 'string' && !explicitOpenRouterKey.startsWith('ENV.');
-    const openRouterKey = isExplicitKey ? explicitOpenRouterKey : (process.env.OPENROUTER_API_KEY ?? process.env.OPEN_ROUTER_KEY);
-    const useOpenRouter = config.openRouter?.enabled !== undefined ? config.openRouter?.enabled : process.env.USE_OPENROUTER;
-    if (openRouterKey && useOpenRouter !== false && useOpenRouter !== 'false') {
-        routerConfig.openRouter = { enabled: true };
+    // OpenRouter: always pass apiKey when set (fallback for providers without direct keys).
+    // USE_OPENROUTER=false only disables *preferring* OpenRouter when direct provider keys exist.
+    const openRouterKey = resolveOpenRouterApiKey(config);
+    const preferOpenRouter = resolvePreferOpenRouter(config);
+    if (openRouterKey) {
         routerConfig.openrouter = { apiKey: openRouterKey };
-        routerConfig.defaultMode = 'openrouter';
+        routerConfig.openRouter = {
+            enabled: true,
+            prefer: preferOpenRouter,
+        };
+        if (preferOpenRouter) {
+            routerConfig.defaultMode = 'openrouter';
+        }
     }
     const router = new LLMProviderRouter(routerConfig);
     // Set up BETWEEN-CALLS rate limiting as a request interceptor (applies to all provider calls)
@@ -302,6 +306,8 @@ export function initializeGatewayComponents(config) {
         optimixerManager,
         usageTracker,
         messageBuilderConfig,
-        defaultModelConfig
+        defaultModelConfig,
+        preferOpenRouter,
+        openRouterApiKey: openRouterKey,
     };
 }

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

@@ -51,4 +51,6 @@ export declare function initializeGatewayComponents(config: GatewayConfig): {
     usageTracker: UsageTracker;
     messageBuilderConfig: MessageBuilderConfig;
     defaultModelConfig: Record<string, unknown>;
+    preferOpenRouter: boolean;
+    openRouterApiKey?: string;
 };

package/dist-cjs/gateway-log-meta.cjs

@@ -1,4 +1,4 @@
-import { DebugLogAbstract } from '@x12i/logxer';
+import { DebugLogAbstract, runWithLogContext } from '@x12i/logxer';
 /** Subset of identity forwarded on every structured log line (plus full envelope under `identity`). */
 export function activityIdentityToLogMeta(identity) {
     if (!identity) {
@@ -27,6 +27,24 @@ export function withActivityIdentity(identity, data, debugKind) {
         ...(debugKind !== undefined ? { debugKind } : {})
     };
 }
+/** Map gateway identity into Logxer ALS correlation context (`runWithLogContext`). */
+export function activityIdentityToLogContext(identity) {
+    if (!identity) {
+        return {};
+    }
+    return {
+        jobId: identity.jobId,
+        taskId: identity.taskId,
+        graphId: identity.graphId,
+        nodeId: identity.nodeId,
+        sessionId: identity.sessionId,
+        correlationId: identity.aiRequestId
+    };
+}
+/** Run gateway work with Logxer correlation context for `getJobLogs` and structured envelopes. */
+export function withGatewayLogContext(identity, fn) {
+    return runWithLogContext(activityIdentityToLogContext(identity), fn);
+}
 export const gatewayLogDebug = {
     anomaly: DebugLogAbstract.ANOMALY,
     trace: DebugLogAbstract.TRACE,

package/dist-cjs/gateway-log-meta.d.ts

@@ -1,11 +1,15 @@
 /**
  * Maps gateway {@link ActivityIdentity} into Logxer {@link LogMeta} fields for correlation and querying.
  */
-import type { LogMeta } from '@x12i/logxer';
+import type { LogMeta, LogRuntimeContext } from '@x12i/logxer';
 import type { ActivityIdentity } from './types.js';
 /** Subset of identity forwarded on every structured log line (plus full envelope under `identity`). */
 export declare function activityIdentityToLogMeta(identity: Partial<ActivityIdentity> | undefined): LogMeta;
 export declare function withActivityIdentity(identity: Partial<ActivityIdentity> | undefined, data?: LogMeta, debugKind?: LogMeta['debugKind']): LogMeta;
+/** Map gateway identity into Logxer ALS correlation context (`runWithLogContext`). */
+export declare function activityIdentityToLogContext(identity: Partial<ActivityIdentity> | undefined): LogRuntimeContext;
+/** Run gateway work with Logxer correlation context for `getJobLogs` and structured envelopes. */
+export declare function withGatewayLogContext<T>(identity: Partial<ActivityIdentity> | undefined, fn: () => T | Promise<T>): Promise<T>;
 export declare const gatewayLogDebug: {
     readonly anomaly: "ANOMALY";
     readonly trace: "TRACE";

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

@@ -146,7 +146,7 @@ export async function autoRegisterProviders(router, logger) {
             optionalEnvVars: PROVIDER_CONFIGS
                 .filter(p => p.optional)
                 .map(p => p.envVar),
-            openRouter: 'Set OPENROUTER_API_KEY (and do not set USE_OPENROUTER=false) to use OpenRouter without registering a provider. Legacy OPEN_ROUTER_KEY is still accepted.',
+            openRouter: 'Set OPENROUTER_API_KEY for OpenRouter (default route when set). USE_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)'
         });
     }

package/dist-cjs/gateway-utils.cjs

@@ -9,7 +9,7 @@ import { extractHttpStatusCode } from './gateway-retry.js';
 import { gatewayLogDebug, withActivityIdentity } from './gateway-log-meta.js';
 import { getPreParsedInstructions } from './gateway-instructions.js';
 import { getModelMaxTokensFromFlexMd } from './flex-md-loader.js';
-import { applyModelResolution } from './ai-tools-client.js';
+import { applyModelResolution, buildModelResolverOptions } from './ai-tools-client.js';
 import { getGatewayOperationalMode, isProdGatewayMode, resolveGatewayDefaultModel, warnDefaultModelSubstitution } from './gateway-mode.js';
 /**
  * Generates MD5 hash of a string
@@ -65,14 +65,15 @@ async function tryResolveSubstitutedDefaultModel(merged, request, config, logger
         return;
     }
     try {
+        const resolverOptions = buildModelResolverOptions(config, mergeOptions?.routingEnv);
         const resolution = await catalog.resolveModel({
             provider: merged.provider,
-            model: merged.model
-        });
+            model: merged.model,
+        }, resolverOptions);
         if (!resolution.found) {
             return;
         }
-        applyModelResolution(merged, resolution, config.defaultEngine);
+        applyModelResolution(merged, resolution, config.defaultEngine, merged.model);
         request._modelResolution = {
             modelId: resolution.modelId,
             routedViaOpenRouter: resolution.routedViaOpenRouter,
@@ -182,12 +183,13 @@ export async function mergeConfig(request, config, logger, mergeOptions) {
     }
     else if (resolveModels && mergeOptions?.catalog) {
         try {
+            const resolverOptions = buildModelResolverOptions(config, mergeOptions?.routingEnv);
             const resolution = await mergeOptions.catalog.resolveModel({
                 provider: merged.provider,
-                model: explicitModel
-            });
+                model: explicitModel,
+            }, resolverOptions);
             if (resolution.found) {
-                applyModelResolution(merged, resolution, config.defaultEngine);
+                applyModelResolution(merged, resolution, config.defaultEngine, explicitModel);
                 request._modelResolution = {
                     modelId: resolution.modelId,
                     routedViaOpenRouter: resolution.routedViaOpenRouter,

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

@@ -4,7 +4,7 @@
  */
 import type { AIInvokeRequest, ChatRequest, GatewayConfig, GatewayFallbackAttempt, GatewayInvokeRejectionMetadata, GatewayTraceAttempt, GatewayTraceMergedConfig, GatewayTraceRequestIds, GatewayTraceUsageSummary, ModelConfig } from './types.js';
 import type { Logxer } from '@x12i/logxer';
-import { type AiCostResult, type AiModelsCatalogClient, type CostCalculator } from '@x12i/ai-tools';
+import { type AiCostResult, type AiModelsCatalogClient, type CostCalculator, type OpenRouterRoutingConfig } from '@x12i/ai-tools';
 /**
  * Generates MD5 hash of a string
  */
@@ -16,6 +16,7 @@ export declare function ensureTaskTypeId(request: ChatRequest, logger: Logxer):
 export type MergeConfigOptions = {
     defaultModelConfig?: Record<string, unknown>;
     catalog?: AiModelsCatalogClient | null;
+    routingEnv?: OpenRouterRoutingConfig;
 };
 /**
  * True when any caller-controlled config source set `maxTokens` (Optimixer should not override).