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

agent_runtime_core/runner.py

@@ -8,14 +8,17 @@ The runner handles:
 - Managing state and checkpoints
 - Handling errors and retries
 - Cancellation
+- Loading conversation history (enabled by default)
+- Persisting messages after runs (enabled by default)
 """
 
 import asyncio
+import logging
 import traceback
 from dataclasses import dataclass, field
 from datetime import datetime, timezone
 from typing import Optional
-from uuid import UUID
+from uuid import UUID, uuid4
 
 from agent_runtime_core.config import get_config
 from agent_runtime_core.events.base import EventBus
@@ -30,6 +33,16 @@ from agent_runtime_core.interfaces import (
 from agent_runtime_core.queue.base import RunQueue, QueuedRun
 from agent_runtime_core.registry import get_runtime
 from agent_runtime_core.state.base import StateStore
+from agent_runtime_core.persistence import (
+    PersistenceManager,
+    ConversationStore,
+    Conversation,
+    ConversationMessage,
+    ToolCall,
+    get_persistence_manager,
+)
+
+logger = logging.getLogger(__name__)
 
 
 @dataclass
@@ -127,26 +140,31 @@ class RunContextImpl:
 class AgentRunner:
     """
     Runs agent executions with full lifecycle management.
-    
+
     The runner:
     1. Claims runs from the queue
     2. Looks up the appropriate runtime
