agno 2.2.13__py3-none-any.whl

agno/tools/pubmed.py

@@ -0,0 +1,188 @@
+import json
+from typing import Any, Dict, List, Optional
+from xml.etree import ElementTree
+
+import httpx
+
+from agno.tools import Toolkit
+from agno.utils.log import log_debug
+
+
+class PubmedTools(Toolkit):
+    def __init__(
+        self,
+        email: str = "your_email@example.com",
+        max_results: Optional[int] = None,
+        results_expanded: bool = False,
+        enable_search_pubmed: bool = True,
+        all: bool = False,
+        **kwargs,
+    ):
+        self.max_results: Optional[int] = max_results
+        self.email: str = email
+        self.results_expanded: bool = results_expanded
+
+        tools: List[Any] = []
+        if enable_search_pubmed or all:
+            tools.append(self.search_pubmed)
+
+        super().__init__(name="pubmed", tools=tools, **kwargs)
+
+    def fetch_pubmed_ids(self, query: str, max_results: int, email: str) -> List[str]:
+        url = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi"
+        params = {
+            "db": "pubmed",
+            "term": query,
+            "retmax": max_results,
+            "email": email,
+            "usehistory": "y",
+        }
+        response = httpx.get(url, params=params)  # type: ignore
+        root = ElementTree.fromstring(response.content)
+        return [id_elem.text for id_elem in root.findall(".//Id") if id_elem.text is not None]
+
+    def fetch_details(self, pubmed_ids: List[str]) -> ElementTree.Element:
+        url = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi"
+        params = {"db": "pubmed", "id": ",".join(pubmed_ids), "retmode": "xml"}
+        response = httpx.get(url, params=params)
+        return ElementTree.fromstring(response.content)
+
+    def parse_details(self, xml_root: ElementTree.Element) -> List[Dict[str, Any]]:
+        articles = []
+        for article in xml_root.findall(".//PubmedArticle"):
+            # Get existing fields
+            pub_date = article.find(".//PubDate/Year")
+            title = article.find(".//ArticleTitle")
+
+            # Handle abstract sections with labels (methods, results, etc.)
+            abstract_sections = article.findall(".//AbstractText")
+            abstract_text = ""
+            if abstract_sections:
+                for section in abstract_sections:
+                    label = section.get("Label", "")
+                    if label:
+                        abstract_text += f"{label}: {section.text}\n\n"
+                    else:
+                        abstract_text += f"{section.text}\n\n"
+                abstract_text = abstract_text.strip()
+            else:
+                abstract_text = "No abstract available"
+
+            # Get first author
+            first_author_elem = article.find(".//AuthorList/Author[1]")
+            first_author = "Unknown"
+            if first_author_elem is not None:
+                last_name = first_author_elem.find("LastName")
+                fore_name = first_author_elem.find("ForeName")
+                if last_name is not None and fore_name is not None:
+                    first_author = f"{last_name.text}, {fore_name.text}"
+                elif last_name is not None and last_name.text:
+                    first_author = last_name.text
+
+            # Get DOI
+            doi_elem = article.find(".//ArticleIdList/ArticleId[@IdType='doi']")
+            doi = doi_elem.text if doi_elem is not None else "No DOI available"
+
+            # Get PMID for URL construction
+            pmid_elem = article.find(".//PMID")
+            pmid = pmid_elem.text if pmid_elem is not None else ""
+            pubmed_url = f"https://pubmed.ncbi.nlm.nih.gov/{pmid}/" if pmid else "No URL available"
+
+            # Check if full text is available via PMC
+            pmc_elem = article.find(".//ArticleIdList/ArticleId[@IdType='pmc']")
+            full_text_url = "Not available"
+            if pmc_elem is not None:
+                full_text_url = f"https://www.ncbi.nlm.nih.gov/pmc/articles/{pmc_elem.text}/"
+            elif doi_elem is not None:
+                full_text_url = f"https://doi.org/{doi}"
+
+            # Get keywords
+            keywords = []
+            for keyword in article.findall(".//KeywordList/Keyword"):
+                if keyword.text:
+                    keywords.append(keyword.text)
+
+            # Get MeSH terms (useful for understanding medical context)
+            mesh_terms = []
+            for mesh in article.findall(".//MeshHeading/DescriptorName"):
+                if mesh.text:
+                    mesh_terms.append(mesh.text)
+
+            # Get journal info
+            journal_elem = article.find(".//Journal/Title")
+            journal = journal_elem.text if journal_elem is not None else "Unknown Journal"
+
+            # Publication type (research article, review, etc.)
+            pub_types = []
+            for pub_type in article.findall(".//PublicationTypeList/PublicationType"):
+                if pub_type.text:
+                    pub_types.append(pub_type.text)
+
+            articles.append(
+                {
+                    "Published": pub_date.text if pub_date is not None else "No date available",
+                    "Title": title.text if title is not None else "No title available",
+                    "Summary": abstract_text,
+                    "First_Author": first_author,
+                    "DOI": doi,
+                    "PubMed_URL": pubmed_url,
+                    "Full_Text_URL": full_text_url,
+                    "Keywords": ", ".join(keywords) if keywords else "No keywords available",
+                    "MeSH_Terms": ", ".join(mesh_terms) if mesh_terms else "No MeSH terms available",
+                    "Journal": journal,
+                    "Publication_Type": ", ".join(pub_types) if pub_types else "Not specified",
+                }
+            )
+
+        return articles
+
+    def search_pubmed(self, query: str, max_results: Optional[int] = 10) -> str:
+        """Use this function to search PubMed for articles.
+
+        Args:
+            query (str): The search query.
+            max_results (int): The maximum number of results to return (default 10).
+
+        Returns:
+            str: A JSON string containing the search results.
+        """
+        try:
+            log_debug(f"Searching PubMed for: {query}")
+            max_results = max_results or self.max_results or 10
+            ids = self.fetch_pubmed_ids(query, max_results, self.email)
+            details_root = self.fetch_details(ids)
+            articles = self.parse_details(details_root)
+
+            # Create result strings based on configured detail level
+            results = []
+            for article in articles:
+                if self.results_expanded:
+                    # Comprehensive format with all metadata
+                    article_text = (
+                        f"Published: {article.get('Published')}\n"
+                        f"Title: {article.get('Title')}\n"
+                        f"First Author: {article.get('First_Author')}\n"
+                        f"Journal: {article.get('Journal')}\n"
+                        f"Publication Type: {article.get('Publication_Type')}\n"
+                        f"DOI: {article.get('DOI')}\n"
+                        f"PubMed URL: {article.get('PubMed_URL')}\n"
+                        f"Full Text URL: {article.get('Full_Text_URL')}\n"
+                        f"Keywords: {article.get('Keywords')}\n"
+                        f"MeSH Terms: {article.get('MeSH_Terms')}\n"
+                        f"Summary:\n{article.get('Summary')}"
+                    )
+                else:
+                    # Concise format with just essential information
+                    summary = article.get("Summary", "")
+                    article_text = (
+                        f"Title: {article.get('Title')}\n"
+                        f"Published: {article.get('Published')}\n"
+                        f"Summary: {summary[:200]}..."
+                        if len(summary) > 200
+                        else f"Summary: {summary}"
+                    )
+                results.append(article_text)
+
+            return json.dumps(results)
+        except Exception as e:
+            return f"Could not fetch articles. Error: {e}"

