@x12i/ai-gateway 7.9.1

package/dist-cjs/gateway-conversion.cjs

@@ -0,0 +1,212 @@
+"use strict";
+/**
+ * Gateway Conversion Module
+ * Handles structured text conversion and two-step conversion
+ *
+ * Text mode now uses flex-md format exclusively.
+ * Two-step conversion parses flex-md directly to JSON without additional LLM call.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invokeStructuredText = invokeStructuredText;
+exports.getDefaultConversionInstructions = getDefaultConversionInstructions;
+exports.convertStructuredToJson = convertStructuredToJson;
+const flex_md_loader_js_1 = require("./flex-md-loader.cjs");
+/**
+ * Get the current directory - works in both ESM and CJS
+ * In CJS: uses __dirname
+ * In ESM: uses import.meta.url (accessed via eval to avoid TS errors in CJS build)
+ */
+async function getCurrentDir() {
+    if (typeof __dirname !== 'undefined') {
+        return __dirname;
+    }
+    // ESM: use import.meta.url
+    // Use Function constructor to access import.meta without TypeScript errors
+    try {
+        const getMetaUrl = new Function('return import.meta.url');
+        const metaUrl = getMetaUrl();
+        if (metaUrl) {
+            const url = await Promise.resolve().then(() => __importStar(require('url')));
+            const path = await Promise.resolve().then(() => __importStar(require('path')));
+            return path.dirname(url.fileURLToPath(metaUrl));
+        }
+    }
+    catch {
+        // Fall through to process.cwd()
+    }
+    // Fallback
+    return process.cwd();
+}
+/**
+ * Invoke structured text mode (first step of two-step conversion)
+ */
+async function invokeStructuredText(request, gateway) {
+    // Create a new request with structured-text mode
+    const structuredRequest = {
+        ...request,
+        jobId: `${request.jobId}-step1`
+    };
+    // Make the call (this will recursively call invoke, but with structured-text mode)
+    return await gateway.invoke(structuredRequest);
+}
+/**
+ * Get default conversion instructions for two-step mode
+ *
+ * NOTE: This function is no longer used in two-step conversion.
+ * Two-step mode now parses flex-md directly using the flex-md package.
+ * This function is kept for backward compatibility only.
+ */
+function getDefaultConversionInstructions() {
+    return `You are a data converter. Your task is to convert structured text into valid JSON.
+
+You will receive structured text output from an AI assistant. Convert it into a valid JSON object that captures all the information from the structured text.
+
+Your response must be ONLY a valid JSON object with no other text. The JSON should preserve all information from the structured text in a structured format.
+
+CRITICAL RULES:
+- Your ENTIRE response must be parseable JSON
+- Do NOT write conversational text outside the JSON
+- Response must START with { and END with }
+- Preserve all information from the structured text
+- Use appropriate JSON data types (strings, numbers, arrays, objects)
+- If the structured text contains a story or narrative, structure it appropriately in JSON
+- Extract key elements and organize them logically`;
+}
+/**
+ * Convert flex-md structured text to JSON (second step of two-step conversion)
+ *
+ * This function now parses flex-md directly using the flex-md package,
+ * eliminating the need for an additional LLM call.
+ */
+async function convertStructuredToJson(structuredText, originalRequest, config, gateway, logger) {
+    logger.debug('Two-step conversion: Parsing flex-md text directly using flex-md SDK 3.0.0', {
+        aiRequestId: originalRequest.aiRequestId,
+        structuredTextLength: structuredText.length,
+        usingFlexMd: true
+    });
+    try {
+        // Use flex-md 3.0.0 to extract and parse JSON
+        const flexMdResult = await (0, flex_md_loader_js_1.extractJsonFromFlexMd)(structuredText);
+        if (!flexMdResult || !flexMdResult.json) {
+            throw new Error('flex-md SDK could not extract JSON from structured text');
+        }
+        const parsedJson = flexMdResult.json;
+        // Create response structure matching EnhancedLLMResponse
+        const conversionResponse = {
+            content: structuredText, // Keep original flex-md text
+            rawText: structuredText,
+            parsedContent: parsedJson, // Parsed JSON from flex-md
+            requestId: originalRequest.aiRequestId,
+            provider: 'conversion',
+            rawResponse: structuredText,
+            metadata: {
+                aiRequestId: originalRequest.aiRequestId,
+                agentId: originalRequest.agentId,
+                latencyMs: 0, // No LLM call, so no latency
+                tokens: {
+                    prompt: 0,
+                    completion: 0,
+                    total: 0
+                },
+                model: 'flex-md-parser', // Indicate we used flex-md parser
+                provider: 'flex-md',
+                isTwoStepConversion: true,
+                structuredTextStep: 'second',
+                contentType: 'object', // Parsed JSON is an object
+                conversionMethod: 'flex-md-direct-parse'
+            }
+        };
+        logger.info('Two-step conversion completed using flex-md parser', {
+            aiRequestId: originalRequest.aiRequestId,
+            parsedContentType: typeof parsedJson,
+            isObject: typeof parsedJson === 'object' && parsedJson !== null
+        });
+        return conversionResponse;
+    }
+    catch (parseError) {
+        const error = parseError instanceof Error ? parseError : new Error(String(parseError));
+        logger.error('Two-step conversion failed: flex-md parse error', {
+            jobId: originalRequest.jobId,
+            error: error.message,
+            errorName: error.name,
+            structuredTextPreview: structuredText.substring(0, 200)
+        });
+        // Create error report for flex-md parsing issue
+        let flexMdVersion = 'unknown';
+        try {
+            // Use type assertion to allow dynamic import of package.json
+            const flexMdPkg = await Promise.resolve(`${'flex-md/package.json'}`).then(s => __importStar(require(s)));
+            flexMdVersion = flexMdPkg?.version || flexMdPkg?.default?.version || 'unknown';
+        }
+        catch {
+            // Package.json not accessible
+        }
+        const report = {
+            package: 'flex-md',
+            version: flexMdVersion,
+            issue: 'parse function threw error',
+            error: error.message,
+            errorName: error.name,
+            stack: error.stack,
+            timestamp: new Date().toISOString(),
+            request: {
+                jobId: originalRequest.jobId,
+                agentId: originalRequest.agentId
+            },
+            inputPreview: structuredText.substring(0, 500),
+            inputLength: structuredText.length,
+            environment: {
+                nodeVersion: process.version,
+                platform: process.platform
+            }
+        };
+        // Write report to docs directory
+        try {
+            const fs = await Promise.resolve().then(() => __importStar(require('fs')));
+            const path = await Promise.resolve().then(() => __importStar(require('path')));
+            const currentDir = await getCurrentDir();
+            const reportPath = path.join(currentDir, '../../docs/FLEX_MD_PACKAGE_ISSUE_REPORT.json');
+            fs.writeFileSync(reportPath, JSON.stringify(report, null, 2));
+            logger.error('flex-md parsing error report written', { reportPath });
+        }
+        catch (writeError) {
+            logger.error('Failed to write flex-md parsing error report', {
+                error: writeError instanceof Error ? writeError.message : String(writeError)
+            });
+        }
+        throw new Error(`flex-md parsing failed: ${error.message}`);
+    }
+}

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

