agno 2.3.16__py3-none-any.whl → 2.3.18__py3-none-any.whl

agno/team/remote.py

@@ -0,0 +1,287 @@
+import json
+import time
+from typing import TYPE_CHECKING, Any, AsyncIterator, Dict, List, Literal, Optional, Sequence, Tuple, Union, overload
+
+from pydantic import BaseModel
+
+from agno.media import Audio, File, Image, Video
+from agno.models.base import Model
+from agno.models.message import Message
+from agno.remote.base import BaseRemote, RemoteDb, RemoteKnowledge
+from agno.run.agent import RunOutputEvent
+from agno.run.team import TeamRunOutput, TeamRunOutputEvent
+from agno.utils.agent import validate_input
+from agno.utils.log import log_warning
+from agno.utils.remote import serialize_input
+
+if TYPE_CHECKING:
+    from agno.os.routers.teams.schema import TeamResponse
+
+
+class RemoteTeam(BaseRemote):
+    # Private cache for team config with TTL: (config, timestamp)
+    _cached_team_config: Optional[Tuple["TeamResponse", float]] = None
+
+    def __init__(
+        self,
+        base_url: str,
+        team_id: str,
+        timeout: float = 300.0,
+        config_ttl: float = 300.0,
+    ):
+        """Initialize AgentOSRunner for local or remote execution.
+
+        For remote execution, provide base_url and team_id.
+
+        Args:
+            base_url: Base URL for remote AgentOS instance (e.g., "http://localhost:7777")
+            team_id: ID of remote team
+            timeout: Request timeout in seconds (default: 300)
+            config_ttl: Time-to-live for cached config in seconds (default: 300)
+        """
+        super().__init__(base_url, timeout, config_ttl)
+        self.team_id = team_id
+        self._cached_team_config = None
+
+    @property
+    def id(self) -> str:
+        return self.team_id
+
+    async def get_team_config(self) -> "TeamResponse":
+        """Get the team config from remote (always fetches fresh)."""
+        return await self.client.aget_team(self.team_id)
+
+    @property
+    def _team_config(self) -> "TeamResponse":
+        """Get the team config from remote, cached with TTL."""
+        from agno.os.routers.teams.schema import TeamResponse
+
+        current_time = time.time()
+
+        # Check if cache is valid
+        if self._cached_team_config is not None:
+            config, cached_at = self._cached_team_config
+            if current_time - cached_at < self.config_ttl:
+                return config
+
+        # Fetch fresh config
+        config: TeamResponse = self.client.get_team(self.team_id)  # type: ignore
+        self._cached_team_config = (config, current_time)
+        return config
+
+    def refresh_config(self) -> "TeamResponse":
+        """Force refresh the cached team config."""
+        from agno.os.routers.teams.schema import TeamResponse
+
+        config: TeamResponse = self.client.get_team(self.team_id)  # type: ignore
+        self._cached_team_config = (config, time.time())
+        return config
+
+    @property
+    def name(self) -> Optional[str]:
+        if self._team_config is not None:
+            return self._team_config.name
+        return None
+
+    @property
+    def description(self) -> Optional[str]:
+        if self._team_config is not None:
+            return self._team_config.description
+        return None
+
+    @property
+    def role(self) -> Optional[str]:
+        if self._team_config is not None:
+            return self._team_config.role
+        return None
+
+    @property
+    def tools(self) -> Optional[List[Dict[str, Any]]]:
+        if self._team_config is not None:
+            try:
+                return json.loads(self._team_config.tools["tools"]) if self._team_config.tools else None
+            except Exception as e:
+                log_warning(f"Failed to load tools for team {self.team_id}: {e}")
+                return None
+        return None
+
+    @property
+    def db(self) -> Optional[RemoteDb]:
+        if self._team_config is not None and self._team_config.db_id is not None:
+            return RemoteDb.from_config(
+                db_id=self._team_config.db_id,
+                client=self.client,
+                config=self._config,
+            )
+        return None
+
+    @property
+    def knowledge(self) -> Optional[RemoteKnowledge]:
+        """Whether the team has knowledge enabled."""
+        if self._team_config is not None and self._team_config.knowledge is not None:
+            return RemoteKnowledge(
+                client=self.client,
+                contents_db=RemoteDb(
+                    id=self._team_config.knowledge.get("db_id"),  # type: ignore
+                    client=self.client,
+                    knowledge_table_name=self._team_config.knowledge.get("knowledge_table"),
+                )
+                if self._team_config.knowledge.get("db_id") is not None
+                else None,
+            )
+        return None
+
+    @property
+    def model(self) -> Optional[Model]:
+        # We don't expose the remote team's models, since they can't be used by other services in AgentOS.
+        return None
+
+    @property
+    def user_id(self) -> Optional[str]:
+        return None
+
+    @overload
+    async def arun(
+        self,
+        input: Union[str, List, Dict, Message, BaseModel, List[Message]],
+        *,
+        stream: Literal[False] = False,
+        user_id: Optional[str] = None,
+        session_id: Optional[str] = None,
+        session_state: Optional[Dict[str, Any]] = None,
+        audio: Optional[Sequence[Audio]] = None,
+        images: Optional[Sequence[Image]] = None,
+        videos: Optional[Sequence[Video]] = None,
+        files: Optional[Sequence[File]] = None,
+        stream_events: Optional[bool] = None,
+        retries: Optional[int] = None,
+        knowledge_filters: Optional[Dict[str, Any]] = None,
+        add_history_to_context: Optional[bool] = None,
+        add_dependencies_to_context: Optional[bool] = None,
+        add_session_state_to_context: Optional[bool] = None,
+        dependencies: Optional[Dict[str, Any]] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        auth_token: Optional[str] = None,
+        **kwargs: Any,
+    ) -> TeamRunOutput: ...
+
+    @overload
+    def arun(
+        self,
+        input: Union[str, List, Dict, Message, BaseModel, List[Message]],
+        *,
+        stream: Literal[True] = True,
+        user_id: Optional[str] = None,
+        session_id: Optional[str] = None,
+        audio: Optional[Sequence[Audio]] = None,
+        images: Optional[Sequence[Image]] = None,
+        videos: Optional[Sequence[Video]] = None,
+        files: Optional[Sequence[File]] = None,
+        stream_events: Optional[bool] = None,
+        retries: Optional[int] = None,
+        knowledge_filters: Optional[Dict[str, Any]] = None,
+        add_history_to_context: Optional[bool] = None,
+        add_dependencies_to_context: Optional[bool] = None,
+        add_session_state_to_context: Optional[bool] = None,
+        dependencies: Optional[Dict[str, Any]] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        auth_token: Optional[str] = None,
+        **kwargs: Any,
+    ) -> AsyncIterator[TeamRunOutputEvent]: ...
+
+    def arun(  # type: ignore
+        self,
+        input: Union[str, List, Dict, Message, BaseModel, List[Message]],
+        *,
+        stream: Optional[bool] = None,
+        user_id: Optional[str] = None,
+        session_id: Optional[str] = None,
+        session_state: Optional[Dict[str, Any]] = None,
+        audio: Optional[Sequence[Audio]] = None,
+        images: Optional[Sequence[Image]] = None,
+        videos: Optional[Sequence[Video]] = None,
+        files: Optional[Sequence[File]] = None,
+        stream_events: Optional[bool] = None,
+        retries: Optional[int] = None,
+        knowledge_filters: Optional[Dict[str, Any]] = None,
+        add_history_to_context: Optional[bool] = None,
+        add_dependencies_to_context: Optional[bool] = None,
+        add_session_state_to_context: Optional[bool] = None,
+        dependencies: Optional[Dict[str, Any]] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        auth_token: Optional[str] = None,
+        **kwargs: Any,
+    ) -> Union[
+        TeamRunOutput,
+        AsyncIterator[RunOutputEvent],
+    ]:
+        validated_input = validate_input(input)
+        serialized_input = serialize_input(validated_input)
+        headers = self._get_auth_headers(auth_token)
+
+        if stream:
+            # Handle streaming response
+            return self.get_client().run_team_stream(  # type: ignore
+                team_id=self.team_id,
+                message=serialized_input,
+                session_id=session_id,
+                user_id=user_id,
+                audio=audio,
+                images=images,
+                videos=videos,
+                files=files,
+                session_state=session_state,
+                stream_events=stream_events,
+                retries=retries,
+                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,
+                headers=headers,
+                **kwargs,
+            )
+        else:
+            return self.get_client().run_team(  # type: ignore
+                team_id=self.team_id,
+                message=serialized_input,
+                session_id=session_id,
+                user_id=user_id,
+                audio=audio,
+                images=images,
+                videos=videos,
+                files=files,
+                session_state=session_state,
+                stream_events=stream_events,
+                retries=retries,
+                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,
+                headers=headers,
+                **kwargs,
+            )
+
+    async def cancel_run(self, run_id: str, auth_token: Optional[str] = None) -> bool:
+        """Cancel a running team execution.
+
+        Args:
+            run_id (str): The run_id to cancel.
+            auth_token: Optional JWT token for authentication.
+
+        Returns:
+            bool: True if the run was found and marked for cancellation, False otherwise.
+        """
+        headers = self._get_auth_headers(auth_token)
+        try:
+            await self.get_client().cancel_team_run(
+                team_id=self.team_id,
+                run_id=run_id,
+                headers=headers,
+            )
+            return True
+        except Exception:
+            return False

