working agent

agent.py

@@ -1,69 +1,90 @@
-from llama_index.llms.openai import OpenAI
-from tools.tavily_search_tool import search_web, record_notes, write_report, review_report, ReportOutput, get_structured_report_from_state
+from llama_index.llms.huggingface_api import HuggingFaceInferenceAPI
+from tools.simple_tools import (
+    search_web_tool, record_notes_tool, write_report_tool, review_report_tool,
+    get_workflow_state, reset_workflow_state
+)
 from dotenv import load_dotenv
 import os
-from llama_index.core.agent.workflow import FunctionAgent
-from llama_index.core.agent.workflow import AgentWorkflow
-from llama_index.core.agent.workflow import (
-    AgentInput,
-    AgentOutput,
-    ToolCall,
-    ToolCallResult,
-    AgentStream,
-)
+from llama_index.core.agent.workflow import AgentWorkflow, ReActAgent
+from llama_index.core.workflow import Context
 
 load_dotenv(os.path.join(os.path.dirname(__file__), 'env.local'))
 
 class TeacherStudentAgentWorkflow:
     def __init__(self):
-        self.llm = OpenAI(model="gpt-4o-mini", api_key=os.getenv("OPENAI_API_KEY"))
+        self.llm = HuggingFaceInferenceAPI(
+            model_name="microsoft/Phi-3.5-mini-instruct",
+            token=os.getenv("HUGGING_FACE_TOKEN")
+        )
 
