@juspay/neurolink 7.4.0 → 7.6.0

package/dist/lib/core/types.d.ts

@@ -42,6 +42,7 @@ export interface TextGenerationResult {
 export declare enum AIProviderName {
     BEDROCK = "bedrock",
     OPENAI = "openai",
+    OPENAI_COMPATIBLE = "openai-compatible",
     VERTEX = "vertex",
     ANTHROPIC = "anthropic",
     AZURE = "azure",
@@ -49,6 +50,7 @@ export declare enum AIProviderName {
     HUGGINGFACE = "huggingface",
     OLLAMA = "ollama",
     MISTRAL = "mistral",
+    LITELLM = "litellm",
     AUTO = "auto"
 }
 /**

package/dist/lib/core/types.js

@@ -5,6 +5,7 @@ export var AIProviderName;
 (function (AIProviderName) {
     AIProviderName["BEDROCK"] = "bedrock";
     AIProviderName["OPENAI"] = "openai";
+    AIProviderName["OPENAI_COMPATIBLE"] = "openai-compatible";
     AIProviderName["VERTEX"] = "vertex";
     AIProviderName["ANTHROPIC"] = "anthropic";
     AIProviderName["AZURE"] = "azure";
@@ -12,6 +13,7 @@ export var AIProviderName;
     AIProviderName["HUGGINGFACE"] = "huggingface";
     AIProviderName["OLLAMA"] = "ollama";
     AIProviderName["MISTRAL"] = "mistral";
+    AIProviderName["LITELLM"] = "litellm";
     AIProviderName["AUTO"] = "auto";
 })(AIProviderName || (AIProviderName = {}));
 /**

package/dist/lib/factories/providerRegistry.js

@@ -71,6 +71,17 @@ export class ProviderRegistry {
                 const { OllamaProvider } = await import("../providers/ollama.js");
                 return new OllamaProvider(modelName);
             }, process.env.OLLAMA_MODEL || "llama3.1:8b", ["ollama", "local"]);
+            // Register LiteLLM provider
+            ProviderFactory.registerProvider(AIProviderName.LITELLM, async (modelName, providerName, sdk) => {
+                const { LiteLLMProvider } = await import("../providers/litellm.js");
+                return new LiteLLMProvider(modelName, sdk);
+            }, process.env.LITELLM_MODEL || "openai/gpt-4o-mini", ["litellm"]);
+            // Register OpenAI Compatible provider
+            ProviderFactory.registerProvider(AIProviderName.OPENAI_COMPATIBLE, async (modelName, providerName, sdk) => {
+                const { OpenAICompatibleProvider } = await import("../providers/openaiCompatible.js");
+                return new OpenAICompatibleProvider(modelName, sdk);
+            }, process.env.OPENAI_COMPATIBLE_MODEL || undefined, // Enable auto-discovery when no model specified
+            ["openai-compatible", "openrouter", "vllm", "compatible"]);
             logger.debug("All providers registered successfully");
             this.registered = true;
         }

package/dist/lib/neurolink.js

@@ -701,6 +701,7 @@ export class NeuroLink {
             "huggingface",
             "ollama",
             "mistral",
+            "litellm",
         ];
         // 🚀 PERFORMANCE FIX: Test providers with controlled concurrency
         // This reduces total time from 16s (sequential) to ~3s (parallel) while preventing resource exhaustion

package/dist/lib/providers/index.d.ts

@@ -5,6 +5,7 @@
 export { GoogleVertexProvider as GoogleVertexAI } from "./googleVertex.js";
 export { AmazonBedrockProvider as AmazonBedrock } from "./amazonBedrock.js";
 export { OpenAIProvider as OpenAI } from "./openAI.js";
+export { OpenAICompatibleProvider as OpenAICompatible } from "./openaiCompatible.js";
 export { AnthropicProvider as AnthropicProvider } from "./anthropic.js";
 export { AzureOpenAIProvider } from "./azureOpenai.js";
 export { GoogleAIStudioProvider as GoogleAIStudio } from "./googleAiStudio.js";
@@ -19,6 +20,7 @@ export declare const PROVIDERS: {
     readonly vertex: "GoogleVertexAI";
     readonly bedrock: "AmazonBedrock";
     readonly openai: "OpenAI";
+    readonly "openai-compatible": "OpenAICompatible";
     readonly anthropic: "AnthropicProvider";
     readonly azure: "AzureOpenAIProvider";
     readonly "google-ai": "GoogleAIStudio";

package/dist/lib/providers/index.js

@@ -5,6 +5,7 @@
 export { GoogleVertexProvider as GoogleVertexAI } from "./googleVertex.js";
 export { AmazonBedrockProvider as AmazonBedrock } from "./amazonBedrock.js";
 export { OpenAIProvider as OpenAI } from "./openAI.js";
+export { OpenAICompatibleProvider as OpenAICompatible } from "./openaiCompatible.js";
 export { AnthropicProvider as AnthropicProvider } from "./anthropic.js";
 export { AzureOpenAIProvider } from "./azureOpenai.js";
 export { GoogleAIStudioProvider as GoogleAIStudio } from "./googleAiStudio.js";
@@ -18,6 +19,7 @@ export const PROVIDERS = {
     vertex: "GoogleVertexAI",
     bedrock: "AmazonBedrock",
     openai: "OpenAI",
+    "openai-compatible": "OpenAICompatible",
     anthropic: "AnthropicProvider",
     azure: "AzureOpenAIProvider",
     "google-ai": "GoogleAIStudio",

package/dist/lib/providers/litellm.d.ts

@@ -0,0 +1,43 @@
+import type { ZodType, ZodTypeDef } from "zod";
+import { type Schema, type LanguageModelV1 } from "ai";
+import type { AIProviderName } from "../core/types.js";
+import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
+import { BaseProvider } from "../core/baseProvider.js";
+/**
+ * LiteLLM Provider - BaseProvider Implementation
+ * Provides access to 100+ models via LiteLLM proxy server
+ */
+export declare class LiteLLMProvider extends BaseProvider {
+    private model;
+    constructor(modelName?: string, sdk?: unknown);
+    protected getProviderName(): AIProviderName;
+    protected getDefaultModel(): string;
+    /**
+     * Returns the Vercel AI SDK model instance for LiteLLM
+     */
+    protected getAISDKModel(): LanguageModelV1;
+    protected handleProviderError(error: unknown): Error;
+    /**
+     * LiteLLM supports tools for compatible models
+     */
+    supportsTools(): boolean;
+    /**
+     * Provider-specific streaming implementation
+     * Note: This is only used when tools are disabled
+     */
+    protected executeStream(options: StreamOptions, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
+    /**
+     * Get available models from LiteLLM proxy server
+     *
+     * TODO: Implement dynamic fetching from LiteLLM's /v1/models endpoint.
+     * Currently returns a hardcoded list of commonly available models.
+     *
+     * Implementation would involve:
+     * 1. Fetch from `${baseURL}/v1/models`
+     * 2. Parse response to extract model IDs
+     * 3. Handle network errors gracefully
+     * 4. Cache results to avoid repeated API calls
+     */
+    getAvailableModels(): Promise<string[]>;
+    private validateStreamOptions;
+}

package/dist/lib/providers/litellm.js

@@ -0,0 +1,188 @@
+import { createOpenAI } from "@ai-sdk/openai";
+import { streamText } from "ai";
+import { BaseProvider } from "../core/baseProvider.js";
+import { logger } from "../utils/logger.js";
+import { createTimeoutController, TimeoutError, } from "../utils/timeout.js";
+import { DEFAULT_MAX_TOKENS } from "../core/constants.js";
+import { getProviderModel } from "../utils/providerConfig.js";
+import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
+// Configuration helpers
+const getLiteLLMConfig = () => {
+    return {
+        baseURL: process.env.LITELLM_BASE_URL || "http://localhost:4000",
+        apiKey: process.env.LITELLM_API_KEY || "sk-anything",
+    };
+};
+/**
+ * Returns the default model name for LiteLLM.
+ *
+ * LiteLLM uses a 'provider/model' format for model names.
+ * For example:
+ *   - 'openai/gpt-4o-mini'
+ *   - 'openai/gpt-3.5-turbo'
+ *   - 'anthropic/claude-3-sonnet-20240229'
+ *   - 'google/gemini-pro'
+ *
+ * You can override the default by setting the LITELLM_MODEL environment variable.
+ */
+const getDefaultLiteLLMModel = () => {
+    return getProviderModel("LITELLM_MODEL", "openai/gpt-4o-mini");
+};
+/**
+ * LiteLLM Provider - BaseProvider Implementation
+ * Provides access to 100+ models via LiteLLM proxy server
+ */
+export class LiteLLMProvider extends BaseProvider {
+    model;
+    constructor(modelName, sdk) {
+        super(modelName, "litellm", sdk);
+        // Initialize LiteLLM using OpenAI SDK with explicit configuration
+        const config = getLiteLLMConfig();
+        // Create OpenAI SDK instance configured for LiteLLM proxy
+        // LiteLLM acts as a proxy server that implements the OpenAI-compatible API.
+        // To communicate with LiteLLM instead of the default OpenAI endpoint, we use createOpenAI
+        // with a custom baseURL and apiKey. This ensures all requests are routed through the LiteLLM
+        // proxy, allowing access to multiple models and custom authentication.
+        const customOpenAI = createOpenAI({
+            baseURL: config.baseURL,
+            apiKey: config.apiKey,
+        });
+        this.model = customOpenAI(this.modelName || getDefaultLiteLLMModel());
+        logger.debug("LiteLLM Provider initialized", {
+            modelName: this.modelName,
+            provider: this.providerName,
+            baseURL: config.baseURL,
+        });
+    }
+    getProviderName() {
+        return "litellm";
+    }
+    getDefaultModel() {
+        return getDefaultLiteLLMModel();
+    }
+    /**
+     * Returns the Vercel AI SDK model instance for LiteLLM
+     */
+    getAISDKModel() {
+        return this.model;
+    }
+    handleProviderError(error) {
+        if (error instanceof TimeoutError) {
+            return new Error(`LiteLLM 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(`LiteLLM 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("LiteLLM proxy server not available. Please start the LiteLLM proxy server at " +
+                    `${process.env.LITELLM_BASE_URL || "http://localhost:4000"}`);
+            }
+            if (errorRecord.message.includes("API_KEY_INVALID") ||
+                errorRecord.message.includes("Invalid API key")) {
+                return new Error("Invalid LiteLLM configuration. Please check your LITELLM_API_KEY environment variable.");
+            }
+            if (errorRecord.message.includes("rate limit")) {
+                return new Error("LiteLLM rate limit exceeded. Please try again later.");
+            }
+            if (errorRecord.message.includes("model") &&
+                errorRecord.message.includes("not found")) {
+                return new Error(`Model '${this.modelName}' not available in LiteLLM proxy. ` +
+                    "Please check your LiteLLM configuration and ensure the model is configured.");
+            }
+        }
+        return new Error(`LiteLLM error: ${errorRecord?.message || "Unknown error"}`);
+    }
+    /**
+     * LiteLLM supports tools for compatible models
+     */
+    supportsTools() {
+        return true;
+    }
+    /**
+     * Provider-specific streaming implementation
+     * Note: This is only used when tools are disabled
+     */
+    async executeStream(options, analysisSchema) {
+        this.validateStreamOptions(options);
+        const startTime = Date.now();
+        const timeout = this.getTimeout(options);
+        const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
+        try {
+            const result = await streamText({
+                model: this.model,
+                prompt: options.input.text,
+                system: options.systemPrompt,
+                temperature: options.temperature,
+                maxTokens: options.maxTokens || DEFAULT_MAX_TOKENS,
+                tools: options.tools,
+                toolChoice: "auto",
+                abortSignal: timeoutController?.controller.signal,
+            });
+            timeoutController?.cleanup();
+            // Transform stream to match StreamResult interface
+            const transformedStream = async function* () {
+                for await (const chunk of result.textStream) {
+                    yield { content: chunk };
+                }
+            };
+            // Create analytics promise that resolves after stream completion
+            const analyticsPromise = streamAnalyticsCollector.createAnalytics(this.providerName, this.modelName, result, Date.now() - startTime, {
+                requestId: `litellm-stream-${Date.now()}`,
+                streamingMode: true,
+            });
+            return {
+                stream: transformedStream(),
+                provider: this.providerName,
+                model: this.modelName,
+                analytics: analyticsPromise,
+                metadata: {
+                    startTime,
+                    streamId: `litellm-${Date.now()}`,
+                },
+            };
+        }
+        catch (error) {
+            timeoutController?.cleanup();
+            throw this.handleProviderError(error);
+        }
+    }
+    /**
+     * Get available models from LiteLLM proxy server
+     *
+     * TODO: Implement dynamic fetching from LiteLLM's /v1/models endpoint.
+     * Currently returns a hardcoded list of commonly available models.
+     *
+     * Implementation would involve:
+     * 1. Fetch from `${baseURL}/v1/models`
+     * 2. Parse response to extract model IDs
+     * 3. Handle network errors gracefully
+     * 4. Cache results to avoid repeated API calls
+     */
+    async getAvailableModels() {
+        // Hardcoded list of commonly available models
+        // TODO: Replace with dynamic fetch from LiteLLM proxy /v1/models endpoint
+        return [
+            "openai/gpt-4o",
+            "openai/gpt-4o-mini",
+            "anthropic/claude-3-5-sonnet",
+            "anthropic/claude-3-haiku",
+            "google/gemini-2.0-flash",
+            "mistral/mistral-large",
+            "mistral/mistral-medium",
+        ];
+    }
+    // ===================
+    // PRIVATE VALIDATION METHODS
+    // ===================
+    validateStreamOptions(options) {
+        if (!options.input?.text || options.input.text.trim().length === 0) {
+            throw new Error("Input text is required and cannot be empty");
+        }
+    }
+}

package/dist/lib/providers/openaiCompatible.d.ts

@@ -0,0 +1,49 @@
+import type { ZodType, ZodTypeDef } from "zod";
+import { type Schema, type LanguageModelV1 } from "ai";
+import type { AIProviderName } from "../core/types.js";
+import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
+import { BaseProvider } from "../core/baseProvider.js";
+/**
+ * OpenAI Compatible Provider - BaseProvider Implementation
+ * Provides access to any OpenAI-compatible endpoint (OpenRouter, vLLM, LiteLLM, etc.)
+ */
+export declare class OpenAICompatibleProvider extends BaseProvider {
+    private model?;
+    private config;
+    private discoveredModel?;
+    private customOpenAI;
+    constructor(modelName?: string, sdk?: unknown);
+    protected getProviderName(): AIProviderName;
+    protected getDefaultModel(): string;
+    /**
+     * Returns the Vercel AI SDK model instance for OpenAI Compatible endpoints
+     * Handles auto-discovery if no model was specified
+     */
+    protected getAISDKModel(): Promise<LanguageModelV1>;
+    protected handleProviderError(error: unknown): Error;
+    /**
+     * OpenAI Compatible endpoints support tools for compatible models
+     */
+    supportsTools(): boolean;
+    /**
+     * Provider-specific streaming implementation
+     * Note: This is only used when tools are disabled
+     */
+    protected executeStream(options: StreamOptions, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
+    /**
+     * Get available models from OpenAI Compatible endpoint
+     *
+     * Fetches from the /v1/models endpoint to discover available models.
+     * This is useful for auto-discovery when no model is specified.
+     */
+    getAvailableModels(): Promise<string[]>;
+    /**
+     * Get the first available model for auto-selection
+     */
+    getFirstAvailableModel(): Promise<string>;
+    /**
+     * Fallback models when discovery fails
+     */
+    private getFallbackModels;
+    private validateStreamOptions;
+}

package/dist/lib/providers/openaiCompatible.js

@@ -0,0 +1,260 @@
+import { createOpenAI } from "@ai-sdk/openai";
+import { streamText } from "ai";
+import { BaseProvider } from "../core/baseProvider.js";
+import { logger } from "../utils/logger.js";
+import { createTimeoutController, TimeoutError, } from "../utils/timeout.js";
+import { DEFAULT_MAX_TOKENS } from "../core/constants.js";
+import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
+// Constants
+const FALLBACK_OPENAI_COMPATIBLE_MODEL = "gpt-3.5-turbo";
+// Configuration helpers
+const getOpenAICompatibleConfig = () => {
+    const baseURL = process.env.OPENAI_COMPATIBLE_BASE_URL;
+    const apiKey = process.env.OPENAI_COMPATIBLE_API_KEY;
+    if (!baseURL) {
+        throw new Error("OPENAI_COMPATIBLE_BASE_URL environment variable is required. " +
+            "Please set it to your OpenAI-compatible endpoint (e.g., https://api.openrouter.ai/api/v1)");
+    }
+    if (!apiKey) {
+        throw new Error("OPENAI_COMPATIBLE_API_KEY environment variable is required. " +
+            "Please set it to your API key for the OpenAI-compatible service.");
+    }
+    return {
+        baseURL,
+        apiKey,
+    };
+};
+/**
+ * Returns the default model name for OpenAI Compatible endpoints.
+ *
+ * Returns undefined if no model is specified via OPENAI_COMPATIBLE_MODEL environment variable,
+ * which triggers auto-discovery from the /v1/models endpoint.
+ */
+const getDefaultOpenAICompatibleModel = () => {
+    return process.env.OPENAI_COMPATIBLE_MODEL || undefined;
+};
+/**
+ * OpenAI Compatible Provider - BaseProvider Implementation
+ * Provides access to any OpenAI-compatible endpoint (OpenRouter, vLLM, LiteLLM, etc.)
+ */
+export class OpenAICompatibleProvider extends BaseProvider {
+    model;
+    config;
+    discoveredModel;
+    customOpenAI;
+    constructor(modelName, sdk) {
+        super(modelName, "openai-compatible", sdk);
+        // Initialize OpenAI Compatible configuration
+        this.config = getOpenAICompatibleConfig();
+        // Create OpenAI SDK instance configured for custom endpoint
+        // This allows us to use any OpenAI-compatible API by simply changing the baseURL
+        this.customOpenAI = createOpenAI({
+            baseURL: this.config.baseURL,
+            apiKey: this.config.apiKey,
+        });
+        logger.debug("OpenAI Compatible Provider initialized", {
+            modelName: this.modelName,
+            provider: this.providerName,
+            baseURL: this.config.baseURL,
+        });
+    }
+    getProviderName() {
+        return "openai-compatible";
+    }
+    getDefaultModel() {
+        // Return empty string when no model is explicitly configured to enable auto-discovery
+        return getDefaultOpenAICompatibleModel() || "";
+    }
+    /**
+     * Returns the Vercel AI SDK model instance for OpenAI Compatible endpoints
+     * Handles auto-discovery if no model was specified
+     */
+    async getAISDKModel() {
+        // If model instance doesn't exist yet, create it
+        if (!this.model) {
+            let modelToUse;
+            // Check if a model was explicitly specified via constructor or env var
+            const explicitModel = this.modelName || getDefaultOpenAICompatibleModel();
+            // Treat empty string as no model specified (trigger auto-discovery)
+            if (explicitModel && explicitModel.trim() !== "") {
+                // Use the explicitly specified model
+                modelToUse = explicitModel;
+                logger.debug(`Using specified model: ${modelToUse}`);
+            }
+            else {
+                // No model specified, auto-discover from endpoint
+                try {
+                    const availableModels = await this.getAvailableModels();
+                    if (availableModels.length > 0) {
+                        this.discoveredModel = availableModels[0];
+                        modelToUse = this.discoveredModel;
+                        logger.info(`🔍 Auto-discovered model: ${modelToUse} from ${availableModels.length} available models`);
+                    }
+                    else {
+                        // Fall back to a common default if no models discovered
+                        modelToUse = FALLBACK_OPENAI_COMPATIBLE_MODEL;
+                        logger.warn(`No models discovered, using fallback: ${modelToUse}`);
+                    }
+                }
+                catch (error) {
+                    logger.warn("Model auto-discovery failed, using fallback:", error);
+                    modelToUse = FALLBACK_OPENAI_COMPATIBLE_MODEL;
+                }
+            }
+            // Create the model instance
+            this.model = this.customOpenAI(modelToUse);
+        }
+        return this.model;
+    }
+    handleProviderError(error) {
+        if (error instanceof TimeoutError) {
+            return new Error(`OpenAI Compatible 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(`OpenAI Compatible 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(`OpenAI Compatible endpoint not available. Please check your OPENAI_COMPATIBLE_BASE_URL: ${this.config.baseURL}`);
+            }
+            if (errorRecord.message.includes("API_KEY_INVALID") ||
+                errorRecord.message.includes("Invalid API key") ||
+                errorRecord.message.includes("Unauthorized")) {
+                return new Error("Invalid OpenAI Compatible API key. Please check your OPENAI_COMPATIBLE_API_KEY environment variable.");
+            }
+            if (errorRecord.message.includes("rate limit")) {
+                return new Error("OpenAI Compatible rate limit exceeded. Please try again later.");
+            }
+            if (errorRecord.message.includes("model") &&
+                (errorRecord.message.includes("not found") ||
+                    errorRecord.message.includes("does not exist"))) {
+                return new Error(`Model '${this.modelName}' not available on OpenAI Compatible endpoint. ` +
+                    "Please check available models or use getAvailableModels() to see supported models.");
+            }
+        }
+        return new Error(`OpenAI Compatible error: ${errorRecord?.message || "Unknown error"}`);
+    }
+    /**
+     * OpenAI Compatible endpoints support tools for compatible models
+     */
+    supportsTools() {
+        return true;
+    }
+    /**
+     * Provider-specific streaming implementation
+     * Note: This is only used when tools are disabled
+     */
+    async executeStream(options, analysisSchema) {
+        this.validateStreamOptions(options);
+        const startTime = Date.now();
+        const timeout = this.getTimeout(options);
+        const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
+        try {
+            const model = await this.getAISDKModel();
+            const result = await streamText({
+                model,
+                prompt: options.input.text,
+                system: options.systemPrompt,
+                temperature: options.temperature,
+                maxTokens: options.maxTokens || DEFAULT_MAX_TOKENS,
+                tools: options.tools,
+                toolChoice: "auto",
+                abortSignal: timeoutController?.controller.signal,
+            });
+            timeoutController?.cleanup();
+            // Transform stream to match StreamResult interface
+            const transformedStream = async function* () {
+                for await (const chunk of result.textStream) {
+                    yield { content: chunk };
+                }
+            };
+            // Create analytics promise that resolves after stream completion
+            const analyticsPromise = streamAnalyticsCollector.createAnalytics(this.providerName, this.modelName, result, Date.now() - startTime, {
+                requestId: `openai-compatible-stream-${Date.now()}`,
+                streamingMode: true,
+            });
+            return {
+                stream: transformedStream(),
+                provider: this.providerName,
+                model: this.modelName,
+                analytics: analyticsPromise,
+                metadata: {
+                    startTime,
+                    streamId: `openai-compatible-${Date.now()}`,
+                },
+            };
+        }
+        catch (error) {
+            timeoutController?.cleanup();
+            throw this.handleProviderError(error);
+        }
+    }
+    /**
+     * Get available models from OpenAI Compatible endpoint
+     *
+     * Fetches from the /v1/models endpoint to discover available models.
+     * This is useful for auto-discovery when no model is specified.
+     */
+    async getAvailableModels() {
+        try {
+            const modelsUrl = new URL("/v1/models", this.config.baseURL).toString();
+            logger.debug(`Fetching available models from: ${modelsUrl}`);
+            const response = await fetch(modelsUrl, {
+                headers: {
+                    Authorization: `Bearer ${this.config.apiKey}`,
+                    "Content-Type": "application/json",
+                },
+            });
+            if (!response.ok) {
+                logger.warn(`Models endpoint returned ${response.status}: ${response.statusText}`);
+                return this.getFallbackModels();
+            }
+            const data = await response.json();
+            if (!data.data || !Array.isArray(data.data)) {
+                logger.warn("Invalid models response format");
+                return this.getFallbackModels();
+            }
+            const models = data.data.map((model) => model.id).filter(Boolean);
+            logger.debug(`Discovered ${models.length} models:`, models);
+            return models.length > 0 ? models : this.getFallbackModels();
+        }
+        catch (error) {
+            logger.warn(`Failed to fetch models from OpenAI Compatible endpoint:`, error);
+            return this.getFallbackModels();
+        }
+    }
+    /**
+     * Get the first available model for auto-selection
+     */
+    async getFirstAvailableModel() {
+        const models = await this.getAvailableModels();
+        return models[0] || FALLBACK_OPENAI_COMPATIBLE_MODEL;
+    }
+    /**
+     * Fallback models when discovery fails
+     */
+    getFallbackModels() {
+        return [
+            "gpt-4o",
+            "gpt-4o-mini",
+            "gpt-4-turbo",
+            FALLBACK_OPENAI_COMPATIBLE_MODEL,
+            "claude-3-5-sonnet",
+            "claude-3-haiku",
+            "gemini-pro",
+        ];
+    }
+    // ===================
+    // PRIVATE VALIDATION METHODS
+    // ===================
+    validateStreamOptions(options) {
+        if (!options.input?.text || options.input.text.trim().length === 0) {
+            throw new Error("Input text is required and cannot be empty");
+        }
+    }
+}

package/dist/lib/utils/providerConfig.d.ts

@@ -91,6 +91,10 @@ export declare function createAzureAPIKeyConfig(): ProviderConfigOptions;
  * Creates Azure OpenAI Endpoint configuration
  */
 export declare function createAzureEndpointConfig(): ProviderConfigOptions;
+/**
+ * Creates OpenAI Compatible provider configuration
+ */
+export declare function createOpenAICompatibleConfig(): ProviderConfigOptions;
 /**
  * Creates Google Vertex Project ID configuration
  */

package/dist/lib/utils/providerConfig.js

@@ -273,6 +273,26 @@ export function createAzureEndpointConfig() {
         ],
     };
 }
+/**
+ * Creates OpenAI Compatible provider configuration
+ */
+export function createOpenAICompatibleConfig() {
+    return {
+        providerName: "OpenAI Compatible",
+        envVarName: "OPENAI_COMPATIBLE_API_KEY",
+        setupUrl: "https://openrouter.ai/",
+        description: "OpenAI-compatible API credentials",
+        instructions: [
+            "1. Set OPENAI_COMPATIBLE_BASE_URL to your endpoint (e.g., https://api.openrouter.ai/api/v1)",
+            "2. Get API key from your OpenAI-compatible service:",
+            "   • OpenRouter: https://openrouter.ai/keys",
+            "   • vLLM: Use any value for local deployments",
+            "   • LiteLLM: Check your LiteLLM server configuration",
+            "3. Set OPENAI_COMPATIBLE_API_KEY to your API key",
+            "4. Optionally set OPENAI_COMPATIBLE_MODEL (will auto-discover if not set)",
+        ],
+    };
+}
 /**
  * Creates Google Vertex Project ID configuration
  */