alita-sdk 0.3.175__py3-none-any.whl → 0.3.177__py3-none-any.whl

alita_sdk/community/deep_researcher/agents/baseclass.py

@@ -1,182 +0,0 @@
-from typing import Any, Callable, Optional, List, Dict, Union, TypeVar, Generic, Type
-from pydantic import BaseModel
-import asyncio
-import json
-
-# LangChain imports
-from langchain_core.tools import BaseTool
-from langchain_core.messages import AIMessage, HumanMessage, SystemMessage, BaseMessage
-from langchain_core.prompts import ChatPromptTemplate
-from langchain.agents import AgentExecutor
-from langchain_core.runnables import RunnablePassthrough
-from langchain.agents.format_scratchpad import format_to_openai_functions
-from langchain.agents.output_parsers import OpenAIFunctionsAgentOutputParser
-from langchain_core.runnables.base import RunnableSerializable
-
-# Type variable for parameterizing the output type
-TContext = TypeVar("TContext")
-
-class ResearchRunner:
-    """
-    LangChain-based runner for research agents that supports both structured output
-    and custom output parsing.
-    """
-    
-    @classmethod
-    async def run(cls, agent, user_message: str, **kwargs) -> 'RunResult':
-        """
-        Run the agent with the given user message and return the result.
-        
-        Args:
-            agent: The agent to run
-            user_message: The user message to send to the agent
-            
-        Returns:
-            A RunResult containing the final output
-        """
-        if not isinstance(agent, ResearchAgent):
-            raise TypeError("Agent must be a ResearchAgent")
-        
-        result = await agent.arun(user_message)
-        return RunResult(final_output=result)
-
-class RunResult:
-    """
-    A simple class to maintain compatibility with the previous API
-    while using LangChain agents under the hood.
-    """
-    
-    def __init__(self, final_output: Any):
-        self.final_output = final_output
-    
-    def final_output_as(self, output_type: Type[Any]) -> Any:
-        """
-        Convert the final output to the specified type.
-        
-        Args:
-            output_type: The type to convert to
-            
-        Returns:
-            An instance of output_type
-        """
-        if isinstance(self.final_output, output_type):
-            return self.final_output
-        
-        if isinstance(self.final_output, str):
-            try:
-                # Try to parse as JSON if it's a string
-                parsed = json.loads(self.final_output)
-                return output_type(**parsed)
-            except Exception:
-                # If that fails, try to parse the string for JSON
-                try:
-                    # Look for JSON-like content in the string
-                    import re
-                    json_match = re.search(r'```json\n(.*?)\n```', self.final_output, re.DOTALL)
-                    if json_match:
-                        json_str = json_match.group(1)
-                        parsed = json.loads(json_str)
-                        return output_type(**parsed)
-                except Exception:
-                    pass
-        
-        # If all else fails, try to initialize with the entire output as a string
-        try:
-            if hasattr(output_type, "model_validate"):
-                return output_type.model_validate({"output": self.final_output})
-            else:
-                return output_type(output=self.final_output)
-        except Exception as e:
-            raise ValueError(f"Could not convert output to {output_type.__name__}: {e}")
-
-class ResearchAgent(Generic[TContext]):
-    """
-    LangChain-based agent for research tasks that supports both structured output
-    and custom output parsing.
-    """
-    
-    def __init__(
-        self,
-        name: str,
-        instructions: str,
-        tools: List[BaseTool],
-        model: Any,
-        output_type: Optional[Type[BaseModel]] = None,
-        output_parser: Optional[Callable[[str], Any]] = None
-    ):
-        self.name = name
-        self.instructions = instructions
-        self.tools = tools
-        self.model = model
-        self.output_type = output_type
-        self.output_parser = output_parser
-        
-        # Create the LangChain agent
-        self.agent = self._create_agent()
-    
-    def _create_agent(self) -> RunnableSerializable:
-        """
-        Create a LangChain agent with the specified configuration.
-        """
-        # Create the system prompt
-        system_prompt = self.instructions
-        
-        # Create the prompt template
-        prompt = ChatPromptTemplate.from_messages([
-            ("system", system_prompt),
-            ("human", "{input}"),
-            ("ai", "{agent_scratchpad}")
-        ])
-        
-        # Create the LangChain agent
-        agent = (
-            {
-                "input": RunnablePassthrough(),
-                "agent_scratchpad": lambda x: format_to_openai_functions(x["intermediate_steps"])
-            }
-            | prompt
-            | self.model
-            | OpenAIFunctionsAgentOutputParser()
-        )
-        
-        # Create the agent executor
-        return AgentExecutor(
-            agent=agent,
-            tools=self.tools,
-            verbose=True,
-            handle_parsing_errors=True
-        )
-    
-    async def arun(self, user_input: str) -> Any:
-        """
-        Run the agent asynchronously with the given user input.
-        
-        Args:
-            user_input: The user input to send to the agent
-            
-        Returns:
-            The agent's output
-        """
-        try:
-            # Run the agent
-            result = await self.agent.ainvoke({"input": user_input, "intermediate_steps": []})
-            output = result.get("output", "")
-            
-            # Apply output parser if specified
-            if self.output_parser is not None:
-                return self.output_parser(output)
-            
-            # Try to convert to output_type if specified
-            if self.output_type is not None:
-                try:
-                    return self.output_type.model_validate_json(output)
-                except Exception:
-                    try:
-                        return self.output_type.model_validate({"output": output})
-                    except Exception:
-                        pass
-            
-            # Otherwise return the raw output
-            return output
-        except Exception as e:
-            return f"Error: {str(e)}"

