working events and session

agent/__init__.py

@@ -2,6 +2,6 @@
 HF Agent - Main agent module
 """
 
-from agent.core.agent_loop import Agent
+from agent.core.agent_loop import submission_loop
 
-__all__ = ["Agent"]
+__all__ = ["submission_loop"]

agent/context_manager/__init__.py

@@ -1,7 +1,7 @@
 """
-Prompt templates and management
+Context manager for handling conversation history
 """
 
-from agent.prompts.manager import PromptManager
+from agent.context_manager.manager import ContextManager
 
-__all__ = ["PromptManager"]
+__all__ = ["ContextManager"]

agent/context_manager/manager.py

@@ -1,16 +1,16 @@
 """
-Prompt template management
+Context management for conversation history
 """
 
 from litellm import Message
 
 
 class ContextManager:
-    """Manages context templates for the agent"""
+    """Manages conversation context and message history for the agent"""
 
     def __init__(self):
         self.system_prompt = self._load_system_prompt()
-        self.messages: list[Message] = [
+        self.items: list[Message] = [
             Message(role="system", content=self.system_prompt)
         ]
 
@@ -21,7 +21,24 @@ class ContextManager:
         return "You are a helpful assistant."
 
     def add_message(self, message: Message) -> None:
-        self.messages.append(message)
+        """Add a message to the history"""
+        self.items.append(message)
 
     def get_messages(self) -> list[Message]:
-        return self.messages
+        """Get all messages for sending to LLM"""
+        return self.items
+
+    def compact(self, target_size: int) -> None:
+        """Remove old messages to keep history under target size"""
+        # Keep system prompt (first message) and remove oldest user/assistant messages
+        if len(self.items) <= target_size:
+            return
+
+        # Always keep system prompt
+        system_msg = self.items[0] if self.items and self.items[0].role == "system" else None
+        messages_to_keep = self.items[-(target_size - 1):]
+
+        if system_msg:
+            self.items = [system_msg] + messages_to_keep
+        else:
+            self.items = messages_to_keep

agent/core/agent_loop.py

@@ -132,13 +132,13 @@ class Handlers:
 
 
 async def submission_loop(
-    submission_queue: asyncio.Queue, event_queue: asyncio.Queue
+    submission_queue: asyncio.Queue, event_queue: asyncio.Queue, config=None
 ) -> None:
     """
     Main agent loop - processes submissions and dispatches to handlers.
     This is the core of the agent (like submission_loop in codex.rs:1259-1340)
     """
-    session = Session(event_queue)
+    session = Session(event_queue, config=config)
 
     print("🤖 Agent loop started")
 

agent/core/session.py

@@ -6,6 +6,7 @@ from pydantic import BaseModel
 
 from agent.context_manager.manager import ContextManager
 from agent.core import ToolExecutor
+from agent.config import Config
 
 
 class OpType(Enum):
@@ -20,13 +21,15 @@ class OpType(Enum):
 class Event(BaseModel):
     event_type: Literal[
         "processing",
+        "assistant_message",
+        "tool_output",
         "turn_complete",
         "compacted",
         "undo_complete",
         "shutdown",
         "error",
         "interrupted",
-    ]  # Dummy events for now
+    ]
     data: dict[str, Any] | None = None
 
 
@@ -36,10 +39,13 @@ class Session:
     Similar to Session in codex-rs/core/src/codex.rs
     """
 
-    def __init__(self, event_queue: asyncio.Queue):
+    def __init__(self, event_queue: asyncio.Queue, config: Config | None = None):
         self.context_manager = ContextManager()
         self.tool_executor = ToolExecutor()
         self.event_queue = event_queue
+        self.config = config or Config(
+            model_name="gpt-3.5-turbo", tools=[], system_prompt_path=""
+        )
         self.is_running = True
         self.current_task: asyncio.Task | None = None
 

agent/main.py

@@ -0,0 +1,108 @@
+"""
+Simple runner for the agent with a single dummy input
+"""
+
+import asyncio
+from dataclasses import dataclass
+from typing import Any, Optional
+
+from agent.core.agent_loop import submission_loop
+from agent.core.session import OpType
+
+
+@dataclass
+class Operation:
+    """Operation to be executed by the agent"""
+
+    op_type: OpType
+    data: Optional[dict[str, Any]] = None
+
+
+@dataclass
+class Submission:
+    """Submission to the agent loop"""
+
+    id: str
+    operation: Operation
+
+
+async def main():
+    """Run agent with a single dummy input"""
+
+    print("🚀 Starting agent...")
+
+    # Create queues for communication
+    submission_queue = asyncio.Queue()
+    event_queue = asyncio.Queue()
+
+    # Start agent loop in background
+    agent_task = asyncio.create_task(submission_loop(submission_queue, event_queue))
+
+    # Wait a moment for agent to initialize
+    await asyncio.sleep(0.1)
+
+    # Submit dummy input
+    print("\n📝 Submitting dummy input...")
+    dummy_submission = Submission(
+        id="sub_1",
+        operation=Operation(
+            op_type=OpType.USER_INPUT,
+            data={"text": "Hello! What tools do you have available?"},
+        ),
+    )
+    await submission_queue.put(dummy_submission)
+
+    # Listen for events
+    print("\n👂 Listening for events...\n")
+    events_received = 0
+    max_events = 10  # Safety limit
+
+    while events_received < max_events:
+        try:
+            event = await asyncio.wait_for(event_queue.get(), timeout=2.0)
+            events_received += 1
+
+            # Display event
+            if event.event_type == "assistant_message":
+                msg = event.data.get("message", {})
+                content = msg.get("content", "")
+                print(f"🤖 Assistant: {content}")
+            elif event.event_type == "tool_output":
+                msg = event.data.get("message", {})
+                content = msg.get("content", "")
+                print(f"🔧 Tool output: {content}")
+            elif event.event_type == "turn_complete":
+                print(f"✅ Turn complete: {event.data}")
+                break
+            elif event.event_type == "error":
+                print(f"❌ Error: {event.data}")
+                break
+            else:
+                print(f"📨 Event: {event.event_type} - {event.data}")
+
+        except asyncio.TimeoutError:
+            print("⏱️  No more events, timing out...")
+            break
+
+    # Shutdown
+    print("\n🛑 Shutting down agent...")
+    shutdown_submission = Submission(
+        id="sub_shutdown", operation=Operation(op_type=OpType.SHUTDOWN)
+    )
+    await submission_queue.put(shutdown_submission)
+
+    # Wait for shutdown event
+    try:
+        event = await asyncio.wait_for(event_queue.get(), timeout=1.0)
+        print(f"✅ {event.event_type}")
+    except asyncio.TimeoutError:
+        pass
+
+    # Wait for agent task to complete
+    await agent_task
+
+    print("\n✨ Done!")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())