abstractcore 2.4.0__tar.gz → 2.4.1__tar.gz

{abstractcore-2.4.0 → abstractcore-2.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstractcore
-Version: 2.4.0
+Version: 2.4.1
 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.1/abstractcore/exceptions/__init__.py

@@ -0,0 +1,125 @@
+"""
+Custom exceptions for AbstractCore.
+"""
+
+
+class AbstractCoreError(Exception):
+    """Base exception for AbstractCore"""
+    pass
+
+
+class ProviderError(AbstractCoreError):
+    """Base exception for provider-related errors"""
+    pass
+
+
+class ProviderAPIError(ProviderError):
+    """API call to provider failed"""
+    pass
+
+
+class AuthenticationError(ProviderError):
+    """Authentication with provider failed"""
+    pass
+
+
+# Alias for backward compatibility with old AbstractCore
+Authentication = AuthenticationError
+
+
+class RateLimitError(ProviderError):
+    """Rate limit exceeded"""
+    pass
+
+
+class InvalidRequestError(ProviderError):
+    """Invalid request to provider"""
+    pass
+
+
+class UnsupportedFeatureError(AbstractCoreError):
+    """Feature not supported by provider"""
+    pass
+
+
+class FileProcessingError(AbstractCoreError):
+    """Error processing file or media"""
+    pass
+
+
+class ToolExecutionError(AbstractCoreError):
+    """Error executing tool"""
+    pass
+
+
+class SessionError(AbstractCoreError):
+    """Error with session management"""
+    pass
+
+
+class ConfigurationError(AbstractCoreError):
+    """Invalid configuration"""
+    pass
+
+
+class ModelNotFoundError(ProviderError):
+    """Model not found or invalid model name"""
+    pass
+
+
+def format_model_error(provider: str, invalid_model: str, available_models: list) -> str:
+    """
+    Format a helpful error message for model not found errors.
+
+    Args:
+        provider: Provider name (e.g., "OpenAI", "Anthropic")
+        invalid_model: The model name that was not found
+        available_models: List of available model names
+
+    Returns:
+        Formatted error message string
+    """
+    message = f"❌ Model '{invalid_model}' not found for {provider} provider.\n"
+
+    if available_models:
+        message += f"\n✅ Available models ({len(available_models)}):\n"
+        for model in available_models[:30]:  # Show max 30
+            message += f"  • {model}\n"
+        if len(available_models) > 30:
+            message += f"  ... and {len(available_models) - 30} more\n"
+    else:
+        # Show provider documentation when we can't fetch models
+        doc_links = {
+            "anthropic": "https://docs.anthropic.com/en/docs/about-claude/models",
+            "openai": "https://platform.openai.com/docs/models",
+            "ollama": "https://ollama.com/library",
+            "huggingface": "https://huggingface.co/models",
+            "mlx": "https://huggingface.co/mlx-community"
+        }
+
+        provider_lower = provider.lower()
+        if provider_lower in doc_links:
+            message += f"\n📚 See available models: {doc_links[provider_lower]}\n"
+        else:
+            message += f"\n⚠️  Could not fetch available models for {provider}.\n"
+
+    return message.rstrip()
+
+
+# Export all exceptions for easy importing
+__all__ = [
+    'AbstractCoreError',
+    'ProviderError', 
+    'ProviderAPIError',
+    'AuthenticationError',
+    'Authentication',  # Backward compatibility alias
+    'RateLimitError',
+    'InvalidRequestError',
+    'UnsupportedFeatureError',
+    'FileProcessingError',
+    'ToolExecutionError',
+    'SessionError',
+    'ConfigurationError',
+    'ModelNotFoundError',
+    'format_model_error'
+]

abstractcore-2.4.1/abstractcore/media/__init__.py

@@ -0,0 +1,151 @@
+"""
+Media handling for different providers.
+"""
+
+import base64
+from pathlib import Path
+from typing import Union, Dict, Any, Optional
+from enum import Enum
+
+
+class MediaType(Enum):
+    """Supported media types"""
+    IMAGE = "image"
+    AUDIO = "audio"
+    VIDEO = "video"
+    DOCUMENT = "document"
+
+
+class MediaHandler:
+    """Base class for media handling"""
+
+    @staticmethod
+    def encode_image(image_path: Union[str, Path]) -> str:
+        """
+        Encode an image file to base64.
+
+        Args:
+            image_path: Path to the image file
+
+        Returns:
+            Base64 encoded string
+        """
+        with open(image_path, "rb") as image_file:
+            return base64.b64encode(image_file.read()).decode('utf-8')
+
+    @staticmethod
+    def format_for_openai(image_path: Union[str, Path]) -> Dict[str, Any]:
+        """
+        Format image for OpenAI API.
+
+        Args:
+            image_path: Path to the image
+
+        Returns:
+            Formatted content for OpenAI
+        """
+        base64_image = MediaHandler.encode_image(image_path)
+        return {
+            "type": "image_url",
+            "image_url": {
+                "url": f"data:image/jpeg;base64,{base64_image}"
+            }
+        }
+
+    @staticmethod
+    def format_for_anthropic(image_path: Union[str, Path]) -> Dict[str, Any]:
+        """
+        Format image for Anthropic API.
+
+        Args:
+            image_path: Path to the image
+
+        Returns:
+            Formatted content for Anthropic
+        """
+        base64_image = MediaHandler.encode_image(image_path)
+
+        # Detect image type
+        path = Path(image_path)
+        media_type = "image/jpeg"
+        if path.suffix.lower() == ".png":
+            media_type = "image/png"
+        elif path.suffix.lower() == ".gif":
+            media_type = "image/gif"
+        elif path.suffix.lower() == ".webp":
+            media_type = "image/webp"
+
+        return {
+            "type": "image",
+            "source": {
+                "type": "base64",
+                "media_type": media_type,
+                "data": base64_image
+            }
+        }
+
+    @staticmethod
+    def format_for_provider(image_path: Union[str, Path], provider: str) -> Optional[Dict[str, Any]]:
+        """
+        Format media for a specific provider.
+
+        Args:
+            image_path: Path to the media file
+            provider: Provider name
+
+        Returns:
+            Formatted content or None if not supported
+        """
+        provider_lower = provider.lower()
+
+        if provider_lower == "openai":
+            return MediaHandler.format_for_openai(image_path)
+        elif provider_lower == "anthropic":
+            return MediaHandler.format_for_anthropic(image_path)
+        else:
+            # Local providers typically don't support images directly
+            return None
+
+    @staticmethod
+    def is_image_file(path: Union[str, Path]) -> bool:
+        """
+        Check if a file is an image.
+
+        Args:
+            path: Path to check
+
+        Returns:
+            True if the file is an image
+        """
+        image_extensions = {'.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp', '.ico', '.tiff'}
+        return Path(path).suffix.lower() in image_extensions
+
+    @staticmethod
+    def get_media_type(path: Union[str, Path]) -> MediaType:
+        """
+        Determine the media type of a file.
+
+        Args:
+            path: Path to the file
+
+        Returns:
+            MediaType enum value
+        """
+        path = Path(path)
+        extension = path.suffix.lower()
+
+        image_extensions = {'.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp'}
+        audio_extensions = {'.mp3', '.wav', '.m4a', '.ogg', '.flac'}
+        video_extensions = {'.mp4', '.avi', '.mov', '.mkv', '.webm'}
+        document_extensions = {'.pdf', '.doc', '.docx', '.txt', '.md'}
+
+        if extension in image_extensions:
+            return MediaType.IMAGE
+        elif extension in audio_extensions:
+            return MediaType.AUDIO
+        elif extension in video_extensions:
+            return MediaType.VIDEO
+        elif extension in document_extensions:
+            return MediaType.DOCUMENT
+        else:
+            return MediaType.DOCUMENT  # Default to document

{abstractcore-2.4.0 → abstractcore-2.4.1}/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.0"
+__version__ = "2.4.1"

{abstractcore-2.4.0 → abstractcore-2.4.1}/abstractcore.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstractcore
-Version: 2.4.0
+Version: 2.4.1
 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.0 → abstractcore-2.4.1}/abstractcore.egg-info/SOURCES.txt

