@x12i/ai-gateway 11.0.5 → 11.1.0

package/dist/openrouter-runtime-adapter/map-runtime-errors.js

@@ -1,6 +1,16 @@
-import { OpenRouterHttpError, RuntimeConfigError, } from '@x12i/openrouter-runtime';
 import { GatewayPolicyViolationError, GatewayValidationError, ProviderConfigError, ProviderInvokeError, } from '../instruction-errors.js';
 import { buildPartialMetadataFromRuntimeResponse, buildRouterLikeEnvelopeFromRuntimeResponse, } from './map-runtime-response.js';
+function isRuntimeConfigError(err) {
+    return (err instanceof Error &&
+        err.name === 'RuntimeConfigError' &&
+        typeof err.code === 'string');
+}
+function isOpenRouterHttpError(err) {
+    return (err instanceof Error &&
+        err.name === 'OpenRouterHttpError' &&
+        typeof err.status === 'number' &&
+        typeof err.code === 'string');
+}
 function attachRouterEnvelopeToError(err, response) {
     const envelope = buildRouterLikeEnvelopeFromRuntimeResponse(response);
     err.response = envelope;
@@ -52,7 +62,7 @@ export function throwMappedRuntimeResponseErrors(response) {
     throw err;
 }
 export function mapRuntimeErrorToGatewayError(err) {
-    if (err instanceof RuntimeConfigError) {
+    if (isRuntimeConfigError(err)) {
         try {
             throwMappedRuntimeConfigError(err);
         }
@@ -60,7 +70,7 @@ export function mapRuntimeErrorToGatewayError(err) {
             return mapped;
         }
     }
-    if (err instanceof OpenRouterHttpError) {
+    if (isOpenRouterHttpError(err)) {
         try {
             throwMappedOpenRouterHttpError(err);
         }

package/dist/openrouter-runtime-adapter/map-runtime-response.d.ts

@@ -1,5 +1,5 @@
-import type { AIResponse } from '@x12i/ai-providers-router';
-import type { RuntimeResponse } from '@x12i/openrouter-runtime';
+import type { AIResponse } from '../router-types.js';
+import type { RuntimeResponse } from '@x12i/ai-router-runtime';
 import type { GatewayCitation, GatewayGeneratedImage, GatewayOpenRouterRuntimeMetadata, GatewayPatchProposal, GatewayServerToolUsageMap } from '../types.js';
 export declare function mapRuntimeToolUsage(toolUsage: RuntimeResponse['toolUsage']): GatewayServerToolUsageMap;
 export declare function mapRuntimeCitations(citations: RuntimeResponse['citations']): GatewayCitation[];

package/dist/openrouter-runtime-adapter/map-server-tools.d.ts

@@ -1,3 +1,3 @@
 import type { GatewayServerToolsConfig } from '../types.js';
-import type { RuntimeServerToolsPolicy } from '@x12i/openrouter-runtime';
+import type { RuntimeServerToolsPolicy } from '@x12i/ai-router-runtime';
 export declare function mapGatewayServerTools(config?: GatewayServerToolsConfig): RuntimeServerToolsPolicy | undefined;

package/dist/openrouter-runtime-adapter/should-use-openrouter-runtime.d.ts

@@ -1,11 +1,6 @@
 import type { GatewayConfig } from '../types.js';
 /**
- * Whether the gateway should register @x12i/openrouter-runtime instead of the router's legacy OpenRouter provider.
- *
- * - AI_GATEWAY_USE_LEGACY_OPENROUTER=1 → legacy router OpenRouter
- * - AI_GATEWAY_USE_OPENROUTER_RUNTIME=0 → legacy
- * - GatewayConfig.openrouterRuntime.enabled=false → legacy
- * - default → runtime enabled
+ * Whether OpenRouter runtime path is enabled (always true with @x12i/ai-router-runtime).
  */
 export declare function shouldUseOpenRouterRuntime(config?: GatewayConfig): boolean;
 export declare function resolveOpenRouterRuntimeDefaults(config?: GatewayConfig): {

package/dist/openrouter-runtime-adapter/should-use-openrouter-runtime.js

@@ -1,10 +1,5 @@
 /**
- * Whether the gateway should register @x12i/openrouter-runtime instead of the router's legacy OpenRouter provider.
- *
- * - AI_GATEWAY_USE_LEGACY_OPENROUTER=1 → legacy router OpenRouter
- * - AI_GATEWAY_USE_OPENROUTER_RUNTIME=0 → legacy
- * - GatewayConfig.openrouterRuntime.enabled=false → legacy
- * - default → runtime enabled
+ * Whether OpenRouter runtime path is enabled (always true with @x12i/ai-router-runtime).
  */
 export function shouldUseOpenRouterRuntime(config) {
     const legacyEnv = process.env.AI_GATEWAY_USE_LEGACY_OPENROUTER;

package/dist/router-errors.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Router error types and enrichment helpers for gateway consumers.
+ */
+export declare const PROVIDER_FAILURE_CODES: readonly ["OPENROUTER_API_KEY_MISSING", "PROVIDER_AUTH_FAILED", "PROVIDER_RATE_LIMITED", "PROVIDER_QUOTA_EXCEEDED", "PROVIDER_MODEL_NOT_FOUND", "PROVIDER_GATEWAY_UNREACHABLE", "PROVIDER_NOT_REGISTERED", "PROVIDER_REQUEST_FAILED", "PROVIDER_INVOKE_FAILED"];
+export type ProviderFailureCode = (typeof PROVIDER_FAILURE_CODES)[number];
+export type ProviderAttemptDetail = {
+    provider: string;
+    modelId?: string;
+    httpStatus?: number;
+    message: string;
+    code: ProviderFailureCode;
+    retryable?: boolean;
+};
+export declare function operatorHintForProviderFailureCode(code: ProviderFailureCode): string;
+export type FallbackAttempt = {
+    provider: string;
+    model?: string;
+    httpStatus?: number;
+    code?: ProviderFailureCode;
+    message?: string;
+    error: Error;
+    responsePreview?: string;
+};
+export declare class ProviderNotFoundError extends Error {
+    constructor(providerName: string);
+}
+export declare class OpenRouterApiKeyMissingError extends Error {
+    readonly code: "OPENROUTER_API_KEY_MISSING";
+    constructor();
+}
+export declare class FallbackExhaustedError extends Error {
+    attempts: FallbackAttempt[];
+    code?: ProviderFailureCode;
+    operatorHint?: string;
+    details?: {
+        providerAttempts: ProviderAttemptDetail[];
+    };
+    constructor(attempts: FallbackAttempt[]);
+}
+export declare function buildProviderAttemptDetail(input: {
+    provider: string;
+    modelId?: string;
+    httpStatus?: number;
+    message: string;
+    code?: ProviderFailureCode;
+    err?: unknown;
+}): ProviderAttemptDetail;
+export declare function providerAttemptsFromFallbackAttempts(attempts: FallbackAttempt[]): ProviderAttemptDetail[];
+export declare function enrichRunTaskError(err: Error, input?: {
+    providerAttempts?: ProviderAttemptDetail[];
+    code?: ProviderFailureCode;
+}): Error;

package/dist/router-errors.js

@@ -0,0 +1,115 @@
+/**
+ * Router error types and enrichment helpers for gateway consumers.
+ */
+export const PROVIDER_FAILURE_CODES = [
+    'OPENROUTER_API_KEY_MISSING',
+    'PROVIDER_AUTH_FAILED',
+    'PROVIDER_RATE_LIMITED',
+    'PROVIDER_QUOTA_EXCEEDED',
+    'PROVIDER_MODEL_NOT_FOUND',
+    'PROVIDER_GATEWAY_UNREACHABLE',
+    'PROVIDER_NOT_REGISTERED',
+    'PROVIDER_REQUEST_FAILED',
+    'PROVIDER_INVOKE_FAILED',
+];
+const OPERATOR_HINTS = {
+    OPENROUTER_API_KEY_MISSING: 'Set OPENROUTER_API_KEY or OPEN_ROUTER_KEY, or pass apiKey when creating the runtime.',
+    PROVIDER_AUTH_FAILED: 'Check that the OpenRouter API key is present, valid, and authorized for this route.',
+    PROVIDER_RATE_LIMITED: 'Retry after the provider rate limit resets or reduce request concurrency.',
+    PROVIDER_QUOTA_EXCEEDED: 'Check provider billing, credits, quota, and project limits.',
+    PROVIDER_MODEL_NOT_FOUND: 'Verify the model id and whether it is available through OpenRouter for this account.',
+    PROVIDER_GATEWAY_UNREACHABLE: 'Retry later; the provider gateway was unreachable or timed out.',
+    PROVIDER_NOT_REGISTERED: 'Provider module is not registered; install and configure the provider package.',
+    PROVIDER_REQUEST_FAILED: 'Provider call failed; inspect providerAttempts in error.details for per-attempt diagnostics.',
+    PROVIDER_INVOKE_FAILED: 'Provider call failed; inspect providerAttempts in error.details for per-attempt diagnostics.',
+};
+export function operatorHintForProviderFailureCode(code) {
+    return OPERATOR_HINTS[code];
+}
+export class ProviderNotFoundError extends Error {
+    constructor(providerName) {
+        super(`Provider not found: ${providerName}`);
+        this.name = 'ProviderNotFoundError';
+    }
+}
+export class OpenRouterApiKeyMissingError extends Error {
+    code = 'OPENROUTER_API_KEY_MISSING';
+    constructor() {
+        super('OPENROUTER_API_KEY is required for OpenRouter routing');
+        this.name = 'OpenRouterApiKeyMissingError';
+    }
+}
+export class FallbackExhaustedError extends Error {
+    attempts;
+    code;
+    operatorHint;
+    details;
+    constructor(attempts) {
+        super('All providers in the fallback chain failed');
+        this.name = 'FallbackExhaustedError';
+        this.attempts = attempts;
+    }
+}
+function classifyProviderFailure(err) {
+    const message = err instanceof Error ? err.message : typeof err === 'string' ? err : String(err ?? '');
+    const lower = message.toLowerCase();
+    if (lower.includes('openrouter_api_key') || lower.includes('api key missing')) {
+        return 'OPENROUTER_API_KEY_MISSING';
+    }
+    if (lower.includes('rate limit') || lower.includes('429'))
+        return 'PROVIDER_RATE_LIMITED';
+    if (lower.includes('quota') || lower.includes('insufficient'))
+        return 'PROVIDER_QUOTA_EXCEEDED';
+    if (lower.includes('model not found') || lower.includes('404'))
+        return 'PROVIDER_MODEL_NOT_FOUND';
+    if (lower.includes('unauthorized') || lower.includes('401') || lower.includes('403')) {
+        return 'PROVIDER_AUTH_FAILED';
+    }
+    if (lower.includes('fetch failed') ||
+        lower.includes('econnrefused') ||
+        lower.includes('etimedout') ||
+        lower.includes('network')) {
+        return 'PROVIDER_GATEWAY_UNREACHABLE';
+    }
+    return 'PROVIDER_REQUEST_FAILED';
+}
+export function buildProviderAttemptDetail(input) {
+    return {
+        provider: input.provider,
+        ...(input.modelId !== undefined ? { modelId: input.modelId } : {}),
+        ...(input.httpStatus !== undefined ? { httpStatus: input.httpStatus } : {}),
+        message: input.message,
+        code: input.code ?? classifyProviderFailure(input.err ?? input.message),
+    };
+}
+export function providerAttemptsFromFallbackAttempts(attempts) {
+    return attempts.map((a) => buildProviderAttemptDetail({
+        provider: String(a.provider),
+        modelId: a.model,
+        httpStatus: a.httpStatus,
+        message: a.message ?? a.error.message,
+        code: a.code,
+        err: a.error,
+    }));
+}
+function resolveExhaustedFailureCode(providerAttempts) {
+    if (providerAttempts.length === 0)
+        return 'PROVIDER_REQUEST_FAILED';
+    return providerAttempts[providerAttempts.length - 1].code;
+}
+export function enrichRunTaskError(err, input) {
+    const existingCode = err.code;
+    const providerAttempts = input?.providerAttempts ??
+        (err instanceof FallbackExhaustedError ? providerAttemptsFromFallbackAttempts(err.attempts) : []);
+    const code = input?.code ??
+        existingCode ??
+        (providerAttempts.length > 0 ? resolveExhaustedFailureCode(providerAttempts) : undefined) ??
+        classifyProviderFailure(err);
+    const enriched = err;
+    enriched.code = code;
+    enriched.operatorHint = operatorHintForProviderFailureCode(code);
+    if (providerAttempts.length > 0) {
+        enriched.details = { providerAttempts };
+    }
+    return enriched;
+}

package/dist/router-types.d.ts

@@ -0,0 +1,147 @@
+/**
+ * Router-level types for @x12i/ai-gateway (backed by @x12i/ai-router-runtime).
+ */
+import type { LogLevel, Logxer, StackLoggingOptions } from '@x12i/logxer';
+import type { ProviderFailureCode } from './router-errors.js';
+export type RouterMode = 'sync' | 'stream' | 'batch';
+export type NormalizedUsage = {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+};
+export type ActivityCostStatus = 'priced' | 'unpriced';
+export type ProviderModelRef = {
+    engine?: string;
+    provider?: string;
+    model?: string;
+};
+export type AttemptErrorSummary = {
+    name: string;
+    message: string;
+    code: ProviderFailureCode;
+    httpStatus?: number;
+    responsePreview?: string;
+};
+export type DiagnosticsMetadata = {
+    provider?: string;
+    region?: string;
+    modelUsed?: string;
+    costUsd?: number;
+    cost?: number;
+    costStatus?: ActivityCostStatus;
+    maxTokensRequested?: number;
+    requestIds?: Record<string, string | undefined>;
+    timing?: {
+        startedAt: number;
+        endedAt: number;
+        durationMs: number;
+    };
+    latencyMs?: number;
+    attempts?: unknown[];
+    failureCode?: ProviderFailureCode;
+    providerAttempts?: unknown[];
+    operatorHint?: string;
+    normalization?: {
+        normalizedConfig?: Record<string, unknown>;
+        warnings?: string[];
+    };
+    [key: string]: unknown;
+};
+/**
+ * Router configuration shared between gateway init and standalone router factory.
+ */
+export interface GatewayRouterConfig {
+    usageTracker?: {
+        recordRequest(event: {
+            provider: string;
+            timestamp: number;
+            duration: number;
+            tokens: {
+                input: number;
+                output: number;
+                total: number;
+            };
+            cost?: number;
+            success: boolean;
+        }): void;
+    };
+    verbose?: boolean;
+    logLevel?: LogLevel;
+    logging?: StackLoggingOptions;
+    logger?: Logxer;
+    timeoutMs?: number;
+    defaultTimeoutMs?: number;
+    preferOpenRouter?: boolean;
+    /** @deprecated Use preferOpenRouter. */
+    useOpenRouter?: boolean;
+    openrouter?: {
+        apiKey?: string;
+        httpReferer?: string;
+        xTitle?: string;
+    };
+    fallbackChain?: ProviderModelRef[];
+    defaultProvider?: string;
+    autoDiscover?: boolean;
+}
+export interface AIRouterRequest {
+    requestId?: string;
+    request: Record<string, unknown>;
+    provider?: string;
+    mode: RouterMode;
+    exec?: {
+        timeoutMs?: number;
+        retries?: number;
+        idempotencyKey?: string;
+        signal?: AbortSignal;
+    };
+}
+export type NormalizedRouterOutput = {
+    parsed?: Record<string, unknown>;
+};
+export interface AIResponse {
+    requestId: string;
+    provider: string;
+    rawResponse: unknown;
+    outputText?: string;
+    output?: NormalizedRouterOutput;
+    usage?: NormalizedUsage;
+    reasoning: {
+        requested: {
+            effort: string;
+            visibility: string;
+        };
+        applied: {
+            effort: string;
+            visibility: string;
+        };
+        artifacts: {
+            encrypted?: unknown[];
+            summary?: {
+                text: string;
+                format: string;
+            };
+            trace?: {
+                text: string;
+                format: string;
+            };
+        };
+        availability: {
+            supportsEffort: boolean;
+            supportsSummary: boolean;
+            supportsTrace: boolean;
+            supportsEncrypted: boolean;
+        };
+        warnings?: unknown[];
+    };
+    metadata?: DiagnosticsMetadata;
+}
+export interface HealthCheckResult {
+    provider: string;
+    healthy: boolean;
+    latencyMs?: number;
+    error?: string;
+}
+/** @deprecated Use {@link GatewayRouterConfig}. */
+export type RouterConfig = GatewayRouterConfig;
+/** Backward-compatible alias for {@link GatewayRouter}. */
+export type LLMProviderRouter = import('./gateway-router.js').GatewayRouter;

package/dist/router-types.js

@@ -0,0 +1,4 @@
+/**
+ * Router-level types for @x12i/ai-gateway (backed by @x12i/ai-router-runtime).
+ */
+export {};

package/dist/types.d.ts

@@ -3,7 +3,8 @@
  *
  * Extends router types with gateway-specific enhancements
  */
-import { AIResponse, LLMProviderRouter, type RouterConfig } from '@x12i/ai-providers-router';
+import type { AIResponse, GatewayRouterConfig } from './router-types.js';
+import type { GatewayRouter } from './gateway-router.js';
 type AIProvider = string;
 type AIModel = string;
 export type UsageTier = string;
@@ -366,7 +367,7 @@ export type GatewayInvokeRejectionMetadata = {
      */
     fallbackAttempts?: GatewayFallbackAttempt[];
     /**
-     * Structured per-attempt diagnostics (`@x12i/ai-providers-router` ≥ 4.10).
+     * Structured per-attempt diagnostics from the gateway fallback chain.
      * Same attempts as {@link fallbackAttempts} when enriched; prefer this for UIs.
      */
     providerAttempts?: Array<{
@@ -399,7 +400,7 @@ export type GatewayFallbackAttempt = {
     model?: string;
     httpStatus?: number;
     error: string;
-    /** Stable sub-code from `@x12i/ai-providers-router` ≥ 4.10 (`PROVIDER_AUTH_FAILED`, …). */
+    /** Stable sub-code (`PROVIDER_AUTH_FAILED`, …). */
     code?: string;
     responsePreview?: string;
 };
@@ -456,18 +457,12 @@ export type ActivityIdentity = {
 };
 /** Re-export parser template options for gateway consumers (MUST/optional protocol, subPathSearch, smartInput, etc.). */
 export type { SmartInputConfig, SmartInputRenderOptions, TemplateRenderOptions } from '@x12i/rendrix';
-type LLMRequest = Parameters<LLMProviderRouter['invoke']>[0];
-type LLMResponse = Awaited<ReturnType<LLMProviderRouter['invoke']>>;
+type LLMRequest = Parameters<GatewayRouter['invoke']>[0];
+type LLMResponse = Awaited<ReturnType<GatewayRouter['invoke']>>;
 /**
  * Gateway configuration extending router configuration
  *
- * RouterConfig already includes:
- * - defaultProvider?: LLMProvider (from llm-provider-interface)
- * - fallbackChain?: LLMProvider[]
- * - autoDiscover?: boolean
- * - usageTracker?: UsageTracker
- *
- * We don't need to redeclare these - they're inherited from RouterConfig
+ * GatewayRouterConfig fields (defaultProvider, fallbackChain, usageTracker, …) are inherited below.
  */
 /**
  * Provider + model reference used for defaults and fallbacks
@@ -578,7 +573,7 @@ export interface ModelConfig {
 }
 /** Alias for {@link ModelConfig} in gateway documentation. */
 export type GatewayModelConfig = ModelConfig;
-export interface GatewayConfig extends Omit<RouterConfig, 'defaultEngine' | 'logger'> {
+export interface GatewayConfig extends Omit<GatewayRouterConfig, 'logger'> {
     /**
      * Default target (engine + model) for routing
      */
@@ -610,8 +605,8 @@ export interface GatewayConfig extends Omit<RouterConfig, 'defaultEngine' | 'log
     /**
      * Process-wide package log level registry (logxer ≥ 4.5).
      * Merged after `applyPackageLogLevelsFromEnv()` on first gateway init.
-     * `logging` (from {@link RouterConfig}) is forwarded to the gateway logger and router.
-     * @example `{ default: 'warn', levels: { AI_GATEWAY: 'info', AI_PROVIDER_ROUTER: 'debug' } }`
+     * `logging` is forwarded to the gateway logger and router runtime.
+     * @example `{ default: 'warn', levels: { AI_GATEWAY: 'info', AI_ROUTER_RUNTIME: 'debug' } }`
      */
     packageLogLevels?: PackageLogLevelsConfig;
     /**
@@ -627,7 +622,7 @@ export interface GatewayConfig extends Omit<RouterConfig, 'defaultEngine' | 'log
     packageName?: string;
     /**
      * Full payload logging for gateway-owned verbose lines (`AI_GATEWAY_VERBOSE=true`).
-     * Separate from log threshold (`AI_GATEWAY_LOGS_LEVEL=verbose`). Router I/O payloads use the same flag via `RouterConfig.verbose`.
+     * Separate from log threshold (`AI_GATEWAY_LOGS_LEVEL=verbose`). Router I/O payloads use the same flag via `GatewayRouterConfig.verbose`.
      */
     verbose?: boolean;
     /**

package/dist-cjs/gateway-config.cjs

@@ -6,12 +6,11 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { fileURLToPath } from 'url';
 import { resolveOpenRouterApiKey, resolvePreferOpenRouter, } from './openrouter-routing.js';
-import { LLMProviderRouter } from '@x12i/ai-providers-router';
+import { GatewayRouter } from './gateway-router.js';
 import { createGatewayLogger } from './logger-factory.js';
 import { ActivityManager } from './activity-manager.js';
 import { UsageTracker } from './usage-tracker.js';
 import { mergeTemplateRenderOptions } from './template-render-merge.js';
-import { registerOpenRouterRuntime, shouldUseOpenRouterRuntime, } from './openrouter-runtime-adapter/index.js';
 /** Resolve current module directory across ESM/CJS builds. */
 function getModuleDir() {
     if (typeof __dirname !== 'undefined') {
@@ -83,12 +82,12 @@ export function loadConfig(logger) {
  */
 export function setupRequestInterceptor(router, logger) {
     logger.debug('Setting up request interceptor for jobId propagation and config cleanup');
-    router.addRequestInterceptor(async (request, provider) => {
+    router.addRequestInterceptor(async (request) => {
         const identityJobId = request?.identity?.jobId;
         if (typeof identityJobId === 'string' && identityJobId.trim().length > 0) {
             logger.verbose('Propagating identity.jobId to request metadata', {
                 jobId: identityJobId,
-                provider: provider?.getProviderName?.() || 'unknown'
+                provider: 'openrouter'
             });
             if (!request.config) {
                 request.config = {};
@@ -99,7 +98,7 @@ export function setupRequestInterceptor(router, logger) {
             request.config.metadata.jobId = identityJobId;
         }
         if (request.config && 'provider' in request.config) {
-            logger.debug('Removing provider from config before passing to provider', {
+            logger.debug('Removing provider from config before passing to router', {
                 provider: request.config.provider
             });
             const { provider: _, ...cleanConfig } = request.config;
@@ -126,59 +125,25 @@ export function initializeGatewayComponents(config) {
         defaultEngine: config.defaultEngine,
         hasTemplateRenderingDefaults: !!defaultTemplateRendering
     });
-    const routerConfig = {};
-    const defaultTarget = config.defaultTarget;
-    if (defaultTarget) {
-        routerConfig.defaultTarget = defaultTarget;
-    }
-    else if (config.defaultProvider !== undefined) {
-        routerConfig.defaultProvider = config.defaultProvider;
-    }
-    else if (config.defaultEngine !== undefined) {
-        routerConfig.defaultProvider = config.defaultEngine;
-    }
-    const fallbackChain = config.fallbackChain;
-    if (fallbackChain) {
-        routerConfig.fallbackChain = fallbackChain;
-    }
-    else if (config.fallbackChain !== undefined) {
-        routerConfig.fallbackChain = config.fallbackChain;
-    }
-    if (config.autoDiscover !== undefined)
-        routerConfig.autoDiscover = config.autoDiscover;
-    if (config.usageTracker !== undefined)
-        routerConfig.usageTracker = config.usageTracker;
-    if (config.verbose !== undefined)
-        routerConfig.verbose = config.verbose;
-    if (config.logLevel !== undefined)
-        routerConfig.logLevel = config.logLevel;
-    if (config.logging !== undefined)
-        routerConfig.logging = config.logging;
     const openRouterKey = resolveOpenRouterApiKey(config);
     const preferOpenRouter = resolvePreferOpenRouter(config);
-    if (openRouterKey) {
-        routerConfig.openrouter = { apiKey: openRouterKey };
-        routerConfig.openRouter = {
-            enabled: true,
-            prefer: preferOpenRouter,
-        };
-        if (preferOpenRouter) {
-            routerConfig.defaultMode = 'openrouter';
-        }
-    }
-    const router = new LLMProviderRouter(routerConfig);
+    const router = new GatewayRouter({
+        verbose: config.verbose,
+        logLevel: config.logLevel,
+        logging: config.logging,
+        logger,
+        usageTracker: config.usageTracker,
+        openrouterRuntime: config.openrouterRuntime,
+        ...(openRouterKey ? { openrouter: { apiKey: openRouterKey } } : {}),
+    });
     setupRequestInterceptor(router, logger);
-    if (openRouterKey && shouldUseOpenRouterRuntime(config)) {
-        registerOpenRouterRuntime(router, {
-            apiKey: openRouterKey,
-            logger,
-            runtimeConfig: config.openrouterRuntime,
+    if (openRouterKey) {
+        logger.debug('OpenRouter runtime enabled via @x12i/ai-router-runtime', {
+            openrouterRuntimeEnabled: config.openrouterRuntime?.enabled !== false,
         });
     }
-    else if (openRouterKey) {
-        logger.debug('OpenRouter legacy provider path enabled (runtime disabled)', {
-            AI_GATEWAY_USE_OPENROUTER_RUNTIME: process.env.AI_GATEWAY_USE_OPENROUTER_RUNTIME,
-            AI_GATEWAY_USE_LEGACY_OPENROUTER: process.env.AI_GATEWAY_USE_LEGACY_OPENROUTER,
+    else {
+        logger.debug('OpenRouter runtime not configured (OPENROUTER_API_KEY missing)', {
             openrouterRuntimeEnabled: config.openrouterRuntime?.enabled,
         });
     }

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

@@ -4,7 +4,7 @@
  */
 import type { GatewayConfig } from './types.js';
 import type { Logxer } from '@x12i/logxer';
-import { LLMProviderRouter } from '@x12i/ai-providers-router';
+import { GatewayRouter } from './gateway-router.js';
 import { ActivityManager } from './activity-manager.js';
 import { UsageTracker } from './usage-tracker.js';
 import type { MessageBuilderConfig } from './message-builder.js';
@@ -12,7 +12,7 @@ import type { TemplateRenderOptions } from '@x12i/rendrix';
 export interface GatewayConfigContext {
     config: GatewayConfig;
     logger: Logxer;
-    router: LLMProviderRouter;
+    router: GatewayRouter;
     activityManager: ActivityManager;
     usageTracker: UsageTracker;
     messageBuilderConfig: MessageBuilderConfig;
@@ -27,13 +27,13 @@ export declare function loadConfig(logger: Logxer): {
 /**
  * Sets up request interceptor for jobId propagation and config cleanup
  */
-export declare function setupRequestInterceptor(router: LLMProviderRouter, logger: Logxer): void;
+export declare function setupRequestInterceptor(router: GatewayRouter, logger: Logxer): void;
 /**
  * Initializes gateway components
  */
 export declare function initializeGatewayComponents(config: GatewayConfig): {
     logger: Logxer;
-    router: LLMProviderRouter;
+    router: GatewayRouter;
     activityManager: ActivityManager;
     usageTracker: UsageTracker;
     messageBuilderConfig: MessageBuilderConfig;

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

@@ -3,7 +3,8 @@
  * @see node_modules/@x12i/logxer/docs/package-log-levels-stack.md
  */
 import { applyPackageLogLevelsFromEnv, mergePackageLogLevelsConfig } from '@x12i/logxer';
-import { ROUTER_LOG_ENV_PREFIX } from '@x12i/ai-providers-router';
+/** @deprecated Use {@link ROUTER_LOG_ENV_PREFIX} from gateway-router. Kept for env var compatibility. */
+export const ROUTER_LOG_ENV_PREFIX = 'AI_ROUTER_RUNTIME';
 /** Stable ERC 2.0 env prefix — controls `AI_GATEWAY_LOGS_LEVEL`, etc. */
 export const GATEWAY_LOG_ENV_PREFIX = 'AI_GATEWAY';
 /**

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

@@ -3,6 +3,8 @@
  * @see node_modules/@x12i/logxer/docs/package-log-levels-stack.md
  */
 import { type PackageLogLevelsConfig } from '@x12i/logxer';
+/** @deprecated Use {@link ROUTER_LOG_ENV_PREFIX} from gateway-router. Kept for env var compatibility. */
+export declare const ROUTER_LOG_ENV_PREFIX = "AI_ROUTER_RUNTIME";
 /** Stable ERC 2.0 env prefix — controls `AI_GATEWAY_LOGS_LEVEL`, etc. */
 export declare const GATEWAY_LOG_ENV_PREFIX = "AI_GATEWAY";
 /**
@@ -17,7 +19,7 @@ export declare const GATEWAY_LOGXER_PACKAGE: {
 /** Known `envPrefix` values in this package's dependency stack (for hosts / `.env`). */
 export declare const GATEWAY_STACK_LOG_PREFIXES: {
     readonly gateway: "AI_GATEWAY";
-    readonly router: "AI_PROVIDER_ROUTER";
+    readonly router: "AI_ROUTER_RUNTIME";
     readonly flexMd: "FLEX_MD";
 };
 /**