@x12i/ai-providers-router 4.6.0

package/dist/router/RouterWrapper.js

@@ -0,0 +1,744 @@
+import { AIRouter } from './Router.js';
+import { ProviderRegistry } from '../registry/ProviderRegistry.js';
+import { AdapterRegistry } from '../registry/AdapterRegistry.js';
+import { OpenAIAdapter } from '../adapters/openai/OpenAIAdapter.js';
+import { GrokAdapter } from '../adapters/grok/GrokAdapter.js';
+import { OpenRouterAdapter } from '../adapters/openrouter/OpenRouterAdapter.js';
+import { getLogger } from '../logger.js';
+/**
+ * Resolve ENV. placeholders to actual environment variable values
+ * Replaces nx-config2 functionality to avoid ESM/CommonJS compatibility issues
+ */
+function resolveEnvPlaceholders(config) {
+    if (typeof config === 'string') {
+        // Handle ENV.VAR_NAME||default pattern
+        if (config.startsWith('ENV.')) {
+            const match = config.match(/^ENV\.([^|]+)(?:\|\|(.+))?$/);
+            if (match) {
+                const envVar = match[1];
+                const defaultValue = match[2] !== undefined ? match[2] : undefined;
+                const value = process.env[envVar];
+                return value !== undefined ? value : (defaultValue !== undefined ? defaultValue : config);
+            }
+        }
+        return config;
+    }
+    if (Array.isArray(config)) {
+        return config.map(item => resolveEnvPlaceholders(item));
+    }
+    if (config && typeof config === 'object') {
+        const resolved = {};
+        for (const [key, value] of Object.entries(config)) {
+            resolved[key] = resolveEnvPlaceholders(value);
+        }
+        return resolved;
+    }
+    return config;
+}
+/**
+ * Wrapper around AIRouter that adds logging, interceptors, and usage tracking
+ * Maintains backward compatibility with existing router API
+ */
+export class LLMProviderRouter {
+    constructor(config) {
+        this.lastConfiguredProvider = null;
+        this.autoRegistrationAttempted = false;
+        this.config = config || {};
+        this.requestInterceptors = [];
+        this.responseInterceptors = [];
+        this.providerConfigs = new Map();
+        // Initialize logger
+        this.logger = config?.logger || getLogger({
+            verbose: config?.verbose || false,
+            level: config?.logLevel || 'info',
+        });
+        // Initialize registries
+        this.providerRegistry = new ProviderRegistry();
+        this.adapterRegistry = new AdapterRegistry();
+        // Register default adapters
+        this.adapterRegistry.register(new OpenAIAdapter());
+        this.adapterRegistry.register(new GrokAdapter());
+        this.adapterRegistry.register(new OpenRouterAdapter());
+        // Create router
+        this.router = new AIRouter(this.providerRegistry, this.adapterRegistry);
+        this.logger.info('Router initialized with ProviderModule architecture', {
+            verbose: this.logger.verbose,
+            logLevel: this.logger.level,
+        });
+    }
+    /**
+     * Register a provider module
+     */
+    registerProvider(providerModuleOrFactory, factoryName) {
+        let providerModule;
+        // Check if it's already a ProviderModule
+        if (providerModuleOrFactory.name && providerModuleOrFactory.execute) {
+            providerModule = providerModuleOrFactory;
+        }
+        else {
+            // It's a factory module - extract the factory function
+            let factory;
+            if (factoryName && providerModuleOrFactory[factoryName]) {
+                factory = providerModuleOrFactory[factoryName];
+            }
+            else if (providerModuleOrFactory.initializeClient) {
+                factory = providerModuleOrFactory.initializeClient;
+            }
+            else if (providerModuleOrFactory.createOpenAIProvider) {
+                factory = providerModuleOrFactory.createOpenAIProvider;
+            }
+            else if (typeof providerModuleOrFactory.default === 'function') {
+                factory = providerModuleOrFactory.default;
+            }
+            else if (providerModuleOrFactory.provider && typeof providerModuleOrFactory.provider === 'object') {
+                // Grok-style: export const provider: ProviderModule
+                providerModule = providerModuleOrFactory.provider;
+            }
+            else {
+                throw new Error(`Cannot determine how to extract ProviderModule from provider. Available keys: ${Object.keys(providerModuleOrFactory).join(', ')}`);
+            }
+            if (factory) {
+                // Get config for this provider
+                // Determine provider name based on factory name or available configs
+                let providerName;
+                if (factoryName === 'createOpenAIProvider') {
+                    providerName = 'openai';
+                }
+                else if (factoryName === 'initializeClient') {
+                    // Use the most recently configured provider (set right before registerProvider is called)
+                    if (this.lastConfiguredProvider && this.providerConfigs.has(this.lastConfiguredProvider)) {
+                        providerName = this.lastConfiguredProvider;
+                    }
+                    else {
+                        // Fallback: try common providers in order
+                        if (this.providerConfigs.has('openai')) {
+                            providerName = 'openai';
+                        }
+                        else if (this.providerConfigs.has('grok')) {
+                            providerName = 'grok';
+                        }
+                        else {
+                            // Use first available config
+                            const configKeys = Array.from(this.providerConfigs.keys());
+                            providerName = configKeys.length > 0 ? configKeys[0] : 'unknown';
+                        }
+                    }
+                }
+                else {
+                    providerName = 'unknown';
+                }
+                const config = this.providerConfigs.get(providerName) || {};
+                providerModule = factory(config);
+            }
+        }
+        if (!providerModule || !providerModule.name || !providerModule.execute) {
+            throw new Error('Failed to create ProviderModule from factory');
+        }
+        // Register the provider module
+        this.providerRegistry.register(providerModule);
+        // Ensure adapter exists for this provider (register if missing)
+        // Adapters are registered by their provider field, which should match ProviderModule.name
+        const providerName = providerModule.name;
+        if (!this.adapterRegistry.has(providerName)) {
+            // Try to find a matching adapter or create a default one
+            // For now, we assume adapters are pre-registered, but we could add dynamic adapter creation here
+            this.logger.warn(`No adapter found for provider '${providerName}'. Make sure adapter is registered.`);
+        }
+        this.logger.info('Provider registered', { provider: providerModule.name });
+    }
+    /**
+     * Configure provider SDK client config
+     */
+    configureProvider(providerName, config) {
+        this.providerConfigs.set(providerName, config);
+        this.lastConfiguredProvider = providerName; // Track most recently configured provider
+        this.logger.debug('Provider configuration set', { provider: providerName });
+    }
+    /**
+     * Add request interceptor
+     */
+    addRequestInterceptor(interceptor) {
+        this.requestInterceptors.push(interceptor);
+    }
+    /**
+     * Add response interceptor
+     */
+    addResponseInterceptor(interceptor) {
+        this.responseInterceptors.push(interceptor);
+    }
+    /**
+     * Invoke router (sync mode)
+     */
+    async invoke(request) {
+        const startTime = Date.now();
+        // Auto-register providers if needed
+        await this.ensureProvidersRegistered();
+        // Apply request interceptors
+        let processedRequest = request;
+        for (const interceptor of this.requestInterceptors) {
+            processedRequest = await interceptor(processedRequest, request.provider);
+        }
+        // Ensure exec.timeoutMs is always set (router owns execution semantics)
+        if (!processedRequest.exec) {
+            processedRequest.exec = {};
+        }
+        if (processedRequest.exec.timeoutMs === undefined) {
+            processedRequest.exec.timeoutMs = this.config.timeoutMs ?? 60000;
+        }
+        // Log request
+        this.logger.logAIRequest(request.provider || 'unknown', processedRequest, {
+            requestId: processedRequest.requestId,
+        });
+        // Execute
+        const invokeStartTime = Date.now();
+        let result;
+        try {
+            result = await this.router.runSync(processedRequest);
+        }
+        catch (error) {
+            // Properly extract error message
+            let err;
+            if (error instanceof Error) {
+                err = error;
+            }
+            else if (error && typeof error === 'object' && 'message' in error) {
+                err = new Error(String(error.message));
+                if ('stack' in error) {
+                    err.stack = String(error.stack);
+                }
+            }
+            else {
+                err = new Error(String(error));
+            }
+            this.logger.error('Router execution failed', {
+                provider: request.provider,
+                error: err.message,
+                stack: err.stack,
+            });
+            throw err;
+        }
+        const invokeDuration = Date.now() - invokeStartTime;
+        // Log response
+        this.logger.logAIResponse(result.provider, result, {
+            requestId: result.requestId,
+            duration: invokeDuration,
+            usage: result.usage,
+        });
+        // #region agent log
+        const logDataC = { location: 'RouterWrapper.ts:224', message: 'Before response interceptors', data: { hasMetadata: !!result.metadata, metadataKeys: result.metadata ? Object.keys(result.metadata) : [], hasAiActivitiesResponse: !!result.metadata?.['ai-activities-response'], hasAiActivitiesRequest: !!result.metadata?.['ai-activities-request'], interceptorsCount: this.responseInterceptors.length }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run1', hypothesisId: 'C' };
+        console.log('[DEBUG]', logDataC);
+        fetch('http://127.0.0.1:7243/ingest/0d4596d8-b8fa-4ca1-a4f4-2e6f23baa429', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(logDataC) }).catch(() => { });
+        // #endregion
+        // Apply response interceptors
+        let processedResponse = result;
+        for (let i = 0; i < this.responseInterceptors.length; i++) {
+            const interceptor = this.responseInterceptors[i];
+            const beforeInterceptor = {
+                hasMetadata: !!processedResponse.metadata,
+                metadataKeys: processedResponse.metadata ? Object.keys(processedResponse.metadata) : [],
+                hasAiActivitiesResponse: !!processedResponse.metadata?.['ai-activities-response'],
+                hasAiActivitiesRequest: !!processedResponse.metadata?.['ai-activities-request'],
+            };
+            processedResponse = await interceptor(processedResponse, result.provider);
+            const afterInterceptor = {
+                hasMetadata: !!processedResponse.metadata,
+                metadataKeys: processedResponse.metadata ? Object.keys(processedResponse.metadata) : [],
+                hasAiActivitiesResponse: !!processedResponse.metadata?.['ai-activities-response'],
+                hasAiActivitiesRequest: !!processedResponse.metadata?.['ai-activities-request'],
+            };
+            // #region agent log
+            const interceptorLog = { location: `RouterWrapper.ts:231:interceptor_${i}`, message: `Interceptor ${i} execution`, data: { before: beforeInterceptor, after: afterInterceptor, changed: JSON.stringify(beforeInterceptor) !== JSON.stringify(afterInterceptor) }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run1', hypothesisId: `INTERCEPTOR_${i}` };
+            console.log(`[DEBUG RouterWrapper] Interceptor ${i} - Before:`, JSON.stringify(beforeInterceptor, null, 2));
+            console.log(`[DEBUG RouterWrapper] Interceptor ${i} - After:`, JSON.stringify(afterInterceptor, null, 2));
+            if (JSON.stringify(beforeInterceptor) !== JSON.stringify(afterInterceptor)) {
+                console.warn(`[WARNING RouterWrapper] Interceptor ${i} modified ai-activities metadata!`);
+            }
+            fetch('http://127.0.0.1:7243/ingest/0d4596d8-b8fa-4ca1-a4f4-2e6f23baa429', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(interceptorLog) }).catch(() => { });
+            // #endregion
+        }
+        // #region agent log
+        const logDataD = { location: 'RouterWrapper.ts:230', message: 'After response interceptors', data: { hasMetadata: !!processedResponse.metadata, metadataKeys: processedResponse.metadata ? Object.keys(processedResponse.metadata) : [], hasAiActivitiesResponse: !!processedResponse.metadata?.['ai-activities-response'], hasAiActivitiesRequest: !!processedResponse.metadata?.['ai-activities-request'], responseChanged: processedResponse !== result }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run1', hypothesisId: 'D' };
+        console.log('[DEBUG]', logDataD);
+        fetch('http://127.0.0.1:7243/ingest/0d4596d8-b8fa-4ca1-a4f4-2e6f23baa429', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(logDataD) }).catch(() => { });
+        // #endregion
+        // Record usage
+        if (this.config.usageTracker) {
+            const duration = Date.now() - startTime;
+            this.config.usageTracker.recordRequest({
+                provider: result.provider,
+                timestamp: Date.now(),
+                duration,
+                tokens: {
+                    input: result.usage?.inputTokens || 0,
+                    output: result.usage?.outputTokens || 0,
+                    total: result.usage?.totalTokens || 0,
+                },
+                cost: result.usage?.cost,
+                success: true,
+            });
+        }
+        // #region agent log
+        const logDataE = { location: 'RouterWrapper.ts:246', message: 'Returning final response from invoke', data: { hasMetadata: !!processedResponse.metadata, metadataKeys: processedResponse.metadata ? Object.keys(processedResponse.metadata) : [], hasAiActivitiesResponse: !!processedResponse.metadata?.['ai-activities-response'], hasAiActivitiesRequest: !!processedResponse.metadata?.['ai-activities-request'], finalResponseKeys: Object.keys(processedResponse) }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run1', hypothesisId: 'E' };
+        console.log('[DEBUG RouterWrapper] Final response metadata keys:', processedResponse.metadata ? Object.keys(processedResponse.metadata) : 'NO METADATA');
+        console.log('[DEBUG RouterWrapper] ai-activities keys in final response:', processedResponse.metadata ? Object.keys(processedResponse.metadata).filter(k => k.startsWith('ai-activities')) : []);
+        console.log('[DEBUG RouterWrapper] Full log data:', JSON.stringify(logDataE, null, 2));
+        fetch('http://127.0.0.1:7243/ingest/0d4596d8-b8fa-4ca1-a4f4-2e6f23baa429', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(logDataE) }).catch(() => { });
+        // Test serialization to verify metadata survives JSON.stringify/parse
+        let serializationTest = null;
+        let serializationError = null;
+        try {
+            const serialized = JSON.stringify(processedResponse);
+            const deserialized = JSON.parse(serialized);
+            serializationTest = {
+                success: true,
+                hasMetadataAfterSerialize: !!deserialized.metadata,
+                metadataKeysAfterSerialize: deserialized.metadata ? Object.keys(deserialized.metadata) : [],
+                hasAiActivitiesResponseAfterSerialize: !!deserialized.metadata?.['ai-activities-response'],
+                hasAiActivitiesRequestAfterSerialize: !!deserialized.metadata?.['ai-activities-request'],
+                aiActivitiesKeysAfterSerialize: deserialized.metadata ? Object.keys(deserialized.metadata).filter((k) => k.startsWith('ai-activities')) : [],
+            };
+        }
+        catch (err) {
+            serializationError = err.message || String(err);
+            serializationTest = { success: false, error: serializationError };
+        }
+        const logDataF = { location: 'RouterWrapper.ts:280', message: 'Serialization test of final response', data: serializationTest, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run1', hypothesisId: 'F' };
+        console.log('[DEBUG RouterWrapper] Serialization test:', JSON.stringify(serializationTest, null, 2));
+        fetch('http://127.0.0.1:7243/ingest/0d4596d8-b8fa-4ca1-a4f4-2e6f23baa429', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(logDataF) }).catch(() => { });
+        // Detailed inspection of ai-activities data structure
+        const aiActivitiesInspection = {
+            hasAiActivitiesResponse: !!processedResponse.metadata?.['ai-activities-response'],
+            hasAiActivitiesRequest: !!processedResponse.metadata?.['ai-activities-request'],
+            aiActivitiesResponseType: typeof processedResponse.metadata?.['ai-activities-response'],
+            aiActivitiesRequestType: typeof processedResponse.metadata?.['ai-activities-request'],
+        };
+        if (processedResponse.metadata?.['ai-activities-response']) {
+            const resp = processedResponse.metadata['ai-activities-response'];
+            aiActivitiesInspection.aiActivitiesResponseKeys = Object.keys(resp);
+            aiActivitiesInspection.hasRequestId = !!resp.requestId;
+            aiActivitiesInspection.hasProvider = !!resp.provider;
+            aiActivitiesInspection.hasRawResponse = !!resp.rawResponse;
+            aiActivitiesInspection.hasOutputText = !!resp.outputText;
+            aiActivitiesInspection.hasUsage = !!resp.usage;
+            aiActivitiesInspection.hasReasoning = !!resp.reasoning;
+            aiActivitiesInspection.outputTextLength = resp.outputText?.length || 0;
+            aiActivitiesInspection.outputTextPreview = resp.outputText?.substring(0, 100) || null;
+        }
+        if (processedResponse.metadata?.['ai-activities-request']) {
+            const req = processedResponse.metadata['ai-activities-request'];
+            aiActivitiesInspection.aiActivitiesRequestKeys = Object.keys(req);
+            aiActivitiesInspection.requestHasInstructions = !!req.instructions;
+            aiActivitiesInspection.requestHasInputData = !!req.inputData;
+            aiActivitiesInspection.requestHasConfig = !!req.config;
+            aiActivitiesInspection.requestHasCallSpec = !!req._callSpec;
+        }
+        // Test if we can serialize just the ai-activities data
+        let aiActivitiesSerializationTest = null;
+        try {
+            const aiActivitiesOnly = {
+                'ai-activities-response': processedResponse.metadata?.['ai-activities-response'],
+                'ai-activities-request': processedResponse.metadata?.['ai-activities-request'],
+                'ai-activities-raw-response': processedResponse.metadata?.['ai-activities-raw-response'],
+                'ai-activities-original-response': processedResponse.metadata?.['ai-activities-original-response'],
+                'ai-activities-exec-meta': processedResponse.metadata?.['ai-activities-exec-meta'],
+            };
+            const serialized = JSON.stringify(aiActivitiesOnly);
+            const deserialized = JSON.parse(serialized);
+            aiActivitiesSerializationTest = {
+                success: true,
+                serializedSize: serialized.length,
+                hasResponseAfterSerialize: !!deserialized['ai-activities-response'],
+                hasRequestAfterSerialize: !!deserialized['ai-activities-request'],
+                responseKeysAfterSerialize: deserialized['ai-activities-response'] ? Object.keys(deserialized['ai-activities-response']) : [],
+            };
+        }
+        catch (err) {
+            aiActivitiesSerializationTest = { success: false, error: err.message || String(err) };
+        }
+        const logDataG = { location: 'RouterWrapper.ts:320', message: 'Detailed ai-activities inspection', data: { inspection: aiActivitiesInspection, serializationTest: aiActivitiesSerializationTest }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run1', hypothesisId: 'G' };
+        console.log('[DEBUG RouterWrapper] ai-activities inspection:', JSON.stringify(aiActivitiesInspection, null, 2));
+        console.log('[DEBUG RouterWrapper] ai-activities serialization test:', JSON.stringify(aiActivitiesSerializationTest, null, 2));
+        fetch('http://127.0.0.1:7243/ingest/0d4596d8-b8fa-4ca1-a4f4-2e6f23baa429', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(logDataG) }).catch(() => { });
+        // Summary: Print complete response structure for downstream system debugging
+        console.log('\n=== ROUTER RESPONSE SUMMARY (for downstream system) ===');
+        console.log('Response has metadata:', !!processedResponse.metadata);
+        console.log('Metadata keys:', processedResponse.metadata ? Object.keys(processedResponse.metadata) : 'NONE');
+        console.log('ai-activities keys:', processedResponse.metadata ? Object.keys(processedResponse.metadata).filter(k => k.startsWith('ai-activities')) : []);
+        console.log('Access path: response.metadata["ai-activities-response"]');
+        console.log('Access path: response.metadata["ai-activities-request"]');
+        if (processedResponse.metadata?.['ai-activities-response']) {
+            const resp = processedResponse.metadata['ai-activities-response'];
+            console.log('ai-activities-response structure:', {
+                hasRequestId: !!resp.requestId,
+                hasProvider: !!resp.provider,
+                hasRawResponse: !!resp.rawResponse,
+                hasOutputText: !!resp.outputText,
+                hasUsage: !!resp.usage,
+                hasReasoning: !!resp.reasoning,
+                outputTextPreview: resp.outputText?.substring(0, 50) || 'NONE',
+            });
+        }
+        console.log('=== END ROUTER RESPONSE SUMMARY ===\n');
+        // Final verification: Test accessing ai-activities data as downstream system would
+        try {
+            const testAccess = {
+                'ai-activities-response': processedResponse.metadata?.['ai-activities-response'],
+                'ai-activities-request': processedResponse.metadata?.['ai-activities-request'],
+                'ai-activities-raw-response': processedResponse.metadata?.['ai-activities-raw-response'],
+                'ai-activities-original-response': processedResponse.metadata?.['ai-activities-original-response'],
+                'ai-activities-exec-meta': processedResponse.metadata?.['ai-activities-exec-meta'],
+            };
+            const canAccess = {
+                responseExists: !!testAccess['ai-activities-response'],
+                requestExists: !!testAccess['ai-activities-request'],
+                responseHasData: testAccess['ai-activities-response'] ? Object.keys(testAccess['ai-activities-response']).length > 0 : false,
+                requestHasData: testAccess['ai-activities-request'] ? Object.keys(testAccess['ai-activities-request']).length > 0 : false,
+            };
+            console.log('[VERIFICATION] Downstream access test:', JSON.stringify(canAccess, null, 2));
+            console.log('[VERIFICATION] Example access code:');
+            console.log('  const response = await router.invoke(request);');
+            console.log('  const activitiesResponse = response.metadata["ai-activities-response"];');
+            console.log('  const activitiesRequest = response.metadata["ai-activities-request"];');
+            console.log('  // Save to database: activitiesResponse, activitiesRequest');
+            if (!canAccess.responseExists || !canAccess.requestExists) {
+                console.error('[ERROR] ai-activities data is missing! This will cause database saves to fail.');
+            }
+        }
+        catch (err) {
+            console.error('[ERROR] Failed to verify ai-activities access:', err.message);
+        }
+        // Final safeguard: Ensure metadata is never lost
+        if (!processedResponse.metadata) {
+            console.error('[CRITICAL ERROR] Response has no metadata! Creating empty metadata object.');
+            processedResponse.metadata = {};
+        }
+        // Final safeguard: Ensure ai-activities data exists, log warning if missing
+        if (!processedResponse.metadata['ai-activities-response'] || !processedResponse.metadata['ai-activities-request']) {
+            console.warn('[WARNING] ai-activities data is missing from final response!');
+            console.warn('[WARNING] This will cause database saves to fail.');
+            console.warn('[WARNING] Metadata keys present:', Object.keys(processedResponse.metadata));
+        }
+        else {
+            console.log('[SUCCESS] ai-activities data confirmed present in final response');
+        }
+        // Final log: Complete response structure snapshot
+        const finalSnapshot = {
+            timestamp: new Date().toISOString(),
+            hasMetadata: !!processedResponse.metadata,
+            metadataKeys: processedResponse.metadata ? Object.keys(processedResponse.metadata) : [],
+            aiActivitiesKeys: processedResponse.metadata ? Object.keys(processedResponse.metadata).filter(k => k.startsWith('ai-activities')) : [],
+            hasAiActivitiesResponse: !!processedResponse.metadata?.['ai-activities-response'],
+            hasAiActivitiesRequest: !!processedResponse.metadata?.['ai-activities-request'],
+            responseKeys: Object.keys(processedResponse),
+        };
+        console.log('[FINAL SNAPSHOT] Response structure before return:', JSON.stringify(finalSnapshot, null, 2));
+        // Add helper property for easier access (non-enumerable to avoid breaking serialization)
+        // This makes it easier for downstream systems to find the data
+        if (processedResponse.metadata?.['ai-activities-response'] && processedResponse.metadata?.['ai-activities-request']) {
+            try {
+                Object.defineProperty(processedResponse, '_aiActivities', {
+                    value: {
+                        response: processedResponse.metadata['ai-activities-response'],
+                        request: processedResponse.metadata['ai-activities-request'],
+                        rawResponse: processedResponse.metadata['ai-activities-raw-response'],
+                        originalResponse: processedResponse.metadata['ai-activities-original-response'],
+                        execMeta: processedResponse.metadata['ai-activities-exec-meta'],
+                    },
+                    enumerable: false, // Don't include in JSON.stringify
+                    writable: false,
+                    configurable: true,
+                });
+                console.log('[HELPER] Added _aiActivities helper property (access via response._aiActivities)');
+            }
+            catch (err) {
+                console.warn('[WARNING] Could not add _aiActivities helper property:', err.message);
+            }
+        }
+        // #endregion
+        return processedResponse;
+    }
+    /**
+     * Stream request
+     */
+    async *stream(request) {
+        // Auto-register providers if needed
+        await this.ensureProvidersRegistered();
+        // Apply request interceptors
+        let processedRequest = request;
+        for (const interceptor of this.requestInterceptors) {
+            processedRequest = await interceptor(processedRequest, request.provider);
+        }
+        // Ensure exec.timeoutMs is always set (router owns execution semantics)
+        // Router forwards all exec options (timeoutMs, idempotencyKey, signal) to providers
+        if (!processedRequest.exec) {
+            processedRequest.exec = {};
+        }
+        if (processedRequest.exec.timeoutMs === undefined) {
+            processedRequest.exec.timeoutMs = this.config.timeoutMs ?? this.config.defaultTimeoutMs ?? 60000;
+        }
+        // idempotencyKey and signal are passed through as-is if provided
+        // Log request
+        this.logger.logAIRequest(request.provider || 'unknown', processedRequest, {
+            requestId: processedRequest.requestId,
+        });
+        // Stream
+        for await (const event of this.router.runStream(processedRequest)) {
+            // Apply response interceptors to completed events
+            if (event.type === 'completed') {
+                let processedResponse = event.response;
+                for (const interceptor of this.responseInterceptors) {
+                    processedResponse = await interceptor(processedResponse, event.response.provider);
+                }
+                yield {
+                    type: 'completed',
+                    requestId: event.requestId,
+                    response: processedResponse,
+                };
+            }
+            else {
+                yield event;
+            }
+        }
+    }
+    /**
+     * Batch request
+     */
+    async createBatch(providerName, items, exec) {
+        // Auto-register providers if needed
+        await this.ensureProvidersRegistered();
+        // Ensure exec.timeoutMs is always set (router owns execution semantics)
+        // Router forwards all exec options (timeoutMs, idempotencyKey, signal) to providers
+        const execWithDefaults = {
+            timeoutMs: exec?.timeoutMs ?? this.config.timeoutMs ?? this.config.defaultTimeoutMs ?? 60000,
+            retries: exec?.retries,
+            idempotencyKey: exec?.idempotencyKey,
+            signal: exec?.signal,
+        };
+        return this.router.runBatch(providerName, items, execWithDefaults);
+    }
+    /**
+     * List registered providers
+     */
+    listProviders() {
+        return this.providerRegistry.list();
+    }
+    /**
+     * Check health of a specific provider
+     */
+    async checkHealth(provider) {
+        const startTime = Date.now();
+        try {
+            // Try a minimal health check request
+            const testRequest = {
+                request: {
+                    instructions: '',
+                    inputData: 'ping',
+                },
+                provider,
+                mode: 'sync',
+                exec: {
+                    timeoutMs: 5000,
+                },
+            };
+            this.logger.debug('Performing health check', { provider });
+            const result = await this.invoke(testRequest);
+            const latencyMs = Date.now() - startTime;
+            this.logger.debug('Health check passed', { provider, latencyMs });
+            return {
+                provider,
+                healthy: true,
+                latencyMs,
+            };
+        }
+        catch (error) {
+            const latencyMs = Date.now() - startTime;
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.logger.warn('Health check failed', {
+                provider,
+                latencyMs,
+                error: errorMessage,
+            });
+            return {
+                provider,
+                healthy: false,
+                latencyMs,
+                error: errorMessage,
+            };
+        }
+    }
+    /**
+     * Get provider registry (for advanced usage)
+     */
+    getProviderRegistry() {
+        return this.providerRegistry;
+    }
+    /**
+     * Get adapter registry (for advanced usage)
+     */
+    getAdapterRegistry() {
+        return this.adapterRegistry;
+    }
+    /**
+     * Try to register OpenRouter if a key is available (constructor config or resolved env).
+     * Used by ensureProvidersRegistered() and by the OpenRouter retry path when the first run skipped registration.
+     */
+    async tryRegisterOpenRouter(config) {
+        const openRouterKey = (this.config?.openrouter?.apiKey && typeof this.config.openrouter.apiKey === 'string' && !this.config.openrouter.apiKey.startsWith('ENV.'))
+            ? this.config.openrouter.apiKey
+            : config.openrouter?.apiKey;
+        const hasOpenRouterKey = openRouterKey &&
+            typeof openRouterKey === 'string' &&
+            openRouterKey.trim() !== '' &&
+            !openRouterKey.startsWith('ENV.');
+        if (!hasOpenRouterKey || this.providerRegistry.has('openrouter'))
+            return;
+        try {
+            const { createOpenRouterProvider } = await import('../providers/OpenRouterProvider.js');
+            const openRouterConfig = {
+                apiKey: openRouterKey,
+                baseURL: 'https://openrouter.ai/api/v1',
+                timeoutMs: this.config.timeoutMs ?? 60000,
+                httpReferer: config.openrouter?.httpReferer,
+                xTitle: config.openrouter?.xTitle,
+            };
+            this.configureProvider('openrouter', openRouterConfig);
+            const providerModule = createOpenRouterProvider(openRouterConfig);
+            if (providerModule) {
+                this.providerRegistry.register(providerModule);
+                this.addRequestInterceptor(async (req, originalProvider) => {
+                    const newRequest = { ...req };
+                    if (!newRequest.request)
+                        newRequest.request = {};
+                    if (!newRequest.request.config)
+                        newRequest.request.config = {};
+                    const callerProvider = originalProvider || newRequest.provider;
+                    const allowOpenRouterProxy = newRequest.request.config?.allowOpenRouterProxy === true ||
+                        newRequest.request.config?.providerProxy === 'openrouter';
+                    if (callerProvider && callerProvider !== 'openrouter' && !allowOpenRouterProxy) {
+                        newRequest.provider = callerProvider;
+                        newRequest.request.config.provider = callerProvider;
+                        return newRequest;
+                    }
+                    let effectiveProvider = originalProvider;
+                    if (!effectiveProvider) {
+                        const model = newRequest.request.config?.model || newRequest.request?.model;
+                        if (model && typeof model === 'string') {
+                            if (model.startsWith('gpt-') || model.startsWith('openai/'))
+                                effectiveProvider = 'openai';
+                            else if (model.startsWith('claude-') || model.startsWith('anthropic/'))
+                                effectiveProvider = 'anthropic';
+                            else if (model.startsWith('grok-') || model.startsWith('xai/'))
+                                effectiveProvider = 'grok';
+                            else if (model.startsWith('gemini-') || model.startsWith('google/'))
+                                effectiveProvider = 'google';
+                        }
+                        if (!effectiveProvider)
+                            effectiveProvider = 'openai';
+                    }
+                    newRequest.request.config.provider = effectiveProvider;
+                    if (effectiveProvider !== 'openrouter') {
+                        this.logger?.warn?.(`[OpenRouterProxy] Forcing provider=openrouter (effectiveProvider=${effectiveProvider}, originalProvider=${originalProvider ?? newRequest.provider}, model=${newRequest.request?.config?.model ?? newRequest.request?.model ?? 'unknown'})`);
+                        newRequest.provider = 'openrouter';
+                    }
+                    return newRequest;
+                });
+                this.logger.info('Auto-registered OpenRouter provider and enabled OpenRouter mode');
+            }
+        }
+        catch (e) {
+            this.logger.warn('Failed to auto-register OpenRouter provider', { error: e.message });
+        }
+    }
+    /**
+     * Automatically detect and register providers based on environment variables
+     * This ensures "Zero-Config" initialization works even if createRouter() isn't used.
+     * When the first run did not register OpenRouter (e.g. key was missing), a later invoke
+     * can still register it by retrying OpenRouter-only registration when the key is now available.
+     */
+    async ensureProvidersRegistered() {
+        if (this.autoRegistrationAttempted) {
+            if (this.providerRegistry.has('openrouter'))
+                return;
+            // Retry OpenRouter only: key may be available now (e.g. from this.config passed by gateway)
+            const detectionConfig = { providers: { openrouter: { apiKey: 'ENV.OPEN_ROUTER_KEY' } } };
+            const resolved = resolveEnvPlaceholders(detectionConfig);
+            await this.tryRegisterOpenRouter(resolved.providers);
+            return;
+        }
+        this.autoRegistrationAttempted = true;
+        // Use our own resolver instead of nx-config2 to avoid ESM/CommonJS compatibility issues
+        const detectionConfig = {
+            providers: {
+                openai: {
+                    apiKey: 'ENV.OPENAI_API_KEY',
+                    baseURL: 'ENV.OPENAI_API_BASE',
+                },
+                grok: {
+                    apiKey: 'ENV.GROK_API_KEY',
+                    baseURL: 'ENV.XAI_API_BASE',
+                },
+                openrouter: {
+                    apiKey: 'ENV.OPEN_ROUTER_KEY',
+                },
+            }
+        };
+        const resolvedConfig = resolveEnvPlaceholders(detectionConfig);
+        const config = resolvedConfig.providers;
+        await this.tryRegisterOpenRouter(config);
+        // If OpenRouter is being used, we SKIP auto-registering other providers
+        // to avoid global state conflicts (e.g. ai-provider-openai singleton config).
+        if (this.providerRegistry.has('openrouter')) {
+            this.logger.info('OpenRouter mode active - skipping individual providers to avoid state conflicts');
+            return;
+        }
+        // 2. OpenAI
+        const openaiKey = config.openai?.apiKey;
+        const hasOpenaiKey = openaiKey &&
+            typeof openaiKey === 'string' &&
+            openaiKey.trim() !== '' &&
+            !openaiKey.startsWith('ENV.');
+        if (hasOpenaiKey && !this.providerRegistry.has('openai')) {
+            try {
+                const openaiModule = await import('@x12i/ai-provider-openai');
+                const openaiConfig = {
+                    apiKey: openaiKey,
+                    baseURL: config.openai?.baseURL && !config.openai.baseURL.startsWith('ENV.') ? config.openai.baseURL : undefined,
+                    timeoutMs: this.config.timeoutMs ?? 60000,
+                };
+                this.configureProvider('openai', openaiConfig);
+                if (openaiModule.initializeClient && typeof openaiModule.initializeClient === 'function') {
+                    this.registerProvider(openaiModule, 'initializeClient');
+                }
+                else if (openaiModule.default && typeof openaiModule.default === 'object' && typeof openaiModule.default.initializeClient === 'function') {
+                    this.registerProvider(openaiModule.default, 'initializeClient');
+                }
+                this.logger.info('Auto-registered OpenAI provider');
+            }
+            catch (e) {
+                this.logger.warn('Failed to auto-register OpenAI provider', { error: e.message });
+            }
+        }
+        // 3. Grok
+        const grokKey = config.grok?.apiKey;
+        const hasGrokKey = grokKey &&
+            typeof grokKey === 'string' &&
+            grokKey.trim() !== '' &&
+            !grokKey.startsWith('ENV.');
+        if (hasGrokKey && !this.providerRegistry.has('grok')) {
+            try {
+                process.env.XAI_API_KEY = grokKey; // Grok provider often reads from env
+                const grokModule = await import('@x12i/ai-provider-grok');
+                const grokConfig = {
+                    apiKey: grokKey,
+                    baseURL: config.grok?.baseURL && !config.grok.baseURL.startsWith('ENV.') ? config.grok.baseURL : undefined,
+                };
+                this.configureProvider('grok', grokConfig);
+                this.registerProvider(grokModule);
+                this.logger.info('Auto-registered Grok provider');
+            }
+            catch (e) {
+                this.logger.warn('Failed to auto-register Grok provider', { error: e.message });
+            }
+        }
+    }
+}