agno 1.8.1__py3-none-any.whl → 2.0.0rc1__py3-none-any.whl

agno/os/interfaces/agui/__init__.py

@@ -0,0 +1,3 @@
+from agno.os.interfaces.agui.agui import AGUI
+
+__all__ = ["AGUI"]

agno/os/interfaces/agui/agui.py

@@ -0,0 +1,31 @@
+"""Main class for the AG-UI app, used to expose an Agno Agent or Team in an AG-UI compatible format."""
+
+from typing import Optional
+
+from fastapi.routing import APIRouter
+
+from agno.agent import Agent
+from agno.os.interfaces.agui.router import attach_routes
+from agno.os.interfaces.base import BaseInterface
+from agno.team import Team
+
+
+class AGUI(BaseInterface):
+    type = "agui"
+
+    router: APIRouter
+
+    def __init__(self, agent: Optional[Agent] = None, team: Optional[Team] = None):
+        self.agent = agent
+        self.team = team
+
+        if not self.agent and not self.team:
+            raise ValueError("AGUI requires an agent and a team")
+
+    def get_router(self, **kwargs) -> APIRouter:
+        # Cannot be overridden
+        self.router = APIRouter(tags=["AGUI"])
+
+        self.router = attach_routes(router=self.router, agent=self.agent, team=self.team)
+
+        return self.router

agno/{app/agui/async_router.py → os/interfaces/agui/router.py}

@@ -16,7 +16,10 @@ from fastapi import APIRouter
 from fastapi.responses import StreamingResponse
 
 from agno.agent.agent import Agent
-from agno.app.agui.utils import async_stream_agno_response_as_agui_events, convert_agui_messages_to_agno_messages
+from agno.os.interfaces.agui.utils import (
+    async_stream_agno_response_as_agui_events,
+    convert_agui_messages_to_agno_messages,
+)
 from agno.team.team import Team
 
 logger = logging.getLogger(__name__)
