agno 2.0.7__py3-none-any.whl → 2.0.8__py3-none-any.whl

agno/os/interfaces/agui/utils.py

@@ -35,10 +35,16 @@ class EventBuffer:
 
     active_tool_call_ids: Set[str]  # All currently active tool calls
     ended_tool_call_ids: Set[str]  # All tool calls that have ended
+    current_text_message_id: str = ""  # ID of the current text message context (for tool call parenting)
+    next_text_message_id: str = ""  # Pre-generated ID for the next text message
+    pending_tool_calls_parent_id: str = ""  # Parent message ID for pending tool calls
 
     def __init__(self):
         self.active_tool_call_ids = set()
         self.ended_tool_call_ids = set()
+        self.current_text_message_id = ""
+        self.next_text_message_id = str(uuid.uuid4())
+        self.pending_tool_calls_parent_id = ""
 
     def start_tool_call(self, tool_call_id: str) -> None:
         """Start a new tool call."""
@@ -49,6 +55,29 @@ class EventBuffer:
         self.active_tool_call_ids.discard(tool_call_id)
         self.ended_tool_call_ids.add(tool_call_id)
 
+    def start_text_message(self) -> str:
+        """Start a new text message and return its ID."""
+        # Use the pre-generated next ID as current, and generate a new next ID
+        self.current_text_message_id = self.next_text_message_id
+        self.next_text_message_id = str(uuid.uuid4())
+        return self.current_text_message_id
+
+    def get_parent_message_id_for_tool_call(self) -> str:
+        """Get the message ID to use as parent for tool calls."""
+        # If we have a pending parent ID set (from text message end), use that
+        if self.pending_tool_calls_parent_id:
+            return self.pending_tool_calls_parent_id
+        # Otherwise use current text message ID
+        return self.current_text_message_id
+
+    def set_pending_tool_calls_parent_id(self, parent_id: str) -> None:
+        """Set the parent message ID for upcoming tool calls."""
+        self.pending_tool_calls_parent_id = parent_id
+
+    def clear_pending_tool_calls_parent_id(self) -> None:
+        """Clear the pending parent ID when a new text message starts."""
+        self.pending_tool_calls_parent_id = ""
+
 
 def convert_agui_messages_to_agno_messages(messages: List[AGUIMessage]) -> List[Message]:
     """Convert AG-UI messages to Agno messages."""
@@ -113,10 +142,18 @@ def _create_events_from_chunk(
     message_id: str,
     message_started: bool,
     event_buffer: EventBuffer,
-) -> Tuple[List[BaseEvent], bool]:
+) -> Tuple[List[BaseEvent], bool, str]:
     """
     Process a single chunk and return events to emit + updated message_started state.
-    Returns: (events_to_emit, new_message_started_state)
+
+    Args:
+        chunk: The event chunk to process
+        message_id: Current message identifier
+        message_started: Whether a message is currently active
+        event_buffer: Event buffer for tracking tool call state
+
+    Returns:
+        Tuple of (events_to_emit, new_message_started_state, message_id)
     """
     events_to_emit: List[BaseEvent] = []
 
