agno 2.0.7__py3-none-any.whl → 2.0.9__py3-none-any.whl

agno/tools/scrapegraph.py

@@ -3,6 +3,7 @@ from os import getenv
 from typing import Any, List, Optional
 
 from agno.tools import Toolkit
+from agno.utils.log import log_debug, log_error
 
 try:
     from scrapegraph_py import Client
@@ -23,11 +24,14 @@ class ScrapeGraphTools(Toolkit):
         enable_crawl: bool = False,
         enable_searchscraper: bool = False,
         enable_agentic_crawler: bool = False,
+        enable_scrape: bool = False,
+        render_heavy_js: bool = False,
         all: bool = False,
         **kwargs,
     ):
         self.api_key: Optional[str] = api_key or getenv("SGAI_API_KEY")
         self.client = Client(api_key=self.api_key)
+        self.render_heavy_js = render_heavy_js
 
         # Start with smartscraper by default
         # Only enable markdownify if smartscraper is False
@@ -45,6 +49,8 @@ class ScrapeGraphTools(Toolkit):
             tools.append(self.searchscraper)
         if enable_agentic_crawler or all:
             tools.append(self.agentic_crawler)
+        if enable_scrape or all:
+            tools.append(self.scrape)
 
         super().__init__(name="scrapegraph_tools", tools=tools, **kwargs)
 
@@ -57,10 +63,13 @@ class ScrapeGraphTools(Toolkit):
             The structured data extracted from the webpage
         """
         try:
+            log_debug(f"ScrapeGraph smartscraper request for URL: {url}")
             response = self.client.smartscraper(website_url=url, user_prompt=prompt)
             return json.dumps(response["result"])
         except Exception as e:
-            return json.dumps({"error": str(e)})
+            error_msg = f"Smartscraper failed: {str(e)}"
+            log_error(error_msg)
+            return f"Error: {error_msg}"
 
     def markdownify(self, url: str) -> str:
         """Convert a webpage to markdown format.
@@ -70,10 +79,13 @@ class ScrapeGraphTools(Toolkit):
             The markdown version of the webpage
         """
         try:
+            log_debug(f"ScrapeGraph markdownify request for URL: {url}")
             response = self.client.markdownify(website_url=url)
             return response["result"]
         except Exception as e:
-            return f"Error converting to markdown: {str(e)}"
+            error_msg = f"Markdownify failed: {str(e)}"
+            log_error(error_msg)
+            return f"Error: {error_msg}"
 
     def crawl(
         self,
@@ -100,10 +112,11 @@ class ScrapeGraphTools(Toolkit):
             The structured data extracted from the website
         """
         try:
+            log_debug(f"ScrapeGraph crawl request for URL: {url}")
             response = self.client.crawl(
                 url=url,
                 prompt=prompt,
-                schema=schema,
+                data_schema=schema,
                 cache_website=cache_website,
                 depth=depth,
                 max_pages=max_pages,
@@ -112,7 +125,9 @@ class ScrapeGraphTools(Toolkit):
             )
             return json.dumps(response, indent=2)
         except Exception as e:
