@x12i/ai-gateway 11.0.7 → 11.1.1

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

@@ -6,7 +6,7 @@
  * Between-calls rate limiting is handled separately in gateway-rate-limiter.ts (smart).
  */
 import type { RetryConfig } from './types.js';
-import type { LLMProviderRouter } from '@x12i/ai-providers-router';
+import type { GatewayRouter } from './gateway-router.js';
 import type { Logxer } from '@x12i/logxer';
 /**
  * Determines if an error is a network error (fetch failed, DNS, connectivity)
@@ -34,7 +34,7 @@ export declare function sleep(ms: number): Promise<void>;
  * Invokes router with retry logic for network and server errors
  * Returns response and retry metadata
  */
-export declare function invokeWithRetry(routerRequest: any, retryConfig: RetryConfig, jobId: string, router: LLMProviderRouter, logger: Logxer, hooks?: {
+export declare function invokeWithRetry(routerRequest: any, retryConfig: RetryConfig, jobId: string, router: GatewayRouter, logger: Logxer, hooks?: {
     /**
      * Called immediately before each provider call attempt (including the first try).
      * `retryIndex` is 0-based within this invokeWithRetry call.

package/dist-cjs/gateway-router.cjs

@@ -0,0 +1,118 @@
+/**
+ * Gateway router backed by @x12i/ai-router-runtime.
+ */
+import { createAiRouterRuntime, AiRouterError, } from '@x12i/ai-router-runtime';
+import { resolveOpenRouterRuntimeDefaults } from './openrouter-runtime-adapter/should-use-openrouter-runtime.js';
+import { mapGatewayRequestToRuntimeRequest, } from './openrouter-runtime-adapter/map-gateway-request.js';
+import { parseRuntimeResponseToAIResponse } from './openrouter-runtime-adapter/map-runtime-response.js';
+import { mapRuntimeErrorToGatewayError, throwMappedRuntimeResponseErrors, } from './openrouter-runtime-adapter/map-runtime-errors.js';
+import { OpenRouterApiKeyMissingError } from './router-errors.js';
+/** Stable ERC 2.0 env prefix for router runtime logging. */
+export const ROUTER_LOG_ENV_PREFIX = 'AI_ROUTER_RUNTIME';
+function mapLogxerToRuntimeLogger(logger) {
+    return {
+        debug: (event, data) => logger.debug(event, data),
+        info: (event, data) => logger.info(event, data),
+        warn: (event, data) => logger.warn(event, data),
+        error: (event, data) => logger.error(event, data),
+    };
+}
+function buildRuntimeOptions(config, apiKey) {
+    const runtimeDefaults = resolveOpenRouterRuntimeDefaults({ openrouterRuntime: config.openrouterRuntime });
+    const timeoutMs = config.timeoutMs ?? config.defaultTimeoutMs;
+    return {
+        provider: 'openrouter',
+        logger: config.logger ? mapLogxerToRuntimeLogger(config.logger) : undefined,
+        openrouter: {
+            apiKey,
+            defaults: {
+                apiMode: runtimeDefaults.apiMode,
+                retry: { enabled: false },
+                onPolicyViolation: 'throw',
+                ...(timeoutMs ? { timeoutMs } : {}),
+            },
+        },
+    };
+}
+export class GatewayRouter {
+    runtime;
+    logger;
+    apiKey;
+    requestInterceptors = [];
+    constructor(config = {}) {
+        this.logger = config.logger;
+        this.apiKey = config.openrouter?.apiKey;
+        this.runtime = createAiRouterRuntime(buildRuntimeOptions(config, this.apiKey));
+    }
+    addRequestInterceptor(interceptor) {
+        this.requestInterceptors.push(interceptor);
+    }
+    addResponseInterceptor(_interceptor) {
+        this.logger?.debug('addResponseInterceptor is not supported with @x12i/ai-router-runtime');
+    }
+    async invoke(input) {
+        if (!this.apiKey) {
+            throw new OpenRouterApiKeyMissingError();
+        }
+        let request = { ...(input.request ?? {}) };
+        for (const interceptor of this.requestInterceptors) {
+            request = (await interceptor(request, { getProviderName: () => 'openrouter' }));
+        }
+        const runtimeRequest = mapGatewayRequestToRuntimeRequest(request, {
+            timeoutMs: input.exec?.timeoutMs,
+        });
+        try {
+            const response = await this.runtime.run(runtimeRequest);
+            if (response.status !== 'completed') {
+                throwMappedRuntimeResponseErrors(response);
+            }
+            return parseRuntimeResponseToAIResponse({
+                requestId: input.requestId ?? runtimeRequest.id ?? 'unknown',
+                execResult: { rawResponse: response },
+            });
+        }
+        catch (err) {
+            if (err instanceof AiRouterError && err.code === 'OPENROUTER_API_KEY_MISSING') {
+                throw new OpenRouterApiKeyMissingError();
+            }
+            throw mapRuntimeErrorToGatewayError(err);
+        }
+    }
+    registerProvider(_provider) {
+        this.logger?.warn('registerProvider is not supported with @x12i/ai-router-runtime; only openrouter is available');
+    }
+    listProviders() {
+        return this.apiKey ? ['openrouter'] : [];
+    }
+    getAdapterRegistry() {
+        return { register: () => undefined };
+    }
+    getProviderRegistry() {
+        return {
+            register: () => undefined,
+            unregister: () => undefined,
+            get: () => undefined,
+        };
+    }
+    async checkHealth(provider) {
+        if (provider !== 'openrouter') {
+            return { provider, healthy: false, error: `Provider "${provider}" is not supported` };
+        }
+        if (!this.apiKey) {
+            return { provider, healthy: false, error: 'OPENROUTER_API_KEY is missing' };
+        }
+        return { provider, healthy: true, latencyMs: 0 };
+    }
+    /** Access the underlying @x12i/ai-router-runtime instance. */
+    getRuntime() {
+        return this.runtime;
+    }
+}
+/** @deprecated Use {@link GatewayRouter}. */
+export const LLMProviderRouter = GatewayRouter;
+export async function createRouter(config) {
+    return new GatewayRouter(config ?? {});
+}
+export async function createRouterFromConfig(_configPath) {
+    return createRouter();
+}

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

@@ -0,0 +1,42 @@
+/**
+ * Gateway router backed by @x12i/ai-router-runtime.
+ */
+import { type AiRouterRuntime } from '@x12i/ai-router-runtime';
+import type { AIResponse, AIRouterRequest, GatewayRouterConfig, HealthCheckResult } from './router-types.js';
+import type { GatewayOpenRouterRuntimeConfig } from './types.js';
+/** Stable ERC 2.0 env prefix for router runtime logging. */
+export declare const ROUTER_LOG_ENV_PREFIX = "AI_ROUTER_RUNTIME";
+export type CreateRouterConfig = GatewayRouterConfig & {
+    openrouterRuntime?: GatewayOpenRouterRuntimeConfig;
+};
+type RequestInterceptor = (request: Record<string, unknown>, provider?: {
+    getProviderName?: () => string;
+}) => Promise<Record<string, unknown>> | Record<string, unknown>;
+export declare class GatewayRouter {
+    private readonly runtime;
+    private readonly logger?;
+    private readonly apiKey?;
+    private readonly requestInterceptors;
+    constructor(config?: CreateRouterConfig);
+    addRequestInterceptor(interceptor: RequestInterceptor): void;
+    addResponseInterceptor(_interceptor: unknown): void;
+    invoke(input: AIRouterRequest): Promise<AIResponse>;
+    registerProvider(_provider: unknown): void;
+    listProviders(): string[];
+    getAdapterRegistry(): {
+        register: (_adapter: unknown) => void;
+    };
+    getProviderRegistry(): {
+        register: (_provider: unknown) => void;
+        unregister: (_name: string) => void;
+        get: (_name: string) => undefined;
+    };
+    checkHealth(provider: string): Promise<HealthCheckResult>;
+    /** Access the underlying @x12i/ai-router-runtime instance. */
+    getRuntime(): AiRouterRuntime;
+}
+/** @deprecated Use {@link GatewayRouter}. */
+export declare const LLMProviderRouter: typeof GatewayRouter;
+export declare function createRouter(config?: CreateRouterConfig): Promise<GatewayRouter>;
+export declare function createRouterFromConfig(_configPath: string): Promise<GatewayRouter>;
+export {};

package/dist-cjs/gateway-utils.cjs

@@ -3,7 +3,7 @@
  * Handles utility functions
  */
 import * as crypto from 'crypto';
-import { FallbackExhaustedError, enrichRunTaskError, providerAttemptsFromFallbackAttempts } from '@x12i/ai-providers-router';
+import { FallbackExhaustedError, enrichRunTaskError, providerAttemptsFromFallbackAttempts } from './router-errors.js';
 import { ModelResolutionError, ModelProfileInputRejectedError, ModelProfileUnroutableError, resolveInvokeModel, } from '@x12i/ai-tools';
 import { extractHttpStatusCode } from './gateway-retry.js';
 import { gatewayLogDebug, withActivityIdentity } from './gateway-log-meta.js';

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

@@ -3,8 +3,8 @@
  * Handles utility functions
  */
 import type { AIInvokeRequest, ChatRequest, GatewayConfig, GatewayFallbackAttempt, GatewayInvokeRejectionMetadata, GatewayTraceAttempt, GatewayTraceMergedConfig, GatewayTraceRequestIds, GatewayTraceUsageSummary, ModelConfig } from './types.js';
-import { FallbackExhaustedError } from '@x12i/ai-providers-router';
-import type { ProviderFailureCode } from '@x12i/ai-providers-router';
+import { FallbackExhaustedError } from './router-errors.js';
+import type { ProviderFailureCode } from './router-errors.js';
 import type { Logxer } from '@x12i/logxer';
 import { type AiCostResult, type AiModelsCatalogClient, type CostCalculator, type OpenRouterRoutingConfig } from '@x12i/ai-tools';
 import { pickOpenRouterRuntimeMetadataSlice, enrichTraceOpenRouterRuntimeMetadata } from './openrouter-runtime-adapter/index.js';

package/dist-cjs/gateway.cjs

@@ -3,7 +3,7 @@
  *
  * Simplified AI Gateway - Clean proxy implementation
  */
-import { FallbackExhaustedError } from '@x12i/ai-providers-router';
+import { FallbackExhaustedError } from './router-errors.js';
 import { validateChatRequest, validateAIRequest } from './gateway-validation.js';
 import { ensureGatewayRequestIdentity } from './activity-manager.js';
 import { initializeGatewayComponents } from './gateway-config.js';
@@ -14,14 +14,13 @@ import { enrichParsedContentForOutputContract, resolveOutputContractFieldKeys }
 import { attachGatewayInvokeRejectionMetadata, buildGatewayFallbackAttemptsFromTrace, buildInvokeRejectionMetadata, capActivityFullResponsePayload, formatFallbackExhaustionMessage, logResolvedModelRouting, enrichGatewayFallbackExhaustedError, mapGatewayFallbackAttemptsToRouter, DEFAULT_ACTIVITY_FULL_RESPONSE_MAX_CHARS, extractCostUsdFromRouterResponse, extractTokenUsageFromRouterResponse, mergeConfig, pickEffectiveModelConfigForMetadata, pickInvokeRoutingMetadataSlice, pickTraceMergedRouterConfig, pickEnhancedOpenRouterMetadata, resolveCostCompletionWithAiTools, buildTraceUsageSummary, enrichTraceAttemptsWithBilling, tryExtractRouterLikePayloadFromErrorChain, tryExtractOpenRouterMetadataFromErrorChain, } from './gateway-utils.js';
 import { buildTraceAttemptOpenRouterRuntimeSlice } from './openrouter-runtime-adapter/index.js';
 import { getAiToolsClient } from './ai-tools-client.js';
-import { autoRegisterProviders } from './gateway-provider-auto-register.js';
 import { setGatewayLastJobId, setGatewayRuntimeClients } from './runtime-objects.js';
 import { gatewayLogDebug, withActivityIdentity, withGatewayLogContext } from './gateway-log-meta.js';
 import { exceptionEvidence, fieldEvidence, GatewayLogCode, gatewayErrorCode, gatewayWarnCode } from './gateway-log-diagnostics.js';
 import { invokeWithRetry } from './gateway-retry.js';
-/** Error message thrown by the router when no provider is registered or specified */
-const NO_PROVIDER_ERROR = 'No provider specified and no providers registered';
-const NO_PROVIDER_HINT = ' Set OPENROUTER_API_KEY in the environment to use OpenRouter, or register a provider with the router (e.g. via autoRegisterProviders or gateway config).';
+/** Error message when OpenRouter is not configured */
+const NO_PROVIDER_ERROR = 'OPENROUTER_API_KEY is required';
+const NO_PROVIDER_HINT = ' Set OPENROUTER_API_KEY in the environment to use OpenRouter.';
 /** Warn when a successful call reports no tokens and/or explicit zero cost (often missing adapter metadata). */
 function warnIfSuccessfulInvokeReportsZeroUsageOrCost(logger, identity, meta, invokeKind) {
     const { tokens, costUsd, cost } = meta;
@@ -58,7 +57,6 @@ export class AIGateway {
     logger;
     activityManager;
     messageBuilderConfig;
-    _autoRegisterDone = false;
     _aiToolsClient = null;
     preferOpenRouter;
     openRouterApiKey;
@@ -151,11 +149,6 @@ export class AIGateway {
             });
             // Activix start snapshot must match what the router receives (modelConfig-only callers omit request.config.model).
             request._mergedRouterConfig = mergedConfig;
-            // Lazy auto-register providers from env (OPENAI_API_KEY, etc.) so consumers don't have to call init
-            if (!this._autoRegisterDone) {
-                await autoRegisterProviders(this.router, this.logger);
-                this._autoRegisterDone = true;
-            }
             // Start activity tracking if available
             let activity = undefined;
             if (this.activityManager) {
@@ -346,11 +339,6 @@ export class AIGateway {
             const diagnosticsMode = request.diagnostics?.mode;
             const traceEnabled = diagnosticsMode === 'trace';
             const includeRawProviderPayload = request.diagnostics?.includeRawProviderPayload === true;
-            // Lazy auto-register providers from env (OPENAI_API_KEY, etc.) so consumers don't have to call init
-            if (!this._autoRegisterDone) {
-                await autoRegisterProviders(this.router, this.logger);
-                this._autoRegisterDone = true;
-            }
             // Start activity tracking if available
             let activity = undefined;
             if (this.activityManager) {

package/dist-cjs/gateway.d.ts

@@ -3,7 +3,7 @@
  *
  * Simplified AI Gateway - Clean proxy implementation
  */
-import { LLMProviderRouter } from '@x12i/ai-providers-router';
+import { GatewayRouter } from './gateway-router.js';
 import type { GatewayConfig, ChatRequest, AIInvokeRequest, EnhancedLLMResponse } from './types.js';
 import type { Logxer } from '@x12i/logxer';
 import { ActivityManager } from './activity-manager.js';
@@ -16,7 +16,6 @@ export declare class AIGateway {
     private logger;
     private activityManager?;
     private messageBuilderConfig?;
-    private _autoRegisterDone;
     private _aiToolsClient;
     private readonly preferOpenRouter;
     private readonly openRouterApiKey?;
@@ -31,7 +30,7 @@ export declare class AIGateway {
     invoke<TContent = unknown>(request: AIInvokeRequest): Promise<EnhancedLLMResponse<TContent>>;
     register(provider: any): void;
     listProviders(): string[];
-    getRouter(): LLMProviderRouter;
+    getRouter(): GatewayRouter;
     getLogger(): Logxer;
     getActivityManager(): ActivityManager | undefined;
     setActivityManager(activityManager: ActivityManager): void;

package/dist-cjs/index.cjs

@@ -2,23 +2,18 @@
  * @x12i/ai-gateway
  *
  * Unified gateway for LLM provider routing and management.
- * This package exposes all functionality from @x12i/ai-providers-router
- * with enhanced features: context propagation, usage tier tracking, and comprehensive metadata.
+ * Router execution is backed by @x12i/ai-router-runtime with enhanced gateway features.
  */
-// Re-export router class and types (base functionality)
-export { LLMProviderRouter } from '@x12i/ai-providers-router';
-// Re-export factory functions
-export { createRouter, createRouterFromConfig } from '@x12i/ai-providers-router';
-// Re-export error classes
-export { ProviderNotFoundError, FallbackExhaustedError, OpenRouterApiKeyMissingError, } from '@x12i/ai-providers-router';
-// Re-export all from router (includes everything it exports)
-export * from '@x12i/ai-providers-router';
+// Router runtime (OpenRouter protocol)
+export { createAiRouterRuntime, AiRouterError, IMPLEMENTED_AI_PROVIDERS, isImplementedAiProvider, providerNotImplemented, resolveProvider, } from '@x12i/ai-router-runtime';
+// Gateway router (invoke-compatible wrapper)
+export { GatewayRouter, LLMProviderRouter, createRouter, createRouterFromConfig, ROUTER_LOG_ENV_PREFIX, } from './gateway-router.js';
+export { FallbackExhaustedError, ProviderNotFoundError, OpenRouterApiKeyMissingError, PROVIDER_FAILURE_CODES, operatorHintForProviderFailureCode, enrichRunTaskError, providerAttemptsFromFallbackAttempts, buildProviderAttemptDetail, } from './router-errors.js';
 // Export enhanced gateway
 export { AIGateway } from './gateway.js';
 export { InstructionNotFoundError, InstructionBackendError, ModelRequiredError, MaxTokensRequiredError, GatewayAliasModelRejectedError, GatewayValidationError, ProviderConfigError, ProviderInvokeError, GatewayPolicyViolationError, } from './instruction-errors.js';
 export { normalizeInvokeModelAtIngress } from './invoke-model-ingress.js';
-export { autoRegisterProviders } from './gateway-provider-auto-register.js';
-export { registerOpenRouterRuntime, shouldUseOpenRouterRuntime, mapGatewayServerTools, } from './openrouter-runtime-adapter/index.js';
+export { shouldUseOpenRouterRuntime, mapGatewayServerTools, } from './openrouter-runtime-adapter/index.js';
 export { attachGatewayInvokeRejectionMetadata, buildInvokeRejectionMetadata, tryExtractRouterLikePayloadFromErrorChain, tryExtractOpenRouterMetadataFromErrorChain, tryExtractFallbackAttemptsFromErrorChain, pickRequestIdsFromRouterLike, resolveActivityCostCompletion, resolveCostCompletionForActivity, resolveCostCompletionWithAiTools, buildGatewayPricingRecord, mapAiCostResultToResolvedActivityCost, catalogPricingSucceeded, extractUsageExtrasFromRouterResponse, buildTraceUsageSummary, enrichTraceAttemptsWithBilling, pickEnhancedOpenRouterMetadata, hasNonZeroTokenUsage, MODEL_PROFILE_UNROUTABLE, ModelProfileUnroutableError, ModelProfileInputRejectedError, buildGatewayFallbackAttemptsFromTrace, formatFallbackExhaustionMessage, enrichGatewayFallbackExhaustedError, logResolvedModelRouting, mapGatewayFallbackAttemptsToRouter } from './gateway-utils.js';
 export { getGatewayOperationalMode, isProdGatewayMode, parseModelProviderSpec } from './gateway-mode.js';
 export { DEFAULT_ACTIVITY_FULL_RESPONSE_MAX_CHARS, GATEWAY_DEFAULT_FREQUENCY_PENALTY, GATEWAY_DEFAULT_PRESENCE_PENALTY, GATEWAY_DEFAULT_RETRY, GATEWAY_DEFAULT_TEMPERATURE, GATEWAY_DEFAULT_TOP_P, resolveRetryConfig } from './gateway-defaults.js';
@@ -39,7 +34,6 @@ export { GatewayLogCode, gatewayErrorCode, gatewayInfoCode, gatewayWarnCode, gat
 export { resolveInvokeModel, applyModelResolution, applyOpenRouterInvokeRouting, applyOpenRouterInvokePolicy, mapResolutionToRouterConfig, buildInvokeModelResolverOptions, buildModelResolverOptions, enrichModelResolutionError, getAiToolsClient, resetAiToolsClientForTests, resolveOpenRouterApiKey, resolvePreferOpenRouter, readPreferOpenRouterFromEnv, getAiToolsInvokeClient, createAiToolsInvokeClient, } from './ai-tools-client.js';
 // Re-export logging (@x12i/logxer)
 export { createLogxer, DebugLogAbstract, runWithLogContext, getStationRuntimeIdentity, mergeRuntimeIdentity, conditionEvidence, sourceEvidence, logReferenceEvidence, readAgentLoggingInstructions, resolveAgentLoggingInstructionsPath, applyPackageLogLevelsFromEnv, configurePackageLogLevels, mergePackageLogLevelsConfig, setPackageLogLevel, resolveStackLogLevelForPrefix, resolvePackageLogsLevel, parseLogxerPackageLevelsEnv, LOGXER_PACKAGE_LEVELS_ENV, LOGXER_PACKAGE_LOGS_DEFAULT_ENV } from '@x12i/logxer';
-export { ROUTER_LOG_ENV_PREFIX } from '@x12i/ai-providers-router';
 // Runtime observability surface (leaf package: no downstream runtime objects)
 export { runtimeObjects } from './runtime-objects.js';
 // Runtime observability surface (leaf package: no downstream runtime objects)

package/dist-cjs/index.d.ts

@@ -2,22 +2,19 @@
  * @x12i/ai-gateway
  *
  * Unified gateway for LLM provider routing and management.
- * This package exposes all functionality from @x12i/ai-providers-router
- * with enhanced features: context propagation, usage tier tracking, and comprehensive metadata.
+ * Router execution is backed by @x12i/ai-router-runtime with enhanced gateway features.
  */
-export { LLMProviderRouter } from '@x12i/ai-providers-router';
-export type { RouterConfig, HealthCheckResult } from '@x12i/ai-providers-router';
-export { createRouter, createRouterFromConfig } from '@x12i/ai-providers-router';
-export type { CreateRouterConfig } from '@x12i/ai-providers-router';
-export { ProviderNotFoundError, FallbackExhaustedError, OpenRouterApiKeyMissingError, } from '@x12i/ai-providers-router';
-export type { RequestInterceptor, ResponseInterceptor } from '@x12i/ai-providers-router';
-export type { UsageTracker } from '@x12i/ai-providers-router';
-export * from '@x12i/ai-providers-router';
+export { createAiRouterRuntime, AiRouterError, IMPLEMENTED_AI_PROVIDERS, isImplementedAiProvider, providerNotImplemented, resolveProvider, } from '@x12i/ai-router-runtime';
+export type { AiProviderId, AiRouterRequest, AiRouterRuntime, AiRouterRuntimeOptions, ImplementedAiProvider, } from '@x12i/ai-router-runtime';
+export { GatewayRouter, LLMProviderRouter, createRouter, createRouterFromConfig, ROUTER_LOG_ENV_PREFIX, } from './gateway-router.js';
+export type { CreateRouterConfig } from './gateway-router.js';
+export type { AIResponse, AIRouterRequest, GatewayRouterConfig, RouterConfig, HealthCheckResult, RouterMode, NormalizedUsage, ProviderModelRef as RouterProviderModelRef, } from './router-types.js';
+export { FallbackExhaustedError, ProviderNotFoundError, OpenRouterApiKeyMissingError, PROVIDER_FAILURE_CODES, operatorHintForProviderFailureCode, enrichRunTaskError, providerAttemptsFromFallbackAttempts, buildProviderAttemptDetail, } from './router-errors.js';
+export type { FallbackAttempt, ProviderFailureCode, ProviderAttemptDetail, } from './router-errors.js';
 export { AIGateway } from './gateway.js';
 export { InstructionNotFoundError, InstructionBackendError, ModelRequiredError, MaxTokensRequiredError, GatewayAliasModelRejectedError, GatewayValidationError, ProviderConfigError, ProviderInvokeError, GatewayPolicyViolationError, } from './instruction-errors.js';
 export { normalizeInvokeModelAtIngress } from './invoke-model-ingress.js';
-export { autoRegisterProviders } from './gateway-provider-auto-register.js';
-export { registerOpenRouterRuntime, shouldUseOpenRouterRuntime, mapGatewayServerTools, } from './openrouter-runtime-adapter/index.js';
+export { shouldUseOpenRouterRuntime, mapGatewayServerTools, } from './openrouter-runtime-adapter/index.js';
 export type { GatewayConfig, ProviderModelRef, ModelConfig, GatewayModelConfig, GatewayServerToolsConfig, GatewayServerToolMode, GatewayServerToolUsage, GatewayNestedServerTool, GatewayWebSearchToolConfig, GatewayWebFetchToolConfig, GatewayDatetimeToolConfig, GatewayImageGenerationToolConfig, GatewayApplyPatchToolConfig, GatewayFusionToolConfig, GatewayAdvisorToolConfig, GatewaySubagentToolConfig, GatewayOpenRouterErrorMetadata, GatewayOpenRouterConfig, GatewayOpenRouterRuntimeConfig, GatewayServerToolUsageMap, GatewayCitation, GatewayGeneratedImage, GatewayPatchProposal, GatewayOpenRouterRuntimeMetadata, RetryConfig, ChatRequest, AIInvokeRequest, AIRequest, GatewayActionType, GatewayInvokeRejectionMetadata, GatewayFallbackAttempt, GatewayTraceRequestIds, GatewayTraceAttempt, GatewayTraceUsageSummary, GatewayTraceMergedConfig, EnhancedLLMResponse, InstructionMetadata, ValidationRule, TemplateRenderOptions, SmartInputConfig, SmartInputRenderOptions } from './types.js';
 export { attachGatewayInvokeRejectionMetadata, buildInvokeRejectionMetadata, tryExtractRouterLikePayloadFromErrorChain, tryExtractOpenRouterMetadataFromErrorChain, tryExtractFallbackAttemptsFromErrorChain, pickRequestIdsFromRouterLike, resolveActivityCostCompletion, resolveCostCompletionForActivity, resolveCostCompletionWithAiTools, buildGatewayPricingRecord, mapAiCostResultToResolvedActivityCost, catalogPricingSucceeded, extractUsageExtrasFromRouterResponse, buildTraceUsageSummary, enrichTraceAttemptsWithBilling, pickEnhancedOpenRouterMetadata, hasNonZeroTokenUsage, MODEL_PROFILE_UNROUTABLE, ModelProfileUnroutableError, ModelProfileInputRejectedError, buildGatewayFallbackAttemptsFromTrace, formatFallbackExhaustionMessage, enrichGatewayFallbackExhaustedError, logResolvedModelRouting, mapGatewayFallbackAttemptsToRouter } from './gateway-utils.js';
 export { getGatewayOperationalMode, isProdGatewayMode, parseModelProviderSpec } from './gateway-mode.js';
@@ -46,7 +43,6 @@ export type { GatewayLogCode as GatewayDiagnosticCode } from './gateway-log-diag
 export { resolveInvokeModel, applyModelResolution, applyOpenRouterInvokeRouting, applyOpenRouterInvokePolicy, mapResolutionToRouterConfig, buildInvokeModelResolverOptions, buildModelResolverOptions, enrichModelResolutionError, getAiToolsClient, resetAiToolsClientForTests, resolveOpenRouterApiKey, resolvePreferOpenRouter, readPreferOpenRouterFromEnv, getAiToolsInvokeClient, createAiToolsInvokeClient, } from './ai-tools-client.js';
 export type { AiToolsClientBundle, AiToolsInvokeClient, InvokeModelResolutionDiagnostics, InvokeModelResolutionInput, InvokeModelResolutionOptions, InvokeModelResolutionResult, InvokeRouterConfigSlice, } from './ai-tools-client.js';
 export { createLogxer, DebugLogAbstract, runWithLogContext, getStationRuntimeIdentity, mergeRuntimeIdentity, conditionEvidence, sourceEvidence, logReferenceEvidence, readAgentLoggingInstructions, resolveAgentLoggingInstructionsPath, applyPackageLogLevelsFromEnv, configurePackageLogLevels, mergePackageLogLevelsConfig, setPackageLogLevel, resolveStackLogLevelForPrefix, resolvePackageLogsLevel, parseLogxerPackageLevelsEnv, LOGXER_PACKAGE_LEVELS_ENV, LOGXER_PACKAGE_LOGS_DEFAULT_ENV } from '@x12i/logxer';
-export { ROUTER_LOG_ENV_PREFIX } from '@x12i/ai-providers-router';
 export type { Logxer, LogMeta, RuntimeIdentity, LogRuntimeContext, GetJobLogsInput, GetJobLogsResult, QueryableLogLine, LogDiagnostics, DiagnosticEvidence, ScopeCriteria, ScopeLogsResult, StackLoggingOptions, PackageLogLevelsConfig, PackageLogLevelSetting } from '@x12i/logxer';
 export { runtimeObjects } from './runtime-objects.js';
 export type { ActivixQueryableClient, LogxerQueryableClient, PackageRuntimeObjects, RuntimeObjects } from './runtime-objects.js';

package/dist-cjs/openrouter-runtime-adapter/index.cjs

@@ -1,6 +1,4 @@
-export { registerOpenRouterRuntime, shouldUseOpenRouterRuntime, resolveOpenRouterRuntimeDefaults, } from './register-openrouter-runtime.js';
-export { createOpenRouterRuntimeProvider } from './create-openrouter-runtime-provider.js';
-export { createOpenRouterRuntimeAdapter } from './create-openrouter-runtime-adapter.js';
+export { shouldUseOpenRouterRuntime, resolveOpenRouterRuntimeDefaults } from './should-use-openrouter-runtime.js';
 export { mapGatewayServerTools } from './map-server-tools.js';
 export { mapGatewayRequestToRuntimeRequest } from './map-gateway-request.js';
 export { buildPartialMetadataFromRuntimeResponse, buildRouterLikeEnvelopeFromRuntimeResponse, pickOpenRouterRuntimeMetadataSlice, extractOpenRouterRuntimeRouterMetadata, parseRuntimeResponseToAIResponse, } from './map-runtime-response.js';

package/dist-cjs/openrouter-runtime-adapter/index.d.ts

@@ -1,6 +1,4 @@
-export { registerOpenRouterRuntime, shouldUseOpenRouterRuntime, resolveOpenRouterRuntimeDefaults, } from './register-openrouter-runtime.js';
-export { createOpenRouterRuntimeProvider } from './create-openrouter-runtime-provider.js';
-export { createOpenRouterRuntimeAdapter } from './create-openrouter-runtime-adapter.js';
+export { shouldUseOpenRouterRuntime, resolveOpenRouterRuntimeDefaults } from './should-use-openrouter-runtime.js';
 export { mapGatewayServerTools } from './map-server-tools.js';
 export { mapGatewayRequestToRuntimeRequest } from './map-gateway-request.js';
 export { buildPartialMetadataFromRuntimeResponse, buildRouterLikeEnvelopeFromRuntimeResponse, pickOpenRouterRuntimeMetadataSlice, extractOpenRouterRuntimeRouterMetadata, parseRuntimeResponseToAIResponse, } from './map-runtime-response.js';

package/dist-cjs/openrouter-runtime-adapter/map-gateway-request.cjs

@@ -1,5 +1,4 @@
 import { mapGatewayServerTools } from './map-server-tools.js';
-export const OPENROUTER_RUNTIME_OPERATION = 'openrouter-runtime.run';
 function mapMessages(messages) {
     if (!messages?.length)
         return [];

package/dist-cjs/openrouter-runtime-adapter/map-gateway-request.d.ts

@@ -1,5 +1,4 @@
-import type { RuntimeRequest } from '@x12i/openrouter-runtime';
-export declare const OPENROUTER_RUNTIME_OPERATION = "openrouter-runtime.run";
+import type { RuntimeRequest } from '@x12i/ai-router-runtime';
 export type GatewayRouterInvokeRequest = {
     messages?: Array<{
         role: string;

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

@@ -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-cjs/openrouter-runtime-adapter/map-runtime-errors.d.ts

@@ -1,5 +1,16 @@
-import { OpenRouterHttpError, RuntimeConfigError, type RuntimeResponse } from '@x12i/openrouter-runtime';
-export declare function throwMappedRuntimeConfigError(err: RuntimeConfigError): never;
-export declare function throwMappedOpenRouterHttpError(err: OpenRouterHttpError): never;
+import type { RuntimeResponse } from '@x12i/ai-router-runtime';
+type RuntimeConfigErrorLike = Error & {
+    code: string;
+    details?: unknown;
+};
+type OpenRouterHttpErrorLike = Error & {
+    status: number;
+    code: string;
+    retryable: boolean;
+    body?: unknown;
+};
+export declare function throwMappedRuntimeConfigError(err: RuntimeConfigErrorLike): never;
+export declare function throwMappedOpenRouterHttpError(err: OpenRouterHttpErrorLike): never;
 export declare function throwMappedRuntimeResponseErrors(response: RuntimeResponse): void;
 export declare function mapRuntimeErrorToGatewayError(err: unknown): Error;
+export {};

package/dist-cjs/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-cjs/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-cjs/openrouter-runtime-adapter/should-use-openrouter-runtime.cjs

@@ -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-cjs/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-cjs/router-errors.cjs

@@ -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;
+}