@@ -0,0 +1,29 @@
+/**
+ * Gateway Conversion Module
+ * Handles structured text conversion and two-step conversion
+ *
+ * Text mode now uses flex-md format exclusively.
+ * Two-step conversion parses flex-md directly to JSON without additional LLM call.
+ */
+import type { AIRequest, EnhancedLLMResponse, GatewayConfig } from './types.js';
+import type { Logxer } from '@x12i/logxer';
+import type { AIGateway } from './gateway.js';
+/**
+ * Invoke structured text mode (first step of two-step conversion)
+ */
+export declare function invokeStructuredText(request: AIRequest, gateway: AIGateway): Promise<EnhancedLLMResponse<string>>;
+/**
+ * Get default conversion instructions for two-step mode
+ *
+ * NOTE: This function is no longer used in two-step conversion.
+ * Two-step mode now parses flex-md directly using the flex-md package.
+ * This function is kept for backward compatibility only.
+ */
+export declare function getDefaultConversionInstructions(): string;
+/**
+ * Convert flex-md structured text to JSON (second step of two-step conversion)
+ *
+ * This function now parses flex-md directly using the flex-md package,
+ * eliminating the need for an additional LLM call.
+ */
+export declare function convertStructuredToJson(structuredText: string, originalRequest: AIRequest, config: GatewayConfig, gateway: AIGateway, logger: Logxer): Promise<EnhancedLLMResponse>;