@@ -30,6 +30,8 @@ abstractcore/embeddings/__init__.py
 abstractcore/embeddings/manager.py
 abstractcore/embeddings/models.py
 abstractcore/events/__init__.py
+abstractcore/exceptions/__init__.py
+abstractcore/media/__init__.py
 abstractcore/processing/__init__.py
 abstractcore/processing/basic_extractor.py
 abstractcore/processing/basic_judge.py

{abstractcore-2.4.0 → abstractcore-2.4.1}/pyproject.toml

@@ -174,7 +174,7 @@ full-dev = [
 
 
 [tool.setuptools]
-packages = ["abstractcore", "abstractcore.core", "abstractcore.providers", "abstractcore.tools", "abstractcore.structured", "abstractcore.events", "abstractcore.embeddings", "abstractcore.architectures", "abstractcore.utils", "abstractcore.assets", "abstractcore.server", "abstractcore.apps", "abstractcore.processing"]
+packages = ["abstractcore", "abstractcore.core", "abstractcore.providers", "abstractcore.tools", "abstractcore.structured", "abstractcore.events", "abstractcore.embeddings", "abstractcore.architectures", "abstractcore.utils", "abstractcore.assets", "abstractcore.server", "abstractcore.apps", "abstractcore.processing", "abstractcore.exceptions", "abstractcore.media"]
 
 [tool.setuptools.dynamic]
 version = {attr = "abstractcore.utils.version.__version__"}

{abstractcore-2.4.0 → abstractcore-2.4.1}/tests/test_agentic_cli_compatibility.py

@@ -19,8 +19,8 @@ import os
 from typing import Dict, Any, List
 
 
-# Test configuration  
-BASE_URL = "http://localhost:8000"
+# Test configuration
+BASE_URL = "http://localhost:8003"
 TEST_MODEL = "ollama/qwen3-coder:30b"
 
 
@@ -29,7 +29,7 @@ def server():
     """Start the AbstractCore server for testing, stop after tests complete."""
     # Check if server is already running
     try:
-        response = httpx.get(f"{BASE_URL}/v1/models", timeout=2)
+        response = httpx.get(f"{BASE_URL}/health", timeout=2)
         if response.status_code == 200:
             # Server already running, use it
             yield
@@ -40,32 +40,26 @@ def server():
     # Start server in background
     env = os.environ.copy()
     env["ABSTRACTCORE_DEBUG"] = "true"
-    env["ABSTRACTCORE_TEST_MODE"] = "true"  # Only use mock provider for fast startup
 
     process = subprocess.Popen(
         ["python", "-m", "uvicorn", "abstractcore.server.app:app",
-         "--host", "0.0.0.0", "--port", "8000"],
+         "--host", "0.0.0.0", "--port", "8003"],
         env=env,
         stdout=subprocess.PIPE,
         stderr=subprocess.PIPE
     )
 
