agno 2.2.13__py3-none-any.whl → 2.4.3__py3-none-any.whl

agno/tools/memory.py

@@ -1,10 +1,11 @@
 import json
 from textwrap import dedent
-from typing import Any, Dict, List, Optional
+from typing import Any, List, Optional
 from uuid import uuid4
 
 from agno.db.base import BaseDb
 from agno.db.schemas import UserMemory
+from agno.run import RunContext
 from agno.tools import Toolkit
 from agno.utils.log import log_debug, log_error
 
@@ -62,7 +63,7 @@ class MemoryTools(Toolkit):
             **kwargs,
         )
 
-    def think(self, session_state: Dict[str, Any], thought: str) -> str:
+    def think(self, run_context: RunContext, thought: str) -> str:
         """Use this tool as a scratchpad to reason about memory operations, refine your approach, brainstorm memory content, or revise your plan.
 
         Call `Think` whenever you need to figure out what to do next, analyze the user's requirements, plan memory operations, or decide on execution strategy.
@@ -75,14 +76,14 @@ class MemoryTools(Toolkit):
             log_debug(f"Memory Thought: {thought}")
 
             # Add the thought to the session state
-            if session_state is None:
-                session_state = {}
-            if "memory_thoughts" not in session_state:
-                session_state["memory_thoughts"] = []
-            session_state["memory_thoughts"].append(thought)
+            if run_context.session_state is None:
+                run_context.session_state = {}
+            if "memory_thoughts" not in run_context.session_state:
+                run_context.session_state["memory_thoughts"] = []
+            run_context.session_state["memory_thoughts"].append(thought)
 
             # Return the full log of thoughts and the new thought
-            thoughts = "\n".join([f"- {t}" for t in session_state["memory_thoughts"]])
+            thoughts = "\n".join([f"- {t}" for t in run_context.session_state["memory_thoughts"]])
             formatted_thoughts = dedent(
                 f"""Memory Thoughts:
                 {thoughts}
@@ -93,21 +94,21 @@ class MemoryTools(Toolkit):
             log_error(f"Error recording memory thought: {e}")
             return f"Error recording memory thought: {e}"
 
-    def get_memories(self, session_state: Dict[str, Any]) -> str:
+    def get_memories(self, run_context: RunContext) -> str:
         """
         Use this tool to get a list of memories for the current user from the database.
         """
         try:
-            # Get user info from session state
-            user_id = session_state.get("current_user_id") if session_state else None
+            # Get user info from run context
+            user_id = run_context.user_id
 
             memories = self.db.get_user_memories(user_id=user_id)
 
             # Store the result in session state for analysis
-            if session_state is None:
-                session_state = {}
-            if "memory_operations" not in session_state:
-                session_state["memory_operations"] = []
+            if run_context.session_state is None:
+                run_context.session_state = {}
+            if "memory_operations" not in run_context.session_state:
+                run_context.session_state["memory_operations"] = []
 
             operation_result = {
                 "operation": "get_memories",
@@ -115,7 +116,7 @@ class MemoryTools(Toolkit):
                 "memories": [memory.to_dict() for memory in memories],  # type: ignore
                 "error": None,
             }
-            session_state["memory_operations"].append(operation_result)
+            run_context.session_state["memory_operations"].append(operation_result)
 
             return json.dumps([memory.to_dict() for memory in memories], indent=2)  # type: ignore
         except Exception as e:
@@ -124,7 +125,7 @@ class MemoryTools(Toolkit):
 
     def add_memory(
         self,
-        session_state: Dict[str, Any],
+        run_context: RunContext,
         memory: str,
         topics: Optional[List[str]] = None,
     ) -> str:
@@ -140,8 +141,8 @@ class MemoryTools(Toolkit):
         try:
             log_debug(f"Adding memory: {memory}")
 
-            # Get user and agent info from session state
-            user_id = session_state.get("current_user_id") if session_state else None
+            # Get user info from run context
+            user_id = run_context.user_id
 
             # Create UserMemory object
             user_memory = UserMemory(
@@ -155,10 +156,10 @@ class MemoryTools(Toolkit):
             created_memory = self.db.upsert_user_memory(user_memory)
 
             # Store the result in session state for analysis
-            if session_state is None:
-                session_state = {}
-            if "memory_operations" not in session_state:
-                session_state["memory_operations"] = []
+            if run_context.session_state is None:
+                run_context.session_state = {}
+            if "memory_operations" not in run_context.session_state:
+                run_context.session_state["memory_operations"] = []
 
             memory_dict = created_memory.to_dict() if created_memory else None  # type: ignore
 
@@ -168,7 +169,7 @@ class MemoryTools(Toolkit):
                 "memory": memory_dict,
                 "error": None,
             }
