fix tests

Author: SentienceDEV

predicate/llm_provider.py

@@ -376,12 +376,12 @@ def supports_vision(self) -> bool:
         return super().supports_vision()
 
 
-class OllamaProvider(OpenAIProvider):
+class OllamaProvider(LLMProvider):
     """
     Ollama local LLM provider via OpenAI-compatible API.
 
     Ollama serves models locally and provides an OpenAI-compatible endpoint at /v1.
-    This provider wraps OpenAIProvider with sensible defaults for local inference.
+    This provider uses HTTP requests directly without requiring the openai package.
 
     Example:
         >>> from predicate.llm_provider import OllamaProvider
@@ -397,6 +397,7 @@ def __init__(
         self,
         model: str,
         base_url: str = "http://localhost:11434",
+        timeout_seconds: float = 120.0,
         **kwargs,
     ):
         """
@@ -405,16 +406,117 @@ def __init__(
         Args:
             model: Ollama model name (e.g., "qwen3:8b", "llama3:8b", "mistral:7b")
             base_url: Ollama server URL (default: http://localhost:11434)
-            **kwargs: Additional parameters passed to OpenAIProvider
+            timeout_seconds: Request timeout in seconds (default: 120)
+            **kwargs: Additional parameters (reserved for future use)
         """
-        # Ollama serves OpenAI-compatible API at /v1
-        super().__init__(
-            model=model,
-            base_url=f"{base_url.rstrip('/')}/v1",
-            api_key="ollama",  # Ollama doesn't require a real API key
-            **kwargs,
+        super().__init__(model)
+        self._ollama_base_url = base_url.rstrip("/")
+        self._api_base_url = f"{self._ollama_base_url}/v1"
+        self._timeout_seconds = timeout_seconds
+
+    def generate(
+        self,
+        system_prompt: str,
+        user_prompt: str,
+        temperature: float = 0.0,
+        max_tokens: int | None = None,
+        json_mode: bool = False,
+        **kwargs,
+    ) -> LLMResponse:
+        """
+        Generate response using Ollama's OpenAI-compatible API.
+
+        Args:
+            system_prompt: System instruction
+            user_prompt: User query
+            temperature: Sampling temperature (0.0 = deterministic, 1.0 = creative)
+            max_tokens: Maximum tokens to generate
+            json_mode: Enable JSON response format (model-dependent support)
+            **kwargs: Additional API parameters (max_new_tokens is mapped to max_tokens)
+
+        Returns:
+            LLMResponse object
+        """
+        import json
+        import urllib.request
+        import urllib.error
+
+        # Handle max_new_tokens -> max_tokens mapping for cross-provider compatibility
+        if "max_new_tokens" in kwargs:
+            if max_tokens is None:
+                max_tokens = kwargs.pop("max_new_tokens")
+            else:
+                kwargs.pop("max_new_tokens")  # max_tokens takes precedence
+
+        messages = []
+        if system_prompt:
+            messages.append({"role": "system", "content": system_prompt})
+        messages.append({"role": "user", "content": user_prompt})
+
+        # Build API parameters
+        api_params: dict[str, Any] = {
+            "model": self._model_name,
+            "messages": messages,
+            "temperature": temperature,
+        }
+
+        if max_tokens:
+            api_params["max_tokens"] = max_tokens
+
+        if json_mode and self.supports_json_mode():
+            api_params["response_format"] = {"type": "json_object"}
+
+        # Merge additional parameters (excluding internal ones)
+        for key, value in kwargs.items():
+            if key not in api_params:
+                api_params[key] = value
+
+        # Make HTTP request to Ollama's OpenAI-compatible endpoint
+        url = f"{self._api_base_url}/chat/completions"
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": "Bearer ollama",  # Ollama doesn't require a real API key
+        }
+
+        try:
+            request_data = json.dumps(api_params).encode("utf-8")
+            req = urllib.request.Request(url, data=request_data, headers=headers, method="POST")
+            with urllib.request.urlopen(req, timeout=self._timeout_seconds) as response:
+                response_data = json.loads(response.read().decode("utf-8"))
+        except urllib.error.URLError as e:
+            raise RuntimeError(
+                f"Failed to connect to Ollama at {self._ollama_base_url}. "
+                f"Ensure Ollama is running: {e}"
+            ) from e
+        except urllib.error.HTTPError as e:
+            raise RuntimeError(
+                f"Ollama API error: {e.code} - {e.reason}"
+            ) from e
+        except json.JSONDecodeError as e:
+            raise RuntimeError(f"Failed to parse Ollama response: {e}") from e
+
+        # Parse response
+        choice = response_data.get("choices", [{}])[0]
+        usage = response_data.get("usage", {})
+        message = choice.get("message", {})
+
+        return LLMResponseBuilder.from_openai_format(
+            content=message.get("content", ""),
+            prompt_tokens=usage.get("prompt_tokens"),
+            completion_tokens=usage.get("completion_tokens"),
+            total_tokens=usage.get("total_tokens"),
+            model_name=response_data.get("model", self._model_name),
+            finish_reason=choice.get("finish_reason"),
         )
-        self._ollama_base_url = base_url
+
+    @property
+    def model_name(self) -> str:
+        return self._model_name
+
+    @property
+    def ollama_base_url(self) -> str:
+        """Return the Ollama server base URL."""
+        return self._ollama_base_url
 
     @property
     def is_local(self) -> bool:
@@ -445,6 +547,109 @@ def supports_vision(self) -> bool:
         model_lower = self._model_name.lower()
         return any(x in model_lower for x in ["llava", "bakllava", "moondream"])
 
+    def generate_with_image(
+        self,
+        system_prompt: str,
+        user_prompt: str,
+        image_base64: str,
+        temperature: float = 0.0,
+        max_tokens: int | None = None,
+        **kwargs,
+    ) -> LLMResponse:
+        """
+        Generate response with image input using Ollama's vision models.
+
+        Args:
+            system_prompt: System instruction
+            user_prompt: User query
+            image_base64: Base64-encoded image (PNG or JPEG)
+            temperature: Sampling temperature (0.0 = deterministic)
+            max_tokens: Maximum tokens to generate
+            **kwargs: Additional API parameters
+
+        Returns:
+            LLMResponse object
+
+        Raises:
+            NotImplementedError: If model doesn't support vision
+        """
+        import json
+        import urllib.request
+        import urllib.error
+
+        if not self.supports_vision():
+            raise NotImplementedError(
+                f"Model {self._model_name} does not support vision. "
+                "Use llava, bakllava, or moondream models."
+            )
+
+        messages = []
+        if system_prompt:
+            messages.append({"role": "system", "content": system_prompt})
+
+        # Vision message format with image_url
+        messages.append(
+            {
+                "role": "user",
+                "content": [
+                    {"type": "text", "text": user_prompt},
+                    {
+                        "type": "image_url",
+                        "image_url": {"url": f"data:image/png;base64,{image_base64}"},
+                    },
+                ],
+            }
+        )
+
+        # Build API parameters
+        api_params: dict[str, Any] = {
+            "model": self._model_name,
+            "messages": messages,
+            "temperature": temperature,
+        }
+
+        if max_tokens:
+            api_params["max_tokens"] = max_tokens
+
+        # Merge additional parameters
+        for key, value in kwargs.items():
+            if key not in api_params:
+                api_params[key] = value
+
+        # Make HTTP request
+        url = f"{self._api_base_url}/chat/completions"
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": "Bearer ollama",
+        }
+
+        try:
+            request_data = json.dumps(api_params).encode("utf-8")
+            req = urllib.request.Request(url, data=request_data, headers=headers, method="POST")
+            with urllib.request.urlopen(req, timeout=self._timeout_seconds) as response:
+                response_data = json.loads(response.read().decode("utf-8"))
+        except urllib.error.URLError as e:
+            raise RuntimeError(
+                f"Failed to connect to Ollama at {self._ollama_base_url}. "
+                f"Ensure Ollama is running: {e}"
+            ) from e
+        except urllib.error.HTTPError as e:
+            raise RuntimeError(f"Ollama API error: {e.code} - {e.reason}") from e
+
+        # Parse response
+        choice = response_data.get("choices", [{}])[0]
+        usage = response_data.get("usage", {})
+        message = choice.get("message", {})
+
+        return LLMResponseBuilder.from_openai_format(
+            content=message.get("content", ""),
+            prompt_tokens=usage.get("prompt_tokens"),
+            completion_tokens=usage.get("completion_tokens"),
+            total_tokens=usage.get("total_tokens"),
+            model_name=response_data.get("model", self._model_name),
+            finish_reason=choice.get("finish_reason"),
+        )
+
 
 class AnthropicProvider(LLMProvider):
     """

tests/test_ollama_provider.py

@@ -2,34 +2,36 @@
 
 import pytest
 
-from predicate.llm_provider import OllamaProvider, OpenAIProvider
+from predicate.llm_provider import OllamaProvider, LLMProvider
 
 
 class TestOllamaProvider:
     """Test suite for OllamaProvider."""
 
-    def test_ollama_provider_is_subclass_of_openai(self):
-        """OllamaProvider should inherit from OpenAIProvider."""
-        assert issubclass(OllamaProvider, OpenAIProvider)
+    def test_ollama_provider_is_subclass_of_llm_provider(self):
+        """OllamaProvider should inherit from LLMProvider (not OpenAIProvider)."""
+        assert issubclass(OllamaProvider, LLMProvider)
 
     def test_ollama_provider_default_base_url(self):
         """OllamaProvider should use default localhost:11434 base URL."""
         provider = OllamaProvider(model="qwen3:8b")
-        # The internal client should have base_url set to /v1 endpoint
+        # The internal base URL should be set correctly
         assert provider._ollama_base_url == "http://localhost:11434"
+        assert provider.ollama_base_url == "http://localhost:11434"
 
     def test_ollama_provider_custom_base_url(self):
         """OllamaProvider should accept custom base URL."""
         provider = OllamaProvider(model="llama3:8b", base_url="http://192.168.1.100:11434")
         assert provider._ollama_base_url == "http://192.168.1.100:11434"
+        assert provider.ollama_base_url == "http://192.168.1.100:11434"
 
     def test_ollama_provider_strips_trailing_slash(self):
         """OllamaProvider should strip trailing slash from base URL."""
         provider = OllamaProvider(model="mistral:7b", base_url="http://localhost:11434/")
-        # The /v1 should be appended correctly without double slash
-        assert provider._ollama_base_url == "http://localhost:11434/"
-        # The actual OpenAI client base_url should be properly formed
-        # (trailing slash stripped before /v1 is appended)
+        # The trailing slash should be stripped
+        assert provider._ollama_base_url == "http://localhost:11434"
+        # The API base URL should be properly formed
+        assert provider._api_base_url == "http://localhost:11434/v1"
 
     def test_ollama_provider_is_local_property(self):
         """OllamaProvider.is_local should return True."""

traces/test-run.jsonl

@@ -13,3 +13,8 @@
 {"v": 1, "type": "run_start", "ts": "2026-03-29T01:08:28.000Z", "run_id": "test-run", "seq": 1, "data": {"agent": "SentienceAgent"}, "ts_ms": 1774746508045}
 {"v": 1, "type": "run_start", "ts": "2026-03-29T01:08:28.000Z", "run_id": "test-run", "seq": 1, "data": {"agent": "SentienceAgent"}, "ts_ms": 1774746508046}
 {"v": 1, "type": "run_start", "ts": "2026-03-29T01:08:28.000Z", "run_id": "test-run", "seq": 1, "data": {"agent": "SentienceAgent"}, "ts_ms": 1774746508134}
+{"v": 1, "type": "run_start", "ts": "2026-03-29T01:51:59.000Z", "run_id": "test-run", "seq": 1, "data": {"agent": "SentienceAgent"}, "ts_ms": 1774749119216}
+{"v": 1, "type": "run_start", "ts": "2026-03-29T01:51:59.000Z", "run_id": "test-run", "seq": 1, "data": {"agent": "SentienceAgent"}, "ts_ms": 1774749119218}
+{"v": 1, "type": "run_start", "ts": "2026-03-29T01:51:59.000Z", "run_id": "test-run", "seq": 1, "data": {"agent": "SentienceAgent"}, "ts_ms": 1774749119219}
+{"v": 1, "type": "run_start", "ts": "2026-03-29T01:51:59.000Z", "run_id": "test-run", "seq": 1, "data": {"agent": "SentienceAgent"}, "ts_ms": 1774749119221}
+{"v": 1, "type": "run_start", "ts": "2026-03-29T01:51:59.000Z", "run_id": "test-run", "seq": 1, "data": {"agent": "SentienceAgent"}, "ts_ms": 1774749119306}