@x12i/ai-gateway 10.3.1 → 10.4.0

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

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

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

@@ -0,0 +1,31 @@
+import type { AIResponse } from '@x12i/ai-providers-router';
+import type { RuntimeResponse } from '@x12i/openrouter-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[];
+export declare function mapRuntimeImages(images: RuntimeResponse['images']): GatewayGeneratedImage[];
+export declare function mapRuntimePatches(patches: RuntimeResponse['patches']): GatewayPatchProposal[];
+export declare function buildOpenRouterRuntimeMetadata(response: RuntimeResponse): GatewayOpenRouterRuntimeMetadata;
+export type OpenRouterRuntimeRouterMetadata = {
+    serverTools?: GatewayServerToolUsageMap;
+    citations?: GatewayCitation[];
+    generatedImages?: GatewayGeneratedImage[];
+    patchProposals?: GatewayPatchProposal[];
+    openrouterRuntime?: GatewayOpenRouterRuntimeMetadata;
+    costUsd?: number;
+    costStatus?: 'priced' | 'unpriced';
+};
+export declare function extractOpenRouterRuntimeRouterMetadata(routerResponse: unknown): OpenRouterRuntimeRouterMetadata;
+export declare function parseRuntimeResponseToAIResponse(input: {
+    requestId: string;
+    execResult: {
+        rawResponse: unknown;
+    };
+}): AIResponse;
+export declare function pickOpenRouterRuntimeMetadataSlice(routerResponse: unknown): {
+    serverTools?: GatewayServerToolUsageMap;
+    citations?: GatewayCitation[];
+    generatedImages?: GatewayGeneratedImage[];
+    patchProposals?: GatewayPatchProposal[];
+    openrouterRuntime?: GatewayOpenRouterRuntimeMetadata;
+};

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

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

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

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

package/dist/openrouter-runtime-adapter/map-server-tools.js

@@ -0,0 +1,143 @@
+function mapWebSearch(src) {
+    if (!src)
+        return undefined;
+    return {
+        mode: src.mode,
+        engine: src.engine,
+        maxResults: src.maxResults,
+        maxTotalResults: src.maxTotalResults,
+        searchContextSize: src.searchContextSize,
+        allowedDomains: src.allowedDomains,
+        excludedDomains: src.excludedDomains,
+        userLocation: src.userLocation,
+        requireCitations: src.requireCitations,
+        onFailure: src.onFailure,
+    };
+}
+function mapWebFetch(src) {
+    if (!src)
+        return undefined;
+    return {
+        mode: src.mode,
+        engine: src.engine,
+        maxUses: src.maxUses,
+        maxContentTokens: src.maxContentTokens,
+        allowedDomains: src.allowedDomains,
+        blockedDomains: src.blockedDomains,
+        onFailure: src.onFailure,
+    };
+}
+function mapDatetime(src) {
+    if (!src)
+        return undefined;
+    return { mode: src.mode, timezone: src.timezone };
+}
+function mapImageGeneration(src) {
+    if (!src)
+        return undefined;
+    return {
+        mode: src.mode,
+        model: src.model,
+        quality: src.quality,
+        size: src.size,
+        aspectRatio: src.aspectRatio,
+        background: src.background,
+        outputFormat: src.outputFormat,
+        outputCompression: src.outputCompression,
+        moderation: src.moderation,
+    };
+}
+function mapApplyPatch(src) {
+    if (!src)
+        return undefined;
+    return {
+        mode: src.mode,
+        behavior: src.behavior ?? 'return_only',
+        workspaceRoot: src.workspaceRoot,
+        allowDelete: src.allowDelete,
+        allowCreate: src.allowCreate,
+        allowUpdate: src.allowUpdate,
+    };
+}
+function mapFusion(src) {
+    if (!src)
+        return undefined;
+    return {
+        mode: src.mode,
+        analysisModels: src.analysisModels,
+        judgeModel: src.judgeModel,
+        maxToolCalls: src.maxToolCalls,
+        maxCompletionTokens: src.maxCompletionTokens,
+        reasoning: src.reasoning,
+        temperature: src.temperature,
+    };
+}
+function mapNestedTools(tools) {
+    if (!tools?.length)
+        return undefined;
+    return tools.map((t) => ({ type: t.type, parameters: t.parameters }));
+}
+function mapAdvisor(src) {
+    if (!src)
+        return undefined;
+    const mapOne = (a) => ({
+        mode: a.mode,
+        name: a.name,
+        model: a.model,
+        instructions: a.instructions,
+        tools: mapNestedTools(a.tools),
+        forwardTranscript: a.forwardTranscript,
+        stream: a.stream,
+        maxToolCalls: a.maxToolCalls,
+        maxCompletionTokens: a.maxCompletionTokens,
+        reasoning: a.reasoning,
+        temperature: a.temperature,
+    });
+    if (Array.isArray(src))
+        return src.map(mapOne);
+    return mapOne(src);
+}
+function mapSubagent(src) {
+    if (!src)
+        return undefined;
+    return {
+        mode: src.mode,
+        model: src.model,
+        instructions: src.instructions,
+        tools: mapNestedTools(src.tools),
+        maxToolCalls: src.maxToolCalls,
+        maxCompletionTokens: src.maxCompletionTokens,
+        reasoning: src.reasoning,
+        temperature: src.temperature,
+    };
+}
+export function mapGatewayServerTools(config) {
+    if (!config)
+        return undefined;
+    const out = {};
+    const webSearch = mapWebSearch(config.webSearch);
+    const webFetch = mapWebFetch(config.webFetch);
+    const datetime = mapDatetime(config.datetime);
+    const imageGeneration = mapImageGeneration(config.imageGeneration);
+    const applyPatch = mapApplyPatch(config.applyPatch);
+    const fusion = mapFusion(config.fusion);
+    const advisor = mapAdvisor(config.advisor);
+    const subagent = mapSubagent(config.subagent);
+    if (webSearch)
+        out.webSearch = webSearch;
+    if (webFetch)
+        out.webFetch = webFetch;
+    if (datetime)
+        out.datetime = datetime;
+    if (imageGeneration)
+        out.imageGeneration = imageGeneration;
+    if (applyPatch)
+        out.applyPatch = applyPatch;
+    if (fusion)
+        out.fusion = fusion;
+    if (advisor)
+        out.advisor = advisor;
+    if (subagent)
+        out.subagent = subagent;
+    return Object.keys(out).length ? out : undefined;
+}

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

