aloop 0.1.0__py3-none-any.whl

llm/__init__.py

@@ -0,0 +1,51 @@
+"""LLM module - LiteLLM adapter for unified access to 100+ providers."""
+
+# Import new types from message_types (primary source)
+# Import compatibility utilities
+from .compat import ensure_new_format, migrate_messages, normalize_stop_reason
+
+# Import utilities
+from .content_utils import (
+    extract_text,
+    extract_text_from_message,
+    extract_tool_calls_from_content,
+    message_to_dict,
+)
+
+# Import adapter
+from .litellm_adapter import LiteLLMAdapter
+from .message_types import (
+    FunctionCall,
+    LLMMessage,
+    LLMResponse,
+    StopReason,
+    ToolCall,
+    ToolCallBlock,
+    ToolResult,
+)
+from .model_manager import ModelManager, ModelProfile
+
+__all__ = [
+    # Core types
+    "LLMMessage",
+    "LLMResponse",
+    "ToolCall",
+    "ToolResult",
+    "ToolCallBlock",
+    "FunctionCall",
+    "StopReason",
+    # Adapter
+    "LiteLLMAdapter",
+    # Model Manager
+    "ModelManager",
+    "ModelProfile",
+    # Utilities
+    "extract_text",
+    "extract_text_from_message",
+    "extract_tool_calls_from_content",
+    "message_to_dict",
+    # Compatibility
+    "ensure_new_format",
+    "migrate_messages",
+    "normalize_stop_reason",
+]

llm/base.py

@@ -0,0 +1,26 @@
+"""Base data structures for LLM interface.
+
+This module re-exports types from message_types.py for backward compatibility.
+New code should import from llm.message_types or llm directly.
+"""
+
+# Re-export all types from message_types for backward compatibility
+from .message_types import (
+    FunctionCall,
+    LLMMessage,
+    LLMResponse,
+    StopReason,
+    ToolCall,
+    ToolCallBlock,
+    ToolResult,
+)
+
+__all__ = [
+    "LLMMessage",
+    "LLMResponse",
+    "ToolCall",
+    "ToolResult",
+    "ToolCallBlock",
+    "FunctionCall",
+    "StopReason",
+]

llm/compat.py

