agno 2.4.0__py3-none-any.whl → 2.4.1__py3-none-any.whl

agno/knowledge/remote_content/config.py

@@ -0,0 +1,204 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Optional
+
+from pydantic import BaseModel
+
+if TYPE_CHECKING:
+    from agno.knowledge.remote_content.remote_content import (
+        GCSContent,
+        GitHubContent,
+        S3Content,
+        SharePointContent,
+    )
+
+
+class RemoteContentConfig(BaseModel):
+    """Base configuration for remote content sources."""
+
+    id: str
+    name: str
+    metadata: Optional[dict] = None
+
+    class Config:
+        extra = "allow"
+
+
+class S3Config(RemoteContentConfig):
+    """Configuration for AWS S3 content source."""
+
+    bucket_name: str
+    region: Optional[str] = None
+    aws_access_key_id: Optional[str] = None
+    aws_secret_access_key: Optional[str] = None
+    prefix: Optional[str] = None
+
+    def file(self, key: str) -> "S3Content":
+        """Create a content reference for a specific file.
+
+        Args:
+            key: The S3 object key (path to file).
+
+        Returns:
+            S3Content configured with this source's credentials.
+        """
+        from agno.knowledge.remote_content.remote_content import S3Content
+
+        return S3Content(
+            bucket_name=self.bucket_name,
+            key=key,
+            config_id=self.id,
+        )
+
+    def folder(self, prefix: str) -> "S3Content":
+        """Create a content reference for a folder (prefix).
+
+        Args:
+            prefix: The S3 prefix (folder path).
+
+        Returns:
+            S3Content configured with this source's credentials.
+        """
+        from agno.knowledge.remote_content.remote_content import S3Content
+
+        return S3Content(
+            bucket_name=self.bucket_name,
+            prefix=prefix,
+            config_id=self.id,
+        )
+
+
+class GcsConfig(RemoteContentConfig):
+    """Configuration for Google Cloud Storage content source."""
+
+    bucket_name: str
+    project: Optional[str] = None
+    credentials_path: Optional[str] = None
+    prefix: Optional[str] = None
+
+    def file(self, blob_name: str) -> "GCSContent":
+        """Create a content reference for a specific file.
+
+        Args:
+            blob_name: The GCS blob name (path to file).
+
+        Returns:
+            GCSContent configured with this source's credentials.
+        """
+        from agno.knowledge.remote_content.remote_content import GCSContent
+
+        return GCSContent(
+            bucket_name=self.bucket_name,
+            blob_name=blob_name,
+            config_id=self.id,
+        )
+
+    def folder(self, prefix: str) -> "GCSContent":
+        """Create a content reference for a folder (prefix).
+
+        Args:
+            prefix: The GCS prefix (folder path).
+
+        Returns:
+            GCSContent configured with this source's credentials.
+        """
+        from agno.knowledge.remote_content.remote_content import GCSContent
+
+        return GCSContent(
+            bucket_name=self.bucket_name,
+            prefix=prefix,
+            config_id=self.id,
+        )
+
+
+class SharePointConfig(RemoteContentConfig):
+    """Configuration for SharePoint content source."""
+
+    tenant_id: str
+    client_id: str
+    client_secret: str
+    hostname: str
+    site_path: Optional[str] = None
+    site_id: Optional[str] = None  # Full site ID (e.g., "contoso.sharepoint.com,guid1,guid2")
+    folder_path: Optional[str] = None
+
+    def file(self, file_path: str, site_path: Optional[str] = None) -> "SharePointContent":
+        """Create a content reference for a specific file.
+
+        Args:
+            file_path: Path to the file in SharePoint.
+            site_path: Optional site path override.
+
+        Returns:
+            SharePointContent configured with this source's credentials.
+        """
+        from agno.knowledge.remote_content.remote_content import SharePointContent
+
+        return SharePointContent(
+            config_id=self.id,
+            file_path=file_path,
+            site_path=site_path or self.site_path,
+        )
+
+    def folder(self, folder_path: str, site_path: Optional[str] = None) -> "SharePointContent":
+        """Create a content reference for a folder.
+
+        Args:
+            folder_path: Path to the folder in SharePoint.
+            site_path: Optional site path override.
+
+        Returns:
+            SharePointContent configured with this source's credentials.
+        """
+        from agno.knowledge.remote_content.remote_content import SharePointContent
+
+        return SharePointContent(
+            config_id=self.id,
+            folder_path=folder_path,
+            site_path=site_path or self.site_path,
+        )
+
+
+class GitHubConfig(RemoteContentConfig):
+    """Configuration for GitHub content source."""
+
+    repo: str
+    token: Optional[str] = None
+    branch: Optional[str] = None
+    path: Optional[str] = None
+
+    def file(self, file_path: str, branch: Optional[str] = None) -> "GitHubContent":
+        """Create a content reference for a specific file.
+
+        Args:
+            file_path: Path to the file in the repository.
+            branch: Optional branch override.
+
+        Returns:
+            GitHubContent configured with this source's credentials.
+        """
+        from agno.knowledge.remote_content.remote_content import GitHubContent
+
+        return GitHubContent(
+            config_id=self.id,
+            file_path=file_path,
+            branch=branch or self.branch,
+        )
+
+    def folder(self, folder_path: str, branch: Optional[str] = None) -> "GitHubContent":
+        """Create a content reference for a folder.
+
+        Args:
+            folder_path: Path to the folder in the repository.
+            branch: Optional branch override.
+
+        Returns:
+            GitHubContent configured with this source's credentials.
+        """
+        from agno.knowledge.remote_content.remote_content import GitHubContent
+
+        return GitHubContent(
+            config_id=self.id,
+            folder_path=folder_path,
+            branch=branch or self.branch,
+        )

