@juspay/neurolink 5.1.0 → 5.2.0

package/dist/lib/providers/ollama.js

@@ -1,23 +1,29 @@
-/**
- * Ollama Provider for NeuroLink
- *
- * Local AI model deployment and management using Ollama.
- * Provides offline AI capabilities with local model hosting.
- *
- * Features:
- * - Local model deployment (privacy-first)
- * - Model management (download, list, remove)
- * - Health checking and service validation
- * - Streaming and non-streaming text generation
- */
-import { streamText, generateText, Output } from "ai";
+import { BaseProvider } from "../core/base-provider.js";
 import { logger } from "../utils/logger.js";
-import { getDefaultTimeout, TimeoutError } from "../utils/timeout.js";
+import { TimeoutError } from "../utils/timeout.js";
 import { DEFAULT_MAX_TOKENS } from "../core/constants.js";
-import { evaluateResponse } from "../core/evaluation.js";
-// Default system context
-const DEFAULT_SYSTEM_CONTEXT = {
-    systemPrompt: "You are a helpful AI assistant.",
+// Model version constants (configurable via environment)
+const DEFAULT_OLLAMA_MODEL = "llama3.1:8b";
+const FALLBACK_OLLAMA_MODEL = "llama3.2:latest"; // Used when primary model fails
+// Configuration helpers
+const getOllamaBaseUrl = () => {
+    return process.env.OLLAMA_BASE_URL || "http://localhost:11434";
+};
+// Create AbortController with timeout for better compatibility
+const createAbortSignalWithTimeout = (timeoutMs) => {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    // Clear timeout if signal is aborted through other means
+    controller.signal.addEventListener("abort", () => {
+        clearTimeout(timeoutId);
+    });
+    return controller.signal;
+};
+const getDefaultOllamaModel = () => {
+    return process.env.OLLAMA_MODEL || DEFAULT_OLLAMA_MODEL;
+};
+const getOllamaTimeout = () => {
+    return parseInt(process.env.OLLAMA_TIMEOUT || "60000", 10);
 };
 // Custom LanguageModelV1 implementation for Ollama
 class OllamaLanguageModel {
@@ -35,7 +41,7 @@ class OllamaLanguageModel {
         this.timeout = timeout;
     }
     estimateTokens(text) {
-        return Math.ceil(text.length / 4); // Rough estimation: 4 characters per token
+        return Math.ceil(text.length / 4);
     }
     convertMessagesToPrompt(messages) {
         return messages
@@ -43,569 +49,340 @@ class OllamaLanguageModel {
             if (typeof msg.content === "string") {
                 return `${msg.role}: ${msg.content}`;
             }
-            else if (Array.isArray(msg.content)) {
-                // Handle multi-part content (text, images, etc.)
-                return `${msg.role}: ${msg.content
-                    .filter((part) => part.type === "text")
-                    .map((part) => part.text)
-                    .join(" ")}`;
-            }
-            return "";
+            return `${msg.role}: ${JSON.stringify(msg.content)}`;
         })
             .join("\n");
     }
-    async checkHealth() {
-        try {
-            const controller = new AbortController();
-            const timeoutId = setTimeout(() => controller.abort(), 5000);
-            const response = await fetch(`${this.baseUrl}/api/tags`, {
-                method: "GET",
-                signal: controller.signal,
-                headers: { "Content-Type": "application/json" },
-            });
-            clearTimeout(timeoutId);
-            return response.ok;
-        }
-        catch {
-            return false;
-        }
-    }
-    async ensureModelAvailable() {
-        try {
-            const response = await fetch(`${this.baseUrl}/api/tags`);
-            if (!response.ok) {
-                throw new Error("Cannot access Ollama");
-            }
-            const data = (await response.json());
-            const models = data.models?.map((m) => m.name) || [];
-            if (!models.includes(this.modelId)) {
-                // Try to pull the model
-                const pullResponse = await fetch(`${this.baseUrl}/api/pull`, {
-                    method: "POST",
-                    headers: { "Content-Type": "application/json" },
-                    body: JSON.stringify({ name: this.modelId }),
-                });
-                if (!pullResponse.ok) {
-                    throw new Error(`Model '${this.modelId}' not available and cannot be pulled`);
-                }
-            }
-        }
-        catch (error) {
-            throw new Error(`Failed to ensure model availability: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
     async doGenerate(options) {
-        // Health check and model availability
-        const isHealthy = await this.checkHealth();
-        if (!isHealthy) {
-            throw new Error("Ollama service is not running or accessible. Please ensure Ollama is installed and running.");
+        const messages = options.messages || [];
+        const prompt = this.convertMessagesToPrompt(messages);
+        const response = await fetch(`${this.baseUrl}/api/generate`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                model: this.modelId,
+                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}`);
         }
-        await this.ensureModelAvailable();
-        const prompt = this.convertMessagesToPrompt(options.prompt);
-        const requestPayload = {
-            model: this.modelId,
-            prompt,
-            stream: false,
-            options: {
-                temperature: options.temperature || 0.7,
-                num_predict: options.maxTokens ?? DEFAULT_MAX_TOKENS,
+        const data = await response.json();
+        return {
+            text: data.response,
+            usage: {
+                promptTokens: this.estimateTokens(prompt),
+                completionTokens: this.estimateTokens(data.response),
             },
         };
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
-        try {
-            const response = await fetch(`${this.baseUrl}/api/generate`, {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify(requestPayload),
-                signal: controller.signal,
-            });
-            clearTimeout(timeoutId);
-            if (!response.ok) {
-                if (response.status === 404) {
-                    const errorData = await response.json();
-                    if (errorData.error && errorData.error.includes("not found")) {
-                        throw new Error(`Model '${this.modelId}' not found. Please run 'ollama pull ${this.modelId}'`);
-                    }
-                }
-                throw new Error(`Ollama API error: ${response.status} ${response.statusText}`);
-            }
-            const data = (await response.json());
-            if (!data.response) {
-                throw new Error("No response received from Ollama");
-            }
-            const promptTokens = this.estimateTokens(prompt);
-            const completionTokens = this.estimateTokens(data.response);
-            return {
-                text: data.response,
-                usage: {
-                    promptTokens,
-                    completionTokens,
-                    totalTokens: promptTokens + completionTokens,
-                },
-                finishReason: "stop",
-                logprobs: undefined,
-                rawCall: { rawPrompt: prompt, rawSettings: options },
-                rawResponse: { headers: {} },
-            };
-        }
-        catch (error) {
-            clearTimeout(timeoutId);
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            if (errorMessage.includes("AbortError") ||
-                errorMessage.includes("timeout")) {
-                throw new Error(`Ollama request timeout (${this.timeout}ms). The model may be large or the system is under load.`);
-            }
-            if (errorMessage.includes("ECONNREFUSED") ||
-                errorMessage.includes("fetch failed")) {
-                throw new Error("Cannot connect to Ollama service. Please ensure Ollama is installed and running on " +
-                    this.baseUrl);
-            }
-            throw error;
-        }
     }
     async doStream(options) {
-        // Health check and model availability
-        const isHealthy = await this.checkHealth();
-        if (!isHealthy) {
-            throw new Error("Ollama service is not running or accessible. Please ensure Ollama is installed and running.");
+        const messages = options.messages || [];
+        const prompt = this.convertMessagesToPrompt(messages);
+        const response = await fetch(`${this.baseUrl}/api/generate`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                model: this.modelId,
+                prompt,
+                stream: true,
+                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}`);
         }
-        await this.ensureModelAvailable();
-        const prompt = this.convertMessagesToPrompt(options.prompt);
-        const requestPayload = {
-            model: this.modelId,
-            prompt,
-            stream: true,
-            options: {
-                temperature: options.temperature || 0.7,
-                num_predict: options.maxTokens ?? DEFAULT_MAX_TOKENS,
-            },
+        return {
+            stream: this.parseStreamResponse(response),
         };
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    }
+    async *parseStreamResponse(response) {
+        const reader = response.body?.getReader();
+        if (!reader) {
+            throw new Error("No response body");
+        }
+        const decoder = new TextDecoder();
+        let buffer = "";
         try {
-            const response = await fetch(`${this.baseUrl}/api/generate`, {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify(requestPayload),
-                signal: controller.signal,
-            });
-            clearTimeout(timeoutId);
-            if (!response.ok) {
-                if (response.status === 404) {
-                    const errorData = await response.json();
-                    if (errorData.error && errorData.error.includes("not found")) {
-                        throw new Error(`Model '${this.modelId}' not found. Please run 'ollama pull ${this.modelId}'`);
-                    }
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) {
+                    break;
                 }
-                throw new Error(`Ollama API error: ${response.status} ${response.statusText}`);
-            }
-            if (!response.body) {
-                throw new Error("No response body received from Ollama streaming API");
-            }
-            // Create a ReadableStream that parses Ollama's streaming format
-            const stream = new ReadableStream({
-                async start(controller) {
-                    const reader = response.body.getReader();
-                    const decoder = new TextDecoder();
-                    let totalTokens = 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) {
+                    if (line.trim()) {
+                        try {
+                            const data = JSON.parse(line);
+                            if (data.response) {
+                                yield {
+                                    type: "text-delta",
+                                    textDelta: data.response,
+                                };
                             }
-                            const chunk = decoder.decode(value, { stream: true });
-                            const lines = chunk.split("\n").filter((line) => line.trim());
-                            for (const line of lines) {
-                                try {
-                                    const data = JSON.parse(line);
-                                    if (data.response) {
-                                        controller.enqueue({
-                                            type: "text-delta",
-                                            textDelta: data.response,
-                                        });
-                                        totalTokens += Math.ceil(data.response.length / 4);
-                                    }
-                                    if (data.done) {
-                                        controller.enqueue({
-                                            type: "finish",
-                                            finishReason: "stop",
-                                            usage: {
-                                                promptTokens: data.prompt_eval_count ||
-                                                    Math.ceil(prompt.length / 4),
-                                                completionTokens: data.eval_count || totalTokens,
-                                            },
-                                            logprobs: undefined,
-                                        });
-                                        controller.close();
-                                        return;
-                                    }
-                                }
-                                catch (parseError) {
-                                    // Skip invalid JSON lines
-                                }
+                            if (data.done) {
+                                yield {
+                                    type: "finish",
+                                    finishReason: "stop",
+                                    usage: {
+                                        promptTokens: this.estimateTokens(data.context || ""),
+                                        completionTokens: data.eval_count || 0,
+                                    },
+                                };
+                                return;
                             }
                         }
+                        catch (error) {
+                            // Ignore JSON parse errors for incomplete chunks
+                        }
                     }
-                    finally {
-                        reader.releaseLock();
-                    }
-                },
-            });
-            return {
-                stream,
-                rawCall: { rawPrompt: prompt, rawSettings: options },
-                rawResponse: { headers: {} },
-            };
-        }
-        catch (error) {
-            clearTimeout(timeoutId);
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            if (errorMessage.includes("AbortError") ||
-                errorMessage.includes("timeout")) {
-                throw new Error(`Ollama streaming timeout (${this.timeout}ms). The model may be large or the system is under load.`);
-            }
-            if (errorMessage.includes("ECONNREFUSED") ||
-                errorMessage.includes("fetch failed")) {
-                throw new Error("Cannot connect to Ollama service. Please ensure Ollama is installed and running on " +
-                    this.baseUrl);
+                }
             }
-            throw error;
+        }
+        finally {
+            reader.releaseLock();
         }
     }
 }
-export class Ollama {
+/**
+ * Ollama Provider v2 - BaseProvider Implementation
+ *
+ * PHASE 3.7: BaseProvider wrap around existing custom Ollama implementation
+ *
+ * Features:
+ * - Extends BaseProvider for shared functionality
+ * - Preserves custom OllamaLanguageModel implementation
+ * - Local model management and health checking
+ * - Enhanced error handling with Ollama-specific guidance
+ */
+export class OllamaProvider extends BaseProvider {
+    ollamaModel;
     baseUrl;
-    modelName;
-    defaultTimeout;
+    timeout;
     constructor(modelName) {
-        this.baseUrl = process.env.OLLAMA_BASE_URL || "http://localhost:11434";
-        this.modelName = modelName || process.env.OLLAMA_MODEL || "llama2";
-        // Use environment variable for backward compatibility, but convert to format used by other providers
-        const envTimeout = process.env.OLLAMA_TIMEOUT
-            ? parseInt(process.env.OLLAMA_TIMEOUT)
-            : undefined;
-        this.defaultTimeout =
-            envTimeout ||
-                parseInt(getDefaultTimeout("ollama", "generate").replace(/[^\d]/g, ""));
-        logger.debug("[Ollama] Initialized", {
-            baseUrl: this.baseUrl,
+        super(modelName, "ollama");
+        this.baseUrl = getOllamaBaseUrl();
+        this.timeout = getOllamaTimeout();
+        // Initialize Ollama model
+        this.ollamaModel = new OllamaLanguageModel(this.modelName || getDefaultOllamaModel(), this.baseUrl, this.timeout);
+        logger.debug("Ollama BaseProvider v2 initialized", {
             modelName: this.modelName,
-            defaultTimeout: this.defaultTimeout,
+            baseUrl: this.baseUrl,
+            timeout: this.timeout,
+            provider: this.providerName,
         });
     }
-    /**
-     * Gets the appropriate model instance
-     * @private
-     */
-    getModel(timeout) {
-        logger.debug("Ollama.getModel - Ollama model selected", {
-            modelName: this.modelName,
-            timeout: timeout || this.defaultTimeout,
-        });
-        return new OllamaLanguageModel(this.modelName, this.baseUrl, timeout || this.defaultTimeout);
+    getProviderName() {
+        return "ollama";
+    }
+    getDefaultModel() {
+        return getDefaultOllamaModel();
     }
     /**
-     * Health check - verify Ollama service is running and accessible
+     * Returns the Vercel AI SDK model instance for Ollama
      */
-    async checkHealth() {
-        const model = new OllamaLanguageModel(this.modelName, this.baseUrl, this.defaultTimeout);
-        return await model["checkHealth"]();
+    getAISDKModel() {
+        return this.ollamaModel;
     }
     /**
-     * List available models on the Ollama instance
+     * Ollama tool/function calling support is currently disabled due to integration issues.
+     *
+     * **Current Issues:**
+     * 1. The OllamaLanguageModel from @ai-sdk/provider-utils doesn't properly integrate
+     *    with BaseProvider's tool calling mechanism
+     * 2. Ollama models require specific prompt formatting for function calls that differs
+     *    from the standardized AI SDK format
+     * 3. Tool response parsing and execution flow needs custom implementation
+     *
+     * **What's needed to enable tool support:**
+     * - Create a custom OllamaLanguageModel wrapper that handles tool schema formatting
+     * - Implement Ollama-specific tool calling prompt templates
+     * - Add proper response parsing for Ollama's function call format
+     * - Test with models that support function calling (llama3.1, mistral, etc.)
+     *
+     * **Tracking:**
+     * - See BaseProvider tool integration patterns in other providers
+     * - Monitor Ollama function calling documentation: https://ollama.com/blog/tool-support
+     * - Track AI SDK updates for better Ollama integration
+     *
+     * @returns false to disable tools by default
      */
-    async listModels() {
-        const functionTag = "Ollama.listModels";
+    supportsTools() {
+        // TODO: Fix the OllamaLanguageModel integration with BaseProvider for tool support.
+        //       Track progress on resolving this issue. See the detailed steps above.
+        //       Issue tracking required for enabling tool support
+        return false;
+    }
+    // executeGenerate removed - BaseProvider handles all generation with tools
+    async executeStream(options, analysisSchema) {
         try {
-            logger.debug(`[${functionTag}] Listing available models`);
-            const response = await fetch(`${this.baseUrl}/api/tags`, {
-                method: "GET",
-                headers: {
-                    "Content-Type": "application/json",
-                },
+            this.validateStreamOptions(options);
+            await this.checkOllamaHealth();
+            // Direct HTTP streaming implementation for better compatibility
+            const response = await fetch(`${this.baseUrl}/api/generate`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    model: this.modelName || FALLBACK_OLLAMA_MODEL,
+                    prompt: options.input.text,
+                    system: options.systemPrompt,
+                    stream: true,
+                    options: {
+                        temperature: options.temperature,
+                        num_predict: options.maxTokens || DEFAULT_MAX_TOKENS,
+                    },
+                }),
+                signal: createAbortSignalWithTimeout(this.timeout),
             });
             if (!response.ok) {
-                throw new Error(`Failed to list models: ${response.status} ${response.statusText}`);
+                throw new Error(`Ollama API error: ${response.status} ${response.statusText}`);
             }
-            const data = (await response.json());
-            const modelNames = data.models?.map((model) => model.name) || [];
-            logger.debug(`[${functionTag}] Found models`, {
-                count: modelNames.length,
-                models: modelNames,
-            });
-            return modelNames;
+            // 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,
+            };
         }
         catch (error) {
-            logger.debug(`[${functionTag}] Error listing models`, {
-                error: error instanceof Error ? error.message : String(error),
-            });
-            throw new Error(`Failed to list Ollama models: ${error instanceof Error ? error.message : String(error)}`);
+            throw this.handleProviderError(error);
         }
     }
-    /**
-     * Check if a specific model is available
-     */
-    async isModelAvailable(modelName) {
+    async *createOllamaStream(response) {
+        const reader = response.body?.getReader();
+        if (!reader) {
+            throw new Error("No response body");
+        }
+        const decoder = new TextDecoder();
+        let buffer = "";
         try {
-            const models = await this.listModels();
-            return models.includes(modelName);
+            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) {
+                    if (line.trim()) {
+                        try {
+                            const data = JSON.parse(line);
+                            if (data.response) {
+                                yield { content: data.response };
+                            }
+                            if (data.done) {
+                                return;
+                            }
+                        }
+                        catch (error) {
+                            // Ignore JSON parse errors for incomplete chunks
+                        }
+                    }
+                }
+            }
         }
-        catch (error) {
-            return false;
+        finally {
+            reader.releaseLock();
         }
     }
-    /**
-     * Pull/download a model to the local Ollama instance
-     */
-    async pullModel(modelName) {
-        const functionTag = "Ollama.pullModel";
-        try {
-            logger.debug(`[${functionTag}] Pulling model`, { modelName });
-            const response = await fetch(`${this.baseUrl}/api/pull`, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                },
-                body: JSON.stringify({
-                    name: modelName,
-                }),
-            });
-            if (!response.ok) {
-                throw new Error(`Failed to pull model: ${response.status} ${response.statusText}`);
-            }
-            // Note: Ollama pull API returns streaming responses
-            // For simplicity, we're not handling the streaming progress here
-            logger.debug(`[${functionTag}] Model pull completed`, { modelName });
+    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);
         }
-        catch (error) {
-            logger.debug(`[${functionTag}] Error pulling model`, {
-                modelName,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            throw new Error(`Failed to pull model '${modelName}': ${error instanceof Error ? error.message : String(error)}`);
+        if (error.message?.includes("ECONNREFUSED") ||
+            error.message?.includes("fetch failed")) {
+            return new Error(`❌ Ollama Service Not Running\n\nCannot connect to Ollama at ${this.baseUrl}\n\n🔧 Steps to Fix:\n1. Install Ollama: https://ollama.ai/\n2. Start Ollama service: 'ollama serve'\n3. Verify it's running: 'curl ${this.baseUrl}/api/version'\n4. Try again`);
+        }
+        if (error.message?.includes("model") &&
+            error.message?.includes("not found")) {
+            return new Error(`❌ 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`);
+        }
+        if (error.message?.includes("404")) {
+            return new Error(`❌ Ollama API Endpoint Not Found\n\nThe API endpoint might have changed or Ollama version is incompatible.\n\n🔧 Check:\n1. Ollama version: 'ollama --version'\n2. Update Ollama to latest version\n3. Verify API is available: 'curl ${this.baseUrl}/api/version'`);
+        }
+        return new Error(`❌ 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`);
+    }
+    validateStreamOptions(options) {
+        if (!options.input?.text?.trim()) {
+            throw new Error("Prompt is required for streaming");
+        }
+        if (options.maxTokens && options.maxTokens < 1) {
+            throw new Error("maxTokens must be greater than 0");
+        }
+        if (options.temperature &&
+            (options.temperature < 0 || options.temperature > 2)) {
+            throw new Error("temperature must be between 0 and 2");
         }
     }
     /**
-     * PRIMARY METHOD: Stream content using AI (recommended for new code)
-     * Future-ready for multi-modal capabilities with current text focus
+     * Check if Ollama service is healthy and accessible
      */
-    async stream(optionsOrPrompt, analysisSchema) {
-        const functionTag = "Ollama.stream";
-        const provider = "ollama";
-        let chunkCount = 0;
-        const startTime = Date.now();
+    async checkOllamaHealth() {
         try {
-            // Parse parameters - support both string and options object
-            const options = typeof optionsOrPrompt === "string"
-                ? { input: { text: optionsOrPrompt } }
-                : optionsOrPrompt;
-            // Validate input
-            if (!options?.input?.text ||
-                typeof options.input.text !== "string" ||
-                options.input.text.trim() === "") {
-                throw new Error("Stream options must include input.text as a non-empty string");
-            }
-            // Extract parameters
-            const { prompt = options.input.text, temperature = 0.7, maxTokens = DEFAULT_MAX_TOKENS, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, timeout, } = options;
-            // Use schema from options or fallback parameter
-            const finalSchema = schema || analysisSchema;
-            // Convert timeout to milliseconds if provided as string
-            const timeoutMs = timeout
-                ? typeof timeout === "string"
-                    ? parseInt(getDefaultTimeout("ollama", "stream").replace(/[^\d]/g, ""))
-                    : timeout
-                : this.defaultTimeout;
-            logger.debug(`[${functionTag}] Stream request started`, {
-                provider,
-                modelName: this.modelName,
-                promptLength: prompt.length,
-                temperature,
-                maxTokens,
-                hasSchema: !!finalSchema,
-                timeout: timeoutMs,
+            // Use traditional AbortController for better compatibility
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 5000);
+            const response = await fetch(`${this.baseUrl}/api/version`, {
+                method: "GET",
+                signal: controller.signal,
             });
-            const model = this.getModel(timeoutMs);
-            const streamOptions = {
-                model: model,
-                prompt: prompt,
-                system: systemPrompt,
-                temperature,
-                maxTokens,
-                onError: (event) => {
-                    const error = event.error;
-                    const errorMessage = error instanceof Error ? error.message : String(error);
-                    const errorStack = error instanceof Error ? error.stack : undefined;
-                    logger.debug(`[${functionTag}] Stream error`, {
-                        provider,
-                        modelName: this.modelName,
-                        error: errorMessage,
-                        stack: errorStack,
-                        promptLength: prompt.length,
-                        chunkCount,
-                    });
-                },
-                onFinish: (event) => {
-                    logger.debug(`[${functionTag}] Stream finished`, {
-                        provider,
-                        modelName: this.modelName,
-                        finishReason: event.finishReason,
-                        usage: event.usage,
-                        totalChunks: chunkCount,
-                        promptLength: prompt.length,
-                        responseLength: event.text?.length || 0,
-                    });
-                },
-                onChunk: (event) => {
-                    chunkCount++;
-                    logger.debug(`[${functionTag}] Stream chunk`, {
-                        provider,
-                        modelName: this.modelName,
-                        chunkNumber: chunkCount,
-                        chunkLength: event.chunk.text?.length || 0,
-                        chunkType: event.chunk.type,
-                    });
-                },
-            };
-            if (finalSchema) {
-                streamOptions.experimental_output = Output.object({
-                    schema: finalSchema,
-                });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                throw new Error(`Ollama health check failed: ${response.status}`);
             }
-            const result = streamText(streamOptions);
-            logger.debug(`[${functionTag}] Stream request completed`, {
-                provider,
-                modelName: this.modelName,
-            });
-            // Convert to StreamResult format
-            return {
-                stream: (async function* () {
-                    for await (const chunk of result.textStream) {
-                        yield { content: chunk };
-                    }
-                })(),
-                provider: "ollama",
-                model: this.modelName,
-                metadata: {
-                    streamId: `ollama-${Date.now()}`,
-                    startTime,
-                },
-            };
         }
-        catch (err) {
-            // Log timeout errors specifically
-            if (err instanceof TimeoutError) {
-                logger.debug(`[${functionTag}] Timeout error`, {
-                    provider,
-                    modelName: this.modelName,
-                    timeout: err.timeout,
-                    message: err.message,
-                });
-            }
-            else {
-                logger.debug(`[${functionTag}] Exception`, {
-                    provider,
-                    modelName: this.modelName,
-                    message: "Error in streaming content",
-                    err: String(err),
-                });
+        catch (error) {
+            if (error instanceof Error && error.message.includes("ECONNREFUSED")) {
+                throw new Error(`❌ Ollama Service Not Running\n\nCannot connect to Ollama service.\n\n🔧 Start Ollama:\n1. Run: ollama serve\n2. Or start Ollama app\n3. Verify: curl ${this.baseUrl}/api/version`);
             }
-            throw err; // Re-throw error to trigger fallback
+            throw error;
         }
     }
     /**
-     * Generate text using Ollama local models
+     * Get available models from Ollama
      */
-    async generate(optionsOrPrompt, analysisSchema) {
-        const functionTag = "Ollama.generate";
-        const provider = "ollama";
-        const startTime = Date.now();
+    async getAvailableModels() {
         try {
-            // Parse parameters - support both string and options object
-            const options = typeof optionsOrPrompt === "string"
-                ? { prompt: optionsOrPrompt }
-                : optionsOrPrompt;
-            const { prompt, temperature = 0.7, maxTokens = DEFAULT_MAX_TOKENS, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, timeout, } = options;
-            // Use schema from options or fallback parameter
-            const finalSchema = schema || analysisSchema;
-            // Convert timeout to milliseconds if provided as string
-            const timeoutMs = timeout
-                ? typeof timeout === "string"
-                    ? parseInt(getDefaultTimeout("ollama", "generate").replace(/[^\d]/g, ""))
-                    : timeout
-                : this.defaultTimeout;
-            logger.debug(`[${functionTag}] Generate request started`, {
-                provider,
-                modelName: this.modelName,
-                promptLength: prompt.length,
-                temperature,
-                maxTokens,
-                timeout: timeoutMs,
-            });
-            const model = this.getModel(timeoutMs);
-            const generateOptions = {
-                model: model,
-                prompt: prompt,
-                system: systemPrompt,
-                temperature,
-                maxTokens,
-            };
-            if (finalSchema) {
-                generateOptions.experimental_output = Output.object({
-                    schema: finalSchema,
-                });
-            }
-            const result = await generateText(generateOptions);
-            if (result.text.includes("model not found")) {
-                throw new Error(`Model '${this.modelName}' not found. Please run 'ollama pull ${this.modelName}'`);
-            }
-            logger.debug(`[${functionTag}] Generate text completed`, {
-                provider,
-                modelName: this.modelName,
-                usage: result.usage,
-                finishReason: result.finishReason,
-                responseLength: result.text?.length || 0,
-            });
-            // Add analytics if enabled
-            if (options.enableAnalytics) {
-                result.analytics = {
-                    provider,
-                    model: this.modelName,
-                    tokens: result.usage,
-                    responseTime: Date.now() - startTime,
-                    context: options.context,
-                };
-            }
-            // Add evaluation if enabled
-            if (options.enableEvaluation) {
-                result.evaluation = await evaluateResponse(prompt, result.text, options.context);
+            const response = await fetch(`${this.baseUrl}/api/tags`);
+            if (!response.ok) {
+                throw new Error(`Failed to fetch models: ${response.status}`);
             }
-            return {
-                content: result.text,
-                provider: "ollama",
-                model: this.modelName,
-                usage: result.usage
-                    ? {
-                        inputTokens: result.usage.promptTokens,
-                        outputTokens: result.usage.completionTokens,
-                        totalTokens: result.usage.totalTokens,
-                    }
-                    : undefined,
-                responseTime: Date.now() - startTime,
-            };
+            const data = await response.json();
+            return data.models?.map((model) => model.name) || [];
         }
-        catch (err) {
-            logger.debug(`[${functionTag}] Exception`, {
-                provider,
-                modelName: this.modelName,
-                message: "Error in generating text",
-                err: String(err),
-            });
-            throw err; // Re-throw error to trigger fallback
+        catch (error) {
+            logger.warn("Failed to fetch Ollama models:", error);
+            return [];
         }
     }
-    async gen(optionsOrPrompt, analysisSchema) {
-        return this.generate(optionsOrPrompt, analysisSchema);
+    /**
+     * Check if a specific model is available
+     */
+    async isModelAvailable(modelName) {
+        const models = await this.getAvailableModels();
+        return models.includes(modelName);
     }
 }
+export default OllamaProvider;