@x12i/ai-providers-router 4.6.0

package/dist/adapters/grok/GrokAdapter.js

@@ -0,0 +1,342 @@
+import { createXai } from '@ai-sdk/xai';
+// 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 {
+            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('[GrokAdapter] Failed to load response maps:', error.message);
+            return null;
+        }
+    }
+    return cachedResponseMaps;
+}
+/**
+ * Router-side adapter for Grok/xAI provider
+ * Converts router requests to ProviderSDKCallSpec and parses responses
+ */
+export class GrokAdapter {
+    constructor() {
+        this.provider = 'grok'; // Note: ProviderModule name might be 'grok' or 'xai', adapter handles both
+    }
+    async buildCallSpec(input) {
+        const { requestId, mode, request, exec } = input;
+        // Extract model from request
+        const model = request.model || request.config?.model || 'grok-2-1212';
+        // Determine operation (Grok provider uses xai.generateText/xai.streamText)
+        const operation = mode === 'stream' ? 'xai.streamText' : 'xai.generateText';
+        // Build args for ai package generateText/streamText
+        // These functions expect: { model: xai('model-name'), messages: [...] } or { model: xai('model-name'), prompt: '...' }
+        // Prefer messages format as shown in Grok provider README
+        // Create xAI provider instance with API key from environment
+        // The factory sets XAI_API_KEY before importing, so it should be available here
+        const apiKey = process.env.XAI_API_KEY;
+        if (!apiKey) {
+            throw new Error('XAI_API_KEY environment variable is not set. Ensure GROK_API_KEY is configured.');
+        }
+        const xaiProvider = createXai({ apiKey });
+        // Build args - prefer messages format if available
+        const args = {
+            model: xaiProvider(model),
+        };
+        // Handle different request formats
+        if (request.messages && Array.isArray(request.messages)) {
+            // Use messages directly (preferred format)
+            args.messages = request.messages.map((msg) => ({
+                role: msg.role || 'user',
+                content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
+            }));
+        }
+        else if (request.instructions || request.inputData) {
+            // Convert instructions/inputData to messages format
+            const messages = [];
+            if (request.instructions) {
+                messages.push({
+                    role: 'system',
+                    content: request.instructions,
+                });
+            }
+            if (request.inputData) {
+                const input = typeof request.inputData === 'string' ? request.inputData : JSON.stringify(request.inputData);
+                messages.push({
+                    role: 'user',
+                    content: input,
+                });
+            }
+            args.messages = messages;
+        }
+        else {
+            // Fallback: use prompt format
+            args.prompt = JSON.stringify(request);
+        }
+        // Add config parameters (ai package format)
+        if (request.config) {
+            if (request.config.maxTokens !== undefined) {
+                args.maxTokens = request.config.maxTokens;
+            }
+            if (request.config.temperature !== undefined) {
+                args.temperature = request.config.temperature;
+            }
+            if (request.config.topP !== undefined) {
+                args.topP = request.config.topP;
+            }
+            if (request.config.stop !== undefined) {
+                args.stop = request.config.stop;
+            }
+        }
+        return {
+            requestId,
+            provider: 'grok', // This should match ProviderModule.name
+            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;
+        // Use ai-io-normalizer for parsing (router stays orchestration-only)
+        // xAI/Grok uses 'xai.chat_completions' variant
+        let outputText;
+        let usage;
+        if (normalizerAvailable && normalizeProviderResponse) {
+            try {
+                const maps = getResponseMaps();
+                if (maps) {
+                    const normalized = normalizeProviderResponse(rawResponse, {
+                        provider: 'xai',
+                        apiVariant: 'xai.chat_completions',
+                        mode: 'standard',
+                        keepRawOverride: false,
+                    }, maps);
+                    if (normalized.choices && normalized.choices.length > 0) {
+                        outputText = normalized.choices[0].message?.content;
+                    }
+                    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 for ai package format if normalizer not available or failed
+        if (!outputText) {
+            if (rawResponse?.text) {
+                outputText = rawResponse.text;
+            }
+            else if (typeof rawResponse === 'string') {
+                outputText = rawResponse;
+            }
+        }
+        if (!usage && rawResponse?.usage) {
+            usage = {
+                inputTokens: rawResponse.usage.promptTokens || rawResponse.usage.input_tokens || rawResponse.usage.prompt_tokens,
+                outputTokens: rawResponse.usage.completionTokens || rawResponse.usage.output_tokens || rawResponse.usage.completion_tokens,
+                totalTokens: rawResponse.usage.totalTokens || rawResponse.usage.total_tokens,
+            };
+        }
+        // Build complete response object for ai-activities storage
+        const fullResponse = {
+            requestId,
+            provider: 'grok',
+            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 || input.request.config?.model,
+                finishReason: rawResponse?.finishReason,
+                ...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: 'grok',
+            raw,
+        });
+        // Parse ai package streamText format
+        // Stream format: { textDelta: "...", text: "...", finishReason: ... }
+        if (raw?.textDelta) {
+            events.push({
+                type: 'output_text_delta',
+                requestId,
+                delta: raw.textDelta,
+            });
+        }
+        else if (raw?.delta) {
+            // Alternative format
+            events.push({
+                type: 'output_text_delta',
+                requestId,
+                delta: raw.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: 'grok',
+            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 Grok batch item response using ai-io-normalizer
+        const rawResponse = item.rawResponse;
+        let outputText;
+        if (normalizerAvailable && normalizeProviderResponse) {
+            try {
+                const maps = getResponseMaps();
+                if (maps) {
+                    const normalized = normalizeProviderResponse(rawResponse, {
+                        provider: 'xai',
+                        apiVariant: 'xai.chat_completions',
+                        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 for ai package format if normalizer not available or failed
+        if (!outputText) {
+            if (rawResponse?.text) {
+                outputText = rawResponse.text;
+            }
+            else if (typeof rawResponse === 'string') {
+                outputText = rawResponse;
+            }
+        }
+        return {
+            requestId,
+            rawResponse,
+            outputText,
+        };
+    }
+}

package/dist/adapters/openai/OpenAIAdapter.d.ts

@@ -0,0 +1,50 @@
+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 OpenAI provider
+ * Converts router requests to ProviderSDKCallSpec and parses responses
+ */
+export declare class OpenAIAdapter implements RouterAdapter {
+    provider: string;
+    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;
+    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;
+    };
+}