@juspay/neurolink 9.42.0 → 9.43.0

package/dist/providers/litellm.d.ts

@@ -29,6 +29,7 @@ export declare class LiteLLMProvider extends BaseProvider {
      * Note: This is only used when tools are disabled
      */
     protected executeStream(options: StreamOptions, analysisSchema?: ZodType | Schema<unknown>): Promise<StreamResult>;
+    private createLiteLLMTransformedStream;
     /**
      * Generate an embedding for a single text input
      * Uses the LiteLLM proxy with OpenAI-compatible embedding API

package/dist/providers/litellm.js

@@ -1,6 +1,6 @@
 import { createOpenAI } from "@ai-sdk/openai";
 import { SpanKind, SpanStatusCode, trace } from "@opentelemetry/api";
-import { NoOutputGeneratedError, Output, streamText } from "ai";
+import { NoOutputGeneratedError, Output, streamText, } from "ai";
 import { BaseProvider } from "../core/baseProvider.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
@@ -10,7 +10,7 @@ import { isAbortError } from "../utils/errorHandling.js";
 import { logger } from "../utils/logger.js";
 import { calculateCost } from "../utils/pricing.js";
 import { getProviderModel } from "../utils/providerConfig.js";
-import { composeAbortSignals, createTimeoutController, TimeoutError } from "../utils/timeout.js";
+import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { resolveToolChoice } from "../utils/toolChoice.js";
 import { getModelId } from "./providerTypeUtils.js";
 const streamTracer = trace.getTracer("neurolink.provider.litellm");
@@ -86,15 +86,18 @@ export class LiteLLMProvider extends BaseProvider {
         // Check for timeout by error name and message as fallback
         const errorRecord = error;
         if (errorRecord?.name === "TimeoutError" ||
-            (typeof errorRecord?.message === "string" && errorRecord.message.toLowerCase().includes("timeout"))) {
+            (typeof errorRecord?.message === "string" &&
+                errorRecord.message.toLowerCase().includes("timeout"))) {
             return new NetworkError(`Request timed out: ${errorRecord?.message || "Unknown timeout"}`, this.providerName);
         }
         if (typeof errorRecord?.message === "string") {
-            if (errorRecord.message.includes("ECONNREFUSED") || errorRecord.message.includes("Failed to fetch")) {
+            if (errorRecord.message.includes("ECONNREFUSED") ||
+                errorRecord.message.includes("Failed to fetch")) {
                 return new NetworkError("LiteLLM proxy server not available. Please start the LiteLLM proxy server at " +
                     `${process.env.LITELLM_BASE_URL || "http://localhost:4000"}`, this.providerName);
             }
-            if (errorRecord.message.includes("API_KEY_INVALID") || errorRecord.message.includes("Invalid API key")) {
+            if (errorRecord.message.includes("API_KEY_INVALID") ||
+                errorRecord.message.includes("Invalid API key")) {
                 return new AuthenticationError("Invalid LiteLLM configuration. Please check your LITELLM_API_KEY environment variable.", this.providerName);
             }
             if (errorRecord.message.toLowerCase().includes("rate limit")) {
@@ -131,7 +134,9 @@ export class LiteLLMProvider extends BaseProvider {
             const model = await this.getAISDKModelWithMiddleware(options); // This is where network connection happens!
             // Get tools - options.tools is pre-merged by BaseProvider.stream()
             const shouldUseTools = !options.disableTools && this.supportsTools();
-            const tools = shouldUseTools ? options.tools || (await this.getAllTools()) : {};
+            const tools = shouldUseTools
+                ? options.tools || (await this.getAllTools())
+                : {};
             logger.debug(`LiteLLM: Tools for streaming`, {
                 shouldUseTools,
                 toolCount: Object.keys(tools).length,
@@ -188,7 +193,8 @@ export class LiteLLMProvider extends BaseProvider {
                             toolName: toolCall.toolName,
                             args: toolCall.args ??
                                 toolCall.input ??
-                                toolCall.parameters ??
+                                toolCall
+                                    .parameters ??
                                 {},
                         });
                     }
@@ -197,7 +203,8 @@ export class LiteLLMProvider extends BaseProvider {
                         collectedToolResults.push({
                             toolName: toolResult.toolName,
                             status: rawToolResult.error ? "failure" : "success",
-                            output: (rawToolResult.output ?? rawToolResult.result) ?? undefined,
+                            output: (rawToolResult.output ??
+                                rawToolResult.result) ?? undefined,
                             error: rawToolResult.error,
                             id: rawToolResult.toolCallId ?? toolResult.toolName,
                         });
@@ -243,7 +250,9 @@ export class LiteLLMProvider extends BaseProvider {
             catch (streamError) {
                 streamSpan.setStatus({
                     code: SpanStatusCode.ERROR,
-                    message: streamError instanceof Error ? streamError.message : String(streamError),
+                    message: streamError instanceof Error
+                        ? streamError.message
+                        : String(streamError),
                 });
                 streamSpan.end();
                 throw streamError;
@@ -285,59 +294,11 @@ export class LiteLLMProvider extends BaseProvider {
                 streamSpan.end();
             });
             timeoutController?.cleanup();
-            // Transform stream to content object stream using fullStream (handles both text and tool calls)
-            // Note: fullStream includes tool results, textStream only has text
-            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(`LiteLLM: Error chunk received:`, {
-                                    errorType: errorChunk.type,
-                                    errorDetails: errorChunk.error,
-                                });
-                                throw new Error(`LiteLLM 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("LiteLLM: 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("LiteLLM: Stream produced no output (NoOutputGeneratedError)");
-                        return;
-                    }
-                    throw streamError;
-                }
-            })();
+            const transformedStream = this.createLiteLLMTransformedStream(result);
             // Create analytics promise that resolves after stream completion
             const analyticsPromise = streamAnalyticsCollector.createAnalytics(this.providerName, this.modelName, result, Date.now() - startTime, {
-                requestId: options.requestId ?? `litellm-stream-${Date.now()}`,
+                requestId: options.requestId ??
+                    `litellm-stream-${Date.now()}`,
                 streamingMode: true,
             });
             return {
@@ -360,6 +321,47 @@ export class LiteLLMProvider extends BaseProvider {
             throw this.handleProviderError(error);
         }
     }
+    async *createLiteLLMTransformedStream(result) {
+        try {
+            const streamToUse = result.fullStream || result.textStream;
+            for await (const chunk of streamToUse) {
+                if (chunk && typeof chunk === "object") {
+                    if ("type" in chunk && chunk.type === "error") {
+                        const errorChunk = chunk;
+                        logger.error(`LiteLLM: Error chunk received:`, {
+                            errorType: errorChunk.type,
+                            errorDetails: errorChunk.error,
+                        });
+                        throw this.formatProviderError(new Error(`LiteLLM streaming error: ${errorChunk.error?.message || "Unknown error"}`));
+                    }
+                    if ("textDelta" in chunk) {
+                        const textDelta = chunk.textDelta;
+                        if (textDelta) {
+                            yield { content: textDelta };
+                        }
+                    }
+                    else if ("type" in chunk &&
+                        chunk.type === "tool-call" &&
+                        "toolCallId" in chunk) {
+                        logger.debug("LiteLLM: Tool call", {
+                            toolCallId: String(chunk.toolCallId),
+                            toolName: "toolName" in chunk ? String(chunk.toolName) : "unknown",
+                        });
+                    }
+                }
+                else if (typeof chunk === "string") {
+                    yield { content: chunk };
+                }
+            }
+        }
+        catch (streamError) {
+            if (NoOutputGeneratedError.isInstance(streamError)) {
+                logger.warn("LiteLLM: Stream produced no output (NoOutputGeneratedError)");
+                return;
+            }
+            throw streamError;
+        }
+    }
     /**
      * Generate an embedding for a single text input
      * Uses the LiteLLM proxy with OpenAI-compatible embedding API
@@ -368,7 +370,9 @@ export class LiteLLMProvider extends BaseProvider {
         const { embed: aiEmbed } = await import("ai");
         const { createOpenAI } = await import("@ai-sdk/openai");
         const config = getLiteLLMConfig();
-        const embeddingModelName = modelName || process.env.LITELLM_EMBEDDING_MODEL || "gemini-embedding-001";
+        const embeddingModelName = modelName ||
+            process.env.LITELLM_EMBEDDING_MODEL ||
+            "gemini-embedding-001";
         const customOpenAI = createOpenAI({
             baseURL: config.baseURL,
             apiKey: config.apiKey,
@@ -386,7 +390,9 @@ export class LiteLLMProvider extends BaseProvider {
         const { embedMany: aiEmbedMany } = await import("ai");
         const { createOpenAI } = await import("@ai-sdk/openai");
         const config = getLiteLLMConfig();
-        const embeddingModelName = modelName || process.env.LITELLM_EMBEDDING_MODEL || "gemini-embedding-001";
+        const embeddingModelName = modelName ||
+            process.env.LITELLM_EMBEDDING_MODEL ||
+            "gemini-embedding-001";
         const customOpenAI = createOpenAI({
             baseURL: config.baseURL,
             apiKey: config.apiKey,
@@ -405,7 +411,8 @@ export class LiteLLMProvider extends BaseProvider {
         const now = Date.now();
         // Check if cached models are still valid
         if (LiteLLMProvider.modelsCache.length > 0 &&
-            now - LiteLLMProvider.modelsCacheTime < LiteLLMProvider.MODELS_CACHE_DURATION) {
+            now - LiteLLMProvider.modelsCacheTime <
+                LiteLLMProvider.MODELS_CACHE_DURATION) {
             logger.debug(`[${functionTag}] Using cached models`, {
                 cacheAge: Math.round((now - LiteLLMProvider.modelsCacheTime) / 1000),
                 modelCount: LiteLLMProvider.modelsCache.length,
@@ -431,7 +438,9 @@ export class LiteLLMProvider extends BaseProvider {
             });
         }
         // Fallback to hardcoded list if API fetch fails
-        const fallbackModels = process.env.LITELLM_FALLBACK_MODELS?.split(",").map((m) => m.trim()) || [
+        const fallbackModels = process.env.LITELLM_FALLBACK_MODELS?.split(",")
+            .map((m) => m.trim())
+            .filter((m) => m.length > 0) || [
             "openai/gpt-4o", // minimal safe baseline
             "anthropic/claude-3-haiku",
             "meta-llama/llama-3.1-8b-instruct",

package/dist/providers/ollama.js

@@ -40,6 +40,11 @@ const getOllamaTimeout = () => {
     // especially for larger models like aliafshar/gemma3-it-qat-tools:latest (12.2B parameters)
     return parseInt(process.env.OLLAMA_TIMEOUT || "240000", 10);
 };
+function isOllamaHttpError(error) {
+    return (error instanceof ProviderError &&
+        typeof error.statusCode === "number" &&
+        typeof error.responseBody === "string");
+}
 async function createOllamaHttpError(response) {
     let responseBody = "";
     try {
@@ -49,7 +54,11 @@ async function createOllamaHttpError(response) {
         // Ignore unreadable bodies
     }
     const suffix = responseBody ? ` - ${responseBody.slice(0, 500)}` : "";
-    return new Error(`Ollama API error: ${response.status} ${response.statusText}${suffix}`);
+    const error = new ProviderError(`Ollama API error: ${response.status} ${response.statusText}${suffix}`, "ollama");
+    error.statusCode = response.status;
+    error.statusText = response.statusText;
+    error.responseBody = responseBody;
+    return error;
 }
 // Create proxy-aware fetch instance
 const proxyFetch = createProxyFetch();
@@ -1538,12 +1547,16 @@ export class OllamaProvider extends BaseProvider {
             return new InvalidModelError(`❌ Ollama Model Not Found\n\nModel '${this.modelName}' is not available locally.\n\n🔧 Install Model:\n1. Run: ollama pull ${this.modelName}\n2. Or try a different model:\n   - ollama pull ${FALLBACK_OLLAMA_MODEL}\n   - ollama pull mistral:latest\n   - ollama pull codellama:latest\n\n🔧 List Available Models:\nollama list`, this.providerName);
         }
         const errMsg = error.message ?? "";
-        if (errMsg.includes("404") &&
-            (errMsg.toLowerCase().includes("model") ||
+        const httpStatus = isOllamaHttpError(error) ? error.statusCode : undefined;
+        const responseBody = isOllamaHttpError(error) ? error.responseBody : "";
+        if (httpStatus === 404 &&
+            (responseBody.toLowerCase().includes("model") ||
+                responseBody.toLowerCase().includes("not found") ||
+                errMsg.toLowerCase().includes("model") ||
                 errMsg.toLowerCase().includes("not found"))) {
             return new InvalidModelError(`❌ Ollama Returned HTTP 404\n\nThis usually means the configured model '${this.modelName}' is not installed locally, although a bad base URL or incompatible API mode can also cause it.\n\n🔧 Check:\n1. Verify the model exists: 'ollama list'\n2. Pull it if missing: 'ollama pull ${this.modelName}'\n3. Verify the service is healthy: 'curl ${this.baseUrl}/api/version'\n4. If you use OpenAI-compatible mode, confirm the base URL serves /v1/chat/completions`, this.providerName);
         }
-        if (errMsg.includes("404")) {
+        if (httpStatus === 404) {
             return new ProviderError(`❌ Ollama Endpoint Returned HTTP 404\n\nThe configured base URL (${this.baseUrl}) did not serve the expected Ollama endpoint for model '${this.modelName}'. This is usually a configuration or API-mode mismatch rather than a missing model.\n\n🔧 Check:\n1. Verify the base URL: ${this.baseUrl}\n2. For native Ollama mode, confirm /api/generate exists\n3. For OpenAI-compatible mode, confirm /v1/chat/completions exists\n4. If the model is missing, the response body should explicitly say so`, this.providerName);
         }
         return new ProviderError(`❌ Ollama Provider Error\n\n${error.message || "Unknown error occurred"}\n\n🔧 Troubleshooting:\n1. Check if Ollama service is running\n2. Verify model is installed: 'ollama list'\n3. Check network connectivity to ${this.baseUrl}\n4. Review Ollama logs for details`, this.providerName);

package/dist/providers/openAI.d.ts

@@ -52,6 +52,8 @@ export declare class OpenAIProvider extends BaseProvider {
      * and the migration guide in the project repository.
      */
     protected executeStream(options: StreamOptions, _analysisSchema?: ValidationSchema): Promise<StreamResult>;
+    private createOpenAITransformedStream;
+    private extractOpenAIChunkContent;
     /**
      * Generate embeddings for text using OpenAI text-embedding models
      * @param text - The text to embed

package/dist/providers/openAI.js

@@ -279,6 +279,16 @@ export class OpenAIProvider extends BaseProvider {
             // Build message array from options with multimodal support
             // Using protected helper from BaseProvider to eliminate code duplication
             const messages = await this.buildMessagesForStream(options);
+            let resolvedToolChoice = resolveToolChoice(options, tools, shouldUseTools);
+            // Guard: if toolChoice names a specific tool that was filtered out, fall back to "auto"
+            if (resolvedToolChoice !== null &&
+                typeof resolvedToolChoice === "object" &&
+                "toolName" in resolvedToolChoice &&
+                typeof resolvedToolChoice.toolName === "string" &&
+                !tools[resolvedToolChoice.toolName]) {
+                logger.warn(`OpenAI: toolChoice references tool "${resolvedToolChoice.toolName}" which was removed during filtering; falling back to "auto"`);
+                resolvedToolChoice = "auto";
+            }
             // Debug the actual request being sent to OpenAI
             logger.debug(`OpenAI: streamText request parameters:`, {
                 modelName: this.modelName,
@@ -286,7 +296,7 @@ export class OpenAIProvider extends BaseProvider {
                 temperature: options.temperature,
                 maxTokens: options.maxTokens,
                 toolsCount: Object.keys(tools).length,
-                toolChoice: shouldUseTools && Object.keys(tools).length > 0 ? "auto" : "none",
+                toolChoice: resolvedToolChoice,
                 maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
                 firstToolExample: Object.keys(tools).length > 0
                     ? {
@@ -315,7 +325,7 @@ export class OpenAIProvider extends BaseProvider {
                     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: resolveToolChoice(options, tools, shouldUseTools),
+                    toolChoice: resolvedToolChoice,
                     abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
                     experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
                     onStepFinish: ({ toolCalls, toolResults }) => {
@@ -382,150 +392,14 @@ export class OpenAIProvider extends BaseProvider {
                 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;
-                }
-            };
+            const transformedStream = this.createOpenAITransformedStream(result, shouldUseTools, tools);
             // 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(),
+                stream: transformedStream,
                 provider: this.providerName,
                 model: this.modelName,
                 analytics: analyticsPromise,
@@ -540,6 +414,131 @@ export class OpenAIProvider extends BaseProvider {
             throw this.handleProviderError(error);
         }
     }
+    async *createOpenAITransformedStream(result, shouldUseTools, tools) {
+        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;
+            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",
+                });
+                const contentToYield = this.extractOpenAIChunkContent(chunk);
+                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) {
+            if (NoOutputGeneratedError.isInstance(streamError)) {
+                logger.warn("OpenAI: Stream produced no output (NoOutputGeneratedError)");
+                return;
+            }
+            logger.error(`OpenAI: Stream transformation error:`, streamError);
+            throw streamError;
+        }
+    }
+    extractOpenAIChunkContent(chunk) {
+        if (chunk && typeof chunk === "object") {
+            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") {
+                const errorChunk = chunk;
+                logger.error(`OpenAI: Error chunk received:`, {
+                    errorType: errorChunk.type,
+                    errorDetails: errorChunk.error,
+                    fullChunk: JSON.stringify(chunk),
+                });
+                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`);
+            }
+            if ("type" in chunk &&
+                chunk.type === "text-delta" &&
+                "textDelta" in chunk) {
+                const textDelta = chunk.textDelta;
+                logger.debug(`OpenAI: Found text-delta:`, { textDelta });
+                return textDelta;
+            }
+            if ("text" in chunk) {
+                const text = chunk.text;
+                logger.debug(`OpenAI: Found direct text:`, { text });
+                return text;
+            }
+            if (process.env.NEUROLINK_DEBUG === "true") {
+                logger.debug(`OpenAI: Unhandled object chunk:`, {
+                    chunkKeys: Object.keys(chunk),
+                    chunkType: "type" in chunk
+                        ? String(chunk.type)
+                        : "no-type",
+                    fullChunk: JSON.stringify(chunk).substring(0, 500),
+                });
+            }
+            return null;
+        }
+        if (typeof chunk === "string") {
+            logger.debug(`OpenAI: Found string chunk:`, {
+                content: chunk,
+            });
+            return chunk;
+        }
+        logger.warn(`OpenAI: Unhandled chunk type:`, {
+            type: typeof chunk,
+            value: String(chunk).substring(0, 100),
+        });
+        return null;
+    }
     /**
      * Generate embeddings for text using OpenAI text-embedding models
      * @param text - The text to embed