agno/tools/python.py

@@ -0,0 +1,205 @@
+import functools
+import runpy
+from pathlib import Path
+from typing import Any, List, Optional
+
+from agno.tools import Toolkit
+from agno.utils.log import log_debug, log_info, logger
+
+
+@functools.lru_cache(maxsize=None)
+def warn() -> None:
+    logger.warning("PythonTools can run arbitrary code, please provide human supervision.")
+
+
+class PythonTools(Toolkit):
+    def __init__(
+        self,
+        base_dir: Optional[Path] = None,
+        safe_globals: Optional[dict] = None,
+        safe_locals: Optional[dict] = None,
+        **kwargs,
+    ):
+        self.base_dir: Path = base_dir or Path.cwd()
+
+        # Restricted global and local scope
+        self.safe_globals: dict = safe_globals or globals()
+        self.safe_locals: dict = safe_locals or locals()
+
+        tools: List[Any] = [
+            self.save_to_file_and_run,
+            self.run_python_code,
+            self.pip_install_package,
+            self.uv_pip_install_package,
+            self.run_python_file_return_variable,
+            self.read_file,
+            self.list_files,
+        ]
+
+        super().__init__(name="python_tools", tools=tools, **kwargs)
+
+    def save_to_file_and_run(
+        self, file_name: str, code: str, variable_to_return: Optional[str] = None, overwrite: bool = True
+    ) -> str:
+        """This function saves Python code to a file called `file_name` and then runs it.
+        If successful, returns the value of `variable_to_return` if provided otherwise returns a success message.
+        If failed, returns an error message.
+
+        Make sure the file_name ends with `.py`
+
+        :param file_name: The name of the file the code will be saved to.
+        :param code: The code to save and run.
+        :param variable_to_return: The variable to return.
+        :param overwrite: Overwrite the file if it already exists.
+        :return: if run is successful, the value of `variable_to_return` if provided else file name.
+        """
+        try:
+            warn()
+            file_path = self.base_dir.joinpath(file_name)
+            log_debug(f"Saving code to {file_path}")
+            if not file_path.parent.exists():
+                file_path.parent.mkdir(parents=True, exist_ok=True)
+            if file_path.exists() and not overwrite:
+                return f"File {file_name} already exists"
+            file_path.write_text(code, encoding="utf-8")
+            log_info(f"Saved: {file_path}")
+            log_info(f"Running {file_path}")
+            globals_after_run = runpy.run_path(str(file_path), init_globals=self.safe_globals, run_name="__main__")
+
+            if variable_to_return:
+                variable_value = globals_after_run.get(variable_to_return)
+                if variable_value is None:
+                    return f"Variable {variable_to_return} not found"
+                log_debug(f"Variable {variable_to_return} value: {variable_value}")
+                return str(variable_value)
+            else:
+                return f"successfully ran {str(file_path)}"
+        except Exception as e:
+            logger.error(f"Error saving and running code: {e}")
+            return f"Error saving and running code: {e}"
+
+    def run_python_file_return_variable(self, file_name: str, variable_to_return: Optional[str] = None) -> str:
+        """This function runs code in a Python file.
+        If successful, returns the value of `variable_to_return` if provided otherwise returns a success message.
+        If failed, returns an error message.
+
+        :param file_name: The name of the file to run.
+        :param variable_to_return: The variable to return.
+        :return: if run is successful, the value of `variable_to_return` if provided else file name.
+        """
+        try:
+            warn()
+            file_path = self.base_dir.joinpath(file_name)
+
+            log_info(f"Running {file_path}")
+            globals_after_run = runpy.run_path(str(file_path), init_globals=self.safe_globals, run_name="__main__")
+            if variable_to_return:
+                variable_value = globals_after_run.get(variable_to_return)
+                if variable_value is None:
+                    return f"Variable {variable_to_return} not found"
+                log_debug(f"Variable {variable_to_return} value: {variable_value}")
+                return str(variable_value)
+            else:
+                return f"successfully ran {str(file_path)}"
+        except Exception as e:
+            logger.error(f"Error running file: {e}")
+            return f"Error running file: {e}"
+
+    def read_file(self, file_name: str) -> str:
+        """Reads the contents of the file `file_name` and returns the contents if successful.
+
+        :param file_name: The name of the file to read.
+        :return: The contents of the file if successful, otherwise returns an error message.
+        """
+        try:
+            log_info(f"Reading file: {file_name}")
+            file_path = self.base_dir.joinpath(file_name)
+            contents = file_path.read_text(encoding="utf-8")
+            return str(contents)
+        except Exception as e:
+            logger.error(f"Error reading file: {e}")
+            return f"Error reading file: {e}"
+
+    def list_files(self) -> str:
+        """Returns a list of files in the base directory
+
+        :return: Comma separated list of files in the base directory.
+        """
+        try:
+            log_info(f"Reading files in : {self.base_dir}")
+            files = [str(file_path.name) for file_path in self.base_dir.iterdir()]
+            return ", ".join(files)
+        except Exception as e:
+            logger.error(f"Error reading files: {e}")
+            return f"Error reading files: {e}"
+
+    def run_python_code(self, code: str, variable_to_return: Optional[str] = None) -> str:
+        """This function to runs Python code in the current environment.
+        If successful, returns the value of `variable_to_return` if provided otherwise returns a success message.
+        If failed, returns an error message.
+
+        Returns the value of `variable_to_return` if successful, otherwise returns an error message.
+
+        :param code: The code to run.
+        :param variable_to_return: The variable to return.
+        :return: value of `variable_to_return` if successful, otherwise returns an error message.
+        """
+        try:
+            warn()
+
+            log_debug(f"Running code:\n\n{code}\n\n")
+            exec(code, self.safe_globals, self.safe_locals)
+
+            if variable_to_return:
+                variable_value = self.safe_locals.get(variable_to_return)
+                if variable_value is None:
+                    return f"Variable {variable_to_return} not found"
+                log_debug(f"Variable {variable_to_return} value: {variable_value}")
+                return str(variable_value)
+            else:
+                return "successfully ran python code"
+        except Exception as e:
+            logger.error(f"Error running python code: {e}")
+            return f"Error running python code: {e}"
+
+    def pip_install_package(self, package_name: str) -> str:
+        """This function installs a package using pip in the current environment.
+        If successful, returns a success message.
+        If failed, returns an error message.
+
+        :param package_name: The name of the package to install.
+        :return: success message if successful, otherwise returns an error message.
+        """
+        try:
+            warn()
+
+            log_debug(f"Installing package {package_name}")
+            import subprocess
+            import sys
+
+            subprocess.check_call([sys.executable, "-m", "pip", "install", package_name])
+            return f"successfully installed package {package_name}"
+        except Exception as e:
+            logger.error(f"Error installing package {package_name}: {e}")
+            return f"Error installing package {package_name}: {e}"
+
+    def uv_pip_install_package(self, package_name: str) -> str:
+        """This function installs a package using uv and pip in the current environment.
+        If successful, returns a success message.
+        If failed, returns an error message.
+
+        :param package_name: The name of the package to install.
+        :return: success message if successful, otherwise returns an error message.
+        """
+        try:
+            warn()
+
+            log_debug(f"Installing package {package_name}")
+            import subprocess
+            import sys
+
+            subprocess.check_call([sys.executable, "-m", "uv", "pip", "install", package_name])
+            return f"successfully installed package {package_name}"
+        except Exception as e:
+            logger.error(f"Error installing package {package_name}: {e}")
+            return f"Error installing package {package_name}: {e}"

