@x12i/ai-gateway 9.7.9 → 10.0.1

package/dist-cjs/defaults/log-diagnostics.json

@@ -70,23 +70,6 @@
     "userActionRequired": false,
     "confidence": "medium"
   },
-  "GATEWAY_DEFAULT_MODEL_SUBSTITUTED": {
-    "defaultLevel": "warn",
-    "title": "Gateway substituted the configured default model",
-    "impact": "The request may run on a different provider/model than the caller specified.",
-    "possibleCauses": [
-      "Request omitted model while gateway defaults apply.",
-      "Operational mode requires a packaged default engine.",
-      "Profile resolution fell back to gateway defaults."
-    ],
-    "remediation": [
-      "Pass an explicit model on the request when substitution is undesired.",
-      "Review default model configuration and AI_TOOLS routing."
-    ],
-    "retryable": false,
-    "userActionRequired": false,
-    "confidence": "high"
-  },
   "GATEWAY_RETRY_MAX_EXCEEDED": {
     "defaultLevel": "warn",
     "title": "Provider invoke retries exhausted",
@@ -121,56 +104,5 @@
     "retryable": true,
     "userActionRequired": false,
     "confidence": "medium"
-  },
-  "GATEWAY_OPTIMIXER_ACTIVIX_UNAVAILABLE": {
-    "defaultLevel": "warn",
-    "title": "Optimixer enabled but Activix is unavailable",
-    "impact": "Adaptive max_tokens prediction is disabled for this gateway instance.",
-    "possibleCauses": [
-      "Activity tracking is disabled or Activix failed to initialize.",
-      "Mongo connection or collection configuration is missing."
-    ],
-    "remediation": [
-      "Enable activity tracking with a working Activix connection.",
-      "Verify activixCollection configuration."
-    ],
-    "retryable": false,
-    "userActionRequired": true,
-    "confidence": "high"
-  },
-  "GATEWAY_OPTIMIXER_INIT_FAILED": {
-    "defaultLevel": "warn",
-    "title": "Optimixer initialization failed",
-    "impact": "Adaptive max_tokens prediction is disabled.",
-    "possibleCauses": [
-      "Activix schema or collection mismatch.",
-      "Optimixer configuration error.",
-      "Dependency or network failure during create()."
-    ],
-    "remediation": [
-      "Check Activix connectivity and collection names.",
-      "Review optimixer gateway config."
-    ],
-    "retryable": false,
-    "userActionRequired": true,
-    "confidence": "high"
-  },
-  "GATEWAY_OPTIMIXER_PREDICT_FAILED": {
-    "defaultLevel": "warn",
-    "title": "Optimixer predictAiMaxTokens failed",
-    "impact": "Caller should use fallback max_tokens for the invoke.",
-    "possibleCauses": [
-      "Insufficient historical samples for the template.",
-      "Token estimation or profile resolution failed.",
-      "Optimixer internal error."
-    ],
-    "remediation": [
-      "Set explicit max_tokens on the request.",
-      "Verify templateId and model profile fields.",
-      "Check prediction history in Activix."
-    ],
-    "retryable": true,
-    "userActionRequired": false,
-    "confidence": "medium"
   }
 }

package/dist-cjs/gateway-config.cjs

@@ -6,6 +6,11 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { fileURLToPath } from 'url';
 import { resolveOpenRouterApiKey, resolvePreferOpenRouter, } from './openrouter-routing.js';
+import { LLMProviderRouter } from '@x12i/ai-providers-router';
+import { createGatewayLogger } from './logger-factory.js';
+import { ActivityManager } from './activity-manager.js';
+import { UsageTracker } from './usage-tracker.js';
+import { mergeTemplateRenderOptions } from './template-render-merge.js';
 /** Resolve current module directory across ESM/CJS builds. */
 function getModuleDir() {
     if (typeof __dirname !== 'undefined') {
@@ -38,29 +43,17 @@ function getDefaultsDir() {
         path.join(cwd, 'src'),
     ];
     for (const dir of candidates) {
-        const modelConfigPath = path.join(dir, 'defaults', 'model-config.json');
-        if (fs.existsSync(modelConfigPath)) {
+        const templateRenderingPath = path.join(dir, 'defaults', 'template-rendering.json');
+        if (fs.existsSync(templateRenderingPath)) {
             return dir;
         }
     }
-    // Keep existing behavior as a last fallback.
     return path.join(cwd, 'dist');
 }
-import { LLMProviderRouter } from '@x12i/ai-providers-router';
-import { createGatewayLogger } from './logger-factory.js';
-import { ActivityManager } from './activity-manager.js';
-import { OptimixerManager } from './optimixer-manager.js';
-import { UsageTracker } from './usage-tracker.js';
-import { mergeTemplateRenderOptions } from './template-render-merge.js';
-import { GatewayRateLimiter } from './gateway-rate-limiter.js';
-import { DEFAULT_RATE_LIMIT_MIN_INTERVAL_MS, DEFAULT_RATE_LIMIT_ENABLED } from './gateway-rate-limiter-constants.js';
 /**
- * Loads configuration from JSON files (model config and instructionsBlocks).
- * Pass a {@link Logxer} instance so load diagnostics go through logxer (not console).
+ * Loads packaged template-rendering defaults for Rendrix merge at init.
  */
 export function loadConfig(logger) {
-    const defaultModelConfig = {};
-    const defaultInstructionsBlocks = {};
     let defaultTemplateRendering;
     try {
         const defaultsDir = getDefaultsDir();
@@ -68,57 +61,21 @@ export function loadConfig(logger) {
         if (fs.existsSync(templateRenderingPath)) {
             const trContent = fs.readFileSync(templateRenderingPath, 'utf-8');
             defaultTemplateRendering = JSON.parse(trContent);
-        }
-        // Load model config (includes rate limiting and retry defaults)
-        const modelConfigPath = path.join(defaultsDir, 'defaults', 'model-config.json');
-        if (fs.existsSync(modelConfigPath)) {
-            const content = fs.readFileSync(modelConfigPath, 'utf-8');
-            const parsed = JSON.parse(content);
-            Object.assign(defaultModelConfig, parsed);
-        }
-        // Load instructionsBlocks
-        const instructionsBlocksPath = path.join(defaultsDir, 'defaults', 'instructions-blocks.json');
-        if (fs.existsSync(instructionsBlocksPath)) {
-            const content = fs.readFileSync(instructionsBlocksPath, 'utf-8');
-            const parsed = JSON.parse(content);
-            // Use Object.assign to merge, preserving nested structure
-            Object.assign(defaultInstructionsBlocks, parsed);
-            logger.debug('Loaded instructions blocks from defaults', {
-                topLevelKeys: Object.keys(defaultInstructionsBlocks),
-                hasOutput: 'output' in defaultInstructionsBlocks,
-                outputKeys: 'output' in defaultInstructionsBlocks ? Object.keys(defaultInstructionsBlocks.output) : []
+            logger.debug('Loaded template rendering defaults', {
+                path: templateRenderingPath,
+                hasSubPathSearch: !!defaultTemplateRendering?.subPathSearch
             });
         }
         else {
-            logger.verbose('Optional instructions blocks file not found; using packaged fallbacks', {
-                instructionsBlocksPath
-            });
+            logger.verbose('Packaged template-rendering defaults not found', { templateRenderingPath });
         }
     }
     catch (error) {
-        logger.warn('Failed to load defaults from JSON files', {
+        logger.warn('Failed to load template-rendering defaults', {
             error: error instanceof Error ? error.message : String(error)
         });
     }
-    // Ensure critical blocks exist even if file loading failed
-    if (!defaultInstructionsBlocks['outputObjectPrefix']) {
-        defaultInstructionsBlocks['outputObjectPrefix'] = "Reply in Markdown. Return your entire answer inside a single ```markdown fenced block and nothing else. The content must conform to the schema provided below. If no items are found, return empty arrays (e.g., emails: []). Never ask for more input. Do not write conversational text. Do not write explanations. Do not ask questions.\n\n";
-    }
-    if (!defaultInstructionsBlocks['outputObjectTypesPrefix']) {
-        defaultInstructionsBlocks['outputObjectTypesPrefix'] = "Reply in Markdown. Return your entire answer inside a single ```markdown fenced block and nothing else. Select ONE of the following object types based on the input. The content must conform to the chosen schema. Do not write conversational text. Do not write explanations.\n\n";
-    }
-    return { defaultModelConfig, defaultInstructionsBlocks, defaultTemplateRendering };
-}
-/**
- * Gets the minimum flex-md compliance level from environment variable
- * Defaults to 'L0' if not set or invalid
- */
-export function getFlexMdMinComplianceLevel() {
-    const envValue = process.env.FLEX_MD_MIN_COMPLIANCE_LEVEL;
-    if (envValue === 'L0' || envValue === 'L1' || envValue === 'L2' || envValue === 'L3') {
-        return envValue;
-    }
-    return 'L0'; // Default: allow anything
+    return { defaultTemplateRendering };
 }
 /**
  * Sets up request interceptor for jobId propagation and config cleanup
@@ -140,9 +97,6 @@ export function setupRequestInterceptor(router, logger) {
             }
             request.config.metadata.jobId = identityJobId;
         }
-        // Remove 'provider' from config - router uses it for routing but providers don't accept it
-        // Router reads config.provider to determine which provider to call, but then passes
-        // the entire config to the provider, which rejects 'provider' as invalid
         if (request.config && 'provider' in request.config) {
             logger.debug('Removing provider from config before passing to provider', {
                 provider: request.config.provider
@@ -158,7 +112,6 @@ export function setupRequestInterceptor(router, logger) {
  * Initializes gateway components
  */
 export function initializeGatewayComponents(config) {
-    // Initialize logger FIRST (before other components that might need it)
     const logger = createGatewayLogger({
         enableLogging: config.enableLogging ?? true,
         customLogger: config.logger,
@@ -167,14 +120,11 @@ export function initializeGatewayComponents(config) {
         logLevel: config.logLevel,
         verbose: config.verbose
     });
-    const { defaultModelConfig, defaultInstructionsBlocks, defaultTemplateRendering } = loadConfig(logger);
+    const { defaultTemplateRendering } = loadConfig(logger);
     logger.verbose('Gateway initializing', {
         defaultEngine: config.defaultEngine,
-        hasDefaultInstructionsBlocks: Object.keys(defaultInstructionsBlocks).length > 0
+        hasTemplateRenderingDefaults: !!defaultTemplateRendering
     });
-    // Activity tracking is handled by Activix internally.
-    // Initialize router - this is the ONLY way to access providers
-    // RouterConfig properties are inherited from RouterConfig interface
     const routerConfig = {};
     const defaultTarget = config.defaultTarget;
     if (defaultTarget) {
@@ -203,8 +153,6 @@ export function initializeGatewayComponents(config) {
         routerConfig.logLevel = config.logLevel;
     if (config.logging !== undefined)
         routerConfig.logging = config.logging;
-    // OpenRouter: always pass apiKey when set (fallback for providers without direct keys).
-    // PREFER_OPENROUTER=false only disables *preferring* OpenRouter when direct provider keys exist.
     const openRouterKey = resolveOpenRouterApiKey(config);
     const preferOpenRouter = resolvePreferOpenRouter(config);
     if (openRouterKey) {
@@ -218,64 +166,12 @@ export function initializeGatewayComponents(config) {
         }
     }
     const router = new LLMProviderRouter(routerConfig);
-    // Set up BETWEEN-CALLS rate limiting as a request interceptor (applies to all provider calls)
-    // This ensures rate limiting works even when router is used directly without gateway
-    // Hidden in the flow - automatic and transparent
-    // 
-    // NOTE: This is for BETWEEN-CALLS rate limiting (smart, tracks last call time).
-    // Retry delays are handled separately in gateway-retry.ts (simple sleep, not smart).
-    const rateLimitConfig = config.rateLimit;
-    // Get defaults from JSON config, fallback to constants
-    const jsonRateLimitConfig = defaultModelConfig.rateLimit || {};
-    const rateLimitEnabled = rateLimitConfig?.enabled ?? jsonRateLimitConfig.enabled ?? DEFAULT_RATE_LIMIT_ENABLED;
-    if (rateLimitEnabled) {
-        // Priority: explicit config > JSON defaults > constants
-        const defaultMinIntervalMs = rateLimitConfig?.defaultMinIntervalMs
-            ?? jsonRateLimitConfig.defaultMinIntervalMs
-            ?? DEFAULT_RATE_LIMIT_MIN_INTERVAL_MS;
-        const providerIntervals = rateLimitConfig?.providerIntervals;
-        const rateLimiter = new GatewayRateLimiter(defaultMinIntervalMs, providerIntervals, logger);
-        // Add request interceptor for BETWEEN-CALLS rate limiting (hidden in the flow)
-        router.addRequestInterceptor(async (request, provider) => {
-            // Get provider name
-            const providerName = typeof provider?.getProviderName === 'function'
-                ? provider.getProviderName()
-                : 'global';
-            // Smart rate limiting: wait only if necessary based on last call time
-            // This is for BETWEEN-CALLS, not retries (retries use simple sleep in gateway-retry.ts)
-            await rateLimiter.waitIfNeeded(providerName);
-            // Return request unchanged (interceptor can modify request, but we just need to wait)
-            return request;
-        });
-        // Add response interceptor to record call completion
-        // Note: Type assertion needed due to ResponseInterceptor type definition mismatch
-        router.addResponseInterceptor((async (response, request, provider) => {
-            // Get provider name
-            const providerName = typeof provider?.getProviderName === 'function'
-                ? provider.getProviderName()
-                : 'global';
-            // Record the call time after completion (for smart between-calls rate limiting)
-            rateLimiter.recordCall(providerName);
-            // Return response unchanged
-            return response;
-        }));
-        logger.debug('Between-calls rate limiting configured as router interceptor', {
-            defaultMinIntervalMs,
-            providerIntervals: providerIntervals ? Object.keys(providerIntervals).length : 0,
-            enabled: true,
-            note: 'Smart rate limiting (between-calls only). Retry delays handled separately (simple sleep).'
-        });
-    }
-    else {
-        logger.debug('Rate limiting disabled');
-    }
-    // Initialize usage tracking
+    setupRequestInterceptor(router, logger);
     const usageTracker = new UsageTracker({
         enableUsageTracking: config.enableUsageTracking ?? true,
         usageTier: config.usageTier,
         logger
     });
-    // Initialize activity tracking
     const activityManager = new ActivityManager({
         enableActivityTracking: config.enableActivityTracking ?? true,
         customTracker: config.activityTracker,
@@ -292,19 +188,8 @@ export function initializeGatewayComponents(config) {
                     }
             })
     });
-    const optimixerManager = new OptimixerManager({
-        optimixer: config.optimixer,
-        logger,
-        getActivix: () => activityManager.getReadyTracker()
-    });
     const templateRendering = mergeTemplateRenderOptions(defaultTemplateRendering, config.templateRendering);
-    const instructionsBlockOverrides = {
-        ...(config.instructionsBlocks ?? {})
-    };
-    // Initialize message builder config - for direct message construction
     const messageBuilderConfig = {
-        defaultInstructionsBlocks,
-        instructionsBlockOverrides,
         logger,
         templateRendering
     };
@@ -312,10 +197,8 @@ export function initializeGatewayComponents(config) {
         logger,
         router,
         activityManager,
-        optimixerManager,
         usageTracker,
         messageBuilderConfig,
-        defaultModelConfig,
         preferOpenRouter,
         openRouterApiKey: openRouterKey,
     };

package/dist-cjs/gateway-config.d.ts

@@ -6,36 +6,24 @@ import type { GatewayConfig } from './types.js';
 import type { Logxer } from '@x12i/logxer';
 import { LLMProviderRouter } from '@x12i/ai-providers-router';
 import { ActivityManager } from './activity-manager.js';
-import { OptimixerManager } from './optimixer-manager.js';
 import { UsageTracker } from './usage-tracker.js';
 import type { MessageBuilderConfig } from './message-builder.js';
 import type { TemplateRenderOptions } from '@x12i/rendrix';
 export interface GatewayConfigContext {
-    defaultModelConfig: Record<string, unknown>;
-    defaultInstructionsBlocks: Record<string, any>;
     config: GatewayConfig;
     logger: Logxer;
     router: LLMProviderRouter;
     activityManager: ActivityManager;
-    optimixerManager: OptimixerManager;
     usageTracker: UsageTracker;
     messageBuilderConfig: MessageBuilderConfig;
 }
 export type InitializedGatewayComponents = ReturnType<typeof initializeGatewayComponents>;
 /**
- * Loads configuration from JSON files (model config and instructionsBlocks).
- * Pass a {@link Logxer} instance so load diagnostics go through logxer (not console).
+ * Loads packaged template-rendering defaults for Rendrix merge at init.
  */
 export declare function loadConfig(logger: Logxer): {
-    defaultModelConfig: Record<string, unknown>;
-    defaultInstructionsBlocks: Record<string, any>;
     defaultTemplateRendering?: TemplateRenderOptions;
 };
-/**
- * Gets the minimum flex-md compliance level from environment variable
- * Defaults to 'L0' if not set or invalid
- */
-export declare function getFlexMdMinComplianceLevel(): 'L0' | 'L1' | 'L2' | 'L3';
 /**
  * Sets up request interceptor for jobId propagation and config cleanup
  */
@@ -47,10 +35,8 @@ export declare function initializeGatewayComponents(config: GatewayConfig): {
     logger: Logxer;
     router: LLMProviderRouter;
     activityManager: ActivityManager;
-    optimixerManager: OptimixerManager;
     usageTracker: UsageTracker;
     messageBuilderConfig: MessageBuilderConfig;
-    defaultModelConfig: Record<string, unknown>;
     preferOpenRouter: boolean;
     openRouterApiKey?: string;
 };

package/dist-cjs/gateway-defaults.cjs

@@ -0,0 +1,29 @@
+/**
+ * Documented gateway runtime defaults (code constants — not env or packaged JSON).
+ * Downstream clients (ai-skills, ai-tasks, graph-engine) should re-export or pass these through.
+ */
+export const GATEWAY_DEFAULT_TEMPERATURE = 0.7;
+export const GATEWAY_DEFAULT_TOP_P = 1.0;
+export const GATEWAY_DEFAULT_FREQUENCY_PENALTY = 0.0;
+export const GATEWAY_DEFAULT_PRESENCE_PENALTY = 0.0;
+/** Caps JSON stored in Activix `content.fullResponse` when diagnostics allow storing it. */
+export const DEFAULT_ACTIVITY_FULL_RESPONSE_MAX_CHARS = 512_000;
+export const GATEWAY_DEFAULT_RETRY = {
+    maxRetries: 3,
+    initialDelay: 1000,
+    maxDelay: 30000,
+    backoffMultiplier: 2,
+    enableJitter: true,
+    throttlingDelay: 5000
+};
+/**
+ * Merge retry config: request.config.retry > request.retry > GatewayConfig.retry > GATEWAY_DEFAULT_RETRY.
+ */
+export function resolveRetryConfig(request, config) {
+    return {
+        ...GATEWAY_DEFAULT_RETRY,
+        ...config.retry,
+        ...request.retry,
+        ...request.config?.retry
+    };
+}

package/dist-cjs/gateway-defaults.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Documented gateway runtime defaults (code constants — not env or packaged JSON).
+ * Downstream clients (ai-skills, ai-tasks, graph-engine) should re-export or pass these through.
+ */
+import type { GatewayConfig, RetryConfig } from './types.js';
+export declare const GATEWAY_DEFAULT_TEMPERATURE = 0.7;
+export declare const GATEWAY_DEFAULT_TOP_P = 1;
+export declare const GATEWAY_DEFAULT_FREQUENCY_PENALTY = 0;
+export declare const GATEWAY_DEFAULT_PRESENCE_PENALTY = 0;
+/** Caps JSON stored in Activix `content.fullResponse` when diagnostics allow storing it. */
+export declare const DEFAULT_ACTIVITY_FULL_RESPONSE_MAX_CHARS = 512000;
+export declare const GATEWAY_DEFAULT_RETRY: Required<Pick<RetryConfig, 'maxRetries' | 'initialDelay' | 'maxDelay' | 'backoffMultiplier' | 'enableJitter' | 'throttlingDelay'>>;
+type RetryRequestSlice = {
+    retry?: RetryConfig;
+    config?: {
+        retry?: RetryConfig;
+    };
+};
+/**
+ * Merge retry config: request.config.retry > request.retry > GatewayConfig.retry > GATEWAY_DEFAULT_RETRY.
+ */
+export declare function resolveRetryConfig(request: RetryRequestSlice, config: GatewayConfig): RetryConfig;
+export {};

package/dist-cjs/gateway-log-diagnostics.cjs

@@ -13,12 +13,8 @@ export const GatewayLogCode = {
     FALLBACK_CHAIN_EXHAUSTED: 'GATEWAY_FALLBACK_CHAIN_EXHAUSTED',
     FLEX_MD_EXTRACTION_FAILED: 'GATEWAY_FLEX_MD_EXTRACTION_FAILED',
     FLEX_MD_EXTRACTION_ERROR: 'GATEWAY_FLEX_MD_EXTRACTION_ERROR',
-    DEFAULT_MODEL_SUBSTITUTED: 'GATEWAY_DEFAULT_MODEL_SUBSTITUTED',
     RETRY_MAX_EXCEEDED: 'GATEWAY_RETRY_MAX_EXCEEDED',
-    RETRY_ATTEMPT: 'GATEWAY_RETRY_ATTEMPT',
-    OPTIMIXER_ACTIVIX_UNAVAILABLE: 'GATEWAY_OPTIMIXER_ACTIVIX_UNAVAILABLE',
-    OPTIMIXER_INIT_FAILED: 'GATEWAY_OPTIMIXER_INIT_FAILED',
-    OPTIMIXER_PREDICT_FAILED: 'GATEWAY_OPTIMIXER_PREDICT_FAILED'
+    RETRY_ATTEMPT: 'GATEWAY_RETRY_ATTEMPT'
 };
 function getModuleDir() {
     if (typeof __dirname !== 'undefined') {

package/dist-cjs/gateway-log-diagnostics.d.ts

@@ -7,12 +7,8 @@ export declare const GatewayLogCode: {
     readonly FALLBACK_CHAIN_EXHAUSTED: "GATEWAY_FALLBACK_CHAIN_EXHAUSTED";
     readonly FLEX_MD_EXTRACTION_FAILED: "GATEWAY_FLEX_MD_EXTRACTION_FAILED";
     readonly FLEX_MD_EXTRACTION_ERROR: "GATEWAY_FLEX_MD_EXTRACTION_ERROR";
-    readonly DEFAULT_MODEL_SUBSTITUTED: "GATEWAY_DEFAULT_MODEL_SUBSTITUTED";
     readonly RETRY_MAX_EXCEEDED: "GATEWAY_RETRY_MAX_EXCEEDED";
     readonly RETRY_ATTEMPT: "GATEWAY_RETRY_ATTEMPT";
-    readonly OPTIMIXER_ACTIVIX_UNAVAILABLE: "GATEWAY_OPTIMIXER_ACTIVIX_UNAVAILABLE";
-    readonly OPTIMIXER_INIT_FAILED: "GATEWAY_OPTIMIXER_INIT_FAILED";
-    readonly OPTIMIXER_PREDICT_FAILED: "GATEWAY_OPTIMIXER_PREDICT_FAILED";
 };
 export type GatewayLogCode = (typeof GatewayLogCode)[keyof typeof GatewayLogCode];
 /** Resolve packaged `defaults/log-diagnostics.json` for createLogxer diagnostics.catalogPath. */

package/dist-cjs/gateway-log-levels.cjs

@@ -20,7 +20,6 @@ export const GATEWAY_STACK_LOG_PREFIXES = {
     gateway: GATEWAY_LOG_ENV_PREFIX,
     router: ROUTER_LOG_ENV_PREFIX,
     flexMd: 'FLEX_MD',
-    optimixer: 'OPTIMIXER'
 };
 let packageLogLevelsInitialized = false;
 /**

package/dist-cjs/gateway-log-levels.d.ts

@@ -19,7 +19,6 @@ export declare const GATEWAY_STACK_LOG_PREFIXES: {
     readonly gateway: "AI_GATEWAY";
     readonly router: "AI_PROVIDER_ROUTER";
     readonly flexMd: "FLEX_MD";
-    readonly optimixer: "OPTIMIXER";
 };
 /**
  * Load bulk env (`LOGXER_PACKAGE_LEVELS`, `LOGXER_PACKAGE_LOGS_DEFAULT`) and merge optional host config.

package/dist-cjs/gateway-messages.cjs

@@ -71,9 +71,6 @@ export async function constructMessages(request, config, logger, parsedSnapshot)
     const requestWithExamples = { ...request, instructions: finalInstructions };
     // Build messages using direct message builder
     const result = await buildMessages(requestWithExamples, config, {
-        useSystemContextFallback: true,
-        includeInputRecognition: isAIRequest(request),
-        includeReinforcement: isAIRequest(request),
         parsedSnapshot
     });
     if (parsedSnapshot && result.metadata) {

package/dist-cjs/gateway-meta.cjs

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

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