alita_sdk/community/deep_researcher/agents/knowledge_gap_agent.py

@@ -1,74 +0,0 @@
-"""
-Agent used to evaluate the state of the research report (typically done in a loop) and identify knowledge gaps that still 
-need to be addressed.
-
-The Agent takes as input a string in the following format:
-===========================================================
-ORIGINAL QUERY: <original user query>
-
-HISTORY OF ACTIONS, FINDINGS AND THOUGHTS: <breakdown of activities and findings carried out so far>
-===========================================================
-
-The Agent then:
-1. Carefully reviews the current draft and assesses its completeness in answering the original query
-2. Identifies specific knowledge gaps that still exist and need to be filled
-3. Returns a KnowledgeGapOutput object
-"""
-
-from pydantic import BaseModel, Field
-from typing import List, Optional, Any
-from langchain_core.tools import BaseTool
-from .baseclass import ResearchAgent
-from ..llm_config import LLMConfig, model_supports_structured_output
-from datetime import datetime
-from .utils.parse_output import create_type_parser
-
-class KnowledgeGapOutput(BaseModel):
-    """Output from the Knowledge Gap Agent"""
-    research_complete: bool = Field(description="Whether the research and findings are complete enough to end the research loop")
-    outstanding_gaps: List[str] = Field(description="List of knowledge gaps that still need to be addressed")
-
-
-INSTRUCTIONS = f"""
-You are a Research State Evaluator. Today's date is {datetime.now().strftime("%Y-%m-%d")}.
-Your job is to critically analyze the current state of a research report, 
-identify what knowledge gaps still exist and determine the best next step to take.
-
-You will be given:
-1. The original user query and any relevant background context to the query
-2. A full history of the tasks, actions, findings and thoughts you've made up until this point in the research process
-
-Your task is to:
-1. Carefully review the findings and thoughts, particularly from the latest iteration, and assess their completeness in answering the original query
-2. Determine if the findings are sufficiently complete to end the research loop
-3. If not, identify up to 3 knowledge gaps that need to be addressed in sequence in order to continue with research - these should be relevant to the original query
-
-Be specific in the gaps you identify and include relevant information as this will be passed onto another agent to process without additional context.
-
-Only output JSON. Follow the JSON schema below. Do not output anything else. I will be parsing this with Pydantic so output valid JSON only:
-{KnowledgeGapOutput.model_json_schema()}
-"""
-
-def init_knowledge_gap_agent(config: LLMConfig) -> ResearchAgent:
-    """
-    Initialize the knowledge gap agent.
-    
-    Args:
-        config: The LLM configuration to use
-        
-    Returns:
-        A ResearchAgent that can evaluate knowledge gaps
-    """
-    selected_model = config.fast_model
-    
-    # Determine whether to use structured output based on if we have a Langchain LLM
-    use_output_parser = not hasattr(selected_model, 'langchain_llm')
-    
-    return ResearchAgent(
-        name="KnowledgeGapAgent",
-        instructions=INSTRUCTIONS,
-        tools=[],  # No tools needed for this agent
-        model=selected_model.langchain_llm if hasattr(selected_model, 'langchain_llm') else selected_model,
-        output_type=KnowledgeGapOutput if not use_output_parser else None,
-        output_parser=create_type_parser(KnowledgeGapOutput) if use_output_parser else None
-    )

