@x12i/ai-gateway 10.0.2 → 10.0.5

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

@@ -1,26 +1,51 @@
 /**
- * Lazy @x12i/ai-tools catalog + cost calculator bootstrap.
+ * @x12i/ai-tools invoke client bootstrap for the gateway.
+ * Model resolution orchestration lives in ai-tools ≥ 2.5.0 (`resolveInvokeModel`).
  */
-import { AiModelsCatalogClient, CostCalculator, isEffectiveOpenRouterTransport, loadOpenRouterRoutingEnv, resolveModelVendorFromResolution } from '@x12i/ai-tools';
+import { getAiToolsInvokeClient, resetAiToolsInvokeClientForTests as resetAiToolsInvokeClientForTestsUpstream, mapResolutionToRouterConfig, buildInvokeModelResolverOptions, CostCalculator, } from '@x12i/ai-tools';
 import { gatewayLogDebug, withActivityIdentity } from './gateway-log-meta.js';
 import { resolvePreferOpenRouter } from './openrouter-routing.js';
-let sharedClientPromise = null;
-let sharedConfigKey;
+export { resolveInvokeModel, applyOpenRouterInvokePolicy, buildInvokeModelResolverOptions, enrichModelResolutionError, mapResolutionToRouterConfig, ModelProfileUnroutableError, ModelProfileInputRejectedError, MODEL_PROFILE_UNROUTABLE, getAiToolsInvokeClient, resetAiToolsInvokeClientForTests as resetAiToolsInvokeClientForTestsUpstream, createAiToolsInvokeClient, } from '@x12i/ai-tools';
+export { resolveOpenRouterApiKey, resolvePreferOpenRouter, readPreferOpenRouterFromEnv } from './openrouter-routing.js';
 let bootstrapFailedLogged = false;
