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

agno/models/openai/chat.py

@@ -16,19 +16,15 @@ from agno.models.response import ModelResponse
 from agno.run.agent import RunOutput
 from agno.utils.log import log_debug, log_error, log_warning
 from agno.utils.openai import _format_file_for_message, audio_to_message, images_to_message
+from agno.utils.reasoning import extract_thinking_content
 
 try:
     from openai import APIConnectionError, APIStatusError, RateLimitError
     from openai import AsyncOpenAI as AsyncOpenAIClient
     from openai import OpenAI as OpenAIClient
     from openai.types import CompletionUsage
-    from openai.types.chat import ChatCompletionAudio
-    from openai.types.chat.chat_completion import ChatCompletion
-    from openai.types.chat.chat_completion_chunk import (
-        ChatCompletionChunk,
-        ChoiceDelta,
-        ChoiceDeltaToolCall,
-    )
+    from openai.types.chat import ChatCompletion, ChatCompletionAudio, ChatCompletionChunk
+    from openai.types.chat.chat_completion_chunk import ChoiceDelta, ChoiceDeltaToolCall
 except (ImportError, ModuleNotFoundError):
     raise ImportError("`openai` not installed. Please install using `pip install openai`")
 
@@ -716,6 +712,12 @@ class OpenAIChat(Model):
         if response_message.content is not None:
             model_response.content = response_message.content
 
+            # Extract thinking content before any structured parsing
+            if model_response.content:
+                reasoning_content, output_content = extract_thinking_content(model_response.content)
+                if reasoning_content:
+                    model_response.reasoning_content = reasoning_content
+                    model_response.content = output_content
         # Add tool calls
         if response_message.tool_calls is not None and len(response_message.tool_calls) > 0:
             try:

agno/models/openai/responses.py

@@ -19,10 +19,7 @@ from agno.utils.models.schema_utils import get_response_schema_for_provider
 
 try:
     from openai import APIConnectionError, APIStatusError, AsyncOpenAI, OpenAI, RateLimitError
-    from openai.types.responses.response import Response
-    from openai.types.responses.response_reasoning_item import ResponseReasoningItem
-    from openai.types.responses.response_stream_event import ResponseStreamEvent
-    from openai.types.responses.response_usage import ResponseUsage
+    from openai.types.responses import Response, ResponseReasoningItem, ResponseStreamEvent, ResponseUsage
 except ImportError as e:
     raise ImportError("`openai` not installed. Please install using `pip install openai -U`") from e
 