-            session_state["memory_operations"].append(operation_result)
+            run_context.session_state["memory_operations"].append(operation_result)
 
             if created_memory:
                 return json.dumps({"success": True, "operation": "add_memory", "memory": memory_dict}, indent=2)
@@ -183,7 +184,7 @@ class MemoryTools(Toolkit):
 
     def update_memory(
         self,
-        session_state: Dict[str, Any],
+        run_context: RunContext,
         memory_id: str,
         memory: Optional[str] = None,
         topics: Optional[List[str]] = None,
@@ -221,10 +222,10 @@ class MemoryTools(Toolkit):
             updated_result = self.db.upsert_user_memory(updated_memory)
 
             # Store the result in session state for analysis
-            if session_state is None:
-                session_state = {}
-            if "memory_operations" not in session_state:
-                session_state["memory_operations"] = []
+            if run_context.session_state is None:
+                run_context.session_state = {}
+            if "memory_operations" not in run_context.session_state:
+                run_context.session_state["memory_operations"] = []
 
             memory_dict = updated_result.to_dict() if updated_result else None  # type: ignore
 
@@ -234,7 +235,7 @@ class MemoryTools(Toolkit):
                 "memory": memory_dict,
                 "error": None,
             }
-            session_state["memory_operations"].append(operation_result)
+            run_context.session_state["memory_operations"].append(operation_result)
 
             if updated_result:
                 return json.dumps({"success": True, "operation": "update_memory", "memory": memory_dict}, indent=2)
@@ -249,7 +250,7 @@ class MemoryTools(Toolkit):
 
     def delete_memory(
         self,
-        session_state: Dict[str, Any],
+        run_context: RunContext,
         memory_id: str,
     ) -> str:
         """Use this tool to delete a memory from the database.
@@ -275,10 +276,10 @@ class MemoryTools(Toolkit):
             self.db.delete_user_memory(memory_id)
 
             # Store the result in session state for analysis
-            if session_state is None:
-                session_state = {}
-            if "memory_operations" not in session_state:
-                session_state["memory_operations"] = []
+            if run_context.session_state is None:
+                run_context.session_state = {}
+            if "memory_operations" not in run_context.session_state:
+                run_context.session_state["memory_operations"] = []
 
             memory_dict = existing_memory.to_dict() if existing_memory else None  # type: ignore
 
@@ -289,7 +290,7 @@ class MemoryTools(Toolkit):
                 "deleted_memory": memory_dict,
                 "error": None,
             }
-            session_state["memory_operations"].append(operation_result)
+            run_context.session_state["memory_operations"].append(operation_result)
 
             return json.dumps(
                 {
@@ -305,7 +306,7 @@ class MemoryTools(Toolkit):
             log_error(f"Error deleting memory: {e}")
             return json.dumps({"success": False, "operation": "delete_memory", "error": str(e)}, indent=2)
 
-    def analyze(self, session_state: Dict[str, Any], analysis: str) -> str:
+    def analyze(self, run_context: RunContext, analysis: str) -> str:
         """Use this tool to evaluate whether the memory operations results are correct and sufficient.
         If not, go back to "Think" or use memory operations with refined parameters.
 
@@ -316,14 +317,14 @@ class MemoryTools(Toolkit):
             log_debug(f"Memory Analysis: {analysis}")
 
             # Add the analysis to the session state
-            if session_state is None:
-                session_state = {}
-            if "memory_analysis" not in session_state:
-                session_state["memory_analysis"] = []
-            session_state["memory_analysis"].append(analysis)
+            if run_context.session_state is None:
+                run_context.session_state = {}
+            if "memory_analysis" not in run_context.session_state:
+                run_context.session_state["memory_analysis"] = []
+            run_context.session_state["memory_analysis"].append(analysis)
 
             # Return the full log of analysis and the new analysis