-    3. Executes the runtime with a context
-    4. Handles errors, retries, and cancellation
-    5. Emits events throughout
+    3. Loads conversation history (enabled by default)
+    4. Executes the runtime with a context
+    5. Handles errors, retries, and cancellation
+    6. Persists messages after successful runs
+    7. Emits events throughout
     """
-    
+
     def __init__(
         self,
         queue: RunQueue,
         event_bus: EventBus,
         state_store: StateStore,
         config: Optional[RunnerConfig] = None,
+        persistence_manager: Optional[PersistenceManager] = None,
     ):
         self.queue = queue
         self.event_bus = event_bus
         self.state_store = state_store
         self.config = config or RunnerConfig()
+        self._persistence = persistence_manager or get_persistence_manager()
+        self._runtime_config = get_config()
         self._running = False
         self._current_run: Optional[UUID] = None
     
@@ -205,9 +223,9 @@ class AgentRunner:
             
             # Update status
             await self.state_store.update_run_status(run_id, "running")
-            
-            # Build context
-            ctx = self._build_context(queued_run)
+
+            # Build context (loads conversation history if enabled)
+            ctx = await self._build_context(queued_run)
             
             # Emit started event
             await ctx.emit(EventType.RUN_STARTED, {
@@ -246,14 +264,25 @@ class AgentRunner:
         finally:
             self._current_run = None
     
-    def _build_context(self, queued_run: QueuedRun) -> RunContextImpl:
+    async def _build_context(self, queued_run: QueuedRun) -> RunContextImpl:
         """Build a RunContext for a queued run."""
         input_data = queued_run.input
-        
+        new_messages = input_data.get("messages", [])
+        conversation_id = input_data.get("conversation_id")
+
+        # Parse conversation_id if it's a string
+        if conversation_id and isinstance(conversation_id, str):
+            conversation_id = UUID(conversation_id)
+
+        # Load conversation history if enabled
+        messages = await self._load_conversation_history(
+            conversation_id, new_messages
+        )
+
         return RunContextImpl(
             run_id=queued_run.run_id,
-            conversation_id=input_data.get("conversation_id"),
-            input_messages=input_data.get("messages", []),
+            conversation_id=conversation_id,
+            input_messages=messages,
             params=input_data.get("params", {}),
             metadata=queued_run.metadata,
             tool_registry=ToolRegistry(),  # TODO: Load from config
@@ -261,6 +290,90 @@ class AgentRunner:
             state_store=self.state_store,
             queue=self.queue,
         )
+
+    async def _load_conversation_history(
+        self,
+        conversation_id: Optional[UUID],
+        new_messages: list[Message],
+    ) -> list[Message]:
+        """
+        Load conversation history and prepend to new messages.
+
+        This enables multi-turn conversations by default. When a run is part of
+        a conversation, previous messages from that conversation are automatically
+        included in the context.
+
+        Args:
+            conversation_id: The conversation ID (if any)
+            new_messages: The new messages for this run
+
+        Returns:
+            Combined list of history + new messages
+        """
+        # Check if conversation history is enabled
+        if not self._runtime_config.include_conversation_history:
+            logger.debug("Conversation history disabled by config")
+            return new_messages
+
+        if not conversation_id:
+            logger.debug("No conversation_id, skipping history load")
+            return new_messages
+
+        try:
+            # Get conversation from persistence
+            conversation = await self._persistence.conversations.get(conversation_id)
+
+            if conversation is None:
+                logger.debug(f"Conversation {conversation_id} not found")
+                return new_messages
+
+            # Convert stored messages to the Message format
+            history: list[Message] = []
+            for msg in conversation.messages:
+                message_dict: Message = {
+                    "role": msg.role,
+                    "content": msg.content,
+                }
+
+                # Include tool_calls for assistant messages
+                if msg.tool_calls:
+                    message_dict["tool_calls"] = [
+                        {
+                            "id": tc.id,
+                            "type": "function",
+                            "function": {
+                                "name": tc.name,
+                                "arguments": tc.arguments if isinstance(tc.arguments, str) else str(tc.arguments),
+                            }
+                        }
+                        for tc in msg.tool_calls
+                    ]
+
+                # Include tool_call_id for tool messages
+                if msg.tool_call_id:
+                    message_dict["tool_call_id"] = msg.tool_call_id
+
+                history.append(message_dict)
+
+            if not history:
+                logger.debug("No conversation history found")
+                return new_messages
+
+            # Apply message limit if configured
+            max_messages = self._runtime_config.max_history_messages
+            if max_messages and len(history) > max_messages:
+                logger.debug(f"Limiting history from {len(history)} to {max_messages} messages")
+                history = history[-max_messages:]
+
+            logger.debug(f"Loaded {len(history)} history messages for conversation {conversation_id}")
+
+            # Combine history with new messages
+            return history + new_messages
+
+        except Exception as e:
+            logger.warning(f"Failed to load conversation history: {e}")
+            # Fall back to just new messages on error
+            return new_messages
     
     async def _heartbeat_loop(self, run_id: UUID) -> None:
         """Send periodic heartbeats to extend the lease."""
@@ -293,18 +406,83 @@ class AgentRunner:
     ) -> None:
         """Handle successful run completion."""
         await self.state_store.update_run_status(queued_run.run_id, "succeeded")
-        
+
+        # Persist messages to conversation store if enabled
+        if self._runtime_config.auto_persist_messages and ctx.conversation_id:
+            await self._persist_messages(ctx.conversation_id, result.final_messages)
+
         await ctx.emit(EventType.RUN_SUCCEEDED, {
             "final_output": result.final_output,
             "usage": result.usage,
         })
-        
+
         await self.queue.release(
             run_id=queued_run.run_id,
             worker_id=self.config.worker_id,
             success=True,
             output=result.final_output,
         )
+
+    async def _persist_messages(
+        self,
+        conversation_id: UUID,
+        messages: list[Message],
+    ) -> None:
+        """
+        Persist messages to the conversation store.
+
+        This saves the final_messages from a run to enable conversation history
+        for future runs.
+
+        Args:
+            conversation_id: The conversation to save to
+            messages: The messages to persist (typically result.final_messages)
+        """
+        try:
+            # Get or create conversation
+            conversation = await self._persistence.conversations.get(conversation_id)
+
+            if conversation is None:
+                # Create new conversation
+                conversation = Conversation(
+                    id=conversation_id,
+                    title="",
+                    messages=[],
+                )
+
+            # Convert messages to ConversationMessage format
+            for msg in messages:
+                # Skip system messages - they're added by the agent each run
+                if msg.get("role") == "system":
+                    continue
+
+                # Parse tool_calls if present
+                tool_calls = []
+                if msg.get("tool_calls"):
+                    for tc in msg["tool_calls"]:
+                        tool_calls.append(ToolCall(
+                            id=tc.get("id", ""),
+                            name=tc.get("function", {}).get("name", ""),
+                            arguments=tc.get("function", {}).get("arguments", "{}"),
+                            timestamp=datetime.now(timezone.utc),
+                        ))
+
+                conv_message = ConversationMessage(
+                    id=uuid4(),
+                    role=msg.get("role", "user"),
+                    content=msg.get("content", ""),
+                    timestamp=datetime.now(timezone.utc),
+                    tool_calls=tool_calls,
+                    tool_call_id=msg.get("tool_call_id"),
+                )
+                conversation.messages.append(conv_message)
+
+            # Save conversation
+            await self._persistence.conversations.save(conversation)
+            logger.debug(f"Persisted {len(messages)} messages to conversation {conversation_id}")
+
+        except Exception as e:
+            logger.warning(f"Failed to persist messages: {e}")
     
     async def _handle_timeout(
         self,

agent_runtime_core/tool_calling_agent.py

@@ -4,12 +4,13 @@ ToolCallingAgent - A base class for agents that use tool calling.
 This eliminates the boilerplate of implementing the tool-calling loop
 in every agent. Just define your system prompt and tools, and the base
 class handles the rest.
+
+Uses run_agentic_loop internally for the actual loop logic.
 """
 
