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

agno/agent/agent.py

@@ -61,6 +61,9 @@ from agno.run.agent import (
     RunOutput,
     RunOutputEvent,
 )
+from agno.run.cancel import (
+    acancel_run as acancel_run_global,
+)
 from agno.run.cancel import (
     acleanup_run,
     araise_if_cancelled,
@@ -77,6 +80,7 @@ from agno.run.requirement import RunRequirement
 from agno.run.team import TeamRunOutputEvent
 from agno.session import AgentSession, SessionSummaryManager, TeamSession, WorkflowSession
 from agno.session.summary import SessionSummary
+from agno.skills import Skills
 from agno.tools import Toolkit
 from agno.tools.function import Function
 from agno.utils.agent import (
@@ -264,6 +268,10 @@ class Agent:
     knowledge_retriever: Optional[Callable[..., Optional[List[Union[Dict, str]]]]] = None
     references_format: Literal["json", "yaml"] = "json"
 
+    # --- Skills ---
+    # Skills provide structured instructions, reference docs, and scripts for agents
+    skills: Optional[Skills] = None
+
     # --- Agent Tools ---
     # A list of tools provided to the Model.
     # Tools are functions the model may generate JSON inputs for.
@@ -487,6 +495,7 @@ class Agent:
         add_knowledge_to_context: bool = False,
         knowledge_retriever: Optional[Callable[..., Optional[List[Union[Dict, str]]]]] = None,
         references_format: Literal["json", "yaml"] = "json",
+        skills: Optional[Skills] = None,
         metadata: Optional[Dict[str, Any]] = None,
         tools: Optional[Sequence[Union[Toolkit, Callable, Function, Dict]]] = None,
         tool_call_limit: Optional[int] = None,
@@ -610,6 +619,8 @@ class Agent:
         self.knowledge_retriever = knowledge_retriever
         self.references_format = references_format
 
+        self.skills = skills
+
         self.metadata = metadata
 
         self.tools = list(tools) if tools else []
@@ -2022,6 +2033,7 @@ class Agent:
                         run_response=run_response,
                         run_context=run_context,
                         session=agent_session,
+                        async_mode=True,
                     )
 
                     # 6. Prepare run messages
@@ -2369,6 +2381,7 @@ class Agent:
                         run_response=run_response,
                         run_context=run_context,
                         session=agent_session,
+                        async_mode=True,
                     )
 
                     # 6. Prepare run messages
@@ -3979,6 +3992,7 @@ class Agent:
                         run_response=run_response,
                         run_context=run_context,
                         session=agent_session,
+                        async_mode=True,
                     )
 
                     # 6. Prepare run messages
@@ -4285,6 +4299,7 @@ class Agent:
                         run_response=run_response,
                         run_context=run_context,
                         session=agent_session,
+                        async_mode=True,
                     )
 
                     # 6. Prepare run messages
@@ -6396,6 +6411,10 @@ class Agent:
             if self.update_knowledge:
                 agent_tools.append(self.add_to_knowledge)
 
