@x12i/ai-gateway 9.7.9 → 10.0.1

package/dist/gateway.js

@@ -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/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/index.js

@@ -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/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;

package/dist/instruction-errors.js

@@ -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/instruction-optimizer.js

@@ -4,6 +4,7 @@
  * Uses AI to analyze and fix poorly-written instructions.
  * This is a meta-feature that uses the AI Gateway (via router) to improve AI instructions.
  */
+import { MaxTokensRequiredError } from './instruction-errors.js';
 /**
  * The meta-instructions used to fix other instructions
  * Loaded from instructions-audit.md
@@ -128,6 +129,9 @@ export async function optimizeInstructions(gateway, originalInstructions, option
     if (enforceJsonOutput) {
         additionalContext += '\n\nIMPORTANT: The fixed instructions MUST include strict JSON-only output enforcement rules.';
     }
+    if (typeof internalConfig?.maxTokens !== 'number' || internalConfig.maxTokens <= 0) {
+        throw new MaxTokensRequiredError('maxTokens must be set in internalSystemActions.instructionOptimization for optimizeInstructions');
+    }
     const aiRequestId = `optimize-instructions-${Date.now()}`;
     const identity = {
         ...options.identity,
@@ -149,7 +153,7 @@ export async function optimizeInstructions(gateway, originalInstructions, option
             model,
             provider,
             temperature: internalConfig?.temperature ?? 0.3, // Use internal config or default
-            maxTokens: internalConfig?.maxTokens ?? 4000 // Use internal config or default
+            maxTokens: internalConfig?.maxTokens
         },
         // Use JSON output type to ensure we get structured response
         primaryObjectType: {

package/dist/message-builder.d.ts

@@ -8,17 +8,11 @@ import type { TemplateRenderOptions } from '@x12i/rendrix';
 import type { Logxer } from '@x12i/logxer';
 type Request = ChatRequest | AIRequest;
 export interface MessageBuilderConfig {
-    defaultInstructionsBlocks: Record<string, any>;
-    /** Flat block overrides from gateway `instructionsBlocks` (merged at init). */
-    instructionsBlockOverrides: Record<string, string>;
     logger: Logxer;
     /** From packaged defaults + gateway `templateRendering`; merged per request with `templateRenderOptions`. */
     templateRendering?: TemplateRenderOptions;
 }
 export interface BuildMessagesOptions {
-    useSystemContextFallback?: boolean;
-    includeInputRecognition?: boolean;
-    includeReinforcement?: boolean;
     parsedSnapshot?: any;
     shortTermMemory?: Record<string, any>;
     experienceMemory?: Record<string, any>;

package/dist/message-builder.js

@@ -5,137 +5,12 @@
  */
 import { parseTemplate } from './template-parser.js';
 import { mergeGatewayAndRequestTemplateRenderOptions } from './template-render-merge.js';
-import { resolveNestedInstructionsBlock } from './gateway-instructions.js';
 // Type guard
 // AIRequest is distinguished by having primaryObjectType or objectTypes
 // ChatRequest does not have these fields
 function isAIRequest(request) {
     return 'primaryObjectType' in request || ('objectTypes' in request && Array.isArray(request.objectTypes));
 }
-/**
- * Builds input recognition rules
- */
-async function buildInputRecognitionRules(request, config, options) {
-    const { defaultInstructionsBlocks, instructionsBlockOverrides, logger } = config;
-    if (!options.includeInputRecognition || !isAIRequest(request)) {
-        return '';
-    }
-    const rules = [];
-    // Add input recognition rules
-    // Try direct access first (faster, more reliable), then fallback to resolver
-    const rulePaths = [
-        'input.inputRecognitionRule',
-        'input.emptyInputHandling',
-        'input.testInputHandling',
-        'input.inputLocationClarifier'
-    ];
-    const requestInstructionsBlocks = isAIRequest(request) && request.config?.instructionsBlocks
-        ? request.config.instructionsBlocks
-        : undefined;
-    const blockContext = {
-        defaultInstructionsBlocks,
-        instructionsBlockOverrides,
-        requestInstructionsBlocks,
-        config: {},
-        logger
-    };
-    for (const rulePath of rulePaths) {
-        try {
-            // Try direct access to nested structure first
-            const pathParts = rulePath.split('.');
-            let rule;
-            if (pathParts.length === 2) {
-                const [parent, child] = pathParts;
-                const parentObj = defaultInstructionsBlocks[parent];
-                if (parentObj && typeof parentObj === 'object' && !Array.isArray(parentObj)) {
-                    rule = parentObj[child];
-                    if (rule && typeof rule === 'string') {
-                        logger.debug('Resolved rule via direct access', {
-                            rulePath,
-                            valueLength: rule.length
-                        });
-                    }
-                }
-            }
-            // If direct access didn't work, try merged inline overrides / nested defaults
-            if (!rule) {
-                rule = await resolveNestedInstructionsBlock(rulePath, request.agentId || '', request.taskTypeId, blockContext);
-            }
-            if (rule && typeof rule === 'string' && rule.trim() !== '') {
-                rules.push(rule);
-            }
-        }
-        catch (error) {
-            logger.debug('Failed to resolve input rule', {
-                rulePath,
-                error: error instanceof Error ? error.message : String(error)
-            });
-        }
-    }
-    return rules.join('\n\n');
-}
-/**
- * Builds reinforcement rules
- */
-async function buildReinforcementRules(request, config, options) {
-    const { defaultInstructionsBlocks, instructionsBlockOverrides, logger } = config;
-    if (!options.includeReinforcement || !isAIRequest(request)) {
-        return '';
-    }
-    const rules = [];
-    // Add reinforcement rules
-    // Try direct access first (faster, more reliable), then fallback to resolver
-    const rulePaths = [
-        'reinforcement.emptyIsSuccess',
-        'reinforcement.inputAlreadyProvided',
-        'reinforcement.noConversation',
-        'reinforcement.failureIndicators'
-    ];
-    const requestInstructionsBlocks = isAIRequest(request) && request.config?.instructionsBlocks
-        ? request.config.instructionsBlocks
-        : undefined;
-    const blockContext = {
-        defaultInstructionsBlocks,
-        instructionsBlockOverrides,
-        requestInstructionsBlocks,
-        config: {},
-        logger
-    };
-    for (const rulePath of rulePaths) {
-        try {
-            // Try direct access to nested structure first
-            const pathParts = rulePath.split('.');
-            let rule;
-            if (pathParts.length === 2) {
-                const [parent, child] = pathParts;
-                const parentObj = defaultInstructionsBlocks[parent];
-                if (parentObj && typeof parentObj === 'object' && !Array.isArray(parentObj)) {
-                    rule = parentObj[child];
-                    if (rule && typeof rule === 'string') {
-                        logger.debug('Resolved rule via direct access', {
-                            rulePath,
-                            valueLength: rule.length
-                        });
-                    }
-                }
-            }
-            // If direct access didn't work, try merged inline overrides / nested defaults
-            if (!rule) {
-                rule = await resolveNestedInstructionsBlock(rulePath, request.agentId || '', request.taskTypeId, blockContext);
-            }
-            if (rule && typeof rule === 'string' && rule.trim() !== '') {
-                rules.push(rule);
-            }
-        }
-        catch (error) {
-            logger.debug('Failed to resolve reinforcement rule', {
-                rulePath,
-                error: error instanceof Error ? error.message : String(error)
-            });
-        }
-    }
-    return rules.join('\n\n');
-}
 /**
  * Builds user message (prompt + input)
  */
@@ -369,10 +244,9 @@ async function hasFlexMdContract(instructionsText, complianceLevel = 'L0') {
  * Main function to build messages
  */
 export async function buildMessages(request, config, options = {}) {
-    const { useSystemContextFallback = true, includeInputRecognition = true, includeReinforcement = true, parsedSnapshot } = options;
+    const { parsedSnapshot } = options;
     const { logger } = config;
     const messages = [];
-    let usingSystemContext = false;
     // Step 1: Instructions as template text (parsed with full memory context)
     let instructionsText = '';
     // Extract memory context from options
@@ -403,27 +277,14 @@ export async function buildMessages(request, config, options = {}) {
         instructionsText = await parseTemplate(instructionsText, request.workingMemory, undefined, // taskConfig removed - no longer used
         shortTermMemory, experienceMemory, knowledgeMemory, templateRenderOptions, logger);
     }
-    // Step 4: Add input recognition rules
-    const inputRules = await buildInputRecognitionRules(request, config, options);
-    if (inputRules) {
-        instructionsText = `${instructionsText}\n\n${inputRules}`;
-    }
-    // Step 5: Add reinforcement rules
-    const reinforcementRules = await buildReinforcementRules(request, config, options);
-    if (reinforcementRules) {
-        instructionsText = `${instructionsText}\n\n${reinforcementRules}`;
-    }
-    // Step 6: Add system message
-    // CRITICAL: We must have instructions - this is a bad request if we don't
+    // Instructions must be provided explicitly — no packaged block injection
     if (!instructionsText || instructionsText.trim() === '') {
         const errorMessage = 'No instructions available - cannot proceed without clear instructions. This is a bad request.';
         logger.error(errorMessage, {
             jobId: request.identity.jobId,
             agentId: request.agentId,
             hasRequestInstructions: !!request.instructions,
-            instructionType: typeof request.instructions,
-            usedSystemContextFallback: usingSystemContext,
-            systemContextFallbackEnabled: useSystemContextFallback
+            instructionType: typeof request.instructions
         });
         throw new Error(errorMessage);
     }
@@ -515,8 +376,6 @@ export async function buildMessages(request, config, options = {}) {
     });
     return {
         messages,
-        metadata: {
-            usingSystemContext
-        }
+        metadata: {}
     };
 }

package/dist/types.d.ts

@@ -398,9 +398,10 @@ export interface GatewayConfig extends Omit<RouterConfig, 'defaultEngine' | 'log
         prefer?: boolean;
     };
     /**
-     * Operational mode override (`process.env.mode` / `MODE` when omitted).
-     * - `prod`: unresolved models fall back to {@link AI_GATEWAY_DEFAULT_MODEL} / packaged default (with Logxer warn).
-     * - `dev` / `debug`: unresolved models throw {@link ModelResolutionError} from `@x12i/ai-tools`.
+     * Operational mode override (`process.env.mode` / `MODE` when omitted; default `debug`).
+     * Downstream hosts (ai-skills, ai-tasks, graph-engine) should expose this to their clients.
+     * - `dev` / `debug`: unresolved profile/model names throw {@link ModelResolutionError} from `@x12i/ai-tools` when catalog resolution is enabled.
+     * - `prod`: same strict resolution — every invoke must include an explicit `model`; the gateway never substitutes a packaged or env default.
      */
     mode?: 'dev' | 'debug' | 'prod';
     /**
@@ -421,70 +422,24 @@ export interface GatewayConfig extends Omit<RouterConfig, 'defaultEngine' | 'log
         costIncludeBreakdown?: boolean;
     };
     /**
-     * Adaptive `max_tokens` via @x12i/optimixer (embedded Activix mode).
-     * When enabled, the gateway predicts completion budget before each LLM call unless
-     * the caller explicitly sets `maxTokens` on the request / modelConfig / gateway config.
-     */
-    optimixer?: {
-        /** @default false */
-        enabled?: boolean;
-        acceptableRisk?: 'very-low' | 'low' | 'medium' | 'high' | number;
-        /** Cap predicted max tokens with flex-md model limit when available. @default true */
-        useFlexMdCeiling?: boolean;
-        /** Passed to Optimixer warmup on create. */
-        warmupLimit?: number;
-    };
-    /**
-     * InstructionsBlocks overrides
-     * Key: block name, Value: block content
-     */
-    instructionsBlocks?: Record<string, string>;
-    /**
-     * Default temperature for LLM requests
+     * Default temperature for LLM requests when not set on the invoke request.
+     * @default 0.7 — see {@link GATEWAY_DEFAULT_TEMPERATURE} in `@x12i/ai-gateway`.
      */
     temperature?: number;
     /**
-     * Other LLM config options
+     * Gateway-wide completion budget. Merged when the invoke does not set `maxTokens` on
+     * `request.config` / `modelConfig` (lower priority than per-request values).
+     * Every invoke must end up with a positive `maxTokens` after merge — no code default.
      */
     maxTokens?: number;
     topP?: number;
     frequencyPenalty?: number;
     presencePenalty?: number;
     /**
-     * Retry configuration for network and server errors
+     * Retry configuration for network and server errors on provider invoke.
+     * Defaults: {@link GATEWAY_DEFAULT_RETRY}. Override per request via `request.retry` or `request.config.retry`.
      */
     retry?: RetryConfig;
-    /**
-     * Rate limiting configuration
-     * Smart rate limiting that tracks when the last API call was made
-     * and only waits if necessary to maintain minimum intervals between calls.
-     * Applied automatically to all provider calls via router interceptors.
-     */
-    rateLimit?: {
-        /**
-         * Enable rate limiting
-         * @default true
-         */
-        enabled?: boolean;
-        /**
-         * Default minimum interval in milliseconds between API calls (used if provider-specific not set)
-         * @default 500
-         */
-        defaultMinIntervalMs?: number;
-        /**
-         * Per-provider minimum intervals in milliseconds
-         * Key: provider name (e.g., 'openai', 'grok')
-         * Value: minimum milliseconds between calls for that provider
-         *
-         * @example
-         * {
-         *   openai: 500,  // 500ms between OpenAI calls
-         *   grok: 1000,   // 1 second between Grok calls
-         *   anthropic: 300  // 300ms between Anthropic calls
-         * }
-         */
-        providerIntervals?: Record<string, number>;
-    };
     /**
      * Default task configuration for template rendering
      * @deprecated taskConfig is no longer used by Rendrix 3.0.0+
@@ -744,6 +699,10 @@ interface BaseLLMRequest extends Omit<LLMRequest, 'messages' | 'input' | 'reques
      * Merged the same way as `smartInput`; `templateRenderOptions.smartInputRenderOptions` wins when both are set.
      */
     smartInputRenderOptions?: SmartInputRenderOptions;
+    /**
+     * Per-request retry overrides (merged over gateway `retry` and {@link GATEWAY_DEFAULT_RETRY}).
+     */
+    retry?: RetryConfig;
     /**
      * Messages array - Optional, can be used instead of instructions/prompt
      * If provided, will be appended as-is after built messages; instructions template text is still parsed for the system message when present
@@ -1089,7 +1048,7 @@ export interface EnhancedLLMResponse<TContent = unknown> extends Omit<AIResponse
         usage?: GatewayTraceUsageSummary;
         /**
          * Merged gateway/router generation config actually used for the invocation (after
-         * {@link mergeConfig}: modelConfig / request.config / defaults / flex-md maxTokens).
+         * {@link mergeConfig}: modelConfig / request.config / gateway maxTokens).
          * Only populated when diagnostics trace mode is enabled.
          */
         mergedRouterConfig?: GatewayTraceMergedConfig;