agno 1.7.10__py3-none-any.whl → 1.7.12__py3-none-any.whl

agno/models/google/gemini.py

@@ -32,6 +32,7 @@ try:
         Part,
         ThinkingConfig,
         Tool,
+        UrlContext,
     )
     from google.genai.types import (
         File as GeminiFile,
@@ -68,6 +69,7 @@ class Gemini(Model):
     search: bool = False
     grounding: bool = False
     grounding_dynamic_threshold: Optional[float] = None
+    url_context: bool = False
 
     temperature: Optional[float] = None
     top_p: Optional[float] = None
@@ -115,7 +117,6 @@ class Gemini(Model):
         """
         if self.client:
             return self.client
-
         client_params: Dict[str, Any] = {}
         vertexai = self.vertexai or getenv("GOOGLE_GENAI_USE_VERTEXAI", "false").lower() == "true"
 
@@ -199,26 +200,34 @@ class Gemini(Model):
         if thinking_config_params:
             config["thinking_config"] = ThinkingConfig(**thinking_config_params)
 
-        if self.grounding and self.search:
-            log_info("Both grounding and search are enabled. Grounding will take precedence.")
-            self.search = False
+        # Build tools array based on enabled built-in tools
+        builtin_tools = []
 
         if self.grounding:
-            log_info("Grounding enabled. External tools will be disabled.")
-            config["tools"] = [
+            log_info("Grounding enabled. This is a legacy tool. For Gemini 2.0+ Please use enable `search` flag instead.")
+            builtin_tools.append(
                 Tool(
                     google_search=GoogleSearchRetrieval(
                         dynamic_retrieval_config=DynamicRetrievalConfig(
                             dynamic_threshold=self.grounding_dynamic_threshold
                         )
                     )
-                ),
-            ]
+                )
+            )
 
-        elif self.search:
-            log_info("Search enabled. External tools will be disabled.")
-            config["tools"] = [Tool(google_search=GoogleSearch())]
+        if self.search:
+            log_info("Google Search enabled.")
+            builtin_tools.append(Tool(google_search=GoogleSearch()))
 
+        if self.url_context:
+            log_info("URL context enabled.")
+            builtin_tools.append(Tool(url_context=UrlContext()))
+
+        # Set tools in config
+        if builtin_tools:
+            if tools:
+                log_info("Built-in tools enabled. External tools will be disabled.")
+            config["tools"] = builtin_tools
         elif tools:
             config["tools"] = [format_function_definitions(tools)]
 
@@ -388,7 +397,10 @@ class Gemini(Model):
             message_parts: List[Any] = []
 
             # Function calls
-            if (not content or role == "model") and message.tool_calls is not None and len(message.tool_calls) > 0:
+            if role == "model" and message.tool_calls is not None and len(message.tool_calls) > 0:
+                if content is not None:
+                    content_str = content if isinstance(content, str) else str(content)
+                    message_parts.append(Part.from_text(text=content_str))
                 for tool_call in message.tool_calls:
                     message_parts.append(
                         Part.from_function_call(
@@ -396,7 +408,7 @@ class Gemini(Model):
                             args=json.loads(tool_call["function"]["arguments"]),
                         )
                     )
-            # Function results
+            # Function call results
             elif message.tool_calls is not None and len(message.tool_calls) > 0:
                 for tool_call in message.tool_calls:
                     message_parts.append(
@@ -758,13 +770,15 @@ class Gemini(Model):
 
                     model_response.tool_calls.append(tool_call)
 
+            citations = Citations()
+            citations_raw = {}
+            citations_urls = []
+
             if response.candidates and response.candidates[0].grounding_metadata is not None:
-                citations = Citations()
                 grounding_metadata = response.candidates[0].grounding_metadata.model_dump()
-                citations.raw = grounding_metadata
+                citations_raw["grounding_metadata"] = grounding_metadata
 
-                # Extract url and title
-                chunks = grounding_metadata.pop("grounding_chunks", None) or []
+                chunks = grounding_metadata.get("grounding_chunks", [])
                 citation_pairs = [
                     (chunk.get("web", {}).get("uri"), chunk.get("web", {}).get("title"))
                     for chunk in chunks
@@ -772,8 +786,31 @@ class Gemini(Model):
                 ]
 
                 # Create citation objects from filtered pairs
-                citations.urls = [UrlCitation(url=url, title=title) for url, title in citation_pairs]
-
+                grounding_urls = [UrlCitation(url=url, title=title) for url, title in citation_pairs]
+                citations_urls.extend(grounding_urls)
+
+            # Handle URLs from URL context tool
+            if (
+                response.candidates
+                and hasattr(response.candidates[0], "url_context_metadata")
+                and response.candidates[0].url_context_metadata is not None
+            ):
+                url_context_metadata = response.candidates[0].url_context_metadata.model_dump()
+                citations_raw["url_context_metadata"] = url_context_metadata
+
+                url_metadata_list = url_context_metadata.get("url_metadata", [])
+                for url_meta in url_metadata_list:
+                    retrieved_url = url_meta.get("retrieved_url")
+                    status = url_meta.get("url_retrieval_status", "UNKNOWN")
+                    if retrieved_url and status == "URL_RETRIEVAL_STATUS_SUCCESS":
+                        # Avoid duplicate URLs
+                        existing_urls = [citation.url for citation in citations_urls]
+                        if retrieved_url not in existing_urls:
+                            citations_urls.append(UrlCitation(url=retrieved_url, title=retrieved_url))
+
+            if citations_raw or citations_urls:
+                citations.raw = citations_raw if citations_raw else None
+                citations.urls = citations_urls if citations_urls else None
                 model_response.citations = citations
 
         # Extract usage metadata if present

agno/models/openai/chat.py

@@ -1,7 +1,7 @@
 from collections.abc import AsyncIterator
 from dataclasses import dataclass
 from os import getenv
-from typing import Any, Dict, Iterator, List, Optional, Type, Union
+from typing import Any, Dict, Iterator, List, Literal, Optional, Type, Union
 
 import httpx
 from pydantic import BaseModel
@@ -45,6 +45,7 @@ class OpenAIChat(Model):
     # Request parameters
     store: Optional[bool] = None
     reasoning_effort: Optional[str] = None
+    verbosity: Optional[Literal["low", "medium", "high"]] = None
     metadata: Optional[Dict[str, Any]] = None
     frequency_penalty: Optional[float] = None
     logit_bias: Optional[Any] = None
@@ -159,6 +160,7 @@ class OpenAIChat(Model):
         base_params = {
             "store": self.store,
             "reasoning_effort": self.reasoning_effort,
+            "verbosity": self.verbosity,
             "frequency_penalty": self.frequency_penalty,
             "logit_bias": self.logit_bias,
             "logprobs": self.logprobs,
@@ -227,6 +229,8 @@ class OpenAIChat(Model):
         model_dict.update(
             {
                 "store": self.store,
+                "reasoning_effort": self.reasoning_effort,
+                "verbosity": self.verbosity,
                 "frequency_penalty": self.frequency_penalty,
                 "logit_bias": self.logit_bias,
                 "logprobs": self.logprobs,
@@ -694,6 +698,9 @@ class OpenAIChat(Model):
                 if choice_delta.tool_calls is not None:
                     model_response.tool_calls = choice_delta.tool_calls  # type: ignore
 
+                if hasattr(choice_delta, "reasoning_content") and choice_delta.reasoning_content is not None:
+                    model_response.reasoning_content = choice_delta.reasoning_content
+
                 # Add audio if present
                 if hasattr(choice_delta, "audio") and choice_delta.audio is not None:
                     try:

agno/models/openai/responses.py

@@ -42,6 +42,8 @@ class OpenAIResponses(Model):
     metadata: Optional[Dict[str, Any]] = None
     parallel_tool_calls: Optional[bool] = None
     reasoning: Optional[Dict[str, Any]] = None
+    verbosity: Optional[Literal["low", "medium", "high"]] = None
+    reasoning_effort: Optional[Literal["minimal", "medium", "high"]] = None
     store: Optional[bool] = None
     temperature: Optional[float] = None
     top_p: Optional[float] = None
@@ -176,7 +178,6 @@ class OpenAIResponses(Model):
             "max_tool_calls": self.max_tool_calls,
             "metadata": self.metadata,
             "parallel_tool_calls": self.parallel_tool_calls,
-            "reasoning": self.reasoning,
             "store": self.store,
             "temperature": self.temperature,
             "top_p": self.top_p,
@@ -184,21 +185,37 @@ class OpenAIResponses(Model):
             "user": self.user,
             "service_tier": self.service_tier,
         }
+
+        # Handle reasoning parameter - convert reasoning_effort to reasoning format
+        if self.reasoning is not None:
+            base_params["reasoning"] = self.reasoning
+        elif self.reasoning_effort is not None:
+            base_params["reasoning"] = {"effort": self.reasoning_effort}
+
+        # Build text parameter
+        text_params: Dict[str, Any] = {}
+
+        # Add verbosity if specified
+        if self.verbosity is not None:
+            text_params["verbosity"] = self.verbosity
+
         # Set the response format
         if response_format is not None:
             if isinstance(response_format, type) and issubclass(response_format, BaseModel):
                 schema = get_response_schema_for_provider(response_format, "openai")
-                base_params["text"] = {
-                    "format": {
-                        "type": "json_schema",
-                        "name": response_format.__name__,
-                        "schema": schema,
-                        "strict": True,
-                    }
+                text_params["format"] = {
+                    "type": "json_schema",
+                    "name": response_format.__name__,
+                    "schema": schema,
+                    "strict": True,
                 }
             else:
                 # JSON mode
-                base_params["text"] = {"format": {"type": "json_object"}}
+                text_params["format"] = {"type": "json_object"}
+
+        # Add text parameter if there are any text-level params
+        if text_params:
+            base_params["text"] = text_params
 
         # Filter out None values
         request_params: Dict[str, Any] = {k: v for k, v in base_params.items() if v is not None}
@@ -372,6 +389,17 @@ class OpenAIResponses(Model):
                     previous_response_id = msg.provider_data["response_id"]
                     break
 
+        # Build a mapping from function_call id (fc_*) → call_id (call_*) from prior assistant tool_calls
+        fc_id_to_call_id: Dict[str, str] = {}
+        for msg in messages:
+            tool_calls = getattr(msg, "tool_calls", None)
+            if tool_calls:
+                for tc in tool_calls:
+                    fc_id = tc.get("id")
+                    call_id = tc.get("call_id") or fc_id
+                    if isinstance(fc_id, str) and isinstance(call_id, str):
+                        fc_id_to_call_id[fc_id] = call_id
+
         for message in messages:
             if message.role in ["user", "system"]:
                 message_dict: Dict[str, Any] = {
@@ -398,27 +426,32 @@ class OpenAIResponses(Model):
 
                 formatted_messages.append(message_dict)
 
+            # Tool call result
             elif message.role == "tool":
                 if message.tool_call_id and message.content is not None:
+                    function_call_id = message.tool_call_id
+                    # Normalize: if a fc_* id was provided, translate to its corresponding call_* id
+                    if isinstance(function_call_id, str) and function_call_id in fc_id_to_call_id:
+                        call_id_value = fc_id_to_call_id[function_call_id]
+                    else:
+                        call_id_value = function_call_id
                     formatted_messages.append(
-                        {"type": "function_call_output", "call_id": message.tool_call_id, "output": message.content}
+                        {"type": "function_call_output", "call_id": call_id_value, "output": message.content}
                     )
+            # Tool Calls
             elif message.tool_calls is not None and len(message.tool_calls) > 0:
-                if self._using_reasoning_model():
-                    # Only include prior function_call items when we are NOT using
-                    # previous_response_id. When previous_response_id is present, the
-                    # Responses API already knows about earlier output items (including
-                    # reasoning/function_call), and re-sending them can trigger validation
-                    # errors (e.g., missing required reasoning item).
-                    if previous_response_id is not None:
-                        continue
+                # Only skip re-sending prior function_call items when we have a previous_response_id
+                # (reasoning models). For non-reasoning models, we must include the prior function_call
+                # so the API can associate the subsequent function_call_output by call_id.
+                if self._using_reasoning_model() and previous_response_id is not None:
+                    continue
 
                 for tool_call in message.tool_calls:
                     formatted_messages.append(
                         {
                             "type": "function_call",
-                            "id": tool_call["id"],
-                            "call_id": tool_call["call_id"],
+                            "id": tool_call.get("id"),
+                            "call_id": tool_call.get("call_id", tool_call.get("id")),
                             "name": tool_call["function"]["name"],
                             "arguments": tool_call["function"]["arguments"],
                             "status": "completed",
@@ -719,7 +752,8 @@ class OpenAIResponses(Model):
                 model_response.tool_calls.append(
                     {
                         "id": output.id,
-                        "call_id": output.call_id,
+                        # Store additional call_id from OpenAI responses
+                        "call_id": output.call_id or output.id,
                         "type": "function",
                         "function": {
                             "name": output.name,
@@ -809,8 +843,8 @@ class OpenAIResponses(Model):
             item = stream_event.item
             if item.type == "function_call":
                 tool_use = {
-                    "id": item.id,
-                    "call_id": item.call_id,
+                    "id": getattr(item, "id", None),
+                    "call_id": getattr(item, "call_id", None) or getattr(item, "id", None),
                     "type": "function",
                     "function": {
                         "name": item.name,

agno/models/qwen/__init__.py

@@ -0,0 +1,5 @@
+from agno.models.dashscope.dashscope import DashScope as Qwen
+
+__all__ = [
+    "Qwen",
+]

agno/reasoning/default.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from textwrap import dedent
-from typing import Callable, Dict, List, Literal, Optional, Union
+from typing import Any, Callable, Dict, List, Literal, Optional, Union
 
 from agno.models.base import Model
 from agno.reasoning.step import ReasoningSteps
@@ -19,6 +19,9 @@ def get_default_reasoning_agent(
     telemetry: bool = True,
     debug_mode: bool = False,
     debug_level: Literal[1, 2] = 1,
+    session_state: Optional[Dict[str, Any]] = None,
+    context: Optional[Dict[str, Any]] = None,
+    extra_data: Optional[Dict[str, Any]] = None,
 ) -> Optional["Agent"]:  # type: ignore  # noqa: F821
     from agno.agent import Agent
 
@@ -87,6 +90,9 @@ def get_default_reasoning_agent(
         telemetry=telemetry,
         debug_mode=debug_mode,
         debug_level=debug_level,
+        session_state=session_state,
+        context=context,
+        extra_data=extra_data,
     )
 
     agent.model.show_tool_calls = False  # type: ignore

agno/reasoning/helpers.py

@@ -1,4 +1,4 @@
-from typing import List, Literal
+from typing import Any, Dict, List, Literal, Optional
 
 from agno.models.base import Model
 from agno.models.message import Message
@@ -13,6 +13,9 @@ def get_reasoning_agent(
     telemetry: bool = False,
     debug_mode: bool = False,
     debug_level: Literal[1, 2] = 1,
+    session_state: Optional[Dict[str, Any]] = None,
+    context: Optional[Dict[str, Any]] = None,
+    extra_data: Optional[Dict[str, Any]] = None,
 ) -> "Agent":  # type: ignore  # noqa: F821
     from agno.agent import Agent
 
@@ -22,6 +25,9 @@ def get_reasoning_agent(
         telemetry=telemetry,
         debug_mode=debug_mode,
         debug_level=debug_level,
+        session_state=session_state,
+        context=context,
+        extra_data=extra_data,
     )
 
 

agno/run/response.py

@@ -420,6 +420,9 @@ class RunResponse:
         messages = data.pop("messages", None)
         messages = [Message.model_validate(message) for message in messages] if messages else None
 
+        citations = data.pop("citations", None)
+        citations = Citations.model_validate(citations) if citations else None
+
         tools = data.pop("tools", [])
         tools = [ToolExecution.from_dict(tool) for tool in tools] if tools else None
 
@@ -441,6 +444,7 @@ class RunResponse:
 
         return cls(
             messages=messages,
+            citations=citations,
             tools=tools,
             images=images,
             audio=audio,

agno/run/team.py

@@ -416,6 +416,9 @@ class TeamRunResponse:
         response_audio = data.pop("response_audio", None)
         response_audio = AudioResponse.model_validate(response_audio) if response_audio else None
 
+        citations = data.pop("citations", None)
+        citations = Citations.model_validate(citations) if citations else None
+
         # To make it backwards compatible
         if "event" in data:
             data.pop("event")
@@ -428,6 +431,7 @@ class TeamRunResponse:
             videos=videos,
             audio=audio,
             response_audio=response_audio,
+            citations=citations,
             tools=tools,
             events=events,
             **data,

agno/storage/dynamodb.py

@@ -30,19 +30,23 @@ class DynamoDbStorage(Storage):
         endpoint_url: Optional[str] = None,
         create_table_if_not_exists: bool = True,
         mode: Optional[Literal["agent", "team", "workflow", "workflow_v2"]] = "agent",
+        create_table_read_capacity_units: int = 5,
+        create_table_write_capacity_units: int = 5,
     ):
         """
         Initialize the DynamoDbStorage.
 
         Args:
             table_name (str): The name of the DynamoDB table.
-            region_name (Optional[str]): AWS region name.
             profile_name (Optional[str]): AWS profile name to use for credentials.
+            region_name (Optional[str]): AWS region name.
             aws_access_key_id (Optional[str]): AWS access key ID.
             aws_secret_access_key (Optional[str]): AWS secret access key.
             endpoint_url (Optional[str]): The complete URL to use for the constructed client.
             create_table_if_not_exists (bool): Whether to create the table if it does not exist.
             mode (Optional[Literal["agent", "team", "workflow", "workflow_v2"]]): The mode of the storage.
+            create_table_read_capacity_units Optional[int]: Read capacity units for created table (default: 5).
+            create_table_write_capacity_units Optional[int]: Write capacity units for created table (default: 5).
         """
         super().__init__(mode)
         self.table_name = table_name
@@ -52,6 +56,8 @@ class DynamoDbStorage(Storage):
         self.aws_access_key_id = aws_access_key_id
         self.aws_secret_access_key = aws_secret_access_key
         self.create_table_if_not_exists = create_table_if_not_exists
+        self.create_table_read_capacity_units = create_table_read_capacity_units
+        self.create_table_write_capacity_units = create_table_write_capacity_units
 
         # Create session using profile name if provided
         if self.profile_name:
@@ -96,6 +102,11 @@ class DynamoDbStorage(Storage):
         """
         Create the DynamoDB table if it does not exist.
         """
+        provisioned_throughput = {
+            "ReadCapacityUnits": self.create_table_read_capacity_units,
+            "WriteCapacityUnits": self.create_table_write_capacity_units,
+        }
+
         try:
             # Check if table exists
             self.dynamodb.meta.client.describe_table(TableName=self.table_name)
@@ -141,10 +152,7 @@ class DynamoDbStorage(Storage):
                             {"AttributeName": "created_at", "KeyType": "RANGE"},
                         ],
                         "Projection": {"ProjectionType": "ALL"},
-                        "ProvisionedThroughput": {
-                            "ReadCapacityUnits": 5,
-                            "WriteCapacityUnits": 5,
-                        },
+                        "ProvisionedThroughput": provisioned_throughput,
                     }
                 ]
                 if self.mode == "agent":
@@ -156,10 +164,7 @@ class DynamoDbStorage(Storage):
                                 {"AttributeName": "created_at", "KeyType": "RANGE"},
                             ],
                             "Projection": {"ProjectionType": "ALL"},
-                            "ProvisionedThroughput": {
-                                "ReadCapacityUnits": 5,
-                                "WriteCapacityUnits": 5,
-                            },
+                            "ProvisionedThroughput": provisioned_throughput,
                         }
                     )
                 elif self.mode == "team":
@@ -171,10 +176,7 @@ class DynamoDbStorage(Storage):
                                 {"AttributeName": "created_at", "KeyType": "RANGE"},
                             ],
                             "Projection": {"ProjectionType": "ALL"},
-                            "ProvisionedThroughput": {
-                                "ReadCapacityUnits": 5,
-                                "WriteCapacityUnits": 5,
-                            },
+                            "ProvisionedThroughput": provisioned_throughput,
                         }
                     )
                 elif self.mode == "workflow":
@@ -186,10 +188,7 @@ class DynamoDbStorage(Storage):
                                 {"AttributeName": "created_at", "KeyType": "RANGE"},
                             ],
                             "Projection": {"ProjectionType": "ALL"},
-                            "ProvisionedThroughput": {
-                                "ReadCapacityUnits": 5,
-                                "WriteCapacityUnits": 5,
-                            },
+                            "ProvisionedThroughput": provisioned_throughput,
                         }
                     )
                 elif self.mode == "workflow_v2":
@@ -201,10 +200,7 @@ class DynamoDbStorage(Storage):
                                 {"AttributeName": "created_at", "KeyType": "RANGE"},
                             ],
                             "Projection": {"ProjectionType": "ALL"},
-                            "ProvisionedThroughput": {
-                                "ReadCapacityUnits": 5,
-                                "WriteCapacityUnits": 5,
-                            },
+                            "ProvisionedThroughput": provisioned_throughput,
                         }
                     )
                 # Create the table
@@ -213,7 +209,7 @@ class DynamoDbStorage(Storage):
                     KeySchema=[{"AttributeName": "session_id", "KeyType": "HASH"}],
                     AttributeDefinitions=attribute_definitions,
                     GlobalSecondaryIndexes=secondary_indexes,
-                    ProvisionedThroughput={"ReadCapacityUnits": 5, "WriteCapacityUnits": 5},
+                    ProvisionedThroughput=provisioned_throughput,
                 )
                 # Wait until the table exists.
                 self.table.wait_until_exists()