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

{casual_llm-0.2.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.2.0
+Version: 0.4.1
 Summary: Lightweight LLM provider abstraction with standardized message models
 Author-email: Alex Stansfield <alex@casualgenius.com>
 License: MIT
@@ -23,8 +23,11 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pydantic>=2.0.0
 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.2.0 → casual_llm-0.4.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "casual-llm"
-version = "0.2.0"
+version = "0.4.1"
 description = "Lightweight LLM provider abstraction with standardized message models"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -24,10 +24,12 @@ classifiers = [
 dependencies = [
     "pydantic>=2.0.0",
     "ollama>=0.6.1",
+    "httpx[http2]>=0.28.1",
 ]
 
 [project.optional-dependencies]
 openai = ["openai>=1.0.0"]
+anthropic = ["anthropic>=0.20.0"]
 
 [project.urls]
 Homepage = "https://github.com/casualgenius/casual-llm"
@@ -72,4 +74,4 @@ dev = [
     "black>=23.0.0",
     "ruff>=0.1.0",
     "mypy>=1.0.0",
-]
+]

{casual_llm-0.2.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.2.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,
 )
 
@@ -29,6 +30,10 @@ from casual_llm.messages import (
     ToolResultMessage,
     AssistantToolCall,
     AssistantToolCallFunction,
+    StreamChunk,
+    # Multimodal content types
+    TextContent,
+    ImageContent,
 )
 
 # Tool models
@@ -43,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__ = [
@@ -62,6 +72,7 @@ __all__ = [
     "Provider",
     "OllamaProvider",
     "OpenAIProvider",
+    "AnthropicProvider",
     "create_provider",
     # Messages
     "ChatMessage",
@@ -71,18 +82,28 @@ __all__ = [
     "ToolResultMessage",
     "AssistantToolCall",
     "AssistantToolCallFunction",
+    "StreamChunk",
+    # Multimodal content types
+    "TextContent",
+    "ImageContent",
     # Tools
     "Tool",
     "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.2.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.2.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.2.0 → casual_llm-0.4.1}/src/casual_llm/message_converters/ollama.py

@@ -13,6 +13,12 @@ from casual_llm.messages import (
     ChatMessage,
     AssistantToolCall,
     AssistantToolCallFunction,
+    TextContent,
+    ImageContent,
+)
+from casual_llm.utils.image import (
+    strip_base64_prefix,
+    fetch_image_as_base64,
 )
 
 if TYPE_CHECKING:
@@ -21,23 +27,101 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 
-def convert_messages_to_ollama(messages: list[ChatMessage]) -> list[dict[str, Any]]:
+async def _convert_image_to_ollama(image: ImageContent) -> str:
+    """
+    Convert ImageContent to Ollama base64 format.
+
+    Ollama expects images as raw base64 strings (no data URI prefix).
+
+    For URL sources, this function fetches the image and converts to base64.
+
+    Raises:
+        ImageFetchError: If a URL image cannot be fetched.
+    """
+    if isinstance(image.source, str):
+        # Check if it's a data URI or a URL
+        if image.source.startswith("data:"):
+            # Data URI - extract base64 data
+            return strip_base64_prefix(image.source)
+        else:
+            # Regular URL - fetch and convert to base64
+            logger.debug(f"Fetching image from URL for Ollama: {image.source}")
+            base64_data, _ = await fetch_image_as_base64(image.source)
+            return base64_data
+    else:
+        # Base64 dict source - use directly
+        base64_data = image.source.get("data", "")
+        # Strip any data URI prefix that might be present
+        return strip_base64_prefix(base64_data)
+
+
+async def _convert_user_content_to_ollama(
+    content: str | list[TextContent | ImageContent] | None,
+) -> tuple[str, list[str]]:
+    """
+    Convert UserMessage content to Ollama format.
+
+    Handles both simple string content (backward compatible) and
+    multimodal content arrays (text + images).
+
+    Ollama uses a format where text goes in "content" and images
+    go in a separate "images" array as raw base64 strings.
+
+    Returns:
+        A tuple of (text_content, images_list) where:
+            - text_content: Combined text from all TextContent items
+            - images_list: List of base64-encoded image strings
+
+    Raises:
+        ImageFetchError: If a URL image cannot be fetched.
+    """
+    if content is None:
+        return "", []
+
+    if isinstance(content, str):
+        # Simple string content
+        return content, []
+
+    # Multimodal content array
+    text_parts: list[str] = []
+    images: list[str] = []
+
+    for item in content:
+        if isinstance(item, TextContent):
+            text_parts.append(item.text)
+        elif isinstance(item, ImageContent):
+            images.append(await _convert_image_to_ollama(item))
+
+    # Join text parts with newlines
+    text_content = "\n".join(text_parts) if text_parts else ""
+
+    return text_content, images
+
+
+async def convert_messages_to_ollama(messages: list[ChatMessage]) -> list[dict[str, Any]]:
     """
     Convert casual-llm ChatMessage list to Ollama format.
 
     Unlike OpenAI which expects tool call arguments as JSON strings,
     Ollama expects them as dictionaries. This function handles that conversion.
 
+    Supports multimodal messages with images. Ollama expects images as raw
+    base64 strings in a separate "images" array.
+
     Args:
         messages: List of ChatMessage objects
 
     Returns:
         List of dictionaries in Ollama message format
 
+    Raises:
+        ImageFetchError: If a URL image cannot be fetched.
+
     Examples:
+        >>> import asyncio
         >>> from casual_llm import UserMessage
         >>> messages = [UserMessage(content="Hello")]
-        >>> ollama_msgs = convert_messages_to_ollama(messages)
+        >>> ollama_msgs = asyncio.run(convert_messages_to_ollama(messages))
         >>> ollama_msgs[0]["role"]
         'user'
     """
@@ -97,7 +181,11 @@ def convert_messages_to_ollama(messages: list[ChatMessage]) -> list[dict[str, An
                 )
 
             case "user":
-                ollama_messages.append({"role": "user", "content": msg.content})
+                text_content, images = await _convert_user_content_to_ollama(msg.content)
+                user_message: dict[str, Any] = {"role": "user", "content": text_content}
+                if images:
+                    user_message["images"] = images
+                ollama_messages.append(user_message)
 
             case _:
                 logger.warning(f"Unknown message role: {msg.role}")

{casual_llm-0.2.0 → casual_llm-0.4.1}/src/casual_llm/message_converters/openai.py

@@ -11,6 +11,8 @@ from casual_llm.messages import (
     ChatMessage,
     AssistantToolCall,
     AssistantToolCallFunction,
+    TextContent,
+    ImageContent,
 )
 
 if TYPE_CHECKING:
@@ -19,6 +21,55 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 
+def _convert_image_to_openai(image: ImageContent) -> dict[str, Any]:
+    """
+    Convert ImageContent to OpenAI image_url format.
+
+    OpenAI expects images in the format:
+    {"type": "image_url", "image_url": {"url": "..."}}
+
+    For base64 images, the URL should be a data URI:
+    data:image/jpeg;base64,...
+    """
+    if isinstance(image.source, str):
+        # URL source - use directly
+        image_url = image.source
+    else:
+        # Base64 dict source - construct data URI
+        base64_data = image.source.get("data", "")
+        image_url = f"data:{image.media_type};base64,{base64_data}"
+
+    return {
+        "type": "image_url",
+        "image_url": {"url": image_url},
+    }
+
+
+def _convert_user_content_to_openai(
+    content: str | list[TextContent | ImageContent] | None,
+) -> str | list[dict[str, Any]] | None:
+    """
+    Convert UserMessage content to OpenAI format.
+
+    Handles both simple string content (backward compatible) and
+    multimodal content arrays (text + images).
+    """
+    if content is None or isinstance(content, str):
+        # Simple string content or None - pass through
+        return content
+
+    # Multimodal content array
+    openai_content: list[dict[str, Any]] = []
+
+    for item in content:
+        if isinstance(item, TextContent):
+            openai_content.append({"type": "text", "text": item.text})
+        elif isinstance(item, ImageContent):
+            openai_content.append(_convert_image_to_openai(item))
+
+    return openai_content
+
+
 def convert_messages_to_openai(messages: list[ChatMessage]) -> list[dict[str, Any]]:
     """
     Convert casual-llm ChatMessage list to OpenAI format.
@@ -86,7 +137,12 @@ def convert_messages_to_openai(messages: list[ChatMessage]) -> list[dict[str, An
                 )
 
             case "user":
-                openai_messages.append({"role": "user", "content": msg.content})
+                openai_messages.append(
+                    {
+                        "role": "user",
+                        "content": _convert_user_content_to_openai(msg.content),
+                    }
+                )
 
             case _:
                 logger.warning(f"Unknown message role: {msg.role}")