-            analysis_log = "\n".join([f"- {a}" for a in session_state["memory_analysis"]])
+            analysis_log = "\n".join([f"- {a}" for a in run_context.session_state["memory_analysis"]])
             formatted_analysis = dedent(
                 f"""Memory Analysis:
                 {analysis_log}
@@ -338,7 +339,7 @@ class MemoryTools(Toolkit):
         You have access to the Think, Add Memory, Update Memory, Delete Memory, and Analyze tools that will help you manage user memories and analyze their operations. Use these tools as frequently as needed to successfully complete memory management tasks.
 
         ## How to use the Think, Memory Operations, and Analyze tools:
-        
+
         1. **Think**
         - Purpose: A scratchpad for planning memory operations, brainstorming memory content, and refining your approach. You never reveal your "Think" content to the user.
         - Usage: Call `think` whenever you need to figure out what memory operations to perform, analyze requirements, or decide on strategy.
@@ -407,12 +408,12 @@ class MemoryTools(Toolkit):
         Analyze: Successfully deleted the outdated work schedule memory. The old information won't interfere with future scheduling requests.
 
         Final Answer: I've removed your old work schedule information. Feel free to share your new schedule when you're ready, and I'll store the updated information.
-        
+
         #### Example 4: Retrieving Memories
 
         User: What have you remembered about me?
         Think: The user wants to retrieve memories about themselves. I should use the get_memories tool to retrieve the memories.
-        Get Memories: 
+        Get Memories:
         Analyze: Successfully retrieved the memories about the user. The memories are relevant to the user's preferences and activities.
 
         Final Answer: I've retrieved the memories about you. You like to hike in the mountains on weekends and travel to new places and experience different cultures. You are planning to travel to Africa in December.\

agno/tools/mlx_transcribe.py

@@ -17,7 +17,7 @@ provides high-quality transcription capabilities.
 
 import json
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any, Dict, List, Optional, Union
 
 from agno.tools import Toolkit
 from agno.utils.log import log_info, logger
@@ -33,9 +33,10 @@ class MLXTranscribeTools(Toolkit):
         self,
         base_dir: Optional[Path] = None,
         enable_read_files_in_base_dir: bool = True,
+        restrict_to_base_dir: bool = True,
         path_or_hf_repo: str = "mlx-community/whisper-large-v3-turbo",
         verbose: Optional[bool] = None,
-        temperature: Optional[Union[float, Tuple[float, ...]]] = None,
+        temperature: Optional[Union[float, tuple[float, ...]]] = None,
         compression_ratio_threshold: Optional[float] = None,
         logprob_threshold: Optional[float] = None,
         no_speech_threshold: Optional[float] = None,
@@ -50,10 +51,11 @@ class MLXTranscribeTools(Toolkit):
         all: bool = False,
         **kwargs,
     ):
-        self.base_dir: Path = base_dir or Path.cwd()
+        self.base_dir: Path = (base_dir or Path.cwd()).resolve()
+        self.restrict_to_base_dir = restrict_to_base_dir
         self.path_or_hf_repo: str = path_or_hf_repo
         self.verbose: Optional[bool] = verbose
-        self.temperature: Optional[Union[float, Tuple[float, ...]]] = temperature
+        self.temperature: Optional[Union[float, tuple[float, ...]]] = temperature
         self.compression_ratio_threshold: Optional[float] = compression_ratio_threshold
         self.logprob_threshold: Optional[float] = logprob_threshold
         self.no_speech_threshold: Optional[float] = no_speech_threshold
@@ -83,9 +85,10 @@ class MLXTranscribeTools(Toolkit):
             str: The transcribed text or an error message if the transcription fails.
         """
         try:
-            audio_file_path = str(self.base_dir.joinpath(file_name))
-            if audio_file_path is None:
-                return "No audio file path provided"
+            safe, file_path = self._check_path(file_name, self.base_dir, self.restrict_to_base_dir)
+            if not safe:
+                return f"Error: Path '{file_name}' is outside the allowed base directory"
+            audio_file_path = str(file_path)
 
             log_info(f"Transcribing audio file {audio_file_path}")
             transcription_kwargs: Dict[str, Any] = {

agno/tools/models/nebius.py

@@ -12,12 +12,12 @@ from agno.utils.log import log_error, log_warning
 
 
 class NebiusTools(Toolkit):
-    """Tools for interacting with Nebius AI Studio's text-to-image API"""
+    """Tools for interacting with Nebius Token Factory's text-to-image API"""
 
     def __init__(
         self,
         api_key: Optional[str] = None,
-        base_url: str = "https://api.studio.nebius.com/v1",
+        base_url: str = "https://api.tokenfactory.nebius.com/v1",
         image_model: str = "black-forest-labs/flux-schnell",
         image_quality: Optional[str] = "standard",
         image_size: Optional[str] = "1024x1024",
@@ -26,11 +26,11 @@ class NebiusTools(Toolkit):
         all: bool = False,
         **kwargs,
     ):
-        """Initialize Nebius AI Studio text-to-image tools.
+        """Initialize Nebius Token Factory text-to-image tools.
 
         Args:
             api_key: Nebius API key. If not provided, will look for NEBIUS_API_KEY environment variable.
-            base_url: The base URL for the Nebius AI Studio API. This should be configured according to Nebius's documentation.
+            base_url: The base URL for the Nebius Token Factory API. This should be configured according to Nebius's documentation.
             image_model: The model to use for generation. Options include:
                   - "black-forest-labs/flux-schnell" (fastest)
                   - "black-forest-labs/flux-dev" (balanced)
@@ -69,7 +69,7 @@ class NebiusTools(Toolkit):
         agent: Agent,
         prompt: str,
     ) -> ToolResult:
-        """Generate images based on a text prompt using Nebius AI Studio.
+        """Generate images based on a text prompt using Nebius Token Factory.
 
         Args:
             agent: The agent instance for adding images

agno/tools/models_labs.py

@@ -4,10 +4,8 @@ from os import getenv
 from typing import Any, Dict, List, Optional, Union
 from uuid import uuid4
 
-from agno.agent import Agent
 from agno.media import Audio, Image, Video
 from agno.models.response import FileType
-from agno.team import Team
 from agno.tools import Toolkit
 from agno.tools.function import ToolResult
 from agno.utils.log import log_debug, log_info, logger
@@ -22,12 +20,14 @@ MODELS_LAB_URLS = {
     "MP4": "https://modelslab.com/api/v6/video/text2video",
     "MP3": "https://modelslab.com/api/v6/voice/music_gen",
     "GIF": "https://modelslab.com/api/v6/video/text2video",
+    "WAV": "https://modelslab.com/api/v6/voice/sfx",
 }
 
 MODELS_LAB_FETCH_URLS = {
     "MP4": "https://modelslab.com/api/v6/video/fetch",
     "MP3": "https://modelslab.com/api/v6/voice/fetch",
     "GIF": "https://modelslab.com/api/v6/video/fetch",
+    "WAV": "https://modelslab.com/api/v6/voice/fetch",
 }
 
 
@@ -78,6 +78,13 @@ class ModelsLabTools(Toolkit):
                 "output_type": self.file_type.value,
             }
             base_payload |= video_template  # Use |= instead of update()
