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

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],
+                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/yfinance.py

@@ -1,5 +1,5 @@
 import json
-from typing import Any, List
+from typing import Any, List, Optional
 
 from agno.tools import Toolkit
 from agno.utils.log import log_debug
@@ -18,6 +18,7 @@ class YFinanceTools(Toolkit):
 
     def __init__(
         self,
+        session: Optional[Any] = None,
         **kwargs,
     ):
         tools: List[Any] = [
@@ -31,7 +32,7 @@ class YFinanceTools(Toolkit):
             self.get_technical_indicators,
             self.get_historical_stock_prices,
         ]
-
+        self.session = session
         super().__init__(name="yfinance_tools", tools=tools, **kwargs)
 
     def get_current_stock_price(self, symbol: str) -> str:
@@ -46,7 +47,7 @@ class YFinanceTools(Toolkit):
         """
         try:
             log_debug(f"Fetching current price for {symbol}")
-            stock = yf.Ticker(symbol)
+            stock = yf.Ticker(symbol, session=self.session)
             # Use "regularMarketPrice" for regular market hours, or "currentPrice" for pre/post market
             current_price = stock.info.get("regularMarketPrice", stock.info.get("currentPrice"))
             return f"{current_price:.4f}" if current_price else f"Could not fetch current price for {symbol}"
@@ -63,7 +64,7 @@ class YFinanceTools(Toolkit):
             str: JSON containing company profile and overview.
         """
         try:
-            company_info_full = yf.Ticker(symbol).info
+            company_info_full = yf.Ticker(symbol, session=self.session).info
             if company_info_full is None:
                 return f"Could not fetch company info for {symbol}"
 
@@ -120,7 +121,7 @@ class YFinanceTools(Toolkit):
         """
         try:
             log_debug(f"Fetching historical prices for {symbol}")
-            stock = yf.Ticker(symbol)
+            stock = yf.Ticker(symbol, session=self.session)
             historical_price = stock.history(period=period, interval=interval)
             return historical_price.to_json(orient="index")
         except Exception as e:
@@ -150,7 +151,7 @@ class YFinanceTools(Toolkit):
         """
         try:
             log_debug(f"Fetching fundamentals for {symbol}")
