agent-runtime-core 0.7.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

agent_runtime_core/llm/__init__.py

@@ -6,15 +6,38 @@ Provides:
 - OpenAIClient: OpenAI API client
 - AnthropicClient: Anthropic API client
 - LiteLLMClient: LiteLLM adapter (optional)
+- get_llm_client: Factory with auto-detection from model name
+- get_llm_client_for_model: Get client for a specific model
 """
 
+from typing import Optional
+
 from agent_runtime_core.interfaces import LLMClient, LLMResponse, LLMStreamChunk
+from agent_runtime_core.llm.models_config import (
+    ModelInfo,
+    SUPPORTED_MODELS,
+    DEFAULT_MODEL,
+    get_model_info,
+    get_provider_for_model,
+    list_models_for_ui,
+)
 
 __all__ = [
+    # Interfaces
     "LLMClient",
     "LLMResponse",
     "LLMStreamChunk",
+    # Factory functions
     "get_llm_client",
+    "get_llm_client_for_model",
+    # Model config
+    "ModelInfo",
+    "SUPPORTED_MODELS",
+    "DEFAULT_MODEL",
+    "get_model_info",
+    "get_provider_for_model",
+    "list_models_for_ui",
+    # Exceptions
     "OpenAIConfigurationError",
     "AnthropicConfigurationError",
 ]
@@ -30,37 +53,56 @@ class AnthropicConfigurationError(Exception):
     pass
 
 
-def get_llm_client(provider: str = None, **kwargs) -> LLMClient:
+def get_llm_client(
+    provider: Optional[str] = None,
+    model: Optional[str] = None,
+    **kwargs
+) -> LLMClient:
     """
     Factory function to get an LLM client.
 
+    Can auto-detect provider from model name if model is provided.
+
     Args:
-        provider: "openai", "anthropic", "litellm", etc.
+        provider: "openai", "anthropic", "litellm", etc. (optional if model provided)
+        model: Model ID - if provided, auto-detects provider
         **kwargs: Provider-specific configuration (e.g., api_key, default_model)
 
     Returns:
         LLMClient instance
-        
+
     Raises:
         OpenAIConfigurationError: If OpenAI is selected but API key is not configured
         AnthropicConfigurationError: If Anthropic is selected but API key is not configured
         ValueError: If an unknown provider is specified
-        
+
     Example:
-        # Using config (recommended)
+        # Auto-detect from model name (recommended)
+        llm = get_llm_client(model="claude-sonnet-4-20250514")
+        llm = get_llm_client(model="gpt-4o")
+
+        # Using config
         from agent_runtime_core.config import configure
         configure(model_provider="openai", openai_api_key="sk-...")
         llm = get_llm_client()
-        
+
         # Or with explicit API key
         llm = get_llm_client(api_key='sk-...')
-        
+
         # Or with a different provider
         llm = get_llm_client(provider='anthropic', api_key='sk-ant-...')
     """
     from agent_runtime_core.config import get_config
 
     config = get_config()
+
+    # Auto-detect provider from model name if not explicitly provided
+    if provider is None and model:
+        detected_provider = get_provider_for_model(model)
+        if detected_provider:
+            provider = detected_provider
+
+    # Fall back to config
     provider = provider or config.model_provider
 
     if provider == "openai":
@@ -81,3 +123,34 @@ def get_llm_client(provider: str = None, **kwargs) -> LLMClient:
             f"Supported providers: 'openai', 'anthropic', 'litellm'\n"
             f"Set model_provider in your configuration."
         )
+
+
+def get_llm_client_for_model(model: str, **kwargs) -> LLMClient:
+    """
+    Get an LLM client configured for a specific model.
+
+    This is a convenience function that auto-detects the provider
+    and sets the default model.
+
+    Args:
+        model: Model ID (e.g., "gpt-4o", "claude-sonnet-4-20250514")
+        **kwargs: Additional client configuration
+
+    Returns:
+        LLMClient configured for the specified model
+
+    Raises:
+        ValueError: If model provider cannot be determined
+
+    Example:
+        llm = get_llm_client_for_model("claude-sonnet-4-20250514")
+        response = await llm.generate(messages)  # Uses claude-sonnet-4-20250514
+    """
+    provider = get_provider_for_model(model)
+    if not provider:
+        raise ValueError(
+            f"Cannot determine provider for model: {model}\n"
+            f"Known models: {', '.join(SUPPORTED_MODELS.keys())}"
+        )
+
+    return get_llm_client(provider=provider, default_model=model, **kwargs)

agent_runtime_core/llm/anthropic.py

@@ -2,6 +2,7 @@
 Anthropic API client implementation.
 """
 
+import json
 import os
 from typing import AsyncIterator, Optional
 
