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

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
-    )

alita_sdk/community/deep_researcher/agents/proofreader_agent.py

@@ -1,80 +0,0 @@
-"""
-Agent used to produce the final draft of a report given initial drafts of each section.
-
-The Agent takes as input the original user query and a stringified object of type ReportDraft.model_dump_json() (defined below).
-
-====
-QUERY: <original user query>
-
-REPORT DRAFT: <stringified ReportDraft object containing all draft sections>
-====
-
-The Agent then outputs the final markdown for the report as a string.
-"""
-
-from pydantic import BaseModel, Field
-from typing import List
-from .baseclass import ResearchAgent
-from ..llm_config import LLMConfig
-from datetime import datetime
-from langchain_core.tools import BaseTool
-
-
-class ReportDraftSection(BaseModel):
-    """A section of the report that needs to be written"""
-    section_title: str = Field(description="The title of the section")
-    section_content: str = Field(description="The content of the section")
-
-
-class ReportDraft(BaseModel):
-    """Output from the Report Planner Agent"""
-    sections: List[ReportDraftSection] = Field(description="List of sections that are in the report")
-
-
-INSTRUCTIONS = f"""
-You are a research expert who proofreads and edits research reports.
-Today's date is {datetime.now().strftime("%Y-%m-%d")}.
-
-You are given:
-1. The original query topic for the report
-2. A first draft of the report in ReportDraft format containing each section in sequence
-
-Your task is to:
-1. **Combine sections:** Concatenate the sections into a single string
-2. **Add section titles:** Add the section titles to the beginning of each section in markdown format, as well as a main title for the report
-3. **De-duplicate:** Remove duplicate content across sections to avoid repetition
-4. **Remove irrelevant sections:** If any sections or sub-sections are completely irrelevant to the query, remove them
-5. **Refine wording:** Edit the wording of the report to be polished, concise and punchy, but **without eliminating any detail** or large chunks of text
-6. **Add a summary:** Add a short report summary / outline to the beginning of the report to provide an overview of the sections and what is discussed
-7. **Preserve sources:** Preserve all sources / references - move the long list of references to the end of the report
-8. **Update reference numbers:** Continue to include reference numbers in square brackets  ([1], [2], [3], etc.) in the main body of the report, but update the numbering to match the new order of references at the end of the report
-9. **Output final report:** Output the final report in markdown format (do not wrap it in a code block)
-
-Guidelines:
-- Do not add any new facts or data to the report
-- Do not remove any content from the report unless it is very clearly wrong, contradictory or irrelevant
-- Remove or reformat any redundant or excessive headings, and ensure that the final nesting of heading levels is correct
-- Ensure that the final report flows well and has a logical structure
-- Include all sources and references that are present in the final report
-"""
-
-def init_proofreader_agent(config: LLMConfig) -> ResearchAgent:
-    """
-    Initialize the proofreader agent.
-    
-    Args:
-        config: The LLM configuration to use
-        
-    Returns:
-        A ResearchAgent that can proofread and edit research reports
-    """
-    selected_model = config.fast_model
-    
-    return ResearchAgent(
-        name="ProofreaderAgent",
-        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=None,  # Direct string output
-        output_parser=None
-    )

alita_sdk/community/deep_researcher/agents/thinking_agent.py

@@ -1,64 +0,0 @@
-"""
-Agent used to reflect on the research process so far and share your latest thoughts.
-
-The Agent takes as input a string in the following format:
-===========================================================
-ORIGINAL QUERY: <original user query>
-
-BACKGROUND CONTEXT: <supporting background context related to the original query>
-
-HISTORY OF ACTIONS, FINDINGS AND THOUGHTS: <a log of prior iterations of the research process>
-===========================================================
-
-The Agent then outputs a string containing its latest thoughts on the research process.
-"""
-from .baseclass import ResearchAgent
-from ..llm_config import LLMConfig
-from datetime import datetime
-from langchain_core.tools import BaseTool
-
-INSTRUCTIONS = f"""
-You are a research expert who is managing a research process in iterations. Today's date is {datetime.now().strftime("%Y-%m-%d")}.
-
-You are given:
-1. The original research query along with some supporting background context
-2. A history of the tasks, actions, findings and thoughts you've made up until this point in the research process (on iteration 1 you will be at the start of the research process, so this will be empty)
-
-Your objective is to reflect on the research process so far and share your latest thoughts.
-
-Specifically, your thoughts should include reflections on questions such as:
-- What have you learned from the last iteration?
-- What new areas would you like to explore next, or existing topics you'd like to go deeper into?
-- Were you able to retrieve the information you were looking for in the last iteration?
-- If not, should we change our approach or move to the next topic?
-- Is there any info that is contradictory or conflicting?
-
-Guidelines:
-- Share you stream of consciousness on the above questions as raw text
-- Keep your response concise and informal
-- Focus most of your thoughts on the most recent iteration and how that influences this next iteration
-- Our aim is to do very deep and thorough research - bear this in mind when reflecting on the research process
-- DO NOT produce a draft of the final report. This is not your job.
-- If this is the first iteration (i.e. no data from prior iterations), provide thoughts on what info we need to gather in the first iteration to get started
-"""
-
-def init_thinking_agent(config: LLMConfig) -> ResearchAgent:
-    """
-    Initialize the thinking agent for reflection and meta-cognition.
-    
-    Args:
-        config: The LLM configuration to use
-        
-    Returns:
-        A ResearchAgent that can reflect on the research process
-    """
-    selected_model = config.reasoning_model
-    
-    return ResearchAgent(
-        name="ThinkingAgent",
-        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=None,  # Direct string output
-        output_parser=None
-    )

