@juspay/neurolink 8.3.0 → 8.4.1

package/dist/providers/ollama.js

@@ -15,6 +15,11 @@ const FALLBACK_OLLAMA_MODEL = "llama3.2:latest"; // Used when primary model fail
 const getOllamaBaseUrl = () => {
     return process.env.OLLAMA_BASE_URL || "http://localhost:11434";
 };
+const isOpenAICompatibleMode = () => {
+    // Enable OpenAI-compatible API mode (/v1/chat/completions) instead of native Ollama API (/api/generate)
+    // Useful for Ollama deployments that only support OpenAI-compatible routes (e.g., breezehq.dev)
+    return process.env.OLLAMA_OPENAI_COMPATIBLE === "true";
+};
 // Create AbortController with timeout for better compatibility
 const createAbortSignalWithTimeout = (timeoutMs) => {
     const controller = new AbortController();
@@ -29,7 +34,9 @@ const getDefaultOllamaModel = () => {
     return process.env.OLLAMA_MODEL || DEFAULT_OLLAMA_MODEL;
 };
 const getOllamaTimeout = () => {
-    return parseInt(process.env.OLLAMA_TIMEOUT || "60000", 10);
+    // Increased default timeout to 240000ms (4 minutes) to support slower native API responses
+    // especially for larger models like aliafshar/gemma3-it-qat-tools:latest (12.2B parameters)
+    return parseInt(process.env.OLLAMA_TIMEOUT || "240000", 10);
 };
 // Create proxy-aware fetch instance
 const proxyFetch = createProxyFetch();
@@ -62,63 +69,176 @@ class OllamaLanguageModel {
             .join("\n");
     }
     async doGenerate(options) {
+        // Vercel AI SDK passes messages via options.messages (same as stream mode)
+        // Check options.messages first, then fall back to options.prompt for backward compatibility
         const messages = options
-            .messages || [];
-        const prompt = this.convertMessagesToPrompt(messages);
-        // Debug: Log what's being sent to Ollama
-        logger.debug("[OllamaLanguageModel] Messages:", JSON.stringify(messages, null, 2));
-        logger.debug("[OllamaLanguageModel] Converted Prompt:", JSON.stringify(prompt));
-        const response = await proxyFetch(`${this.baseUrl}/api/generate`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({
+            .messages ||
+            options
+                .prompt ||
+            [];
+        // Check if we should use OpenAI-compatible API
+        const useOpenAIMode = isOpenAICompatibleMode();
+        if (useOpenAIMode) {
+            // OpenAI-compatible mode: Use /v1/chat/completions
+            const requestBody = {
                 model: this.modelId,
-                prompt,
+                messages,
+                temperature: options.temperature,
+                max_tokens: options.maxTokens,
                 stream: false,
-                system: messages.find((m) => m.role === "system")?.content,
-                options: {
-                    temperature: options.temperature,
-                    num_predict: options.maxTokens,
+            };
+            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" },
+                body: JSON.stringify(requestBody),
+                signal: createAbortSignalWithTimeout(this.timeout),
+            });
+            if (!response.ok) {
+                throw new Error(`Ollama API error: ${response.status} ${response.statusText}`);
+            }
+            const data = await response.json();
+            logger.debug("[OllamaLanguageModel] OpenAI API Response:", JSON.stringify(data, null, 2));
+            const text = data.choices?.[0]?.message?.content || "";
+            const usage = data.usage || {};
+            return {
+                text,
+                usage: {
+                    promptTokens: usage.prompt_tokens ??
+                        this.estimateTokens(JSON.stringify(messages)),
+                    completionTokens: usage.completion_tokens ?? this.estimateTokens(text),
+                    totalTokens: usage.total_tokens,
                 },
-            }),
-            signal: createAbortSignalWithTimeout(this.timeout),
-        });
-        if (!response.ok) {
-            throw new Error(`Ollama API error: ${response.status} ${response.statusText}`);
+                finishReason: "stop",
+                rawCall: {
+                    rawPrompt: messages,
+                    rawSettings: {
+                        model: this.modelId,
+                        temperature: options.temperature,
+                        max_tokens: options.maxTokens,
+                    },
+                },
+                rawResponse: {
+                    headers: {},
+                },
+            };
         }
-        const data = await response.json();
-        // Debug: Log Ollama API response to understand empty content issue
-        logger.debug("[OllamaLanguageModel] API Response:", JSON.stringify(data, null, 2));
-        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)) +
-                    (data.eval_count ?? this.estimateTokens(String(data.response ?? ""))),
-            },
-            finishReason: "stop",
-            rawCall: {
-                rawPrompt: prompt,
-                rawSettings: {
+        else {
+            // Native Ollama mode: Use /api/generate
+            const prompt = this.convertMessagesToPrompt(messages);
+            logger.debug("[OllamaLanguageModel] Using native API with prompt:", JSON.stringify(prompt));
+            const response = await proxyFetch(`${this.baseUrl}/api/generate`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
                     model: this.modelId,
-                    temperature: options.temperature,
-                    num_predict: options.maxTokens,
+                    prompt,
+                    stream: false,
+                    system: messages.find((m) => m.role === "system")?.content,
+                    options: {
+                        temperature: options.temperature,
+                        num_predict: options.maxTokens,
+                    },
+                }),
+                signal: createAbortSignalWithTimeout(this.timeout),
+            });
+            if (!response.ok) {
+                throw new Error(`Ollama API error: ${response.status} ${response.statusText}`);
+            }
+            const data = await response.json();
+            logger.debug("[OllamaLanguageModel] Native API Response:", JSON.stringify(data, null, 2));
+            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)) +
+                        (data.eval_count ??
+                            this.estimateTokens(String(data.response ?? ""))),
                 },
