added session and memory

agent_framework/__init__.py

@@ -7,9 +7,22 @@ from .models import (
     ContentItem,
     Event,
     ExecutionContext,
+    Session,
+    ToolConfirmation,
+    PendingToolCall,
+    BaseSessionManager,
+    InMemorySessionManager,
 )
 from .tools import BaseTool, FunctionTool, tool
-from .llm import LlmClient, LlmRequest, LlmResponse
+from .llm import LlmClient, LlmRequest, LlmResponse, build_messages
+from .memory import (
+    count_tokens,
+    apply_sliding_window,
+    apply_compaction,
+    apply_summarization,
+    ContextOptimizer,
+)
+from .callbacks import create_optimizer_callback
 from .agent import Agent, AgentResult
 from .mcp import load_mcp_tools
 from .utils import (
@@ -18,6 +31,7 @@ from .utils import (
     function_to_tool_definition,
     mcp_tools_to_openai_format,
     display_trace,
+    format_trace,
 )
 
 __all__ = [
@@ -28,6 +42,11 @@ __all__ = [
     "ContentItem",
     "Event",
     "ExecutionContext",
+    "Session",
+    "ToolConfirmation",
+    "PendingToolCall",
+    "BaseSessionManager",
+    "InMemorySessionManager",
     # Tools
     "BaseTool",
     "FunctionTool",
@@ -36,17 +55,26 @@ __all__ = [
     "LlmClient",
     "LlmRequest",
     "LlmResponse",
+    "build_messages",
     # Agent
     "Agent",
     "AgentResult",
     # MCP
     "load_mcp_tools",
+    # Memory
+    "count_tokens",
+    "apply_sliding_window",
+    "apply_compaction",
+    "apply_summarization",
+    "ContextOptimizer",
+    "create_optimizer_callback",
     # Utils
     "function_to_input_schema",
     "format_tool_definition",
     "function_to_tool_definition",
     "mcp_tools_to_openai_format",
     "display_trace",
+    "format_trace",
 ]
 
 __version__ = "0.1.0"

agent_framework/agent.py

@@ -1,20 +1,22 @@
 """Agent class for executing multi-step reasoning with tools."""
 
 from dataclasses import dataclass
-from typing import List, Optional, Type, Callable
-from xxlimited import Str
-from pydantic import BaseModel
+from typing import List, Optional, Type, Callable, Literal
+from pydantic import BaseModel, Field
 from .tools import tool
 import inspect
 import json
 
-from pydantic_core.core_schema import str_schema
 from .models import (
     ExecutionContext, 
     Event, 
     Message, 
     ToolCall, 
-    ToolResult
+    ToolResult,
+    PendingToolCall,
+    ToolConfirmation,
+    BaseSessionManager,
+    InMemorySessionManager
 )
 from .tools import BaseTool
 from .llm import LlmClient, LlmRequest, LlmResponse
@@ -25,6 +27,8 @@ class AgentResult:
     """Result of an agent execution."""
     output: str | BaseModel
     context: ExecutionContext
+    status: Literal["complete", "pending", "error"] = "complete"
+    pending_tool_calls: list[PendingToolCall] = Field(default_factory=list)
 
 
 class Agent:
@@ -39,7 +43,9 @@ class Agent:
         name: str = "agent", 
         output_type: Optional[Type[BaseModel]] = None,
         before_tool_callbacks: List[Callable] = None,
-        after_tool_callbacks: List[Callable] = None
+        after_tool_callbacks: List[Callable] = None,
+        session_manager: BaseSessionManager | None = None
+
 
     ):
         self.model = model
@@ -53,6 +59,10 @@ class Agent:
         self.before_tool_callbacks = before_tool_callbacks or []
         self.after_tool_callbacks = after_tool_callbacks or []
 
+        # Session manager
+        self.session_manager = session_manager or InMemorySessionManager()
+
+
     def _setup_tools(self, tools: List[BaseTool]) -> List[BaseTool]:
         if self.output_type is not None:
             @tool(
@@ -71,9 +81,38 @@ class Agent:
     async def run(
         self, 
         user_input: str, 
-        context: ExecutionContext = None
-    ) -> str:
-        """Run the agent with user input."""
+        context: ExecutionContext = None,
+        session_id: Optional[str] = None,
+        tool_confirmations: Optional[List[ToolConfirmation]] = None
+    ) -> AgentResult:
+        """Execute the agent with optional session support.
+        
+        Args:
+            user_input: User's input message
+            context: Optional execution context (creates new if None)
+            session_id: Optional session ID for persistent conversations
+            tool_confirmations: Optional list of tool confirmations for pending calls
+        """
+        # Load or create session if session_id is provided
+        session = None
+        if session_id and self.session_manager:
+            session = await self.session_manager.get_or_create(session_id)
+            # Load session data into context if context is new
+            if context is None:
+                context = ExecutionContext()
+                # Restore events and state from session
+                context.events = session.events.copy()
+                context.state = session.state.copy()
+                context.execution_id = session.session_id
+            context.session_id = session_id
+    
+        if tool_confirmations:
+            if context is None:
+                context = ExecutionContext()
+            context.state["tool_confirmations"] = [
+                c.model_dump() for c in tool_confirmations
+            ]
+        
         # Create or reuse context
         if context is None:
             context = ExecutionContext()
@@ -89,12 +128,34 @@ class Agent:
         # Execute steps until completion or max steps reached
         while not context.final_result and context.current_step < self.max_steps:
             await self.step(context)
-            
+            # Check for pending confirmations after each step
+            if context.state.get("pending_tool_calls"):
+                pending_calls = [
+                    PendingToolCall.model_validate(p)
+                    for p in context.state["pending_tool_calls"]
+                ]
+                # Save session state before returning
+                if session:
+                    session.events = context.events
+                    session.state = context.state
+                    await self.session_manager.save(session)
+                return AgentResult(
+                    status="pending",
+                    context=context,
+                    pending_tool_calls=pending_calls,
+                )
             # Check if the last event is a final response
             last_event = context.events[-1]
             if self._is_final_response(last_event):
                 context.final_result = self._extract_final_result(last_event)
         
+        # Save session after execution completes
+        if session:
+            session.events = context.events
+            session.state = context.state
+            await self.session_manager.save(session)
+
+     
         return AgentResult(output=context.final_result, context=context)
 
 
@@ -128,6 +189,23 @@ class Agent:
 
     async def step(self, context: ExecutionContext):
         """Execute one step of the agent loop."""
+        
+        # Process pending confirmations if both are present (before preparing request)
+        if ("pending_tool_calls" in context.state and "tool_confirmations" in context.state):
+            confirmation_results = await self._process_confirmations(context)
+            
+            # Add results as an event so they appear in contents
+            if confirmation_results:
+                confirmation_event = Event(
+                    execution_id=context.execution_id,
+                    author=self.name,
+                    content=confirmation_results,
+                )
+                context.add_event(confirmation_event)
+            
+            # Clear processed state
+            del context.state["pending_tool_calls"]
+            del context.state["tool_confirmations"]
       
         llm_request = self._prepare_llm_request(context)
        
@@ -194,7 +272,8 @@ class Agent:
 ) -> List[ToolResult]:
         tools_dict = {tool.name: tool for tool in self.tools}
         results = []
-        
+        pending_calls = []  # ADD THIS
+
         for tool_call in tool_calls:
             if tool_call.name not in tools_dict:
                 raise ValueError(f"Tool '{tool_call.name}' not found")
@@ -212,7 +291,17 @@ class Agent:
                 if result is not None:
                     tool_response = result
                     break
-            
+                # Check if confirmation is required
+            if tool.requires_confirmation:
+                pending = PendingToolCall(
+                    tool_call=tool_call,
+                    confirmation_message=tool.get_confirmation_message(
+                        tool_call.arguments
+                    )
+                )
+                pending_calls.append(pending)
+                continue
+                
             # Stage 2: Execute actual tool only if callback didn't provide a result
             if tool_response is None:
                 try:
@@ -238,9 +327,73 @@ class Agent:
                     break
             
             results.append(tool_result)
+        if pending_calls:
+            context.state["pending_tool_calls"] = [p.model_dump() for p in pending_calls]
         
         return results
-            
+    
+    async def _process_confirmations(
+    self,
+    context: ExecutionContext
+) -> List[ToolResult]:
+        tools_dict = {tool.name: tool for tool in self.tools}
+        results = []
+    
+        # Restore pending tool calls from state
+        pending_map = {
+            p["tool_call"]["tool_call_id"]: PendingToolCall.model_validate(p)
+            for p in context.state["pending_tool_calls"]
+        }
+    
+        # Build confirmation lookup by tool_call_id
+        confirmation_map = {
+            c["tool_call_id"]: ToolConfirmation.model_validate(c)
+            for c in context.state["tool_confirmations"]
+        }
+    
+        # Process ALL pending tool calls
+        for tool_call_id, pending in pending_map.items():
+            tool = tools_dict.get(pending.tool_call.name)
+            confirmation = confirmation_map.get(tool_call_id)
+    
+            if confirmation and confirmation.approved:
+                # Merge original arguments with modifications
+                arguments = {
+                    **pending.tool_call.arguments,
+                    **(confirmation.modified_arguments or {})
+                }
+    
+                # Execute the approved tool
+                try:
+                    output = await tool(context, **arguments)
+                    results.append(ToolResult(
+                        tool_call_id=tool_call_id,
+                        name=pending.tool_call.name,
+                        status="success",
+                        content=[output],
+                    ))
+                except Exception as e:
+                    results.append(ToolResult(
+                        tool_call_id=tool_call_id,
+                        name=pending.tool_call.name,
+                        status="error",
+                        content=[str(e)],
+                    ))
+            else:
+                # Rejected: either explicitly or not in confirmation list
+                if confirmation:
+                    reason = confirmation.reason or "Tool execution was rejected by user."
+                else:
+                    reason = "Tool execution was not approved."
+    
+                results.append(ToolResult(
+                    tool_call_id=tool_call_id,
+                    name=pending.tool_call.name,
+                    status="error",
+                    content=[reason],
+                ))
+    
+        return results
     # List of dangerous tools requiring approval
 DANGEROUS_TOOLS = ["delete_file", "send_email", "execute_sql"]
  

agent_framework/callbacks.py

@@ -0,0 +1,42 @@
+"""Callback utilities for agent execution."""
+
+import inspect
+from typing import Optional, Callable
+
+from .models import ExecutionContext
+from .llm import LlmRequest, LlmResponse
+from .memory import count_tokens
+
+
+def create_optimizer_callback(
+    apply_optimization: Callable,
+    threshold: int = 50000,
+    model_id: str = "gpt-4"
+) -> Callable:
+    """Factory function that creates a callback applying optimization strategy.
+    
+    Args:
+        apply_optimization: Function that modifies the LlmRequest in place
+        threshold: Token count threshold to trigger optimization
+        model_id: Model identifier for token counting
+    
+    Returns:
+        Callback function that can be used as before_llm_callback
+    """
+    async def callback(
+        context: ExecutionContext,
+        request: LlmRequest
+    ) -> Optional[LlmResponse]:
+        token_count = count_tokens(request, model_id=model_id)
+ 
+        if token_count < threshold:
+            return None
+ 
+        # Support both sync and async functions
+        result = apply_optimization(context, request)
+        if inspect.isawaitable(result):
+            await result
+        return None
+
+    return callback
+ 

agent_framework/llm.py

@@ -8,6 +8,49 @@ from litellm import acompletion
 from .models import Message, ToolCall, ToolResult, ContentItem
 
 
+def build_messages(request: 'LlmRequest') -> List[dict]:
+    """Convert LlmRequest to API message format.
+    
+    Standalone function for use by memory/callback modules.
+    """
+    messages = []
+    
+    for instruction in request.instructions:
+        messages.append({"role": "system", "content": instruction})
+    
+    for item in request.contents:
+        if isinstance(item, Message):
+            messages.append({"role": item.role, "content": item.content})
+            
+        elif isinstance(item, ToolCall):
+            tool_call_dict = {
+                "id": item.tool_call_id,
+                "type": "function",
+                "function": {
+                    "name": item.name,
+                    "arguments": json.dumps(item.arguments)
+                }
+            }
+            # Append to previous assistant message if exists
+            if messages and messages[-1]["role"] == "assistant":
+                messages[-1].setdefault("tool_calls", []).append(tool_call_dict)
+            else:
+                messages.append({
+                    "role": "assistant",
+                    "content": None,
+                    "tool_calls": [tool_call_dict]
+                })
+                
+        elif isinstance(item, ToolResult):
+            messages.append({
+                "role": "tool",
+                "tool_call_id": item.tool_call_id,
+                "content": str(item.content[0]) if item.content else ""
+            })
+    
+    return messages
+
+
 class LlmRequest(BaseModel):
     """Request object for LLM calls."""
     instructions: List[str] = Field(default_factory=list)
@@ -51,42 +94,7 @@ class LlmClient:
 
     def _build_messages(self, request: LlmRequest) -> List[dict]:
         """Convert LlmRequest to API message format."""
-        messages = []
-        
-        for instruction in request.instructions:
-            messages.append({"role": "system", "content": instruction})
-        
-        for item in request.contents:
-            if isinstance(item, Message):
-                messages.append({"role": item.role, "content": item.content})
-                
-            elif isinstance(item, ToolCall):
-                tool_call_dict = {
-                    "id": item.tool_call_id,
-                    "type": "function",
-                    "function": {
-                        "name": item.name,
-                        "arguments": json.dumps(item.arguments)
-                    }
-                }
-                # Append to previous assistant message if exists
-                if messages and messages[-1]["role"] == "assistant":
-                    messages[-1].setdefault("tool_calls", []).append(tool_call_dict)
-                else:
-                    messages.append({
-                        "role": "assistant",
-                        "content": None,
-                        "tool_calls": [tool_call_dict]
-                    })
-                    
-            elif isinstance(item, ToolResult):
-                messages.append({
-                    "role": "tool",
-                    "tool_call_id": item.tool_call_id,
-                    "content": str(item.content[0]) if item.content else ""
-                })
-        
-        return messages
+        return build_messages(request)
 
     def _parse_response(self, response) -> LlmResponse:
         """Convert API response to LlmResponse."""

agent_framework/memory.py

@@ -0,0 +1,283 @@
+"""Memory optimization strategies for agent conversations."""
+
+import json
+from typing import Optional, Dict, List
+from .models import ExecutionContext, Message, ToolCall, ToolResult, ContentItem
+from .llm import LlmRequest, LlmResponse, LlmClient, build_messages
+
+
+def apply_sliding_window(
+    context: ExecutionContext,
+    request: LlmRequest,
+    window_size: int = 20
+) -> None:
+    """Sliding window that keeps only the most recent N messages"""
+    
+    contents = request.contents
+    
+    # Find user message position
+    user_message_idx = None
+    for i, item in enumerate(contents):
+        if isinstance(item, Message) and item.role == "user":
+            user_message_idx = i
+            break
+    
+    if user_message_idx is None:
+        return
+    
+    # Preserve up to user message
+    preserved = contents[:user_message_idx + 1]
+    
+    # Keep only the most recent N from remaining items
+    remaining = contents[user_message_idx + 1:]
+    if len(remaining) > window_size:
+        remaining = remaining[-window_size:]
+    
+    request.contents = preserved + remaining
+
+
+def count_tokens(request: LlmRequest, model_id: str = "gpt-4") -> int:
+    """Calculate total token count of LlmRequest.
+    
+    Args:
+        request: The LLM request to count tokens for
+        model_id: Model identifier for selecting encoding (default: "gpt-4")
+    
+    Returns:
+        Estimated total token count
+    """
+    import tiktoken
+    
+    # Select encoding for model, use default on failure
+    try:
+        encoding = tiktoken.encoding_for_model(model_id)
+    except KeyError:
+        encoding = tiktoken.get_encoding("o200k_base")
+ 
+    # Convert to API message format then count tokens
+    messages = build_messages(request)
+    total_tokens = 0
+ 
+    for message in messages:
+        # Per-message overhead (role, separators, etc.)
+        total_tokens += 4
+ 
+        # Content tokens
+        if message.get("content"):
+            total_tokens += len(encoding.encode(message["content"]))
+ 
+        # tool_calls tokens
+        if message.get("tool_calls"):
+            for tool_call in message["tool_calls"]:
+                func = tool_call.get("function", {})
+                if func.get("name"):
+                    total_tokens += len(encoding.encode(func["name"]))
+                if func.get("arguments"):
+                    total_tokens += len(encoding.encode(func["arguments"]))
+ 
+    # Tool definition tokens
+    if request.tools:
+        for tool in request.tools:
+            tool_def = tool.tool_definition
+            total_tokens += len(encoding.encode(json.dumps(tool_def)))
+ 
+    return total_tokens
+
+# Tools to compress ToolCall arguments
+TOOLCALL_COMPACTION_RULES = {
+    "create_file": "[Content saved to file]",
+}
+ 
+# Tools to compress ToolResult content
+TOOLRESULT_COMPACTION_RULES = {
+    "read_file": "File content from {file_path}. Re-read if needed.",
+    "search_web": "Search results processed. Query: {query}. Re-search if needed.",
+    "tavily_search": "Search results processed. Query: {query}. Re-search if needed.",
+}
+ 
+def apply_compaction(context: ExecutionContext, request: LlmRequest) -> None:
+    """Compress tool calls and results into reference messages"""
+    
+    tool_call_args: Dict[str, Dict] = {}
+    compacted = []
+    
+    for item in request.contents:
+        if isinstance(item, ToolCall):
+            # Save arguments (for use when compressing ToolResult later)
+            tool_call_args[item.tool_call_id] = item.arguments
+            
+            # If the ToolCall itself is a compression target (create_file, etc.)
+            if item.name in TOOLCALL_COMPACTION_RULES:
+                compressed_args = {
+                    k: TOOLCALL_COMPACTION_RULES[item.name] if k == "content" else v
+                    for k, v in item.arguments.items()
+                }
+                compacted.append(ToolCall(
+                    tool_call_id=item.tool_call_id,
+                    name=item.name,
+                    arguments=compressed_args
+                ))
+            else:
+                compacted.append(item)
+                
+        elif isinstance(item, ToolResult):
+            # If ToolResult is a compression target (read_file, search_web, etc.)
+            if item.name in TOOLRESULT_COMPACTION_RULES:
+                args = tool_call_args.get(item.tool_call_id, {})
+                template = TOOLRESULT_COMPACTION_RULES[item.name]
+                compressed_content = template.format(
+                    file_path=args.get("file_path", args.get("path", "unknown")),
+                    query=args.get("query", "unknown")
+                )
+                compacted.append(ToolResult(
+                    tool_call_id=item.tool_call_id,
+                    name=item.name,
+                    status=item.status,
+                    content=[compressed_content]
+                ))
+            else:
+                compacted.append(item)
+        else:
+            compacted.append(item)
+    
+    request.contents = compacted
+ 
+SUMMARIZATION_PROMPT = """You are summarizing an AI agent's work progress.
+ 
+Given the following execution history, extract:
+1. Key findings: Important information discovered
+2. Tools used: List of tools that were called
+3. Current status: What has been accomplished and what remains
+ 
+Be concise. Focus on information that will help the agent continue its work.
+ 
+Execution History:
+{history}
+ 
+Provide a structured summary."""
+
+async def apply_summarization(
+    context: ExecutionContext,
+    request: LlmRequest,
+    llm_client: LlmClient,
+    keep_recent: int = 5
+) -> None:
+    """Replace old messages with a summary"""
+ 
+    contents = request.contents
+ 
+    # Find user message position
+    user_idx = None
+    for i, item in enumerate(contents):
+        if isinstance(item, Message) and item.role == "user":
+            user_idx = i
+            break
+ 
+    if user_idx is None:
+        return
+ 
+    # Check previous summary position (skip already-summarized portions)
+    last_summary_idx = context.state.get("last_summary_idx", user_idx)
+ 
+    # Calculate summarization target range
+    summary_start = last_summary_idx + 1
+    summary_end = len(contents) - keep_recent
+ 
+    # Overlap prevention: exit if nothing to summarize or range is invalid
+    if summary_end <= summary_start:
+        return
+ 
+    # Determine portions to preserve (no overlap)
+    preserved_start = contents[:last_summary_idx + 1]
+    preserved_end = contents[summary_end:]
+    to_summarize = contents[summary_start:summary_end]
+ 
+    # Generate summary
+    history_text = format_history_for_summary(to_summarize)
+    summary = await generate_summary(llm_client, history_text)
+ 
+    # Add summary to instructions
+    request.append_instructions(f"[Previous work summary]\n{summary}")
+ 
+    # Keep only preserved portions in contents
+    request.contents = preserved_start + preserved_end
+ 
+    # Record summary position
+    context.state["last_summary_idx"] = len(preserved_start) - 1
+ 
+ 
+def format_history_for_summary(items: List[ContentItem]) -> str:
+    """Convert ContentItem list to text for summarization"""
+    lines = []
+    for item in items:
+        if isinstance(item, Message):
+            lines.append(f"[{item.role}]: {item.content[:500]}...")
+        elif isinstance(item, ToolCall):
+            lines.append(f"[Tool Call]: {item.name}({item.arguments})")
+        elif isinstance(item, ToolResult):
+            content_preview = str(item.content[0])[:200] if item.content else ""
+            lines.append(f"[Tool Result]: {item.name} -> {content_preview}...")
+    return "\n".join(lines)
+ 
+ 
+async def generate_summary(llm_client: LlmClient, history: str) -> str:
+    """Generate history summary using LLM"""
+    
+    request = LlmRequest(
+        instructions=[SUMMARIZATION_PROMPT.format(history=history)],
+        contents=[Message(role="user", content="Please summarize.")]
+    )
+    
+    response = await llm_client.generate(request)
+    
+    for item in response.content:
+        if isinstance(item, Message):
+            return item.content
+    
+    return ""
+
+class ContextOptimizer:
+    """Hierarchical context optimization strategy"""
+ 
+    def __init__(
+        self,
+        llm_client: LlmClient,
+        token_threshold: int = 50000,
+        enable_compaction: bool = True,
+        enable_summarization: bool = True,
+        keep_recent: int = 5
+    ):
+        self.llm_client = llm_client
+        self.token_threshold = token_threshold
+        self.enable_compaction = enable_compaction
+        self.enable_summarization = enable_summarization
+        self.keep_recent = keep_recent
+ 
+    async def __call__(
+        self,
+        context: ExecutionContext,
+        request: LlmRequest
+    ) -> Optional[LlmResponse]:
+        """Register as before_llm_callback"""
+ 
+        # Step 1: Measure tokens
+        if count_tokens(request) < self.token_threshold:
+            return None
+ 
+        # Step 2: Apply Compaction
+        if self.enable_compaction:
+            apply_compaction(context, request)
+ 
+            if count_tokens(request) < self.token_threshold:
+                return None
+ 
+        # Step 3: Apply Summarization
+        if self.enable_summarization:
+            await apply_summarization(
+                context,
+                request,
+                self.llm_client,
+                self.keep_recent
+            )
+ 
+        return None

agent_framework/models.py

@@ -33,6 +33,19 @@ class ToolResult(BaseModel):
 
 ContentItem = Union[Message, ToolCall, ToolResult]
 
+class ToolConfirmation(BaseModel):
+    """User's decision on a pending tool call."""
+    
+    tool_call_id: str
+    approved: bool
+    modified_arguments: dict | None = None
+    reason: str | None = None  # Reason for rejection (if not approved)
+
+class PendingToolCall(BaseModel):
+    """A tool call awaiting user confirmation."""
+    
+    tool_call: ToolCall
+    confirmation_message: str
 
 class Event(BaseModel):
     """A recorded occurrence during agent execution."""
@@ -52,6 +65,7 @@ class ExecutionContext:
     current_step: int = 0
     state: Dict[str, Any] = field(default_factory=dict)
     final_result: Optional[str | BaseModel] = None
+    session_id: Optional[str] = None  # Link to session for persistence
     
     def add_event(self, event: Event):
         """Append an event to the execution history."""
@@ -60,3 +74,78 @@ class ExecutionContext:
     def increment_step(self):
         """Move to the next execution step."""
         self.current_step += 1
+
+class Session(BaseModel):
+    """Container for persistent conversation state across multiple run() calls."""
+    
+    session_id: str
+    user_id: str | None = None
+    events: list[Event] = Field(default_factory=list)
+    state: dict[str, Any] = Field(default_factory=dict)
+    created_at: datetime = Field(default_factory=datetime.now)
+    updated_at: datetime = Field(default_factory=datetime.now)
+
+from abc import ABC, abstractmethod
+ 
+class BaseSessionManager(ABC):
+    """Abstract base class for session management."""
+    
+    @abstractmethod
+    async def create(
+        self, 
+        session_id: str, 
+        user_id: str | None = None
+    ) -> Session:
+        """Create a new session."""
+        pass
+    
+    @abstractmethod
+    async def get(self, session_id: str) -> Session | None:
+        """Retrieve a session by ID. Returns None if not found."""
+        pass
+    
+    @abstractmethod
+    async def save(self, session: Session) -> None:
+        """Persist session changes to storage."""
+        pass
+    
+    async def get_or_create(
+        self, 
+        session_id: str, 
+        user_id: str | None = None
+    ) -> Session:
+        """Get existing session or create new one."""
+        session = await self.get(session_id)
+        if session is None:
+            session = await self.create(session_id, user_id)
+        return session
+
+class InMemorySessionManager(BaseSessionManager):
+    """In-memory session storage for development and testing."""
+    
+    def __init__(self):
+        self._sessions: dict[str, Session] = {}
+    
+    async def create(
+        self, 
+        session_id: str, 
+        user_id: str | None = None
+    ) -> Session:
+        """Create a new session."""
+        if session_id in self._sessions:
+            raise ValueError(f"Session {session_id} already exists")
+        
+        session = Session(
+            session_id=session_id,
+            user_id=user_id
+        )
+        self._sessions[session_id] = session
+        return session
+    
+    async def get(self, session_id: str) -> Session | None:
+        """Retrieve a session by ID."""
+        return self._sessions.get(session_id)
+    
+    async def save(self, session: Session) -> None:
+        """Save session to storage."""
+        self._sessions[session.session_id] = session

agent_framework/tools.py

@@ -15,10 +15,18 @@ class BaseTool(ABC):
         name: str = None, 
         description: str = None, 
         tool_definition: Dict[str, Any] = None,
+        # Confirmation support
+        requires_confirmation: bool = False,
+        confirmation_message_template: str = None
     ):
         self.name = name or self.__class__.__name__
         self.description = description or self.__doc__ or ""
         self._tool_definition = tool_definition