-import json
 import logging
 from abc import abstractmethod
-from typing import Optional
+from typing import Any, Optional
 
 from agent_runtime_core.interfaces import (
     AgentRuntime,
@@ -19,6 +20,7 @@ from agent_runtime_core.interfaces import (
     ToolRegistry,
     LLMClient,
 )
+from agent_runtime_core.agentic_loop import run_agentic_loop
 
 logger = logging.getLogger(__name__)
 
@@ -26,231 +28,187 @@ logger = logging.getLogger(__name__)
 class ToolCallingAgent(AgentRuntime):
     """
     Base class for agents that use tool calling.
-    
+
     Handles the standard tool-calling loop so you don't have to implement it
     in every agent. Just override the abstract properties and you're done.
-    
+
+    Uses run_agentic_loop internally, with hooks for customization.
+
     Example:
         class MyAgent(ToolCallingAgent):
             @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 create_my_tools()
     """
-    
+
     @property
     @abstractmethod
     def system_prompt(self) -> str:
         """
         System prompt for the agent.
-        
+
         This is prepended to the conversation messages.
         """
         ...
-    
+
     @property
     @abstractmethod
     def tools(self) -> ToolRegistry:
         """
         Tools available to the agent.
-        
+
         Return a ToolRegistry with all tools registered.
         """
         ...
-    
+
     @property
     def max_iterations(self) -> int:
         """
         Maximum number of tool-calling iterations.
-        
+
         Override to change the default limit.
         """
-        return 10
-    
+        return 15
+
     @property
     def model(self) -> Optional[str]:
         """
         Model to use for this agent.
-        
+
         If None, uses the default model from configuration.
         Override to use a specific model.
         """
         return None
-    
+
     @property
     def temperature(self) -> Optional[float]:
         """
         Temperature for LLM generation.
-        
+
         If None, uses the LLM client's default.
         Override to set a specific temperature.
         """
         return None
-    
+
     def get_llm_client(self) -> LLMClient:
         """
         Get the LLM client to use.
-        
+
         Override to customize LLM client selection.
         Default uses the configured client.
         """
         from agent_runtime_core.llm import get_llm_client
         return get_llm_client()
-    
+
     async def before_run(self, ctx: RunContext) -> None:
         """
         Hook called before the agent run starts.
-        
+
         Override to add custom initialization logic.
         """
         pass
-    
+
     async def after_run(self, ctx: RunContext, result: RunResult) -> RunResult:
         """
         Hook called after the agent run completes.
-        
+
         Override to add custom finalization logic.
         Can modify the result before returning.
         """
         return result
-    
+
     async def on_tool_call(self, ctx: RunContext, tool_name: str, tool_args: dict) -> None:
         """
         Hook called before each tool execution.
-        
+
         Override to add custom logic (logging, validation, etc.).
         """
         pass
-    
-    async def on_tool_result(self, ctx: RunContext, tool_name: str, result: any) -> any:
+
+    async def on_tool_result(self, ctx: RunContext, tool_name: str, result: Any) -> Any:
         """
         Hook called after each tool execution.
-        
+
         Override to transform or validate tool results.
         Can return a modified result.
         """
         return result
-    
+
     async def run(self, ctx: RunContext) -> RunResult:
         """
         Execute the agent with tool calling support.
-        
-        This implements the standard tool-calling loop:
-        1. Build messages with system prompt
-        2. Call LLM with tools
-        3. If tool calls, execute them and loop
-        4. If no tool calls, return final response
+
+        Uses run_agentic_loop internally with hooks for customization.
         """
-        logger.info(f"[{self.key}] Starting run, input messages: {len(ctx.input_messages)}")
-        
+        logger.debug(f"[{self.key}] Starting run, input messages: {len(ctx.input_messages)}")
+
         # Call before_run hook
         await self.before_run(ctx)
-        
+
         # Get LLM client
         llm = self.get_llm_client()
-        
+
         # Build messages with system prompt
+        # Use system_prompt_with_memory if available (from MemoryEnabledAgent mixin)
+        prompt = (
+            self.system_prompt_with_memory
+            if hasattr(self, 'system_prompt_with_memory')
+            else self.system_prompt
+        )
         messages = [
-            {"role": "system", "content": self.system_prompt}
-        ] + ctx.input_messages
-        
-        logger.info(f"[{self.key}] Built {len(messages)} messages (including system prompt)")
-        
-        # Run the agent loop (tool calling)
-        iteration = 0
-        final_response = None
-        
-        while iteration < self.max_iterations:
-            iteration += 1
-            logger.info(f"[{self.key}] Iteration {iteration}/{self.max_iterations}")
-            
-            # Generate response with tools
-            logger.info(f"[{self.key}] Calling LLM...")
-            response = await llm.generate(
-                messages=messages,
-                tools=self.tools.to_openai_format(),
-                model=self.model,
-                temperature=self.temperature,
-            )
-            logger.info(f"[{self.key}] LLM response received, tool_calls: {bool(response.message.get('tool_calls'))}")
-            
-            # Check if the model wants to call tools
-            if response.message.get('tool_calls'):
-                # Add the assistant message with tool calls
-                messages.append(response.message)
-                
-                # Execute the tools
-                tool_results = []
-                for tool_call in response.message.get('tool_calls'):
-                    # Emit tool call event
-                    await ctx.emit(EventType.TOOL_CALL, {
-                        "tool_name": tool_call["function"]["name"],
-                        "tool_args": json.loads(tool_call["function"]["arguments"]),
-                        "tool_call_id": tool_call["id"],
-                    })
-                    
-                    # Call before_tool_call hook
-                    await self.on_tool_call(ctx, tool_call["function"]["name"], json.loads(tool_call["function"]["arguments"]))
-                    
-                    # Execute the tool
-                    result = await self.tools.execute(
-                        tool_call["function"]["name"],
-                        json.loads(tool_call["function"]["arguments"]),
-                    )
-                    
-                    # Call after_tool_result hook
-                    result = await self.on_tool_result(ctx, tool_call["function"]["name"], result)
-                    
-                    tool_results.append({
-                        "tool_call_id": tool_call["id"],
-                        "result": result,
-                    })
-                    
-                    # Emit tool result event
-                    await ctx.emit(EventType.TOOL_RESULT, {
-                        "tool_name": tool_call["function"]["name"],
-                        "tool_call_id": tool_call["id"],
-                        "result": result,
-                    })
-                
-                # Add tool results to messages
-                for tr in tool_results:
-                    messages.append({
-                        "role": "tool",
-                        "tool_call_id": tr["tool_call_id"],
-                        "content": str(tr["result"]),
-                    })
-            else:
-                # No tool calls - we have the final response
-                final_response = response.message["content"]
-                logger.info(f"[{self.key}] Final response received: {final_response[:100] if final_response else 'None'}...")
-                break
-        
-        # Emit the final assistant message
-        if final_response:
-            logger.info(f"[{self.key}] Emitting ASSISTANT_MESSAGE event")
-            await ctx.emit(EventType.ASSISTANT_MESSAGE, {
-                "content": final_response,
-            })
-            logger.info(f"[{self.key}] Event emitted successfully")
-        else:
-            logger.warning(f"[{self.key}] No final response to emit!")
-        
-        logger.info(f"[{self.key}] Returning RunResult")
+            {"role": "system", "content": prompt}
+        ] + list(ctx.input_messages)
+
+        # Create tool executor that calls our hooks
+        async def execute_tool(name: str, args: dict) -> Any:
+            # Call before hook
+            await self.on_tool_call(ctx, name, args)
+
+            # Execute the tool
+            result = await self.tools.execute(name, args)
+
+            # Call after hook (can transform result)
+            result = await self.on_tool_result(ctx, name, result)
+
+            return result
+
+        # Get tool schemas
+        tool_schemas = self.tools.to_openai_format() if self.tools.list_tools() else None
+
+        # Build LLM kwargs
+        llm_kwargs = {}
+        if self.temperature is not None:
+            llm_kwargs["temperature"] = self.temperature
+
+        # Run the agentic loop
+        # Note: agentic_loop emits ASSISTANT_MESSAGE for the final response
+        loop_result = await run_agentic_loop(
+            llm=llm,
+            messages=messages,
+            tools=tool_schemas,
+            execute_tool=execute_tool,
+            ctx=ctx,
+            model=self.model,
+            max_iterations=self.max_iterations,
+            emit_events=True,
+            **llm_kwargs,
+        )
+
         result = RunResult(
-            final_output={"response": final_response},
-            final_messages=messages,
-            usage=response.usage if response else {},
+            final_output={"response": loop_result.final_content},
+            final_messages=loop_result.messages,
+            usage=loop_result.usage,
         )
-        
+
         # Call after_run hook
         result = await self.after_run(ctx, result)
-        
+
         return result