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

abstractcore/providers/huggingface_provider.py

@@ -1287,7 +1287,13 @@ class HuggingFaceProvider(BaseProvider):
 
             elif self.tool_handler.supports_prompted:
                 # Add tools as system prompt for prompted models
-                tool_prompt = self.tool_handler.format_tools_prompt(tools)
+                system_text = (
+                    chat_messages[0].get("content", "")
+                    if chat_messages and chat_messages[0].get("role") == "system"
+                    else ""
+                )
+                include_tool_list = "## Tools (session)" not in str(system_text)
+                tool_prompt = self.tool_handler.format_tools_prompt(tools, include_tool_list=include_tool_list)
                 if chat_messages and chat_messages[0]["role"] == "system":
                     chat_messages[0]["content"] += f"\n\n{tool_prompt}"
                 else:
@@ -1577,21 +1583,24 @@ class HuggingFaceProvider(BaseProvider):
         """Build input text for transformers model with tool support"""
 
         # Add tools to system prompt if provided
-        enhanced_system_prompt = system_prompt
+        final_system_prompt = system_prompt
         if tools and self.tool_handler.supports_prompted:
-            tool_prompt = self.tool_handler.format_tools_prompt(tools)
-            if enhanced_system_prompt:
-                enhanced_system_prompt += f"\n\n{tool_prompt}"
+            include_tool_list = True
+            if final_system_prompt and "## Tools (session)" in final_system_prompt:
+                include_tool_list = False
+            tool_prompt = self.tool_handler.format_tools_prompt(tools, include_tool_list=include_tool_list)
+            if final_system_prompt:
+                final_system_prompt += f"\n\n{tool_prompt}"
             else:
-                enhanced_system_prompt = tool_prompt
+                final_system_prompt = tool_prompt
 
         # Check if model has chat template
         if hasattr(self.tokenizer, 'chat_template') and self.tokenizer.chat_template:
             # Use chat template if available
             chat_messages = []
 
-            if enhanced_system_prompt:
-                chat_messages.append({"role": "system", "content": enhanced_system_prompt})
+            if final_system_prompt:
+                chat_messages.append({"role": "system", "content": final_system_prompt})
 
             if messages:
                 chat_messages.extend(messages)

abstractcore/providers/lmstudio_provider.py

@@ -16,7 +16,13 @@ except ImportError:
     BaseModel = None
 from .base import BaseProvider
 from ..core.types import GenerateResponse
-from ..exceptions import ProviderAPIError, ModelNotFoundError, format_model_error, format_provider_error
+from ..exceptions import (
+    ProviderAPIError,
+    ModelNotFoundError,
+    InvalidRequestError,
+    format_model_error,
+    format_provider_error,
+)
 from ..tools import UniversalToolHandler, execute_tools
 from ..events import EventType
 
@@ -49,7 +55,16 @@ class LMStudioProvider(BaseProvider):
         except Exception as e:
             # Fallback with default timeout if client creation fails
             try:
-                self.client = httpx.Client(timeout=300.0)
+                fallback_timeout = None
+                try:
+                    from ..config.manager import get_config_manager
+
+                    fallback_timeout = float(get_config_manager().get_default_timeout())
+                except Exception:
+                    fallback_timeout = 7200.0
+                if isinstance(fallback_timeout, (int, float)) and float(fallback_timeout) <= 0:
+                    fallback_timeout = None
+                self.client = httpx.Client(timeout=fallback_timeout)
             except Exception:
                 raise RuntimeError(f"Failed to create HTTP client for LMStudio: {e}")
 
@@ -142,19 +157,24 @@ class LMStudioProvider(BaseProvider):
         chat_messages = []
 
         # Add tools to system prompt if provided
