@x12i/ai-gateway 10.3.0 → 10.4.0

package/dist-cjs/gateway.cjs

@@ -11,7 +11,8 @@ import { resolveRetryConfig } from './gateway-defaults.js';
 import { buildMessages } from './message-builder.js';
 import { extractJsonFromFlexMd } from './flex-md-loader.js';
 import { enrichParsedContentForOutputContract, resolveOutputContractFieldKeys } from './output-contract-normalizer.js';
-import { attachGatewayInvokeRejectionMetadata, buildGatewayFallbackAttemptsFromTrace, buildInvokeRejectionMetadata, capActivityFullResponsePayload, formatFallbackExhaustionMessage, logResolvedModelRouting, mapGatewayFallbackAttemptsToRouter, DEFAULT_ACTIVITY_FULL_RESPONSE_MAX_CHARS, extractCostUsdFromRouterResponse, extractTokenUsageFromRouterResponse, mergeConfig, pickEffectiveModelConfigForMetadata, pickInvokeRoutingMetadataSlice, pickTraceMergedRouterConfig, resolveCostCompletionWithAiTools, buildTraceUsageSummary, enrichTraceAttemptsWithBilling, tryExtractRouterLikePayloadFromErrorChain } from './gateway-utils.js';
+import { attachGatewayInvokeRejectionMetadata, buildGatewayFallbackAttemptsFromTrace, buildInvokeRejectionMetadata, capActivityFullResponsePayload, formatFallbackExhaustionMessage, logResolvedModelRouting, mapGatewayFallbackAttemptsToRouter, DEFAULT_ACTIVITY_FULL_RESPONSE_MAX_CHARS, extractCostUsdFromRouterResponse, extractTokenUsageFromRouterResponse, mergeConfig, pickEffectiveModelConfigForMetadata, pickInvokeRoutingMetadataSlice, pickTraceMergedRouterConfig, pickEnhancedOpenRouterMetadata, resolveCostCompletionWithAiTools, buildTraceUsageSummary, enrichTraceAttemptsWithBilling, tryExtractRouterLikePayloadFromErrorChain } 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';
@@ -140,9 +141,12 @@ export class AIGateway {
                     calculator: aiTools?.calculator ?? null,
                     calculateCost: this.config.aiTools?.calculateCost
                 });
+                const routingMetadataSliceChat = pickInvokeRoutingMetadataSlice(response, mergedConfig);
+                const effectiveModelConfigChat = pickEffectiveModelConfigForMetadata(mergedConfig);
+                const openrouterMetadataChat = pickEnhancedOpenRouterMetadata(response, false);
                 // Create enhanced response
                 const enhancedResponse = {
-                    content: response.content || '',
+                    content: response.content || response.outputText || '',
                     metadata: {
                         aiRequestId: request.aiRequestId,
                         identity: request.identity,
@@ -150,6 +154,9 @@ export class AIGateway {
                         tokens: tokensChat,
                         taskTypeId,
                         agentType: 'chat',
+                        ...routingMetadataSliceChat,
+                        ...(effectiveModelConfigChat !== undefined ? { effectiveModelConfig: effectiveModelConfigChat } : {}),
+                        ...openrouterMetadataChat,
                         ...(costCompletionChat.costStatus === 'priced'
                             ? {
                                 costUsd: costCompletionChat.cost,
@@ -466,6 +473,9 @@ export class AIGateway {
                                             const rawStr = typeof raw === 'string' ? raw : safeJsonStringify(raw);
                                             a.rawProviderPayload = capString(rawStr, 4000);
                                         }
+                                        const runtimeSlice = buildTraceAttemptOpenRouterRuntimeSlice(pickEnhancedOpenRouterMetadata(respAny, true));
+                                        if (runtimeSlice)
+                                            a.openrouterRuntime = runtimeSlice;
                                     }
                                     else if (tryErr) {
                                         a.error = { name: tryErr.name || 'Error', message: capErrorMessage(tryErr.message || String(tryErr)) };
@@ -617,6 +627,7 @@ export class AIGateway {
                 const routerMetaForCost = routerResponse?.metadata || {};
                 const routingMetadataSlice = pickInvokeRoutingMetadataSlice(routerResponse, mergedConfig);
                 const effectiveModelConfig = pickEffectiveModelConfigForMetadata(mergedConfig);
+                const openrouterMetadata = pickEnhancedOpenRouterMetadata(routerResponse, traceEnabled);
                 const traceMergedRouterSnapshot = traceEnabled ? pickTraceMergedRouterConfig(mergedConfig) : undefined;
                 if (traceEnabled && traceAttempts) {
                     await enrichTraceAttemptsWithBilling(traceAttempts, costCompletion, {
@@ -626,7 +637,10 @@ export class AIGateway {
                     });
                 }
                 const traceUsageSummary = traceEnabled
-                    ? buildTraceUsageSummary(tokens, costCompletion, routingMetadataSlice.maxTokensRequested)
+                    ? buildTraceUsageSummary(tokens, costCompletion, routingMetadataSlice.maxTokensRequested, {
+                        serverTools: openrouterMetadata.serverTools,
+                        citations: openrouterMetadata.citations,
+                    })
                     : undefined;
                 const enhancedResponse = {
                     content: content,
@@ -642,6 +656,7 @@ export class AIGateway {
                         parsingMethod,
                         ...routingMetadataSlice,
                         ...(effectiveModelConfig !== undefined ? { effectiveModelConfig } : {}),
+                        ...openrouterMetadata,
                         ...(costCompletion.costStatus === 'priced'
                             ? {
                                 costUsd: costCompletion.cost,

package/dist-cjs/index.cjs

@@ -15,10 +15,11 @@ export { ProviderNotFoundError, FallbackExhaustedError } from '@x12i/ai-provider
 export * from '@x12i/ai-providers-router';
 // Export enhanced gateway
 export { AIGateway } from './gateway.js';
-export { InstructionNotFoundError, InstructionBackendError, ModelRequiredError, MaxTokensRequiredError, GatewayAliasModelRejectedError, } from './instruction-errors.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 { attachGatewayInvokeRejectionMetadata, buildInvokeRejectionMetadata, tryExtractRouterLikePayloadFromErrorChain, tryExtractFallbackAttemptsFromErrorChain, pickRequestIdsFromRouterLike, resolveActivityCostCompletion, resolveCostCompletionForActivity, resolveCostCompletionWithAiTools, buildGatewayPricingRecord, mapAiCostResultToResolvedActivityCost, catalogPricingSucceeded, extractUsageExtrasFromRouterResponse, buildTraceUsageSummary, enrichTraceAttemptsWithBilling, hasNonZeroTokenUsage, MODEL_PROFILE_UNROUTABLE, ModelProfileUnroutableError, ModelProfileInputRejectedError, buildGatewayFallbackAttemptsFromTrace, formatFallbackExhaustionMessage, logResolvedModelRouting, mapGatewayFallbackAttemptsToRouter } from './gateway-utils.js';
+export { registerOpenRouterRuntime, shouldUseOpenRouterRuntime, mapGatewayServerTools, } from './openrouter-runtime-adapter/index.js';
+export { attachGatewayInvokeRejectionMetadata, buildInvokeRejectionMetadata, tryExtractRouterLikePayloadFromErrorChain, tryExtractFallbackAttemptsFromErrorChain, pickRequestIdsFromRouterLike, resolveActivityCostCompletion, resolveCostCompletionForActivity, resolveCostCompletionWithAiTools, buildGatewayPricingRecord, mapAiCostResultToResolvedActivityCost, catalogPricingSucceeded, extractUsageExtrasFromRouterResponse, buildTraceUsageSummary, enrichTraceAttemptsWithBilling, pickEnhancedOpenRouterMetadata, hasNonZeroTokenUsage, MODEL_PROFILE_UNROUTABLE, ModelProfileUnroutableError, ModelProfileInputRejectedError, buildGatewayFallbackAttemptsFromTrace, formatFallbackExhaustionMessage, 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';
 export { contractSpecToFieldKeys, enrichParsedContentForOutputContract, resolveOutputContractFieldKeys } from './output-contract-normalizer.js';

package/dist-cjs/index.d.ts

@@ -14,11 +14,12 @@ export type { RequestInterceptor, ResponseInterceptor } from '@x12i/ai-providers
 export type { UsageTracker } from '@x12i/ai-providers-router';
 export * from '@x12i/ai-providers-router';
 export { AIGateway } from './gateway.js';
-export { InstructionNotFoundError, InstructionBackendError, ModelRequiredError, MaxTokensRequiredError, GatewayAliasModelRejectedError, } from './instruction-errors.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 type { GatewayConfig, ProviderModelRef, ModelConfig, RetryConfig, ChatRequest, AIInvokeRequest, AIRequest, GatewayActionType, GatewayInvokeRejectionMetadata, GatewayFallbackAttempt, GatewayTraceRequestIds, GatewayTraceAttempt, GatewayTraceUsageSummary, GatewayTraceMergedConfig, EnhancedLLMResponse, InstructionMetadata, ValidationRule, TemplateRenderOptions, SmartInputConfig, SmartInputRenderOptions } from './types.js';
-export { attachGatewayInvokeRejectionMetadata, buildInvokeRejectionMetadata, tryExtractRouterLikePayloadFromErrorChain, tryExtractFallbackAttemptsFromErrorChain, pickRequestIdsFromRouterLike, resolveActivityCostCompletion, resolveCostCompletionForActivity, resolveCostCompletionWithAiTools, buildGatewayPricingRecord, mapAiCostResultToResolvedActivityCost, catalogPricingSucceeded, extractUsageExtrasFromRouterResponse, buildTraceUsageSummary, enrichTraceAttemptsWithBilling, hasNonZeroTokenUsage, MODEL_PROFILE_UNROUTABLE, ModelProfileUnroutableError, ModelProfileInputRejectedError, buildGatewayFallbackAttemptsFromTrace, formatFallbackExhaustionMessage, logResolvedModelRouting, mapGatewayFallbackAttemptsToRouter } from './gateway-utils.js';
+export { registerOpenRouterRuntime, shouldUseOpenRouterRuntime, mapGatewayServerTools, } from './openrouter-runtime-adapter/index.js';
+export type { GatewayConfig, ProviderModelRef, ModelConfig, GatewayModelConfig, GatewayServerToolsConfig, 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, tryExtractFallbackAttemptsFromErrorChain, pickRequestIdsFromRouterLike, resolveActivityCostCompletion, resolveCostCompletionForActivity, resolveCostCompletionWithAiTools, buildGatewayPricingRecord, mapAiCostResultToResolvedActivityCost, catalogPricingSucceeded, extractUsageExtrasFromRouterResponse, buildTraceUsageSummary, enrichTraceAttemptsWithBilling, pickEnhancedOpenRouterMetadata, hasNonZeroTokenUsage, MODEL_PROFILE_UNROUTABLE, ModelProfileUnroutableError, ModelProfileInputRejectedError, buildGatewayFallbackAttemptsFromTrace, formatFallbackExhaustionMessage, logResolvedModelRouting, mapGatewayFallbackAttemptsToRouter } from './gateway-utils.js';
 export { getGatewayOperationalMode, isProdGatewayMode, parseModelProviderSpec } from './gateway-mode.js';
 export type { GatewayOperationalMode } 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';

package/dist-cjs/instruction-errors.cjs

@@ -25,6 +25,42 @@ export class GatewayAliasModelRejectedError extends Error {
         this.name = 'GatewayAliasModelRejectedError';
     }
 }
+export class GatewayValidationError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = 'GatewayValidationError';
+        this.code = code;
+    }
+}
+export class ProviderConfigError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = 'ProviderConfigError';
+        this.code = code;
+    }
+}
+export class ProviderInvokeError extends Error {
+    code;
+    status;
+    retryable;
+    constructor(code, message, options) {
+        super(message);
+        this.name = 'ProviderInvokeError';
+        this.code = code;
+        this.status = options?.status;
+        this.retryable = options?.retryable;
+    }
+}
+export class GatewayPolicyViolationError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = 'GatewayPolicyViolationError';
+        this.code = code;
+    }
+}
 export class InstructionNotFoundError extends Error {
     key;
     backend;

package/dist-cjs/instruction-errors.d.ts

@@ -14,6 +14,27 @@ export declare class GatewayAliasModelRejectedError extends Error {
     readonly code = "GATEWAY_ALIAS_MODEL_REJECTED";
     constructor(aliasModel: string, message?: string);
 }
+export declare class GatewayValidationError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export declare class ProviderConfigError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export declare class ProviderInvokeError extends Error {
+    readonly code: string;
+    readonly status?: number;
+    readonly retryable?: boolean;
+    constructor(code: string, message: string, options?: {
+        status?: number;
+        retryable?: boolean;
+    });
+}
+export declare class GatewayPolicyViolationError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
 export declare class InstructionNotFoundError extends Error {
     key: string;
     backend: string;

package/dist-cjs/logger-factory.cjs

@@ -59,8 +59,6 @@ function inheritLoggingConfigFromHost(hostLogger) {
     pick('logFilePath');
     pick('logFormat');
     pick('showFullTimestamp');
-    pick('enableUnifiedLogger');
-    pick('unifiedLogger');
     pick('consolePackagesShow');
     pick('consolePackagesHide');
     pick('transports');

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

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

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

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

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

@@ -0,0 +1,41 @@
+import { createOpenRouterRuntime, RuntimeConfigError, OpenRouterHttpError, } from '@x12i/openrouter-runtime';
+import { OPENROUTER_RUNTIME_OPERATION } from './map-gateway-request.js';
+import { throwMappedOpenRouterHttpError, throwMappedRuntimeConfigError, throwMappedRuntimeResponseErrors, } from './map-runtime-errors.js';
+export function createOpenRouterRuntimeProvider(options) {
+    const runtime = options.runtime ??
+        createOpenRouterRuntime({
+            apiKey: options.apiKey,
+            defaults: {
+                retry: { enabled: false },
+                onPolicyViolation: 'return_error',
+            },
+        });
+    return {
+        name: 'openrouter',
+        capabilities: {
+            modes: { sync: true, stream: false, batch: false },
+            operations: [OPENROUTER_RUNTIME_OPERATION],
+            maxConcurrency: 10,
+        },
+        async execute(spec) {
+            if (spec.operation !== OPENROUTER_RUNTIME_OPERATION) {
+                throw new Error(`Unsupported OpenRouter runtime operation: ${spec.operation}`);
+            }
+            const runtimeRequest = spec.args;
+            try {
+                const response = await runtime.run(runtimeRequest);
+                if (response.status !== 'completed') {
+                    throwMappedRuntimeResponseErrors(response);
+                }
+                return { rawResponse: response };
+            }
+            catch (err) {
+                if (err instanceof RuntimeConfigError)
+                    throwMappedRuntimeConfigError(err);
+                if (err instanceof OpenRouterHttpError)
+                    throwMappedOpenRouterHttpError(err);
+                throw err;
+            }
+        },
+    };
+}

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

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

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

@@ -0,0 +1,8 @@
+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 { mapGatewayServerTools } from './map-server-tools.js';
+export { mapGatewayRequestToRuntimeRequest } from './map-gateway-request.js';
+export { pickOpenRouterRuntimeMetadataSlice, extractOpenRouterRuntimeRouterMetadata, parseRuntimeResponseToAIResponse, } from './map-runtime-response.js';
+export { applyOnlineVariantMigration, applyPostRoutingServerToolsPolicy, mergeOpenRouterConfig, mergeServerToolsConfig, normalizeApplyPatchDefaults, validateApplyPatchConfig, hasAnyActiveServerTool, hasRequiredServerTool, } from './validate-server-tools.js';
+export { buildTraceAttemptOpenRouterRuntimeSlice, enrichTraceOpenRouterRuntimeMetadata, redactRawOpenRouterPayload, } from './map-trace.js';

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

@@ -0,0 +1,8 @@
+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 { mapGatewayServerTools } from './map-server-tools.js';
+export { mapGatewayRequestToRuntimeRequest } from './map-gateway-request.js';
+export { pickOpenRouterRuntimeMetadataSlice, extractOpenRouterRuntimeRouterMetadata, parseRuntimeResponseToAIResponse, } from './map-runtime-response.js';
+export { applyOnlineVariantMigration, applyPostRoutingServerToolsPolicy, mergeOpenRouterConfig, mergeServerToolsConfig, normalizeApplyPatchDefaults, validateApplyPatchConfig, hasAnyActiveServerTool, hasRequiredServerTool, } from './validate-server-tools.js';
+export { buildTraceAttemptOpenRouterRuntimeSlice, enrichTraceOpenRouterRuntimeMetadata, redactRawOpenRouterPayload, } from './map-trace.js';

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

@@ -0,0 +1,62 @@
+import { mapGatewayServerTools } from './map-server-tools.js';
+export const OPENROUTER_RUNTIME_OPERATION = 'openrouter-runtime.run';
+function mapMessages(messages) {
+    if (!messages?.length)
+        return [];
+    return messages.map((m) => ({
+        role: m.role,
+        content: m.content,
+        ...(m.name ? { name: m.name } : {}),
+        ...(m.toolCallId ? { toolCallId: m.toolCallId } : {}),
+    }));
+}
+function buildGenerationOverrides(config) {
+    const overrides = {};
+    if (config.topP !== undefined)
+        overrides.top_p = config.topP;
+    if (config.frequencyPenalty !== undefined)
+        overrides.frequency_penalty = config.frequencyPenalty;
+    if (config.presencePenalty !== undefined)
+        overrides.presence_penalty = config.presencePenalty;
+    if (Array.isArray(config.stop) && config.stop.length)
+        overrides.stop = config.stop;
+    return overrides;
+}
+export function mapGatewayRequestToRuntimeRequest(request, exec) {
+    const config = request.config ?? {};
+    const openrouter = config.openrouter;
+    const generationOverrides = buildGenerationOverrides(config);
+    const trustedRaw = openrouter?.rawOverrides ?? {};
+    const rawOpenRouterOverrides = Object.keys(generationOverrides).length || Object.keys(trustedRaw).length
+        ? { ...generationOverrides, ...trustedRaw }
+        : undefined;
+    const aiRequestId = (typeof request.aiRequestId === 'string' && request.aiRequestId) ||
+        (typeof request.identity?.aiRequestId === 'string' ? request.identity.aiRequestId : undefined);
+    return {
+        id: aiRequestId,
+        model: typeof config.model === 'string' ? config.model : undefined,
+        apiMode: openrouter?.apiMode ?? 'auto',
+        messages: mapMessages(request.messages),
+        temperature: typeof config.temperature === 'number' ? config.temperature : undefined,
+        maxTokens: typeof config.maxTokens === 'number' ? config.maxTokens : undefined,
+        reasoning: config.reasoning != null && typeof config.reasoning === 'object'
+            ? config.reasoning
+            : undefined,
+        serverTools: mapGatewayServerTools(config.serverTools),
+        execution: exec?.timeoutMs ? { timeoutMs: exec.timeoutMs } : undefined,
+        rawOpenRouterOverrides,
+        metadata: {
+            source: 'ai-gateway',
+            sourcePackage: '@x12i/ai-gateway',
+            provider: 'openrouter',
+            identity: request.identity,
+            actionType: request.actionType,
+            actionRef: request.actionRef,
+            aiRequestId,
+            agentId: request.agentId,
+        },
+    };
+}
+export function mapGatewayRequestToRuntimeRequestFromRouter(input) {
+    return mapGatewayRequestToRuntimeRequest(input.request, { timeoutMs: input.exec?.timeoutMs });
+}

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

@@ -0,0 +1,26 @@
+import type { RuntimeRequest } from '@x12i/openrouter-runtime';
+export declare const OPENROUTER_RUNTIME_OPERATION = "openrouter-runtime.run";
+export type GatewayRouterInvokeRequest = {
+    messages?: Array<{
+        role: string;
+        content: string | unknown[];
+        name?: string;
+        toolCallId?: string;
+    }>;
+    config?: Record<string, unknown>;
+    identity?: Record<string, unknown>;
+    aiRequestId?: string;
+    agentId?: string;
+    actionType?: string;
+    actionRef?: string;
+};
+export declare function mapGatewayRequestToRuntimeRequest(request: GatewayRouterInvokeRequest, exec?: {
+    timeoutMs?: number;
+}): RuntimeRequest;
+export declare function mapGatewayRequestToRuntimeRequestFromRouter(input: {
+    request: GatewayRouterInvokeRequest;
+    exec?: {
+        timeoutMs?: number;
+        signal?: AbortSignal;
+    };
+}): RuntimeRequest;

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

@@ -0,0 +1,60 @@
+import { OpenRouterHttpError, RuntimeConfigError, } from '@x12i/openrouter-runtime';
+import { GatewayPolicyViolationError, GatewayValidationError, ProviderConfigError, ProviderInvokeError, } from '../instruction-errors.js';
+export function throwMappedRuntimeConfigError(err) {
+    const code = err.code;
+    if (code === 'OPENROUTER_API_KEY_MISSING') {
+        throw new ProviderConfigError(code, err.message);
+    }
+    if (code === 'MODEL_MISSING') {
+        throw new GatewayValidationError(code, err.message);
+    }
+    if (code === 'INPUT_MISSING') {
+        throw new GatewayValidationError(code, err.message);
+    }
+    if (code === 'APPLY_PATCH_REQUIRES_RESPONSES_API') {
+        throw new GatewayValidationError(code, err.message);
+    }
+    throw new GatewayValidationError(code, err.message);
+}
+export function throwMappedOpenRouterHttpError(err) {
+    throw new ProviderInvokeError(err.code, err.message, {
+        status: err.status,
+        retryable: err.retryable,
+    });
+}
+export function throwMappedRuntimeResponseErrors(response) {
+    if (response.status === 'completed')
+        return;
+    const primary = response.errors[0];
+    if (!primary) {
+        throw new ProviderInvokeError('OPENROUTER_REQUEST_FAILED', 'OpenRouter runtime request failed');
+    }
+    if (primary.source === 'policy' || response.status === 'policy_violation') {
+        throw new GatewayPolicyViolationError(primary.code, primary.message);
+    }
+    if (primary.retryable) {
+        throw new ProviderInvokeError(primary.code, primary.message, { retryable: true });
+    }
+    throw new ProviderInvokeError(primary.code, primary.message);
+}
+export function mapRuntimeErrorToGatewayError(err) {
+    if (err instanceof RuntimeConfigError) {
+        try {
+            throwMappedRuntimeConfigError(err);
+        }
+        catch (mapped) {
+            return mapped;
+        }
+    }
+    if (err instanceof OpenRouterHttpError) {
+        try {
+            throwMappedOpenRouterHttpError(err);
+        }
+        catch (mapped) {
+            return mapped;
+        }
+    }
+    if (err instanceof Error)
+        return err;
+    return new Error(String(err));
+}

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

@@ -0,0 +1,5 @@
+import { OpenRouterHttpError, RuntimeConfigError, type RuntimeResponse } from '@x12i/openrouter-runtime';
+export declare function throwMappedRuntimeConfigError(err: RuntimeConfigError): never;
+export declare function throwMappedOpenRouterHttpError(err: OpenRouterHttpError): never;
+export declare function throwMappedRuntimeResponseErrors(response: RuntimeResponse): void;
+export declare function mapRuntimeErrorToGatewayError(err: unknown): Error;

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

@@ -0,0 +1,153 @@
+const EMPTY_REASONING = {
+    requested: { effort: 'none', visibility: 'none' },
+    applied: { effort: 'none', visibility: 'none' },
+    artifacts: {},
+    availability: {
+        supportsEffort: false,
+        supportsSummary: false,
+        supportsTrace: false,
+        supportsEncrypted: false,
+    },
+};
+export function mapRuntimeToolUsage(toolUsage) {
+    const st = toolUsage.serverTools;
+    return {
+        webSearch: st.webSearch,
+        webFetch: st.webFetch,
+        datetime: st.datetime,
+        imageGeneration: st.imageGeneration,
+        applyPatch: st.applyPatch,
+        fusion: st.fusion,
+        advisor: st.advisor,
+        subagent: st.subagent,
+    };
+}
+export function mapRuntimeCitations(citations) {
+    return citations.map((c) => ({
+        type: 'url',
+        url: c.url,
+        title: c.title,
+        excerpt: c.excerpt,
+        startIndex: c.startIndex,
+        endIndex: c.endIndex,
+        sourceProvider: 'openrouter',
+    }));
+}
+export function mapRuntimeImages(images) {
+    return images.map((img) => ({
+        imageUrl: img.imageUrl,
+        status: img.status,
+        error: img.error,
+        raw: img.raw,
+    }));
+}
+export function mapRuntimePatches(patches) {
+    return patches.map((p) => ({
+        callId: p.callId,
+        status: p.status,
+        operation: p.operation,
+        raw: p.raw,
+    }));
+}
+export function buildOpenRouterRuntimeMetadata(response) {
+    const policyViolations = response.errors
+        .filter((e) => e.source === 'policy')
+        .map((e) => ({ code: e.code, message: e.message, details: e.details }));
+    return {
+        apiMode: response.apiMode,
+        warnings: response.warnings.map((w) => ({
+            code: w.code,
+            message: w.message,
+            details: w.details,
+        })),
+        policyViolations,
+        requestIds: response.id ? [response.id] : undefined,
+    };
+}
+export function extractOpenRouterRuntimeRouterMetadata(routerResponse) {
+    if (routerResponse == null || typeof routerResponse !== 'object')
+        return {};
+    const r = routerResponse;
+    const meta = r.metadata != null && typeof r.metadata === 'object'
+        ? r.metadata
+        : {};
+    const out = {};
+    if (meta.serverTools != null)
+        out.serverTools = meta.serverTools;
+    if (meta.citations != null)
+        out.citations = meta.citations;
+    if (meta.generatedImages != null)
+        out.generatedImages = meta.generatedImages;
+    if (meta.patchProposals != null)
+        out.patchProposals = meta.patchProposals;
+    if (meta.openrouterRuntime != null) {
+        out.openrouterRuntime = meta.openrouterRuntime;
+    }
+    if (typeof meta.costUsd === 'number')
+        out.costUsd = meta.costUsd;
+    if (meta.costStatus === 'priced' || meta.costStatus === 'unpriced') {
+        out.costStatus = meta.costStatus;
+    }
+    return out;
+}
+export function parseRuntimeResponseToAIResponse(input) {
+    const response = input.execResult.rawResponse;
+    const usage = response.usage;
+    const promptTokens = usage?.inputTokens ?? 0;
+    const completionTokens = usage?.outputTokens ?? 0;
+    const totalTokens = usage?.totalTokens ?? promptTokens + completionTokens;
+    const serverTools = mapRuntimeToolUsage(response.toolUsage);
+    const citations = mapRuntimeCitations(response.citations);
+    const generatedImages = mapRuntimeImages(response.images);
+    const patchProposals = mapRuntimePatches(response.patches);
+    const openrouterRuntime = buildOpenRouterRuntimeMetadata(response);
+    const costUsd = usage?.costUsd;
+    const metadata = {
+        provider: 'openrouter',
+        modelUsed: response.model,
+        serverTools,
+        citations,
+        generatedImages,
+        patchProposals,
+        openrouterRuntime,
+        requestIds: {
+            openrouterRequestId: response.id,
+        },
+    };
+    if (typeof costUsd === 'number' && Number.isFinite(costUsd)) {
+        metadata.costUsd = costUsd;
+        metadata.cost = costUsd;
+        metadata.costStatus = 'priced';
+    }
+    else if (usage && (promptTokens || completionTokens || totalTokens)) {
+        metadata.costStatus = 'unpriced';
+    }
+    return {
+        requestId: input.requestId,
+        provider: 'openrouter',
+        rawResponse: response,
+        outputText: response.text,
+        usage: {
+            promptTokens,
+            completionTokens,
+            totalTokens,
+        },
+        reasoning: EMPTY_REASONING,
+        metadata,
+    };
+}
+export function pickOpenRouterRuntimeMetadataSlice(routerResponse) {
+    const extracted = extractOpenRouterRuntimeRouterMetadata(routerResponse);
+    const out = {};
+    if (extracted.serverTools)
+        out.serverTools = extracted.serverTools;
+    if (extracted.citations?.length)
+        out.citations = extracted.citations;
+    if (extracted.generatedImages?.length)
+        out.generatedImages = extracted.generatedImages;
+    if (extracted.patchProposals?.length)
+        out.patchProposals = extracted.patchProposals;
+    if (extracted.openrouterRuntime)
+        out.openrouterRuntime = extracted.openrouterRuntime;
+    return out;
+}