@@ -0,0 +1,5 @@
+import type { GatewayTraceAttempt, GatewayOpenRouterRuntimeMetadata } from '../types.js';
+import type { OpenRouterRuntimeRouterMetadata } from './map-runtime-response.js';
+export declare function buildTraceAttemptOpenRouterRuntimeSlice(metadata: OpenRouterRuntimeRouterMetadata): GatewayTraceAttempt['openrouterRuntime'];
+export declare function enrichTraceOpenRouterRuntimeMetadata(base: GatewayOpenRouterRuntimeMetadata | undefined, metadata: OpenRouterRuntimeRouterMetadata, traceEnabled: boolean): GatewayOpenRouterRuntimeMetadata | undefined;
+export declare function redactRawOpenRouterPayload(raw: unknown, maxChars?: number): unknown;

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

@@ -0,0 +1,45 @@
+export function buildTraceAttemptOpenRouterRuntimeSlice(metadata) {
+    if (!metadata.openrouterRuntime && !metadata.serverTools)
+        return undefined;
+    return {
+        apiMode: metadata.openrouterRuntime?.apiMode,
+        serverTools: metadata.serverTools,
+        citationCount: metadata.citations?.length ?? 0,
+        generatedImageCount: metadata.generatedImages?.length ?? 0,
+        patchProposalCount: metadata.patchProposals?.length ?? 0,
+    };
+}
+export function enrichTraceOpenRouterRuntimeMetadata(base, metadata, traceEnabled) {
+    if (!traceEnabled && !base)
+        return base;
+    const merged = {
+        apiMode: base?.apiMode ?? metadata.openrouterRuntime?.apiMode ?? 'chat',
+        warnings: base?.warnings ?? metadata.openrouterRuntime?.warnings ?? [],
+        policyViolations: base?.policyViolations ?? metadata.openrouterRuntime?.policyViolations ?? [],
+        requestIds: base?.requestIds ?? metadata.openrouterRuntime?.requestIds,
+    };
+    if (traceEnabled) {
+        merged.serverToolsRequested = metadata.serverTools;
+        merged.serverToolsUsed = metadata.serverTools;
+        merged.citations = metadata.citations;
+        merged.generatedImages = metadata.generatedImages;
+        merged.patchProposals = metadata.patchProposals;
+    }
+    return merged;
+}
+export function redactRawOpenRouterPayload(raw, maxChars = 32_000) {
+    if (raw == null)
+        return raw;
+    try {
+        const text = JSON.stringify(raw);
+        const redacted = text
+            .replace(/"(Authorization|authorization|api[_-]?key)"\s*:\s*"[^"]*"/gi, '"$1":"[REDACTED]"')
+            .replace(/Bearer\s+[A-Za-z0-9._-]+/g, 'Bearer [REDACTED]');
+        if (redacted.length <= maxChars)
+            return JSON.parse(redacted);
+        return { truncated: true, preview: redacted.slice(0, maxChars) };
+    }
+    catch {
+        return { truncated: true };
+    }
+}

package/dist/openrouter-runtime-adapter/register-openrouter-runtime.d.ts