package/dist-cjs/gateway-instructions.cjs

@@ -0,0 +1,67 @@
+"use strict";
+/**
+ * Gateway Instructions Module
+ * Handles instructions block resolution from inline config only (no content registry).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveNestedInstructionsBlock = resolveNestedInstructionsBlock;
+exports.resolveInstructionsBlock = resolveInstructionsBlock;
+exports.getPreParsedInstructions = getPreParsedInstructions;
+const instruction_errors_js_1 = require("./instruction-errors.cjs");
+function getNestedString(blocks, dotPath) {
+    const parts = dotPath.split('.');
+    let cur = blocks;
+    for (const p of parts) {
+        if (cur == null || typeof cur !== 'object')
+            return undefined;
+        cur = cur[p];
+    }
+    return typeof cur === 'string' ? cur : undefined;
+}
+/**
+ * Resolves nested instructionsBlocks (e.g., "input.inputRecognitionRule")
+ * Supports dot notation for nested object access in defaultInstructionsBlocks,
+ * then flat keys in merged overrides.
+ */
+async function resolveNestedInstructionsBlock(blockPath, _agentId, _taskTypeId, context) {
+    return resolveInstructionsBlock(blockPath, _agentId, _taskTypeId, context);
+}
+/**
+ * Resolves instructionsBlocks from config overrides, request overrides, nested defaults, or flat defaults.
+ */
+async function resolveInstructionsBlock(blockName, agentId, taskTypeId, context) {
+    const { config, logger, defaultInstructionsBlocks, instructionsBlockOverrides, requestInstructionsBlocks } = context;
+    logger.verbose('Resolving instructionsBlock', {
+        blockName,
+        agentId,
+        taskTypeId,
+        hasConfigOverride: !!config.instructionsBlocks?.[blockName]
+    });
+    const configOverride = config.instructionsBlocks?.[blockName];
+    if (typeof configOverride === 'string' && configOverride.trim()) {
+        logger.debug('Using per-call config override for instructionsBlock', { blockName, agentId });
+        return configOverride;
+    }
+    const fromRequest = requestInstructionsBlocks?.[blockName];
+    if (typeof fromRequest === 'string' && fromRequest.trim()) {
+        logger.debug('Using request.config.instructionsBlocks for instructionsBlock', { blockName, agentId });
+        return fromRequest;
+    }
+    const fromGateway = instructionsBlockOverrides[blockName];
+    if (typeof fromGateway === 'string' && fromGateway.trim()) {
+        logger.debug('Using gateway instructionsBlocks override for instructionsBlock', { blockName, agentId });
+        return fromGateway;
+    }
+    const nested = getNestedString(defaultInstructionsBlocks, blockName);
+    if (nested?.trim()) {
+        logger.debug('Using nested defaultInstructionsBlocks for instructionsBlock', { blockName, agentId });
+        return nested;
+    }
+    throw new instruction_errors_js_1.InstructionNotFoundError(blockName, 'instructions-blocks', `InstructionsBlock "${blockName}" not found. Provide it via packaged defaults, gateway instructionsBlocks, or request.config.instructionsBlocks.`, blockName);
+}
+/**
+ * Pre-parse instructions string for stable hashing (taskTypeId). No external resolution.
+ */
+function getPreParsedInstructions(instructions) {
+    return instructions ?? '';
+}

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