+        elif self.file_type == FileType.WAV:
+            sfx_template = {
+                "duration": 10,
+                "output_format": "wav",
+                "temp": False,
+            }
+            base_payload |= sfx_template  # Use |= instead of update()
         else:
             audio_template = {
                 "base64": False,
@@ -101,7 +108,7 @@ class ModelsLabTools(Toolkit):
         elif self.file_type == FileType.GIF:
             image_artifact = Image(id=str(media_id), url=media_url)
             artifacts["images"].append(image_artifact)
-        elif self.file_type == FileType.MP3:
+        elif self.file_type in [FileType.MP3, FileType.WAV]:
             audio_artifact = Audio(id=str(media_id), url=media_url)
             artifacts["audios"].append(audio_artifact)
 
@@ -131,7 +138,7 @@ class ModelsLabTools(Toolkit):
 
         return False
 
-    def generate_media(self, agent: Union[Agent, Team], prompt: str) -> ToolResult:
+    def generate_media(self, prompt: str) -> ToolResult:
         """Generate media (video, image, or audio) given a prompt."""
         if not self.api_key:
             return ToolResult(content="Please set the MODELS_LAB_API_KEY")
@@ -157,7 +164,6 @@ class ModelsLabTools(Toolkit):
                 return ToolResult(content=f"Error: {result['error']}")
 
             eta = result.get("eta")
-            url_links = result.get("future_links")
             media_id = str(uuid4())
 
             # Collect all media artifacts
@@ -165,17 +171,21 @@ class ModelsLabTools(Toolkit):
             all_videos = []
             all_audios = []
 
+            if self.file_type == FileType.WAV:
+                url_links = result.get("output", [])
+            else:
+                url_links = result.get("future_links")
             for media_url in url_links:
                 artifacts = self._create_media_artifacts(media_id, media_url, str(eta))
                 all_images.extend(artifacts["images"])
                 all_videos.extend(artifacts["videos"])
                 all_audios.extend(artifacts["audios"])
 
-            if self.wait_for_completion and isinstance(eta, int):
-                if self._wait_for_media(media_id, eta):
-                    log_info("Media generation completed successfully")
-                else:
-                    logger.warning("Media generation timed out")
+                if self.wait_for_completion and isinstance(eta, int):
+                    if self._wait_for_media(media_id, eta):
+                        log_info("Media generation completed successfully")
+                    else:
+                        logger.warning("Media generation timed out")
 
             # Return ToolResult with appropriate media artifacts
             return ToolResult(

agno/tools/nano_banana.py

@@ -0,0 +1,151 @@
+from __future__ import annotations
+
+import os
+from io import BytesIO
+from typing import Any, List, Optional
+from uuid import uuid4
+
+from agno.media import Image
+from agno.tools import Toolkit
+from agno.tools.function import ToolResult
+from agno.utils.log import log_debug, logger
+
+try:
+    from google import genai
+    from google.genai import types
+    from PIL import Image as PILImage
+
+except ImportError as exc:
+    missing = []
+    try:
+        from google.genai import types
+    except ImportError:
+        missing.append("google-genai")
+
+    try:
+        from PIL import Image as PILImage
+    except ImportError:
+        missing.append("Pillow")
+
+    raise ImportError(
+        f"Missing required package(s): {', '.join(missing)}. Install using: pip install {' '.join(missing)}"
+    ) from exc
+
+
+# Note: Expand this list as new models become supported by the Google Content Generation API.
+ALLOWED_MODELS = ["gemini-2.5-flash-image"]
+ALLOWED_RATIOS = ["1:1", "2:3", "3:2", "3:4", "4:3", "4:5", "5:4", "9:16", "16:9", "21:9"]
+
+
+class NanoBananaTools(Toolkit):
+    def __init__(
+        self,
+        model: str = "gemini-2.5-flash-image",
+        aspect_ratio: str = "1:1",
+        api_key: Optional[str] = None,
+        enable_create_image: bool = True,
+        **kwargs,
+    ):
+        self.model = model
+        self.aspect_ratio = aspect_ratio
+        self.api_key = api_key or os.getenv("GOOGLE_API_KEY")
+
+        # Validate model
+        if model not in ALLOWED_MODELS:
+            raise ValueError(f"Invalid model '{model}'. Supported: {', '.join(ALLOWED_MODELS)}")
+
+        if self.aspect_ratio not in ALLOWED_RATIOS:
+            raise ValueError(f"Invalid aspect_ratio '{self.aspect_ratio}'. Supported: {', '.join(ALLOWED_RATIOS)}")
+
+        if not self.api_key:
+            raise ValueError("GOOGLE_API_KEY not set. Export it: `export GOOGLE_API_KEY=<your-key>`")
+
+        tools: List[Any] = []
+        if enable_create_image:
+            tools.append(self.create_image)
+
+        super().__init__(name="nano_banana", tools=tools, **kwargs)
+
+    def create_image(self, prompt: str) -> ToolResult:
+        """Generate an image from a text prompt."""
+        try:
+            client = genai.Client(api_key=self.api_key)
+            log_debug(f"NanoBanana generating image with prompt: {prompt}")
+
+            cfg = types.GenerateContentConfig(
+                response_modalities=["IMAGE"],
+                image_config=types.ImageConfig(aspect_ratio=self.aspect_ratio),
+            )
+
+            response = client.models.generate_content(
+                model=self.model,
+                contents=[prompt],  # type: ignore
+                config=cfg,
+            )
+
+            generated_images: List[Image] = []
+            response_str = ""
+
+            if not hasattr(response, "candidates") or not response.candidates:
+                logger.warning("No candidates in response")
+                return ToolResult(content="No images were generated in the response")
+
+            # Process each candidate
+            for candidate in response.candidates:
+                if not hasattr(candidate, "content") or not candidate.content or not candidate.content.parts:
+                    continue
+
+                for part in candidate.content.parts:
+                    if hasattr(part, "text") and part.text:
+                        response_str += part.text + "\n"
+
+                    if hasattr(part, "inline_data") and part.inline_data:
+                        try:
+                            # Extract image data from the blob
+                            image_data = part.inline_data.data
+                            mime_type = getattr(part.inline_data, "mime_type", "image/png")
+
+                            if image_data:
+                                pil_img = PILImage.open(BytesIO(image_data))
+
+                                # Save to buffer with proper format
+                                buffer = BytesIO()
+                                image_format = "PNG" if "png" in mime_type.lower() else "JPEG"
+                                pil_img.save(buffer, format=image_format)
+                                buffer.seek(0)
+
+                                agno_img = Image(
+                                    id=str(uuid4()),
+                                    content=buffer.getvalue(),
+                                    original_prompt=prompt,
+                                )
+                                generated_images.append(agno_img)
+
+                                log_debug(f"Successfully processed image with ID: {agno_img.id}")
+                                response_str += f"Image generated successfully (ID: {agno_img.id}).\n"
+
+                        except Exception as img_exc:
+                            logger.error(f"Failed to process image data: {img_exc}")
+                            response_str += f"Failed to process image: {img_exc}\n"
+
+            if hasattr(response, "usage_metadata") and response.usage_metadata:
+                log_debug(
+                    f"Token usage - Prompt: {response.usage_metadata.prompt_token_count}, "
+                    f"Response: {response.usage_metadata.candidates_token_count}, "
+                    f"Total: {response.usage_metadata.total_token_count}"
+                )
+
+            if generated_images:
+                return ToolResult(
+                    content=response_str.strip() or "Image(s) generated successfully",
+                    images=generated_images,
+                )
+            else:
+                return ToolResult(
+                    content=response_str.strip() or "No images were generated",
+                    images=None,
+                )
+
+        except Exception as exc:
+            logger.error(f"NanoBanana image generation failed: {exc}")
+            return ToolResult(content=f"Error generating image: {str(exc)}")

agno/tools/parallel.py

@@ -41,7 +41,6 @@ class ParallelTools(Toolkit):
         include_domains (Optional[List[str]]): Default domains to restrict results to. Default is None.
         exclude_domains (Optional[List[str]]): Default domains to exclude from results. Default is None.
         max_age_seconds (Optional[int]): Default cache age threshold (minimum 600). Default is None.
-        timeout_seconds (Optional[float]): Default timeout for content retrieval. Default is None.
         disable_cache_fallback (Optional[bool]): Default cache fallback behavior. Default is None.
     """
 
@@ -58,7 +57,6 @@ class ParallelTools(Toolkit):
         include_domains: Optional[List[str]] = None,
         exclude_domains: Optional[List[str]] = None,
         max_age_seconds: Optional[int] = None,
-        timeout_seconds: Optional[float] = None,
         disable_cache_fallback: Optional[bool] = None,
         **kwargs,
     ):
@@ -73,7 +71,6 @@ class ParallelTools(Toolkit):
         self.include_domains = include_domains
         self.exclude_domains = exclude_domains
         self.max_age_seconds = max_age_seconds
-        self.timeout_seconds = timeout_seconds
         self.disable_cache_fallback = disable_cache_fallback
 
         self.parallel_client = ParallelClient(
@@ -153,8 +150,6 @@ class ParallelTools(Toolkit):
             fetch_policy: Dict[str, Any] = {}
             if self.max_age_seconds is not None:
                 fetch_policy["max_age_seconds"] = self.max_age_seconds
-            if self.timeout_seconds is not None:
-                fetch_policy["timeout_seconds"] = self.timeout_seconds
             if self.disable_cache_fallback is not None:
                 fetch_policy["disable_cache_fallback"] = self.disable_cache_fallback
 
@@ -256,8 +251,6 @@ class ParallelTools(Toolkit):
             fetch_policy: Dict[str, Any] = {}
             if self.max_age_seconds is not None:
                 fetch_policy["max_age_seconds"] = self.max_age_seconds
-            if self.timeout_seconds is not None:
-                fetch_policy["timeout_seconds"] = self.timeout_seconds
             if self.disable_cache_fallback is not None:
                 fetch_policy["disable_cache_fallback"] = self.disable_cache_fallback