@juspay/neurolink 9.32.0 → 9.32.1

package/dist/client/providers/openAI.js

@@ -1,627 +0,0 @@
-import { createOpenAI } from "@ai-sdk/openai";
-import { embed, embedMany, NoOutputGeneratedError, stepCountIs, streamText, } from "ai";
-import { trace, SpanKind, SpanStatusCode } from "@opentelemetry/api";
-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 { AuthenticationError, InvalidModelError, NetworkError, ProviderError, RateLimitError, } from "../types/errors.js";
-import { logger } from "../utils/logger.js";
-import { calculateCost } from "../utils/pricing.js";
-import { createOpenAIConfig, getProviderModel, validateApiKey, } from "../utils/providerConfig.js";
-import { isZodSchema } from "../utils/schemaConversion.js";
-import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
-import { getModelId } from "./providerTypeUtils.js";
-/**
- * Retrieve a tool's schema, handling both AI SDK v6 (`inputSchema`) and
- * legacy v4 (`parameters`) field names.
- */
-function getToolSchema(tool) {
-    const t = tool;
-    return t.inputSchema ?? t.parameters;
-}
-// Configuration helpers - now using consolidated utility
-const getOpenAIApiKey = () => {
-    return validateApiKey(createOpenAIConfig());
-};
-const getOpenAIModel = () => {
-    return getProviderModel("OPENAI_MODEL", "gpt-4o");
-};
-const streamTracer = trace.getTracer("neurolink.provider.openai");
-/**
- * OpenAI Provider v2 - BaseProvider Implementation
- * Migrated to use factory pattern with exact Google AI provider pattern
- */
-export class OpenAIProvider extends BaseProvider {
-    model;
-    constructor(modelName, neurolink) {
-        super(modelName || getOpenAIModel(), AIProviderName.OPENAI, neurolink);
-        // Initialize OpenAI provider with proxy support
-        const openai = createOpenAI({
-            apiKey: getOpenAIApiKey(),
-            fetch: createProxyFetch(),
-        });
-        // Initialize model
-        this.model = openai(this.modelName);
-        logger.debug("OpenAIProvider constructor called", {
-            model: this.modelName,
-            provider: this.providerName,
-            supportsTools: this.supportsTools(),
-            className: this.constructor.name,
-        });
-    }
-    // ===================
-    // ABSTRACT METHOD IMPLEMENTATIONS
-    // ===================
-    /**
-     * Check if this provider supports tool/function calling
-     */
-    supportsTools() {
-        return true; // Re-enable tools now that we understand the issue
-    }
-    getProviderName() {
-        return AIProviderName.OPENAI;
-    }
-    getDefaultModel() {
-        return getOpenAIModel();
-    }
-    /**
-     * Get the default embedding model for OpenAI
-     * @returns The default OpenAI embedding model name
-     */
-    getDefaultEmbeddingModel() {
-        return process.env.OPENAI_EMBEDDING_MODEL || "text-embedding-3-small";
-    }
-    /**
-     * Returns the Vercel AI SDK model instance for OpenAI
-     */
-    getAISDKModel() {
-        return this.model;
-    }
-    /**
-     * OpenAI-specific tool validation and filtering
-     * Filters out tools that might cause streaming issues
-     */
-    validateAndFilterToolsForOpenAI(tools) {
-        const validTools = {};
-        for (const [name, tool] of Object.entries(tools)) {
-            try {
-                // Basic validation - ensure tool has required structure
-                if (tool && typeof tool === "object") {
-                    // Check if tool has description (required by OpenAI)
-                    if (tool.description && typeof tool.description === "string") {
-                        // Keep the original tool structure - AI SDK will handle Zod schema conversion internally
-                        const processedTool = { ...tool };
-                        // Validate that Zod schemas are properly structured for AI SDK processing
-                        const toolSchema = getToolSchema(tool);
-                        if (toolSchema && isZodSchema(toolSchema)) {
-                            logger.debug(`OpenAI: Tool ${name} has Zod schema - AI SDK will handle conversion`);
-                            // Basic validation that the Zod schema has the required structure
-                            this.validateZodSchema(name, toolSchema);
-                        }
-                        // Include the tool with original Zod schema for AI SDK processing
-                        if (this.isValidToolStructure(processedTool)) {
-                            validTools[name] = processedTool;
-                        }
-                        else {
-                            logger.warn(`OpenAI: Filtering out tool with invalid structure: ${name}`, {
-                                parametersType: typeof getToolSchema(processedTool),
-                                hasDescription: !!processedTool.description,
-                                hasExecute: !!processedTool.execute,
-                            });
-                        }
-                    }
-                    else {
-                        logger.warn(`OpenAI: Filtering out tool without description: ${name}`);
-                    }
-                }
-                else {
-                    logger.warn(`OpenAI: Filtering out invalid tool: ${name}`);
-                }
-            }
-            catch (error) {
-                logger.warn(`OpenAI: Error validating tool ${name}:`, error);
-            }
-        }
-        return validTools;
-    }
-    /**
-     * Validate Zod schema structure
-     */
-    validateZodSchema(toolName, schema) {
-        try {
-            const zodSchema = schema;
-            if (zodSchema._def && zodSchema._def.typeName) {
-                logger.debug(`OpenAI: Zod schema for ${toolName} appears valid`, {
-                    typeName: zodSchema._def.typeName,
-                });
-            }
-            else {
-                logger.warn(`OpenAI: Zod schema for ${toolName} missing typeName - may cause issues`);
-            }
-        }
-        catch (zodValidationError) {
-            logger.warn(`OpenAI: Zod schema validation failed for ${toolName}:`, zodValidationError);
-            // Continue anyway - let AI SDK handle it
-        }
-    }
-    /**
-     * Validate tool structure for OpenAI compatibility
-     * More lenient validation to avoid filtering out valid tools
-     */
-    isValidToolStructure(tool) {
-        if (!tool || typeof tool !== "object") {
-            return false;
-        }
-        const toolObj = tool;
-        // Ensure tool has description and execute function
-        if (!toolObj.description || typeof toolObj.description !== "string") {
-            return false;
-        }
-        if (!toolObj.execute || typeof toolObj.execute !== "function") {
-            return false;
-        }
-        // AI SDK v6 uses inputSchema; v4 used parameters — check both
-        const schema = "inputSchema" in toolObj
-            ? toolObj.inputSchema
-            : "parameters" in toolObj
-                ? toolObj.parameters
-                : undefined;
-        return this.isValidToolParameters(schema);
-    }
-    /**
-     * Validate tool parameters for OpenAI compatibility
-     * Ensures the tool has either valid Zod schema or valid JSON schema
-     */
-    isValidToolParameters(parameters) {
-        if (!parameters) {
-            // For OpenAI, tools without parameters need an empty object schema
-            return true;
-        }
-        // Check if it's a Zod schema - these are valid
-        if (isZodSchema(parameters)) {
-            return true;
-        }
-        // Check if it's a JSON schema
-        if (typeof parameters !== "object" || parameters === null) {
-            return false;
-        }
-        const params = parameters;
-        // If it's a JSON schema, it should have type "object" for OpenAI
-        if (params.type && params.type !== "object") {
-            return false;
-        }
-        // OpenAI requires schemas to have properties field, even if empty
-        // If there's no properties field, the schema is incomplete
-        if (params.type === "object" && !params.properties) {
-            logger.warn(`Tool parameter schema missing properties field:`, params);
-            return false;
-        }
-        // If properties exist, they should be an object
-        if (params.properties && typeof params.properties !== "object") {
-            return false;
-        }
-        // If required exists, it should be an array
-        if (params.required && !Array.isArray(params.required)) {
-            return false;
-        }
-        return true;
-    }
-    formatProviderError(error) {
-        if (error instanceof TimeoutError) {
-            return new NetworkError(error.message, this.providerName);
-        }
-        const errorObj = error;
-        const message = errorObj?.message && typeof errorObj.message === "string"
-            ? errorObj.message
-            : "Unknown error";
-        const errorType = errorObj?.type && typeof errorObj.type === "string"
-            ? errorObj.type
-            : undefined;
-        if (message.includes("API_KEY_INVALID") ||
-            message.includes("Invalid API key") ||
-            errorType === "invalid_api_key") {
-            return new AuthenticationError("Invalid OpenAI API key. Please check your OPENAI_API_KEY environment variable.", this.providerName);
-        }
-        if (message.includes("rate limit") || errorType === "rate_limit_error") {
-            return new RateLimitError("OpenAI rate limit exceeded. Please try again later.", this.providerName);
-        }
-        if (message.includes("model_not_found")) {
-            return new InvalidModelError(`Model not found: ${this.modelName}`, this.providerName);
-        }
-        // Generic provider error
-        return new ProviderError(`OpenAI error: ${message}`, this.providerName);
-    }
-    /**
-     * executeGenerate method removed - generation is now handled by BaseProvider.
-     * For details on the changes and migration steps, refer to the BaseProvider documentation
-     * and the migration guide in the project repository.
-     */
-    async executeStream(options, _analysisSchema) {
-        this.validateStreamOptions(options);
-        const startTime = Date.now();
-        const timeout = this.getTimeout(options);
-        const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
-        try {
-            // Get tools - options.tools is pre-merged by BaseProvider.stream() with
-            // base tools (MCP/built-in) + user-provided tools (RAG, etc.)
-            const shouldUseTools = !options.disableTools && this.supportsTools();
-            const allTools = shouldUseTools
-                ? options.tools || (await this.getAllTools())
-                : {};
-            // OpenAI-specific fix: Validate tools format and filter out problematic ones
-            let tools = this.validateAndFilterToolsForOpenAI(allTools);
-            // OpenAI max tools limit - configurable via environment variable
-            const MAX_TOOLS = parseInt(process.env.OPENAI_MAX_TOOLS || "150", 10);
-            if (Object.keys(tools).length > MAX_TOOLS) {
-                logger.warn(`OpenAI: Too many tools (${Object.keys(tools).length}), limiting to ${MAX_TOOLS} tools`);
-                const toolEntries = Object.entries(tools);
-                tools = Object.fromEntries(toolEntries.slice(0, MAX_TOOLS));
-            }
-            // Count tools with Zod schemas for debugging
-            const zodToolsCount = Object.values(allTools).filter((tool) => {
-                if (!tool || typeof tool !== "object") {
-                    return false;
-                }
-                const schema = getToolSchema(tool);
-                return schema !== null && schema !== undefined && isZodSchema(schema);
-            }).length;
-            logger.info("OpenAI streaming tools", {
-                shouldUseTools,
-                allToolsCount: Object.keys(allTools).length,
-                filteredToolsCount: Object.keys(tools).length,
-                zodToolsCount,
-                toolNames: Object.keys(tools),
-                filteredOutTools: Object.keys(allTools).filter((name) => !tools[name]),
-            });
-            // Build message array from options with multimodal support
-            // Using protected helper from BaseProvider to eliminate code duplication
-            const messages = await this.buildMessagesForStream(options);
-            // Debug the actual request being sent to OpenAI
-            logger.debug(`OpenAI: streamText request parameters:`, {
-                modelName: this.modelName,
-                messagesCount: messages.length,
-                temperature: options.temperature,
-                maxTokens: options.maxTokens,
-                toolsCount: Object.keys(tools).length,
-                toolChoice: shouldUseTools && Object.keys(tools).length > 0 ? "auto" : "none",
-                maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
-                firstToolExample: Object.keys(tools).length > 0
-                    ? {
-                        name: Object.keys(tools)[0],
-                        description: tools[Object.keys(tools)[0]]?.description,
-                        parametersType: typeof getToolSchema(tools[Object.keys(tools)[0]]),
-                    }
-                    : "no-tools",
-            });
-            const model = await this.getAISDKModelWithMiddleware(options); // This is where network connection happens!
-            // Wrap streamText in an OTel span to capture provider-level latency and token usage
-            const streamSpan = streamTracer.startSpan("neurolink.provider.streamText", {
-                kind: SpanKind.CLIENT,
-                attributes: {
-                    "gen_ai.system": "openai",
-                    "gen_ai.request.model": getModelId(model) || this.modelName || "unknown",
-                },
-            });
-            let result;
-            try {
-                result = streamText({
-                    model,
-                    messages: messages,
-                    temperature: options.temperature,
-                    maxOutputTokens: options.maxTokens, // No default limit - unlimited unless specified
-                    maxRetries: 0, // NL11: Disable AI SDK's invisible internal retries; we handle retries with OTel instrumentation
-                    tools,
-                    stopWhen: stepCountIs(options.maxSteps || DEFAULT_MAX_STEPS),
-                    toolChoice: shouldUseTools && Object.keys(tools).length > 0 ? "auto" : "none",
-                    abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
-                    experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
-                    onStepFinish: ({ toolCalls, toolResults }) => {
-                        logger.info("Tool execution completed", {
-                            toolResults,
-                            toolCalls,
-                        });
-                        // Handle tool execution storage
-                        this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {
-                            logger.warn("[OpenAIProvider] Failed to store tool executions", {
-                                provider: this.providerName,
-                                error: error instanceof Error ? error.message : String(error),
-                            });
-                        });
-                    },
-                });
-            }
-            catch (streamError) {
-                streamSpan.end();
-                throw streamError;
-            }
-            // Collect token usage and finish reason asynchronously when the stream completes,
-            // then end the span. This avoids blocking the stream consumer.
-            Promise.resolve(result.usage)
-                .then((usage) => {
-                streamSpan.setAttribute("gen_ai.usage.input_tokens", usage.inputTokens || 0);
-                streamSpan.setAttribute("gen_ai.usage.output_tokens", usage.outputTokens || 0);
-                const cost = calculateCost(this.providerName, this.modelName, {
-                    input: usage.inputTokens || 0,
-                    output: usage.outputTokens || 0,
-                    total: (usage.inputTokens || 0) + (usage.outputTokens || 0),
-                });
-                if (cost && cost > 0) {
-                    streamSpan.setAttribute("neurolink.cost", cost);
-                }
-            })
-                .catch(() => {
-                // Usage may not be available if the stream is aborted
-            });
-            Promise.resolve(result.finishReason)
-                .then((reason) => {
-                streamSpan.setAttribute("gen_ai.response.finish_reason", reason || "unknown");
-            })
-                .catch(() => {
-                // Finish reason may not be available if the stream is aborted
-            });
-            Promise.resolve(result.text)
-                .then(() => {
-                streamSpan.end();
-            })
-                .catch((err) => {
-                streamSpan.setStatus({
-                    code: SpanStatusCode.ERROR,
-                    message: err instanceof Error ? err.message : String(err),
-                });
-                streamSpan.end();
-            });
-            timeoutController?.cleanup();
-            // Debug the actual result structure
-            logger.debug(`OpenAI: streamText result structure:`, {
-                resultKeys: Object.keys(result),
-                hasTextStream: !!result.textStream,
-                hasToolCalls: !!result.toolCalls,
-                hasToolResults: !!result.toolResults,
-                resultType: typeof result,
-            });
-            // Transform string stream to content object stream using fullStream
-            const transformedStream = async function* () {
-                try {
-                    logger.debug(`OpenAI: Starting stream transformation`, {
-                        hasTextStream: !!result.textStream,
-                        hasFullStream: !!result.fullStream,
-                        resultKeys: Object.keys(result),
-                        toolsEnabled: shouldUseTools,
-                        toolsCount: Object.keys(tools).length,
-                    });
-                    let chunkCount = 0;
-                    let contentYielded = 0;
-                    // Try fullStream first (handles both text and tool calls), fallback to textStream
-                    const streamToUse = result.fullStream || result.textStream;
-                    if (!streamToUse) {
-                        logger.error("OpenAI: No stream available in result", {
-                            resultKeys: Object.keys(result),
-                        });
-                        return;
-                    }
-                    logger.debug(`OpenAI: Stream source selected:`, {
-                        usingFullStream: !!result.fullStream,
-                        usingTextStream: !!result.textStream && !result.fullStream,
-                        streamSourceType: result.fullStream ? "fullStream" : "textStream",
-                    });
-                    for await (const chunk of streamToUse) {
-                        chunkCount++;
-                        logger.debug(`OpenAI: Processing chunk ${chunkCount}:`, {
-                            chunkType: typeof chunk,
-                            chunkValue: typeof chunk === "string"
-                                ? chunk.substring(0, 50)
-                                : "not-string",
-                            chunkKeys: chunk && typeof chunk === "object"
-                                ? Object.keys(chunk)
-                                : "not-object",
-                            hasText: chunk && typeof chunk === "object" && "text" in chunk,
-                            hasTextDelta: chunk && typeof chunk === "object" && "textDelta" in chunk,
-                            hasType: chunk && typeof chunk === "object" && "type" in chunk,
-                            chunkTypeValue: chunk && typeof chunk === "object" && "type" in chunk
-                                ? chunk.type
-                                : "no-type",
-                        });
-                        let contentToYield = null;
-                        // Handle different chunk types from fullStream
-                        if (chunk && typeof chunk === "object") {
-                            // Log the full chunk structure for debugging (debug mode only)
-                            if (process.env.NEUROLINK_DEBUG === "true") {
-                                logger.debug(`OpenAI: Full chunk structure:`, {
-                                    chunkKeys: Object.keys(chunk),
-                                    fullChunk: JSON.stringify(chunk).substring(0, 500),
-                                });
-                            }
-                            if ("type" in chunk && chunk.type === "error") {
-                                // Handle error chunks when tools are enabled
-                                const errorChunk = chunk;
-                                logger.error(`OpenAI: Error chunk received:`, {
-                                    errorType: errorChunk.type,
-                                    errorDetails: errorChunk.error,
-                                    fullChunk: JSON.stringify(chunk),
-                                });
-                                // Throw a more descriptive error for tool-related issues
-                                const errorMessage = errorChunk.error &&
-                                    typeof errorChunk.error === "object" &&
-                                    "message" in errorChunk.error
-                                    ? String(errorChunk.error.message)
-                                    : "OpenAI API error when tools are enabled";
-                                throw new Error(`OpenAI streaming error with tools: ${errorMessage}. Try disabling tools with --disableTools`);
-                            }
-                            else if ("type" in chunk &&
-                                chunk.type === "text-delta" &&
-                                "textDelta" in chunk) {
-                                // Text delta from fullStream
-                                contentToYield = chunk.textDelta;
-                                logger.debug(`OpenAI: Found text-delta:`, {
-                                    textDelta: contentToYield,
-                                });
-                            }
-                            else if ("text" in chunk) {
-                                // Direct text chunk
-                                contentToYield = chunk.text;
-                                logger.debug(`OpenAI: Found direct text:`, {
-                                    text: contentToYield,
-                                });
-                            }
-                            else {
-                                // Log unhandled chunks in debug mode only
-                                if (process.env.NEUROLINK_DEBUG === "true") {
-                                    logger.debug(`OpenAI: Unhandled object chunk:`, {
-                                        chunkKeys: Object.keys(chunk),
-                                        chunkType: chunk.type || "no-type",
-                                        fullChunk: JSON.stringify(chunk).substring(0, 500),
-                                    });
-                                }
-                            }
-                        }
-                        else if (typeof chunk === "string") {
-                            // Direct string chunk from textStream
-                            contentToYield = chunk;
-                            logger.debug(`OpenAI: Found string chunk:`, {
-                                content: contentToYield,
-                            });
-                        }
-                        else {
-                            logger.warn(`OpenAI: Unhandled chunk type:`, {
-                                type: typeof chunk,
-                                value: String(chunk).substring(0, 100),
-                            });
-                        }
-                        if (contentToYield) {
-                            contentYielded++;
-                            logger.debug(`OpenAI: Yielding content ${contentYielded}:`, {
-                                content: contentToYield.substring(0, 50),
-                                length: contentToYield.length,
-                            });
-                            yield { content: contentToYield };
-                        }
-                    }
-                    logger.debug(`OpenAI: Stream transformation completed`, {
-                        totalChunks: chunkCount,
-                        contentYielded,
-                        success: contentYielded > 0,
-                    });
-                    if (contentYielded === 0) {
-                        logger.warn(`OpenAI: No content was yielded from stream despite processing ${chunkCount} chunks`);
-                    }
-                }
-                catch (streamError) {
-                    // AI SDK v6 throws NoOutputGeneratedError when the stream produced no output.
-                    // Treat as an empty stream rather than crashing with an unhandled rejection.
-                    if (NoOutputGeneratedError.isInstance(streamError)) {
-                        logger.warn("OpenAI: Stream produced no output (NoOutputGeneratedError)");
-                        return;
-                    }
-                    logger.error(`OpenAI: Stream transformation error:`, streamError);
-                    throw streamError;
-                }
-            };
-            // Create analytics promise that resolves after stream completion
-            const analyticsPromise = streamAnalyticsCollector.createAnalytics(this.providerName, this.modelName, result, Date.now() - startTime, {
-                requestId: `openai-stream-${Date.now()}`,
-                streamingMode: true,
-            });
-            return {
-                stream: transformedStream(),
-                provider: this.providerName,
-                model: this.modelName,
-                analytics: analyticsPromise,
-                metadata: {
-                    startTime,
-                    streamId: `openai-${Date.now()}`,
-                },
-            };
-        }
-        catch (error) {
-            timeoutController?.cleanup();
-            throw this.handleProviderError(error);
-        }
-    }
-    /**
-     * Generate embeddings for text using OpenAI text-embedding models
-     * @param text - The text to embed
-     * @param modelName - The embedding model to use (default: text-embedding-3-small)
-     * @returns Promise resolving to the embedding vector
-     */
-    async embed(text, modelName) {
-        const embeddingModelName = modelName || "text-embedding-3-small";
-        logger.debug("Generating embedding", {
-            provider: this.providerName,
-            model: embeddingModelName,
-            textLength: text.length,
-        });
-        try {
-            // Create embedding model using the AI SDK
-            // Create the OpenAI provider
-            const openai = createOpenAI({
-                apiKey: getOpenAIApiKey(),
-                fetch: createProxyFetch(),
-            });
-            // Get the text embedding model
-            const embeddingModel = openai.textEmbeddingModel(embeddingModelName);
-            // Generate the embedding
-            const result = await embed({
-                model: embeddingModel,
-                value: text,
-            });
-            logger.debug("Embedding generated successfully", {
-                provider: this.providerName,
-                model: embeddingModelName,
-                embeddingDimension: result.embedding.length,
-            });
-            return result.embedding;
-        }
-        catch (error) {
-            logger.error("Embedding generation failed", {
-                error: error instanceof Error ? error.message : String(error),
-                model: embeddingModelName,
-                textLength: text.length,
-            });
-            throw this.handleProviderError(error);
-        }
-    }
-    /**
-     * Generate embeddings for multiple texts in a single batch
-     * @param texts - The texts to embed
-     * @param modelName - The embedding model to use (default: text-embedding-3-small)
-     * @returns Promise resolving to an array of embedding vectors
-     */
-    async embedMany(texts, modelName) {
-        const embeddingModelName = modelName || "text-embedding-3-small";
-        logger.debug("Generating batch embeddings", {
-            provider: this.providerName,
-            model: embeddingModelName,
-            count: texts.length,
-        });
-        try {
-            const openai = createOpenAI({
-                apiKey: getOpenAIApiKey(),
-                fetch: createProxyFetch(),
-            });
-            const embeddingModel = openai.textEmbeddingModel(embeddingModelName);
-            const result = await embedMany({
-                model: embeddingModel,
-                values: texts,
-            });
-            logger.debug("Batch embeddings generated successfully", {
-                provider: this.providerName,
-                model: embeddingModelName,
-                count: result.embeddings.length,
-                embeddingDimension: result.embeddings[0]?.length,
-            });
-            return result.embeddings;
-        }
-        catch (error) {
-            logger.error("Batch embedding generation failed", {
-                error: error instanceof Error ? error.message : String(error),
-                model: embeddingModelName,
-                count: texts.length,
-            });
-            throw this.handleProviderError(error);
-        }
-    }
-}
-// Export for factory registration
-export default OpenAIProvider;