agno/knowledge/remote_content/remote_content.py

@@ -14,21 +14,23 @@ class S3Content:
         key: Optional[str] = None,
         object: Optional[S3Object] = None,
         prefix: Optional[str] = None,
+        config_id: Optional[str] = None,
     ):
         self.bucket_name = bucket_name
         self.bucket = bucket
         self.key = key
         self.object = object
         self.prefix = prefix
+        self.config_id = config_id
 
         if bucket_name is None and bucket is None:
             raise ValueError("Either bucket_name or bucket must be provided")
-        if key is None and object is None:
-            raise ValueError("Either key or object must be provided")
+        if key is None and object is None and prefix is None:
+            raise ValueError("Either key, object, or prefix must be provided")
         if bucket_name is not None and bucket is not None:
             raise ValueError("Either bucket_name or bucket must be provided, not both")
-        if key is not None and object is not None:
-            raise ValueError("Either key or object must be provided, not both")
+        if sum(x is not None for x in [key, object, prefix]) > 1:
+            raise ValueError("Only one of key, object, or prefix should be provided")
 
         if self.bucket_name is not None:
             self.bucket = S3Bucket(name=self.bucket_name)
@@ -40,6 +42,7 @@ class S3Content:
             "key": self.key,
             "object": self.object,
             "prefix": self.prefix,
+            "config_id": self.config_id,
         }
 
 
@@ -51,19 +54,13 @@ class GCSContent:
         bucket_name: Optional[str] = None,
         blob_name: Optional[str] = None,
         prefix: Optional[str] = None,
+        config_id: Optional[str] = None,
     ):
-        # Import Google Cloud Storage only when actually needed
-        try:
-            from google.cloud import storage  # type: ignore
-        except ImportError:
-            raise ImportError(
-                "The `google-cloud-storage` package is not installed. Please install it via `pip install google-cloud-storage`."
-            )
-
         self.bucket = bucket
         self.bucket_name = bucket_name
         self.blob_name = blob_name
         self.prefix = prefix
+        self.config_id = config_id
 
         if self.bucket is None and self.bucket_name is None:
             raise ValueError("No bucket or bucket_name provided")
@@ -72,17 +69,77 @@ class GCSContent:
         if self.blob_name is None and self.prefix is None:
             raise ValueError("Either blob_name or prefix must be provided")
 
