demo cli

agent/core/agent_loop.py

@@ -11,6 +11,7 @@ from litellm import (
     acompletion,
 )
 
+from agent.config import Config
 from agent.core.session import Event, OpType, Session
 
 ToolCall = ChatCompletionMessageToolCall
@@ -35,6 +36,7 @@ class Handlers:
         iteration = 0
         while iteration < max_iterations:
             messages = session.context_manager.get_messages()
+            print(f"Messages: {messages}")
 
             try:
                 response: ModelResponse = await acompletion(
@@ -65,9 +67,12 @@ class Handlers:
                     break
 
                 for tool_call in tool_calls:
+                    print(f"Executing tool: {tool_call.function.name}")
                     result = await session.tool_executor.execute_tool(tool_call)
-
-                    tool_output = Message(role="tool", content=result.output)
+                    print(result)
+                    tool_output = Message(
+                        role="tool", content=result.output, success=result.success
+                    )
                     session.context_manager.add_message(tool_output)
 
                     await session.send_event(
@@ -80,8 +85,13 @@ class Handlers:
                 iteration += 1
 
             except Exception as e:
+                import traceback
+
                 await session.send_event(
-                    Event(event_type="error", data={"error": str(e)})
+                    Event(
+                        event_type="error",
+                        data={"error": traceback.print_exc() + str(e)},
+                    )
                 )
                 break
 
@@ -132,7 +142,9 @@ class Handlers:
 
 
 async def submission_loop(
-    submission_queue: asyncio.Queue, event_queue: asyncio.Queue, config=None
+    submission_queue: asyncio.Queue,
+    event_queue: asyncio.Queue,
+    config: Config | None = None,
 ) -> None:
     """
     Main agent loop - processes submissions and dispatches to handlers.

agent/core/executor.py

@@ -2,20 +2,26 @@
 Task execution engine
 """
 
-from typing import Any, Dict, List
+from typing import Any, List
 
 from litellm import ChatCompletionMessageToolCall
+from pydantic import BaseModel
 
 ToolCall = ChatCompletionMessageToolCall
 
 
+class ToolResult(BaseModel):
+    output: str
+    success: bool
+
+
 class ToolExecutor:
     """Executes planned tasks using available tools"""
 
     def __init__(self, tools: List[Any] = None):
         self.tools = tools or []
 
-    async def execute_tool(self, tool_call: ToolCall) -> Dict[str, Any]:
+    async def execute_tool(self, tool_call: ToolCall) -> ToolResult:
         """Execute a single step in the plan"""
         # TODO: Implement step execution
-        return {"status": "success", "result": None}
+        return ToolResult(output="", success=True)

agent/core/session.py

@@ -4,9 +4,9 @@ from typing import Any, Literal
 
 from pydantic import BaseModel
 
+from agent.config import Config
 from agent.context_manager.manager import ContextManager
 from agent.core import ToolExecutor
-from agent.config import Config
 
 
 class OpType(Enum):
@@ -44,7 +44,9 @@ class Session:
         self.tool_executor = ToolExecutor()
         self.event_queue = event_queue
         self.config = config or Config(
-            model_name="gpt-3.5-turbo", tools=[], system_prompt_path=""
+            model_name="anthropic/claude-sonnet-4-5-20250929",
+            tools=[],
+            system_prompt_path="",
         )
         self.is_running = True
         self.current_task: asyncio.Task | None = None

agent/main.py

@@ -1,11 +1,12 @@
 """
-Simple runner for the agent with a single dummy input
+Interactive CLI chat with the agent
 """
 
 import asyncio
 from dataclasses import dataclass
 from typing import Any, Optional
 
+from agent.config import Config
 from agent.core.agent_loop import submission_loop
 from agent.core.session import OpType
 
@@ -26,63 +27,127 @@ class Submission:
     operation: Operation
 
 
+async def event_listener(
+    event_queue: asyncio.Queue, turn_complete_event: asyncio.Event
+) -> None:
+    """Background task that listens for events and displays them"""
+    while True:
+        try:
+            event = await event_queue.get()
+
+            # Display event
+            if event.event_type == "assistant_message":
+                msg = event.data.get("message", {})
+                content = msg.get("content", "")
+                if content:
+                    print(f"\n🤖 Assistant: {content}")
+            elif event.event_type == "tool_output":
+                msg = event.data.get("message", {})
+                content = msg.get("content", "")
+                if content:
+                    print(
+                        f"🔧 Tool: {content[:200]}{'...' if len(content) > 200 else ''}"
+                    )
+            elif event.event_type == "turn_complete":
+                print("✅ Turn complete\n")
+                turn_complete_event.set()
+            elif event.event_type == "error":
+                import traceback
+
+                traceback.print_exc()
+                print(f"❌ Error: {event.data.get('error', 'Unknown error')}")
+                turn_complete_event.set()
+            elif event.event_type == "shutdown":
+                print("🛑 Agent shutdown")
+                break
+            elif event.event_type == "processing":
+                print("⏳ Processing...", flush=True)
+            # Silently ignore other events
+
+        except asyncio.CancelledError:
+            break
+        except Exception as e:
+            print(f"⚠️ Event listener error: {e}")
+
+
+async def get_user_input() -> str:
+    """Get user input asynchronously"""
+    loop = asyncio.get_event_loop()
+    return await loop.run_in_executor(None, input, "You: ")
+
+
 async def main():
-    """Run agent with a single dummy input"""
+    """Interactive chat with the agent"""
 
-    print("🚀 Starting agent...")
+    print("=" * 60)
+    print("🤖 Interactive Agent Chat")
+    print("=" * 60)
+    print("Type your messages below. Type 'exit', 'quit', or '/quit' to end.\n")
 
     # Create queues for communication
     submission_queue = asyncio.Queue()
     event_queue = asyncio.Queue()
 
+    # Event to signal turn completion
+    turn_complete_event = asyncio.Event()
+    turn_complete_event.set()  # Ready for first input
+
     # 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?"},
-        ),
+    agent_task = asyncio.create_task(
+        submission_loop(
+            submission_queue,
+            event_queue,
+            config=Config(
+                model_name="anthropic/claude-sonnet-4-5-20250929",
+                tools=[],
+                system_prompt_path="",
+            ),
+        )
     )
-    await submission_queue.put(dummy_submission)
 
-    # Listen for events
-    print("\n👂 Listening for events...\n")
-    events_received = 0
-    max_events = 10  # Safety limit
+    # Start event listener in background
+    listener_task = asyncio.create_task(
+        event_listener(event_queue, turn_complete_event)
+    )
 
-    while events_received < max_events:
-        try:
-            event = await asyncio.wait_for(event_queue.get(), timeout=2.0)
-            events_received += 1
+    # Wait for agent to initialize
+    await asyncio.sleep(0.2)
 
-            # 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}")
+    submission_id = 0
+
+    try:
+        while True:
+            # Wait for previous turn to complete
+            await turn_complete_event.wait()
+            turn_complete_event.clear()
+
+            # Get user input
+            try:
+                user_input = await get_user_input()
+            except EOFError:
                 break
-            elif event.event_type == "error":
-                print(f"❌ Error: {event.data}")
+
+            # Check for exit commands
+            if user_input.strip().lower() in ["exit", "quit", "/quit", "/exit"]:
                 break
-            else:
-                print(f"📨 Event: {event.event_type} - {event.data}")
 
-        except asyncio.TimeoutError:
-            print("⏱️  No more events, timing out...")
-            break
+            # Skip empty input
+            if not user_input.strip():
+                turn_complete_event.set()
+                continue
+
+            # Submit to agent
+            submission_id += 1
+            submission = Submission(
+                id=f"sub_{submission_id}",
+                operation=Operation(
+                    op_type=OpType.USER_INPUT, data={"text": user_input}
+                ),
+            )
+            await submission_queue.put(submission)
+
+    except KeyboardInterrupt:
+        print("\n\n⚠️ Interrupted by user")
 
     # Shutdown
     print("\n🛑 Shutting down agent...")
@@ -91,18 +156,15 @@ async def main():
     )
     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 tasks to complete
+    await asyncio.wait_for(agent_task, timeout=2.0)
+    listener_task.cancel()
 
-    # Wait for agent task to complete
-    await agent_task
-
-    print("\n✨ Done!")
+    print("✨ Goodbye!\n")
 
 
 if __name__ == "__main__":
-    asyncio.run(main())
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        print("\n\n✨ Goodbye!")