agno 1.8.0__py3-none-any.whl → 2.0.0a1__py3-none-any.whl

agno/tools/exa.py

@@ -19,11 +19,15 @@ class ExaTools(Toolkit):
     functionalities to perform categorized searches and retrieve structured results.
 
     Args:
+        enable_search (bool): Enable search functionality. Default is True.
+        enable_get_contents (bool): Enable get contents functionality. Default is True.
+        enable_find_similar (bool): Enable find similar functionality. Default is True.
+        enable_answer (bool): Enable answer generation. Default is True.
+        enable_research (bool): Enable research tool functionality. Default is False.
+        all (bool): Enable all tools. Overrides individual flags when True. Default is False.
         text (bool): Retrieve text content from results. Default is True.
         text_length_limit (int): Max length of text content per result. Default is 1000.
         highlights (bool): Include highlighted snippets. Default is True.
-        answer (bool): Enable answer generation. Default is True.
-        research (bool): Enable research tool functionality. Default is True.
         api_key (Optional[str]): Exa API key. Retrieved from `EXA_API_KEY` env variable if not provided.
         num_results (Optional[int]): Default number of search results. Overrides individual searches if set.
         start_crawl_date (Optional[str]): Include results crawled on/after this date (`YYYY-MM-DD`).
@@ -42,11 +46,12 @@ class ExaTools(Toolkit):
 
     def __init__(
         self,
-        search: bool = True,
-        get_contents: bool = True,
-        find_similar: bool = True,
-        answer: bool = True,
-        research: bool = False,
+        enable_search: bool = True,
+        enable_get_contents: bool = True,
+        enable_find_similar: bool = True,
+        enable_answer: bool = True,
+        enable_research: bool = False,
+        all: bool = False,
         text: bool = True,
         text_length_limit: int = 1000,
         highlights: bool = True,
@@ -96,15 +101,15 @@ class ExaTools(Toolkit):
         self.research_model: Literal["exa-research", "exa-research-pro"] = research_model
 
         tools: List[Any] = []
-        if search:
+        if all or enable_search:
             tools.append(self.search_exa)
-        if get_contents:
+        if all or enable_get_contents:
             tools.append(self.get_contents)
-        if find_similar:
+        if all or enable_find_similar:
             tools.append(self.find_similar)
-        if answer:
+        if all or enable_answer:
             tools.append(self.exa_answer)
-        if research:
+        if all or enable_research:
             tools.append(self.research)
 
         super().__init__(name="exa", tools=tools, **kwargs)
@@ -353,14 +358,14 @@ class ExaTools(Toolkit):
             else:
                 task_kwargs["output_infer_schema"] = True
 
-            task_result = self._execute_with_timeout(self.exa.research.create_task, **task_kwargs)
+            task_result = self._execute_with_timeout(self.exa.research.create_task, **task_kwargs)  # type: ignore
             task_id = task_result.id
 
             if self.show_results:
                 log_info(f"Research task created with ID: {task_id}")
 
             # Step 2: Poll until complete (using default polling settings)
-            task = self.exa.research.poll_task(task_id)
+            task = self.exa.research.poll_task(task_id)  # type: ignore
 
             # Step 3: Format and return results
             result: Dict[str, Any] = {"data": task.data, "citations": {}}

agno/tools/fal.py

@@ -10,6 +10,7 @@ from agno.agent import Agent
 from agno.media import ImageArtifact, VideoArtifact
 from agno.team.team import Team
 from agno.tools import Toolkit
+from agno.tools.function import ToolResult
 from agno.utils.log import log_info, logger
 
 try:
@@ -23,16 +24,22 @@ class FalTools(Toolkit):
         self,
         api_key: Optional[str] = None,
         model: str = "fal-ai/hunyuan-video",
+        enable_generate_media: bool = True,
+        enable_image_to_image: bool = False,
+        all: bool = False,
         **kwargs,
     ):
