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

agent_runtime_core/contexts.py

@@ -24,11 +24,15 @@ import json
 import os
 from datetime import datetime
 from pathlib import Path
-from typing import Any, Callable, Optional
+from typing import Any, Callable, Optional, TYPE_CHECKING
 from uuid import UUID, uuid4
 
 from agent_runtime_core.interfaces import EventType, Message, ToolRegistry
 
+if TYPE_CHECKING:
+    from agent_runtime_core.multi_agent import SystemContext
+    from agent_runtime_core.privacy import PrivacyConfig, UserContext
+
 
 class InMemoryRunContext:
     """
@@ -65,10 +69,13 @@ class InMemoryRunContext:
         metadata: Optional[dict] = None,
         tool_registry: Optional[ToolRegistry] = None,
         on_event: Optional[Callable[[str, dict], None]] = None,
+        system_context: Optional["SystemContext"] = None,
+        user_context: Optional["UserContext"] = None,
+        privacy_config: Optional["PrivacyConfig"] = None,
     ):
         """
         Initialize an in-memory run context.
-        
+
         Args:
             run_id: Unique identifier for this run (auto-generated if not provided)
             conversation_id: Associated conversation ID (optional)
@@ -77,6 +84,9 @@ class InMemoryRunContext:
             metadata: Run metadata
             tool_registry: Registry of available tools
             on_event: Optional callback for events (for testing/debugging)
+            system_context: Optional SystemContext for multi-agent systems with shared knowledge
+            user_context: Optional UserContext for user isolation and privacy
+            privacy_config: Optional PrivacyConfig for privacy settings (defaults to max privacy)
         """
         self._run_id = run_id or uuid4()
         self._conversation_id = conversation_id
@@ -88,7 +98,18 @@ class InMemoryRunContext:
         self._state: Optional[dict] = None
         self._events: list[dict] = []
         self._on_event = on_event
-    
+        self._system_context = system_context
+
+        # Import here to avoid circular imports
+        from agent_runtime_core.privacy import (
+            DEFAULT_PRIVACY_CONFIG,
+            ANONYMOUS_USER,
+        )
+
+        # Default to secure settings: anonymous user + strict privacy
+        self._user_context = user_context if user_context is not None else ANONYMOUS_USER
+        self._privacy_config = privacy_config if privacy_config is not None else DEFAULT_PRIVACY_CONFIG
+
     @property
     def run_id(self) -> UUID:
         """Unique identifier for this run."""
@@ -118,7 +139,22 @@ class InMemoryRunContext:
     def tool_registry(self) -> ToolRegistry:
         """Registry of available tools for this agent."""
         return self._tool_registry
-    
+
+    @property
+    def system_context(self) -> Optional["SystemContext"]:
+        """System context for multi-agent systems with shared knowledge."""
+        return self._system_context
+
+    @property
+    def user_context(self) -> "UserContext":
+        """User context for privacy and data isolation. Defaults to ANONYMOUS_USER."""
+        return self._user_context
+
+    @property
+    def privacy_config(self) -> "PrivacyConfig":
+        """Privacy configuration for this run. Defaults to DEFAULT_PRIVACY_CONFIG (strict)."""
+        return self._privacy_config
+
     async def emit(self, event_type: EventType | str, payload: dict) -> None:
         """Emit an event (stored in memory)."""
         event_type_str = event_type.value if hasattr(event_type, 'value') else str(event_type)
@@ -195,6 +231,9 @@ class FileRunContext:
         metadata: Optional[dict] = None,
         tool_registry: Optional[ToolRegistry] = None,
         on_event: Optional[Callable[[str, dict], None]] = None,
+        system_context: Optional["SystemContext"] = None,
+        user_context: Optional["UserContext"] = None,
+        privacy_config: Optional["PrivacyConfig"] = None,
     ):
         """
         Initialize a file-based run context.
@@ -208,6 +247,9 @@ class FileRunContext:
             metadata: Run metadata
             tool_registry: Registry of available tools
             on_event: Optional callback for events