agno/team/team.py

@@ -103,11 +103,12 @@ from agno.utils.agent import (
     set_session_name_util,
     store_media_util,
     update_session_state_util,
+    validate_input,
     validate_media_object_id,
     wait_for_open_threads,
     wait_for_thread_tasks_stream,
 )
-from agno.utils.common import is_typed_dict, validate_typed_dict
+from agno.utils.common import is_typed_dict
 from agno.utils.events import (
     add_team_error_event,
     create_team_parser_model_response_completed_event,
@@ -794,56 +795,6 @@ class Team:
         if telemetry_env is not None:
             self.telemetry = telemetry_env.lower() == "true"
 
-    def _validate_input(
-        self, input: Union[str, List, Dict, Message, BaseModel]
-    ) -> Union[str, List, Dict, Message, BaseModel]:
-        """Parse and validate input against input_schema if provided, otherwise return input as-is"""
-        if self.input_schema is None:
-            return input  # Return input unchanged if no schema is set
-
-        # Handle Message objects - extract content
-        if isinstance(input, Message):
-            input = input.content  # type: ignore
-
-        # If input is a string, convert it to a dict
-        if isinstance(input, str):
-            import json
-
-            try:
-                input = json.loads(input)
-            except Exception as e:
-                raise ValueError(f"Failed to parse input. Is it a valid JSON string?: {e}")
-
-        # Case 1: Message is already a BaseModel instance
-        if isinstance(input, BaseModel):
-            if isinstance(input, self.input_schema):
-                try:
-                    return input
-                except Exception as e:
-                    raise ValueError(f"BaseModel validation failed: {str(e)}")
-            else:
-                # Different BaseModel types
-                raise ValueError(f"Expected {self.input_schema.__name__} but got {type(input).__name__}")
-
-        # Case 2: Message is a dict
-        elif isinstance(input, dict):
-            try:
-                # Check if the schema is a TypedDict
-                if is_typed_dict(self.input_schema):
-                    validated_dict = validate_typed_dict(input, self.input_schema)
-                    return validated_dict
-                else:
-                    validated_model = self.input_schema(**input)
-                    return validated_model
-            except Exception as e:
-                raise ValueError(f"Failed to parse dict into {self.input_schema.__name__}: {str(e)}")
-
-        # Case 3: Other types not supported for structured input
-        else:
-            raise ValueError(
-                f"Cannot validate {type(input)} against input_schema. Expected dict or {self.input_schema.__name__} instance."
-            )
-
     def _initialize_member(self, member: Union["Team", Agent], debug_mode: Optional[bool] = None) -> None:
         # Set debug mode for all members
         if debug_mode:
@@ -2077,7 +2028,7 @@ class Team:
                     background_tasks: BackgroundTasks = background_tasks  # type: ignore
 
                 # Validate input against input_schema if provided
-                validated_input = self._validate_input(input)
+                validated_input = validate_input(input, self.input_schema)
 
                 # Normalise hook & guardails
                 if not self._hooks_normalised:
@@ -2275,6 +2226,22 @@ class Team:
                     return generator_wrapper(cancelled_run_error)  # type: ignore
                 else:
                     return run_response
+            except KeyboardInterrupt:
+                # Handle KeyboardInterrupt - stop retries immediately
+                run_response.status = RunStatus.cancelled
+                run_response.content = "Operation cancelled by user"
+                if stream:
+                    cancelled_run_error = handle_event(
+                        create_team_run_cancelled_event(
+                            from_run_response=run_response, reason="Operation cancelled by user"
+                        ),
+                        run_response,
+                        events_to_skip=self.events_to_skip,
+                        store_events=self.store_events,
+                    )
+                    return generator_wrapper(cancelled_run_error)  # type: ignore
+                else:
+                    return run_response
             except (InputCheckError, OutputCheckError) as e:
                 run_response.status = RunStatus.error
 
@@ -3139,7 +3106,7 @@ class Team:
             background_tasks: BackgroundTasks = background_tasks  # type: ignore
 
         # Validate input against input_schema if provided
-        validated_input = self._validate_input(input)
+        validated_input = validate_input(input, self.input_schema)
 
         # Normalise hook & guardails
         if not self._hooks_normalised:
@@ -5416,6 +5383,10 @@ class Team:
                             system_message_content += f"{indent * ' '}    - {_tool.name}\n"
                         elif callable(_tool):
                             system_message_content += f"{indent * ' '}    - {_tool.__name__}\n"
+                        elif isinstance(_tool, dict) and "name" in _tool and _tool.get("name") is not None:
+                            system_message_content += f"{indent * ' '}    - {_tool['name']}\n"
+                        else:
+                            system_message_content += f"{indent * ' '}    - {str(_tool)}\n"
 
         return system_message_content
 
@@ -7297,7 +7268,7 @@ class Team:
 
             # 7. Add member-level history for the member if enabled (because we won't load the session for the member, so history won't be loaded automatically)
             history = None
-            if member_agent.add_history_to_context:
+            if hasattr(member_agent, "add_history_to_context") and member_agent.add_history_to_context:
                 history = self._get_history_for_member_agent(session, member_agent)
                 if history:
                     if isinstance(member_agent_task, str):

agno/tracing/exporter.py

@@ -10,6 +10,7 @@ from opentelemetry.sdk.trace import ReadableSpan  # type: ignore
 from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult  # type: ignore
 
 from agno.db.base import AsyncBaseDb, BaseDb
+from agno.remote.base import RemoteDb
 from agno.tracing.schemas import Span, create_trace_from_spans
 from agno.utils.log import logger
 
@@ -17,7 +18,7 @@ from agno.utils.log import logger
 class DatabaseSpanExporter(SpanExporter):
     """Custom OpenTelemetry SpanExporter that writes to Agno database"""
 
-    def __init__(self, db: Union[BaseDb, AsyncBaseDb]):
+    def __init__(self, db: Union[BaseDb, AsyncBaseDb, RemoteDb]):
         """
         Initialize the DatabaseSpanExporter.
 
@@ -71,7 +72,10 @@ class DatabaseSpanExporter(SpanExporter):
                 spans_by_trace[converted_span.trace_id].append(converted_span)
 
             # Handle async DB
-            if isinstance(self.db, AsyncBaseDb):
+            if isinstance(self.db, RemoteDb):
+                # Skipping remote database because it handles its own tracing
+                pass
+            elif isinstance(self.db, AsyncBaseDb):
                 self._export_async(spans_by_trace)
             else:
                 # Synchronous database
@@ -90,10 +94,10 @@ class DatabaseSpanExporter(SpanExporter):
                 # Create trace record (aggregate of all spans)
                 trace = create_trace_from_spans(spans)
                 if trace:
-                    self.db.upsert_trace(trace)
+                    self.db.upsert_trace(trace)  # type: ignore
 
                 # Create span records
-                self.db.create_spans(spans)
+                self.db.create_spans(spans)  # type: ignore
 
         except Exception as e:
             logger.error(f"Failed to export sync traces: {e}", exc_info=True)
@@ -124,12 +128,12 @@ class DatabaseSpanExporter(SpanExporter):
                 # Create trace record (aggregate of all spans)
                 trace = create_trace_from_spans(spans)
                 if trace:
-                    create_trace_result = self.db.upsert_trace(trace)
+                    create_trace_result = self.db.upsert_trace(trace)  # type: ignore
                     if create_trace_result is not None:
                         await create_trace_result
 
                 # Create span records
-                create_spans_result = self.db.create_spans(spans)
+                create_spans_result = self.db.create_spans(spans)  # type: ignore
                 if create_spans_result is not None:
                     await create_spans_result
 

agno/tracing/setup.py

@@ -5,6 +5,7 @@ Setup helper functions for configuring Agno tracing.
 from typing import Union
 
 from agno.db.base import AsyncBaseDb, BaseDb
+from agno.remote.base import RemoteDb
 from agno.tracing.exporter import DatabaseSpanExporter
 from agno.utils.log import logger
 
@@ -20,7 +21,7 @@ except ImportError:
 
 
 def setup_tracing(
-    db: Union[BaseDb, AsyncBaseDb],
+    db: Union[BaseDb, AsyncBaseDb, RemoteDb],
     batch_processing: bool = False,
     max_queue_size: int = 2048,
     max_export_batch_size: int = 512,

agno/utils/agent.py

@@ -1,5 +1,7 @@
 from asyncio import Future, Task
-from typing import TYPE_CHECKING, Any, AsyncIterator, Callable, Dict, Iterator, List, Optional, Sequence, Union
+from typing import TYPE_CHECKING, Any, AsyncIterator, Callable, Dict, Iterator, List, Optional, Sequence, Type, Union
+
+from pydantic import BaseModel
 
 from agno.media import Audio, File, Image, Video
 from agno.models.message import Message
@@ -10,6 +12,7 @@ from agno.run.agent import RunEvent, RunInput, RunOutput, RunOutputEvent
 from agno.run.team import RunOutputEvent as TeamRunOutputEvent
 from agno.run.team import TeamRunOutput
 from agno.session import AgentSession, TeamSession, WorkflowSession
+from agno.utils.common import is_typed_dict, validate_typed_dict
 from agno.utils.events import (
     create_memory_update_completed_event,
     create_memory_update_started_event,
@@ -936,3 +939,57 @@ async def aexecute_system_message(
         return await system_message(**system_message_args)
     else:
         return system_message(**system_message_args)
+
+
+def validate_input(
+    input: Union[str, List, Dict, Message, BaseModel], input_schema: Optional[Type[BaseModel]] = None
+) -> Union[str, List, Dict, Message, BaseModel]:
+    """Parse and validate input against input_schema if provided, otherwise return input as-is"""
+    if input_schema is None:
+        return input  # Return input unchanged if no schema is set
+
+    if input is None:
+        raise ValueError("Input required when input_schema is set")
+
+    # Handle Message objects - extract content
+    if isinstance(input, Message):
+        input = input.content  # type: ignore
+
+    # If input is a string, convert it to a dict
+    if isinstance(input, str):
+        import json
+
+        try:
+            input = json.loads(input)
+        except Exception as e:
+            raise ValueError(f"Failed to parse input. Is it a valid JSON string?: {e}")
+
+    # Case 1: Message is already a BaseModel instance
+    if isinstance(input, BaseModel):
+        if isinstance(input, input_schema):
+            try:
+                return input
+            except Exception as e:
+                raise ValueError(f"BaseModel validation failed: {str(e)}")
+        else:
+            # Different BaseModel types
+            raise ValueError(f"Expected {input_schema.__name__} but got {type(input).__name__}")
+
+    # Case 2: Message is a dict
+    elif isinstance(input, dict):
+        try:
+            # Check if the schema is a TypedDict
+            if is_typed_dict(input_schema):
+                validated_dict = validate_typed_dict(input, input_schema)
+                return validated_dict
+            else:
+                validated_model = input_schema(**input)
+                return validated_model
+        except Exception as e:
+            raise ValueError(f"Failed to parse dict into {input_schema.__name__}: {str(e)}")
+
+    # Case 3: Other types not supported for structured input
+    else:
+        raise ValueError(
+            f"Cannot validate {type(input)} against input_schema. Expected dict or {input_schema.__name__} instance."
+        )