@x12i/ai-gateway 7.9.1

package/dist-cjs/gateway-utils.cjs

@@ -0,0 +1,219 @@
+"use strict";
+/**
+ * Gateway Utilities Module
+ * Handles utility functions
+ */
+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.generateMD5Hash = generateMD5Hash;
+exports.ensureTaskTypeId = ensureTaskTypeId;
+exports.mergeConfig = mergeConfig;
+const crypto = __importStar(require("crypto"));
+const gateway_instructions_js_1 = require("./gateway-instructions.cjs");
+const flex_md_loader_js_1 = require("./flex-md-loader.cjs");
+/**
+ * Generates MD5 hash of a string
+ */
+function generateMD5Hash(text) {
+    return crypto.createHash('md5').update(text).digest('hex');
+}
+/**
+ * Auto-generates taskTypeId from MD5 hash of pre-parsed instructions if not provided
+ */
+async function ensureTaskTypeId(request, logger) {
+    if (request.taskTypeId) {
+        return request.taskTypeId;
+    }
+    const preParsedInstructions = (0, gateway_instructions_js_1.getPreParsedInstructions)(request.instructions);
+    // Generate MD5 hash
+    const taskTypeId = generateMD5Hash(preParsedInstructions);
+    logger.debug('Auto-generated taskTypeId from instructions MD5 hash', {
+        jobId: request.jobId,
+        taskTypeId,
+        instructionsLength: preParsedInstructions.length,
+        instructionsPreview: preParsedInstructions.substring(0, 100) + (preParsedInstructions.length > 100 ? '...' : '')
+    });
+    return taskTypeId;
+}
+/**
+ * Merges config with defaults
+ * Supports using internal system action defaults (internalSkill or skillAudit) when useInternalDefaults is set
+ */
+async function mergeConfig(request, config, logger) {
+    const useInternalDefaults = request.useInternalDefaults;
+    const internalDefaults = useInternalDefaults
+        ? (useInternalDefaults === 'skill'
+            ? config.internalSystemActions?.internalSkill
+            : config.internalSystemActions?.skillAudit)
+        : undefined;
+    logger.verbose('Merging request config with gateway defaults', {
+        jobId: request.jobId,
+        hasRequestConfig: !!request.config,
+        hasModelConfig: !!request.modelConfig,
+        requestModel: request.config?.model,
+        modelConfigModel: request.modelConfig?.model || request.modelConfig?.modelId,
+        requestProvider: request.config?.provider,
+        modelConfigProvider: request.modelConfig?.provider,
+        defaultEngine: config.defaultEngine,
+        useInternalDefaults,
+        hasInternalDefaults: !!internalDefaults
+    });
+    // Default model to "gpt-5-nano" if nothing is provided (most permissive - always works)
+    const defaultModel = 'gpt-5-nano';
+    // Priority: modelConfig > request.config > internalSystemActions[useInternalDefaults] > gateway defaults
+    // First, merge modelConfig into a config-like object if present
+    const modelConfigAsConfig = request.modelConfig ? {
+        model: request.modelConfig.model || request.modelConfig.modelId,
+        provider: request.modelConfig.provider,
+        temperature: request.modelConfig.temperature,
+        maxTokens: request.modelConfig.maxTokens,
+        topP: request.modelConfig.topP,
+        frequencyPenalty: request.modelConfig.frequencyPenalty,
+        presencePenalty: request.modelConfig.presencePenalty,
+        stop: request.modelConfig.stop,
+        // Include any additional properties from modelConfig
+        ...Object.fromEntries(Object.entries(request.modelConfig).filter(([key]) => !['model', 'modelId', 'provider', 'temperature', 'maxTokens', 'topP', 'frequencyPenalty', 'presencePenalty', 'stop'].includes(key)))
+    } : undefined;
+    const merged = {
+        // Start with gateway defaults (lowest priority)
+        temperature: config.temperature ?? 0.7,
+        // maxTokens will be set from flex-md if available, otherwise fallback to 2000
+        topP: config.topP ?? 1.0,
+        frequencyPenalty: config.frequencyPenalty ?? 0.0,
+        presencePenalty: config.presencePenalty ?? 0.0,
+        // Apply internal system action defaults (medium priority) if useInternalDefaults is set
+        ...(internalDefaults ? {
+            model: internalDefaults.model,
+            provider: internalDefaults.engine || config.defaultEngine,
+            temperature: internalDefaults.temperature ?? config.temperature ?? 0.7,
+            // maxTokens from internalDefaults only if explicitly set, otherwise will be auto-detected
+            ...(internalDefaults.maxTokens !== undefined ? { maxTokens: internalDefaults.maxTokens } : {})
+        } : {}),
+        // Request config overrides (higher priority)
+        ...request.config,
+        // ModelConfig overrides (highest priority) - merge only defined values
+        ...(modelConfigAsConfig ? Object.fromEntries(Object.entries(modelConfigAsConfig).filter(([_, value]) => value !== undefined)) : {}),
+        // Ensure model is set: modelConfig > request.config > internalDefaults > default
+        model: modelConfigAsConfig?.model || request.config?.model || internalDefaults?.model || defaultModel,
+        // Ensure provider is set: modelConfig > request.config > internalDefaults > gateway default
+        // Provider is required for router to know which provider to use
+        provider: modelConfigAsConfig?.provider || request.config?.provider || internalDefaults?.engine || config.defaultEngine
+    };
+    // Log if using default model
+    if (!request.config?.model && !internalDefaults?.model) {
+        logger.info('Using default model: gpt-5-nano (no model provided in request)', {
+            jobId: request.jobId,
+            note: 'Default model ensures requests always work regardless of configuration'
+        });
+    }
+    // Auto-get maxTokens from flex-md if not explicitly set in ANY config source
+    // Check all possible sources: request.config, internalDefaults, gateway config
+    const maxTokensExplicitlySet = request.config?.maxTokens !== undefined ||
+        internalDefaults?.maxTokens !== undefined ||
+        config.maxTokens !== undefined;
+    if (!maxTokensExplicitlySet && merged.model && merged.provider) {
+        // Try to get maxTokens from flex-md
+        try {
+            const flexMdMaxTokens = await (0, flex_md_loader_js_1.getModelMaxTokensFromFlexMd)(merged.provider, merged.model);
+            if (flexMdMaxTokens && flexMdMaxTokens > 0) {
+                merged.maxTokens = flexMdMaxTokens;
+                logger.debug('Using maxTokens from flex-md', {
+                    jobId: request.jobId,
+                    model: merged.model,
+                    provider: merged.provider,
+                    maxTokens: merged.maxTokens,
+                    source: 'flex-md'
+                });
+            }
+            else {
+                // flex-md doesn't have model info or returned invalid value - use fallback
+                merged.maxTokens = 2000;
+                logger.debug('Using fallback maxTokens (flex-md unavailable or no model info)', {
+                    jobId: request.jobId,
+                    model: merged.model,
+                    provider: merged.provider,
+                    maxTokens: merged.maxTokens,
+                    note: 'Set maxTokens explicitly in config for custom values.'
+                });
+            }
+        }
+        catch (error) {
+            // Error loading flex-md or getting model info - use fallback
+            merged.maxTokens = 2000;
+            logger.debug('Using fallback maxTokens (flex-md error)', {
+                jobId: request.jobId,
+                model: merged.model,
+                provider: merged.provider,
+                maxTokens: merged.maxTokens,
+                error: error instanceof Error ? error.message : String(error),
+                note: 'Set maxTokens explicitly in config for custom values.'
+            });
+        }
+    }
+    else if (!merged.maxTokens) {
+        // If maxTokens wasn't set and wasn't auto-detected, use fallback
+        // This should rarely happen, but handle edge cases
+        merged.maxTokens = 2000;
+        logger.debug('Using fallback maxTokens (not auto-detected and not explicitly set)', {
+            jobId: request.jobId,
+            model: merged.model,
+            provider: merged.provider,
+            maxTokens: merged.maxTokens,
+            maxTokensExplicitlySet
+        });
+    }
+    else {
+        // maxTokens was explicitly set - log which source
+        const source = request.config?.maxTokens !== undefined ? 'request.config' :
+            internalDefaults?.maxTokens !== undefined ? `internalSystemActions.${useInternalDefaults}` :
+                'gateway.config';
+        logger.debug('Using explicitly set maxTokens', {
+            jobId: request.jobId,
+            model: merged.model,
+            provider: merged.provider,
+            maxTokens: merged.maxTokens,
+            source
+        });
+    }
+    logger.debug('Config merged', {
+        jobId: request.jobId,
+        finalModel: merged.model,
+        finalProvider: merged.provider,
+        finalTemperature: merged.temperature,
+        finalMaxTokens: merged.maxTokens,
+        usedInternalDefaults: !!internalDefaults
+    });
+    return merged;
+}

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