@@ -32,8 +35,8 @@ async def run_agent(agent: Agent, run_input: RunAgentInput) -> AsyncIterator[Bas
         yield RunStartedEvent(type=EventType.RUN_STARTED, thread_id=run_input.thread_id, run_id=run_id)
 
         # Request streaming response from agent
-        response_stream = await agent.arun(
-            messages=messages,
+        response_stream = agent.arun(
+            input=messages,
             session_id=run_input.thread_id,
             stream=True,
             stream_intermediate_steps=True,
@@ -41,7 +44,9 @@ async def run_agent(agent: Agent, run_input: RunAgentInput) -> AsyncIterator[Bas
 
         # Stream the response content in AG-UI format
         async for event in async_stream_agno_response_as_agui_events(
-            response_stream=response_stream, thread_id=run_input.thread_id, run_id=run_id
+            response_stream=response_stream,  # type: ignore
+            thread_id=run_input.thread_id,
+            run_id=run_id,
         ):
             yield event
 
@@ -60,8 +65,8 @@ async def run_team(team: Team, input: RunAgentInput) -> AsyncIterator[BaseEvent]
         yield RunStartedEvent(type=EventType.RUN_STARTED, thread_id=input.thread_id, run_id=run_id)
 
         # Request streaming response from team
-        response_stream = await team.arun(
-            message=messages,
+        response_stream = team.arun(
+            input=messages,
             session_id=input.thread_id,
             stream=True,
             stream_intermediate_steps=True,
@@ -78,15 +83,14 @@ async def run_team(team: Team, input: RunAgentInput) -> AsyncIterator[BaseEvent]
         yield RunErrorEvent(type=EventType.RUN_ERROR, message=str(e))
 
 
-def get_async_agui_router(agent: Optional[Agent] = None, team: Optional[Team] = None) -> APIRouter:
-    """Return an AG-UI compatible FastAPI router."""
-    if (agent is None and team is None) or (agent is not None and team is not None):
-        raise ValueError("One of 'agent' or 'team' must be provided.")
+def attach_routes(router: APIRouter, agent: Optional[Agent] = None, team: Optional[Team] = None) -> APIRouter:
+    if agent is None and team is None:
+        raise ValueError("Either agent or team must be provided.")
 
-    router = APIRouter()
     encoder = EventEncoder()
 
-    async def _run(run_input: RunAgentInput):
+    @router.post("/agui")
+    async def run_agent_agui(run_input: RunAgentInput):
         async def event_generator():
             if agent:
                 async for event in run_agent(agent, run_input):
@@ -109,10 +113,6 @@ def get_async_agui_router(agent: Optional[Agent] = None, team: Optional[Team] =
             },
         )
 
-    @router.post("/agui")
-    async def run_agent_agui(run_input: RunAgentInput):
-        return await _run(run_input)
-
     @router.get("/status")
     async def get_status():
         return {"status": "available"}

agno/{app → os/interfaces}/agui/utils.py

@@ -24,9 +24,10 @@ from ag_ui.core import (
 from ag_ui.core.types import Message as AGUIMessage
 
 from agno.models.message import Message
-from agno.run.response import RunEvent, RunResponseContentEvent, RunResponseEvent, RunResponsePausedEvent
-from agno.run.team import RunResponseContentEvent as TeamRunResponseContentEvent
-from agno.run.team import TeamRunEvent, TeamRunResponseEvent
+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.message import get_text_from_message
 
 
 @dataclass
@@ -89,38 +90,44 @@ def convert_agui_messages_to_agno_messages(messages: List[AGUIMessage]) -> List[
     return result
 
 
-def extract_team_response_chunk_content(response: TeamRunResponseContentEvent) -> str:
+def extract_team_response_chunk_content(response: TeamRunContentEvent) -> str:
     """Given a response stream chunk, find and extract the content."""
 
     # Handle Team members' responses
     members_content = []
     if hasattr(response, "member_responses") and response.member_responses:  # type: ignore
         for member_resp in response.member_responses:  # type: ignore
-            if isinstance(member_resp, RunResponseContentEvent):
+            if isinstance(member_resp, RunContentEvent):
                 member_content = extract_response_chunk_content(member_resp)
                 if member_content:
                     members_content.append(f"Team member: {member_content}")
-            elif isinstance(member_resp, TeamRunResponseContentEvent):
+            elif isinstance(member_resp, TeamRunContentEvent):
                 member_content = extract_team_response_chunk_content(member_resp)
                 if member_content:
                     members_content.append(f"Team member: {member_content}")
     members_response = "\n".join(members_content) if members_content else ""
 
-    return str(response.content) + members_response
+    # Handle structured outputs
+    main_content = get_text_from_message(response.content) if response.content is not None else ""
 
+    return main_content + members_response
 
-def extract_response_chunk_content(response: RunResponseContentEvent) -> str:
+
+def extract_response_chunk_content(response: RunContentEvent) -> str:
     """Given a response stream chunk, find and extract the content."""
+
     if hasattr(response, "messages") and response.messages:  # type: ignore
         for msg in reversed(response.messages):  # type: ignore
             if hasattr(msg, "role") and msg.role == "assistant" and hasattr(msg, "content") and msg.content:
-                return str(msg.content)
+                # Handle structured outputs from messages
+                return get_text_from_message(msg.content)
 
-    return str(response.content) if response.content else ""
+    # Handle structured outputs
+    return get_text_from_message(response.content) if response.content is not None else ""
 
 
 def _create_events_from_chunk(
-    chunk: Union[RunResponseEvent, TeamRunResponseEvent],
+    chunk: Union[RunOutputEvent, TeamRunOutputEvent],
     message_id: str,
     message_started: bool,
     event_buffer: EventBuffer,
@@ -132,9 +139,9 @@ def _create_events_from_chunk(
     events_to_emit: List[BaseEvent] = []
 
     # Extract content if the contextual event is a content event
-    if chunk.event == RunEvent.run_response_content:
+    if chunk.event == RunEvent.run_content:
         content = extract_response_chunk_content(chunk)  # type: ignore
-    elif chunk.event == TeamRunEvent.run_response_content:
+    elif chunk.event == TeamRunEvent.run_content:
         content = extract_team_response_chunk_content(chunk)  # type: ignore
     else:
         content = None
@@ -158,7 +165,7 @@ def _create_events_from_chunk(
                 message_id=message_id,
                 delta=content,
             )
-            events_to_emit.append(content_event)
+            events_to_emit.append(content_event)  # type: ignore
 
     # Handle starting a new tool call
     elif chunk.event == RunEvent.tool_call_started:
@@ -177,7 +184,7 @@ def _create_events_from_chunk(
                 tool_call_id=tool_call.tool_call_id,  # type: ignore
                 delta=json.dumps(tool_call.tool_args),
             )
-            events_to_emit.append(args_event)
+            events_to_emit.append(args_event)  # type: ignore
 
     # Handle tool call completion
     elif chunk.event == RunEvent.tool_call_completed:
@@ -188,7 +195,7 @@ def _create_events_from_chunk(
                     type=EventType.TOOL_CALL_END,
                     tool_call_id=tool_call.tool_call_id,  # type: ignore
                 )
-                events_to_emit.append(end_event)
+                events_to_emit.append(end_event)  # type: ignore
 
                 if tool_call.result is not None:
                     result_event = ToolCallResultEvent(
@@ -198,21 +205,31 @@ def _create_events_from_chunk(
                         role="tool",
                         message_id=str(uuid.uuid4()),
                     )
-                    events_to_emit.append(result_event)
+                    events_to_emit.append(result_event)  # type: ignore
+
+                if tool_call.result is not None:
+                    result_event = ToolCallResultEvent(
+                        type=EventType.TOOL_CALL_RESULT,
+                        tool_call_id=tool_call.tool_call_id,  # type: ignore
+                        content=str(tool_call.result),
+                        role="tool",
+                        message_id=str(uuid.uuid4()),
+                    )
+                    events_to_emit.append(result_event)  # type: ignore
 
     # Handle reasoning
     elif chunk.event == RunEvent.reasoning_started:
-        step_event = StepStartedEvent(type=EventType.STEP_STARTED, step_name="reasoning")
-        events_to_emit.append(step_event)
+        step_started_event = StepStartedEvent(type=EventType.STEP_STARTED, step_name="reasoning")  # type: ignore
+        events_to_emit.append(step_started_event)  # type: ignore
     elif chunk.event == RunEvent.reasoning_completed:
-        step_event = StepFinishedEvent(type=EventType.STEP_FINISHED, step_name="reasoning")
-        events_to_emit.append(step_event)
+        step_started_event = StepFinishedEvent(type=EventType.STEP_FINISHED, step_name="reasoning")  # type: ignore
+        events_to_emit.append(step_started_event)  # type: ignore
 
-    return events_to_emit, message_started
+    return events_to_emit, message_started  # type: ignore
 
 
 def _create_completion_events(
-    chunk: Union[RunResponseEvent, TeamRunResponseEvent],
+    chunk: Union[RunOutputEvent, TeamRunOutputEvent],
     event_buffer: EventBuffer,
     message_started: bool,
     message_id: str,
@@ -220,7 +237,7 @@ def _create_completion_events(
     run_id: str,
 ) -> List[BaseEvent]:
     """Create events for run completion."""
-    events_to_emit = []
+    events_to_emit: List[BaseEvent] = []
 
     # End remaining active tool calls if needed
     for tool_call_id in list(event_buffer.active_tool_call_ids):
@@ -234,10 +251,10 @@ def _create_completion_events(
     # End the message and run, denoting the end of the session
     if message_started:
         end_message_event = TextMessageEndEvent(type=EventType.TEXT_MESSAGE_END, message_id=message_id)
-        events_to_emit.append(end_message_event)
+        events_to_emit.append(end_message_event)  # type: ignore
 
     # emit frontend tool calls, i.e. external_execution=True
-    if isinstance(chunk, RunResponsePausedEvent) and chunk.tools is not None:
+    if isinstance(chunk, RunPausedEvent) and chunk.tools is not None:
         for tool in chunk.tools:
             if tool.tool_call_id is None or tool.tool_name is None:
                 continue
@@ -248,14 +265,14 @@ def _create_completion_events(
                 tool_call_name=tool.tool_name,
                 parent_message_id=message_id,
             )
-            events_to_emit.append(start_event)
+            events_to_emit.append(start_event)  # type: ignore
 
             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)
+            events_to_emit.append(args_event)  # type: ignore
 
             end_event = ToolCallEndEvent(
                 type=EventType.TOOL_CALL_END,
@@ -263,15 +280,42 @@ def _create_completion_events(
             )
             events_to_emit.append(end_event)
 
+    # emit frontend tool calls, i.e. external_execution=True
+    if isinstance(chunk, RunPausedEvent) and chunk.tools is not None:
+        for tool in chunk.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=message_id,
+            )
+            events_to_emit.append(start_event)  # type: ignore
+
+            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)  # type: ignore
+
+            end_event = ToolCallEndEvent(
+                type=EventType.TOOL_CALL_END,
+                tool_call_id=tool.tool_call_id,
+            )
+            events_to_emit.append(end_event)  # type: ignore
+
     run_finished_event = RunFinishedEvent(type=EventType.RUN_FINISHED, thread_id=thread_id, run_id=run_id)
-    events_to_emit.append(run_finished_event)
+    events_to_emit.append(run_finished_event)  # type: ignore
 
-    return events_to_emit
+    return events_to_emit  # type: ignore
 
 
 def _emit_event_logic(event: BaseEvent, event_buffer: EventBuffer) -> List[BaseEvent]:
     """Process an event through the buffer and return events to actually emit."""
-    events_to_emit = []
+    events_to_emit: List[BaseEvent] = []
 
     if event_buffer.is_blocked():
         # Handle events related to the current blocking tool call
@@ -320,7 +364,7 @@ def _emit_event_logic(event: BaseEvent, event_buffer: EventBuffer) -> List[BaseE
 
 
 def stream_agno_response_as_agui_events(
-    response_stream: Iterator[Union[RunResponseEvent, TeamRunResponseEvent]], thread_id: str, run_id: str
+    response_stream: Iterator[Union[RunOutputEvent, TeamRunOutputEvent]], thread_id: str, run_id: str
 ) -> Iterator[BaseEvent]:
     """Map the Agno response stream to AG-UI format, handling event ordering constraints."""
     message_id = str(uuid.uuid4())
@@ -355,7 +399,7 @@ def stream_agno_response_as_agui_events(
 
 # Async version - thin wrapper
 async def async_stream_agno_response_as_agui_events(
-    response_stream: AsyncIterator[Union[RunResponseEvent, TeamRunResponseEvent]],
+    response_stream: AsyncIterator[Union[RunOutputEvent, TeamRunOutputEvent]],
     thread_id: str,
     run_id: str,
 ) -> AsyncIterator[BaseEvent]:

agno/os/interfaces/base.py

@@ -0,0 +1,21 @@
+from abc import ABC, abstractmethod
+from typing import Optional
+
+from fastapi import APIRouter
+
+from agno.agent import Agent
+from agno.team import Team
+
+
+class BaseInterface(ABC):
+    type: str
+    version: str = "1.0"
+    router_prefix: str = ""
+    agent: Optional[Agent] = None
+    team: Optional[Team] = None
+
+    router: APIRouter
+
+    @abstractmethod
+    def get_router(self, use_async: bool = True, **kwargs) -> APIRouter:
+        pass

agno/os/interfaces/slack/__init__.py

@@ -0,0 +1,3 @@
+from agno.os.interfaces.slack.slack import Slack
+
+__all__ = ["Slack"]

agno/{app/slack/async_router.py → os/interfaces/slack/router.py}

@@ -3,15 +3,13 @@ from typing import Optional
 from fastapi import APIRouter, BackgroundTasks, HTTPException, Request
 
 from agno.agent.agent import Agent
-from agno.app.slack.security import verify_slack_signature
+from agno.os.interfaces.slack.security import verify_slack_signature
 from agno.team.team import Team
 from agno.tools.slack import SlackTools
 from agno.utils.log import log_info
 
 
-def get_async_router(agent: Optional[Agent] = None, team: Optional[Team] = None) -> APIRouter:
-    router = APIRouter()
-
+def attach_routes(router: APIRouter, agent: Optional[Agent] = None, team: Optional[Team] = None) -> APIRouter:
     @router.post("/slack/events")
     async def slack_events(request: Request, background_tasks: BackgroundTasks):
         body = await request.body()
@@ -44,7 +42,7 @@ def get_async_router(agent: Optional[Agent] = None, team: Optional[Team] = None)
     async def _process_slack_event(event: dict):
         if event.get("type") == "message":
             user = None
-            message_text = event.get("text")
+            message_text = event.get("text", "")
             channel_id = event.get("channel", "")
             user = event.get("user")
             if event.get("thread_ts"):

agno/os/interfaces/slack/slack.py

@@ -0,0 +1,32 @@
+import logging
+from typing import Optional
+
+from fastapi.routing import APIRouter
+
+from agno.agent.agent import Agent
+from agno.os.interfaces.base import BaseInterface
+from agno.os.interfaces.slack.router import attach_routes
+from agno.team.team import Team
+
+logger = logging.getLogger(__name__)
+
+
+class Slack(BaseInterface):
+    type = "slack"
+
+    router: APIRouter
+
+    def __init__(self, agent: Optional[Agent] = None, team: Optional[Team] = None):
+        self.agent = agent
+        self.team = team
+
+        if not self.agent and not self.team:
+            raise ValueError("Slack requires an agent and a team")
+
+    def get_router(self, **kwargs) -> APIRouter:
+        # Cannot be overridden
+        self.router = APIRouter(prefix="/slack", tags=["Slack"])
+
+        self.router = attach_routes(router=self.router, agent=self.agent, team=self.team)
+
+        return self.router

agno/os/interfaces/whatsapp/__init__.py

@@ -0,0 +1,3 @@
+from agno.os.interfaces.whatsapp.whatsapp import Whatsapp
+
+__all__ = ["Whatsapp"]

agno/{app/whatsapp/async_router.py → os/interfaces/whatsapp/router.py}

@@ -15,9 +15,7 @@ from agno.utils.whatsapp import get_media_async, send_image_message_async, typin
 from .security import validate_webhook_signature
 
 
-def get_async_router(agent: Optional[Agent] = None, team: Optional[Team] = None) -> APIRouter:
-    router = APIRouter()
-
+def attach_routes(router: APIRouter, agent: Optional[Agent] = None, team: Optional[Team] = None) -> APIRouter:
     if agent is None and team is None:
         raise ValueError("Either agent or team must be provided.")
 
@@ -128,7 +126,7 @@ def get_async_router(agent: Optional[Agent] = None, team: Optional[Team] = None)
                     audio=[Audio(content=await get_media_async(message_audio))] if message_audio else None,
                 )
             elif team:
-                response = await team.arun(
+                response = await team.arun(  # type: ignore
                     message_text,
                     user_id=phone_number,
                     files=[File(content=await get_media_async(message_doc))] if message_doc else None,
@@ -167,9 +165,8 @@ def get_async_router(agent: Optional[Agent] = None, team: Optional[Team] = None)
                         log_warning(
                             f"Could not process image content for user {phone_number}. Type: {type(image_content)}"
                         )
-                        await _send_whatsapp_message(phone_number, response.content)  # Send text part if image fails
-            else:
-                await _send_whatsapp_message(phone_number, response.content)
+                        await _send_whatsapp_message(phone_number, response.content)  # type: ignore
+                await _send_whatsapp_message(phone_number, response.content)  # type: ignore
 
         except Exception as e:
             log_error(f"Error processing message: {str(e)}")

agno/os/interfaces/whatsapp/whatsapp.py

@@ -0,0 +1,29 @@
+from typing import Optional
+
+from fastapi.routing import APIRouter
+
+from agno.agent import Agent
+from agno.os.interfaces.base import BaseInterface
+from agno.os.interfaces.whatsapp.router import attach_routes
+from agno.team import Team
+
+
+class Whatsapp(BaseInterface):
+    type = "whatsapp"
+
+    router: APIRouter
+
+    def __init__(self, agent: Optional[Agent] = None, team: Optional[Team] = None):
+        self.agent = agent
+        self.team = team
+
+        if not self.agent and not self.team:
+            raise ValueError("Whatsapp requires an agent and a team")
+
+    def get_router(self, **kwargs) -> APIRouter:
+        # Cannot be overridden
+        self.router = APIRouter(prefix="/whatsapp", tags=["Whatsapp"])
+
+        self.router = attach_routes(router=self.router, agent=self.agent, team=self.team)
+
+        return self.router