abstractcore 2.4.3__tar.gz → 2.4.4__tar.gz

{abstractcore-2.4.3 → abstractcore-2.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstractcore
-Version: 2.4.3
+Version: 2.4.4
 Summary: Unified interface to all LLM providers with essential infrastructure for tool calling, streaming, and model management
 Author-email: Laurent-Philippe Albou <contact@abstractcore.ai>
 Maintainer-email: Laurent-Philippe Albou <contact@abstractcore.ai>

{abstractcore-2.4.3 → abstractcore-2.4.4}/abstractcore/providers/base.py

@@ -867,6 +867,103 @@ class BaseProvider(AbstractCoreInterface, ABC):
         """
         pass
 
+    def health(self, timeout: Optional[float] = 5.0) -> Dict[str, Any]:
+        """
+        Check provider health and connectivity.
+
+        This method tests if the provider is online and accessible by attempting
+        to list available models. A successful model listing indicates the provider
+        is healthy and ready to serve requests.
+
+        Args:
+            timeout: Maximum time in seconds to wait for health check (default: 5.0).
+                    None means unlimited timeout (not recommended for health checks).
+
+        Returns:
+            Dict with health status information:
+            {
+                "status": bool,              # True if provider is healthy/online
+                "provider": str,             # Provider class name (e.g., "OpenAIProvider")
+                "models": List[str] | None,  # Available models if online, None if offline
+                "model_count": int,          # Number of models available (0 if offline)
+                "error": str | None,         # Error message if offline, None if healthy
+                "latency_ms": float          # Time taken for health check in milliseconds
+            }
+
+        Example:
+            >>> provider = OllamaProvider(model="llama2")
+            >>> health = provider.health(timeout=3.0)
+            >>> if health["status"]:
+            >>>     print(f"Healthy! {health['model_count']} models available")
+            >>> else:
+            >>>     print(f"Offline: {health['error']}")
+
+        Note:
+            - This method never raises exceptions; errors are captured in the response
+            - Uses list_available_models() as the connectivity test
+            - Providers can override this method for custom health check logic
+        """
+        import time as time_module
+
+        start_time = time_module.time()
+        provider_name = self.__class__.__name__
+
+        try:
+            # Attempt to list models as connectivity test
+            # Store original timeout if provider has HTTP client
+            original_timeout = None
+            timeout_changed = False
+
+            if timeout is not None and hasattr(self, '_timeout'):
+                original_timeout = self._timeout
+                if original_timeout != timeout:
+                    self.set_timeout(timeout)
+                    timeout_changed = True
+
+            try:
+                models = self.list_available_models()
+
+                # Restore original timeout if changed
+                if timeout_changed and original_timeout is not None:
+                    self.set_timeout(original_timeout)
+
+                latency_ms = (time_module.time() - start_time) * 1000
+
+                return {
+                    "status": True,
+                    "provider": provider_name,
+                    "models": models,
+                    "model_count": len(models) if models else 0,
+                    "error": None,
+                    "latency_ms": round(latency_ms, 2)
+                }
+
+            except Exception as e:
+                # Restore original timeout on error
+                if timeout_changed and original_timeout is not None:
+                    try:
+                        self.set_timeout(original_timeout)
+                    except:
+                        pass  # Best effort restoration
+                raise  # Re-raise to be caught by outer handler
+
+        except Exception as e:
+            latency_ms = (time_module.time() - start_time) * 1000
+
+            # Extract meaningful error message
+            error_message = str(e)
+            if not error_message:
+                error_message = f"{type(e).__name__} occurred during health check"
+
+            return {
+                "status": False,
+                "provider": provider_name,
+                "models": None,
+                "model_count": 0,
+                "error": error_message,
+                "latency_ms": round(latency_ms, 2)
+            }
+
     def _needs_tag_rewriting(self, tool_call_tags) -> bool:
         """Check if tag rewriting is needed (tags are non-standard)"""
         try:

{abstractcore-2.4.3 → abstractcore-2.4.4}/abstractcore/providers/huggingface_provider.py

@@ -864,19 +864,14 @@ class HuggingFaceProvider(BaseProvider):
             if outputs and len(outputs) > 0:
                 response_text = outputs[0]['generated_text'].strip()
 
-                # Calculate token usage
-                input_tokens = len(self.tokenizer.encode(input_text))
-                output_tokens = len(self.tokenizer.encode(response_text))
+                # Calculate token usage using centralized utilities
+                usage = self._calculate_usage(input_text, response_text)
 
                 return GenerateResponse(
                     content=response_text,
                     model=self.model,
                     finish_reason="stop",
-                    usage={
-                        "prompt_tokens": input_tokens,
-                        "completion_tokens": output_tokens,
-                        "total_tokens": input_tokens + output_tokens
-                    }
+                    usage=usage
                 )
             else:
                 return GenerateResponse(
@@ -892,6 +887,20 @@ class HuggingFaceProvider(BaseProvider):
                 finish_reason="error"
             )
 
+    def _calculate_usage(self, prompt: str, response: str) -> Dict[str, int]:
+        """Calculate token usage using centralized token utilities."""
+        from ..utils.token_utils import TokenUtils
+
+        prompt_tokens = TokenUtils.estimate_tokens(prompt, self.model)
+        completion_tokens = TokenUtils.estimate_tokens(response, self.model)
+        total_tokens = prompt_tokens + completion_tokens
+
+        return {
+            "prompt_tokens": prompt_tokens,
+            "completion_tokens": completion_tokens,
+            "total_tokens": total_tokens
+        }
+
     def _stream_generate_transformers(self, input_text: str, max_new_tokens: int,
                                      temperature: float, top_p: float, tool_call_tags: Optional[str] = None) -> Iterator[GenerateResponse]:
         """Stream response using transformers (simulated, original implementation) with tool tag rewriting support"""

{abstractcore-2.4.3 → abstractcore-2.4.4}/abstractcore/utils/version.py

@@ -11,4 +11,4 @@ including when the package is installed from PyPI where pyproject.toml is not av
 
 # Package version - update this when releasing new versions
 # This must be manually synchronized with the version in pyproject.toml
-__version__ = "2.4.3"
+__version__ = "2.4.4"

{abstractcore-2.4.3 → abstractcore-2.4.4}/abstractcore.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstractcore
-Version: 2.4.3
+Version: 2.4.4
 Summary: Unified interface to all LLM providers with essential infrastructure for tool calling, streaming, and model management
 Author-email: Laurent-Philippe Albou <contact@abstractcore.ai>
 Maintainer-email: Laurent-Philippe Albou <contact@abstractcore.ai>