-    # Wait for server to start (max 15 seconds - using mock provider only for fast startup)
-    for i in range(15):
+    # Wait for server to start (max 10 seconds)
+    for _ in range(20):
         try:
-            response = httpx.get(f"{BASE_URL}/v1/models", timeout=2)
+            response = httpx.get(f"{BASE_URL}/health", timeout=2)
             if response.status_code == 200:
-                print(f"Server started successfully after {i} seconds")
                 break
         except (httpx.ConnectError, httpx.TimeoutException):
-            time.sleep(1)
+            time.sleep(0.5)
     else:
-        # Get process output for debugging
-        stdout, stderr = process.communicate()
         process.kill()
-        print(f"Server stdout: {stdout.decode()[:500]}")
-        print(f"Server stderr: {stderr.decode()[:500]}")
-        pytest.fail("Server failed to start within 15 seconds")
+        pytest.fail("Server failed to start within 10 seconds")
 
     yield
 

{abstractcore-2.4.0 → abstractcore-2.4.1}/tests/test_basic_summarizer.py

@@ -166,23 +166,13 @@ class TestBasicSummarizer:
         # Good focus alignment expected with specific technical focus
         assert result.focus_alignment > 0.6, f"Poor technical focus alignment: {result.focus_alignment}"
 
-        # Should contain technical terminology - use broader range of technical terms
+        # Should contain technical terminology
         summary_lower = result.summary.lower()
-        technical_terms = [
-            # Original terms
-            "architecture", "implementation", "interface", "provider", "system",
-            # Additional technical terms that are commonly used
-            "library", "framework", "integration", "api", "module", "component",
-            "configuration", "deployment", "workflow", "session", "metadata",
-            "streaming", "processing", "handling", "management", "functionality",
-            "development", "application", "platform", "infrastructure", "protocol",
-            "structured", "format", "output", "input", "batch", "pipeline"
-        ]
+        technical_terms = ["architecture", "implementation", "interface", "provider", "system"]
         found_terms = [term for term in technical_terms if term in summary_lower]
 
         print(f"- Technical terms found: {found_terms}")
