@juspay/neurolink 9.14.0 → 9.16.0

package/dist/lib/providers/ollama.js

@@ -6,7 +6,9 @@ import { createProxyFetch } from "../proxy/proxyFetch.js";
 import { logger } from "../utils/logger.js";
 import { buildMultimodalMessagesArray } from "../utils/messageBuilder.js";
 import { buildMultimodalOptions } from "../utils/multimodalOptionsBuilder.js";
+import { estimateTokens } from "../utils/tokenEstimation.js";
 import { InvalidModelError, NetworkError, ProviderError, } from "../types/errors.js";
+import { tracers, ATTR, withClientSpan } from "../telemetry/index.js";
 import { TimeoutError } from "../utils/timeout.js";
 // Model version constants (configurable via environment)
 const DEFAULT_OLLAMA_MODEL = "llama3.1:8b";
@@ -55,8 +57,8 @@ class OllamaLanguageModel {
         this.baseUrl = baseUrl;
         this.timeout = timeout;
     }
-    estimateTokens(text) {
-        return Math.ceil(text.length / 4);
+    estimateTokenCount(text) {
+        return estimateTokens(text, "ollama");
     }
     convertMessagesToPrompt(messages) {
         return messages
@@ -87,7 +89,9 @@ class OllamaLanguageModel {
                 max_tokens: options.maxTokens,
                 stream: false,
             };
-            logger.debug("[OllamaLanguageModel] Using OpenAI-compatible API with messages:", JSON.stringify(messages, null, 2));
+            if (logger.shouldLog("debug")) {
+                logger.debug("[OllamaLanguageModel] Using OpenAI-compatible API with messages:", JSON.stringify(messages, null, 2));
+            }
             const response = await proxyFetch(`${this.baseUrl}/v1/chat/completions`, {
                 method: "POST",
                 headers: { "Content-Type": "application/json" },
@@ -105,8 +109,8 @@ class OllamaLanguageModel {
                 text,
                 usage: {
                     promptTokens: usage.prompt_tokens ??
-                        this.estimateTokens(JSON.stringify(messages)),
-                    completionTokens: usage.completion_tokens ?? this.estimateTokens(text),
+                        this.estimateTokenCount(JSON.stringify(messages)),
+                    completionTokens: usage.completion_tokens ?? this.estimateTokenCount(text),
                     totalTokens: usage.total_tokens,
                 },
                 finishReason: "stop",
@@ -150,11 +154,12 @@ class OllamaLanguageModel {
             return {
                 text: data.response,
                 usage: {
-                    promptTokens: data.prompt_eval_count ?? this.estimateTokens(prompt),
-                    completionTokens: data.eval_count ?? this.estimateTokens(String(data.response ?? "")),
-                    totalTokens: (data.prompt_eval_count ?? this.estimateTokens(prompt)) +
+                    promptTokens: data.prompt_eval_count ?? this.estimateTokenCount(prompt),
+                    completionTokens: data.eval_count ??
+                        this.estimateTokenCount(String(data.response ?? "")),
+                    totalTokens: (data.prompt_eval_count ?? this.estimateTokenCount(prompt)) +
                         (data.eval_count ??
-                            this.estimateTokens(String(data.response ?? ""))),
+                            this.estimateTokenCount(String(data.response ?? ""))),
                 },
                 finishReason: "stop",
                 rawCall: {
@@ -329,7 +334,7 @@ class OllamaLanguageModel {
                                     finishReason: "stop",
                                     usage: {
                                         promptTokens: data.prompt_eval_count ||
-                                            this.estimateTokens(data.context || ""),
+                                            this.estimateTokenCount(data.context || ""),
                                         completionTokens: data.eval_count || 0,
                                     },
                                 };
@@ -357,8 +362,11 @@ class OllamaLanguageModel {
         const decoder = new TextDecoder();
         let buffer = "";
         // Estimate prompt tokens from messages (matches non-streaming behavior)
-        const totalPromptTokens = this.estimateTokens(JSON.stringify(messages));
-        let totalCompletionTokens = 0;
+        const totalPromptTokens = this.estimateTokenCount(JSON.stringify(messages));
+        // Accumulate full completion text; estimate tokens once at the end to avoid
+        // per-chunk rounding inflation that occurs when estimateTokenCount is called
+        // on every delta and the results are summed.
+        let completionText = "";
         try {
             while (true) {
                 const { done, value } = await reader.read();
@@ -384,14 +392,16 @@ class OllamaLanguageModel {
                                     type: "text-delta",
                                     textDelta: content,
                                 };
-                                totalCompletionTokens += this.estimateTokens(content);
+                                completionText += content;
                             }
                             // Check for finish
                             const finishReason = data.choices?.[0]?.finish_reason;
                             if (finishReason === "stop") {
-                                // Extract usage if available and update tokens
+                                // Prefer server-reported usage; fall back to a single estimate over
+                                // the full accumulated text (avoids per-chunk rounding inflation).
                                 const promptTokens = data.usage?.prompt_tokens || totalPromptTokens;
-                                const completionTokens = data.usage?.completion_tokens || totalCompletionTokens;
+                                const completionTokens = data.usage?.completion_tokens ||
+                                    this.estimateTokenCount(completionText);
                                 yield {
                                     type: "finish",
                                     finishReason: "stop",
@@ -418,7 +428,7 @@ class OllamaLanguageModel {
                 finishReason: "stop",
                 usage: {
                     promptTokens: totalPromptTokens,
-                    completionTokens: totalCompletionTokens,
+                    completionTokens: this.estimateTokenCount(completionText),
                 },
             };
         }
@@ -604,289 +614,330 @@ export class OllamaProvider extends BaseProvider {
      * Uses conversation loop to handle multi-step tool execution
      */
     async executeStreamWithTools(options, _analysisSchema) {
-        const startTime = Date.now();
-        const maxIterations = options.maxSteps || DEFAULT_MAX_STEPS;
-        let iteration = 0;
-        // Get all available tools (direct + MCP + external)
-        // BaseProvider.stream() pre-merges base tools + external tools into options.tools
-        const allTools = options.tools ||
-            (await this.getAllTools());
-        // Convert tools to Ollama format
-        const ollamaTools = this.convertToolsToOllamaFormat(allTools);
-        // Validate that PDFs are not provided
-        if (options.input?.pdfFiles && options.input.pdfFiles.length > 0) {
-            throw new Error("PDF inputs are not supported by OllamaProvider. " +
-                "Please remove PDFs or use a supported provider (OpenAI, Anthropic, Google Vertex AI, etc.).");
-        }
-        // Initialize conversation history
-        const conversationHistory = [];
-        // Build initial messages
-        const hasMultimodalInput = !!(options.input?.images?.length ||
-            options.input?.content?.length ||
-            options.input?.files?.length ||
-            options.input?.csvFiles?.length);
-        if (hasMultimodalInput) {
-            logger.debug(`Ollama: Detected multimodal input, using multimodal message builder`, {
-                hasImages: !!options.input?.images?.length,
-                imageCount: options.input?.images?.length || 0,
-            });
-            const multimodalOptions = buildMultimodalOptions(options, this.providerName, this.modelName);
-            const multimodalMessages = await buildMultimodalMessagesArray(multimodalOptions, this.providerName, this.modelName);
-            conversationHistory.push(...this.convertToOllamaMessages(multimodalMessages));
-        }
-        else {
-            if (options.systemPrompt) {
+        return withClientSpan({
+            name: "neurolink.provider.stream",
+            tracer: tracers.provider,
+            attributes: {
+                [ATTR.GEN_AI_SYSTEM]: "ollama",
+                [ATTR.GEN_AI_MODEL]: this.modelName || FALLBACK_OLLAMA_MODEL,
+                [ATTR.GEN_AI_OPERATION]: "stream",
+                [ATTR.NL_HAS_TOOLS]: true,
+                [ATTR.NL_STREAM_MODE]: true,
+            },
+        }, async (span) => {
+            const startTime = Date.now();
+            const maxIterations = options.maxSteps || DEFAULT_MAX_STEPS;
+            let iteration = 0;
+            // Get all available tools (direct + MCP + external)
+            // BaseProvider.stream() pre-merges base tools + external tools into options.tools
+            const allTools = options.tools ||
+                (await this.getAllTools());
+            // Convert tools to Ollama format
+            const ollamaTools = this.convertToolsToOllamaFormat(allTools);
+            span.setAttribute(ATTR.NL_TOOL_COUNT, ollamaTools.length);
+            // Validate that PDFs are not provided
+            if (options.input?.pdfFiles && options.input.pdfFiles.length > 0) {
+                throw this.handleProviderError(new Error("PDF inputs are not supported by OllamaProvider. " +
+                    "Please remove PDFs or use a supported provider (OpenAI, Anthropic, Google Vertex AI, etc.)."));
+            }
+            // Initialize conversation history
+            const conversationHistory = [];
+            // Build initial messages
+            const hasMultimodalInput = !!(options.input?.images?.length ||
+                options.input?.content?.length ||
+                options.input?.files?.length ||
+                options.input?.csvFiles?.length);
+            if (hasMultimodalInput) {
+                logger.debug(`Ollama: Detected multimodal input, using multimodal message builder`, {
+                    hasImages: !!options.input?.images?.length,
+                    imageCount: options.input?.images?.length || 0,
+                });
+                const multimodalOptions = buildMultimodalOptions(options, this.providerName, this.modelName);
+                const multimodalMessages = await buildMultimodalMessagesArray(multimodalOptions, this.providerName, this.modelName);
+                conversationHistory.push(...this.convertToOllamaMessages(multimodalMessages));
+            }
+            else {
+                if (options.systemPrompt) {
+                    conversationHistory.push({
+                        role: "system",
+                        content: options.systemPrompt,
+                    });
+                }
                 conversationHistory.push({
-                    role: "system",
-                    content: options.systemPrompt,
+                    role: "user",
+                    content: options.input.text,
                 });
             }
-            conversationHistory.push({
-                role: "user",
-                content: options.input.text,
-            });
-        }
-        // Conversation loop for multi-step tool execution
-        const stream = new ReadableStream({
-            start: async (controller) => {
-                try {
-                    while (iteration < maxIterations) {
-                        logger.debug(`[OllamaProvider] Conversation iteration ${iteration + 1}/${maxIterations}`);
-                        // Make API request
-                        const response = await proxyFetch(`${this.baseUrl}/v1/chat/completions`, {
-                            method: "POST",
-                            headers: { "Content-Type": "application/json" },
-                            body: JSON.stringify({
-                                model: this.modelName || FALLBACK_OLLAMA_MODEL,
-                                messages: conversationHistory,
-                                tools: ollamaTools,
-                                tool_choice: "auto",
-                                stream: true,
-                                temperature: options.temperature,
-                                max_tokens: options.maxTokens,
-                            }),
-                            signal: createAbortSignalWithTimeout(this.timeout),
-                        });
-                        if (!response.ok) {
-                            throw new Error(`Ollama API error: ${response.status} ${response.statusText}`);
-                        }
-                        // Process response stream
-                        const { content, toolCalls, finishReason } = await this.processOllamaResponse(response, controller);
-                        // Add assistant message to history
-                        const assistantMessage = {
-                            role: "assistant",
-                            content: content || "",
-                        };
-                        if (toolCalls && toolCalls.length > 0) {
-                            assistantMessage.tool_calls = toolCalls;
-                        }
-                        conversationHistory.push(assistantMessage);
-                        // Check finish reason
-                        if (finishReason === "stop" || !finishReason) {
-                            // Conversation complete
-                            controller.close();
-                            break;
-                        }
-                        else if (finishReason === "tool_calls" &&
-                            toolCalls &&
-                            toolCalls.length > 0) {
-                            // Execute tools
-                            logger.debug(`[OllamaProvider] Executing ${toolCalls.length} tools`);
-                            const toolResults = await this.executeOllamaTools(toolCalls, options);
-                            // Add tool results to conversation
-                            const toolMessage = {
-                                role: "tool",
-                                content: JSON.stringify(toolResults),
-                            };
-                            conversationHistory.push(toolMessage);
-                            iteration++;
-                        }
-                        else if (finishReason === "length") {
-                            // Max tokens reached, continue conversation
-                            logger.debug(`[OllamaProvider] Max tokens reached, continuing`);
-                            conversationHistory.push({
-                                role: "user",
-                                content: "Please continue.",
+            // Conversation loop for multi-step tool execution
+            const stream = new ReadableStream({
+                start: async (controller) => {
+                    try {
+                        while (iteration < maxIterations) {
+                            logger.debug(`[OllamaProvider] Conversation iteration ${iteration + 1}/${maxIterations}`);
+                            // Make API request
+                            const response = await proxyFetch(`${this.baseUrl}/v1/chat/completions`, {
+                                method: "POST",
+                                headers: { "Content-Type": "application/json" },
+                                body: JSON.stringify({
+                                    model: this.modelName || FALLBACK_OLLAMA_MODEL,
+                                    messages: conversationHistory,
+                                    tools: ollamaTools,
+                                    tool_choice: "auto",
+                                    stream: true,
+                                    temperature: options.temperature,
+                                    max_tokens: options.maxTokens,
+                                }),
+                                signal: createAbortSignalWithTimeout(this.timeout),
                             });
-                            iteration++;
+                            if (!response.ok) {
+                                throw this.handleProviderError(new Error(`Ollama API error: ${response.status} ${response.statusText}`));
+                            }
+                            // Process response stream
+                            const { content, toolCalls, finishReason } = await this.processOllamaResponse(response, controller);
+                            // Add assistant message to history
+                            const assistantMessage = {
+                                role: "assistant",
+                                content: content || "",
+                            };
+                            if (toolCalls && toolCalls.length > 0) {
+                                assistantMessage.tool_calls = toolCalls;
+                            }
+                            conversationHistory.push(assistantMessage);
+                            // Check finish reason
+                            if (finishReason === "stop" || !finishReason) {
+                                // Conversation complete
+                                span.setAttribute(ATTR.GEN_AI_FINISH_REASON, finishReason || "stop");
+                                controller.close();
+                                break;
+                            }
+                            else if (finishReason === "tool_calls" &&
+                                toolCalls &&
+                                toolCalls.length > 0) {
+                                // Execute tools
+                                logger.debug(`[OllamaProvider] Executing ${toolCalls.length} tools`);
+                                for (const tc of toolCalls) {
+                                    span.addEvent("tool_call", {
+                                        [ATTR.GEN_AI_TOOL_NAME]: tc.function.name,
+                                    });
+                                }
+                                const toolResults = await this.executeOllamaTools(toolCalls, options);
+                                // Add tool results to conversation
+                                const toolMessage = {
+                                    role: "tool",
+                                    content: JSON.stringify(toolResults),
+                                };
+                                conversationHistory.push(toolMessage);
+                                iteration++;
+                            }
+                            else if (finishReason === "length") {
+                                // Max tokens reached, continue conversation
+                                logger.debug(`[OllamaProvider] Max tokens reached, continuing`);
+                                conversationHistory.push({
+                                    role: "user",
+                                    content: "Please continue.",
+                                });
+                                iteration++;
+                            }
+                            else {
+                                // Unknown finish reason, end conversation
+                                logger.warn(`[OllamaProvider] Unknown finish reason: ${finishReason}`);
+                                span.setAttribute(ATTR.GEN_AI_FINISH_REASON, finishReason);
+                                controller.close();
+                                break;
+                            }
                         }
-                        else {
-                            // Unknown finish reason, end conversation
-                            logger.warn(`[OllamaProvider] Unknown finish reason: ${finishReason}`);
-                            controller.close();
-                            break;
+                        if (iteration >= maxIterations) {
+                            controller.error(new Error(`Ollama conversation exceeded maximum iterations (${maxIterations})`));
                         }
                     }
-                    if (iteration >= maxIterations) {
-                        controller.error(new Error(`Ollama conversation exceeded maximum iterations (${maxIterations})`));
+                    catch (error) {
+                        controller.error(error);
                     }
-                }
-                catch (error) {
-                    controller.error(error);
-                }
-            },
+                    finally {
+                        // Resolve analytics with final values now that the loop has completed.
+                        resolveAnalytics(createAnalytics(this.providerName, this.modelName || FALLBACK_OLLAMA_MODEL, { usage: { input: 0, output: 0, total: 0 } }, Date.now() - startTime, {
+                            requestId: `ollama-stream-${Date.now()}`,
+                            streamingMode: true,
+                            iterations: iteration,
+                            note: "Token usage not available from Ollama streaming responses",
+                        }));
+                    }
+                },
+            });
+            // Defer analytics resolution until the stream's start callback finishes.
+            // This ensures responseTime and iteration reflect the actual completed values
+            // rather than values captured before the tool-loop executes.
+            let resolveAnalytics;
+            const analyticsPromise = new Promise((resolve) => {
+                resolveAnalytics = resolve;
+            });
+            return {
+                stream: this.convertToAsyncIterable(stream),
+                provider: this.providerName,
+                model: this.modelName || FALLBACK_OLLAMA_MODEL,
+                analytics: analyticsPromise,
+                metadata: {
+                    startTime,
+                    streamId: `ollama-${Date.now()}`,
+                },
+            };
         });
-        // Create analytics promise
-        const analyticsPromise = Promise.resolve(createAnalytics(this.providerName, this.modelName || FALLBACK_OLLAMA_MODEL, { usage: { input: 0, output: 0, total: 0 } }, Date.now() - startTime, {
-            requestId: `ollama-stream-${Date.now()}`,
-            streamingMode: true,
-            iterations: iteration,
-            note: "Token usage not available from Ollama streaming responses",
-        }));
-        return {
-            stream: this.convertToAsyncIterable(stream),
-            provider: this.providerName,
-            model: this.modelName || FALLBACK_OLLAMA_MODEL,
-            analytics: analyticsPromise,
-            metadata: {
-                startTime,
-                streamId: `ollama-${Date.now()}`,
-            },
-        };
     }
     /**
      * Execute streaming without tools using the generate API
      * Fallback for non-tool scenarios or when chat API is unavailable
      */
     async executeStreamWithoutTools(options, _analysisSchema) {
-        // Validate that PDFs are not provided
-        if (options.input?.pdfFiles && options.input.pdfFiles.length > 0) {
-            throw new Error("PDF inputs are not supported by OllamaProvider. " +
-                "Please remove PDFs or use a supported provider (OpenAI, Anthropic, Google Vertex AI, etc.).");
-        }
-        // Check for multimodal input
-        const hasMultimodalInput = !!(options.input?.images?.length ||
-            options.input?.content?.length ||
-            options.input?.files?.length ||
-            options.input?.csvFiles?.length);
-        const useOpenAIMode = isOpenAICompatibleMode();
-        if (useOpenAIMode) {
-            // OpenAI-compatible mode: Use /v1/chat/completions with messages
-            logger.debug(`Ollama (OpenAI mode): Building messages for streaming`);
-            const messages = [];
-            if (options.systemPrompt) {
-                messages.push({ role: "system", content: options.systemPrompt });
+        return withClientSpan({
+            name: "neurolink.provider.stream",
+            tracer: tracers.provider,
+            attributes: {
+                [ATTR.GEN_AI_SYSTEM]: "ollama",
+                [ATTR.GEN_AI_MODEL]: this.modelName || FALLBACK_OLLAMA_MODEL,
+                [ATTR.GEN_AI_OPERATION]: "stream",
+                [ATTR.NL_HAS_TOOLS]: false,
+                [ATTR.NL_STREAM_MODE]: true,
+            },
+        }, async () => {
+            // Validate that PDFs are not provided
+            if (options.input?.pdfFiles && options.input.pdfFiles.length > 0) {
+                throw this.handleProviderError(new Error("PDF inputs are not supported by OllamaProvider. " +
+                    "Please remove PDFs or use a supported provider (OpenAI, Anthropic, Google Vertex AI, etc.)."));
             }
-            if (hasMultimodalInput) {
-                const multimodalOptions = buildMultimodalOptions(options, this.providerName, this.modelName);
-                const multimodalMessages = await buildMultimodalMessagesArray(multimodalOptions, this.providerName, this.modelName);
-                // Convert multimodal messages to text (OpenAI-compatible mode doesn't support images in /v1/chat/completions for Ollama)
-                const content = multimodalMessages
-                    .map((msg) => (typeof msg.content === "string" ? msg.content : ""))
-                    .join("\n");
-                messages.push({ role: "user", content });
+            // Check for multimodal input
+            const hasMultimodalInput = !!(options.input?.images?.length ||
+                options.input?.content?.length ||
+                options.input?.files?.length ||
+                options.input?.csvFiles?.length);
+            const useOpenAIMode = isOpenAICompatibleMode();
+            if (useOpenAIMode) {
+                // OpenAI-compatible mode: Use /v1/chat/completions with messages
+                logger.debug(`Ollama (OpenAI mode): Building messages for streaming`);
+                const messages = [];
+                if (options.systemPrompt) {
+                    messages.push({ role: "system", content: options.systemPrompt });
+                }
+                if (hasMultimodalInput) {
+                    const multimodalOptions = buildMultimodalOptions(options, this.providerName, this.modelName);
+                    const multimodalMessages = await buildMultimodalMessagesArray(multimodalOptions, this.providerName, this.modelName);
+                    // Convert multimodal messages to text (OpenAI-compatible mode doesn't support images in /v1/chat/completions for Ollama)
+                    const content = multimodalMessages
+                        .map((msg) => typeof msg.content === "string" ? msg.content : "")
+                        .join("\n");
+                    messages.push({ role: "user", content });
+                }
+                else {
+                    messages.push({ role: "user", content: options.input.text });
+                }
+                const requestUrl = `${this.baseUrl}/v1/chat/completions`;
+                const requestBody = {
+                    model: this.modelName || FALLBACK_OLLAMA_MODEL,
+                    messages,
+                    temperature: options.temperature,
+                    max_tokens: options.maxTokens,
+                    stream: true,
+                };
+                logger.debug(`[Ollama OpenAI Mode] About to fetch:`, {
+                    url: requestUrl,
+                    baseUrl: this.baseUrl,
+                    modelName: this.modelName,
+                    requestBody: JSON.stringify(requestBody),
+                });
+                const response = await proxyFetch(requestUrl, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify(requestBody),
+                    signal: createAbortSignalWithTimeout(this.timeout),
+                });
+                logger.debug(`[Ollama OpenAI Mode] Response received:`, {
+                    status: response.status,
+                    statusText: response.statusText,
+                    ok: response.ok,
+                });
+                if (!response.ok) {
+                    throw this.handleProviderError(new Error(`Ollama API error: ${response.status} ${response.statusText}`));
+                }
+                // Transform to async generator for OpenAI-compatible format
+                const self = this;
+                const transformedStream = async function* () {
+                    const generator = self.createOpenAIStream(response);
+                    for await (const chunk of generator) {
+                        yield chunk;
+                    }
+                };
+                return {
+                    stream: transformedStream(),
+                    provider: self.providerName,
+                    model: self.modelName,
+                };
             }
             else {
-                messages.push({ role: "user", content: options.input.text });
-            }
-            const requestUrl = `${this.baseUrl}/v1/chat/completions`;
-            const requestBody = {
-                model: this.modelName || FALLBACK_OLLAMA_MODEL,
-                messages,
-                temperature: options.temperature,
-                max_tokens: options.maxTokens,
-                stream: true,
-            };
-            logger.debug(`[Ollama OpenAI Mode] About to fetch:`, {
-                url: requestUrl,
-                baseUrl: this.baseUrl,
-                modelName: this.modelName,
-                requestBody: JSON.stringify(requestBody),
-            });
-            const response = await proxyFetch(requestUrl, {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify(requestBody),
-                signal: createAbortSignalWithTimeout(this.timeout),
-            });
-            logger.debug(`[Ollama OpenAI Mode] Response received:`, {
-                status: response.status,
-                statusText: response.statusText,
-                ok: response.ok,
-            });
-            if (!response.ok) {
-                throw new Error(`Ollama API error: ${response.status} ${response.statusText}`);
-            }
-            // Transform to async generator for OpenAI-compatible format
-            const self = this;
-            const transformedStream = async function* () {
-                const generator = self.createOpenAIStream(response);
-                for await (const chunk of generator) {
-                    yield chunk;
+                // Native Ollama mode: Use /api/generate
+                let prompt = options.input.text;
+                let images;
+                if (hasMultimodalInput) {
+                    logger.debug(`Ollama (native mode): Detected multimodal input`, {
+                        hasImages: !!options.input?.images?.length,
+                        imageCount: options.input?.images?.length || 0,
+                    });
+                    const multimodalOptions = buildMultimodalOptions(options, this.providerName, this.modelName);
+                    const multimodalMessages = await buildMultimodalMessagesArray(multimodalOptions, this.providerName, this.modelName);
+                    // Extract text from messages for prompt
+                    prompt = multimodalMessages
+                        .map((msg) => typeof msg.content === "string" ? msg.content : "")
+                        .join("\n");
+                    // Extract images
+                    images = this.extractImagesFromMessages(multimodalMessages);
                 }
-            };
-            return {
-                stream: transformedStream(),
-                provider: self.providerName,
-                model: self.modelName,
-            };
-        }
-        else {
-            // Native Ollama mode: Use /api/generate
-            let prompt = options.input.text;
-            let images;
-            if (hasMultimodalInput) {
-                logger.debug(`Ollama (native mode): Detected multimodal input`, {
-                    hasImages: !!options.input?.images?.length,
-                    imageCount: options.input?.images?.length || 0,
+                const requestBody = {
+                    model: this.modelName || FALLBACK_OLLAMA_MODEL,
+                    prompt,
+                    system: options.systemPrompt,
+                    stream: true,
+                    options: {
+                        temperature: options.temperature,
+                        num_predict: options.maxTokens,
+                    },
+                };
+                if (images && images.length > 0) {
+                    requestBody.images = images;
+                }
+                const requestUrl = `${this.baseUrl}/api/generate`;
+                logger.debug(`[Ollama Native Mode] About to fetch:`, {
+                    url: requestUrl,
+                    baseUrl: this.baseUrl,
+                    modelName: this.modelName,
+                    requestBody: JSON.stringify(requestBody),
                 });
-                const multimodalOptions = buildMultimodalOptions(options, this.providerName, this.modelName);
-                const multimodalMessages = await buildMultimodalMessagesArray(multimodalOptions, this.providerName, this.modelName);
-                // Extract text from messages for prompt
-                prompt = multimodalMessages
-                    .map((msg) => (typeof msg.content === "string" ? msg.content : ""))
-                    .join("\n");
-                // Extract images
-                images = this.extractImagesFromMessages(multimodalMessages);
-            }
-            const requestBody = {
-                model: this.modelName || FALLBACK_OLLAMA_MODEL,
-                prompt,
-                system: options.systemPrompt,
-                stream: true,
-                options: {
-                    temperature: options.temperature,
-                    num_predict: options.maxTokens,
-                },
-            };
-            if (images && images.length > 0) {
-                requestBody.images = images;
-            }
-            const requestUrl = `${this.baseUrl}/api/generate`;
-            logger.debug(`[Ollama Native Mode] About to fetch:`, {
-                url: requestUrl,
-                baseUrl: this.baseUrl,
-                modelName: this.modelName,
-                requestBody: JSON.stringify(requestBody),
-            });
-            const response = await proxyFetch(requestUrl, {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify(requestBody),
-                signal: createAbortSignalWithTimeout(this.timeout),
-            });
-            logger.debug(`[Ollama Native Mode] Response received:`, {
-                status: response.status,
-                statusText: response.statusText,
-                ok: response.ok,
-            });
-            if (!response.ok) {
-                throw new Error(`Ollama API error: ${response.status} ${response.statusText}`);
-            }
-            // Transform to async generator to match other providers
-            const self = this;
-            const transformedStream = async function* () {
-                const generator = self.createOllamaStream(response);
-                for await (const chunk of generator) {
-                    yield chunk;
+                const response = await proxyFetch(requestUrl, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify(requestBody),
+                    signal: createAbortSignalWithTimeout(this.timeout),
+                });
+                logger.debug(`[Ollama Native Mode] Response received:`, {
+                    status: response.status,
+                    statusText: response.statusText,
+                    ok: response.ok,
+                });
+                if (!response.ok) {
+                    throw this.handleProviderError(new Error(`Ollama API error: ${response.status} ${response.statusText}`));
                 }
-            };
-            return {
-                stream: transformedStream(),
-                provider: this.providerName,
-                model: this.modelName,
-            };
-        }
+                // Transform to async generator to match other providers
+                const self = this;
+                const transformedStream = async function* () {
+                    const generator = self.createOllamaStream(response);
+                    for await (const chunk of generator) {
+                        yield chunk;
+                    }
+                };
+                return {
+                    stream: transformedStream(),
+                    provider: this.providerName,
+                    model: this.modelName,
+                };
+            }
+        });
     }
     /**
      * Convert AI SDK tools format to Ollama's function calling format