-        enhanced_system_prompt = system_prompt
-        if tools and self.tool_handler.supports_prompted:
-            tool_prompt = self.tool_handler.format_tools_prompt(tools)
-            if enhanced_system_prompt:
-                enhanced_system_prompt += f"\n\n{tool_prompt}"
+        final_system_prompt = system_prompt
+        # Prefer native tools when the model supports them. Only inject a prompted tool list
+        # when native tool calling is not available.
+        if tools and self.tool_handler.supports_prompted and not self.tool_handler.supports_native:
+            include_tool_list = True
+            if final_system_prompt and "## Tools (session)" in final_system_prompt:
+                include_tool_list = False
+            tool_prompt = self.tool_handler.format_tools_prompt(tools, include_tool_list=include_tool_list)
+            if final_system_prompt:
+                final_system_prompt += f"\n\n{tool_prompt}"
             else:
-                enhanced_system_prompt = tool_prompt
+                final_system_prompt = tool_prompt
 
         # Add system message if provided
-        if enhanced_system_prompt:
+        if final_system_prompt:
             chat_messages.append({
                 "role": "system",
-                "content": enhanced_system_prompt
+                "content": final_system_prompt
             })
 
         # Add conversation history
@@ -231,6 +251,11 @@ class LMStudioProvider(BaseProvider):
             "max_tokens": max_output_tokens,  # LMStudio uses max_tokens for output tokens
             "top_p": kwargs.get("top_p", 0.9),
         }
+
+        # Native tools (OpenAI-compatible): send structured tools/tool_choice when supported.
+        if tools and self.tool_handler.supports_native:
+            payload["tools"] = self.tool_handler.prepare_tools_for_native(tools)
+            payload["tool_choice"] = kwargs.get("tool_choice", "auto")
         
         # Add additional generation parameters if provided (OpenAI-compatible)
         if "frequency_penalty" in kwargs:
@@ -280,8 +305,9 @@ class LMStudioProvider(BaseProvider):
 
             # Track generation time
             start_time = time.time()
+            request_url = f"{self.base_url}/chat/completions"
             response = self.client.post(
-                f"{self.base_url}/chat/completions",
+                request_url,
                 json=payload,
                 headers={"Content-Type": "application/json"}
             )
@@ -293,20 +319,42 @@ class LMStudioProvider(BaseProvider):
             # Extract response from OpenAI format
             if "choices" in result and len(result["choices"]) > 0:
                 choice = result["choices"][0]
-                content = choice.get("message", {}).get("content", "")
+                message = choice.get("message") or {}
+                if not isinstance(message, dict):
+                    message = {}
+
+                content = message.get("content", "")
+                reasoning = message.get("reasoning")
+                tool_calls = message.get("tool_calls")
+                if tool_calls is None:
+                    # Some servers surface tool calls at the choice level.
+                    tool_calls = choice.get("tool_calls")
                 finish_reason = choice.get("finish_reason", "stop")
             else:
                 content = "No response generated"
+                reasoning = None
+                tool_calls = None
                 finish_reason = "error"
 
             # Extract usage info
             usage = result.get("usage", {})
 