-        # Require at least 2 technical terms from the expanded list
-        assert len(found_terms) >= 2, f"Analytical summary lacks technical depth. Found terms: {found_terms}. Summary may not be technical enough for 'architecture and technical implementation details' focus."
+        assert len(found_terms) >= 2, f"Analytical summary lacks technical depth: {found_terms}"
 
     def test_comprehensive_length(self, summarizer, readme_content):
         """Test comprehensive length produces detailed output"""

{abstractcore-2.4.0 → abstractcore-2.4.1}/tests/test_critical_streaming_tool_fix.py

@@ -218,15 +218,28 @@ class TestStreamingPerformance:
 
 
 # ============================================================================
-# TOOL DETECTION VALIDATION
+# TOOL EXECUTION VALIDATION
 # ============================================================================
 
-class TestToolDetection:
-    """Validate that tools are detected correctly (execution is handled elsewhere)"""
+class TestToolExecution:
+    """Validate that tools are detected and executed correctly"""
 
-    def test_tool_detection_qwen_format(self):
-        """Test tool detection with qwen/qwen3-next-80b format (<function_call>)"""
-        processor = UnifiedStreamProcessor("qwen3-next-80b", execute_tools=False)
+    def test_tool_execution_qwen_format(self):
+        """Test tool execution with qwen/qwen3-next-80b format (<function_call>)"""
+        def read_file(path: str) -> str:
+            """Mock file reading for test"""
+            if path == "README.md":
+                return "# AbstractCore\n\nThis is a test file."
+            return f"File not found: {path}"
+
+        # Register tool
+        from abstractcore.tools.registry import register_tool, clear_registry
+        register_tool(read_file)
+
+        tool_def = ToolDefinition.from_function(read_file).to_dict()
+        tool_def['function'] = read_file
+
+        processor = UnifiedStreamProcessor("qwen3-next-80b", execute_tools=True)
 
         chunks = [
             "I'll read that file for you. ",
@@ -237,35 +250,45 @@ class TestToolDetection:
         ]
 
         stream = (GenerateResponse(content=c, model="test") for c in chunks)
-        results = list(processor.process_stream(stream))
-
-        # Separate content and tool calls
-        content_results = [r for r in results if r.content]
-        tool_results = [r for r in results if r.tool_calls]
+        results = list(processor.process_stream(stream, [tool_def]))
 
-        all_content = " ".join([r.content for r in content_results])
+        # Should have tool execution results
+        all_content = " ".join([r.content for r in results if r.content])
 
-        # Tool should be detected
-        assert len(tool_results) > 0, "Tool should be detected"
-        
-        all_tools = []
-        for result in tool_results:
-            all_tools.extend(result.tool_calls)
-        assert len(all_tools) == 1, f"Expected 1 tool, got {len(all_tools)}"
-        assert all_tools[0].name == "read_file"
-        assert all_tools[0].arguments == {"path": "README.md"}
+        # Tool should be executed
+        assert "Tool Results:" in all_content or "read_file" in all_content
 
         # Original content should be preserved
         assert "I'll read that file for you." in all_content
-        assert "As you can see from the file..." in all_content
 
         # NO tool tags should leak
         assert "<function_call>" not in all_content
         assert "</function_call>" not in all_content
 
-    def test_multiple_sequential_tools_detection(self):
-        """Test multiple tools are detected correctly in sequence (tools are not executed, just detected)"""
-        processor = UnifiedStreamProcessor("qwen3", execute_tools=False)  # Note: execute_tools is ignored anyway
+        # Cleanup
+        clear_registry()
+
+    def test_multiple_sequential_tools_execution(self):
+        """Test multiple tools execute correctly in sequence"""
+        def tool1(value: int) -> int:
+            return value + 10
+
+        def tool2(value: int) -> int:
+            return value * 2
+
+        # Register tools
+        from abstractcore.tools.registry import register_tool, clear_registry
+        register_tool(tool1)
+        register_tool(tool2)
+
+        tools = [
+            ToolDefinition.from_function(tool1).to_dict(),
+            ToolDefinition.from_function(tool2).to_dict()
+        ]
+        tools[0]['function'] = tool1
+        tools[1]['function'] = tool2
+
+        processor = UnifiedStreamProcessor("qwen3", execute_tools=True)
 
         chunks = [
             "First calculation: ",
@@ -280,36 +303,20 @@ class TestToolDetection:
         ]
 
         stream = (GenerateResponse(content=c, model="test") for c in chunks)