alita_sdk/community/deep_researcher/agents/long_writer_agent.py

@@ -1,251 +0,0 @@
-"""
-Agent used to synthesize a final report by iteratively writing each section of the report.
-Used to produce long reports given drafts of each section. Broadly aligned with the methodology described here:
-
-
-The LongWriterAgent takes as input a string in the following format:
-===========================================================
-ORIGINAL QUERY: <original user query>
-
-CURRENT REPORT DRAFT: <current working draft of the report, all sections up to the current one being written>
-
-TITLE OF NEXT SECTION TO WRITE: <title of the next section of the report to be written>
-
-DRAFT OF NEXT SECTION: <draft of the next section of the report>
-===========================================================
-
-The Agent then:
-1. Reads the current draft and the draft of the next section
-2. Writes the next section of the report
-3. Produces an updated draft of the new section to fit the flow of the report
-4. Returns the updated draft of the new section along with references/citations
-"""
-from .baseclass import ResearchAgent, ResearchRunner
-from ..llm_config import LLMConfig, model_supports_structured_output
-from .utils.parse_output import create_type_parser
-from datetime import datetime
-from pydantic import BaseModel, Field
-from .proofreader_agent import ReportDraft
-from typing import List, Tuple, Dict
-import re
-
-
-class LongWriterOutput(BaseModel):
-    next_section_markdown: str = Field(description="The final draft of the next section in markdown format")
-    references: List[str] = Field(description="A list of URLs and their corresponding reference numbers for the section")
-
-
-INSTRUCTIONS = f"""
-You are an expert report writer tasked with iteratively writing each section of a report. 
-Today's date is {datetime.now().strftime('%Y-%m-%d')}.
-You will be provided with:
-1. The original research query
-3. A final draft of the report containing the table of contents and all sections written up until this point (in the first iteration there will be no sections written yet)
-3. A first draft of the next section of the report to be written
-
-OBJECTIVE:
-1. Write a final draft of the next section of the report with numbered citations in square brackets in the body of the report
-2. Produce a list of references to be appended to the end of the report
-
-CITATIONS/REFERENCES:
-The citations should be in numerical order, written in numbered square brackets in the body of the report.
-Separately, a list of all URLs and their corresponding reference numbers will be included at the end of the report.
-Follow the example below for formatting.
-
-LongWriterOutput(
-    next_section_markdown="The company specializes in IT consulting [1](https://example.com/first-source-url). It operates in the software services market which is expected to grow at 10% per year [2](https://example.com/second-source-url).",
-    references=["[1] https://example.com/first-source-url", "[2] https://example.com/second-source-url"]
-)
-
-GUIDELINES:
-- You can reformat and reorganize the flow of the content and headings within a section to flow logically, but DO NOT remove details that were included in the first draft
-- Only remove text from the first draft if it is already mentioned earlier in the report, or if it should be covered in a later section per the table of contents
-- Ensure the heading for the section matches the table of contents
-- Format the final output and references section as markdown
-- Do not include a title for the reference section, just a list of numbered references
-
-Only output JSON. Follow the JSON schema below. Do not output anything else. I will be parsing this with Pydantic so output valid JSON only:
-{LongWriterOutput.model_json_schema()}
-"""
-
-def init_long_writer_agent(config: LLMConfig) -> ResearchAgent:
-    """
-    Initialize the long writer agent.
-    
-    Args:
-        config: The LLM configuration
-        
-    Returns:
-        A ResearchAgent capable of writing long-form content
-    """
-    selected_model = config.fast_model
-    
-    # Determine whether to use structured output
-    use_output_parser = not hasattr(selected_model, 'langchain_llm')
-    
-    return ResearchAgent(
-        name="LongWriterAgent",
-        instructions=INSTRUCTIONS,
-        tools=[],  # No tools needed for this agent
-        model=selected_model.langchain_llm if hasattr(selected_model, 'langchain_llm') else selected_model,
-        output_type=LongWriterOutput if not use_output_parser else None,
-        output_parser=create_type_parser(LongWriterOutput) if use_output_parser else None
-    )
-
-
-async def write_next_section(
-    long_writer_agent: ResearchAgent,
-    original_query: str,
-    report_draft: str,
-    next_section_title: str,
-    next_section_draft: str,
-) -> LongWriterOutput:
-    """Write the next section of the report"""
-
-    user_message = f"""
-    <ORIGINAL QUERY>
-    {original_query}
-    </ORIGINAL QUERY>
-
-    <CURRENT REPORT DRAFT>
-    {report_draft or "No draft yet"}
-    </CURRENT REPORT DRAFT>
-
-    <TITLE OF NEXT SECTION TO WRITE>
-    {next_section_title}
-    </TITLE OF NEXT SECTION TO WRITE>
-
-    <DRAFT OF NEXT SECTION>
-    {next_section_draft}
-    </DRAFT OF NEXT SECTION>
-    """
-
-    result = await ResearchRunner.run(
-        long_writer_agent,
-        user_message,
-    )
-
-    return result.final_output_as(LongWriterOutput)
-
-
-async def write_report(
-    long_writer_agent: ResearchAgent,
-    original_query: str,
-    report_title: str,
-    report_draft: ReportDraft,
-) -> str:
-    """Write the final report by iteratively writing each section"""
-
-    # Initialize the final draft of the report with the title and table of contents
-    final_draft = f"# {report_title}\n\n" + "## Table of Contents\n\n" + "\n".join([f"{i+1}. {section.section_title}" for i, section in enumerate(report_draft.sections)]) + "\n\n"
-    all_references = []
-
-    for section in report_draft.sections:
-        # Produce the final draft of each section and add it to the report with corresponding references
-        next_section_draft = await write_next_section(long_writer_agent, original_query, final_draft, section.section_title, section.section_content)
-        section_markdown, all_references = reformat_references(
-            next_section_draft.next_section_markdown, 
-            next_section_draft.references,
-            all_references
-        )
-        section_markdown = reformat_section_headings(section_markdown)
-        final_draft += section_markdown + '\n\n'
-
-    # Add the final references to the end of the report
-    final_draft += '## References:\n\n' + '  \n'.join(all_references)
-    return final_draft
-
-
-def reformat_references(
-        section_markdown: str, 
-        section_references: List[str], 
-        all_references: List[str] 
-    ) -> Tuple[str, List[str]]:
-    """
-    This method gracefully handles the re-numbering, de-duplication and re-formatting of references as new sections are added to the report draft.
-    It takes as input:
-    1. The markdown content of the new section containing inline references in square brackets, e.g. [1], [2]
-    2. The list of references for the new section, e.g. ["[1] https://example1.com", "[2] https://example2.com"]
-    3. The list of references covering all prior sections of the report
-
-    It returns:
-    1. The updated markdown content of the new section with the references re-numbered and de-duplicated, such that they increment from the previous references
-    2. The updated list of references for the full report, to include the new section's references
-    """
-    def convert_ref_list_to_map(ref_list: List[str]) -> Dict[str, str]:
-        ref_map = {}
-        for ref in ref_list:
-            try:
-                ref_num = int(ref.split(']')[0].strip('['))
-                url = ref.split(']', 1)[1].strip()
-                ref_map[url] = ref_num
-            except ValueError:
-                print(f"Invalid reference format: {ref}")
-                continue
-        return ref_map
-
-    section_ref_map = convert_ref_list_to_map(section_references)
-    report_ref_map = convert_ref_list_to_map(all_references)
-    section_to_report_ref_map = {}
-
-    report_urls = set(report_ref_map.keys())
-    ref_count = max(report_ref_map.values() or [0])
-    for url, section_ref_num in section_ref_map.items():
-        if url in report_urls:
-            section_to_report_ref_map[section_ref_num] = report_ref_map[url]
-        else:
-            # If the reference is not in the report, add it to the report
-            ref_count += 1
-            section_to_report_ref_map[section_ref_num] = ref_count
-            all_references.append(f"[{ref_count}] {url}")
-
-    def replace_reference(match):
-        # Extract the reference number from the match
-        ref_num = int(match.group(1))
-        # Look up the new reference number
-        mapped_ref_num = section_to_report_ref_map.get(ref_num)
-        if mapped_ref_num:
-            return f'[{mapped_ref_num}]'
-        return ''
-    
-    # Replace all references in a single pass using a replacement function
-    section_markdown = re.sub(r'\[(\d+)\]', replace_reference, section_markdown)
-
-    return section_markdown, all_references
-
-
-def reformat_section_headings(section_markdown: str) -> str:
-    """
-    Reformat the headings of a section to be consistent with the report, by rebasing the section's heading to be a level-2 heading
-
-    E.g. this:
-    # Big Title
-    Some content
-    ## Subsection
-
-    Becomes this:
-    ## Big Title
-    Some content
-    ### Subsection
-    """
-    # If the section is empty, return as-is
-    if not section_markdown.strip():
-        return section_markdown
-
-    # Find the first heading level
-    first_heading_match = re.search(r'^(#+)\s', section_markdown, re.MULTILINE)
-    if not first_heading_match:
-        return section_markdown
-
-    # Calculate the level adjustment needed
-    first_heading_level = len(first_heading_match.group(1))
-    level_adjustment = 2 - first_heading_level
-
-    def adjust_heading_level(match):
-        hashes = match.group(1)
-        content = match.group(2)
-        new_level = max(2, len(hashes) + level_adjustment)
-        return '#' * new_level + ' ' + content
-
-    # Apply the heading adjustment to all headings in one pass
-    return re.sub(r'^(#+)\s(.+)$', adjust_heading_level, section_markdown, flags=re.MULTILINE)