@@ -103,14 +104,17 @@ class AnthropicClient(LLMClient):
         """Generate a completion from Anthropic."""
         model = model or self.default_model
 
-        # Extract system message
+        # Extract system message and convert other messages
         system_message = None
-        chat_messages = []
+        converted_messages = []
         for msg in messages:
             if msg.get("role") == "system":
                 system_message = msg.get("content", "")
             else:
-                chat_messages.append(self._convert_message(msg))
+                converted_messages.append(self._convert_message(msg))
+
+        # Merge consecutive messages with the same role (required by Anthropic)
+        chat_messages = self._merge_consecutive_messages(converted_messages)
 
         request_kwargs = {
             "model": model,
@@ -152,14 +156,17 @@ class AnthropicClient(LLMClient):
         """Stream a completion from Anthropic."""
         model = model or self.default_model
 
-        # Extract system message
+        # Extract system message and convert other messages
         system_message = None
-        chat_messages = []
+        converted_messages = []
         for msg in messages:
             if msg.get("role") == "system":
                 system_message = msg.get("content", "")
             else:
-                chat_messages.append(self._convert_message(msg))
+                converted_messages.append(self._convert_message(msg))
+
+        # Merge consecutive messages with the same role (required by Anthropic)
+        chat_messages = self._merge_consecutive_messages(converted_messages)
 
         request_kwargs = {
             "model": model,
@@ -183,18 +190,130 @@ class AnthropicClient(LLMClient):
                     yield LLMStreamChunk(finish_reason="stop")
 
     def _convert_message(self, msg: Message) -> dict:
-        """Convert our message format to Anthropic format."""
+        """
+        Convert our message format to Anthropic format.
+
+        Handles:
+        - Regular user/assistant messages
+        - Assistant messages with tool_calls (need content blocks)
+        - Tool result messages (need tool_result content blocks)
+        """
         role = msg.get("role", "user")
-        if role == "assistant":
-            role = "assistant"
-        elif role == "tool":
-            role = "user"  # Tool results go as user messages in Anthropic
 
+        # Handle tool result messages
+        if role == "tool":
+            # Tool results go as user messages with tool_result content blocks
+            return {
+                "role": "user",
+                "content": [
+                    {
+                        "type": "tool_result",
+                        "tool_use_id": msg.get("tool_call_id", ""),
+                        "content": msg.get("content", ""),
+                    }
+                ],
+            }
+
+        # Handle assistant messages with tool_calls
+        if role == "assistant" and msg.get("tool_calls"):
+            content_blocks = []
+
+            # Add text content if present
+            text_content = msg.get("content", "")
+            if text_content:
+                content_blocks.append({
+                    "type": "text",
+                    "text": text_content,
+                })
+
+            # Add tool_use blocks for each tool call
+            for tool_call in msg.get("tool_calls", []):
+                # Handle both dict format and nested function format
+                if "function" in tool_call:
+                    # OpenAI-style format: {"id": ..., "function": {"name": ..., "arguments": ...}}
+                    func = tool_call["function"]
+                    tool_id = tool_call.get("id", "")
+                    tool_name = func.get("name", "")
+                    # Arguments might be a string (JSON) or already a dict
+                    args = func.get("arguments", {})
+                    if isinstance(args, str):
+                        try:
+                            args = json.loads(args)
+                        except json.JSONDecodeError:
+                            args = {}
+                else:
+                    # Direct format: {"id": ..., "name": ..., "arguments": ...}
+                    tool_id = tool_call.get("id", "")
+                    tool_name = tool_call.get("name", "")
+                    args = tool_call.get("arguments", {})
+                    if isinstance(args, str):
+                        try:
+                            args = json.loads(args)
+                        except json.JSONDecodeError:
+                            args = {}
+
+                content_blocks.append({
+                    "type": "tool_use",
+                    "id": tool_id,
+                    "name": tool_name,
+                    "input": args,
+                })
+
+            return {
+                "role": "assistant",
+                "content": content_blocks,
+            }
+
+        # Regular user or assistant message
         return {
             "role": role,
             "content": msg.get("content", ""),
         }
 
+    def _merge_consecutive_messages(self, messages: list[dict]) -> list[dict]:
+        """
+        Merge consecutive messages with the same role.
+
+        Anthropic requires that messages alternate between user and assistant roles.
+        When we have multiple tool results (which become user messages), they need
+        to be combined into a single user message with multiple content blocks.
+        """
+        if not messages:
+            return messages
+
+        merged = []
+        for msg in messages:
+            if not merged:
+                merged.append(msg)
+                continue
+
+            last_msg = merged[-1]
+
+            # If same role, merge the content
+            if msg["role"] == last_msg["role"]:
+                last_content = last_msg["content"]
+                new_content = msg["content"]
+
+                # Convert to list format if needed
+                if isinstance(last_content, str):
+                    if last_content:
+                        last_content = [{"type": "text", "text": last_content}]
+                    else:
+                        last_content = []
+
+                if isinstance(new_content, str):
+                    if new_content:
+                        new_content = [{"type": "text", "text": new_content}]
+                    else:
+                        new_content = []
+
+                # Merge content blocks
+                last_msg["content"] = last_content + new_content
+            else:
+                merged.append(msg)
+
+        return merged
+
     def _convert_tools(self, tools: list[dict]) -> list[dict]:
         """Convert OpenAI tool format to Anthropic format."""
         result = []
@@ -217,12 +336,14 @@ class AnthropicClient(LLMClient):
             if block.type == "text":
                 content += block.text
             elif block.type == "tool_use":
+                # Convert input to JSON string (not Python str() which gives wrong format)
+                arguments = json.dumps(block.input) if isinstance(block.input, dict) else str(block.input)
                 tool_calls.append({
                     "id": block.id,
                     "type": "function",
                     "function": {
                         "name": block.name,
-                        "arguments": str(block.input),
+                        "arguments": arguments,
                     },
                 })
 

agent_runtime_core/llm/models_config.py

@@ -0,0 +1,180 @@
+"""
+Supported LLM models configuration.
+
+Provides a central registry of supported models with their providers,
+capabilities, and metadata. Used for:
+- Auto-detecting provider from model name
+- Populating model selectors in UI
+- Validating model choices
+"""
+
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class ModelInfo:
+    """Information about a supported model."""
+    id: str  # Model identifier (e.g., "gpt-4o", "claude-sonnet-4-20250514")
+    name: str  # Display name (e.g., "GPT-4o", "Claude Sonnet 4")
+    provider: str  # "openai" or "anthropic"
+    context_window: int  # Max context in tokens
+    supports_tools: bool = True
+    supports_vision: bool = False
+    supports_streaming: bool = True
+    description: str = ""
+
+
+# Registry of supported models
+SUPPORTED_MODELS: dict[str, ModelInfo] = {
+    # OpenAI Models
+    "gpt-4o": ModelInfo(
+        id="gpt-4o",
+        name="GPT-4o",
+        provider="openai",
+        context_window=128000,
+        supports_vision=True,
+        description="Most capable OpenAI model, multimodal",
+    ),
+    "gpt-4o-mini": ModelInfo(
+        id="gpt-4o-mini",
+        name="GPT-4o Mini",
+        provider="openai",
+        context_window=128000,
+        supports_vision=True,
+        description="Fast and affordable, good for most tasks",
+    ),
+    "gpt-4-turbo": ModelInfo(
+        id="gpt-4-turbo",
+        name="GPT-4 Turbo",
+        provider="openai",
+        context_window=128000,
+        supports_vision=True,
+        description="Previous generation flagship",
+    ),
+    "o1": ModelInfo(
+        id="o1",
+        name="o1",
+        provider="openai",
+        context_window=200000,
+        supports_tools=False,
+        description="Advanced reasoning model",
+    ),
+    "o1-mini": ModelInfo(
+        id="o1-mini",
+        name="o1 Mini",
+        provider="openai",
+        context_window=128000,
+        supports_tools=False,
+        description="Fast reasoning model",
+    ),
+    "o3-mini": ModelInfo(
+        id="o3-mini",
+        name="o3 Mini",
+        provider="openai",
+        context_window=200000,
+        supports_tools=True,
+        description="Latest reasoning model with tool use",
+    ),
+    
+    # Anthropic Models - Claude 4.5 (latest)
+    "claude-sonnet-4-5-20250929": ModelInfo(
+        id="claude-sonnet-4-5-20250929",
+        name="Claude Sonnet 4.5",
+        provider="anthropic",
+        context_window=200000,
+        supports_vision=True,
+        description="Best balance of speed and capability for agents and coding",
+    ),
+    "claude-opus-4-5-20251101": ModelInfo(
+        id="claude-opus-4-5-20251101",
+        name="Claude Opus 4.5",
+        provider="anthropic",
+        context_window=200000,
+        supports_vision=True,
+        description="Premium model - maximum intelligence with practical performance",
+    ),
+    "claude-haiku-4-5-20251001": ModelInfo(
+        id="claude-haiku-4-5-20251001",
+        name="Claude Haiku 4.5",
+        provider="anthropic",
+        context_window=200000,
+        supports_vision=True,
+        description="Fastest model with near-frontier intelligence",
+    ),
+    # Anthropic Models - Claude 4 (previous generation)
+    "claude-sonnet-4-20250514": ModelInfo(
+        id="claude-sonnet-4-20250514",
+        name="Claude Sonnet 4",
+        provider="anthropic",
+        context_window=200000,
+        supports_vision=True,
+        description="Previous generation Sonnet",
+    ),
+    "claude-opus-4-20250514": ModelInfo(
+        id="claude-opus-4-20250514",
+        name="Claude Opus 4",
+        provider="anthropic",
+        context_window=200000,
+        supports_vision=True,
+        description="Previous generation Opus",
+    ),
+    # Anthropic Models - Claude 3.5 (legacy)
+    "claude-3-5-sonnet-20241022": ModelInfo(
+        id="claude-3-5-sonnet-20241022",
+        name="Claude 3.5 Sonnet",
+        provider="anthropic",
+        context_window=200000,
+        supports_vision=True,
+        description="Legacy model, still excellent",
+    ),
+    "claude-3-5-haiku-20241022": ModelInfo(
+        id="claude-3-5-haiku-20241022",
+        name="Claude 3.5 Haiku",
+        provider="anthropic",
+        context_window=200000,
+        supports_vision=True,
+        description="Legacy fast model",
+    ),
+}
+
+# Default model to use
+DEFAULT_MODEL = "claude-sonnet-4-5-20250929"
+
+
+def get_model_info(model_id: str) -> Optional[ModelInfo]:
+    """Get info for a model by ID."""
+    return SUPPORTED_MODELS.get(model_id)
+
+
+def get_provider_for_model(model_id: str) -> Optional[str]:
+    """
+    Detect the provider for a model ID.
+    
+    Returns "openai", "anthropic", or None if unknown.
+    """
+    # Check registry first
+    if model_id in SUPPORTED_MODELS:
+        return SUPPORTED_MODELS[model_id].provider
+    
+    # Fallback heuristics for unlisted models
+    if model_id.startswith("gpt-") or model_id.startswith("o1") or model_id.startswith("o3"):
+        return "openai"
+    if model_id.startswith("claude"):
+        return "anthropic"
+    
+    return None
+
+
+def list_models_for_ui() -> list[dict]:
+    """Get list of models formatted for UI dropdowns."""
+    return [
+        {
+            "id": m.id,
+            "name": m.name,
+            "provider": m.provider,
+            "description": m.description,
+        }
+        for m in SUPPORTED_MODELS.values()
+    ]
+

agent_runtime_core/memory/__init__.py

@@ -0,0 +1,70 @@
+"""
+Cross-conversation memory system for AI agents.
+
+This module provides automatic memory extraction and recall across conversations,
+allowing agents to remember facts, preferences, and context about users.
+
+Key Components:
+- MemoryManager: Extracts and recalls memories using LLM
+- MemoryConfig: Configuration for memory behavior
+- MemoryEnabledAgent: Mixin for adding memory to agents
+
+Example usage:
+    from agent_runtime_core.memory import MemoryManager, MemoryConfig
+    from agent_runtime_core.persistence import FileKnowledgeStore
+    from agent_runtime_core.llm import get_llm_client
+    
+    # Setup memory manager
+    knowledge_store = FileKnowledgeStore()
+    llm = get_llm_client()
+    memory = MemoryManager(knowledge_store, llm)
+    
+    # Extract memories from a conversation
+    messages = [
+        {"role": "user", "content": "My name is Alice and I prefer dark mode."},
+        {"role": "assistant", "content": "Nice to meet you, Alice! I've noted your preference for dark mode."},
+    ]
+    await memory.extract_memories(messages, user_id="user-123")
+    
+    # Recall memories for a new conversation
+    relevant_memories = await memory.recall_memories(
+        query="What theme does the user prefer?",
+        user_id="user-123",
+    )
+    
+    # Or use with ToolCallingAgent via mixin
+    from agent_runtime_core.memory import MemoryEnabledAgent
+    from agent_runtime_core import ToolCallingAgent
+    
+    class MyAgent(MemoryEnabledAgent, ToolCallingAgent):
+        memory_enabled = True  # Enable memory for this agent
+        
+        @property
+        def key(self) -> str:
+            return "my-agent"
+        
+        @property
+        def system_prompt(self) -> str:
+            return "You are a helpful assistant."
+        
+        @property
+        def tools(self) -> ToolRegistry:
+            return ToolRegistry()
+"""
+
+from agent_runtime_core.memory.manager import (
+    MemoryManager,
+    MemoryConfig,
+    ExtractedMemory,
+    RecalledMemory,
+)
+from agent_runtime_core.memory.mixin import MemoryEnabledAgent
+
+__all__ = [
+    "MemoryManager",
+    "MemoryConfig",
+    "ExtractedMemory",
+    "RecalledMemory",
+    "MemoryEnabledAgent",
+]
+