+            system_context: Optional SystemContext for multi-agent systems with shared knowledge
+            user_context: Optional UserContext for user isolation and privacy
+            privacy_config: Optional PrivacyConfig for privacy settings (defaults to max privacy)
         """
         self._run_id = run_id or uuid4()
         self._checkpoint_dir = Path(checkpoint_dir)
@@ -219,6 +261,17 @@ class FileRunContext:
         self._cancelled = False
         self._on_event = on_event
         self._state_cache: Optional[dict] = None
+        self._system_context = system_context
+
+        # Import here to avoid circular imports
+        from agent_runtime_core.privacy import (
+            DEFAULT_PRIVACY_CONFIG,
+            ANONYMOUS_USER,
+        )
+
+        # Default to secure settings: anonymous user + strict privacy
+        self._user_context = user_context if user_context is not None else ANONYMOUS_USER
+        self._privacy_config = privacy_config if privacy_config is not None else DEFAULT_PRIVACY_CONFIG
 
         # Ensure checkpoint directory exists
         self._checkpoint_dir.mkdir(parents=True, exist_ok=True)
@@ -253,6 +306,21 @@ class FileRunContext:
         """Registry of available tools for this agent."""
         return self._tool_registry
 
+    @property
+    def system_context(self) -> Optional["SystemContext"]:
+        """System context for multi-agent systems with shared knowledge."""
+        return self._system_context
+
+    @property
+    def user_context(self) -> "UserContext":
+        """User context for privacy and data isolation. Defaults to ANONYMOUS_USER."""
+        return self._user_context
+
+    @property
+    def privacy_config(self) -> "PrivacyConfig":
+        """Privacy configuration for this run. Defaults to DEFAULT_PRIVACY_CONFIG (strict)."""
+        return self._privacy_config
+
     def _checkpoint_path(self) -> Path:
         """Get the path to the checkpoint file for this run."""
         return self._checkpoint_dir / f"{self._run_id}.json"

agent_runtime_core/interfaces.py

@@ -323,13 +323,21 @@ class ToolRegistry:
         """
         return self.to_openai_format()
 
-    async def execute(self, name: str, arguments: dict) -> Any:
+    async def execute(
+        self,
+        name: str,
+        arguments: dict,
+        ctx: Optional["RunContext"] = None,
+        **kwargs
+    ) -> Any:
         """
         Execute a tool by name.
 
         Args:
             name: Tool name
             arguments: Tool arguments
+            ctx: Optional RunContext, passed to handlers with requires_context=True
+            **kwargs: Additional arguments to pass to the handler
 
         Returns:
             Tool result
@@ -340,7 +348,15 @@ class ToolRegistry:
         tool = self._tools.get(name)
         if not tool:
             raise KeyError(f"Tool not found: {name}")
-        return await tool.handler(**arguments)
+
+        # Check if the tool requires context
+        requires_context = tool.metadata.get('requires_context', False) if tool.metadata else False
+
+        if requires_context and ctx is not None:
+            # Pass ctx to the handler for tools that need it (e.g., sub-agent tools)
+            return await tool.handler(**arguments, ctx=ctx, **kwargs)
+        else:
+            return await tool.handler(**arguments, **kwargs)
 
     async def execute_with_events(
         self,
@@ -350,19 +366,19 @@ class ToolRegistry:
     ) -> Any:
         """
         Execute a tool and automatically emit events.
-        
+
         This is a convenience method that wraps execute() and handles
         event emission automatically. Use this in your agent loop to
         reduce boilerplate.
-        
+
         Args:
             tool_call: Tool call object with name, arguments, and id
             ctx: Run context for emitting events
             **kwargs: Additional arguments to pass to the tool
-        
+
         Returns:
             Tool result
-        
+
         Example:
             for tool_call in response.tool_calls:
                 result = await tools.execute_with_events(tool_call, ctx)