+            metadata = {}
+            if isinstance(reasoning, str) and reasoning.strip():
+                metadata["reasoning"] = reasoning
+            # Runtime observability: capture the exact HTTP JSON payload we sent.
+            metadata["_provider_request"] = {
+                "url": request_url,
+                "payload": payload,
+            }
+
             return GenerateResponse(
                 content=content,
                 model=self.model,
                 finish_reason=finish_reason,
                 raw_response=result,
+                tool_calls=tool_calls if isinstance(tool_calls, list) else None,
+                metadata=metadata or None,
                 usage={
                     "input_tokens": usage.get("prompt_tokens", 0),
                     "output_tokens": usage.get("completion_tokens", 0),
@@ -318,6 +366,44 @@ class LMStudioProvider(BaseProvider):
                 gen_time=gen_time
             )
 
+        except httpx.HTTPStatusError as e:
+            # Improve debuggability: include LMStudio's error response body (often a JSON error envelope).
+            resp = getattr(e, "response", None)
+            status = getattr(resp, "status_code", None)
+
+            body_text = ""
+            try:
+                if resp is not None:
+                    # Try to extract a structured error message if the server returns JSON.
+                    try:
+                        j = resp.json()
+                        if isinstance(j, dict):
+                            err = j.get("error")
+                            if isinstance(err, dict):
+                                msg = err.get("message") or err.get("error") or err.get("detail")
+                                if isinstance(msg, str) and msg.strip():
+                                    body_text = msg.strip()
+                            if not body_text:
+                                msg2 = j.get("message") or j.get("detail")
+                                if isinstance(msg2, str) and msg2.strip():
+                                    body_text = msg2.strip()
+                        if not body_text:
+                            body_text = json.dumps(j, ensure_ascii=False)
+                    except Exception:
+                        body_text = str(getattr(resp, "text", "") or "").strip()
+            except Exception:
+                body_text = ""
+
+            if body_text and len(body_text) > 2000:
+                body_text = body_text[:2000] + "…"
+
+            # Preserve classification for BaseProvider error normalization.
+            base = str(e)
+            detail = f"{base} | response={body_text}" if body_text else base
+            if isinstance(status, int) and 400 <= status < 500:
+                raise InvalidRequestError(detail)
+            raise ProviderAPIError(detail)
+
         except AttributeError as e:
             # Handle None type errors specifically
             if "'NoneType'" in str(e):
@@ -336,7 +422,7 @@ class LMStudioProvider(BaseProvider):
                     # If model discovery also fails, provide a generic error
                     raise ModelNotFoundError(f"Model '{self.model}' not found in LMStudio and could not fetch available models")
             else:
-                raise ProviderAPIError(f"LMStudio API error: {str(e)}")
+                raise
 
     def _stream_generate(self, payload: Dict[str, Any]) -> Iterator[GenerateResponse]:
         """Generate streaming response"""
@@ -368,14 +454,24 @@ class LMStudioProvider(BaseProvider):
                                 if "choices" in chunk and len(chunk["choices"]) > 0:
                                     choice = chunk["choices"][0]
                                     delta = choice.get("delta", {})
+                                    if not isinstance(delta, dict):
+                                        delta = {}
                                     content = delta.get("content", "")
+                                    reasoning = delta.get("reasoning")
+                                    tool_calls = delta.get("tool_calls") or choice.get("tool_calls")
                                     finish_reason = choice.get("finish_reason")
 
+                                    metadata = {}
+                                    if isinstance(reasoning, str) and reasoning.strip():
+                                        metadata["reasoning"] = reasoning
+
                                     yield GenerateResponse(
                                         content=content,
                                         model=self.model,
                                         finish_reason=finish_reason,
-                                        raw_response=chunk
+                                        tool_calls=tool_calls if isinstance(tool_calls, list) else None,
+                                        metadata=metadata or None,
+                                        raw_response=chunk,
                                     )
 
                             except json.JSONDecodeError:
@@ -405,19 +501,23 @@ class LMStudioProvider(BaseProvider):
         chat_messages = []
 
         # Add tools to system prompt if provided
-        enhanced_system_prompt = system_prompt
-        if tools and self.tool_handler.supports_prompted:
-            tool_prompt = self.tool_handler.format_tools_prompt(tools)
-            if enhanced_system_prompt:
-                enhanced_system_prompt += f"\n\n{tool_prompt}"
+        final_system_prompt = system_prompt
+        # Prefer native tools when available; only inject prompted tool syntax as fallback.
+        if tools and self.tool_handler.supports_prompted and not self.tool_handler.supports_native:
+            include_tool_list = True
+            if final_system_prompt and "## Tools (session)" in final_system_prompt:
+                include_tool_list = False
+            tool_prompt = self.tool_handler.format_tools_prompt(tools, include_tool_list=include_tool_list)
+            if final_system_prompt:
+                final_system_prompt += f"\n\n{tool_prompt}"
             else:
-                enhanced_system_prompt = tool_prompt
+                final_system_prompt = tool_prompt
 
         # Add system message if provided
-        if enhanced_system_prompt:
+        if final_system_prompt:
             chat_messages.append({
                 "role": "system",
-                "content": enhanced_system_prompt
+                "content": final_system_prompt
             })
 
         # Add conversation history
@@ -473,6 +573,11 @@ class LMStudioProvider(BaseProvider):
             "top_p": kwargs.get("top_p", 0.9),
         }
 
