abstractcore 2.9.1__py3-none-any.whl → 2.11.2__py3-none-any.whl

abstractcore/providers/ollama_provider.py

@@ -51,7 +51,7 @@ class OllamaProvider(BaseProvider):
             )
         return self._async_client
 
-    def unload(self) -> None:
+    def unload_model(self, model_name: str) -> None:
         """
         Unload the model from Ollama server memory.
 
@@ -59,9 +59,11 @@ class OllamaProvider(BaseProvider):
         from the Ollama server, freeing server-side memory.
         """
         try:
+            target_model = model_name.strip() if isinstance(model_name, str) and model_name.strip() else self.model
+
             # Send a minimal generate request with keep_alive=0 to unload
             payload = {
-                "model": self.model,
+                "model": target_model,
                 "prompt": "",  # Minimal prompt
                 "stream": False,
                 "keep_alive": 0  # Immediately unload after this request
@@ -97,6 +99,47 @@ class OllamaProvider(BaseProvider):
         """Public generate method that includes telemetry"""
         return self.generate_with_telemetry(*args, **kwargs)
 
+    def _apply_provider_thinking_kwargs(
+        self,
+        *,
+        enabled: Optional[bool],
+        level: Optional[str],
+        kwargs: Dict[str, Any],
+    ) -> tuple[Dict[str, Any], bool]:
+        # Ollama exposes "thinking" via the request field `think`.
+        # Most models accept a boolean; GPT-OSS uses "low|medium|high" and cannot fully disable traces.
+        if enabled is None and level is None:
+            return kwargs, False
+
+        new_kwargs = dict(kwargs)
+
+        reasoning_levels = self._model_reasoning_levels()
+        wants_levels = bool(reasoning_levels)
+
+        if wants_levels:
+            # Prefer explicit level; otherwise map off->low, on->medium.
+            if level is not None:
+                new_kwargs["think"] = level
+                return new_kwargs, True
+            if enabled is False:
+                new_kwargs["think"] = "low"
+                return new_kwargs, True
+            if enabled is True:
+                new_kwargs["think"] = "medium"
+                return new_kwargs, True
+            return kwargs, False
+
+        # Boolean mode.
+        if level is not None:
+            # Best-effort fallback.
+            new_kwargs["think"] = True
+            return new_kwargs, True
+        if enabled is not None:
+            new_kwargs["think"] = bool(enabled)
+            return new_kwargs, True
+
+        return kwargs, False
+
     def _convert_messages_for_ollama(self, messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
         """Convert OpenAI messages to Ollama-compatible format
 
@@ -167,16 +210,21 @@ class OllamaProvider(BaseProvider):
             "model": self.model,
             "stream": stream,
             "options": {
-                "temperature": kwargs.get("temperature", self.temperature),
+                "temperature": generation_kwargs.get("temperature", self.temperature),
                 "num_predict": max_output_tokens,  # Ollama uses num_predict for max output tokens
             }
         }
 
         # Add seed if provided (Ollama supports seed for deterministic outputs)
-        seed_value = kwargs.get("seed", self.seed)
+        seed_value = generation_kwargs.get("seed")
         if seed_value is not None:
             payload["options"]["seed"] = seed_value
 
+        # Unified thinking/reasoning control (Ollama-native).
+        think_value = generation_kwargs.get("think")
+        if think_value is not None:
+            payload["think"] = think_value
+
         # Add structured output support (Ollama native JSON schema)
         # Ollama accepts the full JSON schema in the "format" parameter
         # This provides server-side guaranteed schema compliance
@@ -204,6 +252,7 @@ class OllamaProvider(BaseProvider):
                 payload["messages"].extend(converted_messages)
 
             # Handle media content regardless of prompt (media can be used with messages too)
+            media_enrichment = None
             if media:
                 # Get the text to combine with media
                 user_message_text = prompt.strip() if prompt else ""
@@ -213,6 +262,7 @@ class OllamaProvider(BaseProvider):
 
                     # Create multimodal message combining text and media
                     multimodal_message = media_handler.create_multimodal_message(user_message_text, media)
+                    media_enrichment = getattr(media_handler, "media_enrichment", None)
 
                     # For local providers, we might get a string (embedded text) or dict (structured)
                     if isinstance(multimodal_message, str):
@@ -223,7 +273,7 @@ class OllamaProvider(BaseProvider):
                     else:
                         payload["messages"].append(multimodal_message)
                 except ImportError:
-                    self.logger.warning("Media processing not available. Install with: pip install abstractcore[media]")
+                    self.logger.warning("Media processing not available. Install with: pip install \"abstractcore[media]\"")
                     if user_message_text:
                         payload["messages"].append({
                             "role": "user",
@@ -257,7 +307,12 @@ class OllamaProvider(BaseProvider):
         if stream:
             return self._stream_generate(endpoint, payload, tools, kwargs.get('tool_call_tags'))
         else:
-            return self._single_generate(endpoint, payload, tools, media_metadata)
+            response = self._single_generate(endpoint, payload, tools, media_metadata)
+            if media_enrichment:
+                from ..media.enrichment import merge_enrichment_metadata
+
+                response.metadata = merge_enrichment_metadata(response.metadata, media_enrichment)
+            return response
 
     def _single_generate(self, endpoint: str, payload: Dict[str, Any], tools: Optional[List[Dict[str, Any]]] = None, media_metadata: Optional[List[Dict[str, Any]]] = None) -> GenerateResponse:
         """Generate single response"""
@@ -303,6 +358,20 @@ class OllamaProvider(BaseProvider):
                 "url": f"{self.base_url}{endpoint}",
                 "payload": payload,
             }
+
+            # Capture Ollama thinking output (if present) into canonical metadata["reasoning"].
+            thinking_text = None
+            try:
+                if endpoint == "/api/chat":
+                    msg = result.get("message") if isinstance(result, dict) else None
+                    msg = msg if isinstance(msg, dict) else {}
+                    thinking_text = msg.get("thinking") or msg.get("reasoning")
+                else:
+                    thinking_text = result.get("thinking") or result.get("reasoning")
+            except Exception:
+                thinking_text = None
+            if isinstance(thinking_text, str) and thinking_text.strip():
+                generate_response.metadata.setdefault("reasoning", thinking_text.strip())
             
             # Attach media metadata if available
             if media_metadata:
@@ -370,17 +439,31 @@ class OllamaProvider(BaseProvider):
                                 rewritten_content, buffer = rewriter.rewrite_streaming_chunk(content, buffer)
                                 content = rewritten_content
 
+                            metadata: Dict[str, Any] = {
+                                "_provider_request": {
+                                    "url": f"{self.base_url}{endpoint}",
+                                    "payload": payload,
+                                }
+                            }
+                            # Capture incremental thinking output when present.
+                            try:
+                                if endpoint == "/api/chat":
+                                    msg = chunk.get("message") if isinstance(chunk, dict) else None
+                                    msg = msg if isinstance(msg, dict) else {}
+                                    thinking_text = msg.get("thinking") or msg.get("reasoning")
+                                else:
+                                    thinking_text = chunk.get("thinking") or chunk.get("reasoning")
+                            except Exception:
+                                thinking_text = None
+                            if isinstance(thinking_text, str) and thinking_text.strip():
+                                metadata.setdefault("reasoning", thinking_text.strip())
+
                             chunk_response = GenerateResponse(
                                 content=content,
                                 model=self.model,
                                 finish_reason="stop" if done else None,
                                 raw_response=chunk,
-                                metadata={
-                                    "_provider_request": {
-                                        "url": f"{self.base_url}{endpoint}",
-                                        "payload": payload,
-                                    }
-                                },
+                                metadata=metadata,
                             )
 
                             yield chunk_response
@@ -449,12 +532,12 @@ class OllamaProvider(BaseProvider):
             "model": self.model,
             "stream": stream,
             "options": {
-                "temperature": kwargs.get("temperature", self.temperature),
+                "temperature": generation_kwargs.get("temperature", self.temperature),
                 "num_predict": max_output_tokens,
             }
         }
 
-        seed_value = kwargs.get("seed", self.seed)
+        seed_value = generation_kwargs.get("seed")
         if seed_value is not None:
             payload["options"]["seed"] = seed_value
 
@@ -685,7 +768,8 @@ class OllamaProvider(BaseProvider):
             finish_reason=response.finish_reason,
             raw_response=response.raw_response,
             usage=response.usage,
-            tool_calls=tool_call_response.tool_calls
+            tool_calls=tool_call_response.tool_calls,
+            metadata=response.metadata,
         )
 
     def get_capabilities(self) -> List[str]: