@x12i/ai-gateway 9.7.9 → 10.0.0

package/dist-cjs/gateway-retry.cjs

@@ -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-cjs/gateway-utils.cjs

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

@@ -7,10 +7,11 @@ import { FallbackExhaustedError } from '@x12i/ai-providers-router';
 import { validateChatRequest, validateAIRequest } from './gateway-validation.js';
 import { ensureGatewayRequestIdentity } from './activity-manager.js';
 import { initializeGatewayComponents } from './gateway-config.js';
+import { resolveRetryConfig } from './gateway-defaults.js';
 import { buildMessages } from './message-builder.js';
-import { extractJsonFromFlexMd, getModelMaxTokensFromFlexMd } from './flex-md-loader.js';
+import { extractJsonFromFlexMd } from './flex-md-loader.js';
 import { enrichParsedContentForOutputContract, resolveOutputContractFieldKeys } from './output-contract-normalizer.js';
-import { attachGatewayInvokeRejectionMetadata, buildGatewayFallbackAttemptsFromTrace, buildInvokeRejectionMetadata, capActivityFullResponsePayload, formatFallbackExhaustionMessage, logResolvedModelRouting, mapGatewayFallbackAttemptsToRouter, hasNonZeroTokenUsage, DEFAULT_ACTIVITY_FULL_RESPONSE_MAX_CHARS, extractCostUsdFromRouterResponse, extractTokenUsageFromRouterResponse, mergeConfig, pickEffectiveModelConfigForMetadata, pickInvokeRoutingMetadataSlice, pickTraceMergedRouterConfig, resolveCostCompletionWithAiTools, buildOptimixerActualUsage, buildTraceUsageSummary, enrichTraceAttemptsWithBilling, isMaxTokensExplicitlySet, tryExtractRouterLikePayloadFromErrorChain } from './gateway-utils.js';
+import { attachGatewayInvokeRejectionMetadata, buildGatewayFallbackAttemptsFromTrace, buildInvokeRejectionMetadata, capActivityFullResponsePayload, formatFallbackExhaustionMessage, logResolvedModelRouting, mapGatewayFallbackAttemptsToRouter, hasNonZeroTokenUsage, DEFAULT_ACTIVITY_FULL_RESPONSE_MAX_CHARS, extractCostUsdFromRouterResponse, extractTokenUsageFromRouterResponse, mergeConfig, pickEffectiveModelConfigForMetadata, pickInvokeRoutingMetadataSlice, pickTraceMergedRouterConfig, resolveCostCompletionWithAiTools, buildTraceUsageSummary, enrichTraceAttemptsWithBilling, tryExtractRouterLikePayloadFromErrorChain } from './gateway-utils.js';
 import { getAiToolsClient } from './ai-tools-client.js';
 import { autoRegisterProviders } from './gateway-provider-auto-register.js';
 import { applyOpenRouterInvokePolicy } from './ai-tools-client.js';
