agno 2.2.13__py3-none-any.whl → 2.4.3__py3-none-any.whl

agno/os/interfaces/a2a/utils.py

@@ -95,7 +95,6 @@ async def map_a2a_request_to_run_input(request_body: dict, stream: bool = True)
         ```json
         {
             "jsonrpc": "2.0",
-            "method": "message/send",
             "id": "id",
             "params": {
                 "message": {
@@ -110,7 +109,7 @@ async def map_a2a_request_to_run_input(request_body: dict, stream: bool = True)
 
     Returns:
         RunInput: The Agno RunInput
-        stream: Wheter we are in stream mode
+        stream: Whether we are in stream mode
     """
 
     # 1. Validate the request
@@ -325,7 +324,7 @@ async def stream_a2a_response(
                 final=False,
             )
             response = SendStreamingMessageSuccessResponse(id=request_id, result=status_event)
-            yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+            yield f"event: TaskStatusUpdateEvent\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         # 2. Send all content and secondary events
 
@@ -341,7 +340,7 @@ async def stream_a2a_response(
                 metadata={"agno_content_category": "content"},
             )
             response = SendStreamingMessageSuccessResponse(id=request_id, result=message)
-            yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+            yield f"event: Message\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         # Send tool call events
         elif isinstance(event, (ToolCallStartedEvent, TeamToolCallStartedEvent)):
@@ -361,7 +360,7 @@ async def stream_a2a_response(
                 metadata=metadata,
             )
             response = SendStreamingMessageSuccessResponse(id=request_id, result=status_event)
-            yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+            yield f"event: TaskStatusUpdateEvent\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         elif isinstance(event, (ToolCallCompletedEvent, TeamToolCallCompletedEvent)):
             metadata = {"agno_event_type": "tool_call_completed"}
@@ -380,7 +379,7 @@ async def stream_a2a_response(
                 metadata=metadata,
             )
             response = SendStreamingMessageSuccessResponse(id=request_id, result=status_event)
-            yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+            yield f"event: TaskStatusUpdateEvent\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         # Send reasoning events
         elif isinstance(event, (ReasoningStartedEvent, TeamReasoningStartedEvent)):
@@ -392,7 +391,7 @@ async def stream_a2a_response(
                 metadata={"agno_event_type": "reasoning_started"},
             )
             response = SendStreamingMessageSuccessResponse(id=request_id, result=status_event)
-            yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+            yield f"event: TaskStatusUpdateEvent\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         elif isinstance(event, (ReasoningStepEvent, TeamReasoningStepEvent)):
             if event.reasoning_content:
@@ -415,7 +414,7 @@ async def stream_a2a_response(
                     metadata={"agno_content_category": "reasoning", "agno_event_type": "reasoning_step"},
                 )
                 response = SendStreamingMessageSuccessResponse(id=request_id, result=reasoning_message)
-                yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+                yield f"event: Message\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         elif isinstance(event, (ReasoningCompletedEvent, TeamReasoningCompletedEvent)):
             status_event = TaskStatusUpdateEvent(
@@ -426,7 +425,7 @@ async def stream_a2a_response(
                 metadata={"agno_event_type": "reasoning_completed"},
             )
             response = SendStreamingMessageSuccessResponse(id=request_id, result=status_event)
-            yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+            yield f"event: TaskStatusUpdateEvent\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         # Send memory update events
         elif isinstance(event, (MemoryUpdateStartedEvent, TeamMemoryUpdateStartedEvent)):
@@ -438,7 +437,7 @@ async def stream_a2a_response(
                 metadata={"agno_event_type": "memory_update_started"},
             )
             response = SendStreamingMessageSuccessResponse(id=request_id, result=status_event)
-            yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+            yield f"event: TaskStatusUpdateEvent\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         elif isinstance(event, (MemoryUpdateCompletedEvent, TeamMemoryUpdateCompletedEvent)):
             status_event = TaskStatusUpdateEvent(
@@ -449,7 +448,7 @@ async def stream_a2a_response(
                 metadata={"agno_event_type": "memory_update_completed"},
             )
             response = SendStreamingMessageSuccessResponse(id=request_id, result=status_event)
-            yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+            yield f"event: TaskStatusUpdateEvent\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         # Send workflow events
         elif isinstance(event, WorkflowStepStartedEvent):
@@ -465,7 +464,7 @@ async def stream_a2a_response(
                 metadata=metadata,
             )
             response = SendStreamingMessageSuccessResponse(id=request_id, result=status_event)
-            yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+            yield f"event: TaskStatusUpdateEvent\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         elif isinstance(event, WorkflowStepCompletedEvent):
             metadata = {"agno_event_type": "workflow_step_completed"}
@@ -480,7 +479,7 @@ async def stream_a2a_response(
                 metadata=metadata,
             )
             response = SendStreamingMessageSuccessResponse(id=request_id, result=status_event)
-            yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+            yield f"event: TaskStatusUpdateEvent\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         elif isinstance(event, WorkflowStepErrorEvent):
             metadata = {"agno_event_type": "workflow_step_error"}
@@ -497,7 +496,7 @@ async def stream_a2a_response(
                 metadata=metadata,
             )
             response = SendStreamingMessageSuccessResponse(id=request_id, result=status_event)
-            yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+            yield f"event: TaskStatusUpdateEvent\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         # Send loop events
         elif isinstance(event, LoopExecutionStartedEvent):
@@ -515,7 +514,7 @@ async def stream_a2a_response(
                 metadata=metadata,
             )
             response = SendStreamingMessageSuccessResponse(id=request_id, result=status_event)
-            yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+            yield f"event: TaskStatusUpdateEvent\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         elif isinstance(event, LoopIterationStartedEvent):
             metadata = {"agno_event_type": "loop_iteration_started"}
@@ -534,7 +533,7 @@ async def stream_a2a_response(
                 metadata=metadata,
             )
             response = SendStreamingMessageSuccessResponse(id=request_id, result=status_event)
-            yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+            yield f"event: TaskStatusUpdateEvent\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         elif isinstance(event, LoopIterationCompletedEvent):
             metadata = {"agno_event_type": "loop_iteration_completed"}
@@ -553,7 +552,7 @@ async def stream_a2a_response(
                 metadata=metadata,
             )
             response = SendStreamingMessageSuccessResponse(id=request_id, result=status_event)
-            yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+            yield f"event: TaskStatusUpdateEvent\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         elif isinstance(event, LoopExecutionCompletedEvent):
             metadata = {"agno_event_type": "loop_execution_completed"}
@@ -570,7 +569,7 @@ async def stream_a2a_response(
                 metadata=metadata,
             )
             response = SendStreamingMessageSuccessResponse(id=request_id, result=status_event)
-            yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+            yield f"event: TaskStatusUpdateEvent\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         # Send parallel events
         elif isinstance(event, ParallelExecutionStartedEvent):
@@ -588,7 +587,7 @@ async def stream_a2a_response(
                 metadata=metadata,
             )
             response = SendStreamingMessageSuccessResponse(id=request_id, result=status_event)
-            yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+            yield f"event: TaskStatusUpdateEvent\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         elif isinstance(event, ParallelExecutionCompletedEvent):
             metadata = {"agno_event_type": "parallel_execution_completed"}
@@ -605,7 +604,7 @@ async def stream_a2a_response(
                 metadata=metadata,
             )
             response = SendStreamingMessageSuccessResponse(id=request_id, result=status_event)
-            yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+            yield f"event: TaskStatusUpdateEvent\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         # Send condition events
         elif isinstance(event, ConditionExecutionStartedEvent):
@@ -623,7 +622,7 @@ async def stream_a2a_response(
                 metadata=metadata,
             )
             response = SendStreamingMessageSuccessResponse(id=request_id, result=status_event)
-            yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+            yield f"event: TaskStatusUpdateEvent\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         elif isinstance(event, ConditionExecutionCompletedEvent):
             metadata = {"agno_event_type": "condition_execution_completed"}
@@ -642,7 +641,7 @@ async def stream_a2a_response(
                 metadata=metadata,
             )
             response = SendStreamingMessageSuccessResponse(id=request_id, result=status_event)
-            yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+            yield f"event: TaskStatusUpdateEvent\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         # Send router events
         elif isinstance(event, RouterExecutionStartedEvent):
@@ -660,7 +659,7 @@ async def stream_a2a_response(
                 metadata=metadata,
             )
             response = SendStreamingMessageSuccessResponse(id=request_id, result=status_event)
-            yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+            yield f"event: TaskStatusUpdateEvent\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         elif isinstance(event, RouterExecutionCompletedEvent):
             metadata = {"agno_event_type": "router_execution_completed"}
@@ -679,7 +678,7 @@ async def stream_a2a_response(
                 metadata=metadata,
             )
             response = SendStreamingMessageSuccessResponse(id=request_id, result=status_event)
-            yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+            yield f"event: TaskStatusUpdateEvent\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         # Send steps events
         elif isinstance(event, StepsExecutionStartedEvent):
@@ -697,7 +696,7 @@ async def stream_a2a_response(
                 metadata=metadata,
             )
             response = SendStreamingMessageSuccessResponse(id=request_id, result=status_event)
-            yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+            yield f"event: TaskStatusUpdateEvent\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         elif isinstance(event, StepsExecutionCompletedEvent):
             metadata = {"agno_event_type": "steps_execution_completed"}
@@ -716,7 +715,7 @@ async def stream_a2a_response(
                 metadata=metadata,
             )
             response = SendStreamingMessageSuccessResponse(id=request_id, result=status_event)
-            yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+            yield f"event: TaskStatusUpdateEvent\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         # Capture completion event for final task construction
         elif isinstance(event, (RunCompletedEvent, TeamRunCompletedEvent, WorkflowCompletedEvent)):
@@ -748,7 +747,7 @@ async def stream_a2a_response(
             final=True,
         )
     response = SendStreamingMessageSuccessResponse(id=request_id, result=final_status_event)
-    yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+    yield f"event: TaskStatusUpdateEvent\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
     # 4. Send final task
     # Handle cancelled case
@@ -778,7 +777,7 @@ async def stream_a2a_response(
             history=[final_message],
         )
         response = SendStreamingMessageSuccessResponse(id=request_id, result=task)
-        yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+        yield f"event: Task\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
         return
 
     # Build from completion_event if available, otherwise use accumulated content
@@ -846,8 +845,8 @@ async def stream_a2a_response(
 
         # Handle all other data as Message metadata
         final_metadata: Dict[str, Any] = {}
-        if hasattr(completion_event, "metrics") and completion_event.metrics:
-            final_metadata["metrics"] = completion_event.metrics.__dict__
+        if hasattr(completion_event, "metrics") and completion_event.metrics:  # type: ignore
+            final_metadata["metrics"] = completion_event.metrics.to_dict()  # type: ignore
         if hasattr(completion_event, "metadata") and completion_event.metadata:
             final_metadata.update(completion_event.metadata)
 
@@ -880,7 +879,7 @@ async def stream_a2a_response(
         artifacts=artifacts if artifacts else None,
     )
     response = SendStreamingMessageSuccessResponse(id=request_id, result=task)
-    yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+    yield f"event: Task\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
 
 async def stream_a2a_response_with_error_handling(
@@ -904,7 +903,7 @@ async def stream_a2a_response_with_error_handling(
             final=True,
         )
         response = SendStreamingMessageSuccessResponse(id=request_id, result=failed_status_event)
-        yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+        yield f"event: TaskStatusUpdateEvent\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"
 
         # Send failed Task
         error_message = A2AMessage(
@@ -921,4 +920,4 @@ async def stream_a2a_response_with_error_handling(
         )
 
         response = SendStreamingMessageSuccessResponse(id=request_id, result=failed_task)
-        yield json.dumps(response.model_dump(exclude_none=True)) + "\n"
+        yield f"event: Task\ndata: {json.dumps(response.model_dump(exclude_none=True))}\n\n"

agno/os/interfaces/agui/agui.py

@@ -1,13 +1,15 @@
 """Main class for the AG-UI app, used to expose an Agno Agent or Team in an AG-UI compatible format."""
 
-from typing import List, Optional
+from typing import List, Optional, Union
 
 from fastapi.routing import APIRouter
 
 from agno.agent import Agent
+from agno.agent.remote import RemoteAgent
 from agno.os.interfaces.agui.router import attach_routes
 from agno.os.interfaces.base import BaseInterface
 from agno.team import Team
+from agno.team.remote import RemoteTeam
 
 
 class AGUI(BaseInterface):
@@ -17,8 +19,8 @@ class AGUI(BaseInterface):
 
     def __init__(
         self,
-        agent: Optional[Agent] = None,
-        team: Optional[Team] = None,
+        agent: Optional[Union[Agent, RemoteAgent]] = None,
+        team: Optional[Union[Team, RemoteTeam]] = None,
         prefix: str = "",
         tags: Optional[List[str]] = None,
     ):

agno/os/interfaces/agui/router.py

@@ -2,37 +2,43 @@
 
 import logging
 import uuid
-from typing import AsyncIterator, Optional
-
-from ag_ui.core import (
-    BaseEvent,
-    EventType,
-    RunAgentInput,
-    RunErrorEvent,
-    RunStartedEvent,
-)
-from ag_ui.encoder import EventEncoder
+from typing import AsyncIterator, Optional, Union
+
+try:
+    from ag_ui.core import (
+        BaseEvent,
+        EventType,
+        RunAgentInput,
+        RunErrorEvent,
+        RunStartedEvent,
+    )
+    from ag_ui.encoder import EventEncoder
+except ImportError as e:
+    raise ImportError("`ag_ui` not installed. Please install it with `pip install -U ag-ui`") from e
+
 from fastapi import APIRouter
 from fastapi.responses import StreamingResponse
 
-from agno.agent.agent import Agent
+from agno.agent import Agent, RemoteAgent
 from agno.os.interfaces.agui.utils import (
     async_stream_agno_response_as_agui_events,
     convert_agui_messages_to_agno_messages,
     validate_agui_state,
 )
+from agno.team.remote import RemoteTeam
 from agno.team.team import Team
 
 logger = logging.getLogger(__name__)
 
 
-async def run_agent(agent: Agent, run_input: RunAgentInput) -> AsyncIterator[BaseEvent]:
+async def run_agent(agent: Union[Agent, RemoteAgent], run_input: RunAgentInput) -> AsyncIterator[BaseEvent]:
     """Run the contextual Agent, mapping AG-UI input messages to Agno format, and streaming the response in AG-UI format."""
     run_id = run_input.run_id or str(uuid.uuid4())
 
     try:
         # Preparing the input for the Agent and emitting the run started event
         messages = convert_agui_messages_to_agno_messages(run_input.messages or [])
+
         yield RunStartedEvent(type=EventType.RUN_STARTED, thread_id=run_input.thread_id, run_id=run_id)
 
         # Look for user_id in run_input.forwarded_props
@@ -44,13 +50,14 @@ async def run_agent(agent: Agent, run_input: RunAgentInput) -> AsyncIterator[Bas
         session_state = validate_agui_state(run_input.state, run_input.thread_id)
 
         # Request streaming response from agent
-        response_stream = agent.arun(
+        response_stream = agent.arun(  # type: ignore
             input=messages,
             session_id=run_input.thread_id,
             stream=True,
             stream_events=True,
             user_id=user_id,
             session_state=session_state,
+            run_id=run_id,
         )
 
         # Stream the response content in AG-UI format
@@ -67,7 +74,7 @@ async def run_agent(agent: Agent, run_input: RunAgentInput) -> AsyncIterator[Bas
         yield RunErrorEvent(type=EventType.RUN_ERROR, message=str(e))
 
 
-async def run_team(team: Team, input: RunAgentInput) -> AsyncIterator[BaseEvent]:
+async def run_team(team: Union[Team, RemoteTeam], input: RunAgentInput) -> AsyncIterator[BaseEvent]:
     """Run the contextual Team, mapping AG-UI input messages to Agno format, and streaming the response in AG-UI format."""
     run_id = input.run_id or str(uuid.uuid4())
     try:
@@ -84,13 +91,14 @@ async def run_team(team: Team, input: RunAgentInput) -> AsyncIterator[BaseEvent]
         session_state = validate_agui_state(input.state, input.thread_id)
 
         # Request streaming response from team
-        response_stream = team.arun(
+        response_stream = team.arun(  # type: ignore
             input=messages,
             session_id=input.thread_id,
             stream=True,
             stream_steps=True,
             user_id=user_id,
             session_state=session_state,
+            run_id=run_id,
         )
 
         # Stream the response content in AG-UI format
@@ -104,7 +112,9 @@ async def run_team(team: Team, input: RunAgentInput) -> AsyncIterator[BaseEvent]
         yield RunErrorEvent(type=EventType.RUN_ERROR, message=str(e))
 
 
-def attach_routes(router: APIRouter, agent: Optional[Agent] = None, team: Optional[Team] = None) -> APIRouter:
+def attach_routes(
+    router: APIRouter, agent: Optional[Union[Agent, RemoteAgent]] = None, team: Optional[Union[Team, RemoteTeam]] = None
+) -> APIRouter:
     if agent is None and team is None:
         raise ValueError("Either agent or team must be provided.")
 

agno/os/interfaces/agui/utils.py

@@ -28,7 +28,7 @@ from agno.models.message import Message
 from agno.run.agent import RunContentEvent, RunEvent, RunOutputEvent, RunPausedEvent
 from agno.run.team import RunContentEvent as TeamRunContentEvent
 from agno.run.team import TeamRunEvent, TeamRunOutputEvent
-from agno.utils.log import log_warning
+from agno.utils.log import log_debug, log_warning
 from agno.utils.message import get_text_from_message
 
 
@@ -116,23 +116,43 @@ class EventBuffer:
 
 def convert_agui_messages_to_agno_messages(messages: List[AGUIMessage]) -> List[Message]:
     """Convert AG-UI messages to Agno messages."""
-    result = []
+    # First pass: collect all tool_call_ids that have results
+    tool_call_ids_with_results: Set[str] = set()
+    for msg in messages:
+        if msg.role == "tool" and msg.tool_call_id:
+            tool_call_ids_with_results.add(msg.tool_call_id)
+
+    # Second pass: convert messages
+    result: List[Message] = []
+    seen_tool_call_ids: Set[str] = set()
+
     for msg in messages:
         if msg.role == "tool":
+            # Deduplicate tool results - keep only first occurrence
+            if msg.tool_call_id in seen_tool_call_ids:
+                log_debug(f"Skipping duplicate AGUI tool result: {msg.tool_call_id}")
+                continue
+            seen_tool_call_ids.add(msg.tool_call_id)
             result.append(Message(role="tool", tool_call_id=msg.tool_call_id, content=msg.content))
+
         elif msg.role == "assistant":
             tool_calls = None
             if msg.tool_calls:
-                tool_calls = [call.model_dump() for call in msg.tool_calls]
-            result.append(
-                Message(
-                    role="assistant",
-                    content=msg.content,
-                    tool_calls=tool_calls,
-                )
-            )
+                # Filter tool_calls to only those with results in this message sequence
+                filtered_calls = [call for call in msg.tool_calls if call.id in tool_call_ids_with_results]
+                if filtered_calls:
+                    tool_calls = [call.model_dump() for call in filtered_calls]
+            result.append(Message(role="assistant", content=msg.content, tool_calls=tool_calls))
+
         elif msg.role == "user":
             result.append(Message(role="user", content=msg.content))
+
+        elif msg.role == "system":
+            pass  # Skip - agent builds its own system message from configuration
+
+        else:
+            log_warning(f"Unknown AGUI message role: {msg.role}")
+
     return result
 
 
@@ -250,7 +270,25 @@ def _create_events_from_chunk(
             parent_message_id = event_buffer.get_parent_message_id_for_tool_call()
 
             if not parent_message_id:
-                parent_message_id = current_message_id
+                # Create parent message for tool calls without preceding assistant message
+                parent_message_id = str(uuid.uuid4())
+
+                # Emit a text message to serve as the parent
+                text_start = TextMessageStartEvent(
+                    type=EventType.TEXT_MESSAGE_START,
+                    message_id=parent_message_id,
+                    role="assistant",
+                )
+                events_to_emit.append(text_start)
+
+                text_end = TextMessageEndEvent(
+                    type=EventType.TEXT_MESSAGE_END,
+                    message_id=parent_message_id,
+                )
+                events_to_emit.append(text_end)
+
+                # Set this as the pending parent for subsequent tool calls in this batch
+                event_buffer.set_pending_tool_calls_parent_id(parent_message_id)
 
             start_event = ToolCallStartEvent(
                 type=EventType.TOOL_CALL_START,
@@ -341,58 +379,60 @@ def _create_completion_events(
         end_message_event = TextMessageEndEvent(type=EventType.TEXT_MESSAGE_END, message_id=message_id)
         events_to_emit.append(end_message_event)
 
-    # emit frontend tool calls, i.e. external_execution=True
-    if isinstance(chunk, RunPausedEvent) and chunk.tools is not None:
-        # First, emit an assistant message for external tool calls
-        assistant_message_id = str(uuid.uuid4())
-        assistant_start_event = TextMessageStartEvent(
-            type=EventType.TEXT_MESSAGE_START,
-            message_id=assistant_message_id,
-            role="assistant",
-        )
-        events_to_emit.append(assistant_start_event)
-
-        # Add any text content if present for the assistant message
-        if chunk.content:
-            content_event = TextMessageContentEvent(
-                type=EventType.TEXT_MESSAGE_CONTENT,
+    # Emit external execution tools
+    if isinstance(chunk, RunPausedEvent):
+        external_tools = chunk.tools_awaiting_external_execution
+        if external_tools:
+            # First, emit an assistant message for external tool calls
+            assistant_message_id = str(uuid.uuid4())
+            assistant_start_event = TextMessageStartEvent(
+                type=EventType.TEXT_MESSAGE_START,
                 message_id=assistant_message_id,
-                delta=str(chunk.content),
+                role="assistant",
             )
-            events_to_emit.append(content_event)
-
-        # End the assistant message
-        assistant_end_event = TextMessageEndEvent(
-            type=EventType.TEXT_MESSAGE_END,
-            message_id=assistant_message_id,
-        )
-        events_to_emit.append(assistant_end_event)
-
-        # Now emit the tool call events with the assistant message as parent
-        for tool in chunk.tools:
-            if tool.tool_call_id is None or tool.tool_name is None:
-                continue
+            events_to_emit.append(assistant_start_event)
+
+            # Add any text content if present for the assistant message
+            if chunk.content:
+                content_event = TextMessageContentEvent(
+                    type=EventType.TEXT_MESSAGE_CONTENT,
+                    message_id=assistant_message_id,
+                    delta=str(chunk.content),
+                )
+                events_to_emit.append(content_event)
 
-            start_event = ToolCallStartEvent(
-                type=EventType.TOOL_CALL_START,
-                tool_call_id=tool.tool_call_id,
-                tool_call_name=tool.tool_name,
-                parent_message_id=assistant_message_id,  # Use the assistant message as parent
+            # End the assistant message
+            assistant_end_event = TextMessageEndEvent(
+                type=EventType.TEXT_MESSAGE_END,
+                message_id=assistant_message_id,
             )
-            events_to_emit.append(start_event)
+            events_to_emit.append(assistant_end_event)
+
+            # Emit tool call events for external execution
+            for tool in external_tools:
+                if tool.tool_call_id is None or tool.tool_name is None:
+                    continue
+
+                start_event = ToolCallStartEvent(
+                    type=EventType.TOOL_CALL_START,
+                    tool_call_id=tool.tool_call_id,
+                    tool_call_name=tool.tool_name,
+                    parent_message_id=assistant_message_id,  # Use the assistant message as parent
+                )
+                events_to_emit.append(start_event)
 
-            args_event = ToolCallArgsEvent(
-                type=EventType.TOOL_CALL_ARGS,
-                tool_call_id=tool.tool_call_id,
-                delta=json.dumps(tool.tool_args),
-            )
-            events_to_emit.append(args_event)
+                args_event = ToolCallArgsEvent(
+                    type=EventType.TOOL_CALL_ARGS,
+                    tool_call_id=tool.tool_call_id,
+                    delta=json.dumps(tool.tool_args),
+                )
+                events_to_emit.append(args_event)
 
-            end_event = ToolCallEndEvent(
-                type=EventType.TOOL_CALL_END,
-                tool_call_id=tool.tool_call_id,
-            )
-            events_to_emit.append(end_event)
+                end_event = ToolCallEndEvent(
+                    type=EventType.TOOL_CALL_END,
+                    tool_call_id=tool.tool_call_id,
+                )
+                events_to_emit.append(end_event)
 
     run_finished_event = RunFinishedEvent(type=EventType.RUN_FINISHED, thread_id=thread_id, run_id=run_id)
     events_to_emit.append(run_finished_event)

agno/os/interfaces/base.py

@@ -1,19 +1,19 @@
 from abc import ABC, abstractmethod
-from typing import List, Optional
+from typing import List, Optional, Union
 
 from fastapi import APIRouter
 
-from agno.agent import Agent
-from agno.team import Team
-from agno.workflow.workflow import Workflow
+from agno.agent import Agent, RemoteAgent
+from agno.team import RemoteTeam, Team
+from agno.workflow import RemoteWorkflow, Workflow
 
 
 class BaseInterface(ABC):
     type: str
     version: str = "1.0"
-    agent: Optional[Agent] = None
-    team: Optional[Team] = None
-    workflow: Optional[Workflow] = None
+    agent: Optional[Union[Agent, RemoteAgent]] = None
+    team: Optional[Union[Team, RemoteTeam]] = None
+    workflow: Optional[Union[Workflow, RemoteWorkflow]] = None
 
     prefix: str
     tags: List[str]