@x12i/ai-gateway 9.7.9 → 10.0.0

package/dist/gateway-meta.js

@@ -2,7 +2,8 @@
  * Gateway Meta Operations Module
  * Handles meta operations like instruction optimization and testing
  */
-import { CODE_DEFAULT_MODEL } from './gateway-mode.js';
+import { GATEWAY_DEFAULT_TEMPERATURE } from './gateway-defaults.js';
+import { MaxTokensRequiredError } from './instruction-errors.js';
 /**
  * Test instructions by running them and analyzing the response
  */
@@ -10,14 +11,15 @@ export async function testInstructions(instructions, testInput, expectedSchema,
     // Get internal system action config (instruction audit)
     const internalConfig = config.internalSystemActions?.instructionAudit;
     const defaultEngine = config.defaultEngine || 'openai';
-    const defaultModel = internalConfig?.model || CODE_DEFAULT_MODEL;
-    const defaultProvider = internalConfig?.engine || defaultEngine;
-    const { agentId = 'instruction-tester', model = options.model || defaultModel, // Use internal config default if not provided
-    provider = options.provider || defaultProvider // Use internal config default if not provided
-     } = options;
-    if (!model) {
-        throw new Error('Model must be provided in options.model or configured as default');
+    const resolvedModel = options.model ?? internalConfig?.model;
+    const resolvedProvider = options.provider ?? internalConfig?.engine ?? defaultEngine;
+    if (!resolvedModel) {
+        throw new Error('Model must be provided in options.model or internalSystemActions.instructionAudit.model');
     }
+    if (typeof internalConfig?.maxTokens !== 'number' || internalConfig.maxTokens <= 0) {
+        throw new MaxTokensRequiredError('maxTokens must be set in internalSystemActions.instructionAudit for testInstructions');
+    }
+    const { agentId = 'instruction-tester', model = resolvedModel, provider = resolvedProvider } = options;
     const aiRequestId = `test-instructions-${Date.now()}`;
     const runtimeIdentity = {
         ...options.identity,
@@ -37,8 +39,8 @@ export async function testInstructions(instructions, testInput, expectedSchema,
         config: {
             model,
             provider,
-            temperature: internalConfig?.temperature ?? 0.7, // Use internal config or default
-            maxTokens: internalConfig?.maxTokens ?? 2000 // Use internal config or default
+            temperature: internalConfig?.temperature ?? GATEWAY_DEFAULT_TEMPERATURE,
+            maxTokens: internalConfig.maxTokens
         }
     };
     // Run the test

package/dist/gateway-mode.d.ts

@@ -1,21 +1,11 @@
 /**
- * Gateway operational mode (prod vs dev/debug) and default model resolution.
+ * Gateway operational mode (prod vs dev/debug).
  */
-import type { Logxer } from '@x12i/logxer';
-import type { ActivityIdentity, GatewayConfig } from './types.js';
+import type { GatewayConfig } from './types.js';
 export type GatewayOperationalMode = 'prod' | 'debug' | 'dev';
-export type GatewayDefaultModelSource = 'env' | 'model-config.json' | 'code';
-export type DefaultModelSubstitutionReason = 'no_model_provided' | 'model_resolution_failed' | 'ai_tools_unavailable';
-/** Profile name resolved via ai-tools + {@link @x12i/ai-profiles} when catalog is enabled. */
-export declare const CODE_DEFAULT_MODEL = "cheap";
-export type ResolvedGatewayDefault = {
-    model: string;
-    provider?: string;
-    source: GatewayDefaultModelSource;
-};
 /**
  * Operational mode: `GatewayConfig.mode` overrides `process.env.mode` / `MODE`.
- * Only `prod` allows silent default-model substitution; all other values are strict.
+ * Affects ai-tools model resolution strictness — does not substitute missing models.
  */
 export declare function getGatewayOperationalMode(config?: Pick<GatewayConfig, 'mode'>): GatewayOperationalMode;
 export declare function isProdGatewayMode(mode: GatewayOperationalMode): boolean;
@@ -26,16 +16,3 @@ export declare function parseModelProviderSpec(spec: string): {
     provider?: string;
     model: string;
 };
-/**
- * Default model priority: AI_GATEWAY_DEFAULT_MODEL → model-config.json → code constant.
- */
-export declare function resolveGatewayDefaultModel(defaultModelConfig?: Record<string, unknown>, gatewayDefaultEngine?: string): ResolvedGatewayDefault;
-export declare function warnDefaultModelSubstitution(logger: Logxer, identity: Partial<ActivityIdentity> | undefined, details: {
-    reason: DefaultModelSubstitutionReason;
-    mode: GatewayOperationalMode;
-    defaultSource: GatewayDefaultModelSource;
-    defaultProvider?: string;
-    defaultModel: string;
-    originalProvider?: string;
-    originalModel?: string;
-}): void;

package/dist/gateway-mode.js

@@ -1,13 +1,9 @@
 /**
- * Gateway operational mode (prod vs dev/debug) and default model resolution.
+ * Gateway operational mode (prod vs dev/debug).
  */
-import { gatewayLogDebug } from './gateway-log-meta.js';
-import { fieldEvidence, GatewayLogCode, gatewayWarnCode } from './gateway-log-diagnostics.js';
-/** Profile name resolved via ai-tools + {@link @x12i/ai-profiles} when catalog is enabled. */
-export const CODE_DEFAULT_MODEL = 'cheap';
 /**
  * Operational mode: `GatewayConfig.mode` overrides `process.env.mode` / `MODE`.
- * Only `prod` allows silent default-model substitution; all other values are strict.
+ * Affects ai-tools model resolution strictness — does not substitute missing models.
  */
 export function getGatewayOperationalMode(config) {
     if (config?.mode) {
@@ -29,7 +25,7 @@ export function isProdGatewayMode(mode) {
 export function parseModelProviderSpec(spec) {
     const trimmed = spec.trim();
     if (!trimmed) {
-        return { model: CODE_DEFAULT_MODEL };
+        throw new Error('Model spec must be a non-empty string');
     }
     const slash = trimmed.indexOf('/');
     if (slash === -1) {
@@ -42,44 +38,3 @@ export function parseModelProviderSpec(spec) {
     }
     return { provider: first, model: rest };
 }
-/**
- * Default model priority: AI_GATEWAY_DEFAULT_MODEL → model-config.json → code constant.
- */
-export function resolveGatewayDefaultModel(defaultModelConfig, gatewayDefaultEngine) {
-    const envSpec = process.env.AI_GATEWAY_DEFAULT_MODEL?.trim();
-    if (envSpec) {
-        const parsed = parseModelProviderSpec(envSpec);
-        return { model: parsed.model, provider: parsed.provider, source: 'env' };
-    }
-    const jsonModel = typeof defaultModelConfig?.defaultModel === 'string' ? defaultModelConfig.defaultModel : undefined;
-    if (jsonModel) {
-        const parsed = parseModelProviderSpec(jsonModel);
-        const jsonEngine = typeof defaultModelConfig?.defaultEngine === 'string'
-            ? defaultModelConfig.defaultEngine
-            : gatewayDefaultEngine;
-        return {
-            model: parsed.model,
-            provider: parsed.provider ?? jsonEngine,
-            source: 'model-config.json'
-        };
-    }
-    return {
-        model: CODE_DEFAULT_MODEL,
-        provider: gatewayDefaultEngine,
-        source: 'code'
-    };
-}
-export function warnDefaultModelSubstitution(logger, identity, details) {
-    gatewayWarnCode(logger, GatewayLogCode.DEFAULT_MODEL_SUBSTITUTED, identity, {
-        ...details,
-        debugKind: gatewayLogDebug.anomaly,
-        evidence: [
-            fieldEvidence('defaultModel', details.defaultModel),
-            fieldEvidence('defaultSource', details.defaultSource),
-            fieldEvidence('reason', details.reason),
-            fieldEvidence('mode', details.mode),
-            ...(details.originalModel ? [fieldEvidence('originalModel', details.originalModel)] : []),
-            ...(details.originalProvider ? [fieldEvidence('originalProvider', details.originalProvider)] : [])
-        ]
-    });
-}

package/dist/gateway-retry.js

@@ -5,6 +5,7 @@
  * NOTE: Retry delays use SIMPLE SLEEP (not smart rate limiting).
  * Between-calls rate limiting is handled separately in gateway-rate-limiter.ts (smart).
  */
+import { GATEWAY_DEFAULT_RETRY } from './gateway-defaults.js';
 import { exceptionEvidence, fieldEvidence, GatewayLogCode, gatewayWarnCode } from './gateway-log-diagnostics.js';
 /**
  * Determines if an error is a network error (fetch failed, DNS, connectivity)
@@ -95,12 +96,12 @@ export function sleep(ms) {
  * Returns response and retry metadata
  */
 export async function invokeWithRetry(routerRequest, retryConfig, jobId, router, logger, hooks) {
-    const maxRetries = retryConfig.maxRetries ?? 3;
-    const initialDelay = retryConfig.initialDelay ?? 1000;
-    const maxDelay = retryConfig.maxDelay ?? 30000;
-    const backoffMultiplier = retryConfig.backoffMultiplier ?? 2;
-    const enableJitter = retryConfig.enableJitter ?? true;
-    const throttlingDelay = retryConfig.throttlingDelay ?? 5000;
+    const maxRetries = retryConfig.maxRetries ?? GATEWAY_DEFAULT_RETRY.maxRetries;
+    const initialDelay = retryConfig.initialDelay ?? GATEWAY_DEFAULT_RETRY.initialDelay;
+    const maxDelay = retryConfig.maxDelay ?? GATEWAY_DEFAULT_RETRY.maxDelay;
+    const backoffMultiplier = retryConfig.backoffMultiplier ?? GATEWAY_DEFAULT_RETRY.backoffMultiplier;
+    const enableJitter = retryConfig.enableJitter ?? GATEWAY_DEFAULT_RETRY.enableJitter;
+    const throttlingDelay = retryConfig.throttlingDelay ?? GATEWAY_DEFAULT_RETRY.throttlingDelay;
     let lastError;
     const retryAttempts = [];
     for (let attempt = 0; attempt <= maxRetries; attempt++) {

package/dist/gateway-utils.d.ts

@@ -14,16 +14,9 @@ export declare function generateMD5Hash(text: string): string;
  */
 export declare function ensureTaskTypeId(request: ChatRequest, logger: Logxer): Promise<string>;
 export type MergeConfigOptions = {
-    defaultModelConfig?: Record<string, unknown>;
     catalog?: AiModelsCatalogClient | null;
     routingEnv?: OpenRouterRoutingConfig;
 };
-/**
- * True when any caller-controlled config source set `maxTokens` (Optimixer should not override).
- */
-export declare function isMaxTokensExplicitlySet(request: ChatRequest & {
-    useInternalDefaults?: 'skill' | 'audit';
-}, config: GatewayConfig): boolean;
 /**
  * Merges config with defaults
  * Supports using internal system action defaults (internalSkill or skillAudit) when useInternalDefaults is set
@@ -199,17 +192,6 @@ export declare function buildInvokeRejectionMetadata(args: {
     error?: unknown;
 }): GatewayInvokeRejectionMetadata;
 export declare function attachGatewayInvokeRejectionMetadata(err: Error, metadata: GatewayInvokeRejectionMetadata): void;
-/** Default JSON string length cap for Activix `content.fullResponse` when diagnostics allow storing it. */
-export declare const DEFAULT_ACTIVITY_FULL_RESPONSE_MAX_CHARS = 512000;
-/**
- * Size-cap a provider/router payload before storing on an activity record.
- * Non-serializable values become a small marker object instead of throwing.
- */
+export { DEFAULT_ACTIVITY_FULL_RESPONSE_MAX_CHARS } from './gateway-defaults.js';
 export declare function capActivityFullResponsePayload(payload: unknown, maxChars?: number): unknown;
 export declare function resolveFinishReasonFromRouterResponse(response: unknown): string | undefined;
-export declare function buildOptimixerActualUsage(tokens: {
-    prompt: number;
-    completion: number;
-    total: number;
-}, response: unknown, latencyMs: number): import('@x12i/optimixer').AiMaxTokensActualUsage;
-export {};

package/dist/gateway-utils.js

@@ -7,10 +7,12 @@ import { FallbackExhaustedError } from '@x12i/ai-providers-router';
 import { ModelResolutionError, isKnownProfileOrShortcut } from '@x12i/ai-tools';
 import { extractHttpStatusCode } from './gateway-retry.js';
 import { gatewayLogDebug, withActivityIdentity } from './gateway-log-meta.js';
-import { getPreParsedInstructions } from './gateway-instructions.js';
-import { getModelMaxTokensFromFlexMd } from './flex-md-loader.js';
+import { MaxTokensRequiredError, ModelRequiredError } from './instruction-errors.js';
 import { applyModelResolution, buildModelResolverOptions } from './ai-tools-client.js';
-import { getGatewayOperationalMode, isProdGatewayMode, resolveGatewayDefaultModel, warnDefaultModelSubstitution } from './gateway-mode.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 ?? '';
+}
 /**
  * Generates MD5 hash of a string
  */
@@ -35,83 +37,6 @@ export async function ensureTaskTypeId(request, logger) {
     });
     return taskTypeId;
 }
-function applyGatewayDefaultToMerged(merged, defaults, config) {
-    merged.model = defaults.model;
-    if (defaults.provider) {
-        merged.provider = defaults.provider;
-    }
-    else if (!merged.provider) {
-        merged.provider = config.defaultEngine;
-    }
-}
-async function substituteGatewayDefaultModel(merged, request, config, logger, mergeOptions, reason, original) {
-    const operationalMode = getGatewayOperationalMode(config);
-    const defaults = resolveGatewayDefaultModel(mergeOptions?.defaultModelConfig, config.defaultEngine);
-    warnDefaultModelSubstitution(logger, request.identity, {
-        reason,
-        mode: operationalMode,
-        defaultSource: defaults.source,
-        defaultProvider: defaults.provider ?? merged.provider,
-        defaultModel: defaults.model,
-        originalProvider: original?.provider ?? merged.provider,
-        originalModel: original?.model
-    });
-    applyGatewayDefaultToMerged(merged, defaults, config);
-}
-async function tryResolveSubstitutedDefaultModel(merged, request, config, logger, mergeOptions, original) {
-    const resolveModels = config.aiTools?.resolveModels !== false;
-    const catalog = mergeOptions?.catalog;
-    if (!resolveModels || !catalog || !merged.model) {
-        return;
-    }
-    try {
-        const resolverOptions = buildModelResolverOptions(config, mergeOptions?.routingEnv);
-        const resolution = await catalog.resolveModel({
-            provider: merged.provider,
-            model: merged.model,
-        }, resolverOptions);
-        if (!resolution.found) {
-            return;
-        }
-        applyModelResolution(merged, resolution, config.defaultEngine, merged.model);
-        request._modelResolution = {
-            modelId: resolution.modelId,
-            routedViaOpenRouter: resolution.routedViaOpenRouter,
-            confidence: resolution.confidence,
-            resolvedVia: resolution.resolvedVia,
-            originalProvider: original?.provider ?? merged.provider,
-            originalModel: original?.model ?? merged.model
-        };
-        logger.verbose('Catalog resolved substituted default model', {
-            jobId: request.identity.jobId,
-            model: merged.model,
-            provider: merged.provider,
-            resolvedModelId: resolution.modelId
-        });
-    }
-    catch {
-        // Prod keeps the substituted bare default when re-resolution fails.
-    }
-}
-async function substituteGatewayDefaultModelAndResolve(merged, request, config, logger, mergeOptions, reason, original) {
-    await substituteGatewayDefaultModel(merged, request, config, logger, mergeOptions, reason, original);
-    await tryResolveSubstitutedDefaultModel(merged, request, config, logger, mergeOptions, original);
-}
-/**
- * True when any caller-controlled config source set `maxTokens` (Optimixer should not override).
- */
-export function isMaxTokensExplicitlySet(request, config) {
-    const useInternalDefaults = request.useInternalDefaults;
-    const internalDefaults = useInternalDefaults === 'skill'
-        ? config.internalSystemActions?.internalSkill
-        : useInternalDefaults === 'audit'
-            ? config.internalSystemActions?.skillAudit
-            : undefined;
-    return (request.config?.maxTokens !== undefined ||
-        request.modelConfig?.maxTokens !== undefined ||
-        internalDefaults?.maxTokens !== undefined ||
-        config.maxTokens !== undefined);
-}
 /**
  * Merges config with defaults
  * Supports using internal system action defaults (internalSkill or skillAudit) when useInternalDefaults is set
@@ -135,7 +60,6 @@ export async function mergeConfig(request, config, logger, mergeOptions) {
         useInternalDefaults,
         hasInternalDefaults: !!internalDefaults
     });
-    const operationalMode = getGatewayOperationalMode(config);
     const resolveModels = config.aiTools?.resolveModels !== false;
     // Priority: modelConfig > request.config > internalSystemActions[useInternalDefaults] > gateway defaults
     // First, merge modelConfig into a config-like object if present
@@ -152,36 +76,29 @@ export async function mergeConfig(request, config, logger, mergeOptions) {
         ...Object.fromEntries(Object.entries(request.modelConfig).filter(([key]) => !['model', 'modelId', 'provider', 'temperature', 'maxTokens', 'topP', 'frequencyPenalty', 'presencePenalty', 'stop'].includes(key)))
     } : undefined;
     const merged = {
-        // Start with gateway defaults (lowest priority)
-        temperature: config.temperature ?? 0.7,
-        // maxTokens will be set from flex-md if available, otherwise fallback to 2000
-        topP: config.topP ?? 1.0,
-        frequencyPenalty: config.frequencyPenalty ?? 0.0,
-        presencePenalty: config.presencePenalty ?? 0.0,
-        // Apply internal system action defaults (medium priority) if useInternalDefaults is set
+        temperature: config.temperature ?? GATEWAY_DEFAULT_TEMPERATURE,
+        topP: config.topP ?? GATEWAY_DEFAULT_TOP_P,
+        frequencyPenalty: config.frequencyPenalty ?? GATEWAY_DEFAULT_FREQUENCY_PENALTY,
+        presencePenalty: config.presencePenalty ?? GATEWAY_DEFAULT_PRESENCE_PENALTY,
+        ...(config.maxTokens !== undefined ? { maxTokens: config.maxTokens } : {}),
         ...(internalDefaults ? {
             model: internalDefaults.model,
             provider: internalDefaults.engine || config.defaultEngine,
-            temperature: internalDefaults.temperature ?? config.temperature ?? 0.7,
-            // maxTokens from internalDefaults only if explicitly set, otherwise will be auto-detected
+            temperature: internalDefaults.temperature ?? config.temperature ?? GATEWAY_DEFAULT_TEMPERATURE,
             ...(internalDefaults.maxTokens !== undefined ? { maxTokens: internalDefaults.maxTokens } : {})
         } : {}),
-        // Request config overrides (higher priority)
         ...request.config,
-        // ModelConfig overrides (highest priority) - merge only defined values
         ...(modelConfigAsConfig ? Object.fromEntries(Object.entries(modelConfigAsConfig).filter(([_, value]) => value !== undefined)) : {}),
-        // Model resolved below (catalog, default chain, or explicit pass-through)
         model: modelConfigAsConfig?.model || request.config?.model || internalDefaults?.model,
-        // Ensure provider is set: modelConfig > request.config > internalDefaults > gateway default
         provider: modelConfigAsConfig?.provider || request.config?.provider || internalDefaults?.engine || config.defaultEngine
     };
     const explicitModel = merged.model;
     const originalProvider = merged.provider;
     const originalModel = explicitModel;
     if (!explicitModel) {
-        await substituteGatewayDefaultModelAndResolve(merged, request, config, logger, mergeOptions, 'no_model_provided');
+        throw new ModelRequiredError();
     }
-    else if (resolveModels && mergeOptions?.catalog) {
+    if (resolveModels && mergeOptions?.catalog) {
         try {
             const resolverOptions = buildModelResolverOptions(config, mergeOptions?.routingEnv);
             const resolution = await mergeOptions.catalog.resolveModel({
@@ -208,9 +125,6 @@ export async function mergeConfig(request, config, logger, mergeOptions) {
                     resolvedVia: resolution.resolvedVia
                 });
             }
-            else if (isProdGatewayMode(operationalMode)) {
-                await substituteGatewayDefaultModelAndResolve(merged, request, config, logger, mergeOptions, 'model_resolution_failed', { provider: originalProvider, model: originalModel });
-            }
             else {
                 throw buildModelResolutionFailureError(explicitModel, merged.provider, resolution);
             }
@@ -219,95 +133,34 @@ export async function mergeConfig(request, config, logger, mergeOptions) {
             if (error instanceof ModelResolutionError) {
                 throw error;
             }
-            if (isProdGatewayMode(operationalMode)) {
-                await substituteGatewayDefaultModelAndResolve(merged, request, config, logger, mergeOptions, 'ai_tools_unavailable', { provider: originalProvider, model: originalModel });
-            }
-            else {
+            if (error instanceof ModelProfileUnroutableError) {
                 throw error;
             }
+            throw error;
         }
     }
-    else if (resolveModels && !mergeOptions?.catalog && isProdGatewayMode(operationalMode)) {
-        await substituteGatewayDefaultModelAndResolve(merged, request, config, logger, mergeOptions, 'ai_tools_unavailable', { provider: originalProvider, model: originalModel });
-    }
     if (!merged.model) {
-        await substituteGatewayDefaultModelAndResolve(merged, request, config, logger, mergeOptions, 'no_model_provided');
-    }
-    const maxTokensExplicitlySet = isMaxTokensExplicitlySet(request, config);
-    const optimixerWillPredict = config.optimixer?.enabled === true && !maxTokensExplicitlySet;
-    // Auto-get maxTokens from flex-md when Optimixer is not handling adaptive max_tokens.
-    if (!optimixerWillPredict && !maxTokensExplicitlySet && merged.model && merged.provider) {
-        // Try to get maxTokens from flex-md
-        try {
-            const flexMdMaxTokens = await getModelMaxTokensFromFlexMd(merged.provider, merged.model);
-            if (flexMdMaxTokens && flexMdMaxTokens > 0) {
-                merged.maxTokens = flexMdMaxTokens;
-                logger.debug('Using maxTokens from flex-md', {
-                    jobId: request.identity.jobId,
-                    model: merged.model,
-                    provider: merged.provider,
-                    maxTokens: merged.maxTokens,
-                    source: 'flex-md'
-                });
-            }
-            else {
-                // flex-md doesn't have model info or returned invalid value - use fallback
-                merged.maxTokens = 2000;
-                logger.debug('Using fallback maxTokens (flex-md unavailable or no model info)', {
-                    jobId: request.identity.jobId,
-                    model: merged.model,
-                    provider: merged.provider,
-                    maxTokens: merged.maxTokens,
-                    note: 'Set maxTokens explicitly in config for custom values.'
-                });
-            }
-        }
-        catch (error) {
-            // Error loading flex-md or getting model info - use fallback
-            merged.maxTokens = 2000;
-            logger.debug('Using fallback maxTokens (flex-md error)', {
-                jobId: request.identity.jobId,
-                model: merged.model,
-                provider: merged.provider,
-                maxTokens: merged.maxTokens,
-                error: error instanceof Error ? error.message : String(error),
-                note: 'Set maxTokens explicitly in config for custom values.'
-            });
-        }
-    }
-    else if (!merged.maxTokens && !optimixerWillPredict) {
-        // If maxTokens wasn't set and wasn't auto-detected, use fallback
-        // This should rarely happen, but handle edge cases
-        merged.maxTokens = 2000;
-        logger.debug('Using fallback maxTokens (not auto-detected and not explicitly set)', {
-            jobId: request.identity.jobId,
-            model: merged.model,
-            provider: merged.provider,
-            maxTokens: merged.maxTokens,
-            maxTokensExplicitlySet,
-            optimixerWillPredict
-        });
-    }
-    else if (optimixerWillPredict) {
-        logger.debug('Deferring maxTokens to Optimixer predictAiMaxTokens', {
-            jobId: request.identity.jobId,
-            model: merged.model,
-            provider: merged.provider
-        });
-    }
-    else {
-        // maxTokens was explicitly set - log which source
-        const source = request.config?.maxTokens !== undefined ? 'request.config' :
-            internalDefaults?.maxTokens !== undefined ? `internalSystemActions.${useInternalDefaults}` :
-                'gateway.config';
-        logger.debug('Using explicitly set maxTokens', {
-            jobId: request.identity.jobId,
-            model: merged.model,
-            provider: merged.provider,
-            maxTokens: merged.maxTokens,
-            source
-        });
-    }
+        throw new ModelRequiredError();
+    }
+    if (typeof merged.maxTokens !== 'number' || !Number.isFinite(merged.maxTokens) || merged.maxTokens <= 0) {
+        throw new MaxTokensRequiredError();
+    }
+    const maxTokensSource = request.config?.maxTokens !== undefined
+        ? 'request.config'
+        : request.modelConfig?.maxTokens !== undefined
+            ? 'modelConfig'
+            : internalDefaults?.maxTokens !== undefined
+                ? `internalSystemActions.${useInternalDefaults}`
+                : config.maxTokens !== undefined
+                    ? 'gateway.config'
+                    : 'unknown';
+    logger.debug('Using maxTokens', {
+        jobId: request.identity.jobId,
+        model: merged.model,
+        provider: merged.provider,
+        maxTokens: merged.maxTokens,
+        source: maxTokensSource
+    });
     logger.debug('Config merged', {
         jobId: request.identity.jobId,
         finalModel: merged.model,
@@ -1014,12 +867,7 @@ export function buildInvokeRejectionMetadata(args) {
 export function attachGatewayInvokeRejectionMetadata(err, metadata) {
     err.metadata = metadata;
 }
-/** Default JSON string length cap for Activix `content.fullResponse` when diagnostics allow storing it. */
-export const DEFAULT_ACTIVITY_FULL_RESPONSE_MAX_CHARS = 512_000;
-/**
- * Size-cap a provider/router payload before storing on an activity record.
- * Non-serializable values become a small marker object instead of throwing.
- */
+export { DEFAULT_ACTIVITY_FULL_RESPONSE_MAX_CHARS } from './gateway-defaults.js';
 export function capActivityFullResponsePayload(payload, maxChars = DEFAULT_ACTIVITY_FULL_RESPONSE_MAX_CHARS) {
     if (payload == null)
         return payload;
@@ -1055,13 +903,3 @@ export function resolveFinishReasonFromRouterResponse(response) {
     }
     return undefined;
 }
-export function buildOptimixerActualUsage(tokens, response, latencyMs) {
-    const finishReason = resolveFinishReasonFromRouterResponse(response);
-    return {
-        promptTokens: tokens.prompt,
-        completionTokens: tokens.completion,
-        totalTokens: tokens.total,
-        ...(finishReason ? { finishReason } : {}),
-        latencyMs
-    };
-}

package/dist/gateway.d.ts

@@ -15,9 +15,7 @@ export declare class AIGateway {
     private config;
     private logger;
     private activityManager?;
-    private optimixerManager?;
     private messageBuilderConfig?;
-    private defaultModelConfig;
     private _autoRegisterDone;
     private _aiToolsClient;
     private readonly preferOpenRouter;
@@ -31,7 +29,6 @@ export declare class AIGateway {
      * Invoke AI request (with structured output support)
      */
     invoke<TContent = unknown>(request: AIInvokeRequest): Promise<EnhancedLLMResponse<TContent>>;
-    private applyAdaptiveMaxTokensIfEnabled;
     /**
      * Build simple messages from request (instructions and prompt as literal template text; no registry).
      */