@@ -0,0 +1,10 @@
+import type { LLMProviderRouter } from '@x12i/ai-providers-router';
+import type { Logxer } from '@x12i/logxer';
+import type { GatewayOpenRouterRuntimeConfig } from '../types.js';
+export type RegisterOpenRouterRuntimeOptions = {
+    apiKey: string;
+    logger?: Logxer;
+    runtimeConfig?: GatewayOpenRouterRuntimeConfig;
+};
+export declare function registerOpenRouterRuntime(router: LLMProviderRouter, options: RegisterOpenRouterRuntimeOptions): void;
+export { shouldUseOpenRouterRuntime, resolveOpenRouterRuntimeDefaults } from './should-use-openrouter-runtime.js';

package/dist/openrouter-runtime-adapter/register-openrouter-runtime.js

@@ -0,0 +1,14 @@
+import { createOpenRouterRuntimeAdapter } from './create-openrouter-runtime-adapter.js';
+import { createOpenRouterRuntimeProvider } from './create-openrouter-runtime-provider.js';
+export function registerOpenRouterRuntime(router, options) {
+    const { apiKey, logger } = options;
+    const provider = createOpenRouterRuntimeProvider({ apiKey, logger });
+    router.registerProvider(provider);
+    const adapter = createOpenRouterRuntimeAdapter();
+    router.getAdapterRegistry().register(adapter);
+    logger?.info('Registered OpenRouter runtime provider and adapter', {
+        provider: 'openrouter',
+        runtimeEnabled: true,
+    });
+}
+export { shouldUseOpenRouterRuntime, resolveOpenRouterRuntimeDefaults } from './should-use-openrouter-runtime.js';

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

@@ -0,0 +1,14 @@
+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
+ */
+export declare function shouldUseOpenRouterRuntime(config?: GatewayConfig): boolean;
+export declare function resolveOpenRouterRuntimeDefaults(config?: GatewayConfig): {
+    apiMode: 'chat' | 'responses' | 'auto';
+    includeRawInTrace: boolean;
+};

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

@@ -0,0 +1,29 @@
+/**
+ * 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
+ */
+export function shouldUseOpenRouterRuntime(config) {
+    const legacyEnv = process.env.AI_GATEWAY_USE_LEGACY_OPENROUTER;
+    if (legacyEnv === '1' || legacyEnv === 'true') {
+        return false;
+    }
+    const runtimeEnv = process.env.AI_GATEWAY_USE_OPENROUTER_RUNTIME;
+    if (runtimeEnv === '0' || runtimeEnv === 'false') {
+        return false;
+    }
+    if (config?.openrouterRuntime?.enabled === false) {
+        return false;
+    }
+    return true;
+}
+export function resolveOpenRouterRuntimeDefaults(config) {
+    const rt = config?.openrouterRuntime;
+    return {
+        apiMode: rt?.apiMode ?? 'auto',
+        includeRawInTrace: rt?.includeRawInTrace ?? false,
+    };
+}

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

@@ -0,0 +1,30 @@
+import type { GatewayOpenRouterConfig, GatewayServerToolsConfig } from '../types.js';
+export type ServerToolValidationWarning = {
+    code: string;
+    message: string;
+};
+export declare function hasAnyServerToolMode(serverTools: GatewayServerToolsConfig | undefined, mode: 'allowed' | 'required'): boolean;
+export declare function hasAnyActiveServerTool(serverTools?: GatewayServerToolsConfig): boolean;
+export declare function hasRequiredServerTool(serverTools?: GatewayServerToolsConfig): boolean;
+export declare function validateApplyPatchConfig(serverTools: GatewayServerToolsConfig | undefined, openrouter: GatewayOpenRouterConfig | undefined): void;
+export type PostRoutingServerToolsResult = {
+    serverTools?: GatewayServerToolsConfig;
+    warnings: ServerToolValidationWarning[];
+    forceOpenRouter: boolean;
+};
+export declare function applyPostRoutingServerToolsPolicy(input: {
+    provider: string | undefined;
+    serverTools?: GatewayServerToolsConfig;
+    openrouter?: GatewayOpenRouterConfig;
+    openRouterApiKey?: string;
+}): PostRoutingServerToolsResult;
+export type OnlineVariantMigrationResult = {
+    model: string;
+    serverTools?: GatewayServerToolsConfig;
+    warning?: ServerToolValidationWarning;
+};
+export declare function applyOnlineVariantMigration(model: string, serverTools?: GatewayServerToolsConfig): OnlineVariantMigrationResult;
+export declare function mergeServerToolsConfig(...layers: (GatewayServerToolsConfig | undefined)[]): GatewayServerToolsConfig | undefined;
+export declare function mergeOpenRouterConfig(...layers: (GatewayOpenRouterConfig | undefined)[]): GatewayOpenRouterConfig | undefined;
+/** Default applyPatch behavior when not specified. */
+export declare function normalizeApplyPatchDefaults(serverTools?: GatewayServerToolsConfig): GatewayServerToolsConfig | undefined;