+        # Native tools (OpenAI-compatible): send structured tools/tool_choice when supported.
+        if tools and self.tool_handler.supports_native:
+            payload["tools"] = self.tool_handler.prepare_tools_for_native(tools)
+            payload["tool_choice"] = kwargs.get("tool_choice", "auto")
+
         # Add additional parameters
         if "frequency_penalty" in kwargs:
             payload["frequency_penalty"] = kwargs["frequency_penalty"]
@@ -513,8 +618,9 @@ class LMStudioProvider(BaseProvider):
         try:
             # Track generation time
             start_time = time.time()
+            request_url = f"{self.base_url}/chat/completions"
             response = await self.async_client.post(
-                f"{self.base_url}/chat/completions",
+                request_url,
                 json=payload,
                 headers={"Content-Type": "application/json"}
             )
@@ -526,20 +632,40 @@ class LMStudioProvider(BaseProvider):
             # Extract response from OpenAI format
             if "choices" in result and len(result["choices"]) > 0:
                 choice = result["choices"][0]
-                content = choice.get("message", {}).get("content", "")
+                message = choice.get("message") or {}
+                if not isinstance(message, dict):
+                    message = {}
+
+                content = message.get("content", "")
+                reasoning = message.get("reasoning")
+                tool_calls = message.get("tool_calls")
+                if tool_calls is None:
+                    tool_calls = choice.get("tool_calls")
                 finish_reason = choice.get("finish_reason", "stop")
             else:
                 content = "No response generated"
+                reasoning = None
+                tool_calls = None
                 finish_reason = "error"
 
             # Extract usage info
             usage = result.get("usage", {})
 