@@ -0,0 +1,21 @@
+/**
+ * Gateway Utilities Module
+ * Handles utility functions
+ */
+import type { ChatRequest, GatewayConfig } from './types.js';
+import type { Logxer } from '@x12i/logxer';
+/**
+ * Generates MD5 hash of a string
+ */
+export declare function generateMD5Hash(text: string): string;
+/**
+ * Auto-generates taskTypeId from MD5 hash of pre-parsed instructions if not provided
+ */
+export declare function ensureTaskTypeId(request: ChatRequest, logger: Logxer): Promise<string>;
+/**
+ * Merges config with defaults
+ * Supports using internal system action defaults (internalSkill or skillAudit) when useInternalDefaults is set
+ */
+export declare function mergeConfig(request: ChatRequest & {
+    useInternalDefaults?: 'skill' | 'audit';
+}, config: GatewayConfig, logger: Logxer): Promise<ChatRequest['config']>;

package/dist-cjs/gateway-validation.cjs

@@ -0,0 +1,54 @@
+"use strict";
+/**
+ * Gateway Validation Module
+ * Basic validation for clean proxy implementation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateChatRequest = validateChatRequest;
+exports.validateAIRequest = validateAIRequest;
+/**
+ * Validates ChatRequest has required fields
+ */
+function validateChatRequest(request) {
+    if (!request.aiRequestId) {
+        throw new Error('aiRequestId is required');
+    }
+    if (!request.agentId) {
+        throw new Error('agentId is required');
+    }
+    // Reject input field - it has been removed
+    if ('input' in request && request.input !== undefined) {
+        const err = new Error(`The 'input' field has been removed. Use workingMemory.input instead for template rendering. Prompt templates should contain {{input}} which will be resolved from workingMemory.input.`);
+        err.code = 'INPUT_FIELD_DEPRECATED';
+        err.details = {
+            field: 'input',
+            alternative: 'workingMemory.input',
+            message: 'Input data must be provided via workingMemory.input for template rendering'
+        };
+        throw err;
+    }
+}
+/**
+ * Validates AIRequest has required fields
+ */
+function validateAIRequest(request) {
+    if (!request.aiRequestId) {
+        throw new Error('aiRequestId is required for AI requests');
+    }
+    if (!request.agentId) {
+        throw new Error('agentId is required for AI requests');
+    }
+    // Reject input field - it has been removed
+    if ('input' in request && request.input !== undefined) {
+        const err = new Error(`The 'input' field has been removed. Use workingMemory.input instead for template rendering. Prompt templates should contain {{input}} which will be resolved from workingMemory.input.`);
+        err.code = 'INPUT_FIELD_DEPRECATED';
+        err.details = {
+            field: 'input',
+            alternative: 'workingMemory.input',
+            message: 'Input data must be provided via workingMemory.input for template rendering'
+        };
+        throw err;
+    }
+    // Note: primaryObjectType and secondaryObjectTypes are now optional
+    // The gateway is a clean proxy - no object type validation logic
+}

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

@@ -0,0 +1,13 @@
+/**
+ * Gateway Validation Module
+ * Basic validation for clean proxy implementation
+ */
+import type { ChatRequest, AIRequest } from './types.js';
+/**
+ * Validates ChatRequest has required fields
+ */
+export declare function validateChatRequest(request: ChatRequest): void;
+/**
+ * Validates AIRequest has required fields
+ */
+export declare function validateAIRequest(request: AIRequest): void;