-            stock = yf.Ticker(symbol)
+            stock = yf.Ticker(symbol, session=self.session)
             info = stock.info
             fundamentals = {
                 "symbol": symbol,
@@ -181,7 +182,7 @@ class YFinanceTools(Toolkit):
         """
         try:
             log_debug(f"Fetching income statements for {symbol}")
-            stock = yf.Ticker(symbol)
+            stock = yf.Ticker(symbol, session=self.session)
             financials = stock.financials
             return financials.to_json(orient="index")
         except Exception as e:
@@ -198,7 +199,7 @@ class YFinanceTools(Toolkit):
         """
         try:
             log_debug(f"Fetching key financial ratios for {symbol}")
-            stock = yf.Ticker(symbol)
+            stock = yf.Ticker(symbol, session=self.session)
             key_ratios = stock.info
             return json.dumps(key_ratios, indent=2)
         except Exception as e:
@@ -215,7 +216,7 @@ class YFinanceTools(Toolkit):
         """
         try:
             log_debug(f"Fetching analyst recommendations for {symbol}")
-            stock = yf.Ticker(symbol)
+            stock = yf.Ticker(symbol, session=self.session)
             recommendations = stock.recommendations
             return recommendations.to_json(orient="index")
         except Exception as e:
@@ -233,7 +234,7 @@ class YFinanceTools(Toolkit):
         """
         try:
             log_debug(f"Fetching company news for {symbol}")
-            news = yf.Ticker(symbol).news
+            news = yf.Ticker(symbol, session=self.session).news
             return json.dumps(news[:num_stories], indent=2)
         except Exception as e:
             return f"Error fetching company news for {symbol}: {e}"
@@ -251,7 +252,7 @@ class YFinanceTools(Toolkit):
         """
         try:
             log_debug(f"Fetching technical indicators for {symbol}")
-            indicators = yf.Ticker(symbol).history(period=period)
+            indicators = yf.Ticker(symbol, session=self.session).history(period=period)
             return indicators.to_json(orient="index")
         except Exception as e:
             return f"Error fetching technical indicators for {symbol}: {e}"

agno/utils/http.py

@@ -10,6 +10,117 @@ logger = logging.getLogger(__name__)
 DEFAULT_MAX_RETRIES = 3
 DEFAULT_BACKOFF_FACTOR = 2  # Exponential backoff: 1, 2, 4, 8...
 
+# Global httpx clients for resource efficiency
+# These are shared across all models to reuse connection pools and avoid resource leaks.
+# Consumers can override these at application startup using set_default_sync_client()
+# and set_default_async_client() to customize limits, timeouts, proxies, etc.
+_global_sync_client: Optional[httpx.Client] = None
+_global_async_client: Optional[httpx.AsyncClient] = None
+
+
+def get_default_sync_client() -> httpx.Client:
+    """Get or create the global synchronous httpx client.
+
+    Returns:
+        A singleton httpx.Client instance with default limits.
+    """
+    global _global_sync_client
+    if _global_sync_client is None or _global_sync_client.is_closed:
+        _global_sync_client = httpx.Client(
+            limits=httpx.Limits(max_connections=1000, max_keepalive_connections=200), http2=True, follow_redirects=True
+        )
+    return _global_sync_client
+
+
+def get_default_async_client() -> httpx.AsyncClient:
+    """Get or create the global asynchronous httpx client.
+
+    Returns:
+        A singleton httpx.AsyncClient instance with default limits.
+    """
+    global _global_async_client
+    if _global_async_client is None or _global_async_client.is_closed:
+        _global_async_client = httpx.AsyncClient(
+            limits=httpx.Limits(max_connections=1000, max_keepalive_connections=200), http2=True, follow_redirects=True
+        )
+    return _global_async_client
+
+
+def close_sync_client() -> None:
+    """Closes the global sync httpx client.
+
+    Should be called during application shutdown.
+    """
+    global _global_sync_client
+    if _global_sync_client is not None and not _global_sync_client.is_closed:
+        _global_sync_client.close()
+
+
+async def aclose_default_clients() -> None:
+    """Asynchronously close the global httpx clients.
+
+    Should be called during application shutdown in async contexts.
+    """
+    global _global_sync_client, _global_async_client
+    if _global_sync_client is not None and not _global_sync_client.is_closed:
+        _global_sync_client.close()
+    if _global_async_client is not None and not _global_async_client.is_closed:
+        await _global_async_client.aclose()
+
+
+def set_default_sync_client(client: httpx.Client) -> None:
+    """Set the global synchronous httpx client.
+
+    IMPORTANT: Call before creating any model instances. Models cache clients on first use.
+
+    Allows consumers to override the default httpx client with custom configuration
+    (e.g., custom limits, timeouts, proxies, SSL verification, etc.).
+    This is useful at application startup to customize how all models connect.
+
+    Example:
+        >>> import httpx
+        >>> from agno.utils.http import set_default_sync_client
+        >>> custom_client = httpx.Client(
+        ...     limits=httpx.Limits(max_connections=500),
+        ...     timeout=httpx.Timeout(30.0),
+        ...     verify=False  # for dev environments
+        ... )
+        >>> set_default_sync_client(custom_client)
+        >>> # All models will now use this custom client
+
+    Args:
+        client: An httpx.Client instance to use as the global sync client.
+    """
+    global _global_sync_client
+    _global_sync_client = client
+
+
+def set_default_async_client(client: httpx.AsyncClient) -> None:
+    """Set the global asynchronous httpx client.
+
+    IMPORTANT: Call before creating any model instances. Models cache clients on first use.
+
+    Allows consumers to override the default async httpx client with custom configuration
+    (e.g., custom limits, timeouts, proxies, SSL verification, etc.).
+    This is useful at application startup to customize how all models connect.
+
+    Example:
+        >>> import httpx
+        >>> from agno.utils.http import set_default_async_client
+        >>> custom_client = httpx.AsyncClient(
+        ...     limits=httpx.Limits(max_connections=500),
+        ...     timeout=httpx.Timeout(30.0),
+        ...     verify=False  # for dev environments
+        ... )
+        >>> set_default_async_client(custom_client)
+        >>> # All models will now use this custom client
+
+    Args:
+        client: An httpx.AsyncClient instance to use as the global async client.
+    """
+    global _global_async_client
+    _global_async_client = client
+
 
 def fetch_with_retry(
     url: str,

agno/utils/media.py

@@ -56,6 +56,17 @@ def download_image(url: str, output_path: str) -> bool:
         return False
 
 
+def download_audio(url: str, output_path: str) -> str:
+    """Download audio from URL"""
+    response = httpx.get(url)
+    response.raise_for_status()
+
+    with open(output_path, "wb") as f:
+        for chunk in response.iter_bytes(chunk_size=8192):
+            f.write(chunk)
+    return output_path
+
+
 def download_video(url: str, output_path: str) -> str:
     """Download video from URL"""
     response = httpx.get(url)

agno/utils/models/claude.py

@@ -320,6 +320,7 @@ def format_messages(messages: List[Message]) -> Tuple[List[Dict[str, str]], str]
 def format_tools_for_model(tools: Optional[List[Dict[str, Any]]] = None) -> Optional[List[Dict[str, Any]]]:
     """
     Transforms function definitions into a format accepted by the Anthropic API.
+    Now supports strict mode for structured outputs.
     """
     if not tools:
         return None
@@ -352,7 +353,14 @@ def format_tools_for_model(tools: Optional[List[Dict[str, Any]]] = None) -> Opti
                 "type": parameters.get("type", "object"),
                 "properties": input_properties,
                 "required": required_params,
+                "additionalProperties": False,
             },
         }
+
+        # Add strict mode if specified (check both function dict and tool_def top level)
+        strict_mode = func_def.get("strict") or tool_def.get("strict")
+        if strict_mode is True:
+            tool["strict"] = True
+
         parsed_tools.append(tool)
     return parsed_tools

agno/utils/print_response/agent.py

@@ -1,4 +1,5 @@
 import json
+import warnings
 from collections.abc import Set
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Sequence, Union, cast, get_args
 
@@ -34,8 +35,6 @@ def print_response_stream(
     images: Optional[Sequence[Image]] = None,
     videos: Optional[Sequence[Video]] = None,
     files: Optional[Sequence[File]] = None,
-    stream_events: bool = False,
-    stream_intermediate_steps: bool = False,
     knowledge_filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None,
     debug_mode: Optional[bool] = None,
     markdown: bool = False,
@@ -82,9 +81,6 @@ def print_response_stream(
 
         input_content = get_text_from_message(input)
 
-        # Consider both stream_events and stream_intermediate_steps (deprecated)
-        stream_events = stream_events or stream_intermediate_steps
-
         for response_event in agent.run(
             input=input,
             session_id=session_id,
@@ -95,7 +91,6 @@ def print_response_stream(
             videos=videos,
             files=files,
             stream=True,
-            stream_events=stream_events,
             knowledge_filters=knowledge_filters,
             debug_mode=debug_mode,
             add_history_to_context=add_history_to_context,
@@ -226,8 +221,6 @@ async def aprint_response_stream(
     images: Optional[Sequence[Image]] = None,
     videos: Optional[Sequence[Video]] = None,
     files: Optional[Sequence[File]] = None,
-    stream_events: bool = False,
-    stream_intermediate_steps: bool = False,
     knowledge_filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None,
     debug_mode: Optional[bool] = None,
     markdown: bool = False,
@@ -272,9 +265,6 @@ async def aprint_response_stream(
         if render:
             live_log.update(Group(*panels))
 
-        # Considering both stream_events and stream_intermediate_steps (deprecated)
-        stream_events = stream_events or stream_intermediate_steps
-
         result = agent.arun(
             input=input,
             session_id=session_id,
@@ -285,7 +275,6 @@ async def aprint_response_stream(
             videos=videos,
             files=files,
             stream=True,
-            stream_events=stream_events,
             knowledge_filters=knowledge_filters,
             debug_mode=debug_mode,
             add_history_to_context=add_history_to_context,
@@ -507,6 +496,8 @@ def print_response(
     videos: Optional[Sequence[Video]] = None,
     files: Optional[Sequence[File]] = None,
     knowledge_filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None,
+    stream_events: Optional[bool] = None,
+    stream_intermediate_steps: Optional[bool] = None,
     debug_mode: Optional[bool] = None,
     markdown: bool = False,
     show_message: bool = True,
@@ -521,6 +512,19 @@ def print_response(
     metadata: Optional[Dict[str, Any]] = None,
     **kwargs: Any,
 ):
+    if stream_events is not None:
+        warnings.warn(
+            "The 'stream_events' parameter is deprecated and will be removed in future versions. Event streaming is always enabled using the print_response function.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+    if stream_intermediate_steps is not None:
+        warnings.warn(
+            "The 'stream_intermediate_steps' parameter is deprecated and will be removed in future versions. Event streaming is always enabled using the print_response function.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
     with Live(console=console) as live_log:
         status = Status("Thinking...", spinner="aesthetic", speed=0.4, refresh_per_second=10)
         live_log.update(status)
@@ -551,6 +555,7 @@ def print_response(
             videos=videos,
             files=files,
             stream=False,
+            stream_events=True,
             knowledge_filters=knowledge_filters,
             debug_mode=debug_mode,
             add_history_to_context=add_history_to_context,
@@ -628,6 +633,8 @@ async def aprint_response(
     show_message: bool = True,
     show_reasoning: bool = True,
     show_full_reasoning: bool = False,
+    stream_events: Optional[bool] = None,
+    stream_intermediate_steps: Optional[bool] = None,
     tags_to_include_in_markdown: Set[str] = {"think", "thinking"},
     console: Optional[Any] = None,
     add_history_to_context: Optional[bool] = None,
@@ -637,6 +644,19 @@ async def aprint_response(
     metadata: Optional[Dict[str, Any]] = None,
     **kwargs: Any,
 ):
+    if stream_events is not None:
+        warnings.warn(
+            "The 'stream_events' parameter is deprecated and will be removed in future versions. Event streaming is always enabled using the aprint_response function.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+    if stream_intermediate_steps is not None:
+        warnings.warn(
+            "The 'stream_intermediate_steps' parameter is deprecated and will be removed in future versions. Event streaming is always enabled using the aprint_response function.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
     with Live(console=console) as live_log:
         status = Status("Thinking...", spinner="aesthetic", speed=0.4, refresh_per_second=10)
         live_log.update(status)
@@ -667,6 +687,7 @@ async def aprint_response(
             videos=videos,
             files=files,
             stream=False,
+            stream_events=True,
             knowledge_filters=knowledge_filters,
             debug_mode=debug_mode,
             add_history_to_context=add_history_to_context,