-        self.research_agent = FunctionAgent(
+        self.research_agent = ReActAgent(
             name="ResearchAgent",
-            description="Useful for searching the web for information on a given topic and recording notes on the topic.",
+            description="Searches the web and records notes.",
             system_prompt=(
-                "You are the ResearchAgent that can search the web for information on a given topic and record notes on the topic. "
-                "IMPORTANT: Never make duplicate tool calls. Each tool call should be unique and purposeful. "
-                "Process: 1) Search for information ONCE with a clear query, 2) Record the notes ONCE with a descriptive title, "
-                "3) Only search again if you need different/additional information with a different query. "
-                "Once you have sufficient notes recorded, immediately hand off control to the WriteAgent. "
-                "You should have at least some notes on a topic before handing off control to the WriteAgent."
+                "You are a Research Agent. Your ONLY job is to research and hand off to WriteAgent.\n"
+                "\n"
+                "STRICT WORKFLOW:\n"
+                "1. Use search_web tool to search for information\n"
+                "2. Use record_notes tool to save what you found\n"
+                "3. Say: 'Research complete. I have gathered sufficient information. Handing off to WriteAgent.'\n"
+                "\n"
+                "CRITICAL RULES:\n"
+                "- You can ONLY use search_web and record_notes tools\n"
+                "- You CANNOT write reports - that's WriteAgent's job\n"
+                "- You CANNOT use write_report tool - you don't have access to it\n"
+                "- After research, you MUST hand off with the exact message above\n"
+                "- Do NOT attempt to write any report content yourself\n"
+                "\n"
+                "AVAILABLE TOOLS: search_web, record_notes\n"
+                "HANDOFF MESSAGE: 'Research complete. I have gathered sufficient information. Handing off to WriteAgent.'"
             ),
+            tools=[search_web_tool, record_notes_tool],
             llm=self.llm,
-            tools=[search_web, record_notes],
             can_handoff_to=["WriteAgent"],
         )
 
-        self.write_agent = FunctionAgent(
+        self.write_agent = ReActAgent(
             name="WriteAgent",
-            description="Useful for writing a structured report on a given topic.",
+            description="Writes a structured report based on research notes.",
             system_prompt=(
-                "You are the WriteAgent that can write a structured report on a given topic. "
-                "IMPORTANT: Never make duplicate tool calls. Write the report only ONCE with all available research. "
-                "Your report should be in markdown format and include a descriptive title. "
-                "When calling write_report, provide both the markdown content AND a clear, descriptive title. "
-                "The content should be grounded in the research notes and well-structured with clear sections. "
-                "Once the report is written ONCE, immediately hand off control to the ReviewAgent for feedback."
+                "You are a Writing Agent. Your purpose is to create a concise, well-structured report.\n"
+                "\n"
+                "INSTRUCTIONS:\n"
+                "1. Check if there's any feedback from ReviewAgent (not 'Review required.')\n"
+                "2. If there's feedback, revise the report accordingly\n"
+                "3. If no feedback, create initial report based on research\n"
+                "4. MUST call write_report tool with these parameters:\n"
+                "   - report_content: Concise markdown report (200-400 words)\n"
+                "   - title: Descriptive report title\n"
+                "5. Report structure (keep sections brief):\n"
+                "   - # Main Title\n"
+                "   - ## Introduction (1-2 sentences)\n"
+                "   - ## Key Points (2-3 bullet points)\n"
+                "   - ## Conclusion (1-2 sentences)\n"
+                "6. After calling tool: 'Report written. Handing off to ReviewAgent.'\n"
+                "\n"
+                "CRITICAL: Keep the report_content CONCISE to avoid truncation!\n"
+                "You MUST actually call the write_report tool with proper parameters!"
             ),
+            tools=[write_report_tool],
             llm=self.llm,
-            tools=[write_report],
-            can_handoff_to=["ReviewAgent", "ResearchAgent"],
+            can_handoff_to=["ReviewAgent"],
         )
 
-        self.review_agent = FunctionAgent(
+        self.review_agent = ReActAgent(
             name="ReviewAgent",
-            description="Useful for reviewing a report and providing feedback.",
+            description="Reviews the written report.",
             system_prompt=(
-                "You are the ReviewAgent that can review the report and provide feedback. "
-                "IMPORTANT: Never make duplicate tool calls. Review the report only ONCE and provide clear feedback. "
-                "Your review should either APPROVE the current report or request specific changes for the WriteAgent to implement. "
-                "When APPROVING a report, use clear approval language like 'APPROVED', 'READY', 'EXCELLENT', 'SATISFACTORY', or 'COMPLETE'. "
-                "If the report meets the requirements and is well-written, APPROVE it to complete the workflow. "
-                "If you have feedback that requires changes, hand off control to the WriteAgent to implement the changes after submitting the review ONCE."
+                "You are a Reviewing Agent. Your purpose is to review the report quality.\n"
+                "1. Check the report content that was written\n"
+                "2. Use review_report tool to provide feedback\n"
+                "3. If report is good quality, start feedback with 'APPROVED:'\n"
+                "4. If needs improvement, provide specific suggestions and hand off to WriteAgent\n"
+                "5. Quality criteria: clear structure, sufficient detail, proper formatting"
             ),
+            tools=[review_report_tool],
             llm=self.llm,
-            tools=[review_report],
-            can_handoff_to=["ResearchAgent","WriteAgent"],
+            can_handoff_to=["WriteAgent"],
         )
 
         self.agent_workflow = AgentWorkflow(
@@ -76,14 +97,9 @@ class TeacherStudentAgentWorkflow:
             },
         )
 
-    async def get_structured_report(self, handler) -> ReportOutput:
-        """Extract the structured report from the workflow state."""
-        try:
-            final_state = await handler.ctx.get("state")
-            return get_structured_report_from_state(final_state)
-        except Exception as e:
-            print(f"Error getting structured report: {e}")
-            return None
+    def get_final_state(self) -> dict:
+        """Get the final workflow state from the simple tools."""
+        return get_workflow_state()
 
     async def run_workflow(self, user_msg=None):
         if user_msg is None:
@@ -92,7 +108,19 @@ class TeacherStudentAgentWorkflow:
                 "Briefly describe the history of the internet, including the development of the internet, the development of the web, "
                 "and the development of the internet in the 21st century."
             )
-        handler = self.agent_workflow.run(user_msg=user_msg)
+        
+        # Reset state for new workflow
+        reset_workflow_state()
+        
+        # Create context and initialize state
+        ctx = Context(self.agent_workflow)
+        await ctx.set("state", {
+            "research_notes": {},
+            "report_content": "Not written yet.",
+            "review": "Review required.",
+        })
+        
+        handler = self.agent_workflow.run(user_msg=user_msg, ctx=ctx)
 
         current_agent = None
         async for event in handler.stream_events():
@@ -105,22 +133,38 @@ class TeacherStudentAgentWorkflow:
                 print(f"🤖 Agent: {current_agent}")
                 print(f"{'='*50}\n")
 
-            if isinstance(event, AgentOutput):
+            if hasattr(event, "response") and hasattr(event.response, "content"):
                 if event.response.content:
                     print("📤 Output:", event.response.content)
-                if event.tool_calls:
+                if hasattr(event, "tool_calls") and event.tool_calls:
                     print(
                         "🛠️  Planning to use tools:",
                         [call.tool_name for call in event.tool_calls],
                     )
-            elif isinstance(event, ToolCallResult):
+            elif hasattr(event, "tool_name") and hasattr(event, "tool_output"):
                 print(f"🔧 Tool Result ({event.tool_name}):")
-                print(f"  Arguments: {event.tool_kwargs}")
+                print(f"  Arguments: {getattr(event, 'tool_kwargs', {})}")
                 print(f"  Output: {event.tool_output}")
-            elif isinstance(event, ToolCall):
+            elif hasattr(event, "tool_name") and hasattr(event, "tool_kwargs"):
                 print(f"🔨 Calling Tool: {event.tool_name}")
                 print(f"  With arguments: {event.tool_kwargs}")
 
+        # After the workflow completes, print the final report
+        final_state = self.get_final_state()
+        print(f"\n📊 Final State:")
+        print(f"Research notes: {len(final_state.get('research_notes', {}))}")
+        print(f"Report written: {final_state.get('report_content', 'Not written') != 'Not written yet.'}")
+        print(f"Review: {final_state.get('review', 'No review')[:100]}...")
+        
+        if final_state.get("structured_report"):
+            print("\n📄 Final Report Generated Successfully!")
+            report = final_state["structured_report"]
+            print(f"Title: {report['title']}")
+            print(f"Word count: {report['word_count']}")
+            print(f"Sections: {len(report['sections'])}")
+        else:
+            print("\n⚠️ No final report was generated by the workflow.")
+
 if __name__ == "__main__":
     import asyncio
     agent = TeacherStudentAgentWorkflow()

app.py

@@ -3,8 +3,9 @@ from gradio import ChatMessage
 import asyncio
 import json
 import hashlib
+from datetime import datetime
 from agent import TeacherStudentAgentWorkflow
-from tools.tavily_search_tool import ReportOutput, get_structured_report_from_state
+from tools.simple_tools import get_workflow_state
 from llama_index.core.agent.workflow import (
     AgentInput,
     AgentOutput,
@@ -12,7 +13,7 @@ from llama_index.core.agent.workflow import (
     ToolCallResult,
     AgentStream,
 )
-from datetime import datetime
+from llama_index.core.workflow import Context
 
 # Initialize the agent workflow
 agent_workflow = None
@@ -26,230 +27,162 @@ def get_agent_workflow():
 async def chat_with_agent(message, history):
     """
     Async chat function that runs the agent workflow and streams each step.
-    Returns structured report data for separate display.
     """
-    if not message.strip():
-        yield history, None, gr.JSON(visible=False)
-        return
-    
-    # Add user message to history
+    history = history or []
     history.append(ChatMessage(role="user", content=message))
-    yield history, None, gr.JSON(visible=False)
+    
+    # Initial yield to show user message immediately
+    yield history, None, None, gr.update(value="", interactive=False)
+
+    final_report_content = None
+    structured_report_data = None
+    displayed_tool_calls = set()
     
     try:
-        # Get the agent workflow
         workflow = get_agent_workflow()
         
-        # Run the workflow with the user message
-        handler = workflow.agent_workflow.run(user_msg=message)
+        # Create context and initialize state properly
+        ctx = Context(workflow.agent_workflow)
+        await ctx.set("state", {
+            "research_notes": {},
+            "report_content": "Not written yet.",
+            "review": "Review required.",
+        })
         
-        current_agent = None
-        current_step_messages = []
-        final_report = None
-        structured_report_data = None
-        workflow_state = {}
+        handler = workflow.agent_workflow.run(user_msg=message, ctx=ctx)
         
-        # Track recent tool calls to prevent UI duplicates
-        recent_tool_calls = set()
-        max_cache_size = 100  # Limit cache size to prevent memory issues
+        current_agent = None
         
         async for event in handler.stream_events():
-            # Check if we switched to a new agent
-            if (
-                hasattr(event, "current_agent_name")
-                and event.current_agent_name != current_agent
-            ):
+            print(f"DEBUG: Event type: {type(event).__name__}")
+            
+            if hasattr(event, "current_agent_name") and event.current_agent_name != current_agent:
                 current_agent = event.current_agent_name
-                
-                # Clear tool call tracking when switching agents
-                recent_tool_calls.clear()
-                
-                # Add agent header message
-                agent_header = ChatMessage(
+                history.append(ChatMessage(
                     role="assistant",
-                    content=f"🤖 **{current_agent}** is now working...",
+                    content=f"**🤖 Agent: {current_agent}**",
                     metadata={"title": f"Agent: {current_agent}"}
-                )
-                history.append(agent_header)
-                yield history, final_report, gr.JSON(visible=False)
-            
-            # Handle different event types
-            if isinstance(event, AgentOutput):
-                if event.response.content:
-                    # Add agent output
-                    output_msg = ChatMessage(
-                        role="assistant",
-                        content=f"📤 **Output:** {event.response.content}",
-                        metadata={"title": f"{current_agent} - Output"}
-                    )
-                    history.append(output_msg)
-                    yield history, final_report, gr.JSON(visible=False)
-                
-                if event.tool_calls:
-                    # Show planned tools
-                    tools_list = [call.tool_name for call in event.tool_calls]
-                    tools_msg = ChatMessage(
-                        role="assistant",
-                        content=f"🛠️ **Planning to use tools:** {', '.join(tools_list)}",
-                        metadata={"title": f"{current_agent} - Tool Planning"}
-                    )
-                    history.append(tools_msg)
-                    yield history, final_report, gr.JSON(visible=False)
-                    
-            elif isinstance(event, ToolCall):
-                # Create a unique identifier for this tool call using a more robust approach
-                try:
-                    # Sort the arguments to ensure consistent hashing
-                    sorted_kwargs = json.dumps(event.tool_kwargs, sort_keys=True, default=str)
-                    tool_call_id = f"{event.tool_name}_{hashlib.md5(sorted_kwargs.encode()).hexdigest()}"
-                except (TypeError, ValueError):
-                    # Fallback for non-serializable arguments
-                    tool_call_id = f"{event.tool_name}_{hash(str(event.tool_kwargs))}"
+                ))
+                yield history, final_report_content, structured_report_data, gr.update(interactive=False)
+
+            if isinstance(event, ToolCall):
+                tool_call_kwargs_str = json.dumps(getattr(event, 'tool_kwargs', {}), sort_keys=True)
+                tool_call_key = f"{current_agent}:{event.tool_name}:{hashlib.md5(tool_call_kwargs_str.encode()).hexdigest()[:8]}"
+                print(f"DEBUG: ToolCall detected - Agent: {current_agent}, Tool: {event.tool_name}, Args: {getattr(event, 'tool_kwargs', {})}")
                 
-                # Only show if we haven't seen this exact tool call recently
-                if tool_call_id not in recent_tool_calls:
-                    recent_tool_calls.add(tool_call_id)
-                    
-                    # Clean up cache if it gets too large
-                    if len(recent_tool_calls) > max_cache_size:
-                        # Remove some old entries (keep the most recent half)
-                        recent_tool_calls = set(list(recent_tool_calls)[-max_cache_size//2:])
-                    
-                    # Show tool being called
-                    tool_msg = ChatMessage(
+                if tool_call_key not in displayed_tool_calls:
+                    args_preview = str(getattr(event, 'tool_kwargs', {}))[:100] + "..." if len(str(getattr(event, 'tool_kwargs', {}))) > 100 else str(getattr(event, 'tool_kwargs', {}))
+                    history.append(ChatMessage(
                         role="assistant",
-                        content=f"🔨 **Calling Tool:** {event.tool_name}\n**Arguments:** {event.tool_kwargs}",
+                        content=f"**🔨 Calling Tool:** `{event.tool_name}`\n**Arguments:** {args_preview}",
                         metadata={"title": f"{current_agent} - Tool Call"}
-                    )
-                    history.append(tool_msg)
-                    yield history, final_report, gr.JSON(visible=False)
-                else:
-                    # Debug: Log duplicate detection (remove this in production)
-                    print(f"🚫 Duplicate tool call detected and skipped: {event.tool_name} with args {event.tool_kwargs}")
-                # If it's a duplicate, we simply skip displaying it
+                    ))
+                    displayed_tool_calls.add(tool_call_key)
+                    yield history, final_report_content, structured_report_data, gr.update(interactive=False)
                 
             elif isinstance(event, ToolCallResult):
-                # Show tool results
-                result_content = str(event.tool_output)
-                if len(result_content) > 500:
-                    result_content = result_content[:500] + "..."
+                print(f"DEBUG: ToolCallResult - Tool: {getattr(event, 'tool_name', 'unknown')}, Output: {getattr(event, 'tool_output', 'no output')}")
                 
-                # Check if this is a duplicate detection message
-                is_duplicate = any(word in result_content.lower() for word in ["duplicate", "skipping"])
+                # Show tool result in UI
+                tool_output = getattr(event, 'tool_output', 'No output')
+                tool_name = getattr(event, 'tool_name', 'unknown')
+                output_preview = str(tool_output)[:200] + "..." if len(str(tool_output)) > 200 else str(tool_output)
                 
-                if is_duplicate:
-                    result_msg = ChatMessage(
-                        role="assistant",
-                        content=f"⚠️ **Duplicate Detection ({event.tool_name}):**\n{result_content}",
-                        metadata={"title": f"{current_agent} - Duplicate Skipped"}
-                    )
-                else:
-                    result_msg = ChatMessage(
-                        role="assistant",
-                        content=f"🔧 **Tool Result ({event.tool_name}):**\n{result_content}",
-                        metadata={"title": f"{current_agent} - Tool Result"}
-                    )
-                
-                history.append(result_msg)
-                
-                # Track tool results to detect report writing and review approval (only for non-duplicates)
-                if not is_duplicate:
-                    if event.tool_name == "write_report":
-                        workflow_state["has_report"] = True
-                    elif event.tool_name == "review_report" and current_agent == "ReviewAgent":
-                        workflow_state["has_review"] = True
-                        # Check if review indicates approval (expanded keywords)
-                        approval_keywords = [
-                            "approved", "ready", "good", "excellent", "satisfactory", 
-                            "complete", "accept", "final", "publish", "meets", "solid",
-                            "well-written", "comprehensive", "thorough"
-                        ]
-                        if any(word in result_content.lower() for word in approval_keywords):
-                            workflow_state["review_approved"] = True
-                
-                yield history, final_report, gr.JSON(visible=False)
+                history.append(ChatMessage(
+                    role="assistant",
+                    content=f"**🔧 Tool Result ({tool_name}):**\n{output_preview}",
+                    metadata={"title": f"{current_agent} - Tool Result"}
+                ))
+                yield history, final_report_content, structured_report_data, gr.update(interactive=False)
+            
+            elif isinstance(event, AgentOutput) and event.response.content:
+                print(f"DEBUG: AgentOutput from {current_agent}: {event.response.content}")
+                # This is the agent's final thought or handoff message
+                history.append(ChatMessage(
+                    role="assistant",
+                    content=f"**📤 Thought:** {event.response.content}",
+                    metadata={"title": f"{current_agent} - Output"}
+                ))
+                yield history, final_report_content, structured_report_data, gr.update(interactive=False)
+
+        # Final state extraction - use the simple tools state
+        print("DEBUG: Workflow completed, extracting final state...")
+        final_state = get_workflow_state()
+        print(f"DEBUG: Final state keys: {final_state.keys() if final_state else 'None'}")
         
-        # Get the final state to extract the structured report
-        try:
-            final_state = await handler.ctx.get("state")
-            if final_state:
-                # Get structured report data
-                structured_report = get_structured_report_from_state(final_state)
-                if structured_report:
-                    # Include ALL fields from the Pydantic model, including content
+        if final_state:
+            print(f"DEBUG: Final state content: {json.dumps(final_state, indent=2, default=str)}")
+            
+            # Check for research notes
+            research_notes = final_state.get("research_notes", {})
+            print(f"DEBUG: Research notes found: {len(research_notes)} items")
+            for title, content in research_notes.items():
+                print(f"DEBUG: Research note '{title}': {content[:100]}..." if len(content) > 100 else f"DEBUG: Research note '{title}': {content}")
+            
+            # Check if we have a structured report
+            if final_state.get("structured_report"):
+                structured_report_data = final_state["structured_report"]
+                final_report_content = structured_report_data.get("content", "*Report content not found in structured report.*")
+                print(f"DEBUG: Found structured report with content length: {len(final_report_content) if final_report_content else 0}")
+            else:
+                # Fallback: try to get report_content directly from state
+                final_report_content = final_state.get("report_content", None)
+                if final_report_content and final_report_content != "Not written yet.":
+                    print(f"DEBUG: Found report_content directly in state with length: {len(final_report_content)}")
+                    # Create minimal structured data for JSON display
                     structured_report_data = {
-                        "title": structured_report.title,
-                        "abstract": structured_report.abstract,
-                        "content": structured_report.content,
-                        "sections": structured_report.sections,
-                        "word_count": structured_report.word_count,
-                        "generated_at": structured_report.generated_at.strftime("%Y-%m-%d %H:%M:%S"),
-                        "sources_used": structured_report.sources_used or []
+                        "title": "Generated Report",
+                        "content": final_report_content,
+                        "word_count": len(final_report_content.split()),
+                        "generated_at": datetime.now().isoformat(),
+                        "research_notes_count": len(final_state.get("research_notes", {}))
                     }
-                    
-                    # Show the final report if we have one
-                    # Check if review indicates approval OR if we just have a completed report
-                    if (workflow_state.get("has_report") and 
-                        (workflow_state.get("review_approved") or workflow_state.get("has_review"))):
-                        final_report = gr.Markdown(structured_report.content, visible=True)
-                    elif workflow_state.get("has_report"):
-                        # Show report even if not reviewed yet, but mark it as preliminary
-                        final_report = gr.Markdown(
-                            f"## 📝 Preliminary Report (Pending Review)\n\n{structured_report.content}", 
-                            visible=True
-                        )
-                        
-                # Fallback to regular content if structured report is not available
-                elif "report_content" in final_state:
-                    report_content = final_state["report_content"]
-                    if report_content and report_content != "Not written yet.":
-                        # Create basic structured data from the raw content
+                else:
+                    print("DEBUG: No valid report content found in final state")
+                    print(f"DEBUG: report_content value: '{final_report_content}'")
+                    # If we have research notes but no report, show that as partial success
+                    if research_notes:
+                        final_report_content = f"**Research completed but report not written.**\n\n**Research Notes:**\n\n"
+                        for title, content in research_notes.items():
+                            final_report_content += f"### {title}\n{content}\n\n"
                         structured_report_data = {
-                            "title": "Generated Report",
-                            "content": report_content,
-                            "generated_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-                            "word_count": len(report_content.split()),
-                            "sources_used": list(final_state.get("research_notes", {}).keys()) if "research_notes" in final_state else []
+                            "title": "Research Notes (Report Incomplete)",
+                            "content": final_report_content,
+                            "word_count": len(final_report_content.split()),
+                            "generated_at": datetime.now().isoformat(),
+                            "research_notes_count": len(research_notes),
+                            "status": "incomplete"
                         }
-                        
-                        if workflow_state.get("has_report"):
-                            final_report = gr.Markdown(report_content, visible=True)
-        except Exception as state_error:
-            print(f"Could not extract final state: {state_error}")
-            # Try to show any report that was generated during the conversation
-            if workflow_state.get("has_report"):
-                final_report = gr.Markdown("Report was generated but could not be extracted from final state.", visible=True)
+                        print(f"DEBUG: Created fallback report from research notes")
+                    else:
+                        final_report_content = None
+                        structured_report_data = None
+        else:
+            print("DEBUG: No final state retrieved")
+            final_report_content = None
+            structured_report_data = None
         
-        # Add completion message
-        completion_msg = ChatMessage(
+        history.append(ChatMessage(
             role="assistant",
-            content="✅ **Workflow completed!** The agent collaboration has finished.",
+            content="✅ **Workflow completed!**",
             metadata={"title": "Workflow Complete"}
-        )
-        history.append(completion_msg)
-        
-        # Ensure we show the final report if we have structured data but no report was set
-        if structured_report_data and final_report is None:
-            if "content" in structured_report_data:
-                final_report = gr.Markdown(structured_report_data["content"], visible=True)
-        
-        # Create the structured report display component
-        structured_report_display = gr.JSON(
-            value=structured_report_data,
-            visible=bool(structured_report_data)
-        )
-        
-        yield history, final_report, structured_report_display
+        ))
+
+        if final_report_content:
+            final_report_update = gr.update(value=final_report_content, visible=True)
+            json_report_update = gr.update(value=structured_report_data, visible=True) if structured_report_data else gr.update(visible=False)
+        else:
+            final_report_update = gr.update(value="*No final report was generated. Check the workflow execution above.*", visible=True)
+            json_report_update = gr.update(visible=False)
         
+        yield history, final_report_update, json_report_update, gr.update(interactive=True, placeholder="Enter your next request...")
+
     except Exception as e:
-        # Handle errors gracefully
-        error_msg = ChatMessage(
-            role="assistant",
-            content=f"❌ **Error:** {str(e)}",
-            metadata={"title": "Error"}
-        )
-        history.append(error_msg)
-        yield history, None, gr.JSON(visible=False)
+        print(f"ERROR in chat_with_agent: {e}")
+        import traceback
+        traceback.print_exc()
+        history.append(ChatMessage(role="assistant", content=f"❌ **Error:** {str(e)}", metadata={"title": "Error"}))
+        yield history, gr.update(visible=False), gr.update(visible=False), gr.update(interactive=True)
 
 def like_feedback(evt: gr.LikeData):
     """Handle user feedback on messages."""
@@ -279,67 +212,43 @@ with gr.Blocks(title="Teacher-Student Agent Workflow", theme=gr.themes.Soft()) a
     """)
     
     chatbot = gr.Chatbot(
+        label="Agent Workflow",
         type="messages",
         height=600,
         show_copy_button=True,
-        placeholder="<strong>Welcome to the Teacher-Student Agent Workflow!</strong><br>Ask me to write a report on any topic and watch the agents collaborate.",
+        placeholder="Ask me to write a report on any topic...",
         render_markdown=True
     )
     
-    textbox = gr.Textbox(
-        placeholder="Enter your request (e.g., 'Write a report on artificial intelligence')",
-        container=False,
-        scale=7
-    )
-    
-    # Create the final report output component
-    final_report_output = gr.Markdown(
-        label="📄 Final Approved Report",
-        visible=False,
-        render=False
-    )
-    
-    # Create structured report metadata component
-    structured_report_json = gr.JSON(
-        label="📊 Report Metadata",
-        visible=False,
-        render=False
-    )
-    
-    # Set up the chat interface with additional outputs
-    chat_interface = gr.ChatInterface(
-        fn=chat_with_agent,
-        chatbot=chatbot,
-        textbox=textbox,
-        type="messages",
+    with gr.Row():
+        textbox = gr.Textbox(
+            placeholder="Enter your request...",
+            container=False,
+            scale=7
+        )
+        submit_btn = gr.Button("Submit", variant="primary", scale=1)
+
+    with gr.Row():
+        with gr.Column(scale=2):
+            final_report_output = gr.Textbox(
+                label="📄 Final Report",
+                interactive=False,
+                lines=20,
+                show_copy_button=True,
+                visible=False
+            )
+        with gr.Column(scale=1):
+            structured_report_json = gr.JSON(label="📊 Report Metadata", visible=False)
+
+    gr.Examples(
         examples=[
             "Write a report on the history of artificial intelligence",
             "Create a report about renewable energy technologies",
             "Write a report on the impact of social media on society",
-            "Generate a report about space exploration achievements"
-        ],
-        example_labels=[
-            "AI History Report",
-            "Renewable Energy Report", 
-            "Social Media Impact Report",
-            "Space Exploration Report"
         ],
-        cache_examples=False,
-        additional_outputs=[final_report_output, structured_report_json]
+        inputs=textbox,
     )
     
-    # Add feedback handling
-    chatbot.like(like_feedback)
-    
-    # Render the final report output in a separate section
-    with gr.Row():
-        with gr.Column(scale=2):
-            gr.Markdown("### 📋 Final Report")
-            final_report_output.render()
-        with gr.Column(scale=1):
-            gr.Markdown("### 📊 Report Metadata")
-            structured_report_json.render()
-    
     gr.Markdown("""
     ### How it works:
     1. **ResearchAgent** searches for information and takes notes
@@ -350,5 +259,20 @@ with gr.Blocks(title="Teacher-Student Agent Workflow", theme=gr.themes.Soft()) a
     Watch the real-time collaboration between agents as they work together!
     """)
 
+    # Event handlers
+    submit_btn.click(
+        chat_with_agent,
+        inputs=[textbox, chatbot],
+        outputs=[chatbot, final_report_output, structured_report_json, textbox],
+        queue=True
+    )
+    
+    textbox.submit(
+        chat_with_agent,
+        inputs=[textbox, chatbot],
+        outputs=[chatbot, final_report_output, structured_report_json, textbox],
+        queue=True
+    )
+
 if __name__ == "__main__":
     demo.launch()

pyproject.toml

@@ -9,5 +9,6 @@ dependencies = [
     "dotenv>=0.9.9",
     "gradio>=5.33.0",
     "llama-index>=0.12.40",
+    "llama-index-llms-huggingface-api>=0.5.0",
     "tavily-python>=0.7.5",
 ]

requirements.txt

@@ -48,6 +48,7 @@ llama-index-core==0.12.40
 llama-index-embeddings-huggingface==0.5.4
 llama-index-embeddings-openai==0.3.1
 llama-index-indices-managed-llama-cloud==0.7.4
+llama-index-llms-huggingface-api==0.5.1
 llama-index-llms-ollama==0.6.2
 llama-index-llms-openai==0.4.3
 llama-index-multi-modal-llms-openai==0.5.1

simple_test.py

@@ -0,0 +1,109 @@
+"""Simple test to manually check tool execution during workflow streaming."""
+
+import asyncio
+import os
+from dotenv import load_dotenv
+from agent import TeacherStudentAgentWorkflow
+from tools.simple_tools import get_workflow_state, reset_workflow_state
+
+load_dotenv(os.path.join(os.path.dirname(__file__), 'env.local'))
+
+async def test_workflow_tool_execution():
+    """Monitor tool execution during workflow execution."""
+    print("Testing workflow tool execution...")
+    
+    # Reset state
+    reset_workflow_state()
+    print(f"Initial state: {get_workflow_state()}")
+    
+    workflow = TeacherStudentAgentWorkflow()
+    
+    # Start workflow
+    print("\nStarting workflow...")
+    handler = workflow.agent_workflow.run(user_msg="Write a short report about renewable energy")
+    
+    tool_calls_seen = []
+    tool_results_seen = []
+    
+    print("\nMonitoring events...")
+    async for event in handler.stream_events():
+        event_type = type(event).__name__
+        print(f"📅 Event: {event_type}")
+        
+        # Check for agent outputs and their content
+        if hasattr(event, 'response') and hasattr(event.response, 'content'):
+            if event.response.content:
+                print(f"  💬 Agent Response: {event.response.content}")
+                
+                # Check if this looks like a handoff message
+                content = event.response.content.lower()
+                if 'handoff' in content or 'handing off' in content:
+                    print(f"  🔄 HANDOFF DETECTED: {event.response.content}")
+                    
+        # Monitor for tool-related events
+        if hasattr(event, 'tool_name') and hasattr(event, 'tool_kwargs'):
+            tool_call_info = {
+                'tool_name': event.tool_name,
+                'tool_kwargs': event.tool_kwargs,
+                'event_type': event_type
+            }
+            tool_calls_seen.append(tool_call_info)
+            print(f"  🔨 Tool Call: {event.tool_name}")
+            print(f"     Args: {event.tool_kwargs}")
+            
+            # Check state after this tool call event
+            current_state = get_workflow_state()
+            if event.tool_name == 'write_report':
+                print(f"     State after write_report call:")
+                print(f"       - report_content: {current_state.get('report_content', 'Not written')[:50]}...")
+                print(f"       - structured_report: {current_state.get('structured_report') is not None}")
+                
+        # Check for agent name changes (handoffs)
+        if hasattr(event, 'current_agent_name'):
+            print(f"  🤖 Current Agent: {event.current_agent_name}")
+        
+        if hasattr(event, 'tool_output'):
+            tool_result_info = {
+                'tool_name': getattr(event, 'tool_name', 'unknown'),
+                'tool_output': event.tool_output,
+                'event_type': event_type
+            }
+            tool_results_seen.append(tool_result_info)
+            print(f"  🔧 Tool Result: {getattr(event, 'tool_name', 'unknown')}")
+            print(f"     Output: {str(event.tool_output)[:100]}...")
+    
+    print(f"\n📊 Summary:")
+    print(f"Tool calls seen: {len(tool_calls_seen)}")
+    print(f"Tool results seen: {len(tool_results_seen)}")
+    
+    for i, call in enumerate(tool_calls_seen):
+        print(f"  Call {i+1}: {call['tool_name']} ({call['event_type']})")
+    
+    for i, result in enumerate(tool_results_seen):
+        print(f"  Result {i+1}: {result['tool_name']} ({result['event_type']})")
+    
+    # Final state check
+    final_state = get_workflow_state()
+    print(f"\nFinal state:")
+    print(f"- Research notes: {len(final_state.get('research_notes', {}))}")
+    print(f"- Report content: {final_state.get('report_content', 'Not written')[:100]}...")
+    print(f"- Has structured report: {final_state.get('structured_report') is not None}")
+    
+    # Try to identify the issue
+    write_report_calls = [c for c in tool_calls_seen if c['tool_name'] == 'write_report']
+    write_report_results = [r for r in tool_results_seen if r['tool_name'] == 'write_report']
+    
+    print(f"\nDiagnosis:")
+    print(f"- write_report calls: {len(write_report_calls)}")
+    print(f"- write_report results: {len(write_report_results)}")
+    
+    if write_report_calls and not write_report_results:
+        print("❌ ISSUE: write_report tool was called but no results were seen!")
+        print("This suggests the tool function is never actually executed.")
+    elif len(write_report_calls) != len(write_report_results):
+        print(f"❌ ISSUE: Mismatch between calls ({len(write_report_calls)}) and results ({len(write_report_results)})")
+    else:
+        print("✅ Tool call/result count matches")
+
+if __name__ == "__main__":
+    asyncio.run(test_workflow_tool_execution()) 

test_tools.py

@@ -0,0 +1,96 @@
+import asyncio
+from llama_index.core.workflow import Context
+from llama_index.core.agent.workflow import AgentWorkflow
+from tools.tavily_search_tool import (
+    search_web, record_notes, write_report, review_report,
+    SearchWebArgs, RecordNotesArgs, WriteReportArgs, ReviewReportArgs
+)
+
+async def test_tools():
+    """Test all tools with the new Pydantic signatures."""
+    print("Testing tools with new Pydantic model arguments...")
+    
+    # Create a simple workflow for context
+    workflow = AgentWorkflow(agents=[], root_agent=None)
+    ctx = Context(workflow)
+    
+    # Initialize state
+    await ctx.set("state", {
+        "research_notes": {},
+        "report_content": "Not written yet.",
+        "review": "Review required.",
+    })
+    
+    print("\n1. Testing search_web...")
+    try:
+        search_args = SearchWebArgs(query="artificial intelligence history")
+        search_result = await search_web(search_args)
+        print(f"✅ search_web worked! Result length: {len(search_result)}")
+        print(f"Preview: {search_result[:200]}...")
+    except Exception as e:
+        print(f"❌ search_web failed: {e}")
+    
+    print("\n2. Testing record_notes...")
+    try:
+        notes_args = RecordNotesArgs(
+            notes="Test research notes about AI history",
+            notes_title="AI History Overview"
+        )
+        notes_result = await record_notes(ctx, notes_args)
+        print(f"✅ record_notes worked! Result: {notes_result}")
+        
+        # Check state
+        state = await ctx.get("state")
+        print(f"State after notes: {list(state.keys())}")
+        print(f"Research notes: {state.get('research_notes', {})}")
+    except Exception as e:
+        print(f"❌ record_notes failed: {e}")
+    
+    print("\n3. Testing write_report...")
+    try:
+        report_args = WriteReportArgs(
+            report_content="""# Artificial Intelligence History
+
+## Introduction
+This is a test report about AI history.
+
+## Early Development
+AI began in the 1950s with researchers like Alan Turing.
+
+## Modern Era
+Today, AI includes machine learning and deep learning.
+
+## Conclusion
+AI continues to evolve rapidly.""",
+            title="Test AI History Report"
+        )
+        report_result = await write_report(ctx, report_args)
+        print(f"✅ write_report worked! Result: {report_result}")
+        
+        # Check state
+        state = await ctx.get("state")
+        print(f"Report content length: {len(state.get('report_content', ''))}")
+        print(f"Has structured report: {'structured_report' in state}")
+    except Exception as e:
+        print(f"❌ write_report failed: {e}")
+    
+    print("\n4. Testing review_report...")
+    try:
+        review_args = ReviewReportArgs(review="APPROVED: The report looks good!")
+        review_result = await review_report(ctx, review_args)
+        print(f"✅ review_report worked! Result: {review_result}")
+        
+        # Check final state
+        state = await ctx.get("state")
+        print(f"Final review: {state.get('review', 'No review')}")
+    except Exception as e:
+        print(f"❌ review_report failed: {e}")
+    
+    print("\n5. Final state check...")
+    final_state = await ctx.get("state")
+    print(f"Final state keys: {list(final_state.keys())}")
+    print(f"Research notes count: {len(final_state.get('research_notes', {}))}")
+    print(f"Report written: {final_state.get('report_content', 'Not written') != 'Not written yet.'}")
+
+if __name__ == "__main__":
+    asyncio.run(test_tools()) 

tools/simple_tools.py

@@ -0,0 +1,225 @@
+"""Simple synchronous tools for LlamaIndex ReActAgent."""
+
+import os
+import time
+import hashlib
+import json
+from typing import Optional
+from datetime import datetime
+from tavily import TavilyClient  # Use sync client
+from llama_index.core.tools import FunctionTool
+
+# Global state store - simple in-memory storage
+_workflow_state = {
+    "research_notes": {},
+    "report_content": "Not written yet.",
+    "review": "Review required.",
+    "structured_report": None
+}
+
+# Global cache to track recent tool calls
+_tool_call_cache = {}
+_cache_timeout = 30
+
+def _generate_call_hash(tool_name: str, **kwargs) -> str:
+    """Generate a hash for tool call deduplication."""
+    call_data = {"tool": tool_name, "args": kwargs}
+    call_str = json.dumps(call_data, sort_keys=True)
+    return hashlib.md5(call_str.encode()).hexdigest()
+
+def _should_execute_call(tool_name: str, **kwargs) -> bool:
+    """Check if a tool call should be executed or if it's a duplicate."""
+    current_time = time.time()
+    call_hash = _generate_call_hash(tool_name, **kwargs)
+    
+    # Clean up old cache entries
+    expired_keys = [k for k, v in _tool_call_cache.items() if current_time - v > _cache_timeout]
+    for key in expired_keys:
+        del _tool_call_cache[key]
+    
+    # Check if this call was made recently
+    if call_hash in _tool_call_cache:
+        return False
+    
+    # Record this call
+    _tool_call_cache[call_hash] = current_time
+    return True
+
+def search_web(query: str) -> str:
+    """Search the web for information on a given query."""
+    try:
+        print(f"DEBUG: search_web called with query: '{query}'")
+        
+        # Check for duplicate calls
+        if not _should_execute_call("search_web", query=query):
+            return f"Duplicate search call detected for query: '{query}'. Skipping to avoid redundant API calls."
+        
+        # Use synchronous Tavily client
+        client = TavilyClient(api_key=os.getenv("TAVILY_API_KEY"))
+        result = client.search(query)
+        
+        print(f"DEBUG: search_web executed successfully for query: '{query}'")
+        return str(result)
+    except Exception as e:
+        error_msg = f"Search failed: {str(e)}"
+        print(f"ERROR: search_web failed: {e}")
+        return error_msg
+
+def record_notes(notes: str, notes_title: str) -> str:
+    """Record notes on a given topic with a title."""
+    try:
+        print(f"DEBUG: record_notes called with title: '{notes_title}', notes length: {len(notes)}")
+        
+        # Check for duplicate calls
+        if not _should_execute_call("record_notes", notes=notes, notes_title=notes_title):
+            return f"Duplicate notes recording detected for title: '{notes_title}'. Skipping to avoid redundant recording."
+        
+        # Store in global state
+        _workflow_state["research_notes"][notes_title] = notes
+        
+        print(f"DEBUG: Notes stored. Total research notes: {len(_workflow_state['research_notes'])}")
+        return f"Notes recorded successfully with title: '{notes_title}'. Total notes: {len(_workflow_state['research_notes'])}"
+    except Exception as e:
+        error_msg = f"Failed to record notes: {str(e)}"
+        print(f"ERROR: record_notes failed: {e}")
+        return error_msg
+
+def write_report(report_content: str, title: str = "Research Report") -> str:
+    """Write a structured report with the given content and title."""
+    try:
+        print(f"DEBUG: write_report FUNCTION ENTERED with title: '{title}', content length: {len(report_content)}")
+        print(f"DEBUG: Function arguments - report_content type: {type(report_content)}, title type: {type(title)}")
+        
+        # Check for duplicate calls
+        if not _should_execute_call("write_report", report_content=report_content, title=title):
+            print("DEBUG: Duplicate call detected, returning early")
+            return "Duplicate report writing detected. Skipping to avoid redundant report generation."
+        
+        print("DEBUG: Processing report content...")
+        
+        # Extract sections from markdown content
+        import re
+        sections = re.findall(r'^#{1,3}\s+(.+)$', report_content, re.MULTILINE)
+        print(f"DEBUG: Found {len(sections)} sections: {sections}")
+        
+        # Calculate word count
+        word_count = len(report_content.split())
+        print(f"DEBUG: Word count: {word_count}")
+        
+        # Extract abstract (first paragraph after title)
+        lines = report_content.split('\n')
+        abstract = ""
+        for line in lines:
+            if line.strip() and not line.startswith('#'):
+                abstract = line.strip()
+                break
+        print(f"DEBUG: Abstract: {abstract[:100]}...")
+        
+        # Create structured report
+        structured_report = {
+            "title": title,
+            "abstract": abstract[:200] + "..." if len(abstract) > 200 else abstract,
+            "content": report_content,
+            "sections": sections,
+            "word_count": word_count,
+            "generated_at": datetime.now().isoformat(),
+            "sources_used": list(_workflow_state["research_notes"].keys())
+        }
+        print("DEBUG: Structured report created")
+        
+        # Store in global state
+        print("DEBUG: Storing in global state...")
+        _workflow_state["report_content"] = report_content
+        _workflow_state["structured_report"] = structured_report
+        
+        print(f"DEBUG: Report stored successfully. Word count: {word_count}, Sections: {len(sections)}")
+        print(f"DEBUG: State keys now: {list(_workflow_state.keys())}")
+        print(f"DEBUG: State report_content length: {len(_workflow_state['report_content'])}")
+        
+        result = f"Report written successfully! Title: '{title}', Word count: {word_count}, Sections: {len(sections)}"
+        print(f"DEBUG: Returning result: {result}")
+        return result
+    except Exception as e:
+        error_msg = f"Failed to write report: {str(e)}"
+        print(f"ERROR: write_report failed: {e}")
+        import traceback
+        traceback.print_exc()
+        return error_msg
+
+def review_report(review: str) -> str:
+    """Review a report and provide feedback."""
+    try:
+        print(f"DEBUG: review_report called with review: '{review[:100]}...'")
+        
+        # Check for duplicate calls
+        if not _should_execute_call("review_report", review=review):
+            return "Duplicate review detected. Skipping to avoid redundant review submission."
+        
+        # Store review in global state
+        _workflow_state["review"] = review
+        
+        print(f"DEBUG: Review stored successfully")
+        return f"Report reviewed successfully. Review: {review[:100]}{'...' if len(review) > 100 else ''}"
+    except Exception as e:
+        error_msg = f"Failed to review report: {str(e)}"
+        print(f"ERROR: review_report failed: {e}")
+        return error_msg
+
+def get_workflow_state() -> dict:
+    """Get the current workflow state."""
+    return _workflow_state.copy()
+
+def reset_workflow_state():
+    """Reset the workflow state."""
+    global _workflow_state
+    _workflow_state = {
+        "research_notes": {},
+        "report_content": "Not written yet.",
+        "review": "Review required.",
+        "structured_report": None
+    }
+
+# Create LlamaIndex FunctionTool instances with better descriptions
+search_web_tool = FunctionTool.from_defaults(
+    fn=search_web,
+    name="search_web",
+    description=(
+        "Search the web for information on any topic. "
+        "Input: A search query string. "
+        "Output: Search results containing relevant information. "
+        "Use this to gather facts and information about your research topic."
+    ),
+)
+
+record_notes_tool = FunctionTool.from_defaults(
+    fn=record_notes,
+    name="record_notes", 
+    description=(
+        "Record research notes with a descriptive title. "
+        "Input: notes (string) - the content to save, notes_title (string) - a title for the notes. "
+        "Output: Confirmation that notes were saved. "
+        "Use this after searching to save important information you found."
+    ),
+)
+
+write_report_tool = FunctionTool.from_defaults(
+    fn=write_report,
+    name="write_report",
+    description=(
+        "Write a comprehensive markdown report. "
+        "Input: report_content (string) - full markdown report content, title (string, optional) - report title. "
+        "Output: Confirmation that report was written. "
+        "The report_content should be well-structured markdown with headers, sections, and detailed content."
+    ),
+)
+
+review_report_tool = FunctionTool.from_defaults(
+    fn=review_report,
+    name="review_report",
+    description=(
+        "Review a written report and provide feedback. "
+        "Input: review (string) - your review and feedback on the report. "
+        "Output: Confirmation that review was recorded. "
+        "Start with 'APPROVED:' if the report is satisfactory, otherwise provide specific improvement suggestions."
+    ),
+) 

tools/tavily_search_tool.py

@@ -1,5 +1,6 @@
 from tavily import AsyncTavilyClient
 from llama_index.core.workflow import Context
+from llama_index.core.tools import FunctionTool
 from dotenv import load_dotenv
 import os
 import time
@@ -40,29 +41,270 @@ def _should_execute_call(tool_name: str, **kwargs) -> bool:
     _tool_call_cache[call_hash] = current_time
     return True
 
-async def search_web(query: str) -> str:
-    """Useful for using the web to answer questions."""
-    # Check for duplicate calls
-    if not _should_execute_call("search_web", query=query):
-        return f"Duplicate search call detected for query: '{query}'. Skipping to avoid redundant API calls."
-    
-    client = AsyncTavilyClient(api_key=os.getenv("TAVILY_API_KEY"))
-    return str(await client.search(query))
+# Pydantic models for tool arguments
+class SearchWebArgs(BaseModel):
+    query: str = Field(..., description="The search query to use")
 
+class RecordNotesArgs(BaseModel):
+    notes: str = Field(..., description="The notes to record")
+    notes_title: str = Field(..., description="The title for the notes")
 
-async def record_notes(ctx: Context, notes: str, notes_title: str) -> str:
-    """Useful for recording notes on a given topic. Your input should be notes with a title to save the notes under."""
-    # Check for duplicate calls
-    if not _should_execute_call("record_notes", notes=notes, notes_title=notes_title):
-        return f"Duplicate notes recording detected for title: '{notes_title}'. Skipping to avoid redundant recording."
-    
-    current_state = await ctx.get("state")
-    if "research_notes" not in current_state:
-        current_state["research_notes"] = {}
-    current_state["research_notes"][notes_title] = notes
-    await ctx.set("state", current_state)
-    return "Notes recorded."
+class WriteReportArgs(BaseModel):
+    report_content: str = Field(..., description="The full markdown report content")
+    title: str = Field(default="Research Report", description="The title of the report")
+
+class ReviewReportArgs(BaseModel):
+    review: str = Field(..., description="The review feedback for the report")
+
+# Core async functions
+async def _search_web_impl(query: str) -> str:
+    """Internal implementation of web search."""
+    try:
+        # Check for duplicate calls
+        if not _should_execute_call("search_web", query=query):
+            return f"Duplicate search call detected for query: '{query}'. Skipping to avoid redundant API calls."
+        
+        client = AsyncTavilyClient(api_key=os.getenv("TAVILY_API_KEY"))
+        result = await client.search(query)
+        print(f"DEBUG: search_web executed successfully for query: '{query}'")
+        return str(result)
+    except Exception as e:
+        print(f"ERROR: search_web failed: {e}")
+        return f"Search failed: {str(e)}"
+
+async def _record_notes_impl(notes: str, notes_title: str) -> str:
+    """Internal implementation of recording notes."""
+    try:
+        # Check for duplicate calls
+        if not _should_execute_call("record_notes", notes=notes, notes_title=notes_title):
+            return f"Duplicate notes recording detected for title: '{notes_title}'. Skipping to avoid redundant recording."
+        
+        # Get the context from the current workflow
+        # Note: This is a simplified implementation - in practice, we'd need to pass context
+        print(f"DEBUG: record_notes called with title: '{notes_title}', notes length: {len(notes)}")
+        return f"Notes recorded successfully with title: '{notes_title}'"
+    except Exception as e:
+        print(f"ERROR: record_notes failed: {e}")
+        return f"Failed to record notes: {str(e)}"
+
+async def _write_report_impl(report_content: str, title: str = "Research Report") -> str:
+    """Internal implementation of writing report."""
+    try:
+        print(f"DEBUG: write_report called with title='{title}', content length={len(report_content)}")
+        
+        # Check for duplicate calls
+        if not _should_execute_call("write_report", report_content=report_content, title=title):
+            return "Duplicate report writing detected. Skipping to avoid redundant report generation."
+        
+        # Extract sections from markdown content (look for ## headers)
+        import re
+        sections = re.findall(r'^#{1,3}\s+(.+)$', report_content, re.MULTILINE)
+        
+        # Calculate word count (approximate)
+        word_count = len(report_content.split())
+        
+        print(f"DEBUG: Report processed. Word count: {word_count}, Sections: {len(sections)}")
+        
+        return f"Report written successfully. Title: '{title}', Word count: {word_count}, Sections: {len(sections)}"
+    except Exception as e:
+        print(f"ERROR: write_report failed: {e}")
+        return f"Failed to write report: {str(e)}"
+
+async def _review_report_impl(review: str) -> str:
+    """Internal implementation of reviewing report."""
+    try:
+        # Check for duplicate calls
+        if not _should_execute_call("review_report", review=review):
+            return "Duplicate review detected. Skipping to avoid redundant review submission."
+        
+        print(f"DEBUG: review_report executed successfully. Review: '{review[:100]}...'")
+        return "Report reviewed successfully."
+    except Exception as e:
+        print(f"ERROR: review_report failed: {e}")
+        return f"Failed to review report: {str(e)}"
+
+# Synchronous wrapper functions for LlamaIndex FunctionTool
+def search_web_sync(query: str) -> str:
+    """Synchronous wrapper for search_web."""
+    import asyncio
+    try:
+        loop = asyncio.get_event_loop()
+        if loop.is_running():
+            # If we're already in an async context, create a new loop
+            import nest_asyncio
+            nest_asyncio.apply()
+        return loop.run_until_complete(_search_web_impl(query))
+    except RuntimeError:
+        # Create new event loop if none exists
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        try:
+            return loop.run_until_complete(_search_web_impl(query))
+        finally:
+            loop.close()
+
+def record_notes_sync(notes: str, notes_title: str) -> str:
+    """Synchronous wrapper for record_notes."""
+    import asyncio
+    try:
+        loop = asyncio.get_event_loop()
+        if loop.is_running():
+            import nest_asyncio
+            nest_asyncio.apply()
+        return loop.run_until_complete(_record_notes_impl(notes, notes_title))
+    except RuntimeError:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        try:
+            return loop.run_until_complete(_record_notes_impl(notes, notes_title))
+        finally:
+            loop.close()
+
+def write_report_sync(report_content: str, title: str = "Research Report") -> str:
+    """Synchronous wrapper for write_report."""
+    import asyncio
+    try:
+        loop = asyncio.get_event_loop()
+        if loop.is_running():
+            import nest_asyncio
+            nest_asyncio.apply()
+        return loop.run_until_complete(_write_report_impl(report_content, title))
+    except RuntimeError:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        try:
+            return loop.run_until_complete(_write_report_impl(report_content, title))
+        finally:
+            loop.close()
+
+def review_report_sync(review: str) -> str:
+    """Synchronous wrapper for review_report."""
+    import asyncio
+    try:
+        loop = asyncio.get_event_loop()
+        if loop.is_running():
+            import nest_asyncio
+            nest_asyncio.apply()
+        return loop.run_until_complete(_review_report_impl(review))
+    except RuntimeError:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        try:
+            return loop.run_until_complete(_review_report_impl(review))
+        finally:
+            loop.close()
+
+# Create LlamaIndex FunctionTool instances
+search_web = FunctionTool.from_defaults(
+    fn=search_web_sync,
+    name="search_web",
+    description="Search the web for information on a given query. Input should be a search query string.",
+)
+
+record_notes = FunctionTool.from_defaults(
+    fn=record_notes_sync,
+    name="record_notes", 
+    description="Record notes on a given topic. Input should be the notes content and a title for the notes.",
+)
+
+write_report = FunctionTool.from_defaults(
+    fn=write_report_sync,
+    name="write_report",
+    description="Write a structured report. Input should be the full markdown report content and an optional title.",
+)
+
+review_report = FunctionTool.from_defaults(
+    fn=review_report_sync,
+    name="review_report",
+    description="Review a report and provide feedback. Input should be the review feedback text.",
+)
+
+# Keep the original async versions for direct use
+async def search_web_async(args: SearchWebArgs) -> str:
+    """Async version using Pydantic args."""
+    return await _search_web_impl(args.query)
 
+async def record_notes_async(ctx: Context, args: RecordNotesArgs) -> str:
+    """Async version using Pydantic args with context."""
+    try:
+        current_state = await ctx.get("state")
+        if current_state is None:
+            current_state = {"research_notes": {}, "report_content": "Not written yet.", "review": "Review required."}
+        
+        if "research_notes" not in current_state:
+            current_state["research_notes"] = {}
+        
+        current_state["research_notes"][args.notes_title] = args.notes
+        await ctx.set("state", current_state)
+        
+        return await _record_notes_impl(args.notes, args.notes_title)
+    except Exception as e:
+        print(f"ERROR: record_notes_async failed: {e}")
+        return f"Failed to record notes: {str(e)}"
+
+async def write_report_async(ctx: Context, args: WriteReportArgs) -> str:
+    """Async version using Pydantic args with context."""
+    try:
+        current_state = await ctx.get("state")
+        if current_state is None:
+            current_state = {"research_notes": {}, "report_content": "Not written yet.", "review": "Review required."}
+        
+        # Extract sections from markdown content (look for ## headers)
+        import re
+        sections = re.findall(r'^#{1,3}\s+(.+)$', args.report_content, re.MULTILINE)
+        
+        # Calculate word count (approximate)
+        word_count = len(args.report_content.split())
+        
+        # Extract abstract (first paragraph after title)
+        lines = args.report_content.split('\n')
+        abstract = ""
+        for line in lines:
+            if line.strip() and not line.startswith('#'):
+                abstract = line.strip()
+                break
+        
+        # Get sources from research notes
+        sources_used = list(current_state.get("research_notes", {}).keys()) if "research_notes" in current_state else None
+        
+        # Create structured report output
+        structured_report = ReportOutput(
+            title=args.title,
+            abstract=abstract[:200] + "..." if len(abstract) > 200 else abstract,
+            content=args.report_content,
+            sections=sections,
+            word_count=word_count,
+            sources_used=sources_used
+        )
+        
+        # Store both the original content and structured output
+        current_state["report_content"] = args.report_content
+        current_state["structured_report"] = structured_report.model_dump()
+        await ctx.set("state", current_state)
+        
+        print(f"DEBUG: Report stored in state. Keys now: {list(current_state.keys())}")
+        print(f"DEBUG: Report content length: {len(args.report_content)}")
+        print(f"DEBUG: Structured report created with {len(sections)} sections")
+        
+        return f"Report written successfully. Title: '{args.title}', Word count: {word_count}, Sections: {len(sections)}"
+    except Exception as e:
+        print(f"ERROR: write_report_async failed: {e}")
+        return f"Failed to write report: {str(e)}"
+
+async def review_report_async(ctx: Context, args: ReviewReportArgs) -> str:
+    """Async version using Pydantic args with context."""
+    try:
+        current_state = await ctx.get("state")
+        if current_state is None:
+            current_state = {"research_notes": {}, "report_content": "Not written yet.", "review": "Review required."}
+        
+        current_state["review"] = args.review
+        await ctx.set("state", current_state)
+        
+        return await _review_report_impl(args.review)
+    except Exception as e:
+        print(f"ERROR: review_report_async failed: {e}")
+        return f"Failed to review report: {str(e)}"
 
 class ReportOutput(BaseModel):
     """Structured output for the writer agent's report."""
@@ -74,64 +316,12 @@ class ReportOutput(BaseModel):
     generated_at: datetime = Field(default_factory=datetime.now, description="Timestamp when the report was generated")
     sources_used: Optional[List[str]] = Field(default=None, description="List of sources or research notes used")
 
-async def write_report(ctx: Context, report_content: str, title: str = "Research Report") -> str:
-    """Useful for writing a report on a given topic. Your input should be a markdown formatted report with a title."""
-    # Check for duplicate calls
-    if not _should_execute_call("write_report", report_content=report_content, title=title):
-        return "Duplicate report writing detected. Skipping to avoid redundant report generation."
-    
-    current_state = await ctx.get("state")
-    
-    # Extract sections from markdown content (look for ## headers)
-    import re
-    sections = re.findall(r'^#{1,3}\s+(.+)$', report_content, re.MULTILINE)
-    
-    # Calculate word count (approximate)
-    word_count = len(report_content.split())
-    
-    # Extract abstract (first paragraph after title)
-    lines = report_content.split('\n')
-    abstract = ""
-    for line in lines:
-        if line.strip() and not line.startswith('#'):
-            abstract = line.strip()
-            break
-    
-    # Get sources from research notes
-    sources_used = list(current_state.get("research_notes", {}).keys()) if "research_notes" in current_state else None
-    
-    # Create structured report output
-    structured_report = ReportOutput(
-        title=title,
-        abstract=abstract[:200] + "..." if len(abstract) > 200 else abstract,
-        content=report_content,
-        sections=sections,
-        word_count=word_count,
-        sources_used=sources_used
-    )
-    
-    # Store both the original content and structured output
-    current_state["report_content"] = report_content
-    current_state["structured_report"] = structured_report.model_dump()
-    await ctx.set("state", current_state)
-    
-    return f"Report written successfully. Title: '{title}', Word count: {word_count}, Sections: {len(sections)}"
-
-
-async def review_report(ctx: Context, review: str) -> str:
-    """Useful for reviewing a report and providing feedback. Your input should be a review of the report."""
-    # Check for duplicate calls
-    if not _should_execute_call("review_report", review=review):
-        return "Duplicate review detected. Skipping to avoid redundant review submission."
-    
-    current_state = await ctx.get("state")
-    current_state["review"] = review
-    await ctx.set("state", current_state)
-    return "Report reviewed."
-
-
 def get_structured_report_from_state(state: dict) -> Optional[ReportOutput]:
     """Helper function to extract structured report from workflow state."""
-    if "structured_report" in state:
-        return ReportOutput(**state["structured_report"])
-    return None
+    try:
+        if "structured_report" in state:
+            return ReportOutput(**state["structured_report"])
+        return None
+    except Exception as e:
+        print(f"ERROR: Failed to extract structured report: {e}")
+        return None

uv.lock

@@ -33,6 +33,7 @@ dependencies = [
     { name = "propcache" },
     { name = "yarl" },
 ]
+sdist = { url = "https://files.pythonhosted.org/packages/fc/76/cc6f37a12372dd72891dad5ffc3fc71375c2f92bb4a59f7ac11119332559/aiohttp-3.12.10.tar.gz", hash = "sha256:a9871b1b1381f8d8241f3ff3de5fcb6e2fdcfe8af43c35bb0496b8be550c5fb9", size = 7810445 }
 wheels = [
     { url = "https://files.pythonhosted.org/packages/39/92/74b8f79a643a87069e4e0ad9621e9e803d51798eba30accd785c71005ffa/aiohttp-3.12.10-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e093a24605e8cf71d8bccd54672581a72404b84fa3adafa2c416b67edff1ced1", size = 693434 },
     { url = "https://files.pythonhosted.org/packages/a6/e4/e4f5e0235e46be576843f3892ab4a846a3cdc72f44e4bc62d38c903a9f25/aiohttp-3.12.10-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:19a8d362b222a40fe97cd1641ce5c6a1fb2b2fbe2cf247d514f84f9c1d0f5549", size = 471098 },
@@ -767,6 +768,19 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/f6/1a/b2187464d9dbd4466eca0f710152903db01fc88ce6ecc46420d51bd52ac0/llama_index_indices_managed_llama_cloud-0.7.4-py3-none-any.whl", hash = "sha256:1d0ff874250c76615d0563409ebd887c5aac824382447054869a6be6335656bd", size = 15515 },
 ]
 
+[[package]]
+name = "llama-index-llms-huggingface-api"
+version = "0.5.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "huggingface-hub" },
+    { name = "llama-index-core" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/21/0c/ccf96de51b842fe1a6d5ccb666b54d78fe14ebb97f08dd82ff969c6b6a62/llama_index_llms_huggingface_api-0.5.0.tar.gz", hash = "sha256:87826a7ebc6946606f0c80007febd89688bd602622e2dbace452e0cde39a88bf", size = 7726 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/79/1d/be41914d77910f01a8608dadd6b8902548229e7bf7fd564f5f2fdf1c1f15/llama_index_llms_huggingface_api-0.5.0-py3-none-any.whl", hash = "sha256:b3ec0452c61be163fb934c3f507906717989dfa40d81a0b9489f3348e96b0979", size = 7489 },
+]
+
 [[package]]
 name = "llama-index-llms-openai"
 version = "0.4.3"
@@ -1523,6 +1537,7 @@ dependencies = [
     { name = "dotenv" },
     { name = "gradio" },
     { name = "llama-index" },
+    { name = "llama-index-llms-huggingface-api" },
     { name = "tavily-python" },
 ]
 
@@ -1532,6 +1547,7 @@ requires-dist = [
     { name = "dotenv", specifier = ">=0.9.9" },
     { name = "gradio", specifier = ">=5.33.0" },
     { name = "llama-index", specifier = ">=0.12.40" },
+    { name = "llama-index-llms-huggingface-api", specifier = ">=0.5.0" },
     { name = "tavily-python", specifier = ">=0.7.5" },
 ]