@@ -133,6 +170,11 @@ def _create_events_from_chunk(
         # Handle the message start event, emitted once per message
         if not message_started:
             message_started = True
+            message_id = event_buffer.start_text_message()
+
+            # Clear pending tool calls parent ID when starting new text message
+            event_buffer.clear_pending_tool_calls_parent_id()
+
             start_event = TextMessageStartEvent(
                 type=EventType.TEXT_MESSAGE_START,
                 message_id=message_id,
@@ -149,21 +191,37 @@ def _create_events_from_chunk(
             )
             events_to_emit.append(content_event)  # type: ignore
 
-    # Handle starting a new tool call
-    elif chunk.event == RunEvent.tool_call_started:
-        # End the current text message if one is active before starting tool calls
-        if message_started:
-            end_message_event = TextMessageEndEvent(type=EventType.TEXT_MESSAGE_END, message_id=message_id)
-            events_to_emit.append(end_message_event)
-            message_started = False  # Reset message_started state
-
+    # Handle starting a new tool
+    elif chunk.event == RunEvent.tool_call_started or chunk.event == TeamRunEvent.tool_call_started:
         if chunk.tool is not None:  # type: ignore
             tool_call = chunk.tool  # type: ignore
+
+            # End current text message and handle for tool calls
+            current_message_id = message_id
+            if message_started:
+                # End the current text message
+                end_message_event = TextMessageEndEvent(type=EventType.TEXT_MESSAGE_END, message_id=current_message_id)
+                events_to_emit.append(end_message_event)
+
+                # Set this message as the parent for any upcoming tool calls
+                # This ensures multiple sequential tool calls all use the same parent
+                event_buffer.set_pending_tool_calls_parent_id(current_message_id)
+
+                # Reset message started state and generate new message_id for future messages
+                message_started = False
+                message_id = str(uuid.uuid4())
+
+            # Get the parent message ID - this will use pending parent if set, ensuring multiple tool calls in sequence have the same parent
+            parent_message_id = event_buffer.get_parent_message_id_for_tool_call()
+
+            if not parent_message_id:
+                parent_message_id = current_message_id
+
             start_event = ToolCallStartEvent(
                 type=EventType.TOOL_CALL_START,
                 tool_call_id=tool_call.tool_call_id,  # type: ignore
                 tool_call_name=tool_call.tool_name,  # type: ignore
-                parent_message_id=message_id,
+                parent_message_id=parent_message_id,
             )
             events_to_emit.append(start_event)
 
@@ -175,7 +233,7 @@ def _create_events_from_chunk(
             events_to_emit.append(args_event)  # type: ignore
 
     # Handle tool call completion
-    elif chunk.event == RunEvent.tool_call_completed:
+    elif chunk.event == RunEvent.tool_call_completed or chunk.event == TeamRunEvent.tool_call_completed:
         if chunk.tool is not None:  # type: ignore
             tool_call = chunk.tool  # type: ignore
             if tool_call.tool_call_id not in event_buffer.ended_tool_call_ids:
@@ -203,7 +261,7 @@ def _create_events_from_chunk(
         step_finished_event = StepFinishedEvent(type=EventType.STEP_FINISHED, step_name="reasoning")
         events_to_emit.append(step_finished_event)
 
-    return events_to_emit, message_started
+    return events_to_emit, message_started, message_id
 
 
 def _create_completion_events(
@@ -237,11 +295,16 @@ def _create_completion_events(
             if tool.tool_call_id is None or tool.tool_name is None:
                 continue
 
+            # Use the current text message ID from event buffer as parent
+            parent_message_id = event_buffer.get_parent_message_id_for_tool_call()
+            if not parent_message_id:
+                parent_message_id = message_id  # Fallback to the passed message_id
+
             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,
+                parent_message_id=parent_message_id,
             )
             events_to_emit.append(start_event)
 
@@ -285,7 +348,7 @@ def stream_agno_response_as_agui_events(
     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())
+    message_id = ""  # Will be set by EventBuffer when text message starts
     message_started = False
     event_buffer = EventBuffer()
     stream_completed = False
@@ -304,7 +367,7 @@ def stream_agno_response_as_agui_events(
             stream_completed = True
         else:
             # Process regular chunk immediately
-            events_from_chunk, message_started = _create_events_from_chunk(
+            events_from_chunk, message_started, message_id = _create_events_from_chunk(
                 chunk, message_id, message_started, event_buffer
             )
 
@@ -345,7 +408,7 @@ async def async_stream_agno_response_as_agui_events(
     run_id: str,
 ) -> AsyncIterator[BaseEvent]:
     """Map the Agno response stream to AG-UI format, handling event ordering constraints."""
-    message_id = str(uuid.uuid4())
+    message_id = ""  # Will be set by EventBuffer when text message starts
     message_started = False
     event_buffer = EventBuffer()
     stream_completed = False
@@ -364,7 +427,7 @@ async def async_stream_agno_response_as_agui_events(
             stream_completed = True
         else:
             # Process regular chunk immediately
-            events_from_chunk, message_started = _create_events_from_chunk(
+            events_from_chunk, message_started, message_id = _create_events_from_chunk(
                 chunk, message_id, message_started, event_buffer
             )
 

agno/os/interfaces/slack/slack.py

@@ -20,8 +20,8 @@ class Slack(BaseInterface):
         self.agent = agent
         self.team = team
 
-        if not self.agent and not self.team:
-            raise ValueError("Slack requires an agent and a team")
+        if not (self.agent or self.team):
+            raise ValueError("Slack requires an agent or a team")
 
     def get_router(self, **kwargs) -> APIRouter:
         # Cannot be overridden

agno/os/interfaces/whatsapp/whatsapp.py

@@ -17,8 +17,8 @@ class Whatsapp(BaseInterface):
         self.agent = agent
         self.team = team
 
-        if not self.agent and not self.team:
-            raise ValueError("Whatsapp requires an agent and a team")
+        if not (self.agent or self.team):
+            raise ValueError("Whatsapp requires an agent or a team")
 
     def get_router(self, **kwargs) -> APIRouter:
         # Cannot be overridden

agno/os/utils.py

@@ -61,6 +61,14 @@ def get_run_input(run_dict: Dict[str, Any], is_workflow_run: bool = False) -> st
                 if message.get("role") == "user":
                     return message.get("content", "")
 
+        # Check the input field directly as final fallback
+        if run_dict.get("input") is not None:
+            input_value = run_dict.get("input")
+            if isinstance(input_value, str):
+                return input_value
+            else:
+                return str(input_value)
+
     if run_dict.get("messages") is not None:
         for message in run_dict["messages"]:
             if message.get("role") == "user":

agno/reasoning/default.py

@@ -14,6 +14,7 @@ def get_default_reasoning_agent(
     min_steps: int,
     max_steps: int,
     tools: Optional[List[Union[Toolkit, Callable, Function, Dict]]] = None,
+    tool_call_limit: Optional[int] = None,
     use_json_mode: bool = False,
     telemetry: bool = True,
     debug_mode: bool = False,
@@ -56,7 +57,7 @@ def get_default_reasoning_agent(
             - **validate**: When you reach a potential answer, signaling it's ready for validation.
             - **final_answer**: Only if you have confidently validated the solution.
             - **reset**: Immediately restart analysis if a critical error or incorrect result is identified.
-        6. **Confidence Score**: Provide a numeric confidence score (0.0–1.0) indicating your certainty in the step’s correctness and its outcome.
+        6. **Confidence Score**: Provide a numeric confidence score (0.0–1.0) indicating your certainty in the step's correctness and its outcome.
 
         Step 5 - Validation (mandatory before finalizing an answer):
         - Explicitly validate your solution by:
@@ -82,6 +83,7 @@ def get_default_reasoning_agent(
         - Only create a single instance of ReasoningSteps for your response.\
         """),
         tools=tools,
+        tool_call_limit=tool_call_limit,
         output_schema=ReasoningSteps,
         use_json_mode=use_json_mode,
         telemetry=telemetry,

agno/session/agent.py

@@ -57,8 +57,9 @@ class AgentSession:
             return None
 
         runs = data.get("runs")
+        serialized_runs: List[RunOutput] = []
         if runs is not None and isinstance(runs[0], dict):
-            runs = [RunOutput.from_dict(run) for run in runs]
+            serialized_runs = [RunOutput.from_dict(run) for run in runs]
 
         summary = data.get("summary")
         if summary is not None and isinstance(summary, dict):
@@ -77,7 +78,7 @@ class AgentSession:
             metadata=metadata,
             created_at=data.get("created_at"),
             updated_at=data.get("updated_at"),
-            runs=runs,
+            runs=serialized_runs,
             summary=summary,
         )
 
@@ -151,12 +152,14 @@ class AgentSession:
                 continue
 
             for message in run_response.messages or []:
-                # Skip messages with specified role
-                if skip_role and message.role == skip_role:
-                    continue
                 # Skip messages that were tagged as history in previous runs
                 if hasattr(message, "from_history") and message.from_history and skip_history_messages:
                     continue
+
+                # Skip messages with specified role
+                if skip_role and message.role == skip_role:
+                    continue
+
                 if message.role == "system":
                     # Only add the system message once
                     if system_message is None:

agno/session/team.py

@@ -54,16 +54,18 @@ class TeamSession:
             log_warning("TeamSession is missing session_id")
             return None
 
-        if data.get("summary") is not None:
+        summary = data.get("summary")
+        if summary is not None and isinstance(summary, dict):
             data["summary"] = SessionSummary.from_dict(data["summary"])  # type: ignore
 
-        runs = data.get("runs", [])
+        runs = data.get("runs")
         serialized_runs: List[Union[TeamRunOutput, RunOutput]] = []
-        for run in runs:
-            if "agent_id" in run:
-                serialized_runs.append(RunOutput.from_dict(run))
-            elif "team_id" in run:
-                serialized_runs.append(TeamRunOutput.from_dict(run))
+        if runs is not None and isinstance(runs[0], dict):
+            for run in runs:
+                if "agent_id" in run:
+                    serialized_runs.append(RunOutput.from_dict(run))
+                elif "team_id" in run:
+                    serialized_runs.append(TeamRunOutput.from_dict(run))
 
         return cls(
             session_id=data.get("session_id"),  # type: ignore
@@ -160,12 +162,14 @@ class TeamSession:
                 continue
 
             for message in run_response.messages or []:
-                # Skip messages with specified role
-                if skip_role and message.role == skip_role:
-                    continue
                 # Skip messages that were tagged as history in previous runs
                 if hasattr(message, "from_history") and message.from_history and skip_history_messages:
                     continue
+
+                # Skip messages with specified role
+                if skip_role and message.role == skip_role:
+                    continue
+
                 if message.role == "system":
                     # Only add the system message once
                     if system_message is None: