@x12i/ai-gateway 9.7.9 → 10.0.1

package/README.md

@@ -118,23 +118,76 @@ const router = new LLMProviderRouter({ defaultProvider: 'openai' });
 | `activityTracker` | — | Custom `Activix` instance (collection names must still match package constants) |
 | `enableUsageTracking` | `true` | In-process usage tier helper |
 | `aiTools` | see below | Model resolution + catalog pricing |
-| `mode` | `'debug'` | `'dev'` \| `'debug'` \| `'prod'` — affects strict model resolution |
+| `mode` | `'debug'` | `'dev'` \| `'debug'` \| `'prod'` — ai-tools model resolution strictness (see below) |
 | `diagnostics` | — | `{ mode: 'trace' }` for rich `metadata.attempts` / `metadata.usage` |
-| `retry` / `rateLimit` | from `defaults/model-config.json` | Router retry and between-call spacing |
+| `retry` | code defaults | Provider invoke retry; override per request (see **Runtime defaults**) |
+| `temperature`, `topP`, `frequencyPenalty`, `presencePenalty` | code defaults | Gateway-wide sampling; override per request |
+| `maxTokens` | — | **Required** on every invoke (see below); optional gateway-wide default |
 
-Defaults load from `defaults/model-config.json`, `instructions-blocks.json`, and `template-rendering.json` (copied into `dist/` on build).
+Packaged defaults: only **`defaults/template-rendering.json`** (Rendrix merge at init). **No** packaged model, instructions blocks, or rate-limit JSON.
+
+### Runtime defaults (v10+)
+
+Constants exported from `@x12i/ai-gateway` — **not** env vars. Downstream packages should re-export or pass through on their public invoke API.
+
+| Constant | Default | Override priority |
+|----------|---------|-------------------|
+| `GATEWAY_DEFAULT_TEMPERATURE` | `0.7` | `modelConfig` > `request.config` > `GatewayConfig` > constant |
+| `GATEWAY_DEFAULT_TOP_P` | `1.0` | same |
+| `GATEWAY_DEFAULT_FREQUENCY_PENALTY` | `0.0` | same |
+| `GATEWAY_DEFAULT_PRESENCE_PENALTY` | `0.0` | same |
+| `GATEWAY_DEFAULT_RETRY` | `{ maxRetries: 3, initialDelay: 1000, maxDelay: 30000, backoffMultiplier: 2, enableJitter: true, throttlingDelay: 5000 }` | `request.config.retry` > `request.retry` > `GatewayConfig.retry` > constant |
+
+```typescript
+import {
+  GATEWAY_DEFAULT_RETRY,
+  GATEWAY_DEFAULT_TEMPERATURE,
+  resolveRetryConfig
+} from '@x12i/ai-gateway';
+```
+
+**Required on every invoke:** `config.model` (or `modelConfig.model`) and `maxTokens` (`request.config`, `modelConfig`, `GatewayConfig`, or `internalSystemActions`). Missing model → `ModelRequiredError` (`code: 'MODEL_REQUIRED'`). Missing `maxTokens` → `MaxTokensRequiredError` (`code: 'MAX_TOKENS_REQUIRED'`). There is **no** packaged default model, **no** flex-md / Optimixer auto-fill, and **no** `GATEWAY_DEFAULT_MAX_TOKENS`. Use [@x12i/optimixer](https://www.npmjs.com/package/@x12i/optimixer) in the **client** that wraps this gateway if you want adaptive completion budgets.
+
+**Rate limiting:** removed from the gateway. See [AI_PROVIDER_ROUTER_RATE_LIMITING_FEATURE_REQUEST.md](./docs/AI_PROVIDER_ROUTER_RATE_LIMITING_FEATURE_REQUEST.md) — implement in `@x12i/ai-providers-router`.
+
+### Template rendering (`defaults/template-rendering.json`)
+
+Used by **@x12i/rendrix** when parsing `instructions`, `prompt`, and `context`:
+
+1. Loaded at gateway init from `defaults/template-rendering.json` (copied to `dist/defaults/` on build).
+2. Merged with `GatewayConfig.templateRendering`.
+3. Per-request override via `templateRenderOptions`, `smartInput`, `smartInputRenderOptions`.
+
+Flow: `mergeGatewayAndRequestTemplateRenderOptions()` → `parseTemplate()` → Rendrix `render()`. Details: [UPSTREAM_TEMPLATE_RENDERING_AND_PARSER_V4.md](./docs/UPSTREAM_TEMPLATE_RENDERING_AND_PARSER_V4.md).
+
+### Downstream passthrough (ai-skills, ai-tasks, graph-engine)
+
+Hosts wrapping the gateway should expose on **their** public API:
+
+| Field | Required | Notes |
+|-------|----------|-------|
+| `model` | **Yes** | Never omit — gateway does not infer a model |
+| `provider` | When not fully resolved by OpenRouter + ai-tools | |
+| `temperature`, `topP`, `frequencyPenalty`, `presencePenalty`, `maxTokens` | Optional | Document defaults from `GATEWAY_DEFAULT_*` |
+| `retry` | Optional | Same shape as `RetryConfig`; defaults from `GATEWAY_DEFAULT_RETRY` |
+| `mode` | Optional | `'dev'` \| `'debug'` \| `'prod'` — pass through to `GatewayConfig.mode` |
+| `templateRenderOptions` / `smartInput` | Optional | Rendrix overrides |
+
+Instructions must be **complete caller text** — the gateway no longer injects packaged instruction blocks.
+
+### Activix response size cap
+
+`DEFAULT_ACTIVITY_FULL_RESPONSE_MAX_CHARS` (`512_000`) caps JSON stored in Activix `content.fullResponse` when diagnostics allow it. Override with `diagnostics.activityFullResponseMaxChars` on the invoke request.
 
 ### Environment (selected)
 
 | Variable | Role |
 |----------|------|
 | `MONGO_URI`, `MONGO_LOGS_DB` / `MONGO_DB` | Activix when no custom tracker |
-| `AI_GATEWAY_DEFAULT_MODEL` | Default model slug (`provider/model` or OpenRouter id) |
-| `mode` / `MODE` | Operational mode (`dev`, `debug`, `prod`) |
+| `mode` / `MODE` | Operational mode (`dev`, `debug`, `prod`) — expose to downstream clients |
 | `AI_GATEWAY_LOGS_LEVEL` | Log threshold for gateway diagnostics (`AI_GATEWAY` prefix): `error` … `verbose` |
 | `AI_GATEWAY_VERBOSE` | Full payload lines (still requires `AI_GATEWAY_LOGS_LEVEL=verbose`) |
 | `LOGXER_PACKAGE_LEVELS` | Bulk stack levels, e.g. `AI_GATEWAY:info,AI_PROVIDER_ROUTER:debug` |
-| `FLEX_MD_MIN_COMPLIANCE_LEVEL` | `L0`–`L3` output-format validation (default `L0`) |
 | `OPENROUTER_API_KEY` | OpenRouter key; always wired when set (required for profile/OpenRouter routes) |
 | `USE_OPENROUTER` | Optional; default **prefer** OpenRouter when key is set. `false` = use direct provider keys when present; OpenRouter still used as fallback when a provider has no key |
 | Other provider keys | `OPENAI_API_KEY`, `GROK_API_KEY`, etc. |
@@ -217,11 +270,13 @@ Adds **`metadata.attempts`**, **`metadata.usage`**, **`metadata.requestIds`**, a
 
 | Mode | Model resolution | Notes |
 |------|------------------|-------|
-| `dev` | Strict — unknown models fail at `mergeConfig` | Best for CI / local |
-| `debug` | Lenient defaults | Default when env unset |
-| `prod` | Falls back to configured default model when resolution fails | See `src/gateway-mode.ts` |
+| `dev` | Strict — unknown profile/model fails at `mergeConfig` when `aiTools.resolveModels` is on | Best for CI / local |
+| `debug` | Same strict resolution | Default when env unset |
+| `prod` | Same strict resolution | **No** implicit default model — callers must pass `model` |
+
+Set via constructor `mode` or env `mode` / `MODE`. **Downstream hosts should document and expose `mode`** so graph/skill callers know resolution behavior.
 
-Set via constructor `mode` or env `mode` / `MODE`.
+Every mode requires an explicit **`model`** on the request. Unresolved catalog profiles throw (e.g. `ModelProfileUnroutableError` in dev when profile has no routable target).
 
 ---
 
@@ -252,8 +307,9 @@ Live tests use `LIVE_TEST_PROVIDER` / `LIVE_TEST_MODEL` (default `openrouter` +
 | [OPENROUTER_ENV.md](./docs/OPENROUTER_ENV.md) | `OPENROUTER_API_KEY` and `USE_OPENROUTER` semantics |
 | [UPSTREAM_PROFILE_RESOLUTION_AND_OPENROUTER_FALLBACK.md](./docs/UPSTREAM_PROFILE_RESOLUTION_AND_OPENROUTER_FALLBACK.md) | Profile routing and OpenRouter fallback checklist |
 | [upstream-reports/README.md](./docs/upstream-reports/README.md) | Upstream issues (one file per package/gap) |
-| [UPSTREAM_TEMPLATE_RENDERING_AND_PARSER_V4.md](./docs/UPSTREAM_TEMPLATE_RENDERING_AND_PARSER_V4.md) | Parser v4 |
+| [AI_PROVIDER_ROUTER_RATE_LIMITING_FEATURE_REQUEST.md](./docs/AI_PROVIDER_ROUTER_RATE_LIMITING_FEATURE_REQUEST.md) | Router rate-limit FR (gateway no longer sleeps between calls) |
 | [RUNTIME_OBJECTS_OBSERVABILITY.md](./docs/RUNTIME_OBJECTS_OBSERVABILITY.md) | Runtime object keys |
+| [UPSTREAM_TEMPLATE_RENDERING_AND_PARSER_V4.md](./docs/UPSTREAM_TEMPLATE_RENDERING_AND_PARSER_V4.md) | Parser v4 + `template-rendering.json` |
 | [GRAPH_EXECUTION_SUPPORT.md](./docs/GRAPH_EXECUTION_SUPPORT.md) | Graph / node identity |
 | [DUAL_PACKAGE_SETUP_GUIDE.md](./docs/DUAL_PACKAGE_SETUP_GUIDE.md) | ESM + CJS publish layout |
 
@@ -273,7 +329,6 @@ export AI_PROVIDER_ROUTER_LOGS_LEVEL=debug
 # Optional full I/O payloads (requires _LOGS_LEVEL=verbose on the relevant package):
 export AI_GATEWAY_VERBOSE=true
 export AI_PROVIDER_ROUTER_VERBOSE=true
-export FLEX_MD_MIN_COMPLIANCE_LEVEL=L0
 ```
 
 ---

package/dist/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/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/gateway-config.js

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

@@ -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/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/gateway-log-diagnostics.js

@@ -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/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/gateway-log-levels.js

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

@@ -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) {