@@ -0,0 +1,30 @@
+/**
+ * Gateway Instructions Module
+ * Handles instructions block resolution from inline config only (no content registry).
+ */
+import type { Logxer } from '@x12i/logxer';
+export interface InstructionsContext {
+    defaultInstructionsBlocks: Record<string, any>;
+    /** Flat overrides from gateway `instructionsBlocks` (merged at init). */
+    instructionsBlockOverrides: Record<string, string>;
+    /** Per-request flat overrides from `request.config.instructionsBlocks`. */
+    requestInstructionsBlocks?: Record<string, string>;
+    config: {
+        instructionsBlocks?: Record<string, any>;
+    };
+    logger: Logxer;
+}
+/**
+ * Resolves nested instructionsBlocks (e.g., "input.inputRecognitionRule")
+ * Supports dot notation for nested object access in defaultInstructionsBlocks,
+ * then flat keys in merged overrides.
+ */
+export declare function resolveNestedInstructionsBlock(blockPath: string, _agentId: string, _taskTypeId: string | undefined, context: InstructionsContext): Promise<string>;
+/**
+ * Resolves instructionsBlocks from config overrides, request overrides, nested defaults, or flat defaults.
+ */
+export declare function resolveInstructionsBlock(blockName: string, agentId: string, taskTypeId: string | undefined, context: InstructionsContext): Promise<string>;
+/**
+ * Pre-parse instructions string for stable hashing (taskTypeId). No external resolution.
+ */
+export declare function getPreParsedInstructions(instructions: string | undefined): string;

package/dist-cjs/gateway-memory.cjs

