agno 1.7.11__py3-none-any.whl → 1.8.0__py3-none-any.whl

agno/agent/agent.py

@@ -5885,6 +5885,9 @@ class Agent:
                 telemetry=self.telemetry,
                 debug_mode=self.debug_mode,
                 debug_level=self.debug_level,
+                session_state=self.session_state,
+                context=self.context,
+                extra_data=self.extra_data,
             )
             is_deepseek = is_deepseek_reasoning_model(reasoning_model)
             is_groq = is_groq_reasoning_model(reasoning_model)
@@ -5974,6 +5977,9 @@ class Agent:
                     telemetry=self.telemetry,
                     debug_mode=self.debug_mode,
                     debug_level=self.debug_level,
+                    session_state=self.session_state,
+                    context=self.context,
+                    extra_data=self.extra_data,
                 )
 
             # Validate reasoning agent
@@ -6108,6 +6114,9 @@ class Agent:
                 telemetry=self.telemetry,
                 debug_mode=self.debug_mode,
                 debug_level=self.debug_level,
+                session_state=self.session_state,
+                context=self.context,
+                extra_data=self.extra_data,
             )
             is_deepseek = is_deepseek_reasoning_model(reasoning_model)
             is_groq = is_groq_reasoning_model(reasoning_model)
@@ -6197,6 +6206,9 @@ class Agent:
                     telemetry=self.telemetry,
                     debug_mode=self.debug_mode,
                     debug_level=self.debug_level,
+                    session_state=self.session_state,
+                    context=self.context,
+                    extra_data=self.extra_data,
                 )
 
             # Validate reasoning agent
@@ -7443,6 +7455,7 @@ class Agent:
                         if citation.url  # Only include citations with valid URLs
                     )
                     if md_content:  # Only create panel if there are citations