+            metadata = {}
+            if isinstance(reasoning, str) and reasoning.strip():
+                metadata["reasoning"] = reasoning
+            metadata["_provider_request"] = {
+                "url": request_url,
+                "payload": payload,
+            }
+
             return GenerateResponse(
                 content=content,
                 model=self.model,
                 finish_reason=finish_reason,
                 raw_response=result,
+                tool_calls=tool_calls if isinstance(tool_calls, list) else None,
+                metadata=metadata or None,
                 usage={
                     "input_tokens": usage.get("prompt_tokens", 0),
                     "output_tokens": usage.get("completion_tokens", 0),
@@ -589,13 +715,23 @@ class LMStudioProvider(BaseProvider):
                                 if "choices" in chunk and len(chunk["choices"]) > 0:
                                     choice = chunk["choices"][0]
                                     delta = choice.get("delta", {})
+                                    if not isinstance(delta, dict):
+                                        delta = {}
                                     content = delta.get("content", "")
+                                    reasoning = delta.get("reasoning")
+                                    tool_calls = delta.get("tool_calls") or choice.get("tool_calls")
                                     finish_reason = choice.get("finish_reason")
 
+                                    metadata = {}
+                                    if isinstance(reasoning, str) and reasoning.strip():
+                                        metadata["reasoning"] = reasoning
+
                                     yield GenerateResponse(
                                         content=content,
                                         model=self.model,
                                         finish_reason=finish_reason,
+                                        tool_calls=tool_calls if isinstance(tool_calls, list) else None,
+                                        metadata=metadata or None,
                                         raw_response=chunk
                                     )
 
@@ -648,7 +784,16 @@ class LMStudioProvider(BaseProvider):
                     self.logger.warning(f"Failed to update HTTP client timeout: {e}")
                 # Try to create a new client with default timeout
                 try:
-                    self.client = httpx.Client(timeout=300.0)
+                    fallback_timeout = None
+                    try:
+                        from ..config.manager import get_config_manager
+
+                        fallback_timeout = float(get_config_manager().get_default_timeout())
+                    except Exception:
+                        fallback_timeout = 7200.0
+                    if isinstance(fallback_timeout, (int, float)) and float(fallback_timeout) <= 0:
+                        fallback_timeout = None
+                    self.client = httpx.Client(timeout=fallback_timeout)
                 except Exception:
                     pass  # Best effort - don't fail the operation
 

abstractcore/providers/mlx_provider.py

@@ -291,21 +291,24 @@ class MLXProvider(BaseProvider):
         """Build prompt for MLX model with tool support"""
 
         # Add tools to system prompt if provided
-        enhanced_system_prompt = system_prompt
+        final_system_prompt = system_prompt
         if tools and self.tool_handler.supports_prompted:
-            tool_prompt = self.tool_handler.format_tools_prompt(tools)
-            if enhanced_system_prompt:
-                enhanced_system_prompt += f"\n\n{tool_prompt}"
+            include_tool_list = True
+            if final_system_prompt and "## Tools (session)" in final_system_prompt:
+                include_tool_list = False
+            tool_prompt = self.tool_handler.format_tools_prompt(tools, include_tool_list=include_tool_list)
+            if final_system_prompt:
+                final_system_prompt += f"\n\n{tool_prompt}"
             else:
-                enhanced_system_prompt = tool_prompt
+                final_system_prompt = tool_prompt
 
         # For Qwen models, use chat template format
         if "qwen" in self.model.lower():
             full_prompt = ""
 
             # Add system prompt
-            if enhanced_system_prompt:
-                full_prompt += f"<|im_start|>system\n{enhanced_system_prompt}<|im_end|>\n"
+            if final_system_prompt:
+                full_prompt += f"<|im_start|>system\n{final_system_prompt}<|im_end|>\n"
 
             # Add conversation history
             if messages:
@@ -321,8 +324,8 @@ class MLXProvider(BaseProvider):
         else:
             # Generic format for other models
             full_prompt = prompt
-            if enhanced_system_prompt:
-                full_prompt = f"{enhanced_system_prompt}\n\n{prompt}"
+            if final_system_prompt:
+                full_prompt = f"{final_system_prompt}\n\n{prompt}"
 
             # Add conversation context if provided
             if messages:
@@ -541,4 +544,4 @@ class MLXProvider(BaseProvider):
             return models
 
         except Exception:
-            return []
+            return []

abstractcore/providers/ollama_provider.py

@@ -148,13 +148,16 @@ class OllamaProvider(BaseProvider):
         """Internal generation with Ollama"""
 
         # Handle tools for prompted models
-        effective_system_prompt = system_prompt
+        final_system_prompt = system_prompt
         if tools and self.tool_handler.supports_prompted:
-            tool_prompt = self.tool_handler.format_tools_prompt(tools)
-            if effective_system_prompt:
-                effective_system_prompt = f"{effective_system_prompt}\n\n{tool_prompt}"
+            include_tool_list = True
+            if final_system_prompt and "## Tools (session)" in final_system_prompt:
+                include_tool_list = False
+            tool_prompt = self.tool_handler.format_tools_prompt(tools, include_tool_list=include_tool_list)
+            if final_system_prompt:
+                final_system_prompt = f"{final_system_prompt}\n\n{tool_prompt}"
             else:
-                effective_system_prompt = tool_prompt
+                final_system_prompt = tool_prompt
 
         # Build request payload using unified system
         generation_kwargs = self._prepare_generation_kwargs(**kwargs)
@@ -189,10 +192,10 @@ class OllamaProvider(BaseProvider):
             payload["messages"] = []
 
             # Add system message if provided
-            if effective_system_prompt:
+            if final_system_prompt:
                 payload["messages"].append({
                     "role": "system",
-                    "content": effective_system_prompt
+                    "content": final_system_prompt
                 })
 
             # Add conversation history (converted to Ollama-compatible format)
@@ -245,8 +248,8 @@ class OllamaProvider(BaseProvider):
         else:
             # Use generate format for single prompt (legacy fallback)
             full_prompt = prompt
-            if effective_system_prompt:
-                full_prompt = f"{effective_system_prompt}\n\n{prompt}"
+            if final_system_prompt:
+                full_prompt = f"{final_system_prompt}\n\n{prompt}"
 
             payload["prompt"] = full_prompt
             endpoint = "/api/generate"
@@ -292,6 +295,14 @@ class OllamaProvider(BaseProvider):
                 },
                 gen_time=gen_time
             )
