@x12i/ai-providers-router 4.6.0

package/dist/adapters/openrouter/OpenRouterAdapter.js

@@ -0,0 +1,1449 @@
+import { openRouterCatalog } from '../../openrouter-catalog.js';
+import { getReasoningCapabilitiesFromRegistry, hasReasoningParamInCatalog } from './reasoning-capabilities.js';
+/**
+ * Router-side adapter for OpenRouter provider
+ * Converts router requests to ProviderSDKCallSpec and parses responses
+ * Does NOT use ai-io-normalizer - parses OpenAI-compatible responses directly
+ */
+export class OpenRouterAdapter {
+    constructor() {
+        this.provider = 'openrouter';
+    }
+    /**
+     * Normalize model name for OpenRouter using catalog data
+     * Uses the catalog to properly map provider + model to OpenRouter format
+     */
+    async normalizeModelName(model, providerName) {
+        try {
+            // Try to normalize using catalog data
+            return await openRouterCatalog.normalizeModelName(model, providerName);
+        }
+        catch (error) {
+            // Fallback to old logic if catalog fails to load
+            console.warn('Failed to use OpenRouter catalog for model normalization, falling back to legacy logic:', error);
+            // Legacy fallback logic
+            if (model.includes('/')) {
+                return model;
+            }
+            if (providerName) {
+                const prefix = this.getProviderPrefix(providerName);
+                return `${prefix}/${model}`;
+            }
+            return `openai/${model}`;
+        }
+    }
+    /**
+     * Map provider name to OpenRouter model prefix (legacy fallback)
+     */
+    getProviderPrefix(providerName) {
+        const mapping = {
+            'openai': 'openai',
+            'grok': 'xai',
+            'xai': 'xai',
+            'anthropic': 'anthropic',
+            'google': 'google',
+            'groq': 'groq',
+            'meta': 'meta',
+            'mistral': 'mistral',
+            'cohere': 'cohere',
+            'perplexity': 'perplexity',
+        };
+        return mapping[providerName.toLowerCase()] || providerName.toLowerCase();
+    }
+    /**
+     * Get reasoning capabilities for a model
+     * Uses JSON registry for cross-vendor support detection
+     */
+    async getReasoningCapabilities(modelId) {
+        try {
+            // Check if model exists in catalog
+            const model = await openRouterCatalog.findModelById(modelId);
+            if (!model) {
+                return {
+                    supportsEffort: false,
+                    supportsMaxTokens: false,
+                    supportsSummary: false,
+                    supportsTrace: false,
+                    supportsEncrypted: false,
+                    supportsReasoningDetails: false,
+                    mode: 'none',
+                };
+            }
+            // First, try registry-based detection (router-owned source of truth)
+            const registryCapabilities = getReasoningCapabilitiesFromRegistry(model.canonicalSlug);
+            if (registryCapabilities) {
+                return {
+                    supportsEffort: registryCapabilities.mode === 'effort' || registryCapabilities.mode === 'both',
+                    supportsMaxTokens: registryCapabilities.mode === 'max_tokens' || registryCapabilities.mode === 'both',
+                    supportsSummary: registryCapabilities.visibility.summary,
+                    supportsTrace: registryCapabilities.visibility.text || registryCapabilities.visibility.encrypted,
+                    supportsEncrypted: registryCapabilities.visibility.encrypted,
+                    supportsReasoningDetails: registryCapabilities.supportsReasoningDetails,
+                    supportedEfforts: registryCapabilities.supportedEfforts,
+                    mode: registryCapabilities.mode,
+                    vendorId: registryCapabilities.vendorId,
+                };
+            }
+            // Fallback: Check catalog metadata for reasoning parameters
+            const hasReasoning = hasReasoningParamInCatalog(model);
+            if (hasReasoning) {
+                // Conservative defaults: assume effort mode if reasoning param exists.
+                // IMPORTANT: visibility (summary/trace/encrypted) is UNKNOWN without registry;
+                // do NOT assume trace/encrypted support from catalog alone.
+                return {
+                    supportsEffort: true,
+                    supportsMaxTokens: false,
+                    supportsSummary: false, // Unknown without registry => false
+                    supportsTrace: false, // Unknown without registry => false
+                    supportsEncrypted: false, // Unknown without registry => false
+                    supportsReasoningDetails: true, // Has reasoning param, so supports reasoning_details
+                    supportedEfforts: ['low', 'medium', 'high'],
+                    mode: 'effort',
+                };
+            }
+            // No reasoning support
+            return {
+                supportsEffort: false,
+                supportsMaxTokens: false,
+                supportsSummary: false,
+                supportsTrace: false,
+                supportsEncrypted: false,
+                supportsReasoningDetails: false,
+                mode: 'none',
+            };
+        }
+        catch (error) {
+            // On catalog failure, be conservative
+            return {
+                supportsEffort: false,
+                supportsMaxTokens: false,
+                supportsSummary: false,
+                supportsTrace: false,
+                supportsEncrypted: false,
+                supportsReasoningDetails: false,
+                mode: 'none',
+            };
+        }
+    }
+    /**
+     * Map unified reasoning request to provider-specific format
+     * Implements deterministic downgrade rules based on capabilities
+     * Supports both effort (OpenAI/xAI) and max_tokens (Anthropic/Gemini) modes
+     */
+    mapReasoningToProvider(reasoning, capabilities) {
+        const applied = {
+            effort: reasoning?.effort || 'none',
+            visibility: reasoning?.visibility || 'none',
+        };
+        const warnings = [];
+        const errors = [];
+        let providerReasoning = undefined;
+        const onUnsupported = reasoning?.onUnsupported || 'downgrade';
+        const mode = capabilities.mode || 'none';
+        // Normalize xhigh -> high before validation (deterministic normalization rule)
+        if (applied.effort === 'xhigh') {
+            applied.effort = 'high';
+            warnings.push({
+                code: 'EFFORT_NORMALIZED',
+                message: `Reasoning effort 'xhigh' normalized to 'high'`,
+            });
+        }
+        // Handle effort/max_tokens mapping based on mode
+        if (mode === 'effort' || mode === 'both') {
+            // Handle effort mapping (OpenAI/xAI style)
+            if (applied.effort !== 'none' && capabilities.supportsEffort) {
+                // Validate effort is supported
+                if (capabilities.supportedEfforts && !capabilities.supportedEfforts.includes(applied.effort)) {
+                    const error = {
+                        code: 'EFFORT_UNSUPPORTED',
+                        message: `Reasoning effort '${applied.effort}' not supported by model`,
+                    };
+                    if (onUnsupported === 'error') {
+                        errors.push(error);
+                    }
+                    else {
+                        warnings.push({
+                            code: 'EFFORT_IGNORED',
+                            message: `${error.message}, using default`,
+                        });
+                        applied.effort = 'none';
+                    }
+                }
+                else {
+                    providerReasoning = providerReasoning || {};
+                    providerReasoning.effort = applied.effort;
+                }
+            }
+            else if (applied.effort !== 'none' && !capabilities.supportsEffort) {
+                const error = {
+                    code: 'REASONING_UNSUPPORTED',
+                    message: `Model does not support reasoning effort control`,
+                };
+                if (onUnsupported === 'error') {
+                    errors.push(error);
+                }
+                else {
+                    warnings.push(error);
+                    applied.effort = 'none';
+                }
+            }
+        }
+        // Handle max_tokens mapping (Anthropic/Gemini style)
+        if ((mode === 'max_tokens' || mode === 'both') && reasoning?.maxTokens !== undefined) {
+            if (capabilities.supportsMaxTokens) {
+                providerReasoning = providerReasoning || {};
+                providerReasoning.max_tokens = reasoning?.maxTokens;
+            }
+            else if (reasoning?.maxTokens !== undefined) {
+                const error = {
+                    code: 'MAX_TOKENS_UNSUPPORTED',
+                    message: `Model does not support reasoning.max_tokens`,
+                };
+                if (onUnsupported === 'error') {
+                    errors.push(error);
+                }
+                else {
+                    warnings.push({
+                        code: 'MAX_TOKENS_IGNORED',
+                        message: `${error.message}, ignoring maxTokens`,
+                    });
+                }
+            }
+        }
+        // Convert effort to max_tokens if needed (for max_tokens-only models)
+        if (mode === 'max_tokens' && applied.effort !== 'none' && reasoning?.maxTokens === undefined) {
+            // Convert effort to approximate max_tokens
+            // Using OpenRouter's documented ratios: low=25%, medium=50%, high=100%
+            const effortToMaxTokens = {
+                'low': 1000, // Conservative default
+                'medium': 2000,
+                'high': 4000,
+            };
+            const estimatedMaxTokens = effortToMaxTokens[applied.effort] || 2000;
+            providerReasoning = providerReasoning || {};
+            providerReasoning.max_tokens = estimatedMaxTokens;
+            warnings.push({
+                code: 'EFFORT_CONVERTED_TO_MAX_TOKENS',
+                message: `Reasoning effort '${applied.effort}' converted to max_tokens=${estimatedMaxTokens} (model uses max_tokens mode)`,
+            });
+        }
+        // Handle visibility - support both text and encrypted traces
+        if (applied.visibility !== 'none') {
+            const supportsRequestedVisibility = (applied.visibility === 'summary' && capabilities.supportsSummary) ||
+                (applied.visibility === 'trace' && capabilities.supportsTrace);
+            if (supportsRequestedVisibility) {
+                // Visibility is supported, keep as requested
+            }
+            else {
+                const error = {
+                    code: 'VISIBILITY_UNSUPPORTED',
+                    message: `Reasoning visibility '${applied.visibility}' not supported by model`,
+                };
+                if (onUnsupported === 'error') {
+                    errors.push(error);
+                }
+                else {
+                    warnings.push({
+                        code: 'VISIBILITY_DOWNGRADED',
+                        message: `${error.message}, downgraded to 'none'`,
+                    });
+                    applied.visibility = 'none';
+                }
+            }
+        }
+        return { providerReasoning, applied, warnings, errors };
+    }
+    async buildCallSpec(input) {
+        const { requestId, mode, request, exec } = input;
+        // Extract model from request (could be in request.model or request.config.model)
+        let model = request.model || request.config?.model || 'openai/gpt-4o-mini';
+        // Determine the original provider name from the request context
+        // When OpenRouter mode is enabled, the interceptor sets request.config.provider
+        // to preserve the original provider name (e.g., "openai", "grok") for model mapping
+        const originalProvider = request.config?.provider;
+        // Normalize model name for OpenRouter using catalog data
+        // (e.g., "gpt-4o" + provider="openai" → "openai/gpt-4o")
+        model = await this.normalizeModelName(model, originalProvider);
+        // Validate model is available in OpenRouter catalog
+        try {
+            const isAvailable = await openRouterCatalog.isModelAvailable(model);
+            if (!isAvailable) {
+                console.warn(`Model '${model}' not found in OpenRouter catalog. This may result in a runtime error.`);
+            }
+        }
+        catch (error) {
+            // Don't fail the request if catalog validation fails, just log warning
+            console.warn('Could not validate model against OpenRouter catalog:', error);
+        }
+        // Determine operation based on reasoning visibility request
+        // If visibility is requested (trace/summary), prefer Responses API if model supports it
+        // Otherwise use Chat Completions (OpenRouter's default)
+        // Note: reasoning_details can appear in both formats, but Responses API is preferred for reasoning
+        // IMPORTANT: Responses API requires reasoning.effort, so only use it for effort-mode models
+        const requestedVisibility = request.config?.reasoning?.visibility;
+        const useResponsesAPIForReasoning = requestedVisibility && requestedVisibility !== 'none';
+        // Check if model supports reasoning and if we should use Responses API
+        let useResponsesAPI = false;
+        if (useResponsesAPIForReasoning && request.config?.reasoning) {
+            const capabilities = await this.getReasoningCapabilities(model);
+            // Use Responses API only if:
+            // 1. Model supports reasoning details
+            // 2. Model uses effort mode (not max_tokens mode) - Responses API requires reasoning.effort
+            // Note: reasoning_details can appear in both Chat Completions and Responses API formats
+            // Chat Completions supports reasoning_details[] for all vendors, so it's safer for max_tokens models
+            const usesEffortMode = capabilities.mode === 'effort' || capabilities.mode === 'both';
+            useResponsesAPI = capabilities.supportsReasoningDetails === true && usesEffortMode;
+        }
+        // Determine operation
+        const operation = useResponsesAPI
+            ? (mode === 'stream' ? 'openai.responses.stream' : 'openai.responses.create')
+            : (mode === 'stream' ? 'openai.chat.completions.create' : 'openai.chat.completions.create');
+        // Build args based on API type
+        const args = {
+            model,
+        };
+        if (useResponsesAPI) {
+            // Responses API format: convert messages to input format
+            let inputValue;
+            if (request.messages && Array.isArray(request.messages)) {
+                // Convert messages array to input text format
+                const systemMessages = request.messages.filter((m) => m.role === 'system');
+                const userMessages = request.messages.filter((m) => m.role === 'user');
+                const assistantMessages = request.messages.filter((m) => m.role === 'assistant');
+                const parts = [];
+                if (systemMessages.length > 0) {
+                    parts.push(...systemMessages.map((m) => `System: ${m.content || ''}`));
+                }
+                if (userMessages.length > 0) {
+                    parts.push(...userMessages.map((m) => `User: ${m.content || ''}`));
+                }
+                if (assistantMessages.length > 0) {
+                    parts.push(...assistantMessages.map((m) => `Assistant: ${m.content || ''}`));
+                }
+                inputValue = parts.join('\n\n');
+            }
+            else if (typeof request.inputData === 'string') {
+                inputValue = request.inputData;
+            }
+            else if (request.inputData) {
+                inputValue = { input_text: String(request.inputData) };
+            }
+            else if (request.instructions) {
+                inputValue = request.instructions;
+            }
+            else {
+                inputValue = JSON.stringify(request);
+            }
+            args.input = inputValue;
+        }
+        else {
+            // Chat Completions API format: use messages array
+            let messages = [];
+            if (request.messages && Array.isArray(request.messages)) {
+                messages = request.messages;
+            }
+            else if (typeof request.inputData === 'string') {
+                messages = [{ role: 'user', content: request.inputData }];
+            }
+            else if (request.inputData) {
+                messages = [{ role: 'user', content: String(request.inputData) }];
+            }
+            else if (request.instructions) {
+                messages = [{ role: 'user', content: request.instructions }];
+            }
+            else {
+                messages = [{ role: 'user', content: JSON.stringify(request) }];
+            }
+            args.messages = messages;
+        }
+        // Add config parameters
+        if (request.config) {
+            if (useResponsesAPI) {
+                // Responses API uses max_output_tokens
+                if (request.config.maxTokens !== undefined) {
+                    args.max_output_tokens = request.config.maxTokens;
+                }
+            }
+            else {
+                // Chat Completions uses max_tokens
+                if (request.config.maxTokens !== undefined) {
+                    args.max_tokens = request.config.maxTokens;
+                }
+            }
+            if (request.config.temperature !== undefined) {
+                args.temperature = request.config.temperature;
+            }
+            if (request.config.topP !== undefined) {
+                args.top_p = request.config.topP;
+            }
+            if (request.config.stop !== undefined) {
+                args.stop = request.config.stop;
+            }
+            if (request.config.stream !== undefined) {
+                args.stream = request.config.stream;
+            }
+            // Handle unified reasoning API
+            if (request.config.reasoning) {
+                // Normalize reasoning defaults at adapter boundary
+                const normalizedReasoning = {
+                    effort: request.config.reasoning.effort || 'none',
+                    visibility: request.config.reasoning.visibility || 'none',
+                    onUnsupported: request.config.reasoning.onUnsupported || 'downgrade',
+                    maxTokens: request.config.reasoning.maxTokens,
+                };
+                // Get capabilities (may have already been fetched above, but fetch again to be safe)
+                const capabilities = await this.getReasoningCapabilities(model);
+                const { providerReasoning, errors, warnings } = this.mapReasoningToProvider(normalizedReasoning, capabilities);
+                // Enforce onUnsupported semantics: never throw in downgrade mode
+                // Only throw if onUnsupported is 'error' AND there are actual errors
+                if (errors.length > 0 && normalizedReasoning.onUnsupported === 'error') {
+                    const error = errors[0]; // Use the first error
+                    throw new Error(`Reasoning request failed: ${error.message}`);
+                }
+                // In downgrade mode, convert errors to warnings (already done in mapReasoningToProvider, but ensure consistency)
+                // The mapper already handles this, but we ensure no errors slip through in downgrade mode
+                if (providerReasoning && Object.keys(providerReasoning).length > 0) {
+                    args.reasoning = providerReasoning;
+                }
+                // Store reasoning request info for response parsing (with normalized requested)
+                args._router_reasoning = {
+                    requested: normalizedReasoning,
+                    capabilities,
+                };
+            }
+        }
+        // Set stream mode for streaming requests
+        if (mode === 'stream') {
+            args.stream = true;
+        }
+        return {
+            requestId,
+            provider: 'openrouter',
+            mode,
+            operation,
+            args,
+            exec: exec ? {
+                timeoutMs: exec.timeoutMs,
+                retries: exec.retries,
+                idempotencyKey: exec.idempotencyKey,
+                signal: exec.signal,
+            } : undefined,
+        };
+    }
+    parseResponse(input) {
+        const { requestId, execResult, request } = input;
+        const rawResponse = execResult.rawResponse;
+        // #region agent log
+        console.log('[DEBUG] parseResponse entry:', {
+            hasRawResponse: !!rawResponse,
+            rawResponseKeys: rawResponse ? Object.keys(rawResponse) : [],
+            rawResponseFormat: rawResponse?.format,
+            rawResponseOutputType: typeof rawResponse?.output,
+            rawResponseOutputIsArray: Array.isArray(rawResponse?.output),
+            rawResponseOutputLength: Array.isArray(rawResponse?.output) ? rawResponse.output.length : 'not-array',
+            rawMetaKeys: execResult.rawMeta ? Object.keys(execResult.rawMeta) : [],
+            rawMetaOriginalResponse: !!execResult.rawMeta?.originalResponse,
+            rawMetaRawResponse: !!execResult.rawMeta?.rawResponse,
+        });
+        // #endregion
+        // Note: The provider SDK may normalize Responses API v1 format to Chat Completions format.
+        // However, OpenRouter may return both formats in the same response, or preserve the output array.
+        // We check both rawResponse and rawMeta for the original response structure.
+        const originalResponse = execResult.rawMeta?.originalResponse ||
+            execResult.rawMeta?.rawResponse ||
+            rawResponse;
+        console.log('[DEBUG] originalResponse:', JSON.stringify(originalResponse, null, 2));
+        // #region agent log
+        const rawMetaOriginalResponseDebug = execResult.rawMeta?.originalResponse;
+        console.log('[DEBUG] originalResponse determined:', {
+            hasOriginalResponse: !!originalResponse,
+            originalResponseKeys: originalResponse ? Object.keys(originalResponse) : [],
+            originalResponseFormat: originalResponse?.format,
+            originalResponseOutputType: typeof originalResponse?.output,
+            originalResponseOutputIsArray: Array.isArray(originalResponse?.output),
+            originalResponseOutputLength: Array.isArray(originalResponse?.output) ? originalResponse.output.length : 'not-array',
+            hasRawMetaOriginalResponse: !!rawMetaOriginalResponseDebug,
+            rawMetaOriginalResponseKeys: rawMetaOriginalResponseDebug ? Object.keys(rawMetaOriginalResponseDebug) : [],
+            rawMetaOriginalResponseFormat: rawMetaOriginalResponseDebug?.format,
+            rawMetaOriginalResponseOutputLength: Array.isArray(rawMetaOriginalResponseDebug?.output) ? rawMetaOriginalResponseDebug.output.length : 'not-array',
+            rawMetaOriginalResponseOutputSample: Array.isArray(rawMetaOriginalResponseDebug?.output) && rawMetaOriginalResponseDebug.output.length > 0
+                ? rawMetaOriginalResponseDebug.output.slice(0, 2).map((i) => ({ type: i?.type, keys: i ? Object.keys(i) : [] }))
+                : [],
+            isFromRawMetaOriginalResponse: !!execResult.rawMeta?.originalResponse,
+            isFromRawMetaRawResponse: !!execResult.rawMeta?.rawResponse,
+            isSameAsRawResponse: originalResponse === rawResponse,
+            originalResponseOutputSample: Array.isArray(originalResponse?.output) && originalResponse.output.length > 0
+                ? originalResponse.output.slice(0, 2).map((i) => ({ type: i?.type, keys: i ? Object.keys(i) : [] }))
+                : [],
+        });
+        // #endregion
+        // Parse OpenAI-compatible response directly (no ai-io-normalizer)
+        // OpenRouter may return either Chat Completions format or newer Responses API format
+        let outputText;
+        let usage;
+        let reasoning;
+        // Extract reasoning request info if present
+        const reasoningRequest = request?._callSpec?.args?._router_reasoning;
+        // Handle OpenAI Responses API format (openai-responses-v1)
+        // OpenRouter may return output array even if format field is not set
+        // Check both rawResponse (normalized) and originalResponse (unnormalized)
+        // IMPORTANT: Check if output array contains Responses API format items (with 'type' field)
+        // vs Chat Completions format items (with 'content', 'role' fields)
+        const hasOutputArray = Array.isArray(rawResponse?.output);
+        // Check rawMeta.originalResponse directly (might have the unnormalized response with output array)
+        const rawMetaOriginalResponse = execResult.rawMeta?.originalResponse;
+        const hasOutputArrayInRawMeta = Array.isArray(rawMetaOriginalResponse?.output);
+        const hasOutputArrayInOriginal = Array.isArray(originalResponse?.output) && originalResponse !== rawResponse;
+        const outputHasResponsesFormat = hasOutputArray && rawResponse.output.length > 0 && rawResponse.output.some((item) => item.type);
+        const rawMetaHasResponsesFormat = hasOutputArrayInRawMeta && rawMetaOriginalResponse.output.length > 0 && rawMetaOriginalResponse.output.some((item) => item.type);
+        const originalHasResponsesFormat = hasOutputArrayInOriginal && originalResponse.output.length > 0 && originalResponse.output.some((item) => item.type);
+        const isResponsesAPIFormat = rawResponse?.format === 'openai-responses-v1' || outputHasResponsesFormat || rawMetaHasResponsesFormat || originalHasResponsesFormat;
+        // Determine the correct output array to use (for both parsing and final response)
+        // Priority: rawMeta.originalResponse > rawResponse.output > originalResponse.output
+        // Declare outside if block so it can be reused when creating responseWithStatus
+        let outputArray = [];
+        if (rawMetaHasResponsesFormat) {
+            outputArray = rawMetaOriginalResponse.output;
+        }
+        else if (outputHasResponsesFormat) {
+            outputArray = rawResponse.output;
+        }
+        else if (originalHasResponsesFormat) {
+            outputArray = originalResponse.output;
+        }
+        else if (isResponsesAPIFormat && hasOutputArray && rawResponse.output.length > 0) {
+            // Fallback: if format is openai-responses-v1 and output exists, use it even if format detection didn't match
+            // This handles cases where the output array structure is correct but format detection logic missed it
+            outputArray = rawResponse.output;
+        }
+        // #region agent log
+        console.log('[DEBUG] output array detection:', {
+            hasOutputArray,
+            rawResponseOutputLength: Array.isArray(rawResponse?.output) ? rawResponse.output.length : 'not-array',
+            hasOutputArrayInRawMeta,
+            rawMetaOutputLength: hasOutputArrayInRawMeta ? rawMetaOriginalResponse.output.length : 'not-array',
+            hasOutputArrayInOriginal,
+            originalResponseOutputLength: Array.isArray(originalResponse?.output) ? originalResponse.output.length : 'not-array',
+            outputHasResponsesFormat,
+            rawMetaHasResponsesFormat,
+            originalHasResponsesFormat,
+            isResponsesAPIFormat,
+            selectedOutputArrayLength: outputArray.length,
+            selectedOutputArraySource: rawMetaHasResponsesFormat ? 'rawMeta' : (outputHasResponsesFormat ? 'rawResponse' : (originalHasResponsesFormat ? 'originalResponse' : 'none')),
+            selectedOutputArraySample: outputArray.length > 0 ? outputArray.slice(0, 2).map((i) => ({ type: i?.type, keys: i ? Object.keys(i) : [] })) : [],
+        });
+        // #endregion
+        // #region agent log
+        // Check for choices in multiple locations (Fix 3: Check rawMeta for Choices)
+        const choicesInRawResponse = rawResponse?.choices;
+        const choicesInRawMeta = execResult.rawMeta?.originalResponse?.choices || execResult.rawMeta?.rawResponse?.choices;
+        const choicesInOriginal = originalResponse?.choices;
+        const hasChoicesInRawResponse = choicesInRawResponse && Array.isArray(choicesInRawResponse) && choicesInRawResponse.length > 0;
+        const hasChoicesInRawMeta = choicesInRawMeta && Array.isArray(choicesInRawMeta) && choicesInRawMeta.length > 0;
+        const hasChoicesInOriginal = choicesInOriginal && Array.isArray(choicesInOriginal) && choicesInOriginal.length > 0;
+        console.log('[DEBUG] Choices detection:', {
+            hasChoicesInRawResponse,
+            hasChoicesInRawMeta,
+            hasChoicesInOriginal,
+            choicesLengthRawResponse: hasChoicesInRawResponse ? choicesInRawResponse.length : 0,
+            choicesLengthRawMeta: hasChoicesInRawMeta ? choicesInRawMeta.length : 0,
+            choicesLengthOriginal: hasChoicesInOriginal ? choicesInOriginal.length : 0,
+            isResponsesAPIFormat,
+            outputArrayLength: outputArray.length,
+        });
+        fetch('http://127.0.0.1:7243/ingest/0d4596d8-b8fa-4ca1-a4f4-2e6f23baa429', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'OpenRouterAdapter.ts:625', message: 'Choices detection', data: { hasChoicesInRawResponse, hasChoicesInRawMeta, hasChoicesInOriginal, choicesLengthRawResponse: hasChoicesInRawResponse ? choicesInRawResponse.length : 0, choicesLengthRawMeta: hasChoicesInRawMeta ? choicesInRawMeta.length : 0, choicesLengthOriginal: hasChoicesInOriginal ? choicesInOriginal.length : 0, isResponsesAPIFormat, outputArrayLength: outputArray.length }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run1', hypothesisId: 'A' }) }).catch(() => { });
+        // #endregion
+        console.log('[DEBUG] Format decision:', {
+            isResponsesAPIFormat,
+            outputArrayLength: outputArray.length,
+            willParseResponsesAPI: isResponsesAPIFormat && outputArray.length > 0,
+        });
+        // PRODUCTION-GRADE FIX: Use unified content extraction function first
+        // This ensures we extract content regardless of format detection issues
+        const extractedContent = this.extractContentFromResponse(rawResponse, originalResponse, execResult, outputArray);
+        if (extractedContent !== undefined) {
+            outputText = extractedContent;
+            console.log('[DEBUG] Content extracted via unified extraction function:', {
+                outputTextLength: outputText.length,
+                outputTextPreview: outputText.substring(0, 50),
+            });
+        }
+        if (isResponsesAPIFormat && outputArray.length > 0) {
+            // New Responses API format - parse the output array we selected
+            console.log('[DEBUG] Parsing Responses API format');
+            const encryptedArtifacts = [];
+            let summaryText;
+            let traceText;
+            // Log output array contents when reasoning was requested (for debugging)
+            const reasoningRequested = reasoningRequest?.requested?.effort !== 'none' || reasoningRequest?.requested?.visibility !== 'none';
+            if (reasoningRequested && outputArray.length > 0) {
+                console.log(`[OpenRouterAdapter] Parsing ${outputArray.length} output items for reasoning artifacts...`);
+            }
+            // #region agent log
+            console.log('[DEBUG] Starting output array parsing:', {
+                outputArrayLength: outputArray.length,
+                outputArrayItems: outputArray.map((i) => ({ type: i?.type, id: i?.id, hasSummary: !!i?.summary, hasText: !!i?.text })),
+            });
+            // #endregion
+            for (const item of outputArray) {
+                // Note: Content extraction is already done by unified function above
+                // This loop now focuses on reasoning artifacts only
+                if (item.type === 'text' && item.content && !outputText) {
+                    // Fallback: Extract text content if unified function didn't find it
+                    if (typeof item.content === 'string' && item.content.trim()) {
+                        outputText = item.content;
+                    }
+                }
+                else if (item.type === 'message' && item.content) {
+                    // Responses API may return message type with content array or object
+                    if (Array.isArray(item.content)) {
+                        for (const contentItem of item.content) {
+                            // Note: Content extraction is already done by unified function above
+                            // This is fallback only if unified function didn't find content
+                            if (!outputText) {
+                                if (contentItem.type === 'text' && contentItem.text && typeof contentItem.text === 'string' && contentItem.text.trim()) {
+                                    outputText = contentItem.text;
+                                }
+                                else if (contentItem.type === 'output_text' && contentItem.text && typeof contentItem.text === 'string' && contentItem.text.trim()) {
+                                    outputText = contentItem.text;
+                                }
+                                else if (contentItem.type === 'text' && contentItem.content && typeof contentItem.content === 'string' && contentItem.content.trim()) {
+                                    outputText = contentItem.content;
+                                }
+                                else if (!contentItem.type && typeof contentItem === 'string' && contentItem.trim()) {
+                                    outputText = contentItem;
+                                }
+                                else if (!contentItem.type && contentItem.text && typeof contentItem.text === 'string' && contentItem.text.trim()) {
+                                    outputText = contentItem.text;
+                                }
+                            }
+                            // ✅ NEW: allow summary inside message content
+                            if (contentItem.type === 'reasoning.summary') {
+                                summaryText = contentItem.summary ?? contentItem.text ?? summaryText;
+                            }
+                            // ✅ NEW: allow readable trace inside message content
+                            if (contentItem.type === 'reasoning.text') {
+                                traceText = contentItem.text ?? traceText;
+                            }
+                            // existing encrypted handling...
+                            else if (contentItem.type === 'reasoning' && contentItem.reasoning) {
+                                // Handle reasoning content within message
+                                if (contentItem.reasoning.encrypted) {
+                                    encryptedArtifacts.push({
+                                        format: 'openai-responses-v1',
+                                        id: item.id || contentItem.reasoning.id,
+                                        index: item.index,
+                                        data: contentItem.reasoning.encrypted,
+                                    });
+                                }
+                            }
+                        }
+                    }
+                    else if (typeof item.content === 'string' && item.content.trim() && !outputText) {
+                        outputText = item.content;
+                    }
+                    else if (item.content && typeof item.content === 'object' && !outputText) {
+                        // Content might be an object with text or other fields
+                        if (item.content.text && typeof item.content.text === 'string' && item.content.text.trim()) {
+                            outputText = item.content.text;
+                        }
+                        // Check for reasoning in content object
+                        if (item.content.reasoning && item.content.reasoning.encrypted) {
+                            encryptedArtifacts.push({
+                                format: 'openai-responses-v1',
+                                id: item.id,
+                                index: item.index,
+                                data: item.content.reasoning.encrypted,
+                            });
+                        }
+                    }
+                }
+                else if (item.type === 'reasoning.summary') {
+                    // ✅ NEW: handle reasoning.summary as top-level output item
+                    summaryText = item.summary ?? item.text ?? summaryText;
+                    // #region agent log
+                    console.log('[DEBUG] Found reasoning.summary:', { summaryText, itemId: item.id, itemKeys: Object.keys(item) });
+                    // #endregion
+                }
+                else if (item.type === 'reasoning.text') {
+                    // ✅ NEW: handle reasoning.text as top-level output item
+                    // Append trace text (may be multiple chunks)
+                    traceText = traceText ? `${traceText}\n${item.text}` : item.text;
+                    // #region agent log
+                    console.log('[DEBUG] Found reasoning.text:', { traceText, itemId: item.id });
+                    // #endregion
+                }
+                else if (item.type === 'reasoning.encrypted' || (item.reasoning && item.reasoning.encrypted)) {
+                    // Collect encrypted reasoning artifacts (direct or nested)
+                    const encryptedData = item.data || item.reasoning?.encrypted || item.reasoning;
+                    encryptedArtifacts.push({
+                        format: 'openai-responses-v1',
+                        id: item.id,
+                        index: item.index,
+                        data: encryptedData,
+                    });
+                    if (reasoningRequested) {
+                        console.log(`[OpenRouterAdapter] ✅ Found encrypted reasoning artifact: id=${item.id}, index=${item.index}`);
+                    }
+                }
+                else if (reasoningRequested && item.type) {
+                    // Log other item types when reasoning was requested (for debugging)
+                    console.log(`[OpenRouterAdapter] Output item type: ${item.type} (not reasoning.encrypted)`);
+                }
+            }
+            if (reasoningRequested) {
+                console.log(`[OpenRouterAdapter] Extracted ${encryptedArtifacts.length} encrypted reasoning artifacts from ${outputArray.length} output items`);
+            }
+            // Extract usage if available
+            if (rawResponse?.usage) {
+                usage = {
+                    inputTokens: rawResponse.usage.input_tokens,
+                    outputTokens: rawResponse.usage.output_tokens,
+                    totalTokens: rawResponse.usage.total_tokens,
+                };
+            }
+            // Build unified reasoning response (ONLY source of truth)
+            reasoning = this.buildReasoningResponse(reasoningRequest, {
+                encrypted: encryptedArtifacts,
+                summaryText,
+                traceText,
+            });
+        }
+        // Handle traditional Chat Completions format
+        // Fix 3: Check rawMeta for choices as fallback
+        else {
+            console.log('[DEBUG] Entering Chat Completions parsing branch');
+            // Find choices in any location (rawResponse, rawMeta, originalResponse)
+            let choices = undefined;
+            if (rawResponse?.choices && Array.isArray(rawResponse.choices) && rawResponse.choices.length > 0) {
+                choices = rawResponse.choices;
+            }
+            else if (execResult.rawMeta?.originalResponse?.choices && Array.isArray(execResult.rawMeta.originalResponse.choices) && execResult.rawMeta.originalResponse.choices.length > 0) {
+                choices = execResult.rawMeta.originalResponse.choices;
+            }
+            else if (execResult.rawMeta?.rawResponse?.choices && Array.isArray(execResult.rawMeta.rawResponse.choices) && execResult.rawMeta.rawResponse.choices.length > 0) {
+                choices = execResult.rawMeta.rawResponse.choices;
+            }
+            else if (originalResponse?.choices && Array.isArray(originalResponse.choices) && originalResponse.choices.length > 0) {
+                choices = originalResponse.choices;
+            }
+            console.log('[DEBUG] Choices search result:', {
+                foundChoices: !!choices,
+                choicesLength: choices?.length || 0,
+                choicesSource: choices === rawResponse?.choices ? 'rawResponse' :
+                    choices === execResult.rawMeta?.originalResponse?.choices ? 'rawMeta.originalResponse' :
+                        choices === execResult.rawMeta?.rawResponse?.choices ? 'rawMeta.rawResponse' :
+                            choices === originalResponse?.choices ? 'originalResponse' : 'none',
+            });
+            if (choices && choices.length > 0) {
+                const firstChoice = choices[0];
+                // #region agent log
+                console.log('[DEBUG] Chat Completions parsing entry:', {
+                    choicesLength: choices.length,
+                    hasFirstChoice: !!firstChoice,
+                    hasMessage: !!firstChoice?.message,
+                    messageKeys: firstChoice?.message ? Object.keys(firstChoice.message) : [],
+                    hasContent: firstChoice?.message?.content !== undefined,
+                    contentType: typeof firstChoice?.message?.content,
+                    contentValue: firstChoice?.message?.content,
+                    contentIsNull: firstChoice?.message?.content === null,
+                    contentIsUndefined: firstChoice?.message?.content === undefined,
+                });
+                fetch('http://127.0.0.1:7243/ingest/0d4596d8-b8fa-4ca1-a4f4-2e6f23baa429', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'OpenRouterAdapter.ts:758', message: 'Chat Completions parsing entry', data: { choicesLength: choices.length, hasFirstChoice: !!firstChoice, hasMessage: !!firstChoice?.message, messageKeys: firstChoice?.message ? Object.keys(firstChoice.message) : [], hasContent: firstChoice?.message?.content !== undefined, contentType: typeof firstChoice?.message?.content, contentValue: firstChoice?.message?.content, contentIsNull: firstChoice?.message?.content === null, contentIsUndefined: firstChoice?.message?.content === undefined }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run1', hypothesisId: 'B' }) }).catch(() => { });
+                // #endregion
+                // Note: Content extraction is already done by unified function above
+                // This is fallback only if unified function didn't find content
+                if (!outputText && firstChoice.message) {
+                    const content = firstChoice.message.content;
+                    if (typeof content === 'string' && content.trim()) {
+                        outputText = content;
+                    }
+                    else if (content !== null && content !== undefined) {
+                        // Handle non-string content (array, object, etc.)
+                        if (Array.isArray(content)) {
+                            const textParts = [];
+                            for (const part of content) {
+                                if (typeof part === 'string' && part.trim()) {
+                                    textParts.push(part);
+                                }
+                                else if (part && typeof part === 'object' && part.text && typeof part.text === 'string' && part.text.trim()) {
+                                    textParts.push(part.text);
+                                }
+                            }
+                            if (textParts.length > 0) {
+                                outputText = textParts.join('\n');
+                            }
+                        }
+                        else if (typeof content === 'object') {
+                            const str = String(content);
+                            if (str && str !== '[object Object]' && str.trim()) {
+                                outputText = str;
+                            }
+                        }
+                    }
+                }
+                // #region agent log
+                console.log('[DEBUG] After content extraction:', {
+                    outputTextExtracted: !!outputText,
+                    outputTextLength: outputText?.length || 0,
+                    outputTextPreview: outputText?.substring(0, 50) || null,
+                });
+                fetch('http://127.0.0.1:7243/ingest/0d4596d8-b8fa-4ca1-a4f4-2e6f23baa429', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'OpenRouterAdapter.ts:770', message: 'After content extraction', data: { outputTextExtracted: !!outputText, outputTextLength: outputText?.length || 0, outputTextPreview: outputText?.substring(0, 50) || null }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run1', hypothesisId: 'B' }) }).catch(() => { });
+                // #endregion
+                // Safety guard: if choices exist but outputText is still empty, log warning
+                if (!outputText && choices.length > 0) {
+                    console.warn('[OpenRouterAdapter] Choices exist but content extraction failed', {
+                        choicesLength: choices.length,
+                        firstChoice: {
+                            hasMessage: !!firstChoice.message,
+                            messageKeys: firstChoice.message ? Object.keys(firstChoice.message) : [],
+                            content: firstChoice.message?.content,
+                            contentType: typeof firstChoice.message?.content,
+                        }
+                    });
+                    // #region agent log
+                    fetch('http://127.0.0.1:7243/ingest/0d4596d8-b8fa-4ca1-a4f4-2e6f23baa429', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'OpenRouterAdapter.ts:785', message: 'Content extraction failed warning', data: { choicesLength: choices.length, firstChoiceKeys: Object.keys(firstChoice || {}), messageKeys: firstChoice?.message ? Object.keys(firstChoice.message) : [], content: firstChoice?.message?.content, contentType: typeof firstChoice?.message?.content }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run1', hypothesisId: 'C' }) }).catch(() => { });
+                    // #endregion
+                }
+                // Use choices from the source we found (for consistency)
+                const choicesToUse = choices;
+                // Extract usage from Chat Completions format
+                const usageSource = rawResponse?.usage || execResult.rawMeta?.originalResponse?.usage || originalResponse?.usage;
+                if (usageSource) {
+                    usage = {
+                        inputTokens: usageSource.prompt_tokens || usageSource.input_tokens,
+                        outputTokens: usageSource.completion_tokens || usageSource.output_tokens,
+                        totalTokens: usageSource.total_tokens,
+                    };
+                }
+                // ✅ Parse reasoning_details from Chat Completions format (choices[].message.reasoning_details[])
+                // This is the standard OpenRouter cross-vendor format
+                const encryptedArtifacts = [];
+                let summaryText;
+                let traceText;
+                // Check all choices for reasoning_details (not just first)
+                for (const choice of choicesToUse || []) {
+                    // Also capture plaintext reasoning if provider returns it in message.reasoning
+                    const msgReasoning = choice.message?.reasoning;
+                    if (typeof msgReasoning === 'string' && msgReasoning.trim()) {
+                        traceText = traceText ? `${traceText}\n${msgReasoning}` : msgReasoning;
+                    }
+                    const reasoningDetails = choice.message?.reasoning_details;
+                    if (Array.isArray(reasoningDetails)) {
+                        for (const d of reasoningDetails) {
+                            if (d.type === 'reasoning.summary') {
+                                summaryText = d.summary ?? d.text ?? summaryText;
+                            }
+                            if (d.type === 'reasoning.text') {
+                                // Append trace text (may be multiple chunks)
+                                traceText = traceText ? `${traceText}\n${d.text}` : d.text;
+                            }
+                            if (d.type === 'reasoning.encrypted') {
+                                encryptedArtifacts.push({
+                                    format: 'openai-responses-v1', // Format may vary by vendor, but we normalize
+                                    id: d.id,
+                                    index: d.index,
+                                    data: d.data ?? d.encrypted ?? d.text,
+                                });
+                            }
+                        }
+                    }
+                }
+                // IMPORTANT: Check if output array exists and contains Responses API format items
+                // Even in Chat Completions response, OpenRouter may include output array with reasoning artifacts
+                // This handles Responses API v1 format (openai-responses-v1, xai-responses-v1, etc.)
+                const outputArraySource = rawResponse?.output || execResult.rawMeta?.originalResponse?.output || originalResponse?.output;
+                if (Array.isArray(outputArraySource)) {
+                    for (const item of outputArraySource) {
+                        if (item.type === 'reasoning.encrypted') {
+                            encryptedArtifacts.push({
+                                format: rawResponse?.format || originalResponse?.format || 'openai-responses-v1',
+                                id: item.id,
+                                index: item.index,
+                                data: item.data,
+                            });
+                        }
+                        else if (item.type === 'reasoning.summary') {
+                            summaryText = item.summary ?? item.text ?? summaryText;
+                        }
+                        else if (item.type === 'reasoning.text') {
+                            // Append trace text (may be multiple chunks)
+                            traceText = traceText ? `${traceText}\n${item.text}` : item.text;
+                        }
+                    }
+                }
+                // Build reasoning response (ONLY source of truth)
+                const actualCapabilities = reasoningRequest?.capabilities || {
+                    supportsEffort: false,
+                    supportsMaxTokens: false,
+                    supportsSummary: false,
+                    supportsTrace: false,
+                    supportsEncrypted: false,
+                    supportsReasoningDetails: false,
+                };
+                reasoning = this.buildReasoningResponse(reasoningRequest ? { ...reasoningRequest, capabilities: actualCapabilities } : undefined, { encrypted: encryptedArtifacts, summaryText, traceText });
+            }
+            else {
+                // Fallback for unknown formats
+                console.log('[DEBUG] No choices found - using fallback reasoning response');
+                reasoning = this.buildReasoningResponse(reasoningRequest, { encrypted: [] });
+            }
+        }
+        // STRICT MODE: if caller asked to crash when trace is unavailable, enforce it.
+        // This covers the "provider returned no trace artifacts" case (not just capability gating).
+        // Note: buildReasoningResponse already checks this, but we add an additional safety check here
+        // to ensure we catch any edge cases where reasoning was built but artifacts are missing.
+        if (reasoningRequest?.requested?.visibility === 'trace' &&
+            reasoningRequest?.requested?.onUnsupported === 'error') {
+            const hasTraceArtifact = typeof reasoning?.artifacts?.trace === 'object' &&
+                typeof reasoning.artifacts.trace?.text === 'string' &&
+                reasoning.artifacts.trace.text.trim().length > 0;
+            const hasEncrypted = Array.isArray(reasoning?.artifacts?.encrypted) &&
+                reasoning.artifacts.encrypted.length > 0;
+            if (!hasTraceArtifact && !hasEncrypted) {
+                throw new Error("Reasoning request failed: trace was requested but no trace/encrypted reasoning artifacts were returned by provider");
+            }
+        }
+        // PRODUCTION-GRADE FIX: Final validation - ensure outputText is always set
+        // The unified extraction function should have found content, but if not, log detailed error
+        if (!outputText || outputText.trim() === '') {
+            console.error('[OpenRouterAdapter] CRITICAL: Failed to extract content from response', {
+                hasRawResponse: !!rawResponse,
+                rawResponseKeys: rawResponse ? Object.keys(rawResponse) : [],
+                hasChoices: !!(rawResponse?.choices || execResult.rawMeta?.originalResponse?.choices),
+                choicesLength: rawResponse?.choices?.length || execResult.rawMeta?.originalResponse?.choices?.length || 0,
+                hasOutputArray: !!(rawResponse?.output || execResult.rawMeta?.originalResponse?.output),
+                outputArrayLength: Array.isArray(rawResponse?.output) ? rawResponse.output.length :
+                    (Array.isArray(execResult.rawMeta?.originalResponse?.output) ?
+                        execResult.rawMeta.originalResponse.output.length : 0),
+                isResponsesAPIFormat,
+                selectedOutputArrayLength: outputArray.length,
+            });
+            // Set to empty string to ensure consistent response structure
+            outputText = '';
+        }
+        // #region agent log
+        console.log('[DEBUG] Before building response:', {
+            hasOutputText: !!outputText,
+            outputTextLength: outputText?.length || 0,
+            outputTextPreview: outputText?.substring(0, 50) || null,
+            hasUsage: !!usage,
+        });
+        fetch('http://127.0.0.1:7243/ingest/0d4596d8-b8fa-4ca1-a4f4-2e6f23baa429', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'OpenRouterAdapter.ts:870', message: 'Before building response', data: { hasOutputText: !!outputText, outputTextLength: outputText?.length || 0, outputTextPreview: outputText?.substring(0, 50) || null, hasUsage: !!usage }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run1', hypothesisId: 'E' }) }).catch(() => { });
+        // #endregion
+        // Add status and normalize response format for compatibility
+        // IMPORTANT: Preserve original output array if it exists (for reasoning artifacts)
+        // OpenRouter may return both choices (normalized) and output (original Responses API format)
+        // Use the same outputArray we determined during parsing (already has correct priority logic applied)
+        const responseWithStatus = {
+            ...rawResponse,
+            status: 'completed', // Responses are completed if they succeed
+            // Use the outputArray we selected during parsing (already has correct source priority)
+            // If outputArray is empty, reconstruct from choices for compatibility
+            output: outputArray.length > 0
+                ? outputArray // Use the output array we selected during parsing
+                : rawResponse?.choices ? rawResponse.choices.map((choice) => ({
+                    content: choice.message?.content ? { text: choice.message.content } : null,
+                    role: choice.message?.role,
+                    tool_calls: choice.message?.tool_calls,
+                })) : [],
+            // Also preserve format field if present
+            format: rawResponse?.format || (outputArray.length > 0 ? 'openai-responses-v1' : undefined),
+        };
+        // #region agent log
+        console.log('[DEBUG] responseWithStatus created:', {
+            finalOutputLength: Array.isArray(responseWithStatus.output) ? responseWithStatus.output.length : 'not-array',
+            finalFormat: responseWithStatus.format,
+            usedOutputArray: outputArray.length > 0,
+            outputArrayLength: outputArray.length,
+            finalOutputItems: Array.isArray(responseWithStatus.output) && responseWithStatus.output.length > 0
+                ? responseWithStatus.output.slice(0, 3).map((i) => ({ type: i?.type, keys: i ? Object.keys(i) : [] }))
+                : [],
+        });
+        // #endregion
+        // #region agent log
+        console.log('[DEBUG] responseWithStatus created:', {
+            finalOutputLength: Array.isArray(responseWithStatus.output) ? responseWithStatus.output.length : 'not-array',
+            finalFormat: responseWithStatus.format,
+            finalOutputItems: Array.isArray(responseWithStatus.output) && responseWithStatus.output.length > 0
+                ? responseWithStatus.output.slice(0, 3).map((i) => ({ type: i?.type, keys: i ? Object.keys(i) : [] }))
+                : [],
+        });
+        // #endregion
+        // #region agent log
+        console.log('[DEBUG] Returning response:', {
+            hasOutputText: !!outputText,
+            outputTextLength: outputText?.length || 0,
+            outputTextPreview: outputText?.substring(0, 50) || null,
+            hasUsage: !!usage,
+            hasReasoning: !!reasoning,
+            provider: 'openrouter',
+        });
+        fetch('http://127.0.0.1:7243/ingest/0d4596d8-b8fa-4ca1-a4f4-2e6f23baa429', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'OpenRouterAdapter.ts:940', message: 'Returning response', data: { hasOutputText: !!outputText, outputTextLength: outputText?.length || 0, outputTextPreview: outputText?.substring(0, 50) || null, hasUsage: !!usage, hasReasoning: !!reasoning, provider: 'openrouter' }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run1', hypothesisId: 'E' }) }).catch(() => { });
+        // #endregion
+        // Build complete response object for ai-activities storage
+        const fullResponse = {
+            requestId,
+            provider: 'openrouter',
+            rawResponse: responseWithStatus,
+            outputText,
+            usage,
+            reasoning,
+            metadata: {
+                model: rawResponse?.model,
+                id: rawResponse?.id,
+                format: rawResponse?.format,
+                ...execResult.rawMeta,
+            },
+        };
+        // Build metadata with ai-activities fields
+        // IMPORTANT: Create a clean copy of fullResponse without circular reference
+        // to avoid serialization issues when storing in metadata
+        const fullResponseForActivities = {
+            requestId: fullResponse.requestId,
+            provider: fullResponse.provider,
+            rawResponse: fullResponse.rawResponse,
+            outputText: fullResponse.outputText,
+            usage: fullResponse.usage,
+            reasoning: fullResponse.reasoning,
+            // Don't include metadata in the copy to avoid circular reference
+        };
+        const metadataWithActivities = {
+            ...fullResponse.metadata,
+            // Include full response in metadata for ai-activities storage (without circular ref)
+            'ai-activities-response': fullResponseForActivities,
+            // Include request for complete audit trail
+            'ai-activities-request': request,
+            // Also include original raw response and exec result for complete audit trail
+            'ai-activities-raw-response': rawResponse,
+            'ai-activities-original-response': originalResponse,
+            'ai-activities-exec-meta': execResult.rawMeta,
+        };
+        // #region agent log
+        const logDataA = { location: 'OpenRouterAdapter.ts:1091', message: 'Building response with ai-activities metadata', data: { hasFullResponse: !!fullResponse, hasRequest: !!request, hasRawResponse: !!rawResponse, metadataKeys: Object.keys(metadataWithActivities), hasAiActivitiesResponse: !!metadataWithActivities['ai-activities-response'], hasAiActivitiesRequest: !!metadataWithActivities['ai-activities-request'], aiActivitiesKeys: Object.keys(metadataWithActivities).filter(k => k.startsWith('ai-activities')), metadataSample: Object.keys(metadataWithActivities).slice(0, 10), metadataWithActivitiesKeys: Object.keys(metadataWithActivities) }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run1', hypothesisId: 'A' };
+        console.log('[DEBUG OpenRouterAdapter] Building ai-activities metadata:', JSON.stringify(logDataA, null, 2));
+        console.log('[DEBUG OpenRouterAdapter] Full metadata keys:', Object.keys(metadataWithActivities));
+        console.log('[DEBUG OpenRouterAdapter] ai-activities keys:', Object.keys(metadataWithActivities).filter(k => k.startsWith('ai-activities')));
+        console.log('[DEBUG OpenRouterAdapter] metadataWithActivities object:', JSON.stringify(metadataWithActivities, 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(logDataA) }).catch(() => { });
+        // #endregion
+        const finalResponse = {
+            ...fullResponse,
+            metadata: metadataWithActivities,
+        };
+        // #region agent log
+        const logDataB = { location: 'OpenRouterAdapter.ts:1125', message: 'Returning response from parseResponse', data: { hasMetadata: !!finalResponse.metadata, metadataKeys: finalResponse.metadata ? Object.keys(finalResponse.metadata) : [], hasAiActivitiesResponse: !!finalResponse.metadata?.['ai-activities-response'], hasAiActivitiesRequest: !!finalResponse.metadata?.['ai-activities-request'], responseKeys: Object.keys(finalResponse), metadataStringified: JSON.stringify(finalResponse.metadata) }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run1', hypothesisId: 'B' };
+        console.log('[DEBUG OpenRouterAdapter] Returning response:', JSON.stringify(logDataB, null, 2));
+        console.log('[DEBUG OpenRouterAdapter] Final response metadata:', JSON.stringify(finalResponse.metadata, null, 2));
+        console.log('[DEBUG OpenRouterAdapter] Final response metadata keys:', finalResponse.metadata ? Object.keys(finalResponse.metadata) : 'NO METADATA');
+        fetch('http://127.0.0.1:7243/ingest/0d4596d8-b8fa-4ca1-a4f4-2e6f23baa429', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(logDataB) }).catch(() => { });
+        // #endregion
+        return finalResponse;
+    }
+    /**
+     * Comprehensive content extraction function
+     * Tries all possible locations and formats to extract text content
+     * Returns the extracted text or undefined if not found
+     */
+    extractContentFromResponse(rawResponse, originalResponse, execResult, outputArray) {
+        // Strategy 1: Extract from Responses API format output array
+        if (outputArray && outputArray.length > 0) {
+            for (const item of outputArray) {
+                // Direct text item
+                if (item.type === 'text' && item.content) {
+                    if (typeof item.content === 'string' && item.content.trim()) {
+                        return item.content;
+                    }
+                }
+                // Message item with content array
+                if (item.type === 'message' && item.content) {
+                    if (Array.isArray(item.content)) {
+                        for (const contentItem of item.content) {
+                            // Text content items
+                            if (contentItem.type === 'text' && contentItem.text && typeof contentItem.text === 'string') {
+                                return contentItem.text;
+                            }
+                            if (contentItem.type === 'output_text' && contentItem.text && typeof contentItem.text === 'string') {
+                                return contentItem.text;
+                            }
+                            if (contentItem.type === 'text' && contentItem.content && typeof contentItem.content === 'string') {
+                                return contentItem.content;
+                            }
+                            // String content without type
+                            if (!contentItem.type && typeof contentItem === 'string' && contentItem.trim()) {
+                                return contentItem;
+                            }
+                            if (!contentItem.type && contentItem.text && typeof contentItem.text === 'string' && contentItem.text.trim()) {
+                                return contentItem.text;
+                            }
+                        }
+                    }
+                    else if (typeof item.content === 'string' && item.content.trim()) {
+                        return item.content;
+                    }
+                    else if (item.content && typeof item.content === 'object' && item.content.text && typeof item.content.text === 'string' && item.content.text.trim()) {
+                        return item.content.text;
+                    }
+                }
+            }
+        }
+        // Strategy 2: Extract from Chat Completions format choices
+        const choicesSources = [
+            rawResponse?.choices,
+            execResult.rawMeta?.originalResponse?.choices,
+            execResult.rawMeta?.rawResponse?.choices,
+            originalResponse?.choices,
+        ];
+        for (const choices of choicesSources) {
+            if (Array.isArray(choices) && choices.length > 0) {
+                for (const choice of choices) {
+                    if (choice.message) {
+                        const content = choice.message.content;
+                        // String content
+                        if (typeof content === 'string' && content.trim()) {
+                            return content;
+                        }
+                        // Array content (multimodal - extract text parts)
+                        if (Array.isArray(content)) {
+                            const textParts = [];
+                            for (const part of content) {
+                                if (typeof part === 'string' && part.trim()) {
+                                    textParts.push(part);
+                                }
+                                else if (part && typeof part === 'object') {
+                                    if (part.type === 'text' && part.text && typeof part.text === 'string' && part.text.trim()) {
+                                        textParts.push(part.text);
+                                    }
+                                    else if (part.text && typeof part.text === 'string' && part.text.trim()) {
+                                        textParts.push(part.text);
+                                    }
+                                }
+                            }
+                            if (textParts.length > 0) {
+                                return textParts.join('\n');
+                            }
+                        }
+                        // Object content (try to extract text)
+                        if (content && typeof content === 'object' && !Array.isArray(content)) {
+                            if (content.text && typeof content.text === 'string' && content.text.trim()) {
+                                return content.text;
+                            }
+                            // Try to stringify if it's a simple object
+                            try {
+                                const str = String(content);
+                                if (str && str !== '[object Object]' && str.trim()) {
+                                    return str;
+                                }
+                            }
+                            catch {
+                                // Ignore
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        // Strategy 3: Direct text fields
+        const textFields = [
+            rawResponse?.output_text,
+            rawResponse?.text,
+            execResult.rawMeta?.originalResponse?.output_text,
+            execResult.rawMeta?.originalResponse?.text,
+            originalResponse?.output_text,
+            originalResponse?.text,
+        ];
+        for (const text of textFields) {
+            if (typeof text === 'string' && text.trim()) {
+                return text;
+            }
+        }
+        // Strategy 4: Check rawResponse.output for text (non-array case)
+        if (rawResponse?.output && typeof rawResponse.output === 'string' && rawResponse.output.trim()) {
+            return rawResponse.output;
+        }
+        if (originalResponse?.output && typeof originalResponse.output === 'string' && originalResponse.output.trim()) {
+            return originalResponse.output;
+        }
+        return undefined;
+    }
+    /**
+     * Build unified reasoning response from request info and parsed artifacts
+     * Implements deterministic downgrade rules based on what was actually returned
+     * This is the ONLY source of truth for reasoning response structure
+     */
+    buildReasoningResponse(reasoningRequest, parsed) {
+        const { encrypted: encryptedArtifacts, summaryText, traceText } = parsed;
+        // Default values
+        const requested = reasoningRequest?.requested || { effort: 'none', visibility: 'none' };
+        const onUnsupported = reasoningRequest?.requested?.onUnsupported || 'downgrade';
+        const capabilities = reasoningRequest?.capabilities || {
+            supportsEffort: false,
+            supportsMaxTokens: false,
+            supportsSummary: false,
+            supportsTrace: false,
+            supportsEncrypted: false,
+            supportsReasoningDetails: false,
+        };
+        // Determine applied values, warnings, and errors
+        // Note: In parseResponse phase, errors should have already been handled in buildCallSpec
+        // But we still convert any remaining errors to warnings here for safety
+        const { applied, warnings, errors } = reasoningRequest
+            ? this.mapReasoningToProvider(reasoningRequest.requested, capabilities)
+            : { applied: { effort: 'none', visibility: 'none' }, warnings: [], errors: [] };
+        // In response parsing phase, convert any remaining errors to warnings (shouldn't happen if buildCallSpec worked correctly)
+        const allWarnings = [...warnings, ...errors.map(error => ({
+                code: error.code,
+                message: error.message
+            }))];
+        // Build artifacts based on what was actually returned
+        const artifacts = {};
+        if (encryptedArtifacts.length > 0) {
+            artifacts.encrypted = encryptedArtifacts;
+        }
+        if (summaryText) {
+            artifacts.summary = { text: summaryText, format: 'text/plain' };
+        }
+        if (traceText) {
+            artifacts.trace = { text: traceText, format: 'text/plain' };
+        }
+        // DETERMINISTIC DOWNGRADE RULES: Adjust applied visibility based on what was actually returned
+        const finalApplied = { ...applied };
+        // Determine availability flags based on what was actually returned
+        const supportsEncrypted = encryptedArtifacts.length > 0;
+        const supportsSummary = !!summaryText;
+        const supportsTrace = encryptedArtifacts.length > 0 || !!traceText; // Either encrypted OR text satisfies trace
+        // Apply visibility based on what was actually returned
+        if (requested.visibility === 'summary') {
+            if (summaryText) {
+                // Summary exists, use it
+                finalApplied.visibility = 'summary';
+            }
+            else {
+                // Summary requested but not returned
+                if (onUnsupported === 'error') {
+                    throw new Error('Reasoning visibility=summary was requested, but no summary was returned.');
+                }
+                finalApplied.visibility = 'none';
+                allWarnings.push({
+                    code: 'VISIBILITY_DOWNGRADED',
+                    message: 'Requested summary visibility but no summary returned, downgraded to none',
+                });
+            }
+        }
+        else if (requested.visibility === 'trace') {
+            // Trace visibility is satisfied by EITHER encrypted artifacts OR readable text
+            if (encryptedArtifacts.length > 0 || traceText) {
+                // Trace exists (encrypted or readable), use it
+                finalApplied.visibility = 'trace';
+            }
+            else {
+                // Trace requested but not returned
+                if (onUnsupported === 'error') {
+                    throw new Error('Reasoning visibility=trace was requested, but no trace was returned (no encrypted artifacts or trace text).');
+                }
+                finalApplied.visibility = 'none';
+                allWarnings.push({
+                    code: 'VISIBILITY_DOWNGRADED',
+                    message: 'Requested trace visibility but no trace returned (no encrypted artifacts or trace text), downgraded to none',
+                });
+            }
+        }
+        // Update capabilities based on what we actually found
+        const actualCapabilities = {
+            ...capabilities,
+            supportsEncrypted,
+            supportsSummary,
+            supportsTrace,
+        };
+        // Log reasoning summary
+        this.logReasoningSummary(requested, finalApplied, artifacts, allWarnings);
+        return {
+            requested,
+            applied: finalApplied,
+            artifacts,
+            availability: actualCapabilities,
+            warnings: allWarnings,
+        };
+    }
+    /**
+     * Log reasoning processing summary
+     */
+    logReasoningSummary(requested, applied, artifacts, warnings) {
+        // Only log if reasoning was actually requested
+        if (requested.effort !== 'none' || requested.visibility !== 'none') {
+            console.log('🧠 Reasoning Processing Summary:');
+            console.log(`   Requested: effort=${requested.effort}, visibility=${requested.visibility}`);
+            console.log(`   Applied: effort=${applied.effort}, visibility=${applied.visibility}`);
+            if (artifacts.encrypted && artifacts.encrypted.length > 0) {
+                console.log(`   📦 Encrypted artifacts: ${artifacts.encrypted.length} items`);
+                artifacts.encrypted.forEach((artifact, i) => {
+                    const dataLen = artifact.data ? (typeof artifact.data === 'string' ? artifact.data.length : JSON.stringify(artifact.data).length) : 0;
+                    const dataPrefix = artifact.data && typeof artifact.data === 'string'
+                        ? artifact.data.substring(0, Math.min(32, artifact.data.length))
+                        : 'N/A';
+                    console.log(`      [${i}] ${artifact.format} (id: ${artifact.id || 'N/A'}, dataLen=${dataLen}, dataPrefix="${dataPrefix}")`);
+                });
+            }
+            if (warnings && warnings.length > 0) {
+                console.log(`   ⚠️  Warnings: ${warnings.length}`);
+                warnings.forEach((warning) => {
+                    console.log(`      ${warning.code}: ${warning.message}`);
+                });
+            }
+            console.log(''); // Empty line for readability
+        }
+    }
+    parseStreamChunk(input) {
+        const { requestId, chunk } = input;
+        const raw = chunk.raw;
+        const events = [];
+        // Emit provider_raw event
+        events.push({
+            type: 'provider_raw',
+            requestId,
+            provider: 'openrouter',
+            raw,
+        });
+        // Handle OpenAI Responses API streaming format
+        if (raw?.format === 'openai-responses-v1' && Array.isArray(raw.output)) {
+            for (const item of raw.output) {
+                if (item.type === 'text' && item.content) {
+                    events.push({
+                        type: 'output_text_delta',
+                        requestId,
+                        delta: item.content,
+                    });
+                }
+                // reasoning.encrypted items are streamed but encrypted
+                // Could potentially emit reasoning_trace_delta for encrypted items if needed
+            }
+        }
+        // Parse traditional OpenAI Chat Completions stream chunk format
+        // OpenAI stream format: { choices: [{ delta: { content: "..." } }] }
+        else if (raw?.choices && Array.isArray(raw.choices)) {
+            for (const choice of raw.choices) {
+                if (choice.delta?.content) {
+                    events.push({
+                        type: 'output_text_delta',
+                        requestId,
+                        delta: choice.delta.content,
+                    });
+                }
+            }
+        }
+        return events;
+    }
+    finalizeStream(input) {
+        const { requestId, collected, finalRaw } = input;
+        // Use finalRaw if available, otherwise use last raw event
+        const rawResponse = finalRaw || (collected.rawEvents.length > 0 ? collected.rawEvents[collected.rawEvents.length - 1] : {});
+        // Try to extract usage from final response
+        let usage;
+        const finalResponse = rawResponse;
+        // Handle both formats for usage extraction
+        if (finalResponse?.usage) {
+            if (finalResponse.format === 'openai-responses-v1') {
+                usage = {
+                    inputTokens: finalResponse.usage.input_tokens,
+                    outputTokens: finalResponse.usage.output_tokens,
+                    totalTokens: finalResponse.usage.total_tokens,
+                };
+            }
+            else {
+                // Traditional Chat Completions format
+                usage = {
+                    inputTokens: finalResponse.usage.prompt_tokens,
+                    outputTokens: finalResponse.usage.completion_tokens,
+                    totalTokens: finalResponse.usage.total_tokens,
+                };
+            }
+        }
+        // For streaming finalize, we don't have access to original reasoning request
+        // Create a basic reasoning response based on available data
+        const encryptedArtifacts = [];
+        // Extract encrypted artifacts from final response if present
+        if (finalResponse?.format === 'openai-responses-v1' && Array.isArray(finalResponse.output)) {
+            for (const item of finalResponse.output) {
+                if (item.type === 'reasoning.encrypted') {
+                    encryptedArtifacts.push({
+                        format: 'openai-responses-v1',
+                        id: item.id,
+                        index: item.index,
+                        data: item.data,
+                    });
+                }
+            }
+        }
+        // Build basic reasoning response (request details not available in streaming finalize)
+        const reasoning = {
+            requested: { effort: 'none', visibility: 'none' },
+            applied: { effort: 'none', visibility: encryptedArtifacts.length > 0 ? 'trace' : 'none' },
+            artifacts: encryptedArtifacts.length > 0 ? { encrypted: encryptedArtifacts } : {},
+            availability: {
+                supportsEffort: false,
+                supportsSummary: false,
+                supportsTrace: false,
+                supportsEncrypted: encryptedArtifacts.length > 0,
+            },
+        };
+        // Build complete response object for ai-activities storage
+        const fullResponse = {
+            requestId,
+            provider: 'openrouter',
+            rawResponse,
+            outputText: collected.outputText,
+            usage,
+            reasoning,
+            metadata: {
+                model: finalResponse?.model,
+                id: finalResponse?.id,
+                format: finalResponse?.format, // Include format for debugging
+            },
+        };
+        // IMPORTANT: Create a clean copy of fullResponse without circular reference
+        const fullResponseForActivities = {
+            requestId: fullResponse.requestId,
+            provider: fullResponse.provider,
+            rawResponse: fullResponse.rawResponse,
+            outputText: fullResponse.outputText,
+            usage: fullResponse.usage,
+            reasoning: fullResponse.reasoning,
+            // Don't include metadata in the copy to avoid circular reference
+        };
+        return {
+            ...fullResponse,
+            metadata: {
+                ...fullResponse.metadata,
+                // Include full response in metadata for ai-activities storage (without circular ref)
+                'ai-activities-response': fullResponseForActivities,
+                // Include request for complete audit trail
+                'ai-activities-request': input.request,
+                'ai-activities-raw-response': rawResponse,
+                'ai-activities-collected-events': collected.rawEvents,
+            },
+        };
+    }
+    parseBatchItem(input) {
+        const { requestId, item } = input;
+        if (item.error) {
+            return {
+                requestId,
+                error: item.error,
+            };
+        }
+        // Parse OpenAI-compatible batch item response directly (no ai-io-normalizer)
+        const rawResponse = item.rawResponse;
+        let outputText;
+        if (rawResponse?.choices && Array.isArray(rawResponse.choices) && rawResponse.choices.length > 0) {
+            const firstChoice = rawResponse.choices[0];
+            if (firstChoice.message?.content) {
+                outputText = firstChoice.message.content;
+            }
+        }
+        return {
+            requestId,
+            rawResponse,
+            outputText,
+        };
+    }
+}