@@ -407,21 +404,28 @@ class OpenAIResponses(Model):
         """
         formatted_messages: List[Union[Dict[str, Any], ResponseReasoningItem]] = []
 
-        if self._using_reasoning_model():
+        messages_to_format = messages
+        previous_response_id: Optional[str] = None
+
+        if self._using_reasoning_model() and self.store is not False:
             # Detect whether we're chaining via previous_response_id. If so, we should NOT
             # re-send prior function_call items; the Responses API already has the state and
             # expects only the corresponding function_call_output items.
-            previous_response_id: Optional[str] = None
-            if self.store is not False:
-                for msg in reversed(messages):
-                    if (
-                        msg.role == "assistant"
-                        and hasattr(msg, "provider_data")
-                        and msg.provider_data
-                        and "response_id" in msg.provider_data
-                    ):
-                        previous_response_id = msg.provider_data["response_id"]
-                        break
+
+            for msg in reversed(messages):
+                if (
+                    msg.role == "assistant"
+                    and hasattr(msg, "provider_data")
+                    and msg.provider_data
+                    and "response_id" in msg.provider_data
+                ):
+                    previous_response_id = msg.provider_data["response_id"]
+                    msg_index = messages.index(msg)
+
+                    # Include messages after this assistant message
+                    messages_to_format = messages[msg_index + 1 :]
+
+                    break
 
         # Build a mapping from function_call id (fc_*) → call_id (call_*) from prior assistant tool_calls
         fc_id_to_call_id: Dict[str, str] = {}
@@ -434,7 +438,7 @@ class OpenAIResponses(Model):
                     if isinstance(fc_id, str) and isinstance(call_id, str):
                         fc_id_to_call_id[fc_id] = call_id
 
-        for message in messages:
+        for message in messages_to_format:
             if message.role in ["user", "system"]:
                 message_dict: Dict[str, Any] = {
                     "role": self.role_map[message.role],

agno/os/interfaces/agui/agui.py

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

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/base.py

@@ -5,6 +5,7 @@ from fastapi import APIRouter
 
 from agno.agent import Agent
 from agno.team import Team
+from agno.workflow.workflow import Workflow
 
 
 class BaseInterface(ABC):
@@ -13,6 +14,7 @@ class BaseInterface(ABC):
     router_prefix: str = ""
     agent: Optional[Agent] = None
     team: Optional[Team] = None
+    workflow: Optional[Workflow] = None
 
     router: APIRouter
 

agno/os/interfaces/slack/router.py

@@ -1,16 +1,49 @@
 from typing import Optional
 
 from fastapi import APIRouter, BackgroundTasks, HTTPException, Request
+from pydantic import BaseModel, Field
 
 from agno.agent.agent import Agent
 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
+from agno.workflow.workflow import Workflow
 
 
-def attach_routes(router: APIRouter, agent: Optional[Agent] = None, team: Optional[Team] = None) -> APIRouter:
-    @router.post("/events")
+class SlackEventResponse(BaseModel):
+    """Response model for Slack event processing"""
+
+    status: str = Field(default="ok", description="Processing status")
+
+
+class SlackChallengeResponse(BaseModel):
+    """Response model for Slack URL verification challenge"""
+
+    challenge: str = Field(description="Challenge string to echo back to Slack")
+
+
+def attach_routes(
+    router: APIRouter, agent: Optional[Agent] = None, team: Optional[Team] = None, workflow: Optional[Workflow] = None
+) -> APIRouter:
+    # Determine entity type for documentation
+    entity_type = "agent" if agent else "team" if team else "workflow" if workflow else "unknown"
+    entity_name = getattr(agent or team or workflow, "name", f"Unnamed {entity_type}")
+
+    @router.post(
+        "/events",
+        operation_id=f"slack_events_{entity_type}",
+        summary=f"Process Slack Events for {entity_type.title()}",
+        description=f"Process incoming Slack events and route them to the configured {entity_type}: {entity_name}",
+        tags=["Slack", f"Slack-{entity_type.title()}"],
+        response_model=SlackEventResponse,
+        response_model_exclude_none=True,
+        responses={
+            200: {"description": "Event processed successfully"},
+            400: {"description": "Missing Slack headers"},
+            403: {"description": "Invalid Slack signature"},
+        },
+    )
     async def slack_events(request: Request, background_tasks: BackgroundTasks):
         body = await request.body()
         timestamp = request.headers.get("X-Slack-Request-Timestamp")
@@ -26,7 +59,7 @@ def attach_routes(router: APIRouter, agent: Optional[Agent] = None, team: Option
 
         # Handle URL verification
         if data.get("type") == "url_verification":
-            return {"challenge": data.get("challenge")}
+            return SlackChallengeResponse(challenge=data.get("challenge"))
 
         # Process other event types (e.g., message events) asynchronously
         if "event" in data:
@@ -37,7 +70,7 @@ def attach_routes(router: APIRouter, agent: Optional[Agent] = None, team: Option
             else:
                 background_tasks.add_task(_process_slack_event, event)
 
-        return {"status": "ok"}
+        return SlackEventResponse(status="ok")
 
     async def _process_slack_event(event: dict):
         if event.get("type") == "message":
@@ -57,12 +90,19 @@ def attach_routes(router: APIRouter, agent: Optional[Agent] = None, team: Option
                 response = await agent.arun(message_text, user_id=user if user else None, session_id=session_id)
             elif team:
                 response = await team.arun(message_text, user_id=user if user else None, session_id=session_id)  # type: ignore
+            elif workflow:
+                response = await workflow.arun(message_text, user_id=user if user else None, session_id=session_id)  # type: ignore
 
-            if response.reasoning_content:
-                _send_slack_message(
-                    channel=channel_id, message=f"Reasoning: \n{response.reasoning_content}", thread_ts=ts, italics=True
-                )
-            _send_slack_message(channel=channel_id, message=response.content or "", thread_ts=ts)
+            if response:
+                if hasattr(response, "reasoning_content") and response.reasoning_content:
+                    _send_slack_message(
+                        channel=channel_id,
+                        message=f"Reasoning: \n{response.reasoning_content}",
+                        thread_ts=ts,
+                        italics=True,
+                    )
+
+                _send_slack_message(channel=channel_id, message=response.content or "", thread_ts=ts)
 
     def _send_slack_message(channel: str, thread_ts: str, message: str, italics: bool = False):
         if len(message) <= 40000:
@@ -85,6 +125,6 @@ def attach_routes(router: APIRouter, agent: Optional[Agent] = None, team: Option
                 formatted_batch = "\n".join([f"_{line}_" for line in batch_message.split("\n")])
                 SlackTools().send_message_thread(channel=channel, text=formatted_batch or "", thread_ts=thread_ts)
             else:
-                SlackTools().send_message_thread(channel=channel, text=message or "", thread_ts=thread_ts)
+                SlackTools().send_message_thread(channel=channel, text=batch_message or "", thread_ts=thread_ts)
 
     return router

agno/os/interfaces/slack/slack.py

@@ -7,6 +7,7 @@ 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
+from agno.workflow.workflow import Workflow
 
 logger = logging.getLogger(__name__)
 
@@ -16,17 +17,18 @@ class Slack(BaseInterface):
 
     router: APIRouter
 
-    def __init__(self, agent: Optional[Agent] = None, team: Optional[Team] = None):
+    def __init__(self, agent: Optional[Agent] = None, team: Optional[Team] = None, workflow: Optional[Workflow] = None):
         self.agent = agent
         self.team = team
+        self.workflow = workflow
 
-        if not self.agent and not self.team:
-            raise ValueError("Slack requires an agent and a team")
+        if not (self.agent or self.team or self.workflow):
+            raise ValueError("Slack requires an agent, team or workflow")
 
     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)
+        self.router = attach_routes(router=self.router, agent=self.agent, team=self.team, workflow=self.workflow)
 
         return self.router

agno/os/interfaces/whatsapp/router.py

@@ -19,6 +19,9 @@ def attach_routes(router: APIRouter, agent: Optional[Agent] = None, team: Option
     if agent is None and team is None:
         raise ValueError("Either agent or team must be provided.")
 
+    # Create WhatsApp tools instance once for reuse
+    whatsapp_tools = WhatsAppTools(async_mode=True)
+
     @router.get("/status")
     async def status():
         return {"status": "available"}
@@ -185,9 +188,9 @@ def attach_routes(router: APIRouter, agent: Optional[Agent] = None, team: Option
             if italics:
                 # Handle multi-line messages by making each line italic
                 formatted_message = "\n".join([f"_{line}_" for line in message.split("\n")])
-                await WhatsAppTools().send_text_message_async(recipient=recipient, text=formatted_message)
+                await whatsapp_tools.send_text_message_async(recipient=recipient, text=formatted_message)
             else:
-                await WhatsAppTools().send_text_message_async(recipient=recipient, text=message)
+                await whatsapp_tools.send_text_message_async(recipient=recipient, text=message)
             return
 
         # Split message into batches of 4000 characters (WhatsApp message limit is 4096)
@@ -199,8 +202,8 @@ def attach_routes(router: APIRouter, agent: Optional[Agent] = None, team: Option
             if italics:
                 # Handle multi-line messages by making each line italic
                 formatted_batch = "\n".join([f"_{line}_" for line in batch_message.split("\n")])
-                await WhatsAppTools().send_text_message_async(recipient=recipient, text=formatted_batch)
+                await whatsapp_tools.send_text_message_async(recipient=recipient, text=formatted_batch)
             else:
-                await WhatsAppTools().send_text_message_async(recipient=recipient, text=batch_message)
+                await whatsapp_tools.send_text_message_async(recipient=recipient, text=batch_message)
 
     return router

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/router.py

@@ -72,6 +72,24 @@ async def _get_request_kwargs(request: Request, endpoint_func: Callable) -> Dict
     sig = inspect.signature(endpoint_func)
     known_fields = set(sig.parameters.keys())
     kwargs = {key: value for key, value in form_data.items() if key not in known_fields}
+
+    # Handle JSON parameters. They are passed as strings and need to be deserialized.
+
+    if session_state := kwargs.get("session_state"):
+        try:
+            session_state_dict = json.loads(session_state)  # type: ignore
+            kwargs["session_state"] = session_state_dict
+        except json.JSONDecodeError:
+            kwargs.pop("session_state")
+            log_warning(f"Invalid session_state parameter couldn't be loaded: {session_state}")
+    if dependencies := kwargs.get("dependencies"):
+        try:
+            dependencies_dict = json.loads(dependencies)  # type: ignore
+            kwargs["dependencies"] = dependencies_dict
+        except json.JSONDecodeError:
+            kwargs.pop("dependencies")
+            log_warning(f"Invalid dependencies parameter couldn't be loaded: {dependencies}")
+
     return kwargs
 
 

agno/os/utils.py

@@ -57,12 +57,20 @@ def get_run_input(run_dict: Dict[str, Any], is_workflow_run: bool = False) -> st
     if is_workflow_run:
         step_executor_runs = run_dict.get("step_executor_runs", [])
         if step_executor_runs:
-            for message in step_executor_runs[0].get("messages", []):
+            for message in reversed(step_executor_runs[0].get("messages", [])):
                 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"]:
+        for message in reversed(run_dict["messages"]):
             if message.get("role") == "user":
                 return message.get("content", "")
 

agno/reasoning/azure_ai_foundry.py

@@ -20,7 +20,7 @@ def get_ai_foundry_reasoning(reasoning_agent: "Agent", messages: List[Message])
     from agno.run.agent import RunOutput
 
     try:
-        reasoning_agent_response: RunOutput = reasoning_agent.run(messages=messages)
+        reasoning_agent_response: RunOutput = reasoning_agent.run(input=messages)
     except Exception as e:
         logger.warning(f"Reasoning error: {e}")
         return None
@@ -46,7 +46,7 @@ async def aget_ai_foundry_reasoning(reasoning_agent: "Agent", messages: List[Mes
     from agno.run.agent import RunOutput
 
     try:
-        reasoning_agent_response: RunOutput = await reasoning_agent.arun(messages=messages)
+        reasoning_agent_response: RunOutput = await reasoning_agent.arun(input=messages)
     except Exception as e:
         logger.warning(f"Reasoning error: {e}")
         return None

agno/reasoning/deepseek.py

@@ -20,7 +20,7 @@ def get_deepseek_reasoning(reasoning_agent: "Agent", messages: List[Message]) ->
             message.role = "system"
 
     try:
-        reasoning_agent_response: RunOutput = reasoning_agent.run(messages=messages)
+        reasoning_agent_response: RunOutput = reasoning_agent.run(input=messages)
     except Exception as e:
         logger.warning(f"Reasoning error: {e}")
         return None
@@ -46,7 +46,7 @@ async def aget_deepseek_reasoning(reasoning_agent: "Agent", messages: List[Messa
             message.role = "system"
 
     try:
-        reasoning_agent_response: RunOutput = await reasoning_agent.arun(messages=messages)
+        reasoning_agent_response: RunOutput = await reasoning_agent.arun(input=messages)
     except Exception as e:
         logger.warning(f"Reasoning error: {e}")
         return None

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/reasoning/groq.py

@@ -20,7 +20,7 @@ def get_groq_reasoning(reasoning_agent: "Agent", messages: List[Message]) -> Opt
             message.role = "system"
 
     try:
-        reasoning_agent_response: RunOutput = reasoning_agent.run(messages=messages)
+        reasoning_agent_response: RunOutput = reasoning_agent.run(input=messages)
     except Exception as e:
         logger.warning(f"Reasoning error: {e}")
         return None
@@ -50,7 +50,7 @@ async def aget_groq_reasoning(reasoning_agent: "Agent", messages: List[Message])
             message.role = "system"
 
     try:
-        reasoning_agent_response: RunOutput = await reasoning_agent.arun(messages=messages)
+        reasoning_agent_response: RunOutput = await reasoning_agent.arun(input=messages)
     except Exception as e:
         logger.warning(f"Reasoning error: {e}")
         return None

agno/reasoning/ollama.py

@@ -20,7 +20,7 @@ def get_ollama_reasoning(reasoning_agent: "Agent", messages: List[Message]) -> O
     from agno.run.agent import RunOutput
 
     try:
-        reasoning_agent_response: RunOutput = reasoning_agent.run(messages=messages)
+        reasoning_agent_response: RunOutput = reasoning_agent.run(input=messages)
     except Exception as e:
         logger.warning(f"Reasoning error: {e}")
         return None
@@ -46,7 +46,7 @@ async def aget_ollama_reasoning(reasoning_agent: "Agent", messages: List[Message
     from agno.run.agent import RunOutput
 
     try:
-        reasoning_agent_response: RunOutput = await reasoning_agent.arun(messages=messages)
+        reasoning_agent_response: RunOutput = await reasoning_agent.arun(input=messages)
     except Exception as e:
         logger.warning(f"Reasoning error: {e}")
         return None