alita_sdk/community/deep_researcher/agents/planner_agent.py

@@ -1,124 +0,0 @@
-"""
-Agent used to produce an initial outline of the report, including a list of section titles and the key question to be 
-addressed in each section.
-
-The Agent takes as input a string in the following format:
-===========================================================
-QUERY: <original user query>
-===========================================================
-
-The Agent then outputs a ReportPlan object, which includes:
-1. A summary of initial background context (if needed), based on web searches and/or crawling
-2. An outline of the report that includes a list of section titles and the key question to be addressed in each section
-"""
-
-from pydantic import BaseModel, Field
-from typing import List, Optional, Any
-from langchain_core.tools import BaseTool, Tool
-from .baseclass import ResearchAgent
-from ..llm_config import LLMConfig, model_supports_structured_output
-from .utils.parse_output import create_type_parser
-from datetime import datetime
-
-
-class ReportPlanSection(BaseModel):
-    """A section of the report that needs to be written"""
-    title: str = Field(description="The title of the section")
-    key_question: str = Field(description="The key question to be addressed in the section")
-
-
-class ReportPlan(BaseModel):
-    """Output from the Report Planner Agent"""
-    background_context: str = Field(description="A summary of supporting context that can be passed onto the research agents")
-    report_outline: List[ReportPlanSection] = Field(description="List of sections that need to be written in the report")
-    report_title: str = Field(description="The title of the report")
-
-
-INSTRUCTIONS = f"""
-You are a research manager, managing a team of research agents. Today's date is {datetime.now().strftime("%Y-%m-%d")}.
-Given a research query, your job is to produce an initial outline of the report (section titles and key questions),
-as well as some background context. Each section will be assigned to a different researcher in your team who will then
-carry out research on the section.
-
-You will be given:
-- An initial research query
-
-Your task is to:
-1. Produce 1-2 paragraphs of initial background context (if needed) on the query by running web searches or crawling websites
-2. Produce an outline of the report that includes a list of section titles and the key question to be addressed in each section
-3. Provide a title for the report that will be used as the main heading
-
-Guidelines:
-- Each section should cover a single topic/question that is independent of other sections
-- The key question for each section should include both the NAME and DOMAIN NAME / WEBSITE (if available and applicable) if it is related to a company, product or similar
-- The background_context should not be more than 2 paragraphs
-- The background_context should be very specific to the query and include any information that is relevant for researchers across all sections of the report
-- The background_context should be draw only from web search or crawl results rather than prior knowledge (i.e. it should only be included if you have called tools)
-- For example, if the query is about a company, the background context should include some basic information about what the company does
-- DO NOT do more than 2 tool calls
-
-Only output JSON. Follow the JSON schema below. Do not output anything else. I will be parsing this with Pydantic so output valid JSON only:
-{ReportPlan.model_json_schema()}
-"""
-
-def init_planner_agent(config: LLMConfig) -> ResearchAgent:
-    """
-    Initialize the planner agent with the appropriate tools and configuration.
-    
-    Args:
-        config: The LLM configuration
-        
-    Returns:
-        A configured ResearchAgent for planning research
-    """
-    selected_model = config.reasoning_model
-    
-    # Create LangChain tools for web search and website crawling
-    
-    # Web search tool wrapper
-    async def web_search_wrapper(query: str) -> str:
-        """Search the web for information on a specific query."""
-        # Import here to avoid circular imports
-        from ...tools import web_search
-        results = await web_search(query)
-        # Format the results into a readable format
-        formatted_results = "\n\n".join([
-            f"Title: {result['title']}\nURL: {result['url']}\nSnippet: {result['snippet']}"
-            for result in results
-        ])
-        return formatted_results
-    
-    # Crawl website tool wrapper
-    async def crawl_website_wrapper(url: str) -> str:
-        """Crawl a website and extract its main content."""
-        # Import here to avoid circular imports
-        from ...tools import crawl_website
-        result = await crawl_website(url)
-        return result
-    
-    # Create LangChain Tool objects
-    web_search_tool = Tool(
-        name="web_search",
-        description="Search the web for information on a specific query - provide a query with 3-6 words as input",
-        func=web_search_wrapper,
-        coroutine=web_search_wrapper
-    )
-    
-    crawl_tool = Tool(
-        name="crawl_website",
-        description="Crawl a website for information relevant to the query - provide a starting URL as input",
-        func=crawl_website_wrapper,
-        coroutine=crawl_website_wrapper
-    )
-    
-    # Determine whether to use structured output
-    use_output_parser = not hasattr(selected_model, 'langchain_llm')
-    
-    return ResearchAgent(
-        name="PlannerAgent",
-        instructions=INSTRUCTIONS,
-        tools=[web_search_tool, crawl_tool],
-        model=selected_model.langchain_llm if hasattr(selected_model, 'langchain_llm') else selected_model,
-        output_type=ReportPlan if not use_output_parser else None,
-        output_parser=create_type_parser(ReportPlan) if use_output_parser else None
-    )