@x12i/ai-providers-router 4.6.0

package/dist/adapters/openai/OpenAIAdapter.js

@@ -0,0 +1,401 @@
+// Import ai-io-normalizer functions
+// Note: Type declaration in src/types/ai-io-normalizer.d.ts allows this import
+import { normalizeProviderResponse, loadResponseMaps } from 'ai-io-normalizer/dist/response-normalizer.js';
+const normalizerAvailable = true;
+// Lazy-load response maps (loaded once, cached)
+let cachedResponseMaps = null;
+function getResponseMaps() {
+    if (!normalizerAvailable || !loadResponseMaps) {
+        return null;
+    }
+    if (!cachedResponseMaps) {
+        try {
+            // Load registry - ai-io-normalizer has built-in response maps
+            const registry = {
+                schemaVersion: '1.0.0',
+                standard: 'chat_completions_like_v1',
+                providers: {
+                    openai: { ref: 'openai' },
+                    xai: { ref: 'xai' },
+                    groq: { ref: 'groq' },
+                    anthropic: { ref: 'anthropic' },
+                    google: { ref: 'google' },
+                    moonshot: { ref: 'moonshot' },
+                },
+            };
+            cachedResponseMaps = loadResponseMaps(registry);
+        }
+        catch (error) {
+            console.warn('[OpenAIAdapter] Failed to load response maps:', error.message);
+            return null;
+        }
+    }
+    return cachedResponseMaps;
+}
+/**
+ * Extract output text using ai-io-normalizer's normalizeProviderResponse
+ * This uses the same parsing logic as ai-io-normalizer adapters
+ */
+function extractOutputTextUsingNormalizer(raw, provider, apiVariant) {
+    if (!raw)
+        return undefined;
+    // Try to use ai-io-normalizer if available
+    if (normalizerAvailable && normalizeProviderResponse) {
+        try {
+            const maps = getResponseMaps();
+            if (maps) {
+                const normalized = normalizeProviderResponse(raw, {
+                    provider,
+                    apiVariant,
+                    mode: 'standard',
+                    keepRawOverride: false,
+                }, maps);
+                // Extract text from normalized response
+                if (normalized.choices && normalized.choices.length > 0) {
+                    const firstChoice = normalized.choices[0];
+                    if (firstChoice.message?.content) {
+                        return firstChoice.message.content;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // Fallback to manual extraction if normalizer fails
+            console.warn('[OpenAIAdapter] Failed to use ai-io-normalizer, falling back to manual extraction:', error.message);
+        }
+    }
+    // Fallback: manual extraction (same logic as before)
+    if (typeof raw.output_text === 'string' && raw.output_text.trim()) {
+        return raw.output_text;
+    }
+    const out = raw.output;
+    if (!Array.isArray(out) || out.length === 0)
+        return undefined;
+    const parts = [];
+    for (const item of out) {
+        const content = item?.content;
+        if (Array.isArray(content)) {
+            for (const c of content) {
+                if (typeof c?.text === 'string') {
+                    parts.push(c.text);
+                }
+                else if (typeof c?.text?.value === 'string') {
+                    parts.push(c.text.value);
+                }
+                else if (typeof c?.value === 'string') {
+                    parts.push(c.value);
+                }
+            }
+        }
+        else if (content && typeof content === 'object') {
+            if (typeof content.text === 'string') {
+                parts.push(content.text);
+            }
+            else if (typeof content.text?.value === 'string') {
+                parts.push(content.text.value);
+            }
+        }
+        if (typeof item?.text === 'string') {
+            parts.push(item.text);
+        }
+    }
+    const joined = parts.join('');
+    return joined.trim() ? joined : undefined;
+}
+/**
+ * Router-side adapter for OpenAI provider
+ * Converts router requests to ProviderSDKCallSpec and parses responses
+ */
+export class OpenAIAdapter {
+    constructor() {
+        this.provider = 'openai';
+    }
+    async buildCallSpec(input) {
+        const { requestId, mode, request, exec } = input;
+        // Extract model from request (could be in request.model or request.config.model)
+        const model = request.model || request.config?.model || 'gpt-4o-mini';
+        // Determine operation based on mode
+        const operation = mode === 'stream' ? 'openai.responses.stream' : 'openai.responses.create';
+        // Build OpenAI Responses API args
+        // OpenAI Responses API expects: { model, input: string | { input_text: string, ... } }
+        let inputValue;
+        // Handle different request formats
+        if (typeof request.inputData === 'string') {
+            // Simple string input
+            inputValue = request.inputData;
+        }
+        else if (request.inputData) {
+            // Structured input
+            inputValue = { input_text: String(request.inputData) };
+        }
+        else if (request.messages) {
+            // Convert messages to input_text
+            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 (request.instructions) {
+            // Use instructions as input
+            inputValue = request.instructions;
+        }
+        else {
+            // Fallback: stringify the request
+            inputValue = JSON.stringify(request);
+        }
+        // Build args for OpenAI Responses API
+        const args = {
+            model,
+            input: inputValue,
+        };
+        // Add config parameters
+        if (request.config) {
+            if (request.config.maxTokens !== undefined) {
+                args.max_output_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;
+            }
+        }
+        return {
+            requestId,
+            provider: 'openai',
+            mode,
+            operation,
+            args,
+            exec: exec ? {
+                timeoutMs: exec.timeoutMs,
+                retries: exec.retries,
+                idempotencyKey: exec.idempotencyKey,
+                signal: exec.signal,
+            } : undefined,
+        };
+    }
+    parseResponse(input) {
+        const { requestId, execResult } = input;
+        const rawResponse = execResult.rawResponse;
+        // Determine API variant from operation or request
+        // OpenAI provider uses 'openai.responses.create' or 'openai.responses.stream' for Responses API
+        // or 'openai.chat.completions.create' for Chat Completions API
+        const operation = execResult.rawMeta?.operation;
+        const apiVariant = operation?.includes('responses') ? 'openai.responses' : 'openai.chat_completions';
+        // Use ai-io-normalizer for parsing (router stays orchestration-only)
+        const outputText = extractOutputTextUsingNormalizer(rawResponse, 'openai', apiVariant);
+        // Extract usage using ai-io-normalizer if possible, otherwise manual extraction
+        let usage;
+        if (normalizerAvailable && normalizeProviderResponse) {
+            try {
+                const maps = getResponseMaps();
+                if (maps) {
+                    const normalized = normalizeProviderResponse(rawResponse, {
+                        provider: 'openai',
+                        apiVariant,
+                        mode: 'standard',
+                        keepRawOverride: false,
+                    }, maps);
+                    if (normalized.usage) {
+                        usage = {
+                            inputTokens: normalized.usage.prompt_tokens,
+                            outputTokens: normalized.usage.completion_tokens,
+                            totalTokens: normalized.usage.total_tokens,
+                        };
+                    }
+                }
+            }
+            catch (error) {
+                // Fallback to manual extraction
+            }
+        }
+        // Fallback to manual extraction if normalizer not available or failed
+        if (!usage && rawResponse?.usage) {
+            usage = {
+                inputTokens: rawResponse.usage.input_tokens || rawResponse.usage.prompt_tokens,
+                outputTokens: rawResponse.usage.output_tokens || rawResponse.usage.completion_tokens,
+                totalTokens: rawResponse.usage.total_tokens,
+            };
+        }
+        // Build complete response object for ai-activities storage
+        const fullResponse = {
+            requestId,
+            provider: 'openai',
+            rawResponse,
+            outputText,
+            usage,
+            reasoning: {
+                requested: { effort: 'none', visibility: 'none' },
+                applied: { effort: 'none', visibility: 'none' },
+                artifacts: {},
+                availability: {
+                    supportsEffort: false,
+                    supportsSummary: false,
+                    supportsTrace: false,
+                    supportsEncrypted: false,
+                },
+            },
+            metadata: {
+                model: rawResponse?.model,
+                id: rawResponse?.id,
+                status: rawResponse?.status,
+                ...execResult.rawMeta,
+            },
+        };
+        // 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-exec-meta': execResult.rawMeta,
+            },
+        };
+    }
+    parseStreamChunk(input) {
+        const { requestId, chunk } = input;
+        const raw = chunk.raw;
+        const events = [];
+        // Emit provider_raw event
+        events.push({
+            type: 'provider_raw',
+            requestId,
+            provider: 'openai',
+            raw,
+        });
+        // Parse OpenAI stream chunk format
+        // OpenAI Responses API stream format: { output: [{ content: { text_delta: "..." } }] }
+        if (raw?.output && Array.isArray(raw.output)) {
+            for (const output of raw.output) {
+                if (output.content?.text_delta) {
+                    events.push({
+                        type: 'output_text_delta',
+                        requestId,
+                        delta: output.content.text_delta,
+                    });
+                }
+            }
+        }
+        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] : {});
+        // Build complete response object for ai-activities storage
+        const fullResponse = {
+            requestId,
+            provider: 'openai',
+            rawResponse,
+            outputText: collected.outputText,
+            reasoning: {
+                requested: { effort: 'none', visibility: 'none' },
+                applied: { effort: 'none', visibility: 'none' },
+                artifacts: {},
+                availability: {
+                    supportsEffort: false,
+                    supportsSummary: false,
+                    supportsTrace: false,
+                    supportsEncrypted: false,
+                },
+            },
+            metadata: {},
+        };
+        // IMPORTANT: Create a clean copy of fullResponse without circular reference
+        const fullResponseForActivities = {
+            requestId: fullResponse.requestId,
+            provider: fullResponse.provider,
+            rawResponse: fullResponse.rawResponse,
+            outputText: fullResponse.outputText,
+            reasoning: fullResponse.reasoning,
+            // Don't include metadata in the copy to avoid circular reference
+        };
+        // Add usage if available (may not be present in streaming responses)
+        if ('usage' in fullResponse && fullResponse.usage) {
+            fullResponseForActivities.usage = fullResponse.usage;
+        }
+        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 batch item response using ai-io-normalizer
+        const rawResponse = item.rawResponse;
+        let outputText;
+        if (normalizerAvailable && normalizeProviderResponse) {
+            try {
+                const maps = getResponseMaps();
+                if (maps) {
+                    // Default to responses API for batch (most common)
+                    const apiVariant = 'openai.responses';
+                    const normalized = normalizeProviderResponse(rawResponse, {
+                        provider: 'openai',
+                        apiVariant,
+                        mode: 'batch',
+                        keepRawOverride: false,
+                    }, maps);
+                    if (normalized.choices && normalized.choices.length > 0) {
+                        outputText = normalized.choices[0].message?.content;
+                    }
+                }
+            }
+            catch (error) {
+                // Fallback to manual extraction
+            }
+        }
+        // Fallback to manual extraction if normalizer not available or failed
+        if (!outputText && rawResponse?.output && Array.isArray(rawResponse.output) && rawResponse.output.length > 0) {
+            const firstOutput = rawResponse.output[0];
+            if (firstOutput.content?.text) {
+                outputText = firstOutput.content.text;
+            }
+        }
+        return {
+            requestId,
+            rawResponse,
+            outputText,
+        };
+    }
+}