-        if self.bucket is None:
-            client = storage.Client()
-            self.bucket = client.bucket(self.bucket_name)
-
     def get_config(self):
         return {
             "bucket": self.bucket,
             "bucket_name": self.bucket_name,
             "blob_name": self.blob_name,
             "prefix": self.prefix,
+            "config_id": self.config_id,
+        }
+
+
+@dataclass
+class SharePointContent:
+    """Content reference for SharePoint files."""
+
+    def __init__(
+        self,
+        config_id: str,
+        file_path: Optional[str] = None,
+        folder_path: Optional[str] = None,
+        site_path: Optional[str] = None,
+        drive_id: Optional[str] = None,
+    ):
+        self.config_id = config_id
+        self.file_path = file_path
+        self.folder_path = folder_path
+        self.site_path = site_path
+        self.drive_id = drive_id
+
+        if self.file_path is None and self.folder_path is None:
+            raise ValueError("Either file_path or folder_path must be provided")
+        if self.file_path is not None and self.folder_path is not None:
+            raise ValueError("Provide either file_path or folder_path, not both")
+
+    def get_config(self):
+        return {
+            "config_id": self.config_id,
+            "file_path": self.file_path,
+            "folder_path": self.folder_path,
+            "site_path": self.site_path,
+            "drive_id": self.drive_id,
+        }
+
+
+@dataclass
+class GitHubContent:
+    """Content reference for GitHub files."""
+
+    def __init__(
+        self,
+        config_id: str,
+        file_path: Optional[str] = None,
+        folder_path: Optional[str] = None,
+        branch: Optional[str] = None,
+    ):
+        self.config_id = config_id
+        self.file_path = file_path
+        self.folder_path = folder_path
+        self.branch = branch
+
+        if self.file_path is None and self.folder_path is None:
+            raise ValueError("Either file_path or folder_path must be provided")
+        if self.file_path is not None and self.folder_path is not None:
+            raise ValueError("Provide either file_path or folder_path, not both")
+
+    def get_config(self):
+        return {
+            "config_id": self.config_id,
+            "file_path": self.file_path,
+            "folder_path": self.folder_path,
+            "branch": self.branch,
         }
 
 
-RemoteContent = Union[S3Content, GCSContent]
+RemoteContent = Union[S3Content, GCSContent, SharePointContent, GitHubContent]

agno/models/base.py

@@ -1988,6 +1988,7 @@ class Model(ABC):
 
                         if isinstance(item, CustomEvent):
                             function_call_output += str(item)
+                            item.tool_call_id = function_call.call_id
 
                         # For WorkflowCompletedEvent, extract content for final output
                         from agno.run.workflow import WorkflowCompletedEvent
@@ -2430,6 +2431,7 @@ class Model(ABC):
 
                         if isinstance(item, CustomEvent):
                             function_call_output += str(item)
+                            item.tool_call_id = function_call.call_id
 
                             # For WorkflowCompletedEvent, extract content for final output
                             from agno.run.workflow import WorkflowCompletedEvent
@@ -2507,8 +2509,12 @@ class Model(ABC):
                                 if async_gen_index in async_generator_outputs:
                                     _, async_function_call_output, error = async_generator_outputs[async_gen_index]
                                     if error:
-                                        log_error(f"Error in async generator: {error}")
-                                        raise error
+                                        # Handle async generator exceptions gracefully like sync generators
+                                        log_error(
+                                            f"Error while iterating async generator for {function_call.function.name}: {error}"
+                                        )
+                                        function_call.error = str(error)
+                                        function_call_success = False
                                 break
                             async_gen_index += 1
 
@@ -2555,6 +2561,10 @@ class Model(ABC):
                                     yield ModelResponse(content=item.content)
                                     continue
 
+                            elif isinstance(item, CustomEvent):
+                                function_call_output += str(item)
+                                item.tool_call_id = function_call.call_id
+
                             # Yield the event itself to bubble it up
                             yield item
                         else:

agno/models/cerebras/cerebras.py

@@ -97,6 +97,35 @@ class Cerebras(Model):
             client_params.update(self.client_params)
         return client_params
 
