casual-llm 0.3.0__tar.gz → 0.4.1__tar.gz

{casual_llm-0.3.0/src/casual_llm.egg-info → casual_llm-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: casual-llm
-Version: 0.3.0
+Version: 0.4.1
 Summary: Lightweight LLM provider abstraction with standardized message models
 Author-email: Alex Stansfield <alex@casualgenius.com>
 License: MIT
@@ -26,6 +26,8 @@ Requires-Dist: ollama>=0.6.1
 Requires-Dist: httpx[http2]>=0.28.1
 Provides-Extra: openai
 Requires-Dist: openai>=1.0.0; extra == "openai"
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.20.0; extra == "anthropic"
 Dynamic: license-file
 
 # casual-llm

{casual_llm-0.3.0 → casual_llm-0.4.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "casual-llm"
-version = "0.3.0"
+version = "0.4.1"
 description = "Lightweight LLM provider abstraction with standardized message models"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -29,6 +29,7 @@ dependencies = [
 
 [project.optional-dependencies]
 openai = ["openai>=1.0.0"]
+anthropic = ["anthropic>=0.20.0"]
 
 [project.urls]
 Homepage = "https://github.com/casualgenius/casual-llm"
@@ -64,7 +65,6 @@ strict = true
 warn_return_any = true
 warn_unused_configs = true
 
-
 [dependency-groups]
 dev = [
     "openai>=2.8.1",
@@ -74,4 +74,4 @@ dev = [
     "black>=23.0.0",
     "ruff>=0.1.0",
     "mypy>=1.0.0",
-]
+]

{casual_llm-0.3.0 → casual_llm-0.4.1}/src/casual_llm/__init__.py

@@ -7,7 +7,7 @@ A simple, protocol-based library for working with different LLM providers
 Part of the casual-* ecosystem of lightweight AI tools.
 """
 
-__version__ = "0.3.0"
+__version__ = "0.4.1"
 
 # Model configuration
 from casual_llm.config import ModelConfig, Provider
@@ -17,6 +17,7 @@ from casual_llm.providers import (
     LLMProvider,
     OllamaProvider,
     OpenAIProvider,
+    AnthropicProvider,
     create_provider,
 )
 
@@ -47,14 +48,19 @@ from casual_llm.tool_converters import (
     tools_to_ollama,
     tool_to_openai,
     tools_to_openai,
+    tool_to_anthropic,
+    tools_to_anthropic,
 )
 
 # Message converters
 from casual_llm.message_converters import (
     convert_messages_to_openai,
     convert_messages_to_ollama,
+    convert_messages_to_anthropic,
     convert_tool_calls_from_openai,
     convert_tool_calls_from_ollama,
+    convert_tool_calls_from_anthropic,
+    extract_system_message,
 )
 
 __all__ = [
@@ -66,6 +72,7 @@ __all__ = [
     "Provider",
     "OllamaProvider",
     "OpenAIProvider",
+    "AnthropicProvider",
     "create_provider",
     # Messages
     "ChatMessage",
@@ -84,13 +91,19 @@ __all__ = [
     "ToolParameter",
     # Usage
     "Usage",
+    # Tool converters
     "tool_to_ollama",
     "tools_to_ollama",
     "tool_to_openai",
     "tools_to_openai",
+    "tool_to_anthropic",
+    "tools_to_anthropic",
     # Message converters
     "convert_messages_to_openai",
     "convert_messages_to_ollama",
+    "convert_messages_to_anthropic",
     "convert_tool_calls_from_openai",
     "convert_tool_calls_from_ollama",
+    "convert_tool_calls_from_anthropic",
+    "extract_system_message",
 ]

{casual_llm-0.3.0 → casual_llm-0.4.1}/src/casual_llm/config.py

@@ -14,6 +14,7 @@ class Provider(Enum):
 
     OPENAI = "openai"
     OLLAMA = "ollama"
+    ANTHROPIC = "anthropic"
 
 
 @dataclass

{casual_llm-0.3.0 → casual_llm-0.4.1}/src/casual_llm/message_converters/__init__.py

@@ -2,7 +2,7 @@
 Message converters for different LLM provider formats.
 
 This package provides converters to translate between casual-llm's unified
-ChatMessage format and provider-specific formats (OpenAI, Ollama).
+ChatMessage format and provider-specific formats (OpenAI, Ollama, Anthropic).
 """
 
 from casual_llm.message_converters.openai import (
@@ -13,10 +13,18 @@ from casual_llm.message_converters.ollama import (
     convert_messages_to_ollama,
     convert_tool_calls_from_ollama,
 )
+from casual_llm.message_converters.anthropic import (
+    convert_messages_to_anthropic,
+    convert_tool_calls_from_anthropic,
+    extract_system_message,
+)
 
 __all__ = [
     "convert_messages_to_openai",
     "convert_messages_to_ollama",
+    "convert_messages_to_anthropic",
     "convert_tool_calls_from_openai",
     "convert_tool_calls_from_ollama",
+    "convert_tool_calls_from_anthropic",
+    "extract_system_message",
 ]

casual_llm-0.4.1/src/casual_llm/message_converters/anthropic.py

@@ -0,0 +1,290 @@
+"""
+Anthropic message converters.
+
+Converts casual-llm ChatMessage format to Anthropic API format and vice versa.
+"""
+
+import json
+import logging
+from typing import TYPE_CHECKING, Any
+
+from casual_llm.messages import (
+    ChatMessage,
+    AssistantToolCall,
+    AssistantToolCallFunction,
+    TextContent,
+    ImageContent,
+)
+
+if TYPE_CHECKING:
+    from anthropic.types import ToolUseBlock
+
+logger = logging.getLogger(__name__)
+
+
+def _convert_image_to_anthropic(image: ImageContent) -> dict[str, Any]:
+    """
+    Convert ImageContent to Anthropic image block format.
+
+    Anthropic supports both URL and base64 images directly.
+
+    Args:
+        image: ImageContent with either URL or base64 source
+
+    Returns:
+        Dictionary in Anthropic image block format
+
+    Examples:
+        >>> from casual_llm import ImageContent
+        >>> img = ImageContent(source="https://example.com/image.jpg")
+        >>> block = _convert_image_to_anthropic(img)
+        >>> block["type"]
+        'image'
+    """
+    if isinstance(image.source, str):
+        # URL image - Anthropic supports URLs directly
+        return {
+            "type": "image",
+            "source": {
+                "type": "url",
+                "url": image.source,
+            },
+        }
+    else:
+        # Base64 image
+        base64_data = image.source.get("data", "")
+        media_type = image.media_type or "image/jpeg"
+
+        return {
+            "type": "image",
+            "source": {
+                "type": "base64",
+                "media_type": media_type,
+                "data": base64_data,
+            },
+        }
+
+
+def _convert_user_content_to_anthropic(
+    content: str | list[TextContent | ImageContent] | None,
+) -> list[dict[str, Any]]:
+    """
+    Convert UserMessage content to Anthropic format.
+
+    Handles both simple string content (backward compatible) and
+    multimodal content arrays (text + images).
+
+    Anthropic always uses content blocks (array format), even for simple text.
+
+    Args:
+        content: Message content (string, multimodal array, or None)
+
+    Returns:
+        List of content blocks in Anthropic format
+
+    Examples:
+        >>> content_blocks = _convert_user_content_to_anthropic("Hello")
+        >>> content_blocks[0]["type"]
+        'text'
+    """
+    if content is None:
+        return [{"type": "text", "text": ""}]
+
+    if isinstance(content, str):
+        # Simple string content
+        return [{"type": "text", "text": content}]
+
+    # Multimodal content array
+    content_blocks: list[dict[str, Any]] = []
+
+    for item in content:
+        if isinstance(item, TextContent):
+            content_blocks.append({"type": "text", "text": item.text})
+        elif isinstance(item, ImageContent):
+            content_blocks.append(_convert_image_to_anthropic(item))
+
+    return content_blocks
+
+
+def extract_system_message(messages: list[ChatMessage]) -> str | None:
+    """
+    Extract system message content from the messages list.
+
+    Anthropic requires system messages to be passed as a separate parameter,
+    not as part of the messages array. This function extracts the first
+    system message content for use with the Anthropic API.
+
+    Args:
+        messages: List of ChatMessage objects
+
+    Returns:
+        System message content string, or None if no system message present
+
+    Examples:
+        >>> from casual_llm import SystemMessage, UserMessage
+        >>> messages = [SystemMessage(content="You are helpful"), UserMessage(content="Hello")]
+        >>> extract_system_message(messages)
+        'You are helpful'
+    """
+    for msg in messages:
+        if msg.role == "system":
+            logger.debug("Extracted system message")
+            return msg.content
+    return None
+
+
+def convert_messages_to_anthropic(messages: list[ChatMessage]) -> list[dict[str, Any]]:
+    """
+    Convert casual-llm ChatMessage list to Anthropic format.
+
+    Handles all message types including tool calls and tool results.
+    Note: System messages are excluded - use extract_system_message() to get
+    the system message content for the separate `system` parameter.
+
+    Anthropic format differences:
+    - System messages are NOT included (passed separately)
+    - Tool results go in user messages with "tool_result" content type
+    - Content is always an array of content blocks
+
+    Args:
+        messages: List of ChatMessage objects
+
+    Returns:
+        List of dictionaries in Anthropic MessageParam format
+
+    Examples:
+        >>> from casual_llm import UserMessage, AssistantMessage
+        >>> messages = [UserMessage(content="Hello")]
+        >>> anthropic_msgs = convert_messages_to_anthropic(messages)
+        >>> anthropic_msgs[0]["role"]
+        'user'
+    """
+    if not messages:
+        return []
+
+    logger.debug(f"Converting {len(messages)} messages to Anthropic format")
+
+    anthropic_messages: list[dict[str, Any]] = []
+
+    for msg in messages:
+        match msg.role:
+            case "assistant":
+                # Handle assistant messages with optional tool calls
+                content_blocks: list[dict[str, Any]] = []
+
+                # Add text content if present
+                if msg.content:
+                    content_blocks.append({"type": "text", "text": msg.content})
+
+                # Add tool use blocks if present
+                if msg.tool_calls:
+                    for tool_call in msg.tool_calls:
+                        # Parse arguments JSON string back to dict for Anthropic
+                        try:
+                            input_data = json.loads(tool_call.function.arguments)
+                        except json.JSONDecodeError:
+                            input_data = {}
+                            logger.warning(
+                                f"Failed to parse tool call arguments: {tool_call.function.arguments}"
+                            )
+
+                        content_blocks.append(
+                            {
+                                "type": "tool_use",
+                                "id": tool_call.id,
+                                "name": tool_call.function.name,
+                                "input": input_data,
+                            }
+                        )
+
+                anthropic_messages.append(
+                    {
+                        "role": "assistant",
+                        "content": content_blocks,
+                    }
+                )
+
+            case "system":
+                # System messages are excluded - they are passed separately
+                # via the `system` parameter in the API call
+                logger.debug("Skipping system message (handled separately)")
+                continue
+
+            case "tool":
+                # Tool results go in user messages with tool_result content type
+                anthropic_messages.append(
+                    {
+                        "role": "user",
+                        "content": [
+                            {
+                                "type": "tool_result",
+                                "tool_use_id": msg.tool_call_id,
+                                "content": msg.content,
+                            }
+                        ],
+                    }
+                )
+
+            case "user":
+                # User messages with text and/or image content
+                content_blocks = _convert_user_content_to_anthropic(msg.content)
+                anthropic_messages.append(
+                    {
+                        "role": "user",
+                        "content": content_blocks,
+                    }
+                )
+
+            case _:
+                logger.warning(f"Unknown message role: {msg.role}")
+
+    return anthropic_messages
+
+
+def convert_tool_calls_from_anthropic(
+    response_tool_calls: list["ToolUseBlock"],
+) -> list[AssistantToolCall]:
+    """
+    Convert Anthropic ToolUseBlock to casual-llm format.
+
+    Anthropic returns tool call arguments as a dict in the `input` field,
+    which must be serialized to JSON string for AssistantToolCallFunction.
+
+    Args:
+        response_tool_calls: List of ToolUseBlock from Anthropic response
+
+    Returns:
+        List of AssistantToolCall objects
+
+    Examples:
+        >>> # Assuming response has tool_use blocks
+        >>> # tool_calls = convert_tool_calls_from_anthropic(tool_use_blocks)
+        >>> # assert len(tool_calls) > 0
+        pass
+    """
+    tool_calls = []
+
+    for tool in response_tool_calls:
+        logger.debug(f"Converting tool call: {tool.name}")
+
+        # Serialize input dict to JSON string for casual-llm format
+        arguments = json.dumps(tool.input) if tool.input else "{}"
+
+        tool_call = AssistantToolCall(
+            id=tool.id,
+            type="function",
+            function=AssistantToolCallFunction(name=tool.name, arguments=arguments),
+        )
+        tool_calls.append(tool_call)
+
+    logger.debug(f"Converted {len(tool_calls)} tool calls")
+    return tool_calls
+
+
+__all__ = [
+    "convert_messages_to_anthropic",
+    "extract_system_message",
+    "convert_tool_calls_from_anthropic",
+    "_convert_image_to_anthropic",
+    "_convert_user_content_to_anthropic",
+]

{casual_llm-0.3.0 → casual_llm-0.4.1}/src/casual_llm/providers/__init__.py

@@ -13,6 +13,11 @@ try:
 except ImportError:
     OpenAIProvider = None  # type: ignore
 
+try:
+    from casual_llm.providers.anthropic import AnthropicProvider
+except ImportError:
+    AnthropicProvider = None  # type: ignore
+
 
 def create_provider(
     model_config: ModelConfig,
@@ -26,11 +31,11 @@ def create_provider(
         timeout: HTTP timeout in seconds (default: 60.0)
 
     Returns:
-        Configured LLM provider (OllamaProvider or OpenAIProvider)
+        Configured LLM provider (OllamaProvider, OpenAIProvider, or AnthropicProvider)
 
     Raises:
         ValueError: If provider type is not supported
-        ImportError: If openai package is not installed for OpenAI provider
+        ImportError: If required package is not installed for the provider
 
     Examples:
         >>> from casual_llm import ModelConfig, Provider, create_provider
@@ -72,6 +77,21 @@ def create_provider(
             timeout=timeout,
         )
 
+    elif model_config.provider == Provider.ANTHROPIC:
+        if AnthropicProvider is None:
+            raise ImportError(
+                "Anthropic provider requires the 'anthropic' package. "
+                "Install it with: pip install casual-llm[anthropic]"
+            )
+
+        return AnthropicProvider(
+            model=model_config.name,
+            api_key=model_config.api_key,
+            base_url=model_config.base_url,
+            temperature=model_config.temperature,
+            timeout=timeout,
+        )
+
     else:
         raise ValueError(f"Unsupported provider: {model_config.provider}")
 
@@ -82,5 +102,6 @@ __all__ = [
     "Provider",
     "OllamaProvider",
     "OpenAIProvider",
+    "AnthropicProvider",
     "create_provider",
 ]