agent-runtime-core 0.8.0__py3-none-any.whl → 0.9.0__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/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],
@@ -104,6 +181,9 @@ class AnthropicClient(LLMClient):
         """Generate a completion from Anthropic."""
         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 = []
@@ -156,6 +236,9 @@ class AnthropicClient(LLMClient):
         """Stream a completion from Anthropic."""
         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 = []