@@ -0,0 +1,226 @@
+"""Backward compatibility layer for message format migration.
+
+This module provides utilities for converting between old and new message formats,
+allowing gradual migration while maintaining backward compatibility.
+"""
+
+from typing import Any, Dict, List, Union
+
+from .content_utils import extract_text, extract_tool_calls_from_content
+from .message_types import LLMMessage, StopReason
+
+
+def ensure_new_format(message: Any) -> LLMMessage:
+    """Convert any message format to the new LLMMessage format.
+
+    Handles:
+    - New LLMMessage instances (passed through)
+    - Old LLMMessage with complex content
+    - Dict representations
+    - Raw message objects from providers
+
+    Args:
+        message: Message in any supported format
+
+    Returns:
+        LLMMessage in new format
+    """
+    # Already new format
+    if isinstance(message, LLMMessage):
+        # Check if it has the new attributes (tool_calls, tool_call_id)
+        if hasattr(message, "tool_calls"):
+            return message
+        # Old format LLMMessage - convert
+        return _convert_old_llm_message(message)
+
+    # Dict format
+    if isinstance(message, dict):
+        return LLMMessage.from_dict(message)
+
+    # Raw message object (from provider)
+    return _convert_raw_message(message)
+
+
+def _convert_old_llm_message(message: LLMMessage) -> LLMMessage:
+    """Convert old-format LLMMessage to new format.
+
+    Old format:
+    - role: str
+    - content: Any (could be str, list of blocks, or Message object)
+
+    New format:
+    - role: Literal[...]
+    - content: Optional[str]
+    - tool_calls: Optional[List[ToolCallBlock]]
+    - tool_call_id: Optional[str]
+    - name: Optional[str]
+
+    Args:
+        message: Old-format LLMMessage
+
+    Returns:
+        New-format LLMMessage
+    """
+    role = message.role
+    content = message.content
+
+    # Extract text content
+    text_content = extract_text(content) if content else None
+
+    # For empty string, use None
+    if text_content == "":
+        text_content = None
+
+    # Extract tool calls if present
+    tool_calls = extract_tool_calls_from_content(content) if content else None
+
+    # Handle tool result messages (old Anthropic format)
+    tool_call_id = None
+    name = None
+
+    if isinstance(content, list):
+        for block in content:
+            if isinstance(block, dict) and block.get("type") == "tool_result":
+                tool_call_id = block.get("tool_use_id")
+                # In old format, tool results don't have name
+                # Try to extract from content if possible
+                text_content = block.get("content", "")
+                role = "tool"  # Convert to OpenAI tool role
+                break
+
+    return LLMMessage(
+        role=role,  # type: ignore
+        content=text_content,
+        tool_calls=tool_calls if tool_calls else None,
+        tool_call_id=tool_call_id,
+        name=name,
+    )
+
+
+def _convert_raw_message(message: Any) -> LLMMessage:
+    """Convert a raw message object from provider to LLMMessage.
+
+    Args:
+        message: Raw message object (e.g., from LiteLLM response)
+
+    Returns:
+        LLMMessage
+    """
+    role = getattr(message, "role", "assistant")
+    content = getattr(message, "content", None)
+
+    # Extract text
+    text_content = extract_text(content) if content else None
+    if text_content == "":
+        text_content = None
+
+    # Extract tool calls
+    tool_calls = None
+    if hasattr(message, "tool_calls") and message.tool_calls:
+        tool_calls = extract_tool_calls_from_content(message)
+
+    return LLMMessage(
+        role=role,  # type: ignore
+        content=text_content,
+        tool_calls=tool_calls,
+    )
+
+
+def normalize_stop_reason(reason: str) -> str:
+    """Normalize stop reason to OpenAI format.
+
+    Args:
+        reason: Stop reason in any format (Anthropic or OpenAI)
+
+    Returns:
+        Normalized stop reason
+    """
+    return StopReason.normalize(reason)
+
+
+def convert_tool_results_to_messages(
+    results: List[Dict[str, Any]],
+) -> List[LLMMessage]:
+    """Convert tool results from old Anthropic format to new message format.
+
+    Old format (single message with list of tool_result blocks):
+    LLMMessage(role="user", content=[
+        {"type": "tool_result", "tool_use_id": "...", "content": "..."},
+        ...
+    ])
+
+    New format (one message per tool result):
+    [
+        LLMMessage(role="tool", content="...", tool_call_id="...", name="..."),
+        ...
+    ]
+
+    Args:
+        results: List of tool result dicts in Anthropic format
+
+    Returns:
+        List of LLMMessages in OpenAI tool format
+    """
+    return [
+        LLMMessage(
+            role="tool",
+            content=result.get("content", ""),
+            tool_call_id=result.get("tool_use_id", ""),
+            name=result.get("name"),
+        )
+        for result in results
+        if result.get("type") == "tool_result"
+    ]
+
+
+def format_tool_results_for_api(
+    results: List[Dict[str, Any]], use_openai_format: bool = True
+) -> Union[LLMMessage, List[LLMMessage]]:
+    """Format tool results for API call.
+
+    Args:
+        results: List of tool result dicts
+        use_openai_format: If True, return list of tool messages (OpenAI format)
+                          If False, return single user message (Anthropic format)
+
+    Returns:
+        Formatted message(s)
+    """
+    if use_openai_format:
+        return convert_tool_results_to_messages(results)
+    else:
+        # Old Anthropic format
+        return LLMMessage(role="user", content=results)  # type: ignore
+
+
+def is_new_format_message(message: LLMMessage) -> bool:
+    """Check if a message is in the new format.
+
+    New format messages have:
+    - content as Optional[str] (not complex types)
+    - tool_calls as Optional[List[ToolCallBlock]]
+
+    Args:
+        message: LLMMessage to check
+
+    Returns:
+        True if new format
+    """
+    # Check if content is simple (str or None)
+    if message.content is not None and not isinstance(message.content, str):
+        return False
+
+    # New format messages have tool_calls attribute
+    return hasattr(message, "tool_calls")
+
+
+def migrate_messages(messages: List[LLMMessage]) -> List[LLMMessage]:
+    """Migrate a list of messages to new format.
+
+    Args:
+        messages: List of messages in any format
+
+    Returns:
+        List of messages in new format
+    """
+    return [ensure_new_format(msg) for msg in messages]