agno/tools/reasoning.py

@@ -0,0 +1,283 @@
+from textwrap import dedent
+from typing import Any, Dict, List, Optional
+
+from agno.reasoning.step import NextAction, ReasoningStep
+from agno.tools import Toolkit
+from agno.utils.log import log_debug, log_error
+
+
+class ReasoningTools(Toolkit):
+    def __init__(
+        self,
+        enable_think: bool = True,
+        enable_analyze: bool = True,
+        all: bool = False,
+        instructions: Optional[str] = None,
+        add_instructions: bool = False,
+        add_few_shot: bool = False,
+        few_shot_examples: Optional[str] = None,
+        **kwargs,
+    ):
+        """A toolkit that provides step-by-step reasoning tools: Think and Analyze."""
+
+        # Add instructions for using this toolkit
+        if instructions is None:
+            self.instructions = "<reasoning_instructions>\n" + self.DEFAULT_INSTRUCTIONS
+            if add_few_shot:
+                if few_shot_examples is not None:
+                    self.instructions += "\n" + few_shot_examples
+                else:
+                    self.instructions += "\n" + self.FEW_SHOT_EXAMPLES
+            self.instructions += "\n</reasoning_instructions>\n"
+        else:
+            self.instructions = instructions
+
+        tools: List[Any] = []
+        # Prefer new flags; fallback to legacy ones
+        if all or enable_think:
+            tools.append(self.think)
+        if all or enable_analyze:
+            tools.append(self.analyze)
+
+        super().__init__(
+            name="reasoning_tools",
+            instructions=self.instructions,
+            add_instructions=add_instructions,
+            tools=tools,
+            **kwargs,
+        )
+
+    def think(
+        self,
+        session_state: Dict[str, Any],
+        title: str,
+        thought: str,
+        action: Optional[str] = None,
+        confidence: float = 0.8,
+    ) -> str:
+        """Use this tool as a scratchpad to reason about the question and work through it step-by-step.
+        This tool will help you break down complex problems into logical steps and track the reasoning process.
+        You can call it as many times as needed. These internal thoughts are never revealed to the user.
+
+        Args:
+            title: A concise title for this step
+            thought: Your detailed thought for this step
+            action: What you'll do based on this thought
+            confidence: How confident you are about this thought (0.0 to 1.0)
+
+        Returns:
+            A list of previous thoughts and the new thought
+        """
+        try:
+            log_debug(f"Thought about {title}")
+
+            # Create a reasoning step
+            reasoning_step = ReasoningStep(
+                title=title,
+                reasoning=thought,
+                action=action,
+                next_action=NextAction.CONTINUE,
+                confidence=confidence,
+            )
+
+            current_run_id = session_state.get("current_run_id", None)
+
+            # Add this step to the Agent's session state
+            if session_state is None:
+                session_state = {}
+            if "reasoning_steps" not in session_state:
+                session_state["reasoning_steps"] = {}
+            if current_run_id not in session_state["reasoning_steps"]:
+                session_state["reasoning_steps"][current_run_id] = []
+            session_state["reasoning_steps"][current_run_id].append(reasoning_step.model_dump_json())
+
+            # Return all previous reasoning_steps and the new reasoning_step
+            if "reasoning_steps" in session_state and current_run_id in session_state["reasoning_steps"]:
+                formatted_reasoning_steps = ""
+                for i, step in enumerate(session_state["reasoning_steps"][current_run_id], 1):
+                    step_parsed = ReasoningStep.model_validate_json(step)
+                    step_str = dedent(f"""\
+Step {i}:
+Title: {step_parsed.title}
+Reasoning: {step_parsed.reasoning}
+Action: {step_parsed.action}
+Confidence: {step_parsed.confidence}
+""")
+                    formatted_reasoning_steps += step_str + "\n"
+                return formatted_reasoning_steps.strip()
+            return reasoning_step.model_dump_json()
+        except Exception as e:
+            log_error(f"Error recording thought: {e}")
+            return f"Error recording thought: {e}"
+
+    def analyze(
+        self,
+        session_state: Dict[str, Any],
+        title: str,
+        result: str,
+        analysis: str,
+        next_action: str = "continue",
+        confidence: float = 0.8,
+    ) -> str:
+        """Use this tool to analyze results from a reasoning step and determine next actions.
+
+        Args:
+            title: A concise title for this analysis step
+            result: The outcome of the previous action
+            analysis: Your analysis of the results
+            next_action: What to do next ("continue", "validate", or "final_answer")
+            confidence: How confident you are in this analysis (0.0 to 1.0)
+
+        Returns:
+            A list of previous thoughts and the new analysis
+        """
+        try:
+            log_debug(f"Analyzed {title}")
+
+            # Map string next_action to enum
+            next_action_enum = NextAction.CONTINUE
+            if next_action.lower() == "validate":
+                next_action_enum = NextAction.VALIDATE
+            elif next_action.lower() in ["final", "final_answer", "finalize"]:
+                next_action_enum = NextAction.FINAL_ANSWER
+
+            # Create a reasoning step for the analysis
+            reasoning_step = ReasoningStep(
+                title=title,
+                result=result,
+                reasoning=analysis,
+                next_action=next_action_enum,
+                confidence=confidence,
+            )
+
+            current_run_id = session_state.get("current_run_id", None)
+            # Add this step to the Agent's session state
+            if session_state is None:
+                session_state = {}
+            if "reasoning_steps" not in session_state:
+                session_state["reasoning_steps"] = {}
+            if current_run_id not in session_state["reasoning_steps"]:
+                session_state["reasoning_steps"][current_run_id] = []
+            session_state["reasoning_steps"][current_run_id].append(reasoning_step.model_dump_json())
+
+            # Return all previous reasoning_steps and the new reasoning_step
+            if "reasoning_steps" in session_state and current_run_id in session_state["reasoning_steps"]:
+                formatted_reasoning_steps = ""
+                for i, step in enumerate(session_state["reasoning_steps"][current_run_id], 1):
+                    step_parsed = ReasoningStep.model_validate_json(step)
+                    step_str = dedent(f"""\
+Step {i}:
+Title: {step_parsed.title}
+Reasoning: {step_parsed.reasoning}
+Action: {step_parsed.action}
+Confidence: {step_parsed.confidence}
+""")
+                    formatted_reasoning_steps += step_str + "\n"
+                return formatted_reasoning_steps.strip()
+            return reasoning_step.model_dump_json()
+        except Exception as e:
+            log_error(f"Error recording analysis: {e}")
+            return f"Error recording analysis: {e}"
+
+    # --------------------------------------------------------------------------------
+    # Default instructions and few-shot examples
+    # --------------------------------------------------------------------------------
+
+    DEFAULT_INSTRUCTIONS = dedent(
+        """\
+        You have access to the `think` and `analyze` tools to work through problems step-by-step and structure your thought process. You must ALWAYS `think` before making tool calls or generating a response.
+
+        1. **Think** (scratchpad):
+            - Purpose: Use the `think` tool as a scratchpad to break down complex problems, outline steps, and decide on immediate actions within your reasoning flow. Use this to structure your internal monologue.
+            - Usage: Call `think` before making tool calls or generating a response. Explain your reasoning and specify the intended action (e.g., "make a tool call", "perform calculation", "ask clarifying question").
+
+        2. **Analyze** (evaluation):
+            - Purpose: Evaluate the result of a think step or a set of tool calls. Assess if the result is expected, sufficient, or requires further investigation.
+            - Usage: Call `analyze` after a set of tool calls. Determine the `next_action` based on your analysis: `continue` (more reasoning needed), `validate` (seek external confirmation/validation if possible), or `final_answer` (ready to conclude).
+            - Explain your reasoning highlighting whether the result is correct/sufficient.
+
+        ## IMPORTANT GUIDELINES
+        - **Always Think First:** You MUST use the `think` tool before making tool calls or generating a response.
+        - **Iterate to Solve:** Use the `think` and `analyze` tools iteratively to build a clear reasoning path. The typical flow is `Think` -> [`Tool Calls` if needed] -> [`Analyze` if needed] -> ... -> `final_answer`. Repeat this cycle until you reach a satisfactory conclusion.
+        - **Make multiple tool calls in parallel:** After a `think` step, you can make multiple tool calls in parallel.
+        - **Keep Thoughts Internal:** The reasoning steps (thoughts and analyses) are for your internal process only. Do not share them directly with the user.
+        - **Conclude Clearly:** When your analysis determines the `next_action` is `final_answer`, provide a concise and accurate final answer to the user."""
+    )
+
+    FEW_SHOT_EXAMPLES = dedent(
+        """
+        Below are examples demonstrating how to use the `think` and `analyze` tools.
+
+        ### Examples
+
+        **Example 1: Simple Fact Retrieval**
+
+        *User Request:* How many continents are there on Earth?
+
+        *Agent's Internal Process:*
+
+        ```tool_call
+        think(
+          title="Understand Request",
+          thought="The user wants to know the standard number of continents on Earth. This is a common piece of knowledge.",
+          action="Recall or verify the number of continents.",
+          confidence=0.95
+        )
+        ```
+        *--(Agent internally recalls the fact)--*
+        ```tool_call
+        analyze(
+          title="Evaluate Fact",
+          result="Standard geographical models list 7 continents: Africa, Antarctica, Asia, Australia, Europe, North America, South America.",
+          analysis="The recalled information directly answers the user's question accurately.",
+          next_action="final_answer",
+          confidence=1.0
+        )
+        ```
+
+        *Agent's Final Answer to User:*
+        There are 7 continents on Earth: Africa, Antarctica, Asia, Australia, Europe, North America, and South America.
+
+        **Example 2: Multi-Step Information Gathering**
+
+        *User Request:* What is the capital of France and its current population?
+
+        *Agent's Internal Process:*
+
+        ```tool_call
+        think(
+          title="Plan Information Retrieval",
+          thought="The user needs two pieces of information: the capital of France and its current population. I should use external tools (like search) to find the most up-to-date and accurate information.",
+          action="First, search for the capital of France.",
+          confidence=0.95
+        )
+        ```
+
+        *Perform multiple tool calls in parallel*
+        *--(Tool call 1: search(query="capital of France"))--*
+        *--(Tool call 2: search(query="population of Paris current"))--*
+        *--(Tool Result 1: "Paris")--*
+        *--(Tool Result 2: "Approximately 2.1 million (city proper, estimate for early 2024)")--*
+
+        ```tool_call
+        analyze(
+          title="Analyze Capital Search Result",
+          result="The search result indicates Paris is the capital of France.",
+          analysis="This provides the first piece of requested information. Now I need to find the population of Paris.",
+          next_action="continue",
+          confidence=1.0
+        )
+        ```
+        ```tool_call
+        analyze(
+          title="Analyze Population Search Result",
+          result="The search provided an estimated population figure for Paris.",
+          analysis="I now have both the capital and its estimated population. I can provide the final answer.",
+          next_action="final_answer",
+          confidence=0.9
+        )
+        ```
+
+        *Agent's Final Answer to User:*
+        The capital of France is Paris. Its estimated population (city proper) is approximately 2.1 million as of early 2024."""
+    )