-            return json.dumps({"error": str(e)})
+            error_msg = f"Crawl failed: {str(e)}"
+            log_error(error_msg)
+            return f"Error: {error_msg}"
 
     def agentic_crawler(
         self,
@@ -143,21 +158,7 @@ class ScrapeGraphTools(Toolkit):
             JSON string containing the scraping results, including request_id, status, and extracted data
         """
         try:
-            # Validate required parameters for AI extraction
-            if ai_extraction and not user_prompt:
-                return json.dumps({"error": "user_prompt is required when ai_extraction=True"})
-
-            # Validate URL format
-            if not url.strip():
-                return json.dumps({"error": "URL cannot be empty"})
-            if not (url.startswith("http://") or url.startswith("https://")):
-                return json.dumps({"error": "Invalid URL - must start with http:// or https://"})
-
-            # Validate steps
-            if not steps:
-                return json.dumps({"error": "Steps cannot be empty"})
-            if any(not step.strip() for step in steps):
-                return json.dumps({"error": "All steps must contain valid instructions"})
+            log_debug(f"ScrapeGraph agentic_crawler request for URL: {url}")
 
             # Prepare parameters for the API call
             params = {"url": url, "steps": steps, "use_session": use_session, "ai_extraction": ai_extraction}
@@ -170,26 +171,52 @@ class ScrapeGraphTools(Toolkit):
 
             # Call the agentic scraper API
             response = self.client.agenticscraper(**params)
-
             return json.dumps(response, indent=2)
 
         except Exception as e:
-            return json.dumps({"error": str(e)})
+            error_msg = f"Agentic crawler failed: {str(e)}"
+            log_error(error_msg)
+            return f"Error: {error_msg}"
 
-    def searchscraper(self, prompt: str) -> str:
+    def searchscraper(self, user_prompt: str) -> str:
         """Search the web and extract information from the web.
         Args:
-            prompt (str): Search query
+            user_prompt (str): Search query
         Returns:
             JSON of the search results
         """
         try:
-            response = self.client.searchscraper(user_prompt=prompt)
-            if hasattr(response, "result"):
-                return json.dumps(response.result)
-            elif isinstance(response, dict) and "result" in response:
-                return json.dumps(response["result"])
-            else:
-                return json.dumps(response)
+            log_debug(f"ScrapeGraph searchscraper request with prompt: {user_prompt}")
+            response = self.client.searchscraper(user_prompt=user_prompt, render_heavy_js=self.render_heavy_js)
+            return json.dumps(response["result"])
+        except Exception as e:
+            error_msg = f"Searchscraper failed: {str(e)}"
+            log_error(error_msg)
+            return f"Error: {error_msg}"
+
+    def scrape(
+        self,
+        website_url: str,
+        headers: Optional[dict] = None,
+    ) -> str:
+        """Get raw HTML content from a website using the ScrapeGraphAI scrape API.
+
+        Args:
+            website_url (str): The URL of the website to scrape
+            headers (Optional[dict]): Optional headers to send with the request
+
+        Returns:
+            JSON string containing the HTML content and metadata
+        """
+        try:
+            log_debug(f"ScrapeGraph scrape request for URL: {website_url}")
+            response = self.client.scrape(
+                website_url=website_url,
+                headers=headers,
+                render_heavy_js=self.render_heavy_js,
+            )
+            return json.dumps(response, indent=2)
         except Exception as e:
-            return json.dumps({"error": str(e)})
+            error_msg = f"Scrape failed: {str(e)}"
+            log_error(error_msg)
+            return f"Error: {error_msg}"

agno/tools/whatsapp.py

@@ -16,7 +16,7 @@ class WhatsAppTools(Toolkit):
         self,
         access_token: Optional[str] = None,
         phone_number_id: Optional[str] = None,
-        version: str = "v22.0",
+        version: Optional[str] = None,
         recipient_waid: Optional[str] = None,
         async_mode: bool = False,
     ):

agno/utils/gemini.py

@@ -1,5 +1,7 @@
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Type, Union
+
+from pydantic import BaseModel
 
 from agno.media import Image
 from agno.utils.log import log_error, log_warning
@@ -9,12 +11,119 @@ try:
         FunctionDeclaration,
         Schema,
         Tool,
-        Type,
+    )
+    from google.genai.types import (
+        Type as GeminiType,
     )
 except ImportError:
     raise ImportError("`google-genai` not installed. Please install it using `pip install google-genai`")
 
 
+def prepare_response_schema(pydantic_model: Type[BaseModel]) -> Union[Type[BaseModel], Schema]:
+    """
+    Prepare a Pydantic model for use as Gemini response schema.
+
+    Returns the model directly if Gemini can handle it natively,
+    otherwise converts to Gemini's Schema format.
+
+    Args:
+        pydantic_model: A Pydantic model class
+
+    Returns:
+        Either the original Pydantic model or a converted Schema object
+    """
+    schema_dict = pydantic_model.model_json_schema()
+
+    # Convert to Gemini Schema if the model has problematic patterns
+    if needs_conversion(schema_dict):
+        try:
+            converted = convert_schema(schema_dict)
+        except Exception as e:
+            log_warning(f"Failed to convert schema for {pydantic_model}: {e}")
+            converted = None
+
+        if converted is None:
+            # If conversion fails, let Gemini handle it directly
+            return pydantic_model
+        return converted
+
+    # Gemini can handle this model directly
+    return pydantic_model
+
+
+def needs_conversion(schema_dict: Dict[str, Any]) -> bool:
+    """
+    Check if a schema needs conversion for Gemini.
+
+    Returns True if the schema has:
+    - Self-references or circular references
+    - Dict fields (additionalProperties) that Gemini doesn't handle well
+    - Empty object definitions that Gemini rejects
+    """
+    # Check for dict fields (additionalProperties) anywhere in the schema
+    if has_additional_properties(schema_dict):
+        return True
+
+    # Check if schema has $defs with circular references
+    if "$defs" in schema_dict:
+        defs = schema_dict["$defs"]
+        for def_name, def_schema in defs.items():
+            ref_path = f"#/$defs/{def_name}"
+            if has_self_reference(def_schema, ref_path):
+                return True
+
+    return False
+
+
+def has_additional_properties(schema: Any) -> bool:
+    """Check if schema has additionalProperties (Dict fields)"""
+    if isinstance(schema, dict):
+        # Direct check
+        if "additionalProperties" in schema:
+            return True
+
+        # Check properties recursively
+        if "properties" in schema:
+            for prop_schema in schema["properties"].values():
+                if has_additional_properties(prop_schema):
+                    return True
+
+        # Check array items
+        if "items" in schema:
+            if has_additional_properties(schema["items"]):
+                return True
+
+    return False
+
+
+def has_self_reference(schema: Dict, target_ref: str) -> bool:
+    """Check if a schema references itself (directly or indirectly)"""
+    if isinstance(schema, dict):
+        # Direct self-reference
+        if schema.get("$ref") == target_ref:
+            return True
+
+        # Check properties
+        if "properties" in schema:
+            for prop_schema in schema["properties"].values():
+                if has_self_reference(prop_schema, target_ref):
+                    return True
+
+        # Check array items
+        if "items" in schema:
+            if has_self_reference(schema["items"], target_ref):
+                return True
+
+        # Check anyOf/oneOf/allOf
+        for key in ["anyOf", "oneOf", "allOf"]:
+            if key in schema:
+                for sub_schema in schema[key]:
+                    if has_self_reference(sub_schema, target_ref):
+                        return True
+
+    return False
+
+
 def format_image_for_message(image: Image) -> Optional[Dict[str, Any]]:
     # Case 1: Image is a URL
     # Download the image from the URL and add it as base64 encoded data
@@ -66,7 +175,9 @@ def format_image_for_message(image: Image) -> Optional[Dict[str, Any]]:
         return None
 
 
-def convert_schema(schema_dict: Dict[str, Any], root_schema: Optional[Dict[str, Any]] = None) -> Optional[Schema]:
+def convert_schema(
+    schema_dict: Dict[str, Any], root_schema: Optional[Dict[str, Any]] = None, visited_refs: Optional[set] = None
+) -> Optional[Schema]:
     """
     Recursively convert a JSON-like schema dictionary to a types.Schema object.
 
@@ -74,23 +185,39 @@ def convert_schema(schema_dict: Dict[str, Any], root_schema: Optional[Dict[str,
         schema_dict (dict): The JSON schema dictionary with keys like "type", "description",
                             "properties", and "required".
         root_schema (dict, optional): The root schema containing $defs for resolving $ref
+        visited_refs (set, optional): Set of visited $ref paths to detect circular references
 
     Returns:
         types.Schema: The converted schema.
     """
 
-    # If this is the initial call, set root_schema to self
+    # If this is the initial call, set root_schema to self and initialize visited_refs
     if root_schema is None:
         root_schema = schema_dict
+    if visited_refs is None:
+        visited_refs = set()
 
-    # Handle $ref references
+    # Handle $ref references with cycle detection
     if "$ref" in schema_dict:
         ref_path = schema_dict["$ref"]
+
+        # Check for circular reference
+        if ref_path in visited_refs:
+            # Return a basic object schema to break the cycle
+            return Schema(
+                type=GeminiType.OBJECT,
+                description=f"Circular reference to {ref_path}",
+            )
+
         if ref_path.startswith("#/$defs/"):
             def_name = ref_path.split("/")[-1]
             if "$defs" in root_schema and def_name in root_schema["$defs"]:
+                # Add to visited set before recursing
+                new_visited = visited_refs.copy()
+                new_visited.add(ref_path)
+
                 referenced_schema = root_schema["$defs"][def_name]
-                return convert_schema(referenced_schema, root_schema)
+                return convert_schema(referenced_schema, root_schema, new_visited)
         # If we can't resolve the reference, return None
         return None
 
@@ -103,7 +230,7 @@ def convert_schema(schema_dict: Dict[str, Any], root_schema: Optional[Dict[str,
     # Handle enum types
     if "enum" in schema_dict:
         enum_values = schema_dict["enum"]
-        return Schema(type=Type.STRING, enum=enum_values, description=description, default=default)
+        return Schema(type=GeminiType.STRING, enum=enum_values, description=description, default=default)
 
     if schema_type == "object":
         # Handle regular objects with properties
@@ -117,8 +244,8 @@ def convert_schema(schema_dict: Dict[str, Any], root_schema: Optional[Dict[str,
                     prop_def["type"] = prop_type[0]
                     is_nullable = True
 
-                # Process property schema (pass root_schema for $ref resolution)
-                converted_schema = convert_schema(prop_def, root_schema)
+                # Process property schema (pass root_schema and visited_refs for $ref resolution)
+                converted_schema = convert_schema(prop_def, root_schema, visited_refs)
                 if converted_schema is not None:
                     if is_nullable:
                         converted_schema.nullable = True
@@ -128,14 +255,14 @@ def convert_schema(schema_dict: Dict[str, Any], root_schema: Optional[Dict[str,
 
             if properties:
                 return Schema(
-                    type=Type.OBJECT,
+                    type=GeminiType.OBJECT,
                     properties=properties,
                     required=required,
                     description=description,
                     default=default,
                 )
             else:
-                return Schema(type=Type.OBJECT, description=description, default=default)
+                return Schema(type=GeminiType.OBJECT, description=description, default=default)
 
         # Handle Dict types (objects with additionalProperties but no properties)
         elif "additionalProperties" in schema_dict:
@@ -170,7 +297,7 @@ def convert_schema(schema_dict: Dict[str, Any], root_schema: Optional[Dict[str,
                     placeholder_properties["example_key"].items = {}  # type: ignore
 
                 return Schema(
-                    type=Type.OBJECT,
+                    type=GeminiType.OBJECT,
                     properties=placeholder_properties,
                     description=description
                     or f"Dictionary with {value_type.lower()} values{type_description_suffix}. Can contain any number of key-value pairs.",
@@ -178,21 +305,22 @@ def convert_schema(schema_dict: Dict[str, Any], root_schema: Optional[Dict[str,
                 )
             else:
                 # additionalProperties is false or true
-                return Schema(type=Type.OBJECT, description=description, default=default)
+                return Schema(type=GeminiType.OBJECT, description=description, default=default)
 
         # Handle empty objects
         else:
-            return Schema(type=Type.OBJECT, description=description, default=default)
+            return Schema(type=GeminiType.OBJECT, description=description, default=default)
 
     elif schema_type == "array" and "items" in schema_dict:
         if not schema_dict["items"]:  # Handle empty {}
-            items = Schema(type=Type.STRING)
+            items = Schema(type=GeminiType.STRING)
         else:
-            items = convert_schema(schema_dict["items"], root_schema)
+            converted_items = convert_schema(schema_dict["items"], root_schema, visited_refs)
+            items = converted_items if converted_items is not None else Schema(type=GeminiType.STRING)
         min_items = schema_dict.get("minItems")
         max_items = schema_dict.get("maxItems")
         return Schema(
-            type=Type.ARRAY,
+            type=GeminiType.ARRAY,
             description=description,
             items=items,
             min_items=min_items,
@@ -201,7 +329,7 @@ def convert_schema(schema_dict: Dict[str, Any], root_schema: Optional[Dict[str,
 
     elif schema_type == "string":
         schema_kwargs = {
-            "type": Type.STRING,
+            "type": GeminiType.STRING,
             "description": description,
             "default": default,
         }
@@ -224,7 +352,7 @@ def convert_schema(schema_dict: Dict[str, Any], root_schema: Optional[Dict[str,
     elif schema_type == "" and "anyOf" in schema_dict:
         any_of = []
         for sub_schema in schema_dict["anyOf"]:
-            sub_schema_converted = convert_schema(sub_schema, root_schema)
+            sub_schema_converted = convert_schema(sub_schema, root_schema, visited_refs)
             any_of.append(sub_schema_converted)
 
         is_nullable = False

agno/utils/models/claude.py

@@ -279,6 +279,15 @@ def format_messages(messages: List[Message]) -> Tuple[List[Dict[str, str]], str]
                             type="tool_use",
                         )
                     )
+        elif message.role == "tool":
+            content = []
+            content.append(
+                {
+                    "type": "tool_result",
+                    "tool_use_id": message.tool_call_id,
+                    "content": str(message.content),
+                }
+            )
 
         # Skip empty assistant responses
         if message.role == "assistant" and not content:

agno/utils/print_response/agent.py

@@ -44,6 +44,8 @@ def print_response_stream(
     console: Optional[Any] = None,
     add_history_to_context: Optional[bool] = None,
     dependencies: Optional[Dict[str, Any]] = None,
+    add_dependencies_to_context: Optional[bool] = None,
+    add_session_state_to_context: Optional[bool] = None,
     metadata: Optional[Dict[str, Any]] = None,
     **kwargs: Any,
 ):
@@ -90,6 +92,8 @@ def print_response_stream(
             knowledge_filters=knowledge_filters,
             debug_mode=debug_mode,
             add_history_to_context=add_history_to_context,
+            add_dependencies_to_context=add_dependencies_to_context,
+            add_session_state_to_context=add_session_state_to_context,
             dependencies=dependencies,
             metadata=metadata,
             **kwargs,
@@ -223,6 +227,8 @@ async def aprint_response_stream(
     console: Optional[Any] = None,
     add_history_to_context: Optional[bool] = None,
     dependencies: Optional[Dict[str, Any]] = None,
+    add_dependencies_to_context: Optional[bool] = None,
+    add_session_state_to_context: Optional[bool] = None,
     metadata: Optional[Dict[str, Any]] = None,
     **kwargs: Any,
 ):
@@ -269,6 +275,8 @@ async def aprint_response_stream(
             knowledge_filters=knowledge_filters,
             debug_mode=debug_mode,
             add_history_to_context=add_history_to_context,
+            add_dependencies_to_context=add_dependencies_to_context,
+            add_session_state_to_context=add_session_state_to_context,
             dependencies=dependencies,
             metadata=metadata,
             **kwargs,
@@ -415,7 +423,7 @@ def build_panels_stream(
             reasoning_panel = create_panel(content=step_content, title=f"Reasoning step {i}", border_style="green")
             panels.append(reasoning_panel)
 
-    if len(response_reasoning_content_buffer) > 0:
+    if len(response_reasoning_content_buffer) > 0 and show_reasoning:
         # Create panel for thinking
         thinking_panel = create_panel(
             content=Text(response_reasoning_content_buffer),
@@ -490,6 +498,8 @@ def print_response(
     console: Optional[Any] = None,
     add_history_to_context: Optional[bool] = None,
     dependencies: Optional[Dict[str, Any]] = None,
+    add_dependencies_to_context: Optional[bool] = None,
+    add_session_state_to_context: Optional[bool] = None,
     metadata: Optional[Dict[str, Any]] = None,
     **kwargs: Any,
 ):
@@ -527,6 +537,8 @@ def print_response(
             knowledge_filters=knowledge_filters,
             debug_mode=debug_mode,
             add_history_to_context=add_history_to_context,
+            add_dependencies_to_context=add_dependencies_to_context,
+            add_session_state_to_context=add_session_state_to_context,
             dependencies=dependencies,
             metadata=metadata,
             **kwargs,
@@ -590,6 +602,8 @@ async def aprint_response(
     console: Optional[Any] = None,
     add_history_to_context: Optional[bool] = None,
     dependencies: Optional[Dict[str, Any]] = None,
+    add_dependencies_to_context: Optional[bool] = None,
+    add_session_state_to_context: Optional[bool] = None,
     metadata: Optional[Dict[str, Any]] = None,
     **kwargs: Any,
 ):
@@ -627,6 +641,8 @@ async def aprint_response(
             knowledge_filters=knowledge_filters,
             debug_mode=debug_mode,
             add_history_to_context=add_history_to_context,
+            add_dependencies_to_context=add_dependencies_to_context,
+            add_session_state_to_context=add_session_state_to_context,
             dependencies=dependencies,
             metadata=metadata,
             **kwargs,
@@ -711,7 +727,7 @@ def build_panels(
             reasoning_panel = create_panel(content=step_content, title=f"Reasoning step {i}", border_style="green")
             panels.append(reasoning_panel)
 
-    if isinstance(run_response, RunOutput) and run_response.reasoning_content is not None:
+    if isinstance(run_response, RunOutput) and run_response.reasoning_content is not None and show_reasoning:
         # Create panel for thinking
         thinking_panel = create_panel(
             content=Text(run_response.reasoning_content),

agno/utils/print_response/team.py

@@ -36,6 +36,8 @@ def print_response(
     knowledge_filters: Optional[Dict[str, Any]] = None,
     add_history_to_context: Optional[bool] = None,
     dependencies: Optional[Dict[str, Any]] = None,
+    add_dependencies_to_context: Optional[bool] = None,
+    add_session_state_to_context: Optional[bool] = None,
     metadata: Optional[Dict[str, Any]] = None,
     debug_mode: Optional[bool] = None,
     **kwargs: Any,
@@ -88,6 +90,8 @@ def print_response(
             knowledge_filters=knowledge_filters,
             add_history_to_context=add_history_to_context,
             dependencies=dependencies,
+            add_dependencies_to_context=add_dependencies_to_context,
+            add_session_state_to_context=add_session_state_to_context,
             metadata=metadata,
             debug_mode=debug_mode,
             **kwargs,
@@ -121,7 +125,7 @@ def print_response(
                 panels.append(reasoning_panel)
             live_console.update(Group(*panels))
 
-        if isinstance(run_response, TeamRunOutput) and run_response.reasoning_content is not None:
+        if isinstance(run_response, TeamRunOutput) and run_response.reasoning_content is not None and show_reasoning:
             # Create panel for thinking
             thinking_panel = create_panel(
                 content=Text(run_response.reasoning_content),
@@ -317,6 +321,8 @@ def print_response_stream(
     knowledge_filters: Optional[Dict[str, Any]] = None,
     add_history_to_context: Optional[bool] = None,
     dependencies: Optional[Dict[str, Any]] = None,
+    add_dependencies_to_context: Optional[bool] = None,
+    add_session_state_to_context: Optional[bool] = None,
     metadata: Optional[Dict[str, Any]] = None,
     debug_mode: Optional[bool] = None,
     **kwargs: Any,
@@ -386,6 +392,8 @@ def print_response_stream(
             knowledge_filters=knowledge_filters,
             add_history_to_context=add_history_to_context,
             dependencies=dependencies,
+            add_dependencies_to_context=add_dependencies_to_context,
+            add_session_state_to_context=add_session_state_to_context,
             metadata=metadata,
             debug_mode=debug_mode,
             yield_run_response=True,
@@ -489,7 +497,7 @@ def print_response_stream(
                     reasoning_panel = build_reasoning_step_panel(i, step, show_full_reasoning)
                     panels.append(reasoning_panel)
 
-            if len(_response_reasoning_content) > 0:
+            if len(_response_reasoning_content) > 0 and show_reasoning:
                 render = True
                 # Create panel for thinking
                 thinking_panel = create_panel(
@@ -671,7 +679,7 @@ def print_response_stream(
                 final_panels.append(reasoning_panel)
 
         # Add thinking panel if available
-        if _response_reasoning_content:
+        if _response_reasoning_content and show_reasoning:
             thinking_panel = create_panel(
                 content=Text(_response_reasoning_content),
                 title=f"Thinking ({response_timer.elapsed:.1f}s)",
@@ -841,6 +849,8 @@ async def aprint_response(
     knowledge_filters: Optional[Dict[str, Any]] = None,
     add_history_to_context: Optional[bool] = None,
     dependencies: Optional[Dict[str, Any]] = None,
+    add_dependencies_to_context: Optional[bool] = None,
+    add_session_state_to_context: Optional[bool] = None,
     metadata: Optional[Dict[str, Any]] = None,
     debug_mode: Optional[bool] = None,
     **kwargs: Any,
@@ -893,6 +903,8 @@ async def aprint_response(
             knowledge_filters=knowledge_filters,
             add_history_to_context=add_history_to_context,
             dependencies=dependencies,
+            add_dependencies_to_context=add_dependencies_to_context,
+            add_session_state_to_context=add_session_state_to_context,
             metadata=metadata,
             debug_mode=debug_mode,
             **kwargs,
@@ -926,7 +938,7 @@ async def aprint_response(
                 panels.append(reasoning_panel)
             live_console.update(Group(*panels))
 
-        if isinstance(run_response, TeamRunOutput) and run_response.reasoning_content is not None:
+        if isinstance(run_response, TeamRunOutput) and run_response.reasoning_content is not None and show_reasoning:
             # Create panel for thinking
             thinking_panel = create_panel(
                 content=Text(run_response.reasoning_content),
@@ -1120,6 +1132,8 @@ async def aprint_response_stream(
     knowledge_filters: Optional[Dict[str, Any]] = None,
     add_history_to_context: Optional[bool] = None,
     dependencies: Optional[Dict[str, Any]] = None,
+    add_dependencies_to_context: Optional[bool] = None,
+    add_session_state_to_context: Optional[bool] = None,
     metadata: Optional[Dict[str, Any]] = None,
     debug_mode: Optional[bool] = None,
     **kwargs: Any,
@@ -1196,6 +1210,8 @@ async def aprint_response_stream(
             user_id=user_id,
             knowledge_filters=knowledge_filters,
             add_history_to_context=add_history_to_context,
+            add_dependencies_to_context=add_dependencies_to_context,
+            add_session_state_to_context=add_session_state_to_context,
             dependencies=dependencies,
             metadata=metadata,
             debug_mode=debug_mode,
@@ -1290,7 +1306,7 @@ async def aprint_response_stream(
                     reasoning_panel = build_reasoning_step_panel(i, step, show_full_reasoning)
                     panels.append(reasoning_panel)
 
-            if len(_response_reasoning_content) > 0:
+            if len(_response_reasoning_content) > 0 and show_reasoning:
                 render = True
                 # Create panel for thinking
                 thinking_panel = create_panel(
@@ -1473,7 +1489,7 @@ async def aprint_response_stream(
                 final_panels.append(reasoning_panel)
 
         # Add thinking panel if available
-        if _response_reasoning_content:
+        if _response_reasoning_content and show_reasoning:
             thinking_panel = create_panel(
                 content=Text(_response_reasoning_content),
                 title=f"Thinking ({response_timer.elapsed:.1f}s)",