@@ -56,9 +57,7 @@ export class AIGateway {
     config;
     logger;
     activityManager;
-    optimixerManager;
     messageBuilderConfig;
-    defaultModelConfig = {};
     _autoRegisterDone = false;
     _aiToolsClient = null;
     preferOpenRouter;
@@ -70,9 +69,7 @@ export class AIGateway {
         this.logger = components.logger;
         this.router = components.router;
         this.activityManager = components.activityManager;
-        this.optimixerManager = components.optimixerManager;
         this.messageBuilderConfig = components.messageBuilderConfig;
-        this.defaultModelConfig = components.defaultModelConfig ?? {};
         this.preferOpenRouter = components.preferOpenRouter;
         this.openRouterApiKey = components.openRouterApiKey;
         setGatewayRuntimeClients({
@@ -101,7 +98,6 @@ export class AIGateway {
             // Merge config (modelConfig > request.config > gateway defaults)
             const aiTools = await this.getAiTools();
             const mergedConfig = await mergeConfig(request, this.config, this.logger, {
-                defaultModelConfig: this.defaultModelConfig,
                 catalog: aiTools?.catalog ?? null,
                 routingEnv: aiTools?.routingEnv,
             });
@@ -118,7 +114,6 @@ export class AIGateway {
                 await autoRegisterProviders(this.router, this.logger);
                 this._autoRegisterDone = true;
             }
-            const optimixerPrediction = await this.applyAdaptiveMaxTokensIfEnabled(request, mergedConfig, messages);
             // Start activity tracking if available
             let activity = undefined;
             if (this.activityManager) {
@@ -192,9 +187,6 @@ export class AIGateway {
                         });
                     }
                 }
-                if (optimixerPrediction) {
-                    await this.optimixerManager?.completePrediction(optimixerPrediction.requestId, buildOptimixerActualUsage(tokensChat, response, Date.now() - startTime));
-                }
                 warnIfSuccessfulInvokeReportsZeroUsageOrCost(this.logger, request.identity, {
                     tokens: enhancedResponse.metadata.tokens,
                     costUsd: enhancedResponse.metadata.costUsd,
@@ -298,7 +290,6 @@ export class AIGateway {
             // Merge config (modelConfig > request.config > gateway defaults)
             const aiTools = await this.getAiTools();
             const mergedConfig = await mergeConfig(request, this.config, this.logger, {
-                defaultModelConfig: this.defaultModelConfig,
                 catalog: aiTools?.catalog ?? null,
                 routingEnv: aiTools?.routingEnv,
             });
@@ -318,7 +309,6 @@ export class AIGateway {
                 await autoRegisterProviders(this.router, this.logger);
                 this._autoRegisterDone = true;
             }
-            const optimixerPrediction = await this.applyAdaptiveMaxTokensIfEnabled(request, mergedConfig, messages);
             // Start activity tracking if available
             let activity = undefined;
             if (this.activityManager) {
@@ -417,7 +407,7 @@ export class AIGateway {
                                         model: candidate.model
                                     }
                                 }
-                            }, (this.config.retry ?? {}), request.identity.jobId || request.aiRequestId, this.router, this.logger, {
+                            }, resolveRetryConfig(request, this.config), request.identity.jobId || request.aiRequestId, this.router, this.logger, {
                                 onTryStart: ({ retryIndex, startedAt }) => {
                                     const idx = traceAttempts.push({
                                         timing: { startedAt, endedAt: startedAt, durationMs: 0 },
@@ -727,9 +717,6 @@ export class AIGateway {
                         });
                     }
                 }
-                if (optimixerPrediction) {
-                    await this.optimixerManager?.completePrediction(optimixerPrediction.requestId, buildOptimixerActualUsage(tokens, routerResponse, Date.now() - startTime));
-                }
                 warnIfSuccessfulInvokeReportsZeroUsageOrCost(this.logger, request.identity, {
                     tokens: enhancedResponse.metadata.tokens,
                     costUsd: enhancedResponse.metadata.costUsd,
@@ -765,52 +752,6 @@ export class AIGateway {
             }
         });
     }
-    async applyAdaptiveMaxTokensIfEnabled(request, mergedConfig, messages) {
-        if (!this.optimixerManager?.isEnabled() || isMaxTokensExplicitlySet(request, this.config)) {
-            return undefined;
-        }
-        const prediction = await this.optimixerManager.predictMaxTokens({
-            request,
-            mergedConfig,
-            messages
-        });
-        if (prediction) {
-            let maxTokens = prediction.recommendedMaxTokens;
-            const useCeiling = this.config.optimixer?.useFlexMdCeiling !== false;
-            if (useCeiling && mergedConfig?.model && mergedConfig?.provider) {
-                try {
-                    const ceiling = await getModelMaxTokensFromFlexMd(mergedConfig.provider, mergedConfig.model);
-                    if (typeof ceiling === 'number' && ceiling > 0 && maxTokens > ceiling) {
-                        maxTokens = ceiling;
-                    }
-                }
-                catch {
-                    // Non-blocking: use uncapped prediction
-                }
-            }
-            mergedConfig.maxTokens = maxTokens;
-            request._mergedRouterConfig = mergedConfig;
-            this.logger.debug('Applied Optimixer recommended max_tokens', {
-                aiRequestId: request.aiRequestId,
-                recommendedMaxTokens: prediction.recommendedMaxTokens,
-                maxTokens,
-                confidence: prediction.confidence,
-                requestId: prediction.requestId
-            });
-            return prediction;
-        }
-        if (mergedConfig?.maxTokens === undefined && mergedConfig?.model && mergedConfig?.provider) {
-            try {
-                const flexMdMaxTokens = await getModelMaxTokensFromFlexMd(mergedConfig.provider, mergedConfig.model);
-                mergedConfig.maxTokens = flexMdMaxTokens && flexMdMaxTokens > 0 ? flexMdMaxTokens : 2000;
-            }
-            catch {
-                mergedConfig.maxTokens = 2000;
-            }
-            request._mergedRouterConfig = mergedConfig;
-        }
-        return undefined;
-    }
     /**
      * Build simple messages from request (instructions and prompt as literal template text; no registry).
      */

package/dist-cjs/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).
      */

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 } from './instruction-errors.js';
+export { InstructionNotFoundError, InstructionBackendError, ModelRequiredError, MaxTokensRequiredError } from './instruction-errors.js';
 export { autoRegisterProviders } from './gateway-provider-auto-register.js';
 export { attachGatewayInvokeRejectionMetadata, buildInvokeRejectionMetadata, tryExtractRouterLikePayloadFromErrorChain, tryExtractFallbackAttemptsFromErrorChain, pickRequestIdsFromRouterLike, resolveActivityCostCompletion, resolveCostCompletionForActivity, resolveCostCompletionWithAiTools, buildGatewayPricingRecord, mapAiCostResultToResolvedActivityCost, buildTraceUsageSummary, enrichTraceAttemptsWithBilling, hasNonZeroTokenUsage, MODEL_PROFILE_UNROUTABLE, ModelProfileUnroutableError, buildGatewayFallbackAttemptsFromTrace, formatFallbackExhaustionMessage, logResolvedModelRouting, mapGatewayFallbackAttemptsToRouter } from './gateway-utils.js';
-export { getGatewayOperationalMode, isProdGatewayMode, resolveGatewayDefaultModel, parseModelProviderSpec, CODE_DEFAULT_MODEL } from './gateway-mode.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';
 export { mergeGatewayAndRequestTemplateRenderOptions, mergeTemplateRenderOptions } from './template-render-merge.js';
 export { GATEWAY_DUAL_MEMORY_ROOTS, buildMemoryResolutionRootFromWorkingMemory, coalesceMergedInputBucket, extractCallerInputsBag, mapSmartInputPathsInputsToInput, parseLooseJsonObject, prepareWorkingMemoryForTemplateRender, resolveGatewayMemoryPathValue } from './memory-path-resolution.js';
@@ -28,7 +29,6 @@ export { GATEWAY_DUAL_MEMORY_ROOTS, buildMemoryResolutionRootFromWorkingMemory,
 export { Activix } from '@x12i/activix';
 export { normalizeToActivixCostShape } from '@x12i/activix';
 export { ActivityManager, ensureGatewayRequestIdentity } from './activity-manager.js';
-export { OptimixerManager } from './optimixer-manager.js';
 export { activityIdentityToLogContext, activityIdentityToLogMeta, withActivityIdentity, withGatewayLogContext, gatewayLogDebug } from './gateway-log-meta.js';
 export { createGatewayLogger, resolveGatewayVerboseEnabled } from './logger-factory.js';
 export { GATEWAY_LOG_ENV_PREFIX, GATEWAY_LOGXER_PACKAGE, GATEWAY_STACK_LOG_PREFIXES, initializeGatewayPackageLogLevels, resetGatewayPackageLogLevelsInit } from './gateway-log-levels.js';
@@ -38,10 +38,7 @@ export { createLogxer, DebugLogAbstract, runWithLogContext, getStationRuntimeIde
 export { ROUTER_LOG_ENV_PREFIX } from '@x12i/ai-providers-router';
 // Runtime observability surface (leaf package: no downstream runtime objects)
 export { runtimeObjects } from './runtime-objects.js';
-// Export rate limiter
-export { GatewayRateLimiter } from './gateway-rate-limiter.js';
-export { DEFAULT_RATE_LIMIT_MIN_INTERVAL_MS, DEFAULT_RATE_LIMIT_ENABLED } from './gateway-rate-limiter-constants.js';
-// Export troubleshooting helpers
+// Runtime observability surface (leaf package: no downstream runtime objects)
 export { validateAIRequest, validateJSON, extractJSON, validateResponse, diagnoseRequest, diagnoseResponse, supportsJSONMode, createTestAIRequest, createValidationTestCases, runValidationTests, formatDiagnostic, assertValidAIRequest } from './troubleshooting-helper.js';
 // Export object types library
 export { OBJECT_TYPES_LIBRARY, getObjectType, getObjectTypesForAgent } from './object-types-library.js';

package/dist-cjs/index.d.ts

@@ -14,12 +14,13 @@ 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 } from './instruction-errors.js';
+export { InstructionNotFoundError, InstructionBackendError, ModelRequiredError, MaxTokensRequiredError } from './instruction-errors.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, buildTraceUsageSummary, enrichTraceAttemptsWithBilling, hasNonZeroTokenUsage, MODEL_PROFILE_UNROUTABLE, ModelProfileUnroutableError, buildGatewayFallbackAttemptsFromTrace, formatFallbackExhaustionMessage, logResolvedModelRouting, mapGatewayFallbackAttemptsToRouter } from './gateway-utils.js';
-export { getGatewayOperationalMode, isProdGatewayMode, resolveGatewayDefaultModel, parseModelProviderSpec, CODE_DEFAULT_MODEL } from './gateway-mode.js';
-export type { GatewayOperationalMode, GatewayDefaultModelSource, DefaultModelSubstitutionReason, ResolvedGatewayDefault } from './gateway-mode.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';
 export type { ActivityCostStatus, ResolvedActivityCost } from './gateway-utils.js';
 export { contractSpecToFieldKeys, enrichParsedContentForOutputContract, resolveOutputContractFieldKeys } from './output-contract-normalizer.js';
 export type { OutputContractSpec } from './output-contract-normalizer.js';
@@ -32,7 +33,6 @@ export { Activix } from '@x12i/activix';
 export type { ActivixRunContext, ActivixAutoCostOptions, ActivixCostShape, FindByRunContextCriteria, GetJobActivitiesInput, GetJobActivitiesResult } from '@x12i/activix';
 export { normalizeToActivixCostShape } from '@x12i/activix';
 export { ActivityManager, ensureGatewayRequestIdentity } from './activity-manager.js';
-export { OptimixerManager } from './optimixer-manager.js';
 export type { ActivityIdentity } from './types.js';
 export { activityIdentityToLogContext, activityIdentityToLogMeta, withActivityIdentity, withGatewayLogContext, gatewayLogDebug } from './gateway-log-meta.js';
 export { createGatewayLogger, resolveGatewayVerboseEnabled } from './logger-factory.js';
@@ -45,8 +45,6 @@ export { ROUTER_LOG_ENV_PREFIX } from '@x12i/ai-providers-router';
 export type { Logxer, LogMeta, RuntimeIdentity, LogRuntimeContext, GetJobLogsInput, GetJobLogsResult, QueryableLogLine, LogDiagnostics, DiagnosticEvidence, ScopeCriteria, ScopeLogsResult, StackLoggingOptions, PackageLogLevelsConfig, PackageLogLevelSetting } from '@x12i/logxer';
 export { runtimeObjects } from './runtime-objects.js';
 export type { ActivixQueryableClient, LogxerQueryableClient, PackageRuntimeObjects, RuntimeObjects } from './runtime-objects.js';
-export { GatewayRateLimiter } from './gateway-rate-limiter.js';
-export { DEFAULT_RATE_LIMIT_MIN_INTERVAL_MS, DEFAULT_RATE_LIMIT_ENABLED } from './gateway-rate-limiter-constants.js';
 export { validateAIRequest, validateJSON, extractJSON, validateResponse, diagnoseRequest, diagnoseResponse, supportsJSONMode, createTestAIRequest, createValidationTestCases, runValidationTests, formatDiagnostic, assertValidAIRequest } from './troubleshooting-helper.js';
 export type { ValidationResult, DiagnosticInfo } from './troubleshooting-helper.js';
 export { OBJECT_TYPES_LIBRARY, getObjectType, getObjectTypesForAgent } from './object-types-library.js';

package/dist-cjs/instruction-errors.cjs

@@ -1,6 +1,20 @@
 /**
- * Errors for instruction / prompt template and instructions-block resolution.
+ * Errors for instruction / prompt template resolution.
  */
+export class ModelRequiredError extends Error {
+    code = 'MODEL_REQUIRED';
+    constructor(message = 'model is required on every invoke request (request.config.model or request.modelConfig.model)') {
+        super(message);
+        this.name = 'ModelRequiredError';
+    }
+}
+export class MaxTokensRequiredError extends Error {
+    code = 'MAX_TOKENS_REQUIRED';
+    constructor(message = 'maxTokens is required on every invoke request (request.config.maxTokens, request.modelConfig.maxTokens, GatewayConfig.maxTokens, or internalSystemActions)') {
+        super(message);
+        this.name = 'MaxTokensRequiredError';
+    }
+}
 export class InstructionNotFoundError extends Error {
     key;
     backend;

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

@@ -1,6 +1,14 @@
 /**
- * Errors for instruction / prompt template and instructions-block resolution.
+ * Errors for instruction / prompt template resolution.
  */
+export declare class ModelRequiredError extends Error {
+    readonly code = "MODEL_REQUIRED";
+    constructor(message?: string);
+}
+export declare class MaxTokensRequiredError extends Error {
+    readonly code = "MAX_TOKENS_REQUIRED";
+    constructor(message?: string);
+}
 export declare class InstructionNotFoundError extends Error {
     key: string;
     backend: string;