agno 2.3.21__py3-none-any.whl → 2.3.22__py3-none-any.whl

agno/team/remote.py

@@ -1,5 +1,4 @@
 import json
-import time
 from typing import TYPE_CHECKING, Any, AsyncIterator, Dict, List, Literal, Optional, Sequence, Tuple, Union, overload
 
 from pydantic import BaseModel
@@ -27,19 +26,25 @@ class RemoteTeam(BaseRemote):
         base_url: str,
         team_id: str,
         timeout: float = 300.0,
+        protocol: Literal["agentos", "a2a"] = "agentos",
+        a2a_protocol: Literal["json-rpc", "rest"] = "rest",
         config_ttl: float = 300.0,
     ):
-        """Initialize AgentOSRunner for local or remote execution.
+        """Initialize RemoteTeam for remote execution.
 
-        For remote execution, provide base_url and team_id.
+        Supports two protocols:
+        - "agentos": Agno's proprietary AgentOS REST API (default)
+        - "a2a": A2A (Agent-to-Agent) protocol for cross-framework communication
 
         Args:
-            base_url: Base URL for remote AgentOS instance (e.g., "http://localhost:7777")
-            team_id: ID of remote team
+            base_url: Base URL for remote instance (e.g., "http://localhost:7777")
+            team_id: ID of remote team on the remote server
             timeout: Request timeout in seconds (default: 300)
+            protocol: Communication protocol - "agentos" (default) or "a2a"
+            a2a_protocol: For A2A protocol only - Whether to use JSON-RPC or REST protocol.
             config_ttl: Time-to-live for cached config in seconds (default: 300)
         """
-        super().__init__(base_url, timeout, config_ttl)
+        super().__init__(base_url, timeout, protocol, a2a_protocol, config_ttl)
         self.team_id = team_id
         self._cached_team_config = None
 
@@ -48,48 +53,95 @@ class RemoteTeam(BaseRemote):
         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)
+        """
+        Get the team config from remote.
+
+        - For AgentOS protocol, always fetches fresh config from the remote.
+        - For A2A protocol, returns a minimal TeamResponse because A2A servers
+          do not expose detailed config endpoints.
+
+        Returns:
+            TeamResponse: The remote team configuration.
+        """
+        from agno.os.routers.teams.schema import TeamResponse
+
+        if self.a2a_client:
+            from agno.client.a2a.schemas import AgentCard
+
+            agent_card: Optional[AgentCard] = await self.a2a_client.aget_agent_card()
+
+            return TeamResponse(
+                id=self.team_id,
+                name=agent_card.name if agent_card else self.team_id,
+                description=agent_card.description if agent_card else f"A2A team: {self.team_id}",
+            )
+
+        # Fetch fresh config from remote for AgentOS
+        return await self.agentos_client.aget_team(self.team_id)  # type: ignore
 
     @property
-    def _team_config(self) -> "TeamResponse":
-        """Get the team config from remote, cached with TTL."""
+    def _team_config(self) -> Optional["TeamResponse"]:
+        """
+        Get the team config from remote, cached with TTL.
+
+        - Returns None for A2A protocol (no config available).
+        - For AgentOS protocol, uses TTL caching for efficiency.
+        """
+        import time
+
         from agno.os.routers.teams.schema import TeamResponse
 
-        current_time = time.time()
+        if self.a2a_client:
+            from agno.client.a2a.schemas import AgentCard
+
+            agent_card: Optional[AgentCard] = self.a2a_client.get_agent_card()
 
-        # Check if cache is valid
+            return TeamResponse(
+                id=self.team_id,
+                name=agent_card.name if agent_card else self.team_id,
+                description=agent_card.description if agent_card else f"A2A team: {self.team_id}",
+            )
+
+        current_time = time.time()
         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
+        # Fetch fresh config and update cache
+        config: TeamResponse = self.agentos_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."""
+    async def refresh_config(self) -> Optional["TeamResponse"]:
+        """
+        Force refresh the cached team config from remote.
+        """
+        import time
+
         from agno.os.routers.teams.schema import TeamResponse
 
-        config: TeamResponse = self.client.get_team(self.team_id)  # type: ignore
+        if self.a2a_client:
+            return None
+
+        config: TeamResponse = await self.agentos_client.aget_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
+        config = self._team_config
+        if config is not None:
+            return config.name
+        return self.team_id
 
     @property
     def description(self) -> Optional[str]:
-        if self._team_config is not None:
-            return self._team_config.description
-        return None
+        config = self._team_config
+        if config is not None:
+            return config.description
+        return ""
 
-    @property
     def role(self) -> Optional[str]:
         if self._team_config is not None:
             return self._team_config.role
@@ -107,10 +159,15 @@ class RemoteTeam(BaseRemote):
 
     @property
     def db(self) -> Optional[RemoteDb]:
-        if self._team_config is not None and self._team_config.db_id is not None:
+        if (
+            self.agentos_client
+            and self._config
+            and 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,
+                client=self.agentos_client,
                 config=self._config,
             )
         return None
@@ -118,12 +175,12 @@ class RemoteTeam(BaseRemote):
     @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:
+        if self.agentos_client and self._team_config is not None and self._team_config.knowledge is not None:
             return RemoteKnowledge(
-                client=self.client,
+                client=self.agentos_client,
                 contents_db=RemoteDb(
                     id=self._team_config.knowledge.get("db_id"),  # type: ignore
-                    client=self.client,
+                    client=self.agentos_client,
                     knowledge_table_name=self._team_config.knowledge.get("knowledge_table"),
                 )
                 if self._team_config.knowledge.get("db_id") is not None
@@ -219,52 +276,155 @@ class RemoteTeam(BaseRemote):
         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,
+        # A2A protocol path
+        if self.a2a_client:
+            return self._arun_a2a(  # type: ignore[return-value]
                 message=serialized_input,
-                session_id=session_id,
+                stream=stream or False,
                 user_id=user_id,
+                context_id=session_id,  # Map session_id → context_id for A2A
                 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,
             )
+
+        # AgentOS protocol path (default)
+        if self.agentos_client:
+            if stream:
+                # Handle streaming response
+                return self.agentos_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.agentos_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,
+                )
         else:
-            return self.get_client().run_team(  # type: ignore
-                team_id=self.team_id,
-                message=serialized_input,
-                session_id=session_id,
+            raise ValueError("No client available")
+
+    def _arun_a2a(
+        self,
+        message: str,
+        stream: bool,
+        user_id: Optional[str],
+        context_id: Optional[str],
+        audio: Optional[Sequence[Audio]],
+        images: Optional[Sequence[Image]],
+        videos: Optional[Sequence[Video]],
+        files: Optional[Sequence[File]],
+        headers: Optional[Dict[str, str]],
+    ) -> Union[TeamRunOutput, AsyncIterator[TeamRunOutputEvent]]:
+        """Execute via A2A protocol.
+
+        Args:
+            message: Serialized message string
+            stream: Whether to stream the response
+            user_id: User identifier
+            context_id: Session/context ID (maps to session_id)
+            audio: Audio files to include
+            images: Images to include
+            videos: Videos to include
+            files: Files to include
+            headers: HTTP headers to include in the request (optional)
+        Returns:
+            TeamRunOutput for non-streaming, AsyncIterator[TeamRunOutputEvent] for streaming
+        """
+        from agno.client.a2a.utils import map_stream_events_to_team_run_events
+
+        if not self.a2a_client:
+            raise ValueError("A2A client not available")
+        if stream:
+            # Return async generator for streaming
+            event_stream = self.a2a_client.stream_message(
+                message=message,
+                context_id=context_id,
                 user_id=user_id,
+                audio=list(audio) if audio else None,
+                images=list(images) if images else None,
+                videos=list(videos) if videos else None,
+                files=list(files) if files else None,
+                headers=headers,
+            )
+            return map_stream_events_to_team_run_events(event_stream, team_id=self.team_id)
+        else:
+            # Return coroutine for non-streaming
+            return self._arun_a2a_send(  # type: ignore[return-value]
+                message=message,
+                user_id=user_id,
+                context_id=context_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 _arun_a2a_send(
+        self,
+        message: str,
+        user_id: Optional[str],
+        context_id: Optional[str],
+        audio: Optional[Sequence[Audio]],
+        images: Optional[Sequence[Image]],
+        videos: Optional[Sequence[Video]],
+        files: Optional[Sequence[File]],
+        headers: Optional[Dict[str, str]],
+    ) -> TeamRunOutput:
+        """Send a non-streaming A2A message and convert response to TeamRunOutput."""
+        if not self.a2a_client:
+            raise ValueError("A2A client not available")
+        from agno.client.a2a.utils import map_task_result_to_team_run_output
+
+        task_result = await self.a2a_client.send_message(
+            message=message,
+            context_id=context_id,
+            user_id=user_id,
+            images=list(images) if images else None,
+            audio=list(audio) if audio else None,
+            videos=list(videos) if videos else None,
+            files=list(files) if files else None,
+            headers=headers,
+        )
+        return map_task_result_to_team_run_output(task_result, team_id=self.team_id, user_id=user_id)
+
     async def cancel_run(self, run_id: str, auth_token: Optional[str] = None) -> bool:
         """Cancel a running team execution.
 
@@ -277,7 +437,7 @@ class RemoteTeam(BaseRemote):
         """
         headers = self._get_auth_headers(auth_token)
         try:
-            await self.get_client().cancel_team_run(
+            await self.agentos_client.cancel_team_run(  # type: ignore
                 team_id=self.team_id,
                 run_id=run_id,
                 headers=headers,

agno/team/team.py

@@ -5135,7 +5135,17 @@ class Team:
 
             try:
                 sig = signature(value)
-                resolved_value = value(agent=self) if "agent" in sig.parameters else value()
+
+                # Build kwargs for the function
+                kwargs: Dict[str, Any] = {}
+                if "agent" in sig.parameters:
+                    kwargs["agent"] = self
+                if "team" in sig.parameters:
+                    kwargs["team"] = self
+                if "run_context" in sig.parameters:
+                    kwargs["run_context"] = run_context
+
+                resolved_value = value(**kwargs) if kwargs else value()
 
                 run_context.dependencies[key] = resolved_value
             except Exception as e:
@@ -5156,7 +5166,17 @@ class Team:
 
             try:
                 sig = signature(value)
-                resolved_value = value(team=self) if "team" in sig.parameters else value()
+
+                # Build kwargs for the function
+                kwargs: Dict[str, Any] = {}
+                if "agent" in sig.parameters:
+                    kwargs["agent"] = self
+                if "team" in sig.parameters:
+                    kwargs["team"] = self
+                if "run_context" in sig.parameters:
+                    kwargs["run_context"] = run_context
+
+                resolved_value = value(**kwargs) if kwargs else value()
 
                 if iscoroutine(resolved_value):
                     resolved_value = await resolved_value