-        results = list(processor.process_stream(stream))
+        results = list(processor.process_stream(stream, tools))
 
-        # Separate content and tool calls
-        content_results = [r for r in results if r.content]
-        tool_results = [r for r in results if r.tool_calls]
+        all_content = " ".join([r.content for r in results if r.content])
 
-        all_content = " ".join([r.content for r in content_results])
+        # Both tools should be executed
+        assert "tool1" in all_content
+        assert "tool2" in all_content
 
-        # Tools should be detected and yielded separately
-        assert len(tool_results) > 0, "Tools should be detected and yielded"
-        
-        # Extract all detected tool calls
-        all_tools = []
-        for result in tool_results:
-            all_tools.extend(result.tool_calls)
-        
-        assert len(all_tools) == 2, f"Expected 2 tools, got {len(all_tools)}"
-        
-        tool_names = [tool.name for tool in all_tools]
-        assert "tool1" in tool_names
-        assert "tool2" in tool_names
-
-        # No tool tags should leak to user content
+        # No tool tags should leak
         assert "<|tool_call|>" not in all_content
         assert "</|tool_call|>" not in all_content
-        
-        # User should see clean content
-        assert "First calculation:" in all_content
-        assert "Second calculation:" in all_content
-        assert "Done." in all_content
+
+        # Cleanup
+        clear_registry()
 
     def test_tool_results_appear_with_proper_formatting(self):
         """Verify tool results appear with proper formatting"""
@@ -631,11 +638,21 @@ class TestProductionReadiness:
     def test_fix_solves_original_issue(self):
         """
         Validate that the original issue is solved:
-        - Tools are being detected properly
-        - Tool tags are NOT appearing in user output  
-        - Content streams properly without buffering
+        - Tools were being detected but not executed
+        - Tool tags were appearing in user output
+        - Content was being buffered incorrectly
         """
-        processor = UnifiedStreamProcessor("qwen3", execute_tools=False)
+        def test_tool(x: int) -> int:
+            return x * 2
+
+        # Register tool
+        from abstractcore.tools.registry import register_tool, clear_registry
+        register_tool(test_tool)
+
+        tool_def = ToolDefinition.from_function(test_tool).to_dict()
+        tool_def['function'] = test_tool
+
+        processor = UnifiedStreamProcessor("qwen3", execute_tools=True)
 
         chunks = [
             "Let me calculate: ",
@@ -646,22 +663,13 @@ class TestProductionReadiness:
         ]
 
         stream = (GenerateResponse(content=c, model="test") for c in chunks)
-        results = list(processor.process_stream(stream))
-
-        # Separate content and tool calls
-        content_results = [r for r in results if r.content]
-        tool_results = [r for r in results if r.tool_calls]
+        results = list(processor.process_stream(stream, [tool_def]))
 
-        all_content = " ".join([r.content for r in content_results])
+        all_content = " ".join([r.content for r in results if r.content])
 
-        # 1. Tool SHOULD be detected (original issue: detection problems)
-        assert len(tool_results) > 0, "CRITICAL: Tool detection still broken!"
-        
-        all_tools = []
-        for result in tool_results:
-            all_tools.extend(result.tool_calls)
-        assert len(all_tools) == 1, f"Expected 1 tool, got {len(all_tools)}"
-        assert all_tools[0].name == "test_tool", f"Expected test_tool, got {all_tools[0].name}"
+        # 1. Tool SHOULD be executed (original issue: wasn't executing)
+        assert "Tool Results:" in all_content or "test_tool" in all_content, \
+            "CRITICAL: Tool execution still broken!"
 
         # 2. Tool tags SHOULD NOT appear in output (original issue: were appearing)
         assert "<|tool_call|>" not in all_content, \
@@ -670,10 +678,11 @@ class TestProductionReadiness:
             "CRITICAL: Tool tags still leaking to output!"
 
         # 3. Content SHOULD stream properly (original issue: was buffered)
-        assert "Let me calculate:" in all_content, \
+        assert "Let me calculate:" in all_content or any("Let me calculate:" in r.content for r in results if r.content), \
             "CRITICAL: Content not streaming correctly!"
-        assert "Result ready." in all_content, \
-            "CRITICAL: Content after tools not streaming correctly!"
+
+        # Cleanup
+        clear_registry()
 
     def test_backward_compatibility(self):
         """Ensure fix doesn't break existing functionality"""