@@ -0,0 +1,211 @@
+"use strict";
+/**
+ * Gateway Memory Module
+ * Handles working memory and template parameter resolution
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildWorkingMemory = buildWorkingMemory;
+exports.resolveTemplateParams = resolveTemplateParams;
+// Type guard to check if request is AIRequest (has primaryObjectType)
+function isAIRequest(request) {
+    return 'primaryObjectType' in request &&
+        typeof request.primaryObjectType === 'object' &&
+        request.primaryObjectType !== null &&
+        typeof request.primaryObjectType.type === 'string';
+}
+/**
+ * Builds workingMemory structure from request fields, enriching with metadata
+ * Merges existing workingMemory (from request or memory component) with request metadata
+ *
+ * Implements tiered token resolution:
+ * - Tier 1 (highest): templateTokens (handled in resolveTemplateParams, merged into shortTermMemory)
+ * - Tier 2: workingMemory (this method) - checks existing workingMemory first
+ * - Tier 3: derived from request fields or other memories (fallback)
+ */
+function buildWorkingMemory(request, existingWorkingMemory, otherMemories) {
+    // Start with existing workingMemory if provided, otherwise empty object
+    const workingMemory = existingWorkingMemory && typeof existingWorkingMemory === 'object'
+        ? { ...existingWorkingMemory }
+        : request.workingMemory && typeof request.workingMemory === 'object'
+            ? { ...request.workingMemory }
+            : {};
+    // Ensure required job and task fields exist (required by Rendrix)
+    if (!workingMemory.job) {
+        workingMemory.job = {};
+    }
+    if (!workingMemory.task) {
+        workingMemory.task = {};
+    }
+    /**
+     * Token Resolution with Tiered Fallback
+     * Tier 1: templateTokens (handled in resolveTemplateParams, merged into shortTermMemory)
+     * Tier 2: workingMemory (check existing workingMemory first)
+     * Tier 3: derive from request fields or other memories
+     */
+    // Resolve {{taskDescription}} token
+    // Tier 2: Check workingMemory first
+    // Tier 3: Fallback to request.instructions or derive from task.objective
+    if (workingMemory.taskDescription === undefined) {
+        // Tier 3: Derive from request.instructions (if available)
+        if (request.instructions) {
+            workingMemory.taskDescription = request.instructions;
+        }
+        else if (workingMemory.task?.objective) {
+            // Fallback to task.objective if instructions not available
+            workingMemory.taskDescription = workingMemory.task.objective;
+        }
+        else if (otherMemories) {
+            // Tier 3: Check other memories (experienceMemory, knowledgeMemory)
+            // Note: shortTermMemory is tier 1, so we skip it here
+            const fromExp = otherMemories.experienceMemory?.['taskDescription'];
+            const fromKnow = otherMemories.knowledgeMemory?.['taskDescription'];
+            if (fromExp !== undefined) {
+                workingMemory.taskDescription = fromExp;
+            }
+            else if (fromKnow !== undefined) {
+                workingMemory.taskDescription = fromKnow;
+            }
+        }
+    }
+    // Resolve {{input}} token
+    // Input must come from workingMemory.input (request.input has been removed)
+    // If not in workingMemory, check other memories as fallback
+    if (workingMemory.input === undefined && otherMemories) {
+        const fromExp = otherMemories.experienceMemory?.['input'];
+        const fromKnow = otherMemories.knowledgeMemory?.['input'];
+        if (fromExp !== undefined) {
+            workingMemory.input = fromExp;
+        }
+        else if (fromKnow !== undefined) {
+            workingMemory.input = fromKnow;
+        }
+    }
+    // Resolve {{role}} token
+    // Tier 2: Check workingMemory first
+    // Tier 3: Derive from request.agentType or message role context
+    if (workingMemory.role === undefined) {
+        // Tier 3: Derive from request.agentType or default to context
+        if (request.agentType) {
+            workingMemory.role = request.agentType;
+        }
+        else if (isAIRequest(request)) {
+            workingMemory.role = 'ai-reasoner';
+        }
+        else {
+            workingMemory.role = 'chat';
+        }
+        // Tier 3: Check other memories (can override derivation)
+        if (otherMemories) {
+            const fromExp = otherMemories.experienceMemory?.['role'];
+            const fromKnow = otherMemories.knowledgeMemory?.['role'];
+            if (fromExp !== undefined) {
+                workingMemory.role = fromExp;
+            }
+            else if (fromKnow !== undefined) {
+                workingMemory.role = fromKnow;
+            }
+        }
+    }
+    // Populate job fields from request if not already present in existing memory
+    if (!workingMemory.job.objective && request.instructions) {
+        workingMemory.job.objective = request.instructions;
+    }
+    if (!workingMemory.job.context && request.context) {
+        workingMemory.job.context = request.context;
+    }
+    // Input field has been removed - data should come from workingMemory.input
+    if (!workingMemory.job.narrative && request.prompt) {
+        workingMemory.job.narrative = request.prompt;
+    }
+    if (!workingMemory.job.id && request.jobId) {
+        workingMemory.job.id = request.jobId;
+    }
+    // Populate task fields from request if not already present in existing memory
+    if (!workingMemory.task.objective && request.instructions) {
+        workingMemory.task.objective = request.instructions;
+    }
+    if (!workingMemory.task.context && request.context) {
+        workingMemory.task.context = request.context;
+    }
+    // Input field has been removed - data should come from workingMemory.input
+    if (!workingMemory.task.id && request.taskId) {
+        workingMemory.task.id = request.taskId;
+    }
+    // Add entity information if not present
+    if (!workingMemory.entity && request.agentId) {
+        workingMemory.entity = {
+            name: request.agentId,
+            type: request.agentType || (isAIRequest(request) ? 'ai-reasoner' : 'chat')
+        };
+    }
+    return workingMemory;
+}
+/**
+ * Resolves template parameters with smart fallback logic
+ * Priority: Request args (tier 1) -> Memory component (tier 2) -> Gateway config (tier 3) -> defaults
+ */
+async function resolveTemplateParams(request, config, logger) {
+    // Tier 1: Request args (highest priority)
+    let workingMemory = request.workingMemory;
+    // Tier 2: Memory component integration (if available)
+    // When memoryManager is configured, it handles fetching, merging, enriching, and updating
+    if (config.memoryManager && config.memoryResolution) {
+        try {
+            // Build memory context from request
+            // Note: Spread request first, then add providedMemories to avoid duplicate properties
+            const memoryContext = {
+                ...request,
+                providedMemories: {
+                    workingMemory
+                }
+            };
+            // Determine which memories need to be fetched
+            const memoryResolution = config.memoryResolution;
+            const needsWorkingMemory = memoryResolution.fetchWorkingMemory !== false && !workingMemory;
+            // Call memoryManager.resolveMemories() which handles:
+            // 1. Fetching missing memories from storage
+            // 2. Merging input memories with fetched memories
+            // 3. Enriching memories if configured
+            // 4. Updating existing memories in storage if updateExistingMemories is true
+            // 5. Returning final merged memory
+            const memoryManager = config.memoryManager;
+            if (memoryManager && typeof memoryManager.resolveMemories === 'function') {
+                const resolved = await memoryManager.resolveMemories(memoryContext, {
+                    fetchWorkingMemory: needsWorkingMemory,
+                    updateExistingMemories: memoryResolution.updateExistingMemories ?? false,
+                    updateScope: memoryResolution.updateScope ?? ['workingMemory'],
+                    enrichment: memoryResolution.enrichment ?? { experience: 'none', knowledge: 'none' },
+                    resolutionStrategy: memoryResolution.resolutionStrategy ?? 'fetch-on-demand'
+                });
+                // Use resolved memories (already merged from input + fetched, enriched if configured)
+                // Input memories take precedence, but resolved memories fill in missing pieces
+                workingMemory = resolved.workingMemory || workingMemory;
+            }
+        }
+        catch (error) {
+            // If memory component fails, fall back to request-only mode
+            logger?.warn('Memory component resolution failed, using request-only mode', {
+                error: error instanceof Error ? error.message : String(error),
+                jobId: request.jobId
+            });
+        }
+    }
+    // Build proper workingMemory structure (merge with request fields if needed)
+    // This implements tiered token resolution: tier 2 (workingMemory) and tier 3 (derive from request fields)
+    const finalWorkingMemory = buildWorkingMemory(request, workingMemory);
+    // Merge templateTokens (tier 1 - highest priority) into shortTermMemory AFTER memory resolution
+    // This ensures templateTokens override everything (workingMemory and other memories)
+    // Rendrix priority: shortTermMemory > workingMemory > experienceMemory > knowledgeMemory
+    if (request.templateTokens && Object.keys(request.templateTokens).length > 0) {
+        logger?.debug('Merged templateTokens into shortTermMemory (tier 1 - highest priority)', {
+            jobId: request.jobId,
+            tokenKeys: Object.keys(request.templateTokens)
+        });
+    }
+    // Note: taskConfig removed - Rendrix 3.0.0+ no longer accepts it
+    // taskConfig is deprecated and no longer used
+    return {
+        workingMemory: finalWorkingMemory
+        // taskConfig removed - Rendrix 3.0.0+ no longer uses it
+    };
+}

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