+                        md_content = md_content.strip()
                         citations_panel = create_panel(
                             content=Markdown(md_content),
                             title="Citations",

agno/app/agui/utils.py

@@ -129,7 +129,7 @@ def _create_events_from_chunk(
     Process a single chunk and return events to emit + updated message_started state.
     Returns: (events_to_emit, new_message_started_state)
     """
-    events_to_emit = []
+    events_to_emit: List[BaseEvent] = []
 
     # Extract content if the contextual event is a content event
     if chunk.event == RunEvent.run_response_content:

agno/app/fastapi/async_router.py

@@ -13,7 +13,7 @@ from agno.media import Audio, Image, Video
 from agno.media import File as FileMedia
 from agno.run.response import RunResponseErrorEvent
 from agno.run.team import RunResponseErrorEvent as TeamRunResponseErrorEvent
-from agno.run.team import TeamRunResponseEvent
+from agno.run.team import TeamRunResponse, TeamRunResponseEvent
 from agno.run.v2.workflow import WorkflowErrorEvent
 from agno.team.team import Team
 from agno.utils.log import logger
@@ -425,15 +425,18 @@ def get_async_router(
                 )
                 return run_response.to_dict()
             elif team:
-                team_run_response = await team.arun(
-                    message=message,
-                    session_id=session_id,
-                    user_id=user_id,
-                    images=base64_images if base64_images else None,
-                    audio=base64_audios if base64_audios else None,
-                    videos=base64_videos if base64_videos else None,
-                    files=document_files if document_files else None,
-                    stream=False,
+                team_run_response = cast(
+                    TeamRunResponse,
+                    await team.arun(
+                        message=message,
+                        session_id=session_id,
+                        user_id=user_id,
+                        images=base64_images if base64_images else None,
+                        audio=base64_audios if base64_audios else None,
+                        videos=base64_videos if base64_videos else None,
+                        files=document_files if document_files else None,
+                        stream=False,
+                    ),
                 )
                 return team_run_response.to_dict()
             elif workflow:

agno/embedder/google.py

@@ -23,6 +23,10 @@ class GeminiEmbedder(Embedder):
     request_params: Optional[Dict[str, Any]] = None
     client_params: Optional[Dict[str, Any]] = None
     gemini_client: Optional[GeminiClient] = None
+    # Vertex AI parameters
+    vertexai: bool = False
+    project_id: Optional[str] = None
+    location: Optional[str] = None
 
     @property
     def client(self):
@@ -30,13 +34,21 @@ class GeminiEmbedder(Embedder):
             return self.gemini_client
 
         _client_params: Dict[str, Any] = {}
+        vertexai = self.vertexai or getenv("GOOGLE_GENAI_USE_VERTEXAI", "false").lower() == "true"
 
-        self.api_key = self.api_key or getenv("GOOGLE_API_KEY")
-        if not self.api_key:
-            log_error("GOOGLE_API_KEY not set. Please set the GOOGLE_API_KEY environment variable.")
-
-        if self.api_key:
+        if not vertexai:
+            self.api_key = self.api_key or getenv("GOOGLE_API_KEY")
+            if not self.api_key:
+                log_error("GOOGLE_API_KEY not set. Please set the GOOGLE_API_KEY environment variable.")
             _client_params["api_key"] = self.api_key
+        else:
+            log_info("Using Vertex AI API for embeddings")
+            _client_params["vertexai"] = True
+            _client_params["project"] = self.project_id or getenv("GOOGLE_CLOUD_PROJECT")
+            _client_params["location"] = self.location or getenv("GOOGLE_CLOUD_LOCATION")
+
+        _client_params = {k: v for k, v in _client_params.items() if v is not None}
+
         if self.client_params:
             _client_params.update(self.client_params)
 

agno/knowledge/gcs/pdf.py

@@ -1,8 +1,9 @@
-from typing import AsyncIterator, Iterator, List
+from typing import Any, AsyncIterator, Dict, Iterator, List, Optional
 
 from agno.document import Document
 from agno.document.reader.gcs.pdf_reader import GCSPDFReader
 from agno.knowledge.gcs.base import GCSKnowledgeBase
+from agno.utils.log import log_debug, log_info
 
 
 class GCSPDFKnowledgeBase(GCSKnowledgeBase):
@@ -19,3 +20,106 @@ class GCSPDFKnowledgeBase(GCSKnowledgeBase):
         for blob in self.gcs_blobs:
             if blob.name.endswith(".pdf"):
                 yield await self.reader.async_read(blob=blob)
+
+    def load(
+        self,
+        recreate: bool = False,
+        upsert: bool = False,
+        skip_existing: bool = True,
+    ) -> None:
+        """Load the knowledge base to the vector db
+        Args:
+            recreate (bool): If True, recreates the collection in the vector db. Defaults to False.
+            upsert (bool): If True, upserts documents to the vector db. Defaults to False.
+            skip_existing (bool): If True, skips documents which already exist in the vector db when inserting. Defaults to True.
+        """
+        self._load_init(recreate, upsert)
+        if self.vector_db is None:
+            return
+
+        log_info("Loading knowledge base")
+        num_documents = 0
+        for document_list in self.document_lists:
+            documents_to_load = document_list
+
+            # Track metadata for filtering capabilities and collect metadata for filters
+            filters_metadata: Optional[Dict[str, Any]] = None
+            for doc in document_list:
+                if doc.meta_data:
+                    self._track_metadata_structure(doc.meta_data)
+                    # Use the first non-None metadata for filters
+                    if filters_metadata is None:
+                        filters_metadata = doc.meta_data
+
+            # Skip processing if no documents in this batch
+            if not documents_to_load:
+                log_debug("Skipping empty document batch")
+                continue
+
+            # Upsert documents if upsert is True and vector db supports upsert
+            if upsert and self.vector_db.upsert_available():
+                self.vector_db.upsert(documents=documents_to_load, filters=filters_metadata)
+            # Insert documents
+            else:
+                # Filter out documents which already exist in the vector db
+                if skip_existing:
+                    log_debug("Filtering out existing documents before insertion.")
+                    documents_to_load = self.filter_existing_documents(document_list)
+
+                if documents_to_load:
+                    self.vector_db.insert(documents=documents_to_load, filters=filters_metadata)
+
+            num_documents += len(documents_to_load)
+        log_info(f"Added {num_documents} documents to knowledge base")
+
+    async def aload(
+        self,
+        recreate: bool = False,
+        upsert: bool = False,
+        skip_existing: bool = True,
+    ) -> None:
+        """Load the knowledge base to the vector db asynchronously
+        Args:
+            recreate (bool): If True, recreates the collection in the vector db. Defaults to False.
+            upsert (bool): If True, upserts documents to the vector db. Defaults to False.
+            skip_existing (bool): If True, skips documents which already exist in the vector db when inserting. Defaults to True.
+        """
+        await self._aload_init(recreate, upsert)
+        if self.vector_db is None:
+            return
+
+        log_info("Loading knowledge base")
+        num_documents = 0
+        document_iterator = self.async_document_lists
+        async for document_list in document_iterator:  # type: ignore
+            documents_to_load = document_list
+
+            # Track metadata for filtering capabilities and collect metadata for filters
+            filters_metadata: Optional[Dict[str, Any]] = None
+            for doc in document_list:
+                if doc.meta_data:
+                    self._track_metadata_structure(doc.meta_data)
+                    # Use the first non-None metadata for filters
+                    if filters_metadata is None:
+                        filters_metadata = doc.meta_data
+
+            # Skip processing if no documents in this batch
+            if not documents_to_load:
+                log_debug("Skipping empty document batch")
+                continue
+
+            # Upsert documents if upsert is True and vector db supports upsert
+            if upsert and self.vector_db.upsert_available():
+                await self.vector_db.async_upsert(documents=documents_to_load, filters=filters_metadata)
+            # Insert documents
+            else:
+                # Filter out documents which already exist in the vector db
+                if skip_existing:
+                    log_debug("Filtering out existing documents before insertion.")
+                    documents_to_load = await self.async_filter_existing_documents(document_list)
+
+                if documents_to_load:
+                    await self.vector_db.async_insert(documents=documents_to_load, filters=filters_metadata)
+
+            num_documents += len(documents_to_load)
+        log_info(f"Added {num_documents} documents to knowledge base")

agno/media.py

@@ -38,13 +38,34 @@ class ImageArtifact(Media):
     mime_type: Optional[str] = None
     alt_text: Optional[str] = None
 
+    def _normalise_content(self) -> Optional[Union[str, bytes]]:
+        if self.content is None:
+            return None
+        content_normalised: Union[str, bytes] = self.content
+        if content_normalised and isinstance(content_normalised, bytes):
+            from base64 import b64encode
+
+            try:
+                # First try to decode as UTF-8
+                content_normalised = content_normalised.decode("utf-8")  # type: ignore
+            except UnicodeDecodeError:
+                # Fallback to base64 encoding for binary content
+                content_normalised = b64encode(bytes(content_normalised)).decode("utf-8")  # type: ignore
+            except Exception:
+                # Last resort: try to convert to base64
+                try:
+                    content_normalised = b64encode(bytes(content_normalised)).decode("utf-8")  # type: ignore
+                except Exception:
+                    pass
+        return content_normalised
+
     def to_dict(self) -> Dict[str, Any]:
+        content_normalised = self._normalise_content()
+
         response_dict = {
             "id": self.id,
             "url": self.url,
-            "content": self.content.decode("utf-8")
-            if self.content and isinstance(self.content, bytes)
-            else self.content,
+            "content": content_normalised,
             "mime_type": self.mime_type,
             "alt_text": self.alt_text,
         }

agno/models/google/gemini.py

@@ -30,8 +30,11 @@ try:
         GoogleSearch,
         GoogleSearchRetrieval,
         Part,
+        Retrieval,
         ThinkingConfig,
         Tool,
+        UrlContext,
+        VertexAISearch,
     )
     from google.genai.types import (
         File as GeminiFile,
@@ -68,6 +71,9 @@ class Gemini(Model):
     search: bool = False
     grounding: bool = False
     grounding_dynamic_threshold: Optional[float] = None
+    url_context: bool = False
+    vertexai_search: bool = False
+    vertexai_search_datastore: Optional[str] = None
 
     temperature: Optional[float] = None
     top_p: Optional[float] = None
@@ -115,7 +121,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 +204,45 @@ 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()))
+
+        if self.vertexai_search:
+            log_info("Vertex AI Search enabled.")
+            if not self.vertexai_search_datastore:
+                log_error("vertexai_search_datastore must be provided when vertexai_search is enabled.")
+                raise ValueError("vertexai_search_datastore must be provided when vertexai_search is enabled.")
+            builtin_tools.append(
+                Tool(retrieval=Retrieval(vertex_ai_search=VertexAISearch(datastore=self.vertexai_search_datastore)))
+            )
 
+        # 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 +412,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 +423,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 +785,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 +801,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,

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}

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,
     )