abstractcore 2.4.3__py3-none-any.whl → 2.4.5__py3-none-any.whl

abstractcore/media/utils/image_scaler.py

@@ -0,0 +1,306 @@
+"""
+Image scaling utility for AbstractCore media handling.
+
+Provides intelligent image scaling based on model-specific requirements
+and capabilities for vision models.
+"""
+
+from typing import Tuple, Optional, Union, Dict, Any
+from enum import Enum
+from pathlib import Path
+import logging
+
+try:
+    from PIL import Image, ImageOps
+    PIL_AVAILABLE = True
+except ImportError:
+    PIL_AVAILABLE = False
+
+from ..base import MediaProcessingError
+
+
+class ScalingMode(Enum):
+    """Image scaling modes."""
+    FIT = "fit"          # Scale to fit within target size, maintaining aspect ratio
+    FILL = "fill"        # Scale to fill target size, may crop, maintaining aspect ratio
+    STRETCH = "stretch"  # Stretch to exact target size, may distort aspect ratio
+    PAD = "pad"          # Scale to fit and pad with background to exact target size
+    CROP_CENTER = "crop_center"  # Scale to fill and crop from center
+
+
+class ModelOptimizedScaler:
+    """
+    Intelligent image scaler that optimizes images for specific vision models.
+
+    Uses model capability information to determine optimal scaling strategies.
+    """
+
+    def __init__(self):
+        self.logger = logging.getLogger(__name__)
+
+        if not PIL_AVAILABLE:
+            raise MediaProcessingError("PIL (Pillow) is required for image scaling")
+
+    def get_optimal_resolution(self, model_name: str, original_size: Tuple[int, int],
+                             model_capabilities: Optional[Dict[str, Any]] = None) -> Tuple[int, int]:
+        """
+        Get optimal resolution for a specific model.
+
+        Args:
+            model_name: Name of the model
+            original_size: Original image size (width, height)
+            model_capabilities: Model capability information
+
+        Returns:
+            Optimal target size (width, height)
+        """
+        if model_capabilities is None:
+            model_capabilities = self._get_model_capabilities(model_name)
+
+        max_resolution = model_capabilities.get("max_image_resolution", "variable")
+        image_patch_size = model_capabilities.get("image_patch_size", 16)
+        adaptive_windowing = model_capabilities.get("adaptive_windowing", False)
+
+        # Handle different resolution strategies
+        if max_resolution == "variable":
+            return self._optimize_variable_resolution(original_size, image_patch_size)
+        elif max_resolution == "896x896":
+            return (896, 896)
+        elif max_resolution == "3584x3584":
+            return self._optimize_large_resolution(original_size, (3584, 3584), image_patch_size)
+        elif "x" in str(max_resolution):
+            # Parse specific resolution like "1568x1568"
+            w, h = map(int, str(max_resolution).split("x"))
+            return (w, h)
+        else:
+            # Default fallback
+            return self._optimize_variable_resolution(original_size, image_patch_size)
+
+    def _optimize_variable_resolution(self, original_size: Tuple[int, int],
+                                    patch_size: int = 16) -> Tuple[int, int]:
+        """Optimize for variable resolution models like Qwen3-VL."""
+        width, height = original_size
+
+        # For variable resolution, aim for reasonable size that's efficient
+        # while maintaining good quality
+        max_dimension = 1024  # Good balance for most use cases
+
+        # Scale down if too large
+        if max(width, height) > max_dimension:
+            if width > height:
+                new_width = max_dimension
+                new_height = int(height * (max_dimension / width))
+            else:
+                new_height = max_dimension
+                new_width = int(width * (max_dimension / height))
+        else:
+            new_width, new_height = width, height
+
+        # Round to nearest patch size multiple for efficiency
+        new_width = ((new_width + patch_size - 1) // patch_size) * patch_size
+        new_height = ((new_height + patch_size - 1) // patch_size) * patch_size
+
+        return (new_width, new_height)
+
+    def _optimize_large_resolution(self, original_size: Tuple[int, int],
+                                 max_size: Tuple[int, int],
+                                 patch_size: int = 14) -> Tuple[int, int]:
+        """Optimize for large resolution models like Qwen2.5-VL."""
+        width, height = original_size
+        max_width, max_height = max_size
+
+        # Scale to fit within max size while maintaining aspect ratio
+        scale = min(max_width / width, max_height / height)
+
+        if scale < 1:  # Only scale down, never up
+            new_width = int(width * scale)
+            new_height = int(height * scale)
+        else:
+            new_width, new_height = width, height
+
+        # Round to nearest patch size multiple
+        new_width = ((new_width + patch_size - 1) // patch_size) * patch_size
+        new_height = ((new_height + patch_size - 1) // patch_size) * patch_size
+
+        return (new_width, new_height)
+
+    def scale_image(self, image: Image.Image, target_size: Tuple[int, int],
+                   mode: ScalingMode = ScalingMode.FIT,
+                   background_color: Tuple[int, int, int] = (255, 255, 255)) -> Image.Image:
+        """
+        Scale image to target size using specified mode.
+
+        Args:
+            image: PIL Image to scale
+            target_size: Target size (width, height)
+            mode: Scaling mode
+            background_color: Background color for padding (RGB)
+
+        Returns:
+            Scaled PIL Image
+        """
+        target_width, target_height = target_size
+
+        if mode == ScalingMode.FIT:
+            # Scale to fit within target size, maintaining aspect ratio
+            image.thumbnail((target_width, target_height), Image.Resampling.LANCZOS)
+            return image
+
+        elif mode == ScalingMode.FILL:
+            # Scale to fill target size, may crop
+            return ImageOps.fit(image, target_size, Image.Resampling.LANCZOS)
+
+        elif mode == ScalingMode.STRETCH:
+            # Stretch to exact target size
+            return image.resize(target_size, Image.Resampling.LANCZOS)
+
+        elif mode == ScalingMode.PAD:
+            # Scale to fit and pad to exact size
+            image.thumbnail((target_width, target_height), Image.Resampling.LANCZOS)
+
+            # Create new image with background color
+            new_image = Image.new('RGB', target_size, background_color)
+
+            # Paste scaled image centered
+            paste_x = (target_width - image.width) // 2
+            paste_y = (target_height - image.height) // 2
+            new_image.paste(image, (paste_x, paste_y))
+
+            return new_image
+
+        elif mode == ScalingMode.CROP_CENTER:
+            # Scale to fill and crop from center
+            return ImageOps.fit(image, target_size, Image.Resampling.LANCZOS, centering=(0.5, 0.5))
+
+        else:
+            raise MediaProcessingError(f"Unknown scaling mode: {mode}")
+
+    def scale_for_model(self, image: Image.Image, model_name: str,
+                       scaling_mode: ScalingMode = ScalingMode.FIT,
+                       model_capabilities: Optional[Dict[str, Any]] = None) -> Image.Image:
+        """
+        Scale image optimally for a specific model.
+
+        Args:
+            image: PIL Image to scale
+            model_name: Name of the target model
+            scaling_mode: How to scale the image
+            model_capabilities: Model capability information
+
+        Returns:
+            Optimally scaled PIL Image for the model
+        """
+        original_size = image.size
+        target_size = self.get_optimal_resolution(model_name, original_size, model_capabilities)
+
+        self.logger.debug(f"Scaling image for {model_name}: {original_size} -> {target_size}")
+
+        # For fixed resolution models, always use PAD mode to maintain exact size
+        if model_capabilities and model_capabilities.get("max_image_resolution") == "896x896":
+            scaling_mode = ScalingMode.PAD
+
+        return self.scale_image(image, target_size, scaling_mode)
+
+    def _get_model_capabilities(self, model_name: str) -> Dict[str, Any]:
+        """
+        Get model capabilities from the capabilities JSON.
+
+        Args:
+            model_name: Name of the model
+
+        Returns:
+            Model capabilities dictionary
+        """
+        try:
+            from ..capabilities import get_media_capabilities
+            return get_media_capabilities(model_name).__dict__
+        except ImportError:
+            # Fallback capability detection
+            return self._fallback_model_capabilities(model_name)
+
+    def _fallback_model_capabilities(self, model_name: str) -> Dict[str, Any]:
+        """Fallback capability detection when capabilities module not available."""
+        model_lower = model_name.lower()
+
+        # Gemma models - fixed 896x896
+        if any(gem in model_lower for gem in ["gemma3", "gemma-3n"]):
+            return {
+                "max_image_resolution": "896x896",
+                "image_patch_size": 16,
+                "adaptive_windowing": True
+            }
+
+        # Qwen2.5-VL models - up to 3584x3584
+        elif "qwen2.5" in model_lower and "vl" in model_lower:
+            return {
+                "max_image_resolution": "3584x3584",
+                "image_patch_size": 14,
+                "pixel_grouping": "28x28"
+            }
+
+        # Qwen3-VL models - variable resolution
+        elif "qwen3" in model_lower and "vl" in model_lower:
+            return {
+                "max_image_resolution": "variable",
+                "image_patch_size": 16,
+                "pixel_grouping": "32x32"
+            }
+
+        # Claude models - up to 1568x1568
+        elif "claude" in model_lower:
+            return {
+                "max_image_resolution": "1568x1568",
+                "image_patch_size": 14
+            }
+
+        # Default fallback
+        else:
+            return {
+                "max_image_resolution": "variable",
+                "image_patch_size": 16
+            }
+
+
+# Convenience functions for easy usage
+_scaler_instance = None
+
+def get_scaler() -> ModelOptimizedScaler:
+    """Get shared scaler instance."""
+    global _scaler_instance
+    if _scaler_instance is None:
+        _scaler_instance = ModelOptimizedScaler()
+    return _scaler_instance
+
+def scale_image_for_model(image: Union[Image.Image, str, Path],
+                         model_name: str,
+                         scaling_mode: ScalingMode = ScalingMode.FIT) -> Image.Image:
+    """
+    Convenience function to scale an image for a specific model.
+
+    Args:
+        image: PIL Image, or path to image file
+        model_name: Name of the target model
+        scaling_mode: How to scale the image
+
+    Returns:
+        Optimally scaled PIL Image
+    """
+    if isinstance(image, (str, Path)):
+        image = Image.open(image)
+
+    scaler = get_scaler()
+    return scaler.scale_for_model(image, model_name, scaling_mode)
+
+def get_optimal_size_for_model(model_name: str, original_size: Tuple[int, int]) -> Tuple[int, int]:
+    """
+    Get optimal image size for a specific model.
+
+    Args:
+        model_name: Name of the target model
+        original_size: Original image size (width, height)
+
+    Returns:
+        Optimal target size (width, height)
+    """
+    scaler = get_scaler()
+    return scaler.get_optimal_resolution(model_name, original_size)

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/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/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.5"

{abstractcore-2.4.3.dist-info → abstractcore-2.4.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstractcore
-Version: 2.4.3
+Version: 2.4.5
 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.dist-info → abstractcore-2.4.5.dist-info}/RECORD

@@ -11,6 +11,9 @@ abstractcore/architectures/enums.py,sha256=9vIv2vDBEKhxwzwH9iaSAyf-iVj3p8y9loMeN
 abstractcore/assets/architecture_formats.json,sha256=CIf6SaR_IJs1D7Uvd1K3zWngIXJ_yq3DM_IE3wnpCHY,16076
 abstractcore/assets/model_capabilities.json,sha256=iUkDiljyZUZzPlpYCOFgStXyc6e7dvOfReYQ0HFrX9Q,49703
 abstractcore/assets/session_schema.json,sha256=b6HTAWxRVlVhAzA7FqaKpunK1yO6jilBOsD5sQkqJTo,10580
+abstractcore/cli/__init__.py,sha256=rUjLjZSK3wENSw4g_iN43Bc2i5cggcEmj4NPXBMohdc,241
+abstractcore/cli/main.py,sha256=QD38nnfrInavO452WbkXCI37SVsdIu9VhvjEOojXBGY,31834
+abstractcore/cli/vision_config.py,sha256=jJzO4zBexh8SqSKp6YKOXdMDSv4AL4Ztl5Xi-5c4KyY,17869
 abstractcore/core/__init__.py,sha256=2h-86U4QkCQ4gzZ4iRusSTMlkODiUS6tKjZHiEXz6rM,684
 abstractcore/core/enums.py,sha256=BhkVnHC-X1_377JDmqd-2mnem9GdBLqixWlYzlP_FJU,695
 abstractcore/core/factory.py,sha256=UdrNwQAvifvFS3LMjF5KO87m-2n1bJBryTs9pvesYcI,2804
@@ -29,14 +32,25 @@ abstractcore/media/base.py,sha256=vWdxscqTGTvd3oc4IzzsBTWhUrznWcqM7M_sFyq6-eE,15
 abstractcore/media/capabilities.py,sha256=qqKvXGkUT-FNnbFS-EYx8KCT9SZOovO2h4N7ucrHgBA,12844
 abstractcore/media/types.py,sha256=jG-g_2_gzl8eOgEalk9x3Ikhni9GoGfoRjkZWaBhV30,10165
 abstractcore/media/vision_fallback.py,sha256=XcEV5T9ekqd4DRBrhJvxgX5j_puxSlofvuUIfQc2vmg,10629
+abstractcore/media/handlers/__init__.py,sha256=HBqFo15JX1q7RM11076iFQUfPvInLlOizX-LGSznLuI,404
+abstractcore/media/handlers/anthropic_handler.py,sha256=iwcHKnHgHoQGpJKlJmwFJWBvrYg9lAzAnndybwsWZRA,12427
+abstractcore/media/handlers/local_handler.py,sha256=xfMV2Ztre3eUkDno4aSGob96oWUlgicZ3VChs-txjXU,23033
+abstractcore/media/handlers/openai_handler.py,sha256=o0H_WQ_NQt133my55xYQmq6_QFGafghF8sPTrqr1f0Q,9726
+abstractcore/media/processors/__init__.py,sha256=tExCZwVhD9Qzn3D99-zQcU-T1324YtiLkWjIfWLC708,442
+abstractcore/media/processors/image_processor.py,sha256=wj-f1W71ZCs4AZdmyTKZvnMee83GkiXKuZ6QvJwd3Lo,22577
+abstractcore/media/processors/office_processor.py,sha256=MqhLDWNtjHEpiMgpFaf7tbj8iDcTCf_zelWrHZkr7Z4,18580
+abstractcore/media/processors/pdf_processor.py,sha256=qniYt7cTYYPVRi_cS1IsXztOldeY0bqdn7sdbELBU9k,17157
+abstractcore/media/processors/text_processor.py,sha256=E28FtT2_jzsvMIDwZi6aVWuu_pSyAPSBa96fe4YYcU8,21092
+abstractcore/media/utils/__init__.py,sha256=30-CTif91iRKOXJ4njGiduWAt-xp31U7NafMBNvgdO0,460
+abstractcore/media/utils/image_scaler.py,sha256=QrYqoNQc8tzGu7I9Sf_E-Iv7ei2oLh714AGiX3yACNM,11338
 abstractcore/processing/__init__.py,sha256=t6hiakQjcZROT4pw9ZFt2q6fF3vf5VpdMKG2EWlsFd8,540
 abstractcore/processing/basic_extractor.py,sha256=3x-3BdIHgLvqLnLF6K1-P4qVaLIpAnNIIutaJi7lDQM,49832
 abstractcore/processing/basic_judge.py,sha256=tKWJrg_tY4vCHzWgXxz0ZjgLXBYYfpMcpG7vl03hJcM,32218
 abstractcore/processing/basic_summarizer.py,sha256=XHNxMQ_8aLStTeUo6_2JaThlct12Htpz7ORmm0iuJsg,25495
 abstractcore/providers/__init__.py,sha256=t8Kp4flH5GvZEC6dx-iYJSPeSxMODa2spXb8MqtlPy4,1282
 abstractcore/providers/anthropic_provider.py,sha256=tcOrARLd1kA4vRkH7MCgy99YIGVaegdCd3-Z8UaKP3Q,20705
-abstractcore/providers/base.py,sha256=kdgHjm_GYKi1Bag1B-hkiJuYO1b4NtnXUF2NVkiDrgA,46645
-abstractcore/providers/huggingface_provider.py,sha256=rM0e2E5KSmoBUmQ_gbAPwZoauqDJ3ls4xYY-qh9VI1w,47462
+abstractcore/providers/base.py,sha256=5YR64kqTYiCvWtIUBul5QfO0XRZr6_Aiho4atpDOh0o,50579
+abstractcore/providers/huggingface_provider.py,sha256=mJGfi1lgsvjV3Lj4q7KCQZhQqw_o23af40i5WLg150o,47789
 abstractcore/providers/lmstudio_provider.py,sha256=oPL_Y4gkJMAniecdWQVaDi7WozCZumSRs0lE7uFgvQk,20406
 abstractcore/providers/mlx_provider.py,sha256=61i5VhpNw_QlhOwPcEcryaGbI45aYyL9q15TrpinIgs,17427
 abstractcore/providers/mock_provider.py,sha256=tIjA57Hlwu3vNODOZShNn0tY9HWvz1p4z-HyD_bsvbo,5741
@@ -63,10 +77,10 @@ abstractcore/utils/message_preprocessor.py,sha256=GdHkm6tmrgjm3PwHRSCjIsq1XLkbhy
 abstractcore/utils/self_fixes.py,sha256=QEDwNTW80iQM4ftfEY3Ghz69F018oKwLM9yeRCYZOvw,5886
 abstractcore/utils/structured_logging.py,sha256=Vm-HviSa42G9DJCWmaEv4a0QG3NMsADD3ictLOs4En0,19952
 abstractcore/utils/token_utils.py,sha256=eLwFmJ68p9WMFD_MHLMmeJRW6Oqx_4hKELB8FNQ2Mnk,21097
-abstractcore/utils/version.py,sha256=gF_Ck5Ba5iARL_Ruybdnb3eKPC8510xyhH3S4uLL5_k,605
-abstractcore-2.4.3.dist-info/licenses/LICENSE,sha256=PI2v_4HMvd6050uDD_4AY_8PzBnu2asa3RKbdDjowTA,1078
-abstractcore-2.4.3.dist-info/METADATA,sha256=Gd1Wqq6wEEsoL3zA2ezoWConAWpeMkh7KLRtcafgwmc,27596
-abstractcore-2.4.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-abstractcore-2.4.3.dist-info/entry_points.txt,sha256=di-rxy4iD6A3j8DmQHeVmXYlncgCJKZGamyjrQXEfcU,357
-abstractcore-2.4.3.dist-info/top_level.txt,sha256=DiNHBI35SIawW3N9Z-z0y6cQYNbXd32pvBkW0RLfScs,13
-abstractcore-2.4.3.dist-info/RECORD,,
+abstractcore/utils/version.py,sha256=WKRMOS_TRIxsNu-vJqfCYHA335-rya9xBBMzhx_S-Z8,605
+abstractcore-2.4.5.dist-info/licenses/LICENSE,sha256=PI2v_4HMvd6050uDD_4AY_8PzBnu2asa3RKbdDjowTA,1078
+abstractcore-2.4.5.dist-info/METADATA,sha256=9w6Q7NZXePxhRYnmloyJ6Nd2DFQ7YY4294OMF-6QYuY,27596
+abstractcore-2.4.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+abstractcore-2.4.5.dist-info/entry_points.txt,sha256=UdVmchBC_Lt3H4Vlkt5js-QDAkVlBbkCu1yCsswk-KE,454
+abstractcore-2.4.5.dist-info/top_level.txt,sha256=DiNHBI35SIawW3N9Z-z0y6cQYNbXd32pvBkW0RLfScs,13
+abstractcore-2.4.5.dist-info/RECORD,,

{abstractcore-2.4.3.dist-info → abstractcore-2.4.5.dist-info}/entry_points.txt

@@ -1,5 +1,7 @@
 [console_scripts]
 abstractcore = abstractcore.cli.main:main
+abstractcore-chat = abstractcore.utils.cli:main
+abstractcore-config = abstractcore.cli.main:main
 abstractcore-extractor = abstractcore.apps.extractor:main
 abstractcore-judge = abstractcore.apps.judge:main
 abstractcore-summarizer = abstractcore.apps.summarizer:main