package/dist/adapters/openrouter/OpenRouterAdapter.d.ts

@@ -0,0 +1,87 @@
+import type { ProviderSDKCallSpec, ProviderSDKExecResult, ProviderSDKStreamChunk, ProviderBatchResults } from '@x12i/ai-provider-interface';
+import type { RouterAdapter } from '../../registry/AdapterRegistry.js';
+import type { AIResponse, AIStreamEvent } from '../../router/RouterTypes.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 declare class OpenRouterAdapter implements RouterAdapter {
+    provider: string;
+    /**
+     * Normalize model name for OpenRouter using catalog data
+     * Uses the catalog to properly map provider + model to OpenRouter format
+     */
+    private normalizeModelName;
+    /**
+     * Map provider name to OpenRouter model prefix (legacy fallback)
+     */
+    private getProviderPrefix;
+    /**
+     * Get reasoning capabilities for a model
+     * Uses JSON registry for cross-vendor support detection
+     */
+    private getReasoningCapabilities;
+    /**
+     * 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
+     */
+    private mapReasoningToProvider;
+    buildCallSpec(input: {
+        requestId: string;
+        mode: 'sync' | 'stream';
+        request: any;
+        exec?: {
+            timeoutMs?: number;
+            retries?: number;
+            idempotencyKey?: string;
+            signal?: AbortSignal;
+        };
+    }): Promise<ProviderSDKCallSpec>;
+    parseResponse(input: {
+        requestId: string;
+        request: any;
+        execResult: ProviderSDKExecResult;
+    }): AIResponse;
+    /**
+     * Comprehensive content extraction function
+     * Tries all possible locations and formats to extract text content
+     * Returns the extracted text or undefined if not found
+     */
+    private extractContentFromResponse;
+    /**
+     * 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
+     */
+    private buildReasoningResponse;
+    /**
+     * Log reasoning processing summary
+     */
+    private logReasoningSummary;
+    parseStreamChunk(input: {
+        requestId: string;
+        request: any;
+        chunk: ProviderSDKStreamChunk;
+    }): AIStreamEvent[];
+    finalizeStream(input: {
+        requestId: string;
+        request: any;
+        collected: {
+            rawEvents: unknown[];
+            outputText?: string;
+        };
+        finalRaw?: unknown;
+    }): AIResponse;
+    parseBatchItem(input: {
+        requestId: string;
+        request: any;
+        item: ProviderBatchResults['items'][number];
+    }): {
+        requestId: string;
+        rawResponse?: unknown;
+        outputText?: string;
+        error?: any;
+    };
+}