@juspay/neurolink 9.30.0 → 9.31.1

package/dist/client/providers/openRouter.js

@@ -0,0 +1,543 @@
+import { createOpenRouter } from "@openrouter/ai-sdk-provider";
+import { NoOutputGeneratedError, Output, streamText, } from "ai";
+import { AIProviderName } from "../constants/enums.js";
+import { BaseProvider } from "../core/baseProvider.js";
+import { DEFAULT_MAX_STEPS } from "../core/constants.js";
+import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
+import { createProxyFetch } from "../proxy/proxyFetch.js";
+import { isAbortError } from "../utils/errorHandling.js";
+import { logger } from "../utils/logger.js";
+import { getProviderModel } from "../utils/providerConfig.js";
+import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
+// Constants
+const MODELS_DISCOVERY_TIMEOUT_MS = 5000; // 5 seconds for model discovery
+// Configuration helpers
+const getOpenRouterConfig = () => {
+    const apiKey = process.env.OPENROUTER_API_KEY;
+    if (!apiKey) {
+        throw new Error("OPENROUTER_API_KEY environment variable is required. " +
+            "Get your API key at https://openrouter.ai/keys");
+    }
+    return {
+        apiKey,
+        referer: process.env.OPENROUTER_REFERER,
+        appName: process.env.OPENROUTER_APP_NAME,
+    };
+};
+/**
+ * Returns the default model name for OpenRouter.
+ *
+ * OpenRouter uses a 'provider/model' format for model names.
+ * For example:
+ *   - 'anthropic/claude-3-5-sonnet'
+ *   - 'openai/gpt-4o'
+ *   - 'google/gemini-2.0-flash'
+ *   - 'meta-llama/llama-3-70b-instruct'
+ *
+ * You can override the default by setting the OPENROUTER_MODEL environment variable.
+ */
+const getDefaultOpenRouterModel = () => {
+    return getProviderModel("OPENROUTER_MODEL", "anthropic/claude-3-5-sonnet");
+};
+/**
+ * OpenRouter Provider - BaseProvider Implementation
+ * Provides access to 300+ models from 60+ providers via OpenRouter unified gateway
+ */
+export class OpenRouterProvider extends BaseProvider {
+    model;
+    openRouterClient;
+    // Cache for available models to avoid repeated API calls
+    static modelsCache = [];
+    static modelsCacheTime = 0;
+    static MODELS_CACHE_DURATION = 10 * 60 * 1000; // 10 minutes
+    // Cache for model capabilities (which models support tools)
+    static toolCapableModels = new Set();
+    static capabilitiesCached = false;
+    constructor(modelName, sdk) {
+        super(modelName, AIProviderName.OPENROUTER, sdk);
+        // Initialize OpenRouter using the official SDK
+        const config = getOpenRouterConfig();
+        // Build headers for attribution on openrouter.ai/activity dashboard
+        const headers = {};
+        if (config.referer) {
+            headers["HTTP-Referer"] = config.referer;
+        }
+        if (config.appName) {
+            headers["X-Title"] = config.appName;
+        }
+        // Create OpenRouter client with optional attribution headers
+        this.openRouterClient = createOpenRouter({
+            apiKey: config.apiKey,
+            ...(Object.keys(headers).length > 0 && { headers }),
+        });
+        // Initialize model with OpenRouter client
+        // OpenRouterChatLanguageModel implements LanguageModelV3 which is part of the LanguageModel union
+        this.model = this.openRouterClient(this.modelName || getDefaultOpenRouterModel());
+        logger.debug("OpenRouter Provider initialized", {
+            modelName: this.modelName,
+            provider: this.providerName,
+        });
+    }
+    getProviderName() {
+        return AIProviderName.OPENROUTER;
+    }
+    getDefaultModel() {
+        return getDefaultOpenRouterModel();
+    }
+    /**
+     * Returns the Vercel AI SDK model instance for OpenRouter
+     */
+    getAISDKModel() {
+        return this.model;
+    }
+    formatProviderError(error) {
+        if (error instanceof TimeoutError) {
+            return new Error(`OpenRouter request timed out: ${error.message}`);
+        }
+        // Check for timeout by error name and message as fallback
+        const errorRecord = error;
+        if (errorRecord?.name === "TimeoutError" ||
+            (typeof errorRecord?.message === "string" &&
+                errorRecord.message.includes("Timeout"))) {
+            return new Error(`OpenRouter request timed out: ${errorRecord?.message || "Unknown timeout"}`);
+        }
+        if (typeof errorRecord?.message === "string") {
+            if (errorRecord.message.includes("ECONNREFUSED") ||
+                errorRecord.message.includes("Failed to fetch")) {
+                return new Error("OpenRouter API not available. Please check your network connection and try again.");
+            }
+            if (errorRecord.message.includes("API_KEY_INVALID") ||
+                errorRecord.message.includes("Invalid API key") ||
+                errorRecord.message.includes("invalid_api_key") ||
+                errorRecord.message.includes("Unauthorized")) {
+                return new Error("Invalid OpenRouter API key. Please check your OPENROUTER_API_KEY environment variable. " +
+                    "Get your key at https://openrouter.ai/keys");
+            }
+            if (errorRecord.message.includes("rate limit")) {
+                return new Error("OpenRouter rate limit exceeded. Please try again later or upgrade your account at https://openrouter.ai/credits");
+            }
+            if (errorRecord.message.includes("model") &&
+                errorRecord.message.includes("not found")) {
+                return new Error(`Model '${this.modelName}' not available on OpenRouter. ` +
+                    "Browse available models at https://openrouter.ai/models");
+            }
+            if (errorRecord.message.includes("insufficient_credits")) {
+                return new Error("Insufficient OpenRouter credits. Add credits at https://openrouter.ai/credits");
+            }
+            // "No endpoints found" — model temporarily unavailable or unsupported parameters
+            // This is distinct from tool errors: it can happen on any request when the
+            // model has no available providers on OpenRouter (e.g., free-tier model down).
+            if (errorRecord.message.includes("No endpoints found")) {
+                return new Error(`No endpoints found for model '${this.modelName}' on OpenRouter. ` +
+                    "The model may be temporarily unavailable or does not support the requested parameters. " +
+                    "Try a different model or check availability at https://openrouter.ai/models");
+            }
+            // Tool/function calling errors
+            if (errorRecord.message.includes("tool use") ||
+                errorRecord.message.includes("tool_use") ||
+                errorRecord.message.includes("function_call") ||
+                errorRecord.message.includes("tools are not supported")) {
+                return new Error(`Model '${this.modelName}' does not support tool calling. ` +
+                    "Use a tool-capable model like:\n" +
+                    "  • google/gemini-2.0-flash-exp:free (free)\n" +
+                    "  • meta-llama/llama-3.3-70b-instruct:free (free)\n" +
+                    "  • anthropic/claude-3-5-sonnet (paid)\n" +
+                    "  • openai/gpt-4o (paid)\n" +
+                    "Or use --disableTools flag. " +
+                    "See all tool-capable models at https://openrouter.ai/models?supported_parameters=tools");
+            }
+        }
+        return new Error(`OpenRouter error: ${errorRecord?.message || "Unknown error"}`);
+    }
+    /**
+     * OpenRouter supports tools for compatible models
+     * Checks cached model capabilities or uses known patterns as fallback
+     */
+    supportsTools() {
+        const modelName = this.modelName || getDefaultOpenRouterModel();
+        // If we have cached capabilities, use them
+        if (OpenRouterProvider.capabilitiesCached) {
+            const supported = OpenRouterProvider.toolCapableModels.has(modelName);
+            logger.debug("OpenRouter: Tool support check (cached)", {
+                model: modelName,
+                supportsTools: supported,
+            });
+            return supported;
+        }
+        // Fallback: Known tool-capable model patterns (conservative list)
+        const knownToolCapablePatterns = [
+            "anthropic/claude",
+            "openai/gpt-4",
+            "openai/gpt-3.5",
+            "openai/o1",
+            "openai/o3",
+            "openai/o4",
+            "google/gemini",
+            "google/gemma-3",
+            "mistralai/mistral-large",
+            "mistralai/mistral-small",
+            "mistralai/devstral",
+            "meta-llama/llama-3.3",
+            "meta-llama/llama-3.2",
+            "qwen/qwen3",
+            "nvidia/nemotron",
+        ];
+        const isKnownCapable = knownToolCapablePatterns.some((pattern) => modelName.toLowerCase().includes(pattern.toLowerCase()));
+        if (isKnownCapable) {
+            logger.debug("OpenRouter: Tool support enabled (pattern match)", {
+                model: modelName,
+            });
+            return true;
+        }
+        // For unknown models, warn and disable tools (safe default)
+        logger.warn("OpenRouter: Unknown model tool capability, disabling tools", {
+            model: modelName,
+            suggestion: "Use a known tool-capable model like anthropic/claude-3-5-sonnet, openai/gpt-4o, or google/gemini-2.0-flash-exp:free",
+        });
+        return false;
+    }
+    /**
+     * Provider-specific streaming implementation
+     * Note: This is only used when tools are disabled
+     */
+    async executeStream(options, analysisSchema) {
+        this.validateStreamOptions(options);
+        const startTime = Date.now();
+        let chunkCount = 0; // Track chunk count for debugging
+        const timeout = this.getTimeout(options);
+        const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
+        try {
+            // Build message array from options with multimodal support
+            // Using protected helper from BaseProvider to eliminate code duplication
+            const messages = await this.buildMessagesForStream(options);
+            const model = await this.getAISDKModelWithMiddleware(options);
+            // Get all available tools (direct + MCP + external) for streaming
+            // BaseProvider.stream() pre-merges base tools + external tools into options.tools
+            const shouldUseTools = !options.disableTools && this.supportsTools();
+            const tools = shouldUseTools
+                ? options.tools || (await this.getAllTools())
+                : {};
+            logger.debug(`OpenRouter: Tools for streaming`, {
+                shouldUseTools,
+                toolCount: Object.keys(tools).length,
+                toolNames: Object.keys(tools),
+            });
+            // Build complete stream options with proper typing
+            // Note: maxRetries set to 0 for OpenRouter free tier to prevent SDK's quick retries
+            // from consuming rate limits. Our test suite handles retries with appropriate delays.
+            let streamOptions = {
+                model: model,
+                messages: messages,
+                temperature: options.temperature,
+                maxRetries: 0, // Disable SDK retries - let caller handle rate limit retries with delays
+                ...(options.maxTokens && { maxTokens: options.maxTokens }),
+                ...(shouldUseTools &&
+                    Object.keys(tools).length > 0 && {
+                    tools,
+                    toolChoice: "auto",
+                    maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
+                }),
+                abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
+                experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
+                onError: (event) => {
+                    const error = event.error;
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    logger.error(`OpenRouter: Stream error`, {
+                        provider: this.providerName,
+                        modelName: this.modelName,
+                        error: errorMessage,
+                        chunkCount,
+                    });
+                },
+                onFinish: (event) => {
+                    logger.debug(`OpenRouter: Stream finished`, {
+                        finishReason: event.finishReason,
+                        totalChunks: chunkCount,
+                    });
+                },
+                onChunk: () => {
+                    chunkCount++;
+                },
+                onStepFinish: ({ toolCalls, toolResults }) => {
+                    logger.info("Tool execution completed", {
+                        toolCallCount: toolCalls?.length || 0,
+                        toolResultCount: toolResults?.length || 0,
+                        toolNames: toolCalls?.map((tc) => tc.toolName),
+                    });
+                    this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {
+                        logger.warn("OpenRouterProvider: Failed to store tool executions", {
+                            provider: this.providerName,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    });
+                },
+            };
+            // Add analysisSchema support if provided
+            if (analysisSchema) {
+                try {
+                    streamOptions = {
+                        ...streamOptions,
+                        experimental_output: Output.object({
+                            schema: analysisSchema,
+                        }),
+                    };
+                }
+                catch (error) {
+                    logger.warn("Schema application failed, continuing without schema", {
+                        error: String(error),
+                    });
+                }
+            }
+            const result = await streamText(streamOptions);
+            // Guard against NoOutputGeneratedError becoming an unhandled rejection.
+            Promise.resolve(result.text)
+                .catch((err) => {
+                logger.debug("Stream text promise rejected (expected for empty streams)", {
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            })
+                .finally(() => timeoutController?.cleanup());
+            // Transform stream to content object stream using fullStream (handles both text and tool calls)
+            const transformedStream = (async function* () {
+                try {
+                    // Try fullStream first (handles both text and tool calls), fallback to textStream
+                    const streamToUse = result.fullStream || result.textStream;
+                    for await (const chunk of streamToUse) {
+                        // Handle different chunk types from fullStream
+                        if (chunk && typeof chunk === "object") {
+                            // Check for error chunks first (critical error handling)
+                            if ("type" in chunk && chunk.type === "error") {
+                                const errorChunk = chunk;
+                                logger.error(`OpenRouter: Error chunk received:`, {
+                                    errorType: errorChunk.type,
+                                    errorDetails: errorChunk.error,
+                                });
+                                throw new Error(`OpenRouter streaming error: ${errorChunk.error?.message ||
+                                    "Unknown error"}`);
+                            }
+                            if ("textDelta" in chunk) {
+                                // Text delta from fullStream
+                                const textDelta = chunk.textDelta;
+                                if (textDelta) {
+                                    yield { content: textDelta };
+                                }
+                            }
+                            else if ("type" in chunk &&
+                                chunk.type === "tool-call" &&
+                                "toolCallId" in chunk) {
+                                // Tool call event - log for debugging
+                                const toolCallId = String(chunk.toolCallId);
+                                const toolName = "toolName" in chunk ? String(chunk.toolName) : "unknown";
+                                logger.debug("OpenRouter: Tool call", {
+                                    toolCallId,
+                                    toolName,
+                                });
+                            }
+                        }
+                        else if (typeof chunk === "string") {
+                            // Direct string chunk from textStream fallback
+                            yield { content: chunk };
+                        }
+                    }
+                }
+                catch (streamError) {
+                    // AI SDK v6 throws NoOutputGeneratedError when the stream produced no output.
+                    if (NoOutputGeneratedError.isInstance(streamError)) {
+                        logger.warn("OpenRouter: Stream produced no output (NoOutputGeneratedError)");
+                        return;
+                    }
+                    throw streamError;
+                }
+            })();
+            // Create analytics promise that resolves after stream completion
+            const analyticsPromise = streamAnalyticsCollector.createAnalytics(this.providerName, this.modelName, result, Date.now() - startTime, {
+                requestId: `openrouter-stream-${Date.now()}`,
+                streamingMode: true,
+            });
+            return {
+                stream: transformedStream,
+                provider: this.providerName,
+                model: this.modelName,
+                analytics: analyticsPromise,
+                metadata: {
+                    startTime,
+                    streamId: `openrouter-${Date.now()}`,
+                },
+            };
+        }
+        catch (error) {
+            timeoutController?.cleanup();
+            throw this.handleProviderError(error);
+        }
+    }
+    /**
+     * Get available models from OpenRouter API
+     * Dynamically fetches from /api/v1/models endpoint with caching and fallback
+     */
+    async getAvailableModels() {
+        const functionTag = "OpenRouterProvider.getAvailableModels";
+        const now = Date.now();
+        // Check if cached models are still valid
+        if (OpenRouterProvider.modelsCache.length > 0 &&
+            now - OpenRouterProvider.modelsCacheTime <
+                OpenRouterProvider.MODELS_CACHE_DURATION) {
+            logger.debug(`[${functionTag}] Using cached models`, {
+                cacheAge: Math.round((now - OpenRouterProvider.modelsCacheTime) / 1000),
+                modelCount: OpenRouterProvider.modelsCache.length,
+            });
+            return OpenRouterProvider.modelsCache;
+        }
+        // Try to fetch models dynamically
+        try {
+            const dynamicModels = await this.fetchModelsFromAPI();
+            if (dynamicModels.length > 0) {
+                // Cache successful result
+                OpenRouterProvider.modelsCache = dynamicModels;
+                OpenRouterProvider.modelsCacheTime = now;
+                logger.debug(`[${functionTag}] Successfully fetched models from API`, {
+                    modelCount: dynamicModels.length,
+                });
+                return dynamicModels;
+            }
+        }
+        catch (error) {
+            logger.warn(`[${functionTag}] Failed to fetch models from API, using fallback`, {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+        // Fallback to hardcoded list if API fetch fails
+        const fallbackModels = [
+            // Anthropic Claude models
+            "anthropic/claude-3-5-sonnet",
+            "anthropic/claude-3-5-haiku",
+            "anthropic/claude-3-opus",
+            // OpenAI models
+            "openai/gpt-4o",
+            "openai/gpt-4o-mini",
+            "openai/gpt-4-turbo",
+            // Google models
+            "google/gemini-2.0-flash",
+            "google/gemini-1.5-pro",
+            // Meta Llama models
+            "meta-llama/llama-3.1-70b-instruct",
+            "meta-llama/llama-3.1-8b-instruct",
+            // Mistral models
+            "mistralai/mistral-large",
+            "mistralai/mixtral-8x7b-instruct",
+        ];
+        logger.debug(`[${functionTag}] Using fallback model list`, {
+            modelCount: fallbackModels.length,
+        });
+        return fallbackModels;
+    }
+    /**
+     * Fetch available models from OpenRouter API /api/v1/models endpoint
+     * @private
+     */
+    async fetchModelsFromAPI() {
+        const functionTag = "OpenRouterProvider.fetchModelsFromAPI";
+        const config = getOpenRouterConfig();
+        const modelsUrl = "https://openrouter.ai/api/v1/models";
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), MODELS_DISCOVERY_TIMEOUT_MS);
+        try {
+            logger.debug(`[${functionTag}] Fetching models from ${modelsUrl}`);
+            const proxyFetch = createProxyFetch();
+            const response = await proxyFetch(modelsUrl, {
+                method: "GET",
+                headers: {
+                    Authorization: `Bearer ${config.apiKey}`,
+                    "Content-Type": "application/json",
+                },
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            const data = await response.json();
+            // Parse OpenRouter models response with type guard
+            if (!this.isValidModelsResponse(data)) {
+                throw new Error("Invalid response format: expected data.data array");
+            }
+            const models = data.data
+                .map((model) => model.id)
+                .filter((id) => typeof id === "string" && id.length > 0)
+                .sort();
+            logger.debug(`[${functionTag}] Successfully parsed models`, {
+                totalModels: models.length,
+                sampleModels: models.slice(0, 5),
+            });
+            return models;
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            if (isAbortError(error)) {
+                throw new Error(`Request timed out after ${MODELS_DISCOVERY_TIMEOUT_MS / 1000} seconds`, { cause: error });
+            }
+            throw error;
+        }
+    }
+    /**
+     * Type guard to validate the models API response structure
+     * @private
+     */
+    isValidModelsResponse(data) {
+        return (data !== null &&
+            typeof data === "object" &&
+            "data" in data &&
+            Array.isArray(data.data));
+    }
+    /**
+     * Fetch and cache model capabilities from OpenRouter API
+     * Call this to enable accurate tool support detection
+     */
+    async cacheModelCapabilities() {
+        const functionTag = "OpenRouterProvider.cacheModelCapabilities";
+        if (OpenRouterProvider.capabilitiesCached) {
+            return; // Already cached
+        }
+        try {
+            const config = getOpenRouterConfig();
+            const modelsUrl = "https://openrouter.ai/api/v1/models";
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), MODELS_DISCOVERY_TIMEOUT_MS);
+            const proxyFetch = createProxyFetch();
+            const response = await proxyFetch(modelsUrl, {
+                method: "GET",
+                headers: {
+                    Authorization: `Bearer ${config.apiKey}`,
+                    "Content-Type": "application/json",
+                },
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            const data = await response.json();
+            if (!this.isValidModelsResponse(data)) {
+                throw new Error("Invalid response format");
+            }
+            // Extract tool-capable models
+            const toolCapable = new Set();
+            for (const model of data.data) {
+                if (model.id && model.supported_parameters?.includes("tools")) {
+                    toolCapable.add(model.id);
+                }
+            }
+            OpenRouterProvider.toolCapableModels = toolCapable;
+            OpenRouterProvider.capabilitiesCached = true;
+            logger.debug(`[${functionTag}] Cached model capabilities`, {
+                totalModels: data.data.length,
+                toolCapableCount: toolCapable.size,
+            });
+        }
+        catch (error) {
+            logger.warn(`[${functionTag}] Failed to cache capabilities, using fallback patterns`, {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            // Don't set capabilitiesCached - let it use fallback patterns
+        }
+    }
+}