-function configKey(config) {
-    return `${config.aiTools?.cacheTtlMs ?? ''}:${config.aiTools?.costIncludeBreakdown ?? ''}:${config.aiTools?.bundledOnly ?? ''}`;
+function invokeClientOptions(config) {
+    return {
+        cacheTtlMs: config.aiTools?.cacheTtlMs,
+        ...(config.aiTools?.bundledOnly ? { bundledOnly: true } : {}),
+        ...(config.aiTools?.costIncludeBreakdown ? { costIncludeBreakdown: true } : {}),
+        cacheKey: `${config.aiTools?.cacheTtlMs ?? ''}:${config.aiTools?.costIncludeBreakdown ?? ''}:${config.aiTools?.bundledOnly ?? ''}:${config.aiTools?.catalogLane ?? ''}`,
+    };
 }
-/**
- * Per-invoke resolver options: ai-tools decides OpenRouter vs direct from env + optional gateway prefer override.
- */
-export function buildModelResolverOptions(config, routingEnv) {
-    const env = routingEnv ?? loadOpenRouterRoutingEnv();
-    const prefer = resolvePreferOpenRouter(config);
+function withCatalogLaneCalculator(client, config) {
+    const lane = config.aiTools?.catalogLane;
+    if (!lane)
+        return client;
     return {
-        routingEnv: env,
-        ...(prefer ? { routeViaOpenRouter: true } : {}),
+        ...client,
+        calculator: new CostCalculator(client.catalog, {
+            ...(config.aiTools?.costIncludeBreakdown ? { includeBreakdown: true } : {}),
+            resolverOptions: buildInvokeModelResolverOptions({
+                routingEnv: client.routingEnv,
+                catalogLane: lane
+            })
+        })
     };
 }
+/** @deprecated Use buildInvokeModelResolverOptions */
+export function buildModelResolverOptions(config, routingEnv) {
+    return buildInvokeModelResolverOptions({
+        routingEnv,
+        preferOpenRouter: resolvePreferOpenRouter(config),
+    });
+}
+/**
+ * @deprecated Use mapResolutionToRouterConfig from @x12i/ai-tools
+ */
+export function applyModelResolution(merged, resolution, gatewayDefaultEngine, inputModel) {
+    const mapped = mapResolutionToRouterConfig(resolution, { provider: merged.provider, model: inputModel ?? merged.model ?? '' }, gatewayDefaultEngine);
+    merged.provider = mapped.provider;
+    merged.model = mapped.model;
+}
 /**
  * Returns catalog + calculator, or null when disabled or bootstrap fails.
  */
@@ -28,102 +53,27 @@ export async function getAiToolsClient(config, logger) {
     if (config.aiTools?.enabled === false) {
         return null;
     }
-    const key = configKey(config);
-    if (sharedClientPromise && sharedConfigKey !== key) {
-        sharedClientPromise = null;
-    }
-    sharedConfigKey = key;
-    if (!sharedClientPromise) {
-        sharedClientPromise = bootstrapAiTools(config, logger);
-    }
-    return sharedClientPromise;
-}
-/** Reset singleton (tests). */
-export function resetAiToolsClientForTests() {
-    sharedClientPromise = null;
-    sharedConfigKey = undefined;
-    bootstrapFailedLogged = false;
-}
-async function bootstrapAiTools(config, logger) {
-    try {
-        const routingEnv = loadOpenRouterRoutingEnv();
-        const catalog = new AiModelsCatalogClient({
-            cacheTtlMs: config.aiTools?.cacheTtlMs,
-            ...(config.aiTools?.bundledOnly ? { bundledOnly: true } : {}),
-            resolverOptions: { routingEnv },
-        });
-        const calculator = new CostCalculator(catalog, {
-            includeBreakdown: config.aiTools?.costIncludeBreakdown === true,
-        });
+    const client = await getAiToolsInvokeClient(invokeClientOptions(config), {
+        warn: (msg, err) => {
+            if (!bootstrapFailedLogged) {
+                bootstrapFailedLogged = true;
+                logger.warn(msg, withActivityIdentity(undefined, {
+                    error: err instanceof Error ? err.message : String(err),
+                    debugKind: gatewayLogDebug.anomaly,
+                }));
+            }
+        },
+    });
+    if (client) {
         logger.debug('ai-tools catalog client ready', {
             debugKind: gatewayLogDebug.state,
         });
-        return { catalog, calculator, routingEnv };
-    }
-    catch (error) {
-        if (!bootstrapFailedLogged) {
-            bootstrapFailedLogged = true;
-            logger.warn('ai-tools catalog bootstrap failed; model resolution and catalog cost calculation disabled', withActivityIdentity(undefined, {
-                error: error instanceof Error ? error.message : String(error),
-                debugKind: gatewayLogDebug.anomaly,
-            }));
-        }
-        return null;
-    }
-}
-/**
- * Map catalog resolution to router `{ provider, model }` (agnostic to openrouter vs vendor input).
- */
-export function applyModelResolution(merged, resolution, gatewayDefaultEngine, inputModel) {
-    const ref = resolveModelVendorFromResolution(resolution, inputModel ?? merged.model ?? '', {
-        asOpenRouter: resolution.routedViaOpenRouter,
-    });
-    if (ref) {
-        merged.provider = ref.provider;
-        merged.model = ref.model;
-        return;
-    }
-    if (resolution.routedViaOpenRouter) {
-        merged.provider = 'openrouter';
-        merged.model = resolution.modelId;
-        return;
-    }
-    const slash = resolution.modelId.indexOf('/');
-    if (slash > 0) {
-        merged.provider = resolution.record?.providerId ?? resolution.modelId.slice(0, slash);
-        merged.model = resolution.modelId.slice(slash + 1);
-    }
-    else {
-        merged.model = resolution.modelId;
-        if (resolution.record?.providerId) {
-            merged.provider = resolution.record.providerId;
-        }
-    }
-    if (!merged.provider && gatewayDefaultEngine) {
-        merged.provider = gatewayDefaultEngine;
+        return withCatalogLaneCalculator(client, config);
     }
+    return client;
 }
-/**
- * Router invoke flags after mergeConfig + ai-tools resolution (OpenRouter vs direct transport).
- */
-export function applyOpenRouterInvokePolicy(merged, options) {
-    if (!options.openRouterApiKey?.trim())
-        return;
-    const routingEnv = options.routingEnv ?? loadOpenRouterRoutingEnv();
-    const viaOpenRouter = options.resolution?.routedViaOpenRouter === true ||
-        (options.resolution?.routedViaOpenRouter !== false &&
-            isEffectiveOpenRouterTransport(routingEnv, {
-                provider: merged.provider,
-                modelId: merged.model,
-                routeViaOpenRouter: options.preferOpenRouter ? true : undefined,
-            }));
-    if (viaOpenRouter) {
-        merged.allowOpenRouterProxy = true;
-        if (merged.provider && merged.provider !== 'openrouter') {
-            merged.providerProxy = 'openrouter';
-        }
-    }
-    else {
-        merged.allowOpenRouterProxy = false;
-    }
+/** Reset singleton (tests). */
+export function resetAiToolsClientForTests() {
+    resetAiToolsInvokeClientForTestsUpstream();
+    bootstrapFailedLogged = false;
 }

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

@@ -1,44 +1,26 @@
 /**
- * Lazy @x12i/ai-tools catalog + cost calculator bootstrap.
+ * @x12i/ai-tools invoke client bootstrap for the gateway.
+ * Model resolution orchestration lives in ai-tools ≥ 2.5.0 (`resolveInvokeModel`).
  */
-import { AiModelsCatalogClient, CostCalculator, type ModelResolutionSuccess, type ModelResolverOptions, type OpenRouterRoutingConfig } from '@x12i/ai-tools';
+import { type AiToolsInvokeClient, type ModelResolutionSuccess, type OpenRouterRoutingConfig } from '@x12i/ai-tools';
 import type { Logxer } from '@x12i/logxer';
-import type { ChatRequest, GatewayConfig } from './types.js';
-export type AiToolsClientBundle = {
-    catalog: AiModelsCatalogClient;
-    calculator: CostCalculator;
-    routingEnv: OpenRouterRoutingConfig;
-};
+import type { GatewayConfig } from './types.js';
+export type AiToolsClientBundle = AiToolsInvokeClient;
+export { resolveInvokeModel, applyOpenRouterInvokePolicy, buildInvokeModelResolverOptions, enrichModelResolutionError, mapResolutionToRouterConfig, ModelProfileUnroutableError, ModelProfileInputRejectedError, MODEL_PROFILE_UNROUTABLE, getAiToolsInvokeClient, resetAiToolsInvokeClientForTests as resetAiToolsInvokeClientForTestsUpstream, createAiToolsInvokeClient, } from '@x12i/ai-tools';
+export { resolveOpenRouterApiKey, resolvePreferOpenRouter, readPreferOpenRouterFromEnv } from './openrouter-routing.js';
+export type { InvokeModelResolutionDiagnostics, InvokeModelResolutionInput, InvokeModelResolutionOptions, InvokeModelResolutionResult, InvokeRouterConfigSlice, AiToolsInvokeClient, } from '@x12i/ai-tools';
+/** @deprecated Use buildInvokeModelResolverOptions */
+export declare function buildModelResolverOptions(config: GatewayConfig, routingEnv?: OpenRouterRoutingConfig): import("@x12i/ai-tools").ModelResolverOptions;
 /**
- * Per-invoke resolver options: ai-tools decides OpenRouter vs direct from env + optional gateway prefer override.
+ * @deprecated Use mapResolutionToRouterConfig from @x12i/ai-tools
  */
-export declare function buildModelResolverOptions(config: GatewayConfig, routingEnv?: OpenRouterRoutingConfig): ModelResolverOptions;
+export declare function applyModelResolution(merged: {
+    provider?: string;
+    model?: string;
+}, resolution: ModelResolutionSuccess, gatewayDefaultEngine?: string, inputModel?: string): void;
 /**
  * Returns catalog + calculator, or null when disabled or bootstrap fails.
  */
 export declare function getAiToolsClient(config: GatewayConfig, logger: Logxer): Promise<AiToolsClientBundle | null>;
 /** Reset singleton (tests). */
 export declare function resetAiToolsClientForTests(): void;
-/**
- * Map catalog resolution to router `{ provider, model }` (agnostic to openrouter vs vendor input).
- */
-export declare function applyModelResolution(merged: NonNullable<ChatRequest['config']>, resolution: ModelResolutionSuccess, gatewayDefaultEngine?: string, inputModel?: string): void;
-type RouterConfigSlice = {
-    provider?: string;
-    model?: string;
-    allowOpenRouterProxy?: boolean;
-    providerProxy?: string;
-};
-type ModelResolutionMeta = {
-    routedViaOpenRouter?: boolean;
-};
-/**
- * Router invoke flags after mergeConfig + ai-tools resolution (OpenRouter vs direct transport).
- */
-export declare function applyOpenRouterInvokePolicy(merged: RouterConfigSlice, options: {
-    openRouterApiKey?: string;
-    preferOpenRouter?: boolean;
-    routingEnv?: OpenRouterRoutingConfig;
-    resolution?: ModelResolutionMeta;
-}): void;
-export {};

package/dist-cjs/gateway-utils.cjs

@@ -4,11 +4,10 @@
  */
 import * as crypto from 'crypto';
 import { FallbackExhaustedError } from '@x12i/ai-providers-router';
-import { ModelResolutionError, isKnownProfileChoice } from '@x12i/ai-tools';
+import { ModelResolutionError, ModelProfileInputRejectedError, ModelProfileUnroutableError, resolveInvokeModel, } from '@x12i/ai-tools';
 import { extractHttpStatusCode } from './gateway-retry.js';
 import { gatewayLogDebug, withActivityIdentity } from './gateway-log-meta.js';
 import { MaxTokensRequiredError, ModelRequiredError } from './instruction-errors.js';
-import { applyModelResolution, buildModelResolverOptions } from './ai-tools-client.js';
 import { DEFAULT_ACTIVITY_FULL_RESPONSE_MAX_CHARS, GATEWAY_DEFAULT_FREQUENCY_PENALTY, GATEWAY_DEFAULT_PRESENCE_PENALTY, GATEWAY_DEFAULT_TEMPERATURE, GATEWAY_DEFAULT_TOP_P } from './gateway-defaults.js';
 function getPreParsedInstructions(instructions) {
     return instructions ?? '';
@@ -37,6 +36,7 @@ export async function ensureTaskTypeId(request, logger) {
     });
     return taskTypeId;
 }
+export { MODEL_PROFILE_UNROUTABLE, ModelProfileUnroutableError, ModelProfileInputRejectedError, } from '@x12i/ai-tools';
 /**
  * Merges config with defaults
  * Supports using internal system action defaults (internalSkill or skillAudit) when useInternalDefaults is set
@@ -100,45 +100,64 @@ export async function mergeConfig(request, config, logger, mergeOptions) {
     }
     if (resolveModels && mergeOptions?.catalog) {
         try {
-            const resolverOptions = buildModelResolverOptions(config, mergeOptions?.routingEnv);
-            const resolution = await mergeOptions.catalog.resolveModel({
-                provider: merged.provider,
-                model: explicitModel,
-            }, resolverOptions);
-            if (resolution.found) {
-                applyModelResolution(merged, resolution, config.defaultEngine, explicitModel);
-                request._modelResolution = {
-                    modelId: resolution.modelId,
-                    routedViaOpenRouter: resolution.routedViaOpenRouter,
-                    confidence: resolution.confidence,
-                    resolvedVia: resolution.resolvedVia,
-                    originalProvider,
-                    originalModel
-                };
-                logger.verbose('Catalog resolved model name', {
-                    jobId: request.identity.jobId,
-                    originalModel,
-                    resolvedModelId: resolution.modelId,
-                    provider: merged.provider,
-                    model: merged.model,
-                    confidence: resolution.confidence,
-                    resolvedVia: resolution.resolvedVia
-                });
+            const resolved = await resolveInvokeModel({ provider: merged.provider, model: explicitModel }, {
+                catalog: mergeOptions.catalog,
+                routingEnv: mergeOptions.routingEnv,
+                openRouterApiKey: mergeOptions.openRouterApiKey,
+                preferOpenRouter: mergeOptions.preferOpenRouter,
+                defaultProvider: config.defaultEngine,
+                resolveModels: true,
+                modelsOnly: config.aiTools?.modelsOnly !== false,
+                ...(config.aiTools?.catalogLane ? { catalogLane: config.aiTools.catalogLane } : {}),
+                ...(config.aiTools?.bundledOnly ? { bundledOnly: true } : {}),
+            });
+            merged.provider = resolved.router.provider;
+            merged.model = resolved.router.model;
+            if (resolved.router.allowOpenRouterProxy !== undefined) {
+                merged.allowOpenRouterProxy = resolved.router.allowOpenRouterProxy;
             }
-            else {
-                throw buildModelResolutionFailureError(explicitModel, merged.provider, resolution);
+            if (resolved.router.providerProxy !== undefined) {
+                merged.providerProxy = resolved.router.providerProxy;
             }
+            request._modelResolution = resolved.diagnostics;
+            logger.verbose('Catalog resolved model name', {
+                jobId: request.identity.jobId,
+                originalModel,
+                originalProvider,
+                resolvedModelId: resolved.diagnostics.modelId,
+                provider: merged.provider,
+                model: merged.model,
+                confidence: resolved.diagnostics.confidence,
+                resolvedVia: resolved.diagnostics.resolvedVia,
+                routedViaOpenRouter: resolved.diagnostics.routedViaOpenRouter,
+            });
         }
         catch (error) {
-            if (error instanceof ModelResolutionError) {
-                throw error;
-            }
-            if (error instanceof ModelProfileUnroutableError) {
+            if (error instanceof ModelResolutionError ||
+                error instanceof ModelProfileUnroutableError ||
+                error instanceof ModelProfileInputRejectedError) {
                 throw error;
             }
             throw error;
         }
     }
+    else if (mergeOptions?.openRouterApiKey) {
+        const resolved = await resolveInvokeModel({ provider: merged.provider, model: explicitModel }, {
+            resolveModels: false,
+            routingEnv: mergeOptions.routingEnv,
+            openRouterApiKey: mergeOptions.openRouterApiKey,
+            preferOpenRouter: mergeOptions.preferOpenRouter,
+            defaultProvider: config.defaultEngine,
+        });
+        merged.provider = resolved.router.provider;
+        merged.model = resolved.router.model;
+        if (resolved.router.allowOpenRouterProxy !== undefined) {
+            merged.allowOpenRouterProxy = resolved.router.allowOpenRouterProxy;
+        }
+        if (resolved.router.providerProxy !== undefined) {
+            merged.providerProxy = resolved.router.providerProxy;
+        }
+    }
     if (!merged.model) {
         throw new ModelRequiredError();
     }
@@ -351,42 +370,119 @@ export function resolveCostCompletionForActivity(routerResponse, tokens) {
     }
     return resolveActivityCostCompletion(tokens, costUsd);
 }
-/** Record shape for {@link CostCalculator.calculateFromRecord} (router + merged config + usage). */
+/**
+ * Best-effort cache/reasoning token counts from router usage buckets
+ * (for {@link buildGatewayPricingRecord} / ai-tools {@link CostCalculator.calculateFromRecord}).
+ */
+export function extractUsageExtrasFromRouterResponse(routerResponse) {
+    if (routerResponse == null || typeof routerResponse !== 'object')
+        return {};
+    const r = routerResponse;
+    const roots = [r.usage];
+    const meta = r.metadata != null && typeof r.metadata === 'object'
+        ? r.metadata
+        : undefined;
+    if (meta) {
+        roots.push(meta.usage, meta.tokens);
+    }
+    const raw = r.rawResponse ?? r.raw;
+    if (raw != null && typeof raw === 'object') {
+        roots.push(raw.usage);
+    }
+    const extras = {};
+    for (const bucket of roots) {
+        if (bucket == null || typeof bucket !== 'object')
+            continue;
+        const u = bucket;
+        const cached = firstFiniteNumber(u.cached, u.cached_tokens, u.cachedTokens, u.cache_read_tokens, u.cacheReadTokens);
+        const cacheWrite = firstFiniteNumber(u.cacheWrite, u.cache_write_tokens, u.cacheWriteTokens);
+        const reasoning = firstFiniteNumber(u.reasoning, u.reasoning_tokens, u.reasoningTokens);
+        if (cached !== undefined && extras.cached === undefined)
+            extras.cached = cached;
+        if (cacheWrite !== undefined && extras.cacheWrite === undefined)
+            extras.cacheWrite = cacheWrite;
+        if (reasoning !== undefined && extras.reasoning === undefined)
+            extras.reasoning = reasoning;
+    }
+    return extras;
+}
+/**
+ * Whether ai-tools catalog pricing is authoritative enough for Step B (`priced`).
+ * Matches the generic engine contract: authoritative catalog hit with finite cost ≥ 0.
+ */
+export function catalogPricingSucceeded(result) {
+    if (result.unknownModel)
+        return false;
+    if (!result.isAuthoritative)
+        return false;
+    if (result.source === 'estimate-fallback' || result.source === 'local')
+        return false;
+    if (typeof result.cost !== 'number' || !Number.isFinite(result.cost) || result.cost < 0) {
+        return false;
+    }
+    return true;
+}
+/** Record shape for {@link CostCalculator.calculateFromRecord} (shared engine contract). */
 export function buildGatewayPricingRecord(routerResponse, tokens, mergedConfig) {
-    const base = routerResponse != null && typeof routerResponse === 'object'
-        ? { ...routerResponse }
-        : {};
-    const meta = base.metadata != null && typeof base.metadata === 'object'
-        ? { ...base.metadata }
-        : {};
     const routing = pickInvokeRoutingMetadataSlice(routerResponse, mergedConfig);
+    const cfg = mergedConfig != null && typeof mergedConfig === 'object'
+        ? mergedConfig
+        : {};
+    const requestModel = typeof cfg.model === 'string'
+        ? cfg.model
+        : typeof routing.modelUsed === 'string'
+            ? routing.modelUsed
+            : undefined;
+    const modelUsed = routing.modelUsed ?? requestModel;
+    const provider = routing.provider ??
+        (typeof cfg.provider === 'string' ? cfg.provider : undefined) ??
+        'openrouter';
+    const usageExtras = extractUsageExtrasFromRouterResponse(routerResponse);
+    const tokenSlice = {
+        prompt: tokens.prompt,
+        completion: tokens.completion,
+        total: tokens.total,
+        ...usageExtras
+    };
     return {
-        ...base,
+        model: modelUsed ?? requestModel ?? '',
+        ...(requestModel && modelUsed && requestModel !== modelUsed
+            ? { modelAlias: requestModel }
+            : {}),
+        ...(modelUsed ? { modelUsed, usedModel: modelUsed } : {}),
+        provider,
+        ...(provider || routing.region
+            ? {
+                routing: {
+                    provider,
+                    ...(routing.region ? { region: routing.region } : {})
+                }
+            }
+            : {}),
         usage: {
-            promptTokens: tokens.prompt,
-            completionTokens: tokens.completion,
-            totalTokens: tokens.total
+            prompt_tokens: tokens.prompt,
+            completion_tokens: tokens.completion,
+            total_tokens: tokens.total,
+            ...(usageExtras.cached !== undefined ? { cachedTokensPrompt: usageExtras.cached } : {}),
+            ...(usageExtras.cached !== undefined ? { cachedTokensTotal: usageExtras.cached } : {})
         },
-        tokens,
+        promptTokens: tokens.prompt,
+        completionTokens: tokens.completion,
+        totalTokens: tokens.total,
+        tokens: tokenSlice,
         metadata: {
-            ...meta,
-            tokens,
-            ...(routing.provider ? { provider: routing.provider } : {}),
-            ...(routing.modelUsed
-                ? { modelUsed: routing.modelUsed, model: routing.modelUsed }
-                : {})
+            provider,
+            ...(modelUsed ? { modelUsed, model: modelUsed } : {}),
+            ...(routing.maxTokensRequested !== undefined
+                ? { maxTokensRequested: routing.maxTokensRequested }
+                : {}),
+            tokens: tokenSlice
         },
         ...(mergedConfig != null ? { config: mergedConfig } : {})
     };
 }
 export function mapAiCostResultToResolvedActivityCost(base, result) {
-    if (result.unknownModel) {
-        return base.costStatus ? base : { ...base, costStatus: 'unpriced' };
-    }
-    if (typeof result.cost !== 'number' || !Number.isFinite(result.cost)) {
-        return base;
-    }
-    if (!result.isAuthoritative && result.source === 'estimate-fallback') {
+    if (!catalogPricingSucceeded(result)) {
         return base.costStatus ? base : { ...base, costStatus: 'unpriced' };
     }
     return {
@@ -395,6 +491,16 @@ export function mapAiCostResultToResolvedActivityCost(base, result) {
         ...(result.breakdown ? { costBreakdown: result.breakdown } : {})
     };
 }
+/**
+ * G8 safety net: token usage without a billing signal → `unpriced`.
+ * Used at invoke boundaries after {@link resolveCostCompletionWithAiTools}.
+ */
+export function ensureInvokeBillingCostStatus(billing, tokens) {
+    if (!billing.costStatus && hasNonZeroTokenUsage(tokens)) {
+        return { ...billing, costStatus: 'unpriced' };
+    }
+    return billing;
+}
 /**
  * Router cost passthrough, then optional @x12i/ai-tools catalog pricing when still unpriced.
  */
@@ -419,30 +525,7 @@ export async function resolveCostCompletionWithAiTools(routerResponse, tokens, o
         return mapAiCostResultToResolvedActivityCost(base, result);
     }
     catch {
-        const routing = pickInvokeRoutingMetadataSlice(routerResponse, options.mergedConfig);
-        const cfg = options.mergedConfig != null && typeof options.mergedConfig === 'object'
-            ? options.mergedConfig
-            : {};
-        const provider = routing.provider ?? cfg.provider;
-        const modelUsed = routing.modelUsed ?? cfg.model;
-        if (!provider || !modelUsed) {
-            return base;
-        }
-        try {
-            const result = await options.calculator.calculate({
-                tokens: {
-                    prompt: tokens.prompt,
-                    completion: tokens.completion,
-                    total: tokens.total
-                },
-                provider,
-                usedModel: modelUsed
-            });
-            return mapAiCostResultToResolvedActivityCost(base, result);
-        }
-        catch {
-            return base;
-        }
+        return ensureInvokeBillingCostStatus(base, tokens);
     }
 }
 function applyBillingToTraceAttempt(attempt, billing) {
@@ -679,31 +762,6 @@ export function pickRequestIdsFromRouterLike(gatewayAiRequestId, routerLike) {
     }
     return out;
 }
-/** Error code hint when a bundled profile name cannot be routed to a catalog target. */
-export const MODEL_PROFILE_UNROUTABLE = 'MODEL_PROFILE_UNROUTABLE';
-export class ModelProfileUnroutableError extends Error {
-    profileAlias;
-    provider;
-    code = MODEL_PROFILE_UNROUTABLE;
-    constructor(profileAlias, provider, cause) {
-        super(`${MODEL_PROFILE_UNROUTABLE}: profile "${profileAlias}" is retired or has no routable catalog target` +
-            (provider ? ` (provider: "${provider}")` : '') +
-            '. Update @x12i/ai-profiles or choose another profile alias.');
-        this.profileAlias = profileAlias;
-        this.provider = provider;
-        this.name = 'ModelProfileUnroutableError';
-        if (cause !== undefined) {
-            this.cause = cause;
-        }
-    }
-}
-function buildModelResolutionFailureError(explicitModel, provider, resolution) {
-    const base = new ModelResolutionError({ provider, model: explicitModel }, resolution);
-    if (isKnownProfileChoice(explicitModel)) {
-        return new ModelProfileUnroutableError(explicitModel, provider, base);
-    }
-    return base;
-}
 /**
  * Build rejection-metadata fallback attempts from trace-mode {@link GatewayTraceAttempt}s.
  */
@@ -772,7 +830,7 @@ export function mapGatewayFallbackAttemptsToRouter(attempts) {
     }));
 }
 /**
- * Log profile alias vs OpenRouter model id actually sent to the router after catalog resolution.
+ * Log original input vs OpenRouter model id actually sent to the router after catalog resolution.
  */
 export function logResolvedModelRouting(logger, request, mergedConfig) {
     const res = request._modelResolution;
@@ -780,14 +838,14 @@ export function logResolvedModelRouting(logger, request, mergedConfig) {
         return;
     }
     const profileAlias = res.originalModel ?? mergedConfig?.model;
-    const invokedModelId = res.modelId ?? mergedConfig?.model;
+    const invokedModelId = res.invokedModelId ?? res.modelId ?? mergedConfig?.model;
     const provider = mergedConfig?.provider;
     const openRouterPath = res.routedViaOpenRouter === true || provider === 'openrouter';
     if (!openRouterPath) {
         return;
     }
-    logger.info('OpenRouter routing: profile alias resolved to model id for invoke', withActivityIdentity(request.identity, {
-        profileAlias,
+    logger.info('OpenRouter routing: input model resolved to catalog id for invoke', withActivityIdentity(request.identity, {
+        inputModel: profileAlias,
         invokedOpenRouterModelId: invokedModelId,
         provider,
         routedViaOpenRouter: res.routedViaOpenRouter,