llm/content_utils.py

@@ -0,0 +1,309 @@
+"""Centralized content extraction utilities for LLM messages.
+
+This module consolidates all content extraction logic that was previously
+scattered across litellm_adapter.py, compressor.py, and token_tracker.py.
+"""
+
+from typing import Any, List, Optional
+
+from .message_types import LLMMessage, ToolCallBlock
+
+
+def extract_text(content: Any) -> str:
+    """Extract text content from any message format.
+
+    Handles:
+    - String content
+    - Message objects with .content attribute
+    - List of content blocks (Anthropic format)
+    - Dict content blocks
+
+    Args:
+        content: Content in any supported format
+
+    Returns:
+        Extracted text as string
+    """
+    if content is None:
+        return ""
+
+    if isinstance(content, str):
+        return content
+
+    # Handle Message objects (from previous LLM responses)
+    if hasattr(content, "content"):
+        return extract_text(content.content)
+
+    # Handle list of content blocks
+    if isinstance(content, list):
+        texts = []
+        for block in content:
+            text = _extract_text_from_block(block)
+            if text:
+                texts.append(text)
+        return "\n".join(texts) if texts else ""
+
+    # Handle dict content block
+    if isinstance(content, dict):
+        return _extract_text_from_block(content)
+
+    # Fallback: convert to string
+    return str(content)
+
+
+def _extract_text_from_block(block: Any) -> str:
+    """Extract text from a single content block.
+
+    Args:
+        block: Content block (dict or object)
+
+    Returns:
+        Text content or empty string
+    """
+    # Handle dict format
+    if isinstance(block, dict):
+        if block.get("type") == "text":
+            return block.get("text", "")
+        if "text" in block:
+            return block["text"]
+        # For tool_use/tool_result, don't include in text extraction
+        if block.get("type") in ("tool_use", "tool_result"):
+            return ""
+        return ""
+
+    # Handle object format (ContentBlock from Anthropic SDK)
+    if hasattr(block, "text"):
+        return block.text
+
+    if hasattr(block, "type") and block.type == "text":
+        return getattr(block, "text", "")
+
+    return ""
+
+
+def extract_text_from_message(message: LLMMessage) -> str:
+    """Extract text content from an LLMMessage.
+
+    For new-format messages, returns the content directly.
+    For old-format messages with complex content, extracts text.
+
+    Args:
+        message: LLMMessage instance
+
+    Returns:
+        Text content
+    """
+    if message.content is None:
+        return ""
+
+    if isinstance(message.content, str):
+        return message.content
+
+    # Handle legacy complex content
+    return extract_text(message.content)
+
+
+def extract_tool_calls_from_content(content: Any) -> List[ToolCallBlock]:
+    """Extract tool calls from message content.
+
+    Handles both OpenAI format (tool_calls field) and Anthropic format
+    (tool_use blocks in content).
+
+    Args:
+        content: Message content in any format
+
+    Returns:
+        List of tool calls in OpenAI/LiteLLM format
+    """
+    tool_calls: List[ToolCallBlock] = []
+
+    # Handle Message objects
+    if hasattr(content, "tool_calls") and content.tool_calls:
+        for tc in content.tool_calls:
+            tool_call = _normalize_tool_call(tc)
+            if tool_call:
+                tool_calls.append(tool_call)
+        return tool_calls
+
+    # Handle list of content blocks (Anthropic format)
+    if isinstance(content, list):
+        for block in content:
+            if (
+                isinstance(block, dict)
+                and block.get("type") == "tool_use"
+                or hasattr(block, "type")
+                and block.type == "tool_use"
+            ):
+                tool_call = _anthropic_to_openai_tool_call(block)
+                if tool_call:
+                    tool_calls.append(tool_call)
+
+    return tool_calls
+
+
+def _normalize_tool_call(tc: Any) -> Optional[ToolCallBlock]:
+    """Normalize a tool call to OpenAI format.
+
+    Args:
+        tc: Tool call in any format
+
+    Returns:
+        ToolCallBlock in OpenAI format or None
+    """
+    import json
+
+    # Already in OpenAI dict format
+    if isinstance(tc, dict):
+        if "function" in tc:
+            return tc  # type: ignore
+        # Anthropic format in dict
+        if tc.get("type") == "tool_use":
+            return _anthropic_to_openai_tool_call(tc)
+
+    # OpenAI object format (from LiteLLM)
+    if hasattr(tc, "function") and hasattr(tc, "id"):
+        arguments = tc.function.arguments
+        if not isinstance(arguments, str):
+            arguments = json.dumps(arguments)
+
+        return {
+            "id": tc.id,
+            "type": "function",
+            "function": {
+                "name": tc.function.name,
+                "arguments": arguments,
+            },
+        }
+
+    # Anthropic object format
+    if hasattr(tc, "type") and tc.type == "tool_use":
+        return _anthropic_to_openai_tool_call(tc)
+
+    return None
+
+
+def _anthropic_to_openai_tool_call(block: Any) -> Optional[ToolCallBlock]:
+    """Convert Anthropic tool_use block to OpenAI format.
+
+    Args:
+        block: Anthropic tool_use block (dict or object)
+
+    Returns:
+        ToolCallBlock in OpenAI format or None
+    """
+    import json
+
+    if isinstance(block, dict):
+        tool_id = block.get("id", "")
+        name = block.get("name", "")
+        input_data = block.get("input", {})
+    else:
+        tool_id = getattr(block, "id", "")
+        name = getattr(block, "name", "")
+        input_data = getattr(block, "input", {})
+
+    if not tool_id or not name:
+        return None
+
+    # Convert input to JSON string
+    arguments = input_data if isinstance(input_data, str) else json.dumps(input_data)
+
+    return {
+        "id": tool_id,
+        "type": "function",
+        "function": {
+            "name": name,
+            "arguments": arguments,
+        },
+    }
+
+
+def message_to_dict(message: LLMMessage) -> dict:
+    """Convert LLMMessage to dictionary for API calls.
+
+    This is a convenience wrapper around message.to_dict() that also
+    handles legacy message formats.
+
+    Args:
+        message: LLMMessage instance
+
+    Returns:
+        Dictionary in OpenAI format
+    """
+    # Use the new to_dict if available
+    if hasattr(message, "to_dict"):
+        return message.to_dict()
+
+    # Legacy format
+    result = {"role": message.role}
+
+    if message.content is not None:
+        if isinstance(message.content, str):
+            result["content"] = message.content
+        else:
+            # Extract text from complex content
+            result["content"] = extract_text(message.content)
+
+    return result
+
+
+def content_has_tool_calls(content: Any) -> bool:
+    """Check if content contains tool calls.
+
+    Args:
+        content: Message content in any format
+
+    Returns:
+        True if contains tool calls
+    """
+    # Check for tool_calls field
+    if hasattr(content, "tool_calls") and content.tool_calls:
+        return True
+
+    # Check for tool_use blocks in list
+    if isinstance(content, list):
+        for block in content:
+            if isinstance(block, dict) and block.get("type") in ("tool_use", "tool_calls"):
+                return True
+            if hasattr(block, "type") and block.type in ("tool_use", "tool_calls"):
+                return True
+
+    return False
+
+
+def content_has_tool_results(content: Any) -> bool:
+    """Check if content contains tool results.
+
+    Args:
+        content: Message content in any format
+
+    Returns:
+        True if contains tool results
+    """
+    if isinstance(content, list):
+        for block in content:
+            if isinstance(block, dict):
+                if block.get("type") == "tool_result":
+                    return True
+            elif hasattr(block, "type") and block.type == "tool_result":
+                return True
+
+    return False
+
+
+def estimate_tokens(content: Any) -> int:
+    """Estimate token count for content.
+
+    Uses a simple character-based estimation:
+    ~3.5 characters per token for mixed content.
+
+    Args:
+        content: Content to estimate
+
+    Returns:
+        Estimated token count
+    """
+    text = extract_text(content)
+    if not text:
+        return 0
+    return max(1, int(len(text) / 3.5))