add research agent and use it as research manager

src/research_agent.py

@@ -0,0 +1,51 @@
+from agents import Agent, ModelSettings
+
+from planner import planner_agent
+from report_generator import ReportData, writer_agent
+from web_search import search_agent
+
+INSTRUCTIONS = (
+    "You are a senior research orchestrator tasked with answering complex user questions by calling the "
+    "appropriate tools.  You have access to the following tools:\n\n"
+    "1. planner_agent(input: str) -> WebSearchPlan - Produce up to five web-search queries that, when executed, "
+    "will help address the user's request.\n"
+    "3. search_agent(input: str) -> str - Run a single web search and return a concise summary of the results.\n"
+    "4. writer_agent(input: str) -> ReportData - Synthesise the final markdown report.  This **must** be the last "
+    "tool you call; treat its output as your final hand-off to the user.\n\n"
+    "Workflow guidelines:\n"
+    "> Think step-by-step and decide which tool to invoke next. \n"
+    "> After gathering clarifications (if any), call planner_agent once to devise your search strategy.\n"
+    "> Next, iterate through search_agent calls to collect evidence.  You may call search_agent multiple times to "
+    "cover each planned search term.\n"
+    "> If, after reviewing the results, you believe the information is still insufficient, you may make additional "
+    "calls to planner_agent or search_agent.  LIMIT yourself to a maximum of **two** extra tool calls beyond your "
+    "initial plan/execution.\n"
+    "> Once satisfied, call writer_agent **exactly once** and return its markdown_report to the user as your final "
+    "answer.\n"
+    "> Never reveal chain-of-thought or internal reasoning.  Keep your responses concise and focused on using the "
+    "tools effectively.\n\n"
+    "Remember: you have at most two extra tool invocations if you are unhappy with the intermediate results.  Choose "
+    "them wisely."
+)
+
+planner_tool = planner_agent.as_tool(
+    tool_name="planner_agent",
+    tool_description="Produce up to five web-search queries that, when executed, will help address the user's request.",
+)
+web_search_tool = search_agent.as_tool(
+    tool_name="search_agent",
+    tool_description="Run a single web search and return a concise summary of the results.",
+)
+writer_tool = writer_agent.as_tool(
+    tool_name="writer_agent", tool_description="Synthesise the markdown report."
+)
+tools = [planner_tool, web_search_tool, writer_tool]
+
+research_agent = Agent(
+    name="Research Agent",
+    instructions=INSTRUCTIONS,
+    tools=tools,
+    model="gpt-4o-mini",
+    model_settings=ModelSettings(tool_choice="auto"),
+    output_type=ReportData,
+)

src/research_manager.py

@@ -1,90 +1,30 @@
-import asyncio
-
 from agents import Runner, gen_trace_id, trace
 
 from clarifier import ClarifyingQuestions, clarifier_agent
-from planner import WebSearchItem, WebSearchPlan, planner_agent
-from report_generator import ReportData, writer_agent
-from web_search import search_agent
+from report_generator import ReportData
+from research_agent import research_agent
 
 
 class ResearchManager:
 
     async def run(self, query: str, clarifications: str | None = None):
-        """Run the deep research process, yielding status updates and the final report.
-
-        If *clarifications* are provided (the user's answers to the clarifying questions), we will use them to
-        augment the planning and reporting stages. Otherwise this behaves exactly like the previous implementation.
-        """
+        """Run the deep-research pipeline using `research_agent`."""
         trace_id = gen_trace_id()
         with trace("Research trace", trace_id=trace_id):
-            print("Starting research...")
-
-            # Combine the original query with any clarification the user has supplied.
-            if clarifications:
-                combined_query = (
-                    f"Original query: {query}\n\nUser clarifications:\n{clarifications}"
-                )
-            else:
-                combined_query = query
-
-            search_plan = await self.plan_searches(combined_query)
-            yield "Searches planned, starting to search..."
-            search_results = await self.perform_searches(search_plan)
-            yield "Searches complete, writing report..."
-            report = await self.write_report(combined_query, search_results)
-            yield report.markdown_report
+            print("Starting research with ResearchAgent…")
 
-    async def plan_searches(self, query: str) -> WebSearchPlan:
-        """Plan the searches to perform for the query"""
-        print("Planning searches...")
-        result = await Runner.run(
-            planner_agent,
-            f"Query: {query}",
-        )
-        print(f"Will perform {len(result.final_output.searches)} searches")
-        return result.final_output_as(WebSearchPlan)
-
-    async def perform_searches(self, search_plan: WebSearchPlan) -> list[str]:
-        """Perform the searches to perform for the query"""
-        print("Searching...")
-        num_completed = 0
-        tasks = [
-            asyncio.create_task(self.search(item)) for item in search_plan.searches
-        ]
-        results = []
-        for task in asyncio.as_completed(tasks):
-            result = await task
-            if result is not None:
-                results.append(result)
-            num_completed += 1
-            print(f"Searching... {num_completed}/{len(tasks)} completed")
-        print("Finished searching")
-        return results
-
-    async def search(self, item: WebSearchItem) -> str | None:
-        """Perform a search for the query"""
-        input = f"Search term: {item.query}\nReason for searching: {item.reason}"
-        try:
-            result = await Runner.run(
-                search_agent,
-                input,
+            combined_query = (
+                f"Original query: {query}\n\nUser clarifications:\n{clarifications}"
+                if clarifications
+                else query
             )
-            return str(result.final_output)
-        except Exception:
-            return None
+            yield "Research in progress…"
 
-    async def write_report(self, query: str, search_results: list[str]) -> ReportData:
-        """Write the report for the query"""
-        print("Thinking about report...")
-        input = f"{query}\nSummarized search results: {search_results}"
-        result = await Runner.run(
-            writer_agent,
-            input,
-        )
+            result = await Runner.run(research_agent, combined_query)
+            report: ReportData = result.final_output_as(ReportData)
 
-        print("Finished writing report")
-        return result.final_output_as(ReportData)
+            yield "Report generated. Rendering markdown…"
+            yield report.markdown_report
 
     async def get_clarifying_questions(self, query: str) -> list[str]:
         """Generate clarifying questions for a given query."""