+        self.requires_confirmation = requires_confirmation
+        self.confirmation_message_template = confirmation_message_template or (
+            "The agent wants to execute '{name}' with arguments: {arguments}. "
+            "Do you approve?"
+        )
     
     @property
     def tool_definition(self) -> Dict[str, Any] | None:
@@ -31,7 +39,12 @@ class BaseTool(ABC):
     async def __call__(self, context: ExecutionContext, **kwargs) -> Any:
         return await self.execute(context, **kwargs)
 
-
+    def get_confirmation_message(self, arguments: dict[str, Any]) -> str:
+        """Generate a confirmation message for this tool call."""
+        return self.confirmation_message_template.format(
+            name=self.name,
+            arguments=arguments
+        )
 class FunctionTool(BaseTool):
     """Wraps a Python function as a BaseTool."""
     
@@ -40,7 +53,9 @@ class FunctionTool(BaseTool):
         func: Callable, 
         name: str = None, 
         description: str = None,
-        tool_definition: Dict[str, Any] = None
+        tool_definition: Dict[str, Any] = None,
+        requires_confirmation: bool = False,
+        confirmation_message_template: str = None
     ):
         self.func = func
         self.needs_context = 'context' in inspect.signature(func).parameters
@@ -52,7 +67,9 @@ class FunctionTool(BaseTool):
         super().__init__(
             name=self.name, 
             description=self.description, 
-            tool_definition=tool_definition
+            tool_definition=tool_definition,
+            requires_confirmation=requires_confirmation,
+            confirmation_message_template=confirmation_message_template
         )
     
     async def execute(self, context: ExecutionContext = None, **kwargs) -> Any:
@@ -86,7 +103,9 @@ def tool(
     *,
     name: str = None,
     description: str = None,
-    tool_definition: Dict[str, Any] = None
+    tool_definition: Dict[str, Any] = None,
+    requires_confirmation: bool = False,
+    confirmation_message: str = None
 ):
     """Decorator to convert a function into a FunctionTool.
     
@@ -99,6 +118,11 @@ def tool(
         @tool(name="custom_name", description="Custom description")
         def my_function(x: int) -> int:
             return x * 2
+        
+        # With confirmation:
+        @tool(requires_confirmation=True, confirmation_message="Delete file?")
+        def delete_file(filename: str) -> str:
+            ...
     """
     from typing import Union
     
@@ -107,9 +131,12 @@ def tool(
             func=f,
             name=name,
             description=description,
-            tool_definition=tool_definition
+            tool_definition=tool_definition,
+            requires_confirmation=requires_confirmation,
+            confirmation_message_template=confirmation_message
         )
     
     if func is not None:
         return decorator(func)
-    return decorator
+    return decorator
+

agent_framework/utils.py

@@ -79,41 +79,57 @@ def mcp_tools_to_openai_format(mcp_tools) -> list[dict]:
     ]
 
 
-def display_trace(context):
-    """Display the execution trace of an agent run.
+def format_trace(context) -> str:
+    """Format execution trace as a string.
     
     Args:
-        context: ExecutionContext to display
+        context: ExecutionContext to format
+        
+    Returns:
+        Formatted trace string
     """
-    from .models import Event, Message, ToolCall, ToolResult
+    from .models import Message, ToolCall, ToolResult
     
-    print(f"\n{'='*60}")
-    print(f"Execution Trace (ID: {context.execution_id})")
-    print(f"{'='*60}\n")
+    lines = []
+    lines.append("=" * 60)
+    lines.append(f"Execution Trace (ID: {context.execution_id})")
+    lines.append("=" * 60)
+    lines.append("")
     
     for i, event in enumerate(context.events, 1):
-        print(f"Step {i} - {event.author.upper()} ({event.timestamp:.2f})")
-        print(f"{'-'*60}")
+        lines.append(f"Step {i} - {event.author.upper()} ({event.timestamp:.2f})")
+        lines.append("-" * 60)
         
         for item in event.content:
             if isinstance(item, Message):
                 content_preview = item.content[:100] + "..." if len(item.content) > 100 else item.content
-                print(f"  [Message] ({item.role}): {content_preview}")
+                lines.append(f"  [Message] ({item.role}): {content_preview}")
             elif isinstance(item, ToolCall):
-                print(f"  [Tool Call] {item.name}")
-                print(f"     Arguments: {item.arguments}")
+                lines.append(f"  [Tool Call] {item.name}")
+                lines.append(f"     Arguments: {item.arguments}")
             elif isinstance(item, ToolResult):
                 status_marker = "[SUCCESS]" if item.status == "success" else "[ERROR]"
-                print(f"  {status_marker} Tool Result: {item.name} ({item.status})")
+                lines.append(f"  {status_marker} Tool Result: {item.name} ({item.status})")
                 if item.content:
                     content_preview = str(item.content[0])[:100]
                     if len(str(item.content[0])) > 100:
                         content_preview += "..."
-                    print(f"     Output: {content_preview}")
+                    lines.append(f"     Output: {content_preview}")
         
-        print()
+        lines.append("")
     
-    print(f"{'='*60}")
-    print(f"Final Result: {context.final_result}")
-    print(f"Total Steps: {context.current_step}")
-    print(f"{'='*60}\n")
+    lines.append("=" * 60)
+    lines.append(f"Final Result: {context.final_result}")
+    lines.append(f"Total Steps: {context.current_step}")
+    lines.append("=" * 60)
+    
+    return "\n".join(lines)
+
+
+def display_trace(context):
+    """Display the execution trace of an agent run.
+    
+    Args:
+        context: ExecutionContext to display
+    """
+    print(format_trace(context))

agent_tools/example_usage.py

@@ -20,13 +20,13 @@ async def main():
     agent = Agent(
         model=LlmClient(model="gpt-5-mini"),  # Use a valid model name
         tools=[search_web, list_files, read_file, delete_file],
-        instructions="You are a helpful assistant that have speciality in deleting files",
+        instructions="You are a helpful assistant that can search the web and explore files to answer questions.",
         max_steps=20,
         before_tool_callbacks=[approval_callback],
         after_tool_callbacks=[search_compressor],
     )
     
-    result = await agent.run("delete README.md from the agent_tools directory")   
+    result = await agent.run("search about andrej karpathy")   
     print(result.output)
 
 if __name__ == "__main__":

agent_tools/file_tools.py

@@ -319,8 +319,15 @@ def _analyze_pdf(file_path: str, query: str) -> str:
     )
     return response.choices[0].message.content
 
-@tool
-def delete_file(file_path: str) -> str:
-    """Deletes a file. This action cannot be undone."""
-    # Only returns message instead of actual deletion (for demo)
-    return f"File {file_path} has been deleted."
+@tool(
+    name="delete_file",
+    description="Delete a file from the filesystem",
+    requires_confirmation=True,
+    confirmation_message="The agent wants to delete a file. Arguments: {arguments}. "
+                        "This action cannot be undone. Do you approve?"
+)
+def delete_file(filename: str) -> str:
+    """Delete the specified file."""
+    import os
+    os.remove(filename)
+    return f"Successfully deleted {filename}"

agent_tools/web_tools.py

@@ -75,24 +75,62 @@ def _extract_search_query(context: ExecutionContext, tool_call_id: str) -> str:
                 return item.arguments.get("query", "")
     return ""
 
+## callbacks
+# def search_compressor(context: ExecutionContext, tool_result: ToolResult):
+#     """Callback that compresses web search results."""
+#     # Pass through unchanged if not a search tool
+#     if tool_result.name != "search_web":
+#         return None
+    
+#     original_content = tool_result.content[0]
+    
+#     # No compression needed if result is short enough
+#     if len(original_content) < 2000:
+#         return None
+    
+#     # Extract search query matching the tool_call_id
+#     query = _extract_search_query(context, tool_result.tool_call_id)
+#     if not query:
+#         return None
+    
+#     # Use functions implemented in section 5.3
+#     chunks = fixed_length_chunking(original_content, chunk_size=500, overlap=50)
+#     embeddings = get_embeddings(chunks)
+#     results = vector_search(query, chunks, embeddings, top_k=3)
+    
+#     # Create compressed result
+#     compressed = "\n\n".join([r['chunk'] for r in results])
+    
+#     return ToolResult(
+#         tool_call_id=tool_result.tool_call_id,
+#         name=tool_result.name,
+#         status="success",
+#         content=[compressed]
+#     )
+
 ## callbacks
 def search_compressor(context: ExecutionContext, tool_result: ToolResult):
     """Callback that compresses web search results."""
     # Pass through unchanged if not a search tool
     if tool_result.name != "search_web":
+        print("DEBUG: Callback skipped - not a search_web tool")
         return None
     
     original_content = tool_result.content[0]
+    print(f"DEBUG: Callback triggered! Original content length: {len(original_content)}")
     
     # No compression needed if result is short enough
     if len(original_content) < 2000:
+        print("DEBUG: Callback skipped - content too short")
         return None
     
     # Extract search query matching the tool_call_id
     query = _extract_search_query(context, tool_result.tool_call_id)
     if not query:
+        print("DEBUG: Callback skipped - could not extract query")
         return None
     
+    print(f"DEBUG: Compressing search results for query: {query}")
     # Use functions implemented in section 5.3
     chunks = fixed_length_chunking(original_content, chunk_size=500, overlap=50)
     embeddings = get_embeddings(chunks)
@@ -100,6 +138,7 @@ def search_compressor(context: ExecutionContext, tool_result: ToolResult):
     
     # Create compressed result
     compressed = "\n\n".join([r['chunk'] for r in results])
+    print(f"DEBUG: Compressed from {len(original_content)} to {len(compressed)} chars")
     
     return ToolResult(
         tool_call_id=tool_result.tool_call_id,

example_agent.py

@@ -0,0 +1,41 @@
+"""Simple example to test the agent framework.
+
+This script demonstrates basic agent usage with tools.
+"""
+
+import asyncio
+import sys
+from pathlib import Path
+
+# Add parent directory to path
+sys.path.insert(0, str(Path(__file__).parent))
+
+from agent_framework import Agent, LlmClient, display_trace
+from agent_tools import calculator, search_web
+
+
+async def main():
+    """Run a simple agent example."""
+    
+    print("=" * 60)
+    print("Agent Framework - Simple Test")
+    print("=" * 60)
+    print()
+    
+    # Create agent with calculator and web search tools
+    agent = Agent(
+        model=LlmClient(model="gpt-4o-mini"),  # Use a cost-effective model for testing
+        tools=[calculator, search_web],
+        instructions="You are a helpful assistant. Use websearch tool to search web for sure.",
+        max_steps=10
+    )
+ 
+    result1 = await agent.run("What are the finalists of australian open 2026 mens singles")
+    print(f"\nAnswer: {result1.output}")
+    print(f"Steps taken: {result1.context}")
+    
+  
+
+if __name__ == "__main__":
+    asyncio.run(main())
+

pyproject.toml

@@ -7,6 +7,7 @@ requires-python = ">=3.11"
 dependencies = [
     "chromadb>=1.0.20",
     "datasets>=4.5.0",
+    "fastapi>=0.100.0",
     "fastmcp>=2.11.3",
     "ipykernel>=7.1.0",
     "litellm>=1.81.3",
@@ -17,9 +18,11 @@ dependencies = [
     "pydantic>=2.11.7",
     "pymupdf>=1.26.7",
     "python-dotenv>=1.1.1",
+    "python-multipart>=0.0.6",
     "scikit-learn>=1.0.0",
     "tavily-python>=0.7.11",
     "tqdm>=4.67.1",
+    "uvicorn>=0.23.0",
     "wikipedia>=1.4.0",
 ]
 

rag/embeddings.py

@@ -41,8 +41,4 @@ sentences = [
 embeddings = get_embeddings(sentences)
  
 cat_kitten = cosine_similarity([embeddings[0]], [embeddings[1]])[0][0]
-cat_dog = cosine_similarity([embeddings[0]], [embeddings[2]])[0][0]
- 
-print(f"Cat vs Kitten: {cat_kitten:.3f}")
-print(f"Cat vs Dog: {cat_dog:.3f}")
- 
+cat_dog = cosine_similarity([embeddings[0]], [embeddings[2]])[0][0]

test_session.py

@@ -0,0 +1,108 @@
+"""Test session manager to verify context persistence across conversations."""
+
+import asyncio
+import sys
+from pathlib import Path
+
+# Add parent directory to path
+sys.path.insert(0, str(Path(__file__).parent))
+
+from agent_framework import Agent, LlmClient, InMemorySessionManager, display_trace
+from agent_tools import calculator
+
+
+async def main():
+    """Test session persistence."""
+    
+    print("=" * 60)
+    print("Session Manager Test - Context Persistence")
+    print("=" * 60)
+    
+    # Create a shared session manager
+    session_manager = InMemorySessionManager()
+    
+    # Create agent with session support
+    agent = Agent(
+        model=LlmClient(model="gpt-4o-mini"),
+        tools=[calculator],
+        instructions="You are a helpful assistant with memory. Remember what users tell you.",
+        max_steps=5,
+        session_manager=session_manager
+    )
+    
+    session_id = "test-user-123"
+    
+    # === Conversation 1: Introduce yourself ===
+    print("\n" + "-" * 60)
+    print("Conversation 1: User introduces themselves")
+    print("-" * 60)
+    
+    result1 = await agent.run(
+        "Hi! My name is Alice and I'm a software engineer. I love Python.",
+        session_id=session_id
+    )
+    print(f"User: Hi! My name is Alice and I'm a software engineer. I love Python.")
+    print(f"Agent: {result1.output}")
+    print(f"Events in context: {len(result1.context.events)}")
+    
+    # === Conversation 2: Ask about something else ===
+    print("\n" + "-" * 60)
+    print("Conversation 2: Continue conversation")
+    print("-" * 60)
+    
+    result2 = await agent.run(
+        "What's 1234 * 5678?",
+        session_id=session_id
+    )
+    print(f"User: What's 1234 * 5678?")
+    print(f"Agent: {result2.output}")
+    print(f"Events in context: {len(result2.context.events)}")
+    
+    # === Conversation 3: Test if it remembers ===
+    print("\n" + "-" * 60)
+    print("Conversation 3: Test memory - Does it remember?")
+    print("-" * 60)
+    
+    result3 = await agent.run(
+        "What's my name and what do I do for work?",
+        session_id=session_id
+    )
+    print(f"User: What's my name and what do I do for work?")
+    print(f"Agent: {result3.output}")
+    print(f"Events in context: {len(result3.context.events)}")
+    
+    # === Test with a DIFFERENT session ===
+    print("\n" + "-" * 60)
+    print("Conversation 4: Different session (should NOT remember)")
+    print("-" * 60)
+    
+    result4 = await agent.run(
+        "What's my name?",
+        session_id="different-user-456"  # Different session!
+    )
+    print(f"User: What's my name?")
+    print(f"Agent: {result4.output}")
+    print(f"Events in context: {len(result4.context.events)}")
+    
+    # === Show session storage ===
+    print("\n" + "=" * 60)
+    print("Session Storage Summary")
+    print("=" * 60)
+    
+    # Access internal storage to show what's stored
+    for sid, session in session_manager._sessions.items():
+        print(f"\nSession ID: {sid}")
+        print(f"  Events: {len(session.events)}")
+        print(f"  State keys: {list(session.state.keys())}")
+        print(f"  Created: {session.created_at}")
+    
+    # === Optional: Show full trace ===
+    print("\n" + "=" * 60)
+    print("Full Trace for Session 'test-user-123' (Last Conversation)")
+    print("=" * 60)
+    display_trace(result3.context)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+

web_app/README.md

@@ -0,0 +1,63 @@
+# Agent Chat Web Application
+
+A modern chat interface for interacting with the AI agent framework.
+
+## Features
+
+- Real-time chat with AI agent
+- Session memory toggle (on/off)
+- File upload support
+- Display of available tools
+- Tool usage indicators in responses
+
+## Running the Application
+
+### Option 1: Direct run
+
+```bash
+cd web_app
+python app.py
+```
+
+### Option 2: With uvicorn (recommended)
+
+```bash
+uvicorn web_app.app:app --reload --host 0.0.0.0 --port 8000
+```
+
+Then open http://localhost:8000 in your browser.
+
+## API Endpoints
+
+| Endpoint | Method | Description |
+|----------|--------|-------------|
+| `/` | GET | Chat interface |
+| `/api/tools` | GET | List available tools |
+| `/api/chat` | POST | Send message to agent |
+| `/api/upload` | POST | Upload a file |
+| `/api/uploads` | GET | List uploaded files |
+| `/api/uploads/{filename}` | DELETE | Delete uploaded file |
+| `/api/sessions` | GET | List active sessions |
+| `/api/sessions/{session_id}` | DELETE | Clear a session |
+
+## Chat Request Format
+
+```json
+{
+    "message": "Your message here",
+    "session_id": "optional-session-id",
+    "use_session": true
+}
+```
+
+## Chat Response Format
+
+```json
+{
+    "response": "Agent's response",
+    "session_id": "session-uuid",
+    "events_count": 4,
+    "tools_used": ["calculator", "search_web"]
+}
+```
+

web_app/app.py

@@ -0,0 +1,244 @@
+"""FastAPI web application for the Agent Framework."""
+
+import os
+import sys
+import uuid
+import shutil
+from pathlib import Path
+from typing import Optional, List
+from datetime import datetime
+
+# Add parent directory to path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from fastapi import FastAPI, UploadFile, File, Form, HTTPException
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import HTMLResponse, FileResponse
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from dotenv import load_dotenv
+
+from agent_framework import (
+    Agent, LlmClient, InMemorySessionManager, 
+    display_trace, ExecutionContext, format_trace
+)
+from agent_tools import calculator, search_web, read_file, list_files, unzip_file, read_media_file
+
+# Load environment variables
+load_dotenv()
+
+app = FastAPI(title="Agent Chat", description="AI Agent with Tools")
+
+# Enable CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Global session manager (shared across requests)
+session_manager = InMemorySessionManager()
+
+# Upload directory for files
+UPLOAD_DIR = Path(__file__).parent / "uploads"
+UPLOAD_DIR.mkdir(exist_ok=True)
+
+# Available tools
+TOOLS = [calculator, search_web, read_file, list_files, unzip_file, read_media_file]
+
+# Create agent  
+def create_agent(use_session: bool = True) -> Agent:
+    """Create an agent instance."""
+    
+    # Include the actual upload directory path in instructions
+    upload_path = str(UPLOAD_DIR.absolute())
+    
+    instructions = f"""You are a helpful AI assistant with access to various tools.
+
+You can:
+- Perform calculations using the calculator
+- Search the web for current information
+- Read excel files using the read_file tool
+- List files in directories using the list_files tool
+- Extract zip files using the unzip_file tool
+- Read pdf using read_media_file
+
+IMPORTANT - Uploaded files location:
+Files uploaded by users are stored at: {upload_path}
+To see uploaded files, use: list_files("{upload_path}")
+To read a file, use: read_file("{upload_path}/filename.ext")
+
+Always be helpful and use your tools when needed to provide accurate answers."""
+
+    return Agent(
+        model=LlmClient(model="gpt-4o-mini"),
+        tools=TOOLS,
+        instructions=instructions,
+        max_steps=10,
+        session_manager=session_manager if use_session else None
+    )
+
+
+# Pydantic models for API
+class ChatRequest(BaseModel):
+    message: str
+    session_id: Optional[str] = None
+    use_session: bool = True
+
+
+class ChatResponse(BaseModel):
+    response: str
+    session_id: str
+    events_count: int
+    tools_used: List[str]
+    trace_text: str = ""  # Simple text-based trace like display_trace
+
+
+class ToolInfo(BaseModel):
+    name: str
+    description: str
+
+
+class SessionInfo(BaseModel):
+    session_id: str
+    events_count: int
+    created_at: str
+
+
+# API Endpoints
+@app.get("/")
+async def root():
+    """Serve the chat interface."""
+    return FileResponse(Path(__file__).parent / "static" / "index.html")
+
+
+@app.get("/api/tools")
+async def get_tools() -> List[ToolInfo]:
+    """Get list of available tools."""
+    return [
+        ToolInfo(
+            name=tool.name,
+            description=tool.description[:100] + "..." if len(tool.description) > 100 else tool.description
+        )
+        for tool in TOOLS
+    ]
+
+
+@app.post("/api/chat")
+async def chat(request: ChatRequest) -> ChatResponse:
+    """Send a message to the agent."""
+    
+    # Generate or use provided session ID
+    session_id = request.session_id or str(uuid.uuid4())
+    
+    # Create agent
+    agent = create_agent(use_session=request.use_session)
+    
+    try:
+        # Run the agent
+        if request.use_session:
+            result = await agent.run(request.message, session_id=session_id)
+        else:
+            result = await agent.run(request.message)
+        
+        # Extract tools used
+        tools_used = []
+        for event in result.context.events:
+            for item in event.content:
+                if hasattr(item, 'name') and item.type == "tool_call":
+                    if item.name not in tools_used:
+                        tools_used.append(item.name)
+        
+        # Use your format_trace function directly!
+        trace_text = format_trace(result.context)
+        
+        return ChatResponse(
+            response=str(result.output) if result.output else "I couldn't generate a response.",
+            session_id=session_id,
+            events_count=len(result.context.events),
+            tools_used=tools_used,
+            trace_text=trace_text
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/api/upload")
+async def upload_file(file: UploadFile = File(...)):
+    """Upload a file for the agent to access."""
+    
+    # Save file to uploads directory
+    file_path = UPLOAD_DIR / file.filename
+    
+    try:
+        with open(file_path, "wb") as buffer:
+            shutil.copyfileobj(file.file, buffer)
+        
+        return {
+            "filename": file.filename,
+            "path": str(file_path),
+            "size": file_path.stat().st_size,
+            "message": f"File uploaded successfully. You can reference it at: {file_path}"
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/api/uploads")
+async def list_uploads():
+    """List uploaded files."""
+    files = []
+    for f in UPLOAD_DIR.iterdir():
+        if f.is_file() and not f.name.startswith('.'):
+            files.append({
+                "name": f.name,
+                "path": str(f),
+                "size": f.stat().st_size
+            })
+    return files
+
+
+@app.delete("/api/uploads/{filename}")
+async def delete_upload(filename: str):
+    """Delete an uploaded file."""
+    file_path = UPLOAD_DIR / filename
+    if file_path.exists():
+        file_path.unlink()
+        return {"message": f"Deleted {filename}"}
+    raise HTTPException(status_code=404, detail="File not found")
+
+
+@app.get("/api/sessions")
+async def list_sessions() -> List[SessionInfo]:
+    """List all active sessions."""
+    sessions = []
+    for sid, session in session_manager._sessions.items():
+        sessions.append(SessionInfo(
+            session_id=sid,
+            events_count=len(session.events),
+            created_at=session.created_at.isoformat()
+        ))
+    return sessions
+
+
+@app.delete("/api/sessions/{session_id}")
+async def delete_session(session_id: str):
+    """Delete a session to clear conversation history."""
+    if session_id in session_manager._sessions:
+        del session_manager._sessions[session_id]
+        return {"message": f"Session {session_id} cleared"}
+    raise HTTPException(status_code=404, detail="Session not found")
+
+
+# Mount static files
+static_dir = Path(__file__).parent / "static"
+static_dir.mkdir(exist_ok=True)
+app.mount("/static", StaticFiles(directory=static_dir), name="static")
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)
+

web_app/static/index.html

@@ -0,0 +1,1012 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Agent Chat</title>
+    <link href="https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@400;500;600&family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
+    <style>
+        :root {
+            --bg-primary: #0a0a0f;
+            --bg-secondary: #12121a;
+            --bg-tertiary: #1a1a25;
+            --accent: #00d4aa;
+            --accent-dim: #00a080;
+            --text-primary: #e8e8e8;
+            --text-secondary: #888;
+            --border: #2a2a3a;
+            --user-msg: #1e3a5f;
+            --agent-msg: #1a2a1a;
+            --tool-tag: #2d1f4e;
+            --error: #ff4757;
+            --success: #00d4aa;
+        }
+
+        html {
+            height: 100%;
+            width: 100%;
+        }
+
+        * {
+            margin: 0;
+            padding: 0;
+            -webkit-box-sizing: border-box;
+            box-sizing: border-box;
+        }
+
+        body {
+            font-family: 'Inter', -apple-system, BlinkMacSystemFont, sans-serif;
+            background-color: #0a0a0f;
+            background: var(--bg-primary);
+            color: #e8e8e8;
+            color: var(--text-primary);
+            min-height: 100vh;
+            height: 100vh;
+            display: -webkit-box;
+            display: -webkit-flex;
+            display: flex;
+            overflow: hidden;
+        }
+
+        /* Sidebar */
+        .sidebar {
+            width: 280px;
+            min-width: 280px;
+            background: var(--bg-secondary);
+            border-right: 1px solid var(--border);
+            display: -webkit-box;
+            display: -webkit-flex;
+            display: flex;
+            -webkit-flex-direction: column;
+            flex-direction: column;
+            padding: 20px;
+            overflow-y: auto;
+        }
+
+        .logo {
+            font-family: 'JetBrains Mono', monospace;
+            font-size: 1.4rem;
+            font-weight: 600;
+            color: var(--accent);
+            margin-bottom: 30px;
+            display: flex;
+            align-items: center;
+            gap: 10px;
+        }
+
+        .logo::before {
+            content: '>';
+            animation: blink 1s infinite;
+        }
+
+        @keyframes blink {
+            50% { opacity: 0; }
+        }
+
+        .section-title {
+            font-size: 0.75rem;
+            font-weight: 600;
+            text-transform: uppercase;
+            letter-spacing: 1px;
+            color: var(--text-secondary);
+            margin-bottom: 12px;
+        }
+
+        /* Session Toggle */
+        .session-control {
+            background: var(--bg-tertiary);
+            border-radius: 12px;
+            padding: 16px;
+            margin-bottom: 24px;
+        }
+
+        .toggle-container {
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+            margin-top: 10px;
+        }
+
+        .toggle-label {
+            font-size: 0.9rem;
+            color: var(--text-primary);
+        }
+
+        .toggle {
+            position: relative;
+            width: 50px;
+            height: 26px;
+        }
+
+        .toggle input {
+            opacity: 0;
+            width: 0;
+            height: 0;
+        }
+
+        .toggle-slider {
+            position: absolute;
+            cursor: pointer;
+            inset: 0;
+            background: var(--bg-primary);
+            border-radius: 26px;
+            transition: 0.3s;
+            border: 2px solid var(--border);
+        }
+
+        .toggle-slider::before {
+            position: absolute;
+            content: "";
+            height: 18px;
+            width: 18px;
+            left: 2px;
+            bottom: 2px;
+            background: var(--text-secondary);
+            border-radius: 50%;
+            transition: 0.3s;
+        }
+
+        .toggle input:checked + .toggle-slider {
+            background: var(--accent-dim);
+            border-color: var(--accent);
+        }
+
+        .toggle input:checked + .toggle-slider::before {
+            transform: translateX(24px);
+            background: var(--accent);
+        }
+
+        .session-info {
+            font-size: 0.8rem;
+            color: var(--text-secondary);
+            margin-top: 10px;
+            font-family: 'JetBrains Mono', monospace;
+        }
+
+        /* Tools List */
+        .tools-section {
+            flex: 1;
+            overflow-y: auto;
+        }
+
+        .tool-item {
+            background: var(--bg-tertiary);
+            border-radius: 8px;
+            padding: 12px;
+            margin-bottom: 8px;
+            border: 1px solid transparent;
+            transition: all 0.2s;
+        }
+
+        .tool-item:hover {
+            border-color: var(--accent-dim);
+        }
+
+        .tool-name {
+            font-family: 'JetBrains Mono', monospace;
+            font-size: 0.85rem;
+            color: var(--accent);
+            margin-bottom: 4px;
+        }
+
+        .tool-desc {
+            font-size: 0.75rem;
+            color: var(--text-secondary);
+            line-height: 1.4;
+        }
+
+        /* Files Section */
+        .files-section {
+            margin-top: 20px;
+            padding-top: 20px;
+            border-top: 1px solid var(--border);
+        }
+
+        .file-item {
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+            background: var(--bg-tertiary);
+            border-radius: 8px;
+            padding: 10px 12px;
+            margin-bottom: 8px;
+            font-size: 0.8rem;
+        }
+
+        .file-name {
+            font-family: 'JetBrains Mono', monospace;
+            color: var(--text-primary);
+            overflow: hidden;
+            text-overflow: ellipsis;
+            white-space: nowrap;
+            flex: 1;
+        }
+
+        .file-delete {
+            background: none;
+            border: none;
+            color: var(--error);
+            cursor: pointer;
+            padding: 4px;
+            opacity: 0.6;
+            transition: opacity 0.2s;
+        }
+
+        .file-delete:hover {
+            opacity: 1;
+        }
+
+        /* Main Chat Area */
+        .main {
+            -webkit-box-flex: 1;
+            -webkit-flex: 1;
+            flex: 1;
+            display: -webkit-box;
+            display: -webkit-flex;
+            display: flex;
+            -webkit-flex-direction: column;
+            flex-direction: column;
+            height: 100vh;
+            max-height: 100vh;
+            overflow: hidden;
+        }
+
+        .chat-header {
+            padding: 20px 30px;
+            border-bottom: 1px solid var(--border);
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+        }
+
+        .chat-title {
+            font-size: 1.1rem;
+            font-weight: 600;
+        }
+
+        .header-buttons {
+            display: flex;
+            gap: 10px;
+        }
+
+        .header-btn {
+            background: var(--bg-tertiary);
+            border: 1px solid var(--border);
+            color: var(--text-secondary);
+            padding: 8px 16px;
+            border-radius: 8px;
+            cursor: pointer;
+            font-size: 0.85rem;
+            transition: all 0.2s;
+        }
+
+        .header-btn:hover {
+            border-color: var(--accent);
+            color: var(--accent);
+        }
+
+        .clear-btn:hover {
+            border-color: var(--error) !important;
+            color: var(--error) !important;
+        }
+
+        /* Trace Modal */
+        .modal-overlay {
+            display: none;
+            position: fixed;
+            inset: 0;
+            background: rgba(0, 0, 0, 0.8);
+            z-index: 1000;
+            -webkit-backdrop-filter: blur(4px);
+            backdrop-filter: blur(4px);
+        }
+
+        .modal-overlay.active {
+            display: flex;
+            align-items: center;
+            justify-content: center;
+        }
+
+        .modal {
+            background: var(--bg-secondary);
+            border: 1px solid var(--border);
+            border-radius: 16px;
+            width: 90%;
+            max-width: 800px;
+            max-height: 80vh;
+            display: flex;
+            flex-direction: column;
+            animation: slideIn 0.3s ease;
+        }
+
+        @keyframes slideIn {
+            from { opacity: 0; transform: translateY(-20px); }
+            to { opacity: 1; transform: translateY(0); }
+        }
+
+        .modal-header {
+            padding: 20px;
+            border-bottom: 1px solid var(--border);
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+        }
+
+        .modal-title {
+            font-size: 1.2rem;
+            font-weight: 600;
+            color: var(--accent);
+        }
+
+        .modal-close {
+            background: none;
+            border: none;
+            color: var(--text-secondary);
+            cursor: pointer;
+            padding: 8px;
+            font-size: 1.5rem;
+            line-height: 1;
+        }
+
+        .modal-close:hover {
+            color: var(--text-primary);
+        }
+
+        .modal-body {
+            padding: 20px;
+            overflow-y: auto;
+            -webkit-overflow-scrolling: touch;
+        }
+
+        .trace-step {
+            background: var(--bg-tertiary);
+            border-radius: 8px;
+            padding: 16px;
+            margin-bottom: 12px;
+            border-left: 3px solid var(--accent);
+        }
+
+        .trace-step-header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 10px;
+        }
+
+        .trace-step-num {
+            font-family: 'JetBrains Mono', monospace;
+            font-size: 0.8rem;
+            color: var(--accent);
+            background: var(--bg-primary);
+            padding: 4px 8px;
+            border-radius: 4px;
+        }
+
+        .trace-author {
+            font-size: 0.85rem;
+            color: var(--text-secondary);
+            text-transform: uppercase;
+        }
+
+        .trace-item {
+            margin-top: 8px;
+            padding: 10px;
+            background: var(--bg-primary);
+            border-radius: 6px;
+            font-size: 0.85rem;
+        }
+
+        .trace-item-type {
+            font-family: 'JetBrains Mono', monospace;
+            font-size: 0.75rem;
+            padding: 2px 6px;
+            border-radius: 3px;
+            margin-bottom: 6px;
+            display: inline-block;
+        }
+
+        .trace-item-type.message { background: var(--user-msg); color: #7cb3d4; }
+        .trace-item-type.tool_call { background: var(--tool-tag); color: var(--accent); }
+        .trace-item-type.tool_result { background: var(--agent-msg); color: #7cd47c; }
+
+        .trace-content {
+            color: var(--text-primary);
+            line-height: 1.5;
+            white-space: pre-wrap;
+            word-break: break-word;
+        }
+
+        .trace-args {
+            font-family: 'JetBrains Mono', monospace;
+            font-size: 0.8rem;
+            color: var(--text-secondary);
+        }
+
+        /* Messages */
+        .messages {
+            -webkit-box-flex: 1;
+            -webkit-flex: 1;
+            flex: 1;
+            overflow-y: auto;
+            -webkit-overflow-scrolling: touch;
+            padding: 30px;
+            display: -webkit-box;
+            display: -webkit-flex;
+            display: flex;
+            -webkit-flex-direction: column;
+            flex-direction: column;
+            gap: 20px;
+        }
+
+        .message {
+            max-width: 80%;
+            padding: 16px 20px;
+            border-radius: 16px;
+            line-height: 1.6;
+            animation: fadeIn 0.3s ease;
+        }
+
+        @keyframes fadeIn {
+            from { opacity: 0; transform: translateY(10px); }
+            to { opacity: 1; transform: translateY(0); }
+        }
+
+        .message.user {
+            background: var(--user-msg);
+            align-self: flex-end;
+            border-bottom-right-radius: 4px;
+        }
+
+        .message.agent {
+            background: var(--bg-tertiary);
+            align-self: flex-start;
+            border-bottom-left-radius: 4px;
+            border: 1px solid var(--border);
+        }
+
+        .message-meta {
+            display: flex;
+            align-items: center;
+            gap: 10px;
+            margin-top: 10px;
+            font-size: 0.75rem;
+            color: var(--text-secondary);
+        }
+
+        .tool-tag {
+            background: var(--tool-tag);
+            color: var(--accent);
+            padding: 2px 8px;
+            border-radius: 4px;
+            font-family: 'JetBrains Mono', monospace;
+            font-size: 0.7rem;
+        }
+
+        /* Input Area */
+        .input-area {
+            padding: 20px 30px;
+            border-top: 1px solid var(--border);
+            background: var(--bg-secondary);
+        }
+
+        .input-container {
+            display: flex;
+            gap: 12px;
+            align-items: flex-end;
+        }
+
+        .input-wrapper {
+            flex: 1;
+            position: relative;
+        }
+
+        textarea {
+            width: 100%;
+            background: var(--bg-primary);
+            border: 1px solid var(--border);
+            border-radius: 12px;
+            padding: 16px 20px;
+            color: var(--text-primary);
+            font-family: inherit;
+            font-size: 0.95rem;
+            resize: none;
+            min-height: 56px;
+            max-height: 200px;
+            outline: none;
+            transition: border-color 0.2s;
+        }
+
+        textarea:focus {
+            border-color: var(--accent);
+        }
+
+        textarea::placeholder {
+            color: var(--text-secondary);
+        }
+
+        .btn-group {
+            display: flex;
+            gap: 8px;
+        }
+
+        .btn {
+            background: var(--accent);
+            border: none;
+            color: var(--bg-primary);
+            padding: 16px 24px;
+            border-radius: 12px;
+            cursor: pointer;
+            font-weight: 600;
+            font-size: 0.9rem;
+            transition: all 0.2s;
+            display: flex;
+            align-items: center;
+            gap: 8px;
+        }
+
+        .btn:hover {
+            background: var(--accent-dim);
+            transform: translateY(-1px);
+        }
+
+        .btn:disabled {
+            opacity: 0.5;
+            cursor: not-allowed;
+            transform: none;
+        }
+
+        .btn-upload {
+            background: var(--bg-tertiary);
+            border: 1px solid var(--border);
+            color: var(--text-primary);
+        }
+
+        .btn-upload:hover {
+            border-color: var(--accent);
+            color: var(--accent);
+            background: var(--bg-tertiary);
+        }
+
+        #file-input {
+            display: none;
+        }
+
+        /* Loading */
+        .loading {
+            display: flex;
+            gap: 6px;
+            padding: 20px;
+        }
+
+        .loading-dot {
+            width: 8px;
+            height: 8px;
+            background: var(--accent);
+            border-radius: 50%;
+            animation: bounce 1.4s infinite ease-in-out both;
+        }
+
+        .loading-dot:nth-child(1) { animation-delay: -0.32s; }
+        .loading-dot:nth-child(2) { animation-delay: -0.16s; }
+
+        @keyframes bounce {
+            0%, 80%, 100% { transform: scale(0); }
+            40% { transform: scale(1); }
+        }
+
+        /* Scrollbar */
+        ::-webkit-scrollbar {
+            width: 8px;
+        }
+
+        ::-webkit-scrollbar-track {
+            background: var(--bg-primary);
+        }
+
+        ::-webkit-scrollbar-thumb {
+            background: var(--border);
+            border-radius: 4px;
+        }
+
+        ::-webkit-scrollbar-thumb:hover {
+            background: var(--text-secondary);
+        }
+
+        /* Mobile responsive */
+        @media (max-width: 768px) {
+            .sidebar {
+                display: none;
+            }
+        }
+    </style>
+</head>
+<body>
+    <noscript>
+        <div style="padding: 50px; text-align: center; color: #00d4aa; font-size: 18px;">
+            Please enable JavaScript to use Agent Chat.
+        </div>
+    </noscript>
+    <aside class="sidebar">
+        <div class="logo">Agent Chat</div>
+        
+        <div class="session-control">
+            <div class="section-title">Session Memory</div>
+            <div class="toggle-container">
+                <span class="toggle-label">Remember context</span>
+                <label class="toggle">
+                    <input type="checkbox" id="session-toggle" checked>
+                    <span class="toggle-slider"></span>
+                </label>
+            </div>
+            <div class="session-info" id="session-info">
+                Session: <span id="session-id">-</span>
+            </div>
+        </div>
+
+        <div class="tools-section">
+            <div class="section-title">Available Tools</div>
+            <div id="tools-list"></div>
+        </div>
+
+        <div class="files-section">
+            <div class="section-title">Uploaded Files</div>
+            <div id="files-list"></div>
+        </div>
+    </aside>
+
+    <main class="main">
+        <header class="chat-header">
+            <h1 class="chat-title">Chat with AI Agent</h1>
+            <div class="header-buttons">
+                <button class="header-btn" id="trace-btn">View Trace</button>
+                <button class="header-btn clear-btn" id="clear-btn">Clear Session</button>
+            </div>
+        </header>
+
+        <div class="messages" id="messages">
+            <div class="message agent">
+                Hello! I'm an AI assistant with access to various tools. I can help you with calculations, web searches, reading files, and more. How can I help you today?
+            </div>
+        </div>
+
+        <div class="input-area">
+            <div class="input-container">
+                <div class="input-wrapper">
+                    <textarea 
+                        id="message-input" 
+                        placeholder="Type your message... (Enter to send, Shift+Enter for new line)"
+                        rows="1"
+                    ></textarea>
+                </div>
+                <div class="btn-group">
+                    <label class="btn btn-upload" for="file-input">
+                        <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                            <path d="M21 15v4a2 2 0 01-2 2H5a2 2 0 01-2-2v-4M17 8l-5-5-5 5M12 3v12"/>
+                        </svg>
+                    </label>
+                    <input type="file" id="file-input" multiple>
+                    <button class="btn" id="send-btn">
+                        Send
+                        <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                            <path d="M22 2L11 13M22 2l-7 20-4-9-9-4 20-7z"/>
+                        </svg>
+                    </button>
+                </div>
+            </div>
+        </div>
+    </main>
+
+    <!-- Trace Modal -->
+    <div class="modal-overlay" id="trace-modal">
+        <div class="modal">
+            <div class="modal-header">
+                <h2 class="modal-title">Execution Trace</h2>
+                <button class="modal-close" id="modal-close">&times;</button>
+            </div>
+            <div class="modal-body" id="trace-content">
+                <p style="color: var(--text-secondary);">No trace available. Send a message first.</p>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        // State
+        let sessionId = generateUUID();
+        let useSession = true;
+        let currentTrace = "";  // Text-based trace
+
+        function generateUUID() {
+            return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
+                const r = Math.random() * 16 | 0;
+                const v = c === 'x' ? r : (r & 0x3 | 0x8);
+                return v.toString(16);
+            });
+        }
+
+        // DOM Elements
+        const messagesContainer = document.getElementById('messages');
+        const messageInput = document.getElementById('message-input');
+        const sendBtn = document.getElementById('send-btn');
+        const clearBtn = document.getElementById('clear-btn');
+        const sessionToggle = document.getElementById('session-toggle');
+        const sessionIdSpan = document.getElementById('session-id');
+        const toolsList = document.getElementById('tools-list');
+        const filesList = document.getElementById('files-list');
+        const fileInput = document.getElementById('file-input');
+        const traceBtn = document.getElementById('trace-btn');
+        const traceModal = document.getElementById('trace-modal');
+        const modalClose = document.getElementById('modal-close');
+        const traceContent = document.getElementById('trace-content');
+
+        // Initialize
+        async function init() {
+            await loadTools();
+            await loadFiles();
+            updateSessionDisplay();
+        }
+
+        function updateSessionDisplay() {
+            sessionIdSpan.textContent = useSession ? sessionId.substring(0, 8) + '...' : 'disabled';
+        }
+
+        // Load tools
+        async function loadTools() {
+            try {
+                const response = await fetch('/api/tools');
+                const tools = await response.json();
+                toolsList.innerHTML = tools.map(tool => `
+                    <div class="tool-item">
+                        <div class="tool-name">${tool.name}</div>
+                        <div class="tool-desc">${tool.description}</div>
+                    </div>
+                `).join('');
+            } catch (e) {
+                toolsList.innerHTML = '<div class="tool-item">Failed to load tools</div>';
+            }
+        }
+
+        // Load files
+        async function loadFiles() {
+            try {
+                const response = await fetch('/api/uploads');
+                const files = await response.json();
+                if (files.length === 0) {
+                    filesList.innerHTML = '<div style="color: var(--text-secondary); font-size: 0.8rem;">No files uploaded</div>';
+                } else {
+                    filesList.innerHTML = files.map(file => `
+                        <div class="file-item">
+                            <span class="file-name">${file.name}</span>
+                            <button class="file-delete" onclick="deleteFile('${file.name}')">
+                                <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                                    <path d="M18 6L6 18M6 6l12 12"/>
+                                </svg>
+                            </button>
+                        </div>
+                    `).join('');
+                }
+            } catch (e) {
+                filesList.innerHTML = '<div style="color: var(--text-secondary); font-size: 0.8rem;">Failed to load files</div>';
+            }
+        }
+
+        // Delete file
+        async function deleteFile(filename) {
+            try {
+                await fetch(`/api/uploads/${encodeURIComponent(filename)}`, { method: 'DELETE' });
+                await loadFiles();
+            } catch (e) {
+                console.error('Failed to delete file:', e);
+            }
+        }
+
+        // Add message to chat
+        function addMessage(content, isUser, toolsUsed = []) {
+            const messageDiv = document.createElement('div');
+            messageDiv.className = `message ${isUser ? 'user' : 'agent'}`;
+            
+            let html = content.replace(/\n/g, '<br>');
+            
+            if (!isUser && toolsUsed.length > 0) {
+                const toolTags = toolsUsed.map(t => `<span class="tool-tag">${t}</span>`).join(' ');
+                html += `<div class="message-meta">Tools used: ${toolTags}</div>`;
+            }
+            
+            messageDiv.innerHTML = html;
+            messagesContainer.appendChild(messageDiv);
+            messagesContainer.scrollTop = messagesContainer.scrollHeight;
+        }
+
+        // Show loading indicator
+        function showLoading() {
+            const loadingDiv = document.createElement('div');
+            loadingDiv.className = 'loading';
+            loadingDiv.id = 'loading';
+            loadingDiv.innerHTML = `
+                <div class="loading-dot"></div>
+                <div class="loading-dot"></div>
+                <div class="loading-dot"></div>
+            `;
+            messagesContainer.appendChild(loadingDiv);
+            messagesContainer.scrollTop = messagesContainer.scrollHeight;
+        }
+
+        function hideLoading() {
+            const loading = document.getElementById('loading');
+            if (loading) loading.remove();
+        }
+
+        // Send message
+        async function sendMessage() {
+            const message = messageInput.value.trim();
+            if (!message) return;
+
+            addMessage(message, true);
+            messageInput.value = '';
+            messageInput.style.height = 'auto';
+            sendBtn.disabled = true;
+            showLoading();
+
+            try {
+                const response = await fetch('/api/chat', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        message: message,
+                        session_id: useSession ? sessionId : null,
+                        use_session: useSession
+                    })
+                });
+
+                const data = await response.json();
+                hideLoading();
+
+                if (response.ok) {
+                    addMessage(data.response, false, data.tools_used);
+                    if (useSession) {
+                        sessionId = data.session_id;
+                        updateSessionDisplay();
+                    }
+                    // Store trace text for viewing
+                    if (data.trace_text) {
+                        currentTrace = data.trace_text;
+                    }
+                } else {
+                    addMessage(`Error: ${data.detail || 'Something went wrong'}`, false);
+                }
+            } catch (e) {
+                hideLoading();
+                addMessage(`Error: ${e.message}`, false);
+            }
+
+            sendBtn.disabled = false;
+        }
+
+        // Upload file
+        async function uploadFile(file) {
+            const formData = new FormData();
+            formData.append('file', file);
+
+            try {
+                const response = await fetch('/api/upload', {
+                    method: 'POST',
+                    body: formData
+                });
+
+                const data = await response.json();
+                if (response.ok) {
+                    addMessage(
+                        `File uploaded successfully: ${file.name}\n\n` +
+                        `You can now ask me to:\n` +
+                        `• "Read the file ${file.name}"\n` +
+                        `• "What's in ${file.name}?"\n` +
+                        `• "List my uploaded files"`,
+                        false
+                    );
+                    await loadFiles();
+                } else {
+                    addMessage(`Failed to upload ${file.name}: ${data.detail}`, false);
+                }
+            } catch (e) {
+                addMessage(`Failed to upload ${file.name}: ${e.message}`, false);
+            }
+        }
+
+        // Clear session
+        async function clearSession() {
+            if (useSession && sessionId) {
+                try {
+                    await fetch(`/api/sessions/${sessionId}`, { method: 'DELETE' });
+                } catch (e) {
+                    console.error('Failed to clear session:', e);
+                }
+            }
+            
+            sessionId = generateUUID();
+            updateSessionDisplay();
+            messagesContainer.innerHTML = `
+                <div class="message agent">
+                    Session cleared! I'm ready for a fresh conversation. How can I help you?
+                </div>
+            `;
+        }
+
+        // Event listeners
+        sendBtn.addEventListener('click', sendMessage);
+
+        messageInput.addEventListener('keydown', (e) => {
+            if (e.key === 'Enter' && !e.shiftKey) {
+                e.preventDefault();
+                sendMessage();
+            }
+        });
+
+        messageInput.addEventListener('input', () => {
+            messageInput.style.height = 'auto';
+            messageInput.style.height = Math.min(messageInput.scrollHeight, 200) + 'px';
+        });
+
+        sessionToggle.addEventListener('change', () => {
+            useSession = sessionToggle.checked;
+            updateSessionDisplay();
+        });
+
+        clearBtn.addEventListener('click', clearSession);
+
+        fileInput.addEventListener('change', async (e) => {
+            for (const file of e.target.files) {
+                await uploadFile(file);
+            }
+            fileInput.value = '';
+        });
+
+        // Trace modal functions
+        function renderTrace() {
+            if (!currentTrace) {
+                traceContent.innerHTML = '<p style="color: var(--text-secondary);">No trace available. Send a message first.</p>';
+                return;
+            }
+
+            // Display text trace in a pre-formatted block
+            traceContent.innerHTML = `<pre style="
+                font-family: 'JetBrains Mono', monospace;
+                font-size: 0.85rem;
+                line-height: 1.6;
+                white-space: pre-wrap;
+                word-break: break-word;
+                color: var(--text-primary);
+                margin: 0;
+            ">${escapeHtml(currentTrace)}</pre>`;
+        }
+
+        function escapeHtml(text) {
+            if (!text) return '';
+            const div = document.createElement('div');
+            div.textContent = text;
+            return div.innerHTML;
+        }
+
+        function showTraceModal() {
+            renderTrace();
+            traceModal.classList.add('active');
+        }
+
+        function hideTraceModal() {
+            traceModal.classList.remove('active');
+        }
+
+        // Trace modal event listeners
+        traceBtn.addEventListener('click', showTraceModal);
+        modalClose.addEventListener('click', hideTraceModal);
+        traceModal.addEventListener('click', (e) => {
+            if (e.target === traceModal) hideTraceModal();
+        });
+        document.addEventListener('keydown', (e) => {
+            if (e.key === 'Escape') hideTraceModal();
+        });
+
+        // Initialize
+        init();
+    </script>
+</body>
+</html>
+