@@ -373,17 +389,17 @@ class ToolRegistry:
             "tool_args": tool_call.arguments,
             "tool_call_id": tool_call.id,
         })
-        
-        # Execute the tool
-        result = await self.execute(tool_call.name, tool_call.arguments, **kwargs)
-        
+
+        # Execute the tool, passing ctx for tools that require it
+        result = await self.execute(tool_call.name, tool_call.arguments, ctx=ctx, **kwargs)
+
         # Emit tool result event
         await ctx.emit(EventType.TOOL_RESULT, {
             "tool_name": tool_call.name,
             "tool_call_id": tool_call.id,
             "result": result,
         })
-        
+
         return result
 
 
@@ -501,6 +517,7 @@ class LLMResponse:
     model: str = ""
     finish_reason: str = ""
     raw_response: Optional[Any] = None
+    thinking: Optional[str] = None  # Extended thinking content (Anthropic)
 
     @property
     def tool_calls(self) -> Optional[list["LLMToolCall"]]:
@@ -528,6 +545,7 @@ class LLMStreamChunk:
     tool_calls: Optional[list] = None
     finish_reason: Optional[str] = None
     usage: Optional[dict] = None
+    thinking: Optional[str] = None  # Extended thinking content (Anthropic)
 
 
 class TraceSink(ABC):

agent_runtime_core/llm/anthropic.py

@@ -90,6 +90,83 @@ class AnthropicClient(LLMClient):
         
         return os.environ.get("ANTHROPIC_API_KEY")
 
+    def _validate_tool_call_pairs(self, messages: list[Message]) -> list[Message]:
+        """
+        Validate and repair tool_use/tool_result pairing in message history.
+
+        Anthropic requires that every tool_use block has a corresponding tool_result
+        block immediately after. This can be violated if a run fails mid-way through
+        tool execution (e.g., timeout, crash, API error during parallel tool calls).
+
+        This method removes orphaned tool_use blocks (assistant messages with tool_calls
+        that don't have corresponding tool results).
+
+        Args:
+            messages: List of messages in framework-neutral format
+
+        Returns:
+            Cleaned list of messages with orphaned tool_use blocks removed
+        """
+        if not messages:
+            return messages
+
+        # First pass: collect all tool_call_ids that have results
+        tool_result_ids = set()
+        for msg in messages:
+            if msg.get("role") == "tool" and msg.get("tool_call_id"):
+                tool_result_ids.add(msg["tool_call_id"])
+
+        # Second pass: check each assistant message with tool_calls
+        cleaned_messages = []
+        orphaned_count = 0
+
+        for msg in messages:
+            if msg.get("role") == "assistant" and msg.get("tool_calls"):
+                # Check which tool_calls have results
+                tool_calls = msg.get("tool_calls", [])
+                valid_tool_calls = []
+                orphaned_ids = []
+
+                for tc in tool_calls:
+                    # Handle both formats: {"id": ...} and {"function": {...}, "id": ...}
+                    tc_id = tc.get("id")
+                    if tc_id in tool_result_ids:
+                        valid_tool_calls.append(tc)
+                    else:
+                        orphaned_ids.append(tc_id)
+
+                if orphaned_ids:
+                    orphaned_count += len(orphaned_ids)
+                    print(
+                        f"[anthropic] Removing {len(orphaned_ids)} orphaned tool_use blocks "
+                        f"without results: {orphaned_ids[:3]}{'...' if len(orphaned_ids) > 3 else ''}",
+                        flush=True,
+                    )
+
+                if valid_tool_calls:
+                    # Keep the message but only with valid tool_calls
+                    cleaned_msg = msg.copy()
+                    cleaned_msg["tool_calls"] = valid_tool_calls
+                    cleaned_messages.append(cleaned_msg)
+                elif msg.get("content"):
+                    # No valid tool_calls but has text content - keep as regular message
+                    cleaned_msg = {
+                        "role": "assistant",
+                        "content": msg["content"],
+                    }
+                    cleaned_messages.append(cleaned_msg)
+                # else: skip the message entirely (no valid tool_calls, no content)
+            else:
+                cleaned_messages.append(msg)
+
+        if orphaned_count > 0:
+            print(
+                f"[anthropic] Cleaned {orphaned_count} orphaned tool_use blocks from message history",
+                flush=True,
+            )
+
+        return cleaned_messages
+
     async def generate(
         self,
         messages: list[Message],
@@ -99,11 +176,32 @@ class AnthropicClient(LLMClient):
         tools: Optional[list[dict]] = None,
         temperature: Optional[float] = None,
         max_tokens: Optional[int] = None,
+        thinking: bool = False,
+        thinking_budget: Optional[int] = None,
         **kwargs,
     ) -> LLMResponse:
-        """Generate a completion from Anthropic."""
+        """
+        Generate a completion from Anthropic.
+
+        Args:
+            messages: List of messages in framework-neutral format
+            model: Model ID to use (defaults to self.default_model)
+            stream: Whether to stream the response (not used here, use stream() method)
+            tools: List of tools in OpenAI format
+            temperature: Sampling temperature (0.0 to 1.0)
+            max_tokens: Maximum tokens to generate
+            thinking: Enable extended thinking mode for deeper reasoning
+            thinking_budget: Max tokens for thinking (default: 10000, max: 128000)
+            **kwargs: Additional parameters passed to the API
+
+        Returns:
+            LLMResponse with the generated message
+        """
         model = model or self.default_model
 
+        # Validate and repair message history before processing
+        messages = self._validate_tool_call_pairs(messages)
+
         # Extract system message and convert other messages
         system_message = None
         converted_messages = []
@@ -126,15 +224,28 @@ class AnthropicClient(LLMClient):
             request_kwargs["system"] = system_message
         if tools:
             request_kwargs["tools"] = self._convert_tools(tools)
-        if temperature is not None:
+
+        # Handle extended thinking mode
+        if thinking:
+            # Extended thinking requires specific configuration
+            # Temperature must be 1.0 when using thinking
+            request_kwargs["thinking"] = {
+                "type": "enabled",
+                "budget_tokens": thinking_budget or 10000,
+            }
+            # Temperature must be exactly 1.0 for extended thinking
+            request_kwargs["temperature"] = 1.0
+        elif temperature is not None:
             request_kwargs["temperature"] = temperature
 
         request_kwargs.update(kwargs)
 
         response = await self._client.messages.create(**request_kwargs)
 
+        message, thinking_content = self._convert_response(response)
+
         return LLMResponse(
-            message=self._convert_response(response),
+            message=message,
             usage={
                 "prompt_tokens": response.usage.input_tokens,
                 "completion_tokens": response.usage.output_tokens,
@@ -143,6 +254,7 @@ class AnthropicClient(LLMClient):
             model=response.model,
             finish_reason=response.stop_reason or "",
             raw_response=response,
+            thinking=thinking_content,
         )
 
     async def stream(
@@ -151,11 +263,31 @@ class AnthropicClient(LLMClient):
         *,
         model: Optional[str] = None,
         tools: Optional[list[dict]] = None,
+        thinking: bool = False,
+        thinking_budget: Optional[int] = None,
+        temperature: Optional[float] = None,
         **kwargs,
     ) -> AsyncIterator[LLMStreamChunk]:
-        """Stream a completion from Anthropic."""
+        """
+        Stream a completion from Anthropic.
+
+        Args:
+            messages: List of messages in framework-neutral format
+            model: Model ID to use
+            tools: List of tools in OpenAI format
+            thinking: Enable extended thinking mode
+            thinking_budget: Max tokens for thinking (default: 10000)
+            temperature: Sampling temperature (ignored if thinking=True)
+            **kwargs: Additional parameters
+
+        Yields:
+            LLMStreamChunk with delta content and thinking content
+        """
         model = model or self.default_model
 
+        # Validate and repair message history before processing
+        messages = self._validate_tool_call_pairs(messages)
+
         # Extract system message and convert other messages
         system_message = None
         converted_messages = []
@@ -179,6 +311,16 @@ class AnthropicClient(LLMClient):
         if tools:
             request_kwargs["tools"] = self._convert_tools(tools)
 
+        # Handle extended thinking mode
+        if thinking:
+            request_kwargs["thinking"] = {
+                "type": "enabled",
+                "budget_tokens": thinking_budget or 10000,
+            }
+            request_kwargs["temperature"] = 1.0
+        elif temperature is not None:
+            request_kwargs["temperature"] = temperature
+
         request_kwargs.update(kwargs)
 
         async with self._client.messages.stream(**request_kwargs) as stream:
@@ -186,6 +328,9 @@ class AnthropicClient(LLMClient):
                 if event.type == "content_block_delta":
                     if hasattr(event.delta, "text"):
                         yield LLMStreamChunk(delta=event.delta.text)
+                    elif hasattr(event.delta, "thinking"):
+                        # Extended thinking content
+                        yield LLMStreamChunk(delta="", thinking=event.delta.thinking)
                 elif event.type == "message_stop":
                     yield LLMStreamChunk(finish_reason="stop")
 
@@ -327,14 +472,23 @@ class AnthropicClient(LLMClient):
                 })
         return result
 