alita_sdk/community/deep_researcher/agents/tool_agents/__init__.py

@@ -1,20 +0,0 @@
-from pydantic import BaseModel, Field
-
-class ToolAgentOutput(BaseModel):
-    """Standard output for all tool agents"""
-    output: str
-    sources: list[str] = Field(default_factory=list)
-
-from .search_agent import init_search_agent
-from .crawl_agent import init_crawl_agent
-from ...llm_config import LLMConfig
-from ..baseclass import ResearchAgent
-
-def init_tool_agents(config: LLMConfig) -> dict[str, ResearchAgent]:
-    search_agent = init_search_agent(config)
-    crawl_agent = init_crawl_agent(config)
-
-    return {
-        "WebSearchAgent": search_agent,
-        "SiteCrawlerAgent": crawl_agent,
-    }

alita_sdk/community/deep_researcher/agents/tool_agents/crawl_agent.py

@@ -1,87 +0,0 @@
-"""
-Agent used to crawl a website and return the results.
-
-The CrawlAgent takes as input a string in the format of AgentTask.model_dump_json(), or can take a simple starting url string as input
-
-The Agent then:
-1. Uses the crawl_website tool to crawl the website
-2. Writes a 3+ paragraph summary of the crawled contents
-3. Includes citations/URLs in brackets next to information sources
-4. Returns the formatted summary as a string
-"""
-
-from langchain_core.tools import Tool
-from typing import Dict, Any
-
-from . import ToolAgentOutput
-from ...llm_config import LLMConfig
-from ..baseclass import ResearchAgent
-from ..utils.parse_output import create_type_parser
-
-INSTRUCTIONS = f"""
-You are a web crawling agent that crawls the contents of a website and answers a query based on the crawled contents. Follow these steps exactly:
-
-* From the provided information, use the 'entity_website' as the starting_url for the web crawler
-* Crawl the website using the crawl_website tool
-* After using the crawl_website tool, write a 3+ paragraph summary that captures the main points from the crawled contents
-* In your summary, try to comprehensively answer/address the 'gaps' and 'query' provided (if available)
-* If the crawled contents are not relevant to the 'gaps' or 'query', simply write "No relevant results found"
-* Use headings and bullets to organize the summary if needed
-* Include citations/URLs in brackets next to all associated information in your summary
-* Only run the crawler once
-
-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:
-{ToolAgentOutput.model_json_schema()}
-"""
-
-def init_crawl_agent(config: LLMConfig) -> ResearchAgent:
-    """
-    Initialize a crawl agent using LangChain tools.
-    
-    Args:
-        config: The LLM configuration to use
-        
-    Returns:
-        A ResearchAgent that can crawl websites
-    """
-    # Create a LangChain wrapper around the crawl_website tool
-    async def crawl_website_wrapper(starting_url: str, max_links: int = 5) -> str:
-        """
-        Crawl a website and extract its main content.
-        
-        Args:
-            starting_url: The URL to start crawling from
-            max_links: Maximum number of links to follow from the starting page
-            
-        Returns:
-            The extracted content from the website
-        """
-        from ...tools import crawl_website
-        # Import inside function to avoid circular imports
-        
-        # Use the original crawl_website function
-        result = await crawl_website(starting_url, max_links)
-        return result
-    
-    # Create a LangChain Tool
-    crawl_tool = Tool(
-        name="crawl_website",
-        description="Crawls a website and extracts its main content starting from the provided URL",
-        func=crawl_website_wrapper,
-        coroutine=crawl_website_wrapper,
-    )
-    
-    # Use our adapter to initialize the agent with the LangChain tool
-    selected_model = config.fast_model
-    
-    # Determine whether to use structured output
-    use_output_parser = not hasattr(selected_model, 'langchain_llm')
-    
-    return ResearchAgent(
-        name="SiteCrawlerAgent",
-        instructions=INSTRUCTIONS,
-        tools=[crawl_tool],
-        model=selected_model.langchain_llm if hasattr(selected_model, 'langchain_llm') else selected_model,
-        output_type=ToolAgentOutput if not use_output_parser else None,
-        output_parser=create_type_parser(ToolAgentOutput) if use_output_parser else None
-    )