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

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

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

@@ -1,96 +0,0 @@
-"""
-Agent used to perform web searches and summarize the results.
-
-The SearchAgent takes as input a string in the format of AgentTask.model_dump_json(), or can take a simple query string as input
-
-The Agent then:
-1. Uses the web_search tool to retrieve search results
-2. Analyzes the retrieved information
-3. Writes a 3+ paragraph summary of the search results
-4. Includes citations/URLs in brackets next to information sources
-5. Returns the formatted summary as a string
-
-The agent can use either OpenAI's built-in web search capability or a custom
-web search implementation based on environment configuration.
-"""
-
-from langchain_core.tools import Tool
-from typing import Dict, Any, List
-
-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 research assistant that specializes in retrieving and summarizing information from the web.
-
-OBJECTIVE:
-Given an AgentTask, follow these steps:
-- Convert the 'query' into an optimized SERP search term for Google, limited to 3-5 words
-- If an 'entity_website' is provided, make sure to include the domain name in your optimized Google search term
-- Enter the optimized search term into the web_search tool
-- After using the web_search tool, write a 3+ paragraph summary that captures the main points from the search results
-
-GUIDELINES:
-- In your summary, try to comprehensively answer/address the 'gap' provided (which is the objective of the search)
-- The summary should always quote detailed facts, figures and numbers where these are available
-- If the search results are not relevant to the search term or do not address the 'gap', 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
-- Do not make additional searches
-
-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_search_agent(config: LLMConfig) -> ResearchAgent:
-    """
-    Initialize a search agent using LangChain tools.
-    
-    Args:
-        config: The LLM configuration to use
-        
-    Returns:
-        A ResearchAgent that can search the web and summarize results
-    """
-    # Create a LangChain wrapper around the web_search tool
-    async def web_search_wrapper(query: str, num_results: int = 8) -> List[Dict[str, Any]]:
-        """
-        Perform a web search and return the results.
-        
-        Args:
-            query: The query to search for
-            num_results: Number of results to return
-            
-        Returns:
-            A list of search results with title, url, and snippet
-        """
-        # Import here to avoid circular imports
-        from ...tools import web_search
-        
-        # Use the original web_search function
-        results = await web_search(query, num_results)
-        return results
-    
-    # Create a LangChain Tool
-    web_search_tool = Tool(
-        name="web_search",
-        description="Search the web for information on a specific query. Returns a list of search results.",
-        func=web_search_wrapper,
-        coroutine=web_search_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="WebSearchAgent",
-        instructions=INSTRUCTIONS,
-        tools=[web_search_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
-    )

alita_sdk/community/deep_researcher/agents/tool_selector_agent.py

@@ -1,83 +0,0 @@
-"""
-Agent used to determine which specialized agents should be used to address knowledge gaps.
-
-The Agent takes as input a string in the following format:
-===========================================================
-ORIGINAL QUERY: <original user query>
-
-KNOWLEDGE GAP TO ADDRESS: <knowledge gap that needs to be addressed>
-
-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:
-1. Analyzes the knowledge gap to determine which agents are best suited to address it
-2. Returns an AgentSelectionPlan object containing a list of AgentTask objects
-
-The available agents are:
-- WebSearchAgent: General web search for broad topics
-- SiteCrawlerAgent: Crawl the pages of a specific website to retrieve information about it
-"""
-
-from pydantic import BaseModel, Field
-from typing import List, Optional
-from ..llm_config import LLMConfig, model_supports_structured_output
-from datetime import datetime
-from .baseclass import ResearchAgent
-from .utils.parse_output import create_type_parser
-
-
-class AgentTask(BaseModel):
-    """A task for a specific agent to address knowledge gaps"""
-    gap: Optional[str] = Field(description="The knowledge gap being addressed", default=None)
-    agent: str = Field(description="The name of the agent to use")
-    query: str = Field(description="The specific query for the agent")
-    entity_website: Optional[str] = Field(description="The website of the entity being researched, if known", default=None)
-
-
-class AgentSelectionPlan(BaseModel):
-    """Plan for which agents to use for knowledge gaps"""
-    tasks: List[AgentTask] = Field(description="List of agent tasks to address knowledge gaps")
-
-
-INSTRUCTIONS = f"""
-You are an Tool Selector responsible for determining which specialized agents should address a knowledge gap in a research project.
-Today's date is {datetime.now().strftime("%Y-%m-%d")}.
-
-You will be given:
-1. The original user query
-2. A knowledge gap identified in the research
-3. 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 decide:
-1. Which specialized agents are best suited to address the gap
-2. What specific queries should be given to the agents (keep this short - 3-6 words)
-
-Available specialized agents:
-- WebSearchAgent: General web search for broad topics (can be called multiple times with different queries)
-- SiteCrawlerAgent: Crawl the pages of a specific website to retrieve information about it - use this if you want to find out something about a particular company, entity or product
-
-Guidelines:
-- Aim to call at most 3 agents at a time in your final output
-- You can list the WebSearchAgent multiple times with different queries if needed to cover the full scope of the knowledge gap
-- Be specific and concise (3-6 words) with the agent queries - they should target exactly what information is needed
-- If you know the website or domain name of an entity being researched, always include it in the query
-- If a gap doesn't clearly match any agent's capability, default to the WebSearchAgent
-- Use the history of actions / tool calls as a guide - try not to repeat yourself if an approach didn't work previously
-
-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:
-{AgentSelectionPlan.model_json_schema()}
-"""
-
-def init_tool_selector_agent(config: LLMConfig) -> ResearchAgent:
-    selected_model = config.reasoning_model
-
-    return ResearchAgent(
-        name="ToolSelectorAgent",
-        instructions=INSTRUCTIONS,
-        model=selected_model,
-        output_type=AgentSelectionPlan if model_supports_structured_output(selected_model) else None,
-        output_parser=create_type_parser(AgentSelectionPlan) if not model_supports_structured_output(selected_model) else None
-    )

alita_sdk/community/deep_researcher/agents/utils/parse_output.py

@@ -1,148 +0,0 @@
-import json
-import re
-from typing import Type, Any, Callable, TypeVar
-
-from pydantic import BaseModel
-
-T = TypeVar('T', bound=BaseModel)
-
-
-class OutputParserError(Exception):
-    """
-    Exception raised when the output parser fails to parse the output.
-    """
-    def __init__(self, message, output=None):
-        self.message = message
-        self.output = output
-        super().__init__(self.message)
-        
-    def __str__(self):
-        if self.output:
-            return f"{self.message}\nProblematic output: {self.output}"
-        return self.message
-
-
-def find_json_in_string(string: str) -> str:
-    """
-    Method to extract all text in the left-most brace that appears in a string.
-    Used to extract JSON from a string (note that this function does not validate the JSON).
-
-    Example:
-        string = "bla bla bla {this is {some} text{{}and it's sneaky}} because {it's} confusing"
-        output = "{this is {some} text{{}and it's sneaky}}"
-    """
-    stack = 0
-    start_index = None
-
-    for i, c in enumerate(string):
-        if c == '{':
-            if stack == 0:
-                start_index = i  # Start index of the first '{'
-            stack += 1  # Push to stack
-        elif c == '}':
-            stack -= 1  # Pop stack
-            if stack == 0:
-                # Return the substring from the start of the first '{' to the current '}'
-                return string[start_index:i + 1] if start_index is not None else ""
-
-    # If no complete set of braces is found, return an empty string
-    return ""
-
-
-def parse_json_output(output: str) -> Any:
-    """Take a string output and parse it as JSON"""
-    # First try to load the string as JSON
-    try:
-        return json.loads(output)
-    except json.JSONDecodeError as e:
-        pass
-
-    # If that fails, assume that the output is in a code block - remove the code block markers and try again
-    parsed_output = output
-    parsed_output = parsed_output.split("```")[1]
-    parsed_output = parsed_output.split("```")[0]
-    if parsed_output.startswith("json") or parsed_output.startswith("JSON"):
-        parsed_output = parsed_output[4:].strip()
-    try:
-        return json.loads(parsed_output)
-    except json.JSONDecodeError:
-        pass
-
-    # As a last attempt, try to manually find the JSON object in the output and parse it
-    parsed_output = find_json_in_string(output)
-    if parsed_output:
-        try:
-            return json.loads(parsed_output)
-        except json.JSONDecodeError:
-            raise OutputParserError(f"Failed to parse output as JSON", output)
-
-    # If all fails, raise an error
-    raise OutputParserError(f"Failed to parse output as JSON", output)
-
-
-def create_type_parser(model_class: Type[T]) -> Callable[[str], T]:
-    """
-    Creates a parser function that attempts to parse the output into the given model class.
-    This handles various formats that might be returned by the LLM.
-    
-    Args:
-        model_class: The Pydantic model class to parse the output into
-        
-    Returns:
-        A function that takes a string and returns an instance of the model class
-    """
-    def parser(text: str) -> T:
-        """
-        Parse the output into the model class.
-        
-        Args:
-            text: The text to parse
-            
-        Returns:
-            An instance of the model class
-        """
-        # First try direct JSON parsing
-        try:
-            return model_class.model_validate_json(text)
-        except Exception:
-            pass
-        
-        # Try to extract JSON from markdown codeblocks
-        json_match = re.search(r"```(?:json)?\n(.*?)\n```", text, re.DOTALL)
-        if json_match:
-            try:
-                json_str = json_match.group(1).strip()
-                return model_class.model_validate_json(json_str)
-            except Exception:
-                pass
-        
-        # Try to parse the entire text as a JSON object
-        try:
-            # Look for JSON-like patterns
-            json_pattern = r"(\{.*\})"
-            match = re.search(json_pattern, text, re.DOTALL)
-            if match:
-                json_str = match.group(1)
-                parsed = json.loads(json_str)
-                return model_class.model_validate(parsed)
-        except Exception:
-            pass
-        
-        # Fall back to creating an instance with the text as output
-        try:
-            # Check if model has 'output' field
-            if 'output' in model_class.model_fields:
-                return model_class(output=text)
-        except Exception:
-            pass
-        
-        # Last resort: just try to create an empty instance and set attributes
-        try:
-            instance = model_class()
-            if hasattr(instance, 'output'):
-                setattr(instance, 'output', text)
-            return instance
-        except Exception as e:
-            raise ValueError(f"Could not parse output to {model_class.__name__}: {e}")
-    
-    return parser

alita_sdk/community/deep_researcher/agents/writer_agent.py

@@ -1,63 +0,0 @@
-"""
-Agent used to synthesize a final report based on provided findings.
-
-The WriterAgent takes as input a string in the following format:
-===========================================================
-QUERY: <original user query>
-
-FINDINGS: <findings from the iterative research process>
-===========================================================
-
-The Agent then:
-1. Generates a comprehensive markdown report based on all available information
-2. Includes proper citations for sources in the format [1], [2], etc.
-3. Returns a string containing the markdown formatted report
-"""
-from .baseclass import ResearchAgent
-from ..llm_config import LLMConfig
-from datetime import datetime
-from langchain_core.tools import BaseTool
-
-INSTRUCTIONS = f"""
-You are a senior researcher tasked with comprehensively answering a research query. 
-Today's date is {datetime.now().strftime('%Y-%m-%d')}.
-You will be provided with the original query along with research findings put together by a research assistant.
-Your objective is to generate the final response in markdown format.
-The response should be as lengthy and detailed as possible with the information provided, focusing on answering the original query.
-In your final output, include references to the source URLs for all information and data gathered. 
-This should be formatted in the form of a numbered square bracket next to the relevant information, 
-followed by a list of URLs at the end of the response, per the example below.
-
-EXAMPLE REFERENCE FORMAT:
-The company has XYZ products [1]. It operates in the software services market which is expected to grow at 10% per year [2].
-
-References:
-[1] https://example.com/first-source-url
-[2] https://example.com/second-source-url
-
-GUIDELINES:
-* Answer the query directly, do not include unrelated or tangential information.
-* Adhere to any instructions on the length of your final response if provided in the user prompt.
-* If any additional guidelines are provided in the user prompt, follow them exactly and give them precedence over these system instructions.
-"""
-
-def init_writer_agent(config: LLMConfig) -> ResearchAgent:
-    """
-    Initialize the writer agent.
-    
-    Args:
-        config: The LLM configuration to use
-        
-    Returns:
-        A ResearchAgent that can generate comprehensive research reports
-    """
-    selected_model = config.main_model
-    
-    return ResearchAgent(
-        name="WriterAgent",
-        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
-    )