@@ -0,0 +1,51 @@
+/**
+ * Gateway Memory Module
+ * Handles working memory and template parameter resolution
+ */
+import type { ChatRequest, AIRequest, GatewayConfig } from './types.js';
+import type { Logxer } from '@x12i/logxer';
+type Request = ChatRequest | AIRequest;
+/**
+ * Builds workingMemory structure from request fields, enriching with metadata
+ * Merges existing workingMemory (from request or memory component) with request metadata
+ *
+ * Implements tiered token resolution:
+ * - Tier 1 (highest): templateTokens (handled in resolveTemplateParams, merged into shortTermMemory)
+ * - Tier 2: workingMemory (this method) - checks existing workingMemory first
+ * - Tier 3: derived from request fields or other memories (fallback)
+ */
+export declare function buildWorkingMemory(request: Request, existingWorkingMemory?: unknown, otherMemories?: {
+    shortTermMemory?: {
+        [key: string]: any;
+    };
+    experienceMemory?: {
+        [key: string]: any;
+    };
+    knowledgeMemory?: {
+        [key: string]: any;
+    };
+}): unknown;
+/**
+ * Resolves template parameters with smart fallback logic
+ * Priority: Request args (tier 1) -> Memory component (tier 2) -> Gateway config (tier 3) -> defaults
+ */
+export declare function resolveTemplateParams(request: Request, config: GatewayConfig, logger: Logxer): Promise<{
+    workingMemory: unknown;
+    shortTermMemory?: {
+        [key: string]: string | number | boolean | object | object[];
+    };
+    experienceMemory?: {
+        knowHows?: object | object[] | string[] | string;
+        narratives?: object | object[] | string[] | string;
+        experiences?: object | object[] | string[] | string;
+        insights?: object | object[] | string[] | string;
+        learnings?: object | object[] | string[] | string;
+        lessons?: object | object[] | string[] | string;
+        frameworks?: object | object[] | string[] | string;
+        tools?: object | object[] | string[] | string;
+    };
+    knowledgeMemory?: {
+        [key: string]: string | number | boolean | object | object[];
+    };
+}>;
+export {};