+
+            # Runtime observability: capture the exact HTTP JSON payload we sent to Ollama.
+            if not generate_response.metadata:
+                generate_response.metadata = {}
+            generate_response.metadata["_provider_request"] = {
+                "url": f"{self.base_url}{endpoint}",
+                "payload": payload,
+            }
             
             # Attach media metadata if available
             if media_metadata:
@@ -314,12 +325,8 @@ class OllamaProvider(BaseProvider):
                 available_models = self.list_available_models(base_url=self.base_url)
                 error_message = format_model_error("Ollama", self.model, available_models)
                 raise ModelNotFoundError(error_message)
-            else:
-                return GenerateResponse(
-                    content=f"Error: {str(e)}",
-                    model=self.model,
-                    finish_reason="error"
-                )
+            # Let BaseProvider normalize (timeouts/connectivity/etc.) consistently.
+            raise
 
     def _stream_generate(self, endpoint: str, payload: Dict[str, Any], tools: Optional[List[Dict[str, Any]]] = None, tool_call_tags: Optional[str] = None) -> Iterator[GenerateResponse]:
         """Generate streaming response with tool tag rewriting support"""
@@ -367,7 +374,13 @@ class OllamaProvider(BaseProvider):
                                 content=content,
                                 model=self.model,
                                 finish_reason="stop" if done else None,
-                                raw_response=chunk
+                                raw_response=chunk,
+                                metadata={
+                                    "_provider_request": {
+                                        "url": f"{self.base_url}{endpoint}",
+                                        "payload": payload,
+                                    }
+                                },
                             )
 
                             yield chunk_response
@@ -416,13 +429,16 @@ class OllamaProvider(BaseProvider):
                                    **kwargs):
         """Native async implementation using httpx.AsyncClient - 3-10x faster for batch operations."""
         # Handle tools for prompted models
-        effective_system_prompt = system_prompt
+        final_system_prompt = system_prompt
         if tools and self.tool_handler.supports_prompted:
-            tool_prompt = self.tool_handler.format_tools_prompt(tools)
-            if effective_system_prompt:
-                effective_system_prompt = f"{effective_system_prompt}\n\n{tool_prompt}"
+            include_tool_list = True
+            if final_system_prompt and "## Tools (session)" in final_system_prompt:
+                include_tool_list = False
+            tool_prompt = self.tool_handler.format_tools_prompt(tools, include_tool_list=include_tool_list)
+            if final_system_prompt:
+                final_system_prompt = f"{final_system_prompt}\n\n{tool_prompt}"
             else:
-                effective_system_prompt = tool_prompt
+                final_system_prompt = tool_prompt
 
         # Build request payload (same logic as sync)
         generation_kwargs = self._prepare_generation_kwargs(**kwargs)
@@ -453,10 +469,10 @@ class OllamaProvider(BaseProvider):
         if use_chat_format:
             payload["messages"] = []
 
-            if effective_system_prompt:
+            if final_system_prompt:
                 payload["messages"].append({
                     "role": "system",
-                    "content": effective_system_prompt
+                    "content": final_system_prompt
                 })
 
             if messages:
@@ -486,8 +502,8 @@ class OllamaProvider(BaseProvider):
             endpoint = "/api/chat"
         else:
             full_prompt = prompt
-            if effective_system_prompt:
-                full_prompt = f"{effective_system_prompt}\n\n{prompt}"
+            if final_system_prompt:
+                full_prompt = f"{final_system_prompt}\n\n{prompt}"
             payload["prompt"] = full_prompt
             endpoint = "/api/generate"
 
@@ -809,4 +825,4 @@ class OllamaProvider(BaseProvider):
             
         except Exception as e:
             self.logger.error(f"Failed to generate embeddings: {e}")
-            raise ProviderAPIError(f"Ollama embedding error: {str(e)}")
+            raise ProviderAPIError(f"Ollama embedding error: {str(e)}")