+    def _ensure_additional_properties_false(self, schema: Dict[str, Any]) -> None:
+        """
+        Recursively ensure all object types have additionalProperties: false.
+        Cerebras API requires this for JSON schema validation.
+        """
+        if not isinstance(schema, dict):
+            return
+
+        # Set additionalProperties: false for object types
+        if schema.get("type") == "object":
+            schema["additionalProperties"] = False
+
+        # Recursively process nested schemas
+        if "properties" in schema and isinstance(schema["properties"], dict):
+            for prop_schema in schema["properties"].values():
+                self._ensure_additional_properties_false(prop_schema)
+
+        if "items" in schema:
+            self._ensure_additional_properties_false(schema["items"])
+
+        if "$defs" in schema and isinstance(schema["$defs"], dict):
+            for def_schema in schema["$defs"].values():
+                self._ensure_additional_properties_false(def_schema)
+
+        for key in ["allOf", "anyOf", "oneOf"]:
+            if key in schema and isinstance(schema[key], list):
+                for item in schema[key]:
+                    self._ensure_additional_properties_false(item)
+
     def get_client(self) -> CerebrasClient:
         """
         Returns a Cerebras client.
@@ -191,8 +220,11 @@ class Cerebras(Model):
             ):
                 # Ensure json_schema has strict parameter set
                 schema = response_format["json_schema"]
-                if isinstance(schema.get("schema"), dict) and "strict" not in schema:
-                    schema["strict"] = self.strict_output
+                if isinstance(schema.get("schema"), dict):
+                    if "strict" not in schema:
+                        schema["strict"] = self.strict_output
+                    # Cerebras requires additionalProperties: false for all object types
+                    self._ensure_additional_properties_false(schema["schema"])
 
                 request_params["response_format"] = response_format
 

agno/models/n1n/__init__.py

@@ -0,0 +1,3 @@
+from agno.models.n1n.n1n import N1N
+
+__all__ = ["N1N"]

agno/models/n1n/n1n.py

@@ -0,0 +1,57 @@
+from dataclasses import dataclass, field
+from os import getenv
+from typing import Any, Dict, Optional
+
+from agno.exceptions import ModelAuthenticationError
+from agno.models.openai.like import OpenAILike
+
+
+@dataclass
+class N1N(OpenAILike):
+    """
+    A class for interacting with n1n.ai models.
+
+    Attributes:
+        id (str): The model id. Defaults to "gpt-4o".
+        name (str): The model name. Defaults to "N1N".
+        provider (str): The provider name. Defaults to "N1N".
+        api_key (Optional[str]): The API key.
+        base_url (str): The base URL. Defaults to "https://api.n1n.ai/v1".
+    """
+
+    id: str = "gpt-4o"
+    name: str = "N1N"
+    provider: str = "N1N"
+
+    api_key: Optional[str] = field(default_factory=lambda: getenv("N1N_API_KEY"))
+    base_url: str = "https://api.n1n.ai/v1"
+
+    def _get_client_params(self) -> Dict[str, Any]:
+        # Fetch API key from env if not already set
+        if not self.api_key:
+            self.api_key = getenv("N1N_API_KEY")
+            if not self.api_key:
+                # Raise error immediately if key is missing
+                raise ModelAuthenticationError(
+                    message="N1N_API_KEY not set. Please set the N1N_API_KEY environment variable.",
+                    model_name=self.name,
+                )
+
+        # Define base client params
+        base_params = {
+            "api_key": self.api_key,
+            "organization": self.organization,
+            "base_url": self.base_url,
+            "timeout": self.timeout,
+            "max_retries": self.max_retries,
+            "default_headers": self.default_headers,
+            "default_query": self.default_query,
+        }
+
+        # Create client_params dict with non-None values
+        client_params = {k: v for k, v in base_params.items() if v is not None}
+
+        # Add additional client params if provided
+        if self.client_params:
+            client_params.update(self.client_params)
+        return client_params

agno/models/openai/chat.py

@@ -43,6 +43,8 @@ class OpenAIChat(Model):
     name: str = "OpenAIChat"
     provider: str = "OpenAI"
     supports_native_structured_outputs: bool = True
+    # If True, only collect metrics on the final streaming chunk (for providers with cumulative token counts)
+    collect_metrics_on_completion: bool = False
 
     # Request parameters
     store: Optional[bool] = None
@@ -752,6 +754,21 @@ class OpenAIChat(Model):
                     tool_call_entry["type"] = _tool_call_type
         return tool_calls
 
+    def _should_collect_metrics(self, response: ChatCompletionChunk) -> bool:
+        """
+        Determine if metrics should be collected from the response.
+        """
+        if not response.usage:
+            return False
+
+        if not self.collect_metrics_on_completion:
+            return True
+
+        if not response.choices:
+            return False
+
+        return response.choices[0].finish_reason is not None
+
     def _parse_provider_response(
         self,
         response: ChatCompletion,
@@ -920,7 +937,7 @@ class OpenAIChat(Model):
                         log_warning(f"Error processing audio: {e}")
 
         # Add usage metrics if present
-        if response_delta.usage is not None:
+        if self._should_collect_metrics(response_delta) and response_delta.usage is not None:
             model_response.response_usage = self._get_metrics(response_delta.usage)
 
         return model_response

agno/models/perplexity/perplexity.py

@@ -41,6 +41,8 @@ class Perplexity(OpenAILike):
     id: str = "sonar"
     name: str = "Perplexity"
     provider: str = "Perplexity"
+    # Perplexity returns cumulative token counts in each streaming chunk, so only collect on final chunk
+    collect_metrics_on_completion: bool = True
 
     api_key: Optional[str] = field(default_factory=lambda: getenv("PERPLEXITY_API_KEY"))
     base_url: str = "https://api.perplexity.ai/"

agno/os/interfaces/slack/router.py

@@ -7,7 +7,7 @@ from agno.agent import Agent, RemoteAgent
 from agno.os.interfaces.slack.security import verify_slack_signature
 from agno.team import RemoteTeam, Team
 from agno.tools.slack import SlackTools
-from agno.utils.log import log_info
+from agno.utils.log import log_error, log_info
 from agno.workflow import RemoteWorkflow, Workflow
 
 
@@ -112,6 +112,15 @@ def attach_routes(
             response = await workflow.arun(message_text, user_id=user, session_id=session_id)  # type: ignore
 
         if response:
+            if response.status == "ERROR":
+                log_error(f"Error processing message: {response.content}")
+                _send_slack_message(
+                    channel=channel_id,
+                    message="Sorry, there was an error processing your message. Please try again later.",
+                    thread_ts=ts,
+                )
+                return
+
             if hasattr(response, "reasoning_content") and response.reasoning_content:
                 _send_slack_message(
                     channel=channel_id,

agno/os/interfaces/whatsapp/router.py

@@ -162,6 +162,12 @@ def attach_routes(
                     videos=[Video(content=await get_media_async(message_video))] if message_video else None,
                     audio=[Audio(content=await get_media_async(message_audio))] if message_audio else None,
                 )
+            if response.status == "ERROR":
+                await _send_whatsapp_message(
+                    phone_number, "Sorry, there was an error processing your message. Please try again later."
+                )
+                log_error(response.content)
+                return
 
             if response.reasoning_content:
                 await _send_whatsapp_message(phone_number, f"Reasoning: \n{response.reasoning_content}", italics=True)

agno/os/routers/components/components.py

@@ -25,7 +25,7 @@ from agno.os.schema import (
 )
 from agno.os.settings import AgnoAPISettings
 from agno.registry import Registry
-from agno.utils.log import log_error
+from agno.utils.log import log_error, log_warning
 from agno.utils.string import generate_id_from_name
 
 logger = logging.getLogger(__name__)
@@ -167,6 +167,15 @@ def attach_routes(
             config = body.config or {}
             config = _resolve_db_in_config(config, db, registry)
 
+            # Warn if creating a team without members
+            if body.component_type == ComponentType.TEAM:
+                members = config.get("members")
+                if not members or len(members) == 0:
+                    log_warning(
+                        f"Creating team '{body.name}' without members. "
+                        "If this is unintended, add members to the config."
+                    )
+
             component, _config = db.create_component_with_config(
                 component_id=component_id,
                 component_type=DbComponentType(body.component_type.value),