+        # Add tools for accessing skills
+        if self.skills is not None:
+            agent_tools.extend(self.skills.get_tools())
+
         return agent_tools
 
     async def aget_tools(
@@ -6489,6 +6508,10 @@ class Agent:
             if self.update_knowledge:
                 agent_tools.append(self.add_to_knowledge)
 
+        # Add tools for accessing skills
+        if self.skills is not None:
+            agent_tools.extend(self.skills.get_tools())
+
         return agent_tools
 
     def _determine_tools_for_model(
@@ -6498,6 +6521,7 @@ class Agent:
         run_response: RunOutput,
         run_context: RunContext,
         session: AgentSession,
+        async_mode: bool = False,
     ) -> List[Union[Function, dict]]:
         _function_names = []
         _functions: List[Union[Function, dict]] = []
@@ -6528,7 +6552,8 @@ class Agent:
 
                 elif isinstance(tool, Toolkit):
                     # For each function in the toolkit and process entrypoint
-                    for name, _func in tool.functions.items():
+                    toolkit_functions = tool.get_async_functions() if async_mode else tool.get_functions()
+                    for name, _func in toolkit_functions.items():
                         if name in _function_names:
                             continue
                         _function_names.append(name)
@@ -6758,6 +6783,18 @@ class Agent:
         """
         return cancel_run_global(run_id)
 
+    @staticmethod
+    async def acancel_run(run_id: str) -> bool:
+        """Cancel a running agent execution (async version).
+
+        Args:
+            run_id (str): The run_id to cancel.
+
+        Returns:
+            bool: True if the run was found and marked for cancellation, False otherwise.
+        """
+        return await acancel_run_global(run_id)
+
     # -*- Session Database Functions
     def _read_session(
         self, session_id: str, session_type: SessionType = SessionType.AGENT
@@ -7171,7 +7208,6 @@ class Agent:
         """
         if self._has_async_db():
             raise ValueError("Async database not supported for save_session")
-
         # If the agent is a member of a team, do not save the session to the database
         if (
             self.db is not None
@@ -7937,6 +7973,11 @@ class Agent:
         # 3.3.8 Then add additional context
         if self.additional_context is not None:
             system_message_content += f"{self.additional_context}\n"
+        # 3.3.8.1 Then add skills to the system prompt
+        if self.skills is not None:
+            skills_snippet = self.skills.get_system_prompt_snippet()
+            if skills_snippet:
+                system_message_content += f"\n{skills_snippet}\n"
         # 3.3.9 Then add memories to the system prompt
         if self.add_memories_to_context:
             _memory_manager_not_set = False
@@ -8281,6 +8322,11 @@ class Agent:
         # 3.3.8 Then add additional context
         if self.additional_context is not None:
             system_message_content += f"{self.additional_context}\n"
+        # 3.3.8.1 Then add skills to the system prompt
+        if self.skills is not None:
+            skills_snippet = self.skills.get_system_prompt_snippet()
+            if skills_snippet:
+                system_message_content += f"\n{skills_snippet}\n"
         # 3.3.9 Then add memories to the system prompt
         if self.add_memories_to_context:
             _memory_manager_not_set = False

agno/agent/remote.py

@@ -1,5 +1,4 @@
 import json
-import time
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, AsyncIterator, Dict, List, Literal, Optional, Sequence, Tuple, Union, overload
 
@@ -29,19 +28,25 @@ class RemoteAgent(BaseRemote):
         base_url: str,
         agent_id: str,
         timeout: float = 60.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 RemoteAgent for remote execution.
 
-        For remote execution, provide base_url and agent_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")
-            agent_id: ID of remote agent
+            base_url: Base URL for remote instance (e.g., "http://localhost:7777")
+            agent_id: ID of remote agent on the remote server
             timeout: Request timeout in seconds (default: 60)
+            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.agent_id = agent_id
         self._cached_agent_config = None
 
@@ -50,14 +55,48 @@ class RemoteAgent(BaseRemote):
         return self.agent_id
 
     async def get_agent_config(self) -> "AgentResponse":
-        """Get the agent config from remote (always fetches fresh)."""
-        return await self.client.aget_agent(self.agent_id)
+        """
+        Get the agent config from remote.
+
+        For A2A protocol, returns a minimal AgentResponse since A2A servers
+        don't expose the same config endpoints as AgentOS. For AgentOS, always fetches fresh config.
+        """
+        from agno.os.routers.agents.schema import AgentResponse
+
+        if self.a2a_client:
+            from agno.client.a2a.schemas import AgentCard
+
+            agent_card: Optional[AgentCard] = await self.a2a_client.aget_agent_card()
+
+            return AgentResponse(
+                id=self.agent_id,
+                name=agent_card.name if agent_card else self.agent_id,
+                description=agent_card.description if agent_card else f"A2A agent: {self.agent_id}",
+            )
+
+        return await self.agentos_client.aget_agent(self.agent_id)  # type: ignore
 
     @property
-    def _agent_config(self) -> "AgentResponse":
-        """Get the agent config from remote, cached with TTL."""
+    def _agent_config(self) -> Optional["AgentResponse"]:
+        """
+        Get the agent config from remote, cached with TTL.
+        Returns None for A2A protocol since A2A servers don't expose agent config endpoints.
+        """
+        import time
+
         from agno.os.routers.agents.schema import AgentResponse
 
+        if self.a2a_client:
+            from agno.client.a2a.schemas import AgentCard
+
+            agent_card: Optional[AgentCard] = self.a2a_client.get_agent_card()
+
+            return AgentResponse(
+                id=self.agent_id,
+                name=agent_card.name if agent_card else self.agent_id,
+                description=agent_card.description if agent_card else f"A2A agent: {self.agent_id}",
+            )
+
         current_time = time.time()
 
         # Check if cache is valid
@@ -67,15 +106,24 @@ class RemoteAgent(BaseRemote):
                 return config
 
         # Fetch fresh config
-        config: AgentResponse = self.client.get_agent(self.agent_id)  # type: ignore
+        config: AgentResponse = self.agentos_client.get_agent(self.agent_id)  # type: ignore
         self._cached_agent_config = (config, current_time)
         return config
 
-    def refresh_config(self) -> "AgentResponse":
-        """Force refresh the cached agent config."""
+    async def refresh_config(self) -> Optional["AgentResponse"]:
+        """
+        Force refresh the cached agent config.
+        Returns None for A2A protocol.
+        """
+        import time
+
         from agno.os.routers.agents.schema import AgentResponse
 
-        config: AgentResponse = self.client.get_agent(self.agent_id)
+        if self.a2a_client:
+            self._cached_agent_config = None
+            return None
+
+        config: AgentResponse = await self.agentos_client.aget_agent(self.agent_id)  # type: ignore
         self._cached_agent_config = (config, time.time())
         return config
 
@@ -91,7 +139,6 @@ class RemoteAgent(BaseRemote):
             return self._agent_config.description
         return ""
 
-    @property
     def role(self) -> Optional[str]:
         if self._agent_config is not None:
             return self._agent_config.role
@@ -109,23 +156,27 @@ class RemoteAgent(BaseRemote):
 
     @property
     def db(self) -> Optional[RemoteDb]:
-        if self._agent_config is not None and self._agent_config.db_id is not None:
+        if (
+            self.agentos_client
+            and self._config
+            and self._agent_config is not None
+            and self._agent_config.db_id is not None
+        ):
             return RemoteDb.from_config(
                 db_id=self._agent_config.db_id,
-                client=self.client,
+                client=self.agentos_client,
                 config=self._config,
             )
         return None
 
     @property
     def knowledge(self) -> Optional[RemoteKnowledge]:
-        """Whether the agent has knowledge enabled."""
-        if self._agent_config is not None and self._agent_config.knowledge is not None:
+        if self.agentos_client and self._agent_config is not None and self._agent_config.knowledge is not None:
             return RemoteKnowledge(
-                client=self.client,
+                client=self.agentos_client,
                 contents_db=RemoteDb(
                     id=self._agent_config.knowledge.get("db_id"),  # type: ignore
-                    client=self.client,
+                    client=self.agentos_client,
                     knowledge_table_name=self._agent_config.knowledge.get("knowledge_table"),
                 )
                 if self._agent_config.knowledge.get("db_id") is not None
@@ -139,7 +190,7 @@ class RemoteAgent(BaseRemote):
         return None
 
     async def aget_tools(self, **kwargs: Any) -> List[Dict]:
-        if self._agent_config.tools is not None:
+        if self._agent_config is not None and self._agent_config.tools is not None:
             return json.loads(self._agent_config.tools["tools"])
         return []
 
@@ -222,52 +273,156 @@ class RemoteAgent(BaseRemote):
         serialized_input = serialize_input(validated_input)
         headers = self._get_auth_headers(auth_token)
 
-        if stream:
-            # Handle streaming response
-            return self.get_client().run_agent_stream(
-                agent_id=self.agent_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_agent_stream(
+                    agent_id=self.agent_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_agent(  # type: ignore
+                    agent_id=self.agent_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_agent(  # type: ignore
-                agent_id=self.agent_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[RunOutput, AsyncIterator[RunOutputEvent]]:
+        """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:
+            RunOutput for non-streaming, AsyncIterator[RunOutputEvent] for streaming
+        """
+        if not self.a2a_client:
+            raise ValueError("A2A client not available")
+        from agno.client.a2a.utils import map_stream_events_to_run_events
+
+        if stream:
+            # Return async generator for streaming
+            event_stream = self.a2a_client.stream_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_stream_events_to_run_events(event_stream, agent_id=self.agent_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]],
+    ) -> RunOutput:
+        """Send a non-streaming A2A message and convert response to RunOutput."""
+        if not self.a2a_client:
+            raise ValueError("A2A client not available")
+        from agno.client.a2a.utils import map_task_result_to_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_run_output(task_result, agent_id=self.agent_id, user_id=user_id)
+
     @overload
     async def acontinue_run(
         self,
@@ -307,29 +462,33 @@ class RemoteAgent(BaseRemote):
     ]:
         headers = self._get_auth_headers(auth_token)
 
-        if stream:
-            # Handle streaming response
-            return self.get_client().continue_agent_run_stream(  # type: ignore
-                agent_id=self.agent_id,
-                run_id=run_id,
-                user_id=user_id,
-                session_id=session_id,
-                tools=updated_tools,
-                headers=headers,
-                **kwargs,
-            )
+        if self.agentos_client:
+            if stream:
+                # Handle streaming response
+                return self.agentos_client.continue_agent_run_stream(  # type: ignore
+                    agent_id=self.agent_id,
+                    run_id=run_id,
+                    user_id=user_id,
+                    session_id=session_id,
+                    tools=updated_tools,
+                    headers=headers,
+                    **kwargs,
+                )
+            else:
+                return self.agentos_client.continue_agent_run(  # type: ignore
+                    agent_id=self.agent_id,
+                    run_id=run_id,
+                    tools=updated_tools,
+                    user_id=user_id,
+                    session_id=session_id,
+                    headers=headers,
+                    **kwargs,
+                )
+
         else:
-            return self.get_client().continue_agent_run(  # type: ignore
-                agent_id=self.agent_id,
-                run_id=run_id,
-                tools=updated_tools,
-                user_id=user_id,
-                session_id=session_id,
-                headers=headers,
-                **kwargs,
-            )
+            raise ValueError("No client available")
 
-    async def cancel_run(self, run_id: str, auth_token: Optional[str] = None) -> bool:
+    async def acancel_run(self, run_id: str, auth_token: Optional[str] = None) -> bool:
         """Cancel a running agent execution.
 
         Args:
@@ -340,8 +499,10 @@ class RemoteAgent(BaseRemote):
             bool: True if the run was successfully cancelled, False otherwise.
         """
         headers = self._get_auth_headers(auth_token)
+        if not self.agentos_client:
+            raise ValueError("AgentOS client not available")
         try:
-            await self.get_client().cancel_agent_run(
+            await self.agentos_client.cancel_agent_run(
                 agent_id=self.agent_id,
                 run_id=run_id,
                 headers=headers,

agno/client/a2a/__init__.py

@@ -0,0 +1,10 @@
+from agno.client.a2a.client import A2AClient
+from agno.client.a2a.schemas import AgentCard, Artifact, StreamEvent, TaskResult
+
+__all__ = [
+    "A2AClient",
+    "AgentCard",
+    "Artifact",
+    "StreamEvent",
+    "TaskResult",
+]