@x12i/ai-gateway 7.9.1

package/dist/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 {};

package/dist/gateway-memory.js

@@ -0,0 +1,207 @@
+/**
+ * Gateway Memory Module
+ * Handles working memory and template parameter resolution
+ */
+// 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)
+ */
+export 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
+ */
+export 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/gateway-messages.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Gateway Messages Module
+ * Handles message construction using direct message builder
+ */
+import type { ChatRequest, AIRequest } from './types.js';
+import type { Logxer } from '@x12i/logxer';
+import { type MessageBuilderConfig } from './message-builder.js';
+type Request = ChatRequest | AIRequest;
+/**
+ * Constructs messages from instructions/prompt/input/context
+ *
+ * Uses direct message builder which handles:
+ * - Token resolution (3-tier system)
+ * - Template parsing (via Rendrix, @x12i/rendrix)
+ * - Instruction block resolution and composition
+ * - Flex-md format specification
+ * - Message assembly
+ */
+export declare function constructMessages(request: Request, config: MessageBuilderConfig, logger: Logxer, parsedSnapshot?: any): Promise<Array<{
+    role: string;
+    content: string;
+}>>;
+export {};

package/dist/gateway-messages.js

@@ -0,0 +1,83 @@
+/**
+ * Gateway Messages Module
+ * Handles message construction using direct message builder
+ */
+import { buildMessages } from './message-builder.js';
+// Type guard to check if request is AIRequest
+// AIRequest is distinguished by having primaryObjectType, objectTypes, or other AIRequest-specific fields
+function isAIRequest(request) {
+    return 'primaryObjectType' in request ||
+        ('objectTypes' in request && Array.isArray(request.objectTypes)) ||
+        'skillId' in request ||
+        'masterSkillId' in request ||
+        'reasoningEncrypted' in request;
+}
+/**
+ * Constructs messages from instructions/prompt/input/context
+ *
+ * Uses direct message builder which handles:
+ * - Token resolution (3-tier system)
+ * - Template parsing (via Rendrix, @x12i/rendrix)
+ * - Instruction block resolution and composition
+ * - Flex-md format specification
+ * - Message assembly
+ */
+export async function constructMessages(request, config, logger, parsedSnapshot) {
+    logger.verbose('Constructing messages from request', {
+        jobId: request.jobId,
+        agentId: request.agentId,
+        hasInstructions: !!request.instructions,
+        hasContext: !!request.context,
+        hasPrompt: !!request.prompt,
+        hasWorkingMemory: !!request.workingMemory
+    });
+    // LOGGING: Construct messages phase (instructions should already be resolved)
+    const traceId = request.jobId || `trace-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+    const agentId = request.agentId;
+    logger.info('instructions.constructMessages.entry', {
+        traceId,
+        jobId: request.jobId,
+        agentId,
+        'instructionsType': typeof request.instructions,
+        'instructionsLength': typeof request.instructions === 'string' ? request.instructions.length : 'N/A',
+        'hasResolvedText': !!request.resolvedInstructionsText
+    });
+    // Always use flex-md format - no modes needed
+    let finalInstructions = request.instructions;
+    // Add examples for few-shot learning if using standard type
+    if (isAIRequest(request)) {
+        const resolvedType = request._resolvedTypes?.primary;
+        if (resolvedType?.isStandard && resolvedType.definition?.examples) {
+            const examples = resolvedType.definition.examples;
+            if (examples.length > 0) {
+                // Use first 3 examples for few-shot learning
+                const fewShotExamples = examples
+                    .slice(0, 3)
+                    .map((ex) => `Input: ${ex.input}\nOutput: ${ex.output}`)
+                    .join('\n\n');
+                // Append to instructions
+                if (typeof finalInstructions === 'string') {
+                    finalInstructions = `${finalInstructions}\n\nExamples:\n${fewShotExamples}`;
+                    logger.debug('Added few-shot examples to instructions', {
+                        jobId: request.jobId,
+                        exampleCount: Math.min(examples.length, 3),
+                        totalExamples: examples.length
+                    });
+                }
+            }
+        }
+    }
+    // Update request with final instructions (for message builder)
+    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) {
+        parsedSnapshot._requestBuilderMetadata = result.metadata;
+    }
+    return result.messages;
+}

package/dist/gateway-meta.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Gateway Meta Operations Module
+ * Handles meta operations like instruction optimization and testing
+ */
+import type { EnhancedLLMResponse, GatewayConfig } from './types.js';
+import type { Logxer } from '@x12i/logxer';
+import type { AIGateway } from './gateway.js';
+/**
+ * Test instructions by running them and analyzing the response
+ */
+export declare function testInstructions(instructions: string, testInput: string, expectedSchema: Record<string, unknown> | undefined, options: {
+    agentId?: string;
+    model?: string;
+    provider?: string;
+}, config: GatewayConfig, gateway: AIGateway, logger: Logxer): Promise<{
+    passed: boolean;
+    response: EnhancedLLMResponse;
+    analysis: {
+        isValidJson: boolean;
+        matchesSchema: boolean;
+        hasProse: boolean;
+        issues: string[];
+        qualityScore: number;
+    };
+}>;

package/dist/gateway-meta.js

@@ -0,0 +1,87 @@
+/**
+ * Gateway Meta Operations Module
+ * Handles meta operations like instruction optimization and testing
+ */
+/**
+ * Test instructions by running them and analyzing the response
+ */
+export async function testInstructions(instructions, testInput, expectedSchema, options, config, gateway, logger) {
+    // Get internal system action config (instruction audit)
+    const internalConfig = config.internalSystemActions?.instructionAudit;
+    const defaultEngine = config.defaultEngine || 'openai';
+    const defaultModel = internalConfig?.model || 'gpt-5-nano';
+    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');
+    }
+    // Create test request with internal system action config
+    const testRequest = {
+        jobId: `test-instructions-${Date.now()}`,
+        agentId,
+        instructions,
+        input: testInput,
+        config: {
+            model,
+            provider,
+            temperature: internalConfig?.temperature ?? 0.7, // Use internal config or default
+            maxTokens: internalConfig?.maxTokens ?? 2000 // Use internal config or default
+        }
+    };
+    // Run the test
+    const response = await gateway.invoke(testRequest);
+    // Analyze the response
+    const analysis = {
+        isValidJson: !!response.parsedContent && typeof response.parsedContent === 'object',
+        matchesSchema: false,
+        hasProse: false,
+        issues: [],
+        qualityScore: 0
+    };
+    // Check for prose
+    const contentStr = response.content || '';
+    const proseIndicators = ["I'm sorry", "Please provide", "Sure!", "Here is", "Let me", "I can", "I'll"];
+    analysis.hasProse = proseIndicators.some(indicator => contentStr.toLowerCase().includes(indicator.toLowerCase()));
+    // Check if matches schema
+    if (expectedSchema && response.parsedContent) {
+        const parsed = response.parsedContent;
+        const schemaKeys = Object.keys(expectedSchema);
+        const responseKeys = Object.keys(parsed);
+        analysis.matchesSchema = schemaKeys.every(key => responseKeys.includes(key));
+    }
+    else if (response.parsedContent) {
+        analysis.matchesSchema = true; // No schema to match against
+    }
+    // Collect issues
+    if (!analysis.isValidJson) {
+        analysis.issues.push('Response is not valid JSON');
+    }
+    if (analysis.hasProse) {
+        analysis.issues.push('Response contains conversational prose');
+    }
+    if (!analysis.matchesSchema && expectedSchema) {
+        analysis.issues.push('Response does not match expected schema');
+    }
+    if (!response.parsedContent) {
+        analysis.issues.push('Response missing parsedContent');
+    }
+    // Calculate quality score (0-10)
+    let score = 10;
+    if (!analysis.isValidJson)
+        score -= 5;
+    if (analysis.hasProse)
+        score -= 3;
+    if (!analysis.matchesSchema && expectedSchema)
+        score -= 2;
+    if (!response.parsedContent)
+        score -= 5;
+    analysis.qualityScore = Math.max(0, score);
+    const passed = analysis.issues.length === 0 && analysis.qualityScore >= 7;
+    return {
+        passed,
+        response,
+        analysis
+    };
+}

package/dist/gateway-provider-auto-register.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Gateway Provider Auto-Registration Module
+ * Automatically registers providers based on environment variables
+ */
+import type { LLMProviderRouter } from '@x12i/ai-providers-router';
+import type { Logxer } from '@x12i/logxer';
+/**
+ * Auto-registers providers based on environment variables
+ * Only registers providers that:
+ * 1. Have their API key set in environment variables
+ * 2. Have their provider package installed
+ *
+ * @param router - LLM provider router instance
+ * @param logger - Logger instance
+ * @returns Array of provider names that were successfully registered
+ */
+export declare function autoRegisterProviders(router: LLMProviderRouter, logger: Logxer): Promise<string[]>;

package/dist/gateway-provider-auto-register.js

@@ -0,0 +1,159 @@
+/**
+ * Gateway Provider Auto-Registration Module
+ * Automatically registers providers based on environment variables
+ */
+const PROVIDER_CONFIGS = [
+    {
+        name: 'openai',
+        packageName: '@x12i/ai-provider-openai',
+        className: 'OpenAIProvider',
+        envVar: 'OPENAI_API_KEY'
+    },
+    {
+        name: 'grok',
+        packageName: '@x12i/ai-provider-grok',
+        className: 'GrokProvider',
+        envVar: 'GROK_API_KEY'
+    },
+    {
+        name: 'anthropic',
+        packageName: '@x12i/ai-provider-anthropic',
+        className: 'AnthropicProvider',
+        envVar: 'ANTHROPIC_API_KEY',
+        optional: true // Optional - may not be installed
+    },
+    {
+        name: 'google',
+        packageName: '@x12i/ai-provider-google',
+        className: 'GoogleProvider',
+        envVar: 'GOOGLE_API_KEY',
+        optional: true // Optional - may not be installed
+    },
+    {
+        name: 'cohere',
+        packageName: '@x12i/ai-provider-cohere',
+        className: 'CohereProvider',
+        envVar: 'COHERE_API_KEY',
+        optional: true // Optional - may not be installed
+    },
+    {
+        name: 'mistral',
+        packageName: '@x12i/ai-provider-mistral',
+        className: 'MistralProvider',
+        envVar: 'MISTRAL_API_KEY',
+        optional: true // Optional - may not be installed
+    }
+];
+/**
+ * Auto-registers providers based on environment variables
+ * Only registers providers that:
+ * 1. Have their API key set in environment variables
+ * 2. Have their provider package installed
+ *
+ * @param router - LLM provider router instance
+ * @param logger - Logger instance
+ * @returns Array of provider names that were successfully registered
+ */
+export async function autoRegisterProviders(router, logger) {
+    const registeredProviders = [];
+    logger.debug('Auto-registering providers from environment variables');
+    for (const providerConfig of PROVIDER_CONFIGS) {
+        const apiKey = process.env[providerConfig.envVar];
+        // Skip if API key is not set
+        if (!apiKey) {
+            if (!providerConfig.optional) {
+                logger.debug(`Skipping ${providerConfig.name} provider: ${providerConfig.envVar} not set`);
+            }
+            continue;
+        }
+        try {
+            // Dynamically import the provider package
+            // Use dynamic import() for ES module compatibility
+            let ProviderClass;
+            try {
+                const providerModule = await import(providerConfig.packageName);
+                ProviderClass = providerModule[providerConfig.className] || providerModule.default;
+                if (!ProviderClass) {
+                    logger.debug(`Provider class ${providerConfig.className} not found in ${providerConfig.packageName}`);
+                    continue;
+                }
+            }
+            catch (importError) {
+                if (!providerConfig.optional) {
+                    logger.warn(`Failed to import ${providerConfig.packageName}`, {
+                        error: importError instanceof Error ? importError.message : String(importError),
+                        note: `Install it with: npm install ${providerConfig.packageName}`
+                    });
+                }
+                continue;
+            }
+            // Instantiate the provider
+            const provider = new ProviderClass({
+                apiKey: apiKey
+            });
+            // Get provider name for both module creation and logging
+            const providerName = typeof provider.getProviderName === 'function'
+                ? provider.getProviderName()
+                : providerConfig.name;
+            // Register with router as ProviderModule
+            const providerModule = {
+                name: providerName,
+                capabilities: {
+                    modes: {
+                        sync: true,
+                        stream: false,
+                        batch: false
+                    },
+                    operations: ['invoke'],
+                    maxConcurrency: 10
+                },
+                execute: async (request) => {
+                    // Use aiCall if available, otherwise assume invoke
+                    if (typeof provider.aiCall === 'function') {
+                        return await provider.aiCall(request);
+                    }
+                    else if (typeof provider.invoke === 'function') {
+                        return await provider.invoke(request);
+                    }
+                    else {
+                        throw new Error(`Provider ${providerName} has neither aiCall nor invoke method`);
+                    }
+                }
+            };
+            router.registerProvider(providerModule);
+            registeredProviders.push(providerName);
+            logger.info(`Auto-registered provider: ${providerName}`, {
+                provider: providerName,
+                envVar: providerConfig.envVar,
+                hasApiKey: !!apiKey
+            });
+        }
+        catch (error) {
+            logger.error(`Failed to auto-register ${providerConfig.name} provider`, {
+                provider: providerConfig.name,
+                package: providerConfig.packageName,
+                error: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined
+            });
+            // Continue with other providers even if one fails
+        }
+    }
+    if (registeredProviders.length === 0) {
+        logger.warn('No providers were auto-registered. Make sure API keys are set in environment variables:', {
+            requiredEnvVars: PROVIDER_CONFIGS
+                .filter(p => !p.optional)
+                .map(p => p.envVar),
+            optionalEnvVars: PROVIDER_CONFIGS
+                .filter(p => p.optional)
+                .map(p => p.envVar),
+            openRouter: 'Set OPEN_ROUTER_KEY or OPENROUTER_API_KEY (and do not set USE_OPENROUTER=false) to use OpenRouter without registering a provider.',
+            note: 'You can still manually register providers using gateway.register(provider)'
+        });
+    }
+    else {
+        logger.info(`Auto-registered ${registeredProviders.length} provider(s)`, {
+            providers: registeredProviders
+        });
+    }
+    return registeredProviders;
+}