-            },
-            rawResponse: {
-                headers: {},
-            },
-        };
+                finishReason: "stop",
+                rawCall: {
+                    rawPrompt: prompt,
+                    rawSettings: {
+                        model: this.modelId,
+                        temperature: options.temperature,
+                        num_predict: options.maxTokens,
+                    },
+                },
+                rawResponse: {
+                    headers: {},
+                },
+            };
+        }
     }
     async doStream(options) {
         const messages = options
             .messages || [];
-        const prompt = this.convertMessagesToPrompt(messages);
-        const response = await proxyFetch(`${this.baseUrl}/api/generate`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({
+        // Check if we should use OpenAI-compatible API
+        const useOpenAIMode = isOpenAICompatibleMode();
+        if (useOpenAIMode) {
+            // OpenAI-compatible mode: Use /v1/chat/completions
+            const requestUrl = `${this.baseUrl}/v1/chat/completions`;
+            const requestBody = {
+                model: this.modelId,
+                messages,
+                temperature: options.temperature,
+                max_tokens: options.maxTokens,
+                stream: true,
+            };
+            logger.debug("[OllamaLanguageModel] doStream: Using OpenAI-compatible API", {
+                url: requestUrl,
+                baseUrl: this.baseUrl,
+                modelId: this.modelId,
+                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("[OllamaLanguageModel] doStream: Response received", {
+                status: response.status,
+                statusText: response.statusText,
+                ok: response.ok,
+            });
+            if (!response.ok) {
+                throw new Error(`Ollama API error: ${response.status} ${response.statusText}`);
+            }
+            const self = this;
+            return {
+                stream: new ReadableStream({
+                    async start(controller) {
+                        try {
+                            for await (const chunk of self.parseOpenAIStreamResponse(response, messages)) {
+                                controller.enqueue(chunk);
+                            }
+                            controller.close();
+                        }
+                        catch (error) {
+                            controller.error(error);
+                        }
+                    },
+                }),
+                rawCall: {
+                    rawPrompt: messages,
+                    rawSettings: {
+                        model: this.modelId,
+                        temperature: options.temperature,
+                        max_tokens: options.maxTokens,
+                    },
+                },
+                rawResponse: {
+                    headers: {},
+                },
+            };
+        }
+        else {
+            // Native Ollama mode: Use /api/generate
+            const prompt = this.convertMessagesToPrompt(messages);
+            const requestUrl = `${this.baseUrl}/api/generate`;
+            const requestBody = {
                 model: this.modelId,
                 prompt,
                 stream: true,
@@ -127,39 +247,55 @@ class OllamaLanguageModel {
                     temperature: options.temperature,
                     num_predict: options.maxTokens,
                 },
-            }),
-            signal: createAbortSignalWithTimeout(this.timeout),
-        });
-        if (!response.ok) {
-            throw new Error(`Ollama API error: ${response.status} ${response.statusText}`);
-        }
-        const self = this;
-        return {
-            stream: new ReadableStream({
-                async start(controller) {
-                    try {
-                        for await (const chunk of self.parseStreamResponse(response)) {
-                            controller.enqueue(chunk);
+            };
+            logger.debug("[OllamaLanguageModel] doStream: Using native API", {
+                url: requestUrl,
+                baseUrl: this.baseUrl,
+                modelId: this.modelId,
+                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("[OllamaLanguageModel] doStream: Response received", {
+                status: response.status,
+                statusText: response.statusText,
+                ok: response.ok,
+            });
+            if (!response.ok) {
+                throw new Error(`Ollama API error: ${response.status} ${response.statusText}`);
+            }
+            const self = this;
+            return {
+                stream: new ReadableStream({
+                    async start(controller) {
+                        try {
+                            for await (const chunk of self.parseStreamResponse(response)) {
+                                controller.enqueue(chunk);
+                            }
+                            controller.close();
                         }
-                        controller.close();
-                    }
-                    catch (error) {
-                        controller.error(error);
-                    }
+                        catch (error) {
+                            controller.error(error);
+                        }
+                    },
+                }),
+                rawCall: {
+                    rawPrompt: messages,
+                    rawSettings: {
+                        model: this.modelId,
+                        temperature: options.temperature,
+                        num_predict: options.maxTokens,
+                    },
                 },
-            }),
-            rawCall: {
-                rawPrompt: prompt,
-                rawSettings: {
-                    model: this.modelId,
-                    temperature: options.temperature,
-                    num_predict: options.maxTokens,
+                rawResponse: {
+                    headers: {},
                 },
-            },
-            rawResponse: {
-                headers: {},
-            },
-        };
+            };
+        }
     }
     async *parseStreamResponse(response) {
         const reader = response.body?.getReader();
@@ -213,6 +349,83 @@ class OllamaLanguageModel {
             reader.releaseLock();
         }
     }
+    async *parseOpenAIStreamResponse(response, messages) {
+        const reader = response.body?.getReader();
+        if (!reader) {
+            throw new Error("No response body");
+        }
+        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;
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) {
+                    break;
+                }
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split("\n");
+                buffer = lines.pop() || "";
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (trimmed === "" || trimmed === "data: [DONE]") {
+                        continue;
+                    }
+                    if (trimmed.startsWith("data: ")) {
+                        try {
+                            const jsonStr = trimmed.slice(6); // Remove "data: " prefix
+                            const data = JSON.parse(jsonStr);
+                            // Extract content delta
+                            const content = data.choices?.[0]?.delta?.content;
+                            if (content) {
+                                yield {
+                                    type: "text-delta",
+                                    textDelta: content,
+                                };
+                                totalCompletionTokens += this.estimateTokens(content);
+                            }
+                            // Check for finish
+                            const finishReason = data.choices?.[0]?.finish_reason;
+                            if (finishReason === "stop") {
+                                // Extract usage if available and update tokens
+                                const promptTokens = data.usage?.prompt_tokens || totalPromptTokens;
+                                const completionTokens = data.usage?.completion_tokens || totalCompletionTokens;
+                                yield {
+                                    type: "finish",
+                                    finishReason: "stop",
+                                    usage: {
+                                        promptTokens,
+                                        completionTokens,
+                                    },
+                                };
+                                return;
+                            }
+                        }
+                        catch (error) {
+                            logger.error("Error parsing OpenAI stream response", {
+                                error,
+                                line: trimmed,
+                            });
+                        }
+                    }
+                }
+            }
+            // If loop exits without explicit finish, yield final finish
+            yield {
+                type: "finish",
+                finishReason: "stop",
+                usage: {
+                    promptTokens: totalPromptTokens,
+                    completionTokens: totalCompletionTokens,
+                },
+            };
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
 }
 /**
  * Ollama Provider v2 - BaseProvider Implementation
@@ -279,18 +492,28 @@ export class OllamaProvider extends BaseProvider {
         // Get tool-capable models from configuration
         const ollamaConfig = modelConfig.getProviderConfiguration("ollama");
         const toolCapableModels = ollamaConfig?.modelBehavior?.toolCapableModels || [];
-        // Check if current model matches tool-capable model patterns
-        const isToolCapable = toolCapableModels.some((capableModel) => modelName.includes(capableModel));
+        // Only disable tools if we have positive evidence the model doesn't support them
+        // If toolCapableModels config is empty, assume tools are supported (don't make assumptions)
+        if (toolCapableModels.length === 0) {
+            logger.debug("Ollama tool calling enabled", {
+                model: this.modelName,
+                reason: "No tool-capable config defined, assuming tools supported",
+                baseUrl: this.baseUrl,
+            });
+            return true;
+        }
+        // Config exists - check if current model matches tool-capable model patterns
+        const isToolCapable = toolCapableModels.some((capableModel) => modelName.includes(capableModel.toLowerCase()));
         if (isToolCapable) {
             logger.debug("Ollama tool calling enabled", {
                 model: this.modelName,
-                reason: "Model supports function calling",
+                reason: "Model in tool-capable list",
                 baseUrl: this.baseUrl,
                 configuredModels: toolCapableModels.length,
             });
             return true;
         }
-        // Log why tools are disabled for transparency
+        // Config exists and model is NOT in list - disable tools
         logger.debug("Ollama tool calling disabled", {
             model: this.modelName,
             reason: "Model not in tool-capable list",
@@ -536,57 +759,134 @@ export class OllamaProvider extends BaseProvider {
             options.input?.content?.length ||
             options.input?.files?.length ||
             options.input?.csvFiles?.length);
-        let prompt = options.input.text;
-        let images;
-        if (hasMultimodalInput) {
-            logger.debug(`Ollama (generate API): 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);
-        }
-        const requestBody = {
-            model: this.modelName || FALLBACK_OLLAMA_MODEL,
-            prompt,
-            system: options.systemPrompt,
-            stream: true,
-            options: {
+        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,
-                num_predict: options.maxTokens,
-            },
-        };
-        if (images && images.length > 0) {
-            requestBody.images = images;
-        }
-        const response = await proxyFetch(`${this.baseUrl}/api/generate`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify(requestBody),
-            signal: createAbortSignalWithTimeout(this.timeout),
-        });
-        if (!response.ok) {
-            throw new Error(`Ollama API error: ${response.status} ${response.statusText}`);
+                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;
+                }
+            };
+            return {
+                stream: transformedStream(),
+                provider: self.providerName,
+                model: self.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;
+        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 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: this.providerName,
-            model: this.modelName,
-        };
+            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;
+                }
+            };
+            return {
+                stream: transformedStream(),
+                provider: this.providerName,
+                model: this.modelName,
+            };
+        }
     }
     /**
      * Convert AI SDK tools format to Ollama's function calling format
@@ -1051,6 +1351,53 @@ export class OllamaProvider extends BaseProvider {
             reader.releaseLock();
         }
     }
+    async *createOpenAIStream(response) {
+        const reader = response.body?.getReader();
+        if (!reader) {
+            throw new Error("No response body");
+        }
+        const decoder = new TextDecoder();
+        let buffer = "";
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) {
+                    break;
+                }
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split("\n");
+                buffer = lines.pop() || "";
+                for (const line of lines) {
+                    const trimmedLine = line.trim();
+                    if (!trimmedLine || trimmedLine === "data: [DONE]") {
+                        continue;
+                    }
+                    if (trimmedLine.startsWith("data: ")) {
+                        try {
+                            const jsonStr = trimmedLine.slice(6); // Remove "data: " prefix
+                            const data = JSON.parse(jsonStr);
+                            const content = data.choices?.[0]?.delta?.content;
+                            if (content) {
+                                yield { content };
+                            }
+                            if (data.choices?.[0]?.finish_reason) {
+                                return;
+                            }
+                        }
+                        catch (error) {
+                            logger.error("Error parsing OpenAI stream response", {
+                                error,
+                                line: trimmedLine,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
     handleProviderError(error) {
         if (error.name === "TimeoutError") {
             return new TimeoutError(`Ollama request timed out. The model might be loading or the request is too complex.`, this.defaultTimeout);