-        self.api_key = api_key or getenv("FAL_KEY")
+        self.api_key = api_key or getenv("FAL_API_KEY")
         if not self.api_key:
-            logger.error("FAL_KEY not set. Please set the FAL_KEY environment variable.")
+            logger.error("FAL_API_KEY not set. Please set the FAL_API_KEY environment variable.")
         self.model = model
         self.seen_logs: set[str] = set()
 
         tools = []
-        tools.append(self.generate_media)
+        if all or enable_generate_media:
+            tools.append(self.generate_media)
+        if all or enable_image_to_image:
+            tools.append(self.image_to_image)
 
         super().__init__(name="fal-tools", tools=tools, **kwargs)
 
@@ -44,14 +51,14 @@ class FalTools(Toolkit):
                     log_info(message)
                     self.seen_logs.add(message)
 
-    def generate_media(self, agent: Union[Agent, Team], prompt: str) -> str:
+    def generate_media(self, agent: Union[Agent, Team], prompt: str) -> ToolResult:
         """
         Use this function to run a model with a given prompt.
 
         Args:
             prompt (str): A text description of the task.
         Returns:
-            str: Return the result of the model.
+            ToolResult: Contains the generated media and success message.
         """
         try:
             result = fal_client.subscribe(
@@ -65,32 +72,27 @@ class FalTools(Toolkit):
 
             if "image" in result:
                 url = result.get("image", {}).get("url", "")
-                agent.add_image(
-                    ImageArtifact(
-                        id=media_id,
-                        url=url,
-                    )
+                image_artifact = ImageArtifact(
+                    id=media_id,
+                    url=url,
                 )
-                media_type = "image"
+                return ToolResult(content=f"Image generated successfully at {url}", images=[image_artifact])
             elif "video" in result:
                 url = result.get("video", {}).get("url", "")
-                agent.add_video(
-                    VideoArtifact(
-                        id=media_id,
-                        url=url,
-                    )
+                video_artifact = VideoArtifact(
+                    id=media_id,
+                    url=url,
                 )
-                media_type = "video"
+                return ToolResult(content=f"Video generated successfully at {url}", videos=[video_artifact])
             else:
                 logger.error(f"Unsupported type in result: {result}")
-                return f"Unsupported type in result: {result}"
+                return ToolResult(content=f"Unsupported type in result: {result}")
 
-            return f"{media_type.capitalize()} generated successfully at {url}"
         except Exception as e:
             logger.error(f"Failed to run model: {e}")
-            return f"Error: {e}"
+            return ToolResult(content=f"Error: {e}")
 
-    def image_to_image(self, agent: Union[Agent, Team], prompt: str, image_url: Optional[str] = None) -> str:
+    def image_to_image(self, agent: Union[Agent, Team], prompt: str, image_url: Optional[str] = None) -> ToolResult:
         """
         Use this function to transform an input image based on a text prompt using the Fal AI image-to-image model.
         The model takes an existing image and generates a new version modified according to your prompt.
@@ -101,7 +103,7 @@ class FalTools(Toolkit):
             image_url (str): The URL of the image to use for the generation.
 
         Returns:
-            str: Return the result of the model.
+            ToolResult: Contains the generated image and success message.
         """
 
         try:
@@ -113,15 +115,13 @@ class FalTools(Toolkit):
             )
             url = result.get("images", [{}])[0].get("url", "")
             media_id = str(uuid4())
-            agent.add_image(
-                ImageArtifact(
-                    id=media_id,
-                    url=url,
-                )
+            image_artifact = ImageArtifact(
+                id=media_id,
+                url=url,
             )
 
-            return f"Image generated successfully at {url}"
+            return ToolResult(content=f"Image generated successfully at {url}", images=[image_artifact])
 
         except Exception as e:
             logger.error(f"Failed to generate image: {e}")
-            return f"Error: {e}"
+            return ToolResult(content=f"Error: {e}")

agno/tools/file.py

@@ -10,22 +10,23 @@ class FileTools(Toolkit):
     def __init__(
         self,
         base_dir: Optional[Path] = None,
-        save_files: bool = True,
-        read_files: bool = True,
-        list_files: bool = True,
-        search_files: bool = True,
+        enable_save_file: bool = True,
+        enable_read_file: bool = True,
+        enable_list_files: bool = True,
+        enable_search_files: bool = True,
+        all: bool = False,
         **kwargs,
     ):
         self.base_dir: Path = base_dir or Path.cwd()
 
         tools: List[Any] = []
-        if save_files:
+        if all or enable_save_file:
             tools.append(self.save_file)
-        if read_files:
+        if all or enable_read_file:
             tools.append(self.read_file)
-        if list_files:
+        if all or enable_list_files:
             tools.append(self.list_files)
-        if search_files:
+        if all or enable_search_files:
             tools.append(self.search_files)
 
         super().__init__(name="file_tools", tools=tools, **kwargs)

agno/tools/financial_datasets.py

@@ -11,29 +11,12 @@ class FinancialDatasetsTools(Toolkit):
     def __init__(
         self,
         api_key: Optional[str] = None,
-        enable_financial_statements: bool = True,
-        enable_company_info: bool = True,
-        enable_market_data: bool = True,
-        enable_ownership_data: bool = True,
-        enable_news: bool = True,
-        enable_sec_filings: bool = True,
-        enable_crypto: bool = True,
-        enable_search: bool = True,
         **kwargs,
     ):
-        """
-        Initialize the Financial Datasets Tools with feature flags.
+        """Initialize the Financial Datasets Tools.
 
         Args:
             api_key: API key for Financial Datasets API (optional, can be set via environment variable)
-            enable_financial_statements: Enable financial statement related functions (income statements, balance sheets, etc.)
-            enable_company_info: Enable company information related functions
-            enable_market_data: Enable market data related functions (stock prices, earnings, metrics)
-            enable_ownership_data: Enable ownership data related functions (insider trades, institutional ownership)
-            enable_news: Enable news related functions
-            enable_sec_filings: Enable SEC filings related functions
-            enable_crypto: Enable cryptocurrency related functions
-            enable_search: Enable search related functions
         """
 
         self.api_key: Optional[str] = api_key or getenv("FINANCIAL_DATASETS_API_KEY")
@@ -44,32 +27,30 @@ class FinancialDatasetsTools(Toolkit):
 
         self.base_url = "https://api.financialdatasets.ai"
 
-        tools: List[Any] = []
-
-        if enable_financial_statements:
-            tools.extend(
-                [
-                    self.get_income_statements,
-                    self.get_balance_sheets,
-                    self.get_cash_flow_statements,
-                    self.get_segmented_financials,
-                    self.get_financial_metrics,
-                ]
-            )
-        if enable_company_info:
-            tools.append(self.get_company_info)
-        if enable_market_data:
-            tools.extend([self.get_stock_prices, self.get_earnings])
-        if enable_ownership_data:
-            tools.extend([self.get_insider_trades, self.get_institutional_ownership])
-        if enable_news:
-            tools.append(self.get_news)
-        if enable_sec_filings:
-            tools.append(self.get_sec_filings)
-        if enable_crypto:
-            tools.append(self.get_crypto_prices)
-        if enable_search:
-            tools.append(self.search_tickers)
+        tools: List[Any] = [
+            # Financial statements
+            self.get_income_statements,
+            self.get_balance_sheets,
+            self.get_cash_flow_statements,
+            self.get_segmented_financials,
+            self.get_financial_metrics,
+            # Company info
+            self.get_company_info,
+            # Market data
+            self.get_stock_prices,
+            self.get_earnings,
+            # Ownership data
+            self.get_insider_trades,
+            self.get_institutional_ownership,
+            # News
+            self.get_news,
+            # SEC filings
+            self.get_sec_filings,
+            # Crypto
+            self.get_crypto_prices,
+            # Search
+            self.search_tickers,
+        ]
 
         super().__init__(name="financial_datasets_tools", tools=tools, **kwargs)
 

agno/tools/firecrawl.py

@@ -6,7 +6,8 @@ from agno.tools import Toolkit
 from agno.utils.log import logger
 
 try:
-    from firecrawl import FirecrawlApp, ScrapeOptions  # type: ignore[attr-defined]
+    from firecrawl import FirecrawlApp  # type: ignore[attr-defined]
+    from firecrawl.types import ScrapeOptions
 except ImportError:
     raise ImportError("`firecrawl-py` not installed. Please install using `pip install firecrawl-py`")
 
@@ -24,26 +25,32 @@ class CustomJSONEncoder(json.JSONEncoder):
 class FirecrawlTools(Toolkit):
     """
     Firecrawl is a tool for scraping and crawling websites.
+
     Args:
         api_key (Optional[str]): The API key to use for the Firecrawl app.
+        enable_scrape (bool): Enable website scraping functionality. Default is True.
+        enable_crawl (bool): Enable website crawling functionality. Default is False.
+        enable_mapping (bool): Enable website mapping functionality. Default is False.
+        enable_search (bool): Enable web search functionality. Default is False.
+        all (bool): Enable all tools. Overrides individual flags when True. Default is False.
         formats (Optional[List[str]]): The formats to use for the Firecrawl app.
         limit (int): The maximum number of pages to crawl.
-        scrape (bool): Whether to scrape the website.
-        crawl (bool): Whether to crawl the website.
-        mapping (bool): Whether to map the website.
+        poll_interval (int): Polling interval for crawl operations.
+        search_params (Optional[Dict[str, Any]]): Parameters for search operations.
         api_url (Optional[str]): The API URL to use for the Firecrawl app.
     """
 
     def __init__(
         self,
         api_key: Optional[str] = None,
+        enable_scrape: bool = True,
+        enable_crawl: bool = False,
+        enable_mapping: bool = False,
+        enable_search: bool = False,
+        all: bool = False,
         formats: Optional[List[str]] = None,
         limit: int = 10,
         poll_interval: int = 30,
-        scrape: bool = True,
-        crawl: bool = False,
-        mapping: bool = False,
-        search: bool = False,
         search_params: Optional[Dict[str, Any]] = None,
         api_url: Optional[str] = "https://api.firecrawl.dev",
         **kwargs,
@@ -58,21 +65,14 @@ class FirecrawlTools(Toolkit):
         self.app: FirecrawlApp = FirecrawlApp(api_key=self.api_key, api_url=api_url)
         self.search_params = search_params
 
-        # Start with scrape by default. But if crawl is set, then set scrape to False.
-        if crawl:
-            scrape = False
-            mapping = False
-        elif not scrape:
-            crawl = True
-
         tools: List[Any] = []
-        if scrape:
+        if all or enable_scrape:
             tools.append(self.scrape_website)
-        if crawl:
+        if all or enable_crawl:
             tools.append(self.crawl_website)
-        if mapping:
+        if all or enable_mapping:
             tools.append(self.map_website)
-        if search:
+        if all or enable_search:
             tools.append(self.search)
 
         super().__init__(name="firecrawl_tools", tools=tools, **kwargs)
@@ -87,7 +87,7 @@ class FirecrawlTools(Toolkit):
         if self.formats:
             params["formats"] = self.formats
 
-        scrape_result = self.app.scrape_url(url, **params)
+        scrape_result = self.app.scrape(url, **params)
         return json.dumps(scrape_result.model_dump(), cls=CustomJSONEncoder)
 
     def crawl_website(self, url: str, limit: Optional[int] = None) -> str:
@@ -108,7 +108,7 @@ class FirecrawlTools(Toolkit):
 
         params["poll_interval"] = self.poll_interval
 
-        crawl_result = self.app.crawl_url(url, **params)
+        crawl_result = self.app.crawl(url, **params)
         return json.dumps(crawl_result.model_dump(), cls=CustomJSONEncoder)
 
     def map_website(self, url: str) -> str:
@@ -118,7 +118,7 @@ class FirecrawlTools(Toolkit):
             url (str): The URL to map.
 
         """
-        map_result = self.app.map_url(url)
+        map_result = self.app.map(url)
         return json.dumps(map_result.model_dump(), cls=CustomJSONEncoder)
 
     def search(self, query: str, limit: Optional[int] = None):

agno/tools/function.py

@@ -8,6 +8,7 @@ from packaging.version import Version
 from pydantic import BaseModel, Field, validate_call
 
 from agno.exceptions import AgentRunException
+from agno.media import AudioArtifact, ImageArtifact, VideoArtifact
 from agno.utils.log import log_debug, log_error, log_exception, log_warning
 
 T = TypeVar("T")
@@ -84,8 +85,6 @@ class Function(BaseModel):
     entrypoint: Optional[Callable] = None
     # If True, the entrypoint processing is skipped and the Function is used as is.
     skip_entrypoint_processing: bool = False
-    # If True, the arguments are sanitized before being passed to the function. (Deprecated)
-    sanitize_arguments: bool = False
     # If True, the function call will show the result along with sending it to the model.
     show_result: bool = False
     # If True, the agent will stop after the function call.
@@ -123,6 +122,8 @@ class Function(BaseModel):
     _agent: Optional[Any] = None
     # The team that the function is associated with
     _team: Optional[Any] = None
+    # The session state that the function is associated with
+    _session_state: Optional[Dict[str, Any]] = None
 
     def to_dict(self) -> Dict[str, Any]:
         return self.model_dump(
@@ -143,17 +144,19 @@ class Function(BaseModel):
             type_hints = get_type_hints(c)
 
             # If function has an the agent argument, remove the agent parameter from the type hints
-            if "agent" in sig.parameters:
+            if "agent" in sig.parameters and "agent" in type_hints:
                 del type_hints["agent"]
-            if "team" in sig.parameters:
+            if "team" in sig.parameters and "team" in type_hints:
                 del type_hints["team"]
+            if "session_state" in sig.parameters and "session_state" in type_hints:
+                del type_hints["session_state"]
             # log_info(f"Type hints for {function_name}: {type_hints}")
 
             # Filter out return type and only process parameters
             param_type_hints = {
                 name: type_hints.get(name)
                 for name in sig.parameters
-                if name != "return" and name not in ["agent", "team", "self"]
+                if name != "return" and name not in ["agent", "team", "session_state", "self"]
             }
 
             # Parse docstring for parameters
@@ -180,14 +183,14 @@ class Function(BaseModel):
             # See: https://platform.openai.com/docs/guides/structured-outputs/supported-schemas#all-fields-must-be-required
             if strict:
                 parameters["required"] = [
-                    name for name in parameters["properties"] if name not in ["agent", "team", "self"]
+                    name for name in parameters["properties"] if name not in ["agent", "team", "session_state", "self"]
                 ]
             else:
                 # Mark a field as required if it has no default value (this would include optional fields)
                 parameters["required"] = [
                     name
                     for name, param in sig.parameters.items()
-                    if param.default == param.empty and name != "self" and name not in ["agent", "team"]
+                    if param.default == param.empty and name not in ["agent", "team", "session_state", "self"]
                 ]
 
             # log_debug(f"JSON schema for {function_name}: {parameters}")
@@ -232,14 +235,16 @@ class Function(BaseModel):
             type_hints = get_type_hints(self.entrypoint)
 
             # If function has an the agent argument, remove the agent parameter from the type hints
-            if "agent" in sig.parameters:
+            if "agent" in sig.parameters and "agent" in type_hints:
                 del type_hints["agent"]
-            if "team" in sig.parameters:
+            if "team" in sig.parameters and "team" in type_hints:
                 del type_hints["team"]
+            if "session_state" in sig.parameters and "session_state" in type_hints:
+                del type_hints["session_state"]
             # log_info(f"Type hints for {self.name}: {type_hints}")
 
             # Filter out return type and only process parameters
-            excluded_params = ["return", "agent", "team", "self"]
+            excluded_params = ["return", "agent", "team", "session_state", "self"]
             if self.requires_user_input and self.user_input_fields:
                 if len(self.user_input_fields) == 0:
                     excluded_params.extend(list(type_hints.keys()))
@@ -352,7 +357,7 @@ class Function(BaseModel):
     def process_schema_for_strict(self):
         self.parameters["additionalProperties"] = False
         self.parameters["required"] = [
-            name for name in self.parameters["properties"] if name not in ["agent", "team", "self"]
+            name for name in self.parameters["properties"] if name not in ["agent", "team", "session_state", "self"]
         ]
 
     def _get_cache_key(self, entrypoint_args: Dict[str, Any], call_args: Optional[Dict[str, Any]] = None) -> str:
@@ -365,6 +370,8 @@ class Function(BaseModel):
             del copy_entrypoint_args["agent"]
         if "team" in copy_entrypoint_args:
             del copy_entrypoint_args["team"]
+        if "session_state" in copy_entrypoint_args:
+            del copy_entrypoint_args["session_state"]
         args_str = str(copy_entrypoint_args)
 
         kwargs_str = str(sorted((call_args or {}).items()))
@@ -425,6 +432,13 @@ class FunctionExecutionResult(BaseModel):
     result: Optional[Any] = None
     error: Optional[str] = None
 
+    updated_session_state: Optional[Dict[str, Any]] = None
+
+    # New fields for media artifacts
+    images: Optional[List[ImageArtifact]] = None
+    videos: Optional[List[VideoArtifact]] = None
+    audios: Optional[List[AudioArtifact]] = None
+
 
 class FunctionCall(BaseModel):
     """Model for Function Calls"""
@@ -480,6 +494,9 @@ class FunctionCall(BaseModel):
                 # Check if the pre-hook has an team argument
                 if "team" in signature(self.function.pre_hook).parameters:
                     pre_hook_args["team"] = self.function._team
+                # Check if the pre-hook has an session_state argument
+                if "session_state" in signature(self.function.pre_hook).parameters:
+                    pre_hook_args["session_state"] = self.function._session_state
                 # Check if the pre-hook has an fc argument
                 if "fc" in signature(self.function.pre_hook).parameters:
                     pre_hook_args["fc"] = self
@@ -505,6 +522,9 @@ class FunctionCall(BaseModel):
                 # Check if the post-hook has an team argument
                 if "team" in signature(self.function.post_hook).parameters:
                     post_hook_args["team"] = self.function._team
+                # Check if the post-hook has an session_state argument
+                if "session_state" in signature(self.function.post_hook).parameters:
+                    post_hook_args["session_state"] = self.function._session_state
                 # Check if the post-hook has an fc argument
                 if "fc" in signature(self.function.post_hook).parameters:
                     post_hook_args["fc"] = self
@@ -528,6 +548,9 @@ class FunctionCall(BaseModel):
         # Check if the entrypoint has an team argument
         if "team" in signature(self.function.entrypoint).parameters:  # type: ignore
             entrypoint_args["team"] = self.function._team
+        # Check if the entrypoint has an session_state argument
+        if "session_state" in signature(self.function.entrypoint).parameters:  # type: ignore
+            entrypoint_args["session_state"] = self.function._session_state
         # Check if the entrypoint has an fc argument
         if "fc" in signature(self.function.entrypoint).parameters:  # type: ignore
             entrypoint_args["fc"] = self
@@ -544,6 +567,9 @@ class FunctionCall(BaseModel):
         # Check if the hook has an team argument
         if "team" in signature(hook).parameters:
             hook_args["team"] = self.function._team
+        # Check if the hook has an session_state argument
+        if "session_state" in signature(hook).parameters:
+            hook_args["session_state"] = self.function._session_state
 
         if "name" in signature(hook).parameters:
             hook_args["name"] = name
@@ -641,10 +667,11 @@ class FunctionCall(BaseModel):
                 execution_chain = self._build_nested_execution_chain(entrypoint_args=entrypoint_args)
                 result = execution_chain(self.function.name, self.function.entrypoint, self.arguments or {})
             else:
-                arguments = entrypoint_args
-                if self.arguments is not None:
-                    arguments.update(self.arguments)
-                result = self.function.entrypoint(**arguments)
+                result = self.function.entrypoint(**entrypoint_args, **self.arguments)  # type: ignore
+
+            updated_session_state = None
+            if entrypoint_args.get("session_state") is not None:
+                updated_session_state = entrypoint_args.get("session_state")
 
             # Handle generator case
             if isgenerator(result):
@@ -670,7 +697,9 @@ class FunctionCall(BaseModel):
         # Execute post-hook if it exists
         self._handle_post_hook()
 
-        return FunctionExecutionResult(status="success", result=self.result)
+        return FunctionExecutionResult(
+            status="success", result=self.result, updated_session_state=updated_session_state
+        )
 
     async def _handle_pre_hook_async(self):
         """Handles the async pre-hook for the function call."""
@@ -685,6 +714,9 @@ class FunctionCall(BaseModel):
                 # Check if the pre-hook has an team argument
                 if "team" in signature(self.function.pre_hook).parameters:
                     pre_hook_args["team"] = self.function._team
+                # Check if the pre-hook has an session_state argument
+                if "session_state" in signature(self.function.pre_hook).parameters:
+                    pre_hook_args["session_state"] = self.function._session_state
                 # Check if the pre-hook has an fc argument
                 if "fc" in signature(self.function.pre_hook).parameters:
                     pre_hook_args["fc"] = self
@@ -711,6 +743,10 @@ class FunctionCall(BaseModel):
                 # Check if the post-hook has an team argument
                 if "team" in signature(self.function.post_hook).parameters:
                     post_hook_args["team"] = self.function._team
+                # Check if the post-hook has an session_state argument
+                if "session_state" in signature(self.function.post_hook).parameters:
+                    post_hook_args["session_state"] = self.function._session_state
+
                 # Check if the post-hook has an fc argument
                 if "fc" in signature(self.function.post_hook).parameters:
                     post_hook_args["fc"] = self
@@ -839,6 +875,10 @@ class FunctionCall(BaseModel):
                 cache_file = self.function._get_cache_file_path(cache_key)
                 self.function._save_to_cache(cache_file, self.result)
 
+            updated_session_state = None
+            if entrypoint_args.get("session_state") is not None:
+                updated_session_state = entrypoint_args.get("session_state")
+
         except AgentRunException as e:
             log_debug(f"{e.__class__.__name__}: {e}")
             self.error = str(e)
@@ -855,4 +895,15 @@ class FunctionCall(BaseModel):
         else:
             self._handle_post_hook()
 
-        return FunctionExecutionResult(status="success", result=self.result)
+        return FunctionExecutionResult(
+            status="success", result=self.result, updated_session_state=updated_session_state
+        )
+
+
+class ToolResult(BaseModel):
+    """Result from a tool that can include media artifacts."""
+
+    content: str
+    images: Optional[List[ImageArtifact]] = None
+    videos: Optional[List[VideoArtifact]] = None
+    audios: Optional[List[AudioArtifact]] = None