-    def _convert_response(self, response) -> Message:
-        """Convert Anthropic response to our format."""
+    def _convert_response(self, response) -> tuple[Message, Optional[str]]:
+        """
+        Convert Anthropic response to our format.
+
+        Returns:
+            Tuple of (message, thinking_content)
+        """
         content = ""
         tool_calls = []
+        thinking_content = None
 
         for block in response.content:
             if block.type == "text":
                 content += block.text
+            elif block.type == "thinking":
+                # Extended thinking block
+                thinking_content = block.thinking
             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)
@@ -355,4 +509,4 @@ class AnthropicClient(LLMClient):
         if tool_calls:
             result["tool_calls"] = tool_calls
 
-        return result
+        return result, thinking_content

agent_runtime_core/llm/models_config.py

@@ -22,19 +22,48 @@ class ModelInfo:
     supports_tools: bool = True
     supports_vision: bool = False
     supports_streaming: bool = True
+    supports_thinking: bool = False  # Extended thinking (Anthropic) or reasoning (OpenAI)
     description: str = ""
 
 
 # Registry of supported models
 SUPPORTED_MODELS: dict[str, ModelInfo] = {
-    # OpenAI Models
+    # OpenAI Models - GPT-5 (latest)
+    "gpt-5": ModelInfo(
+        id="gpt-5",
+        name="GPT-5",
+        provider="openai",
+        context_window=256000,
+        supports_vision=True,
+        supports_thinking=True,
+        description="Most capable OpenAI model with reasoning",
+    ),
+    "gpt-5-mini": ModelInfo(
+        id="gpt-5-mini",
+        name="GPT-5 Mini",
+        provider="openai",
+        context_window=256000,
+        supports_vision=True,
+        supports_thinking=True,
+        description="Fast GPT-5 variant with reasoning",
+    ),
+    "gpt-5-turbo": ModelInfo(
+        id="gpt-5-turbo",
+        name="GPT-5 Turbo",
+        provider="openai",
+        context_window=256000,
+        supports_vision=True,
+        supports_thinking=True,
+        description="Balanced GPT-5 variant for production",
+    ),
+    # OpenAI Models - GPT-4o
     "gpt-4o": ModelInfo(
         id="gpt-4o",
         name="GPT-4o",
         provider="openai",
         context_window=128000,
         supports_vision=True,
-        description="Most capable OpenAI model, multimodal",
+        description="Most capable GPT-4 model, multimodal",
     ),
     "gpt-4o-mini": ModelInfo(
         id="gpt-4o-mini",
@@ -52,12 +81,14 @@ SUPPORTED_MODELS: dict[str, ModelInfo] = {
         supports_vision=True,
         description="Previous generation flagship",
     ),
+    # OpenAI Models - o-series (reasoning)
     "o1": ModelInfo(
         id="o1",
         name="o1",
         provider="openai",
         context_window=200000,
         supports_tools=False,
+        supports_thinking=True,
         description="Advanced reasoning model",
     ),
     "o1-mini": ModelInfo(
@@ -66,6 +97,7 @@ SUPPORTED_MODELS: dict[str, ModelInfo] = {
         provider="openai",
         context_window=128000,
         supports_tools=False,
+        supports_thinking=True,
         description="Fast reasoning model",
     ),
     "o3-mini": ModelInfo(
@@ -74,6 +106,7 @@ SUPPORTED_MODELS: dict[str, ModelInfo] = {
         provider="openai",
         context_window=200000,
         supports_tools=True,
+        supports_thinking=True,
         description="Latest reasoning model with tool use",
     ),
     
@@ -84,6 +117,7 @@ SUPPORTED_MODELS: dict[str, ModelInfo] = {
         provider="anthropic",
         context_window=200000,
         supports_vision=True,
+        supports_thinking=True,
         description="Best balance of speed and capability for agents and coding",
     ),
     "claude-opus-4-5-20251101": ModelInfo(
@@ -92,6 +126,7 @@ SUPPORTED_MODELS: dict[str, ModelInfo] = {
         provider="anthropic",
         context_window=200000,
         supports_vision=True,
+        supports_thinking=True,
         description="Premium model - maximum intelligence with practical performance",
     ),
     "claude-haiku-4-5-20251001": ModelInfo(
@@ -100,6 +135,7 @@ SUPPORTED_MODELS: dict[str, ModelInfo] = {
         provider="anthropic",
         context_window=200000,
         supports_vision=True,
+        supports_thinking=True,
         description="Fastest model with near-frontier intelligence",
     ),
     # Anthropic Models - Claude 4 (previous generation)
@@ -109,6 +145,7 @@ SUPPORTED_MODELS: dict[str, ModelInfo] = {
         provider="anthropic",
         context_window=200000,
         supports_vision=True,
+        supports_thinking=True,
         description="Previous generation Sonnet",
     ),
     "claude-opus-4-20250514": ModelInfo(
@@ -117,6 +154,7 @@ SUPPORTED_MODELS: dict[str, ModelInfo] = {
         provider="anthropic",
         context_window=200000,
         supports_vision=True,
+        supports_thinking=True,
         description="Previous generation Opus",
     ),
     # Anthropic Models - Claude 3.5 (legacy)
@@ -126,6 +164,7 @@ SUPPORTED_MODELS: dict[str, ModelInfo] = {
         provider="anthropic",
         context_window=200000,
         supports_vision=True,
+        supports_thinking=True,
         description="Legacy model, still excellent",
     ),
     "claude-3-5-haiku-20241022": ModelInfo(
@@ -134,6 +173,7 @@ SUPPORTED_MODELS: dict[str, ModelInfo] = {
         provider="anthropic",
         context_window=200000,
         supports_vision=True,
+        supports_thinking=True,
         description="Legacy fast model",
     ),
 }
@@ -150,19 +190,20 @@ def get_model_info(model_id: str) -> Optional[ModelInfo]:
 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"):
+    if (model_id.startswith("gpt-") or model_id.startswith("o1") or
+        model_id.startswith("o3") or model_id.startswith("gpt5")):
         return "openai"
     if model_id.startswith("claude"):
         return "anthropic"
-    
+
     return None
 
 
@@ -174,6 +215,9 @@ def list_models_for_ui() -> list[dict]:
             "name": m.name,
             "provider": m.provider,
             "description": m.description,
+            "supports_thinking": m.supports_thinking,
+            "supports_tools": m.supports_tools,
+            "supports_vision": m.supports_vision,
         }
         for m in SUPPORTED_MODELS.values()
     ]