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

agno/models/openai/responses.py

@@ -406,25 +406,25 @@ class OpenAIResponses(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.
-        
+
             for msg in reversed(messages):
                 if (
-                    msg.role == "assistant" 
-                    and hasattr(msg, "provider_data") 
-                    and msg.provider_data 
+                    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:]
-                    
+                    messages_to_format = messages[msg_index + 1 :]
+
                     break
 
         # Build a mapping from function_call id (fc_*) → call_id (call_*) from prior assistant tool_calls

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 or self.team):
-            raise ValueError("Slack requires an agent or 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/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,7 +57,7 @@ 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", "")
 
@@ -70,7 +70,7 @@ def get_run_input(run_dict: Dict[str, Any], is_workflow_run: bool = False) -> st
                 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/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

agno/reasoning/openai.py

@@ -29,7 +29,7 @@ def get_openai_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
@@ -60,7 +60,7 @@ async def aget_openai_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/run/base.py

@@ -117,6 +117,19 @@ class BaseRunOutputEvent:
 
     def to_json(self, separators=(", ", ": "), indent: Optional[int] = 2) -> str:
         import json
+        from datetime import date, datetime, time
+        from enum import Enum
+
+        def json_serializer(obj):
+            # Datetime like
+            if isinstance(obj, (datetime, date, time)):
+                return obj.isoformat()
+            # Enums
+            if isinstance(obj, Enum):
+                v = obj.value
+                return v if isinstance(v, (str, int, float, bool, type(None))) else obj.name
+            # Fallback to string
+            return str(obj)
 
         try:
             _dict = self.to_dict()
@@ -125,9 +138,9 @@ class BaseRunOutputEvent:
             raise
 
         if indent is None:
-            return json.dumps(_dict, separators=separators)
+            return json.dumps(_dict, separators=separators, default=json_serializer, ensure_ascii=False)
         else:
-            return json.dumps(_dict, indent=indent, separators=separators)
+            return json.dumps(_dict, indent=indent, separators=separators, default=json_serializer, ensure_ascii=False)
 
     @classmethod
     def from_dict(cls, data: Dict[str, Any]):

agno/team/team.py

@@ -156,6 +156,8 @@ class Team:
     add_session_state_to_context: bool = False
     # Set to True to give the team tools to update the session_state dynamically
     enable_agentic_state: bool = False
+    # Set to True to overwrite the stored session_state with the session_state provided in the run
+    overwrite_db_session_state: bool = False
     # If True, cache the current Team session in memory for faster access
     cache_session: bool = False
 
@@ -364,6 +366,7 @@ class Team:
         session_state: Optional[Dict[str, Any]] = None,
         add_session_state_to_context: bool = False,
         enable_agentic_state: bool = False,
+        overwrite_db_session_state: bool = False,
         resolve_in_context: bool = True,
         cache_session: bool = False,
         description: Optional[str] = None,
@@ -453,6 +456,7 @@ class Team:
         self.session_state = session_state
         self.add_session_state_to_context = add_session_state_to_context
         self.enable_agentic_state = enable_agentic_state
+        self.overwrite_db_session_state = overwrite_db_session_state
         self.resolve_in_context = resolve_in_context
         self.cache_session = cache_session
 
@@ -1156,7 +1160,7 @@ class Team:
         self._update_metadata(session=team_session)
 
         # Update session state from DB
-        session_state = self._update_session_state(session=team_session, session_state=session_state)
+        session_state = self._load_session_state(session=team_session, session_state=session_state)
 
         # Determine runtime dependencies
         run_dependencies = dependencies if dependencies is not None else self.dependencies
@@ -1780,7 +1784,7 @@ class Team:
         self._update_metadata(session=team_session)
 
         # Update session state from DB
-        session_state = self._update_session_state(session=team_session, session_state=session_state)
+        session_state = self._load_session_state(session=team_session, session_state=session_state)
 
         # Determine run dependencies (runtime override takes priority)
         run_dependencies = dependencies if dependencies is not None else self.dependencies
@@ -2037,9 +2041,6 @@ class Team:
         if model_response.audio is not None:
             run_response.response_audio = model_response.audio
 
-        # Update the run_response created_at with the model response created_at
-        run_response.created_at = model_response.created_at
-
         # Build a list of messages that should be added to the RunOutput
         messages_for_run_response = [m for m in run_messages.messages if m.add_to_agent_memory]
 
@@ -2099,7 +2100,6 @@ class Team:
             )
 
         # 3. Update TeamRunOutput
-        run_response.created_at = full_model_response.created_at
         if full_model_response.content is not None:
             run_response.content = full_model_response.content
         if full_model_response.reasoning_content is not None:
@@ -2189,7 +2189,6 @@ class Team:
             run_response.content = full_model_response.parsed
 
         # Update TeamRunOutput
-        run_response.created_at = full_model_response.created_at
         if full_model_response.content is not None:
             run_response.content = full_model_response.content
         if full_model_response.reasoning_content is not None:
@@ -2851,7 +2850,6 @@ class Team:
 
         # Update the TeamRunResponse content
         run_response.content = model_response.content
-        run_response.created_at = model_response.created_at
 
         if stream_intermediate_steps:
             yield self._handle_event(create_team_output_model_response_completed_event(run_response), run_response)
@@ -2909,7 +2907,6 @@ class Team:
 
         # Update the TeamRunResponse content
         run_response.content = model_response.content
-        run_response.created_at = model_response.created_at
 
         if stream_intermediate_steps:
             yield self._handle_event(create_team_output_model_response_completed_event(run_response), run_response)
@@ -4277,7 +4274,7 @@ class Team:
                     system_message_content += f"{indent * ' '}   - Name: {member.name}\n"
                 if member.role is not None:
                     system_message_content += f"{indent * ' '}   - Role: {member.role}\n"
-                if member.tools is not None and self.add_member_tools_to_context:
+                if member.tools and self.add_member_tools_to_context:
                     system_message_content += f"{indent * ' '}   - Member tools:\n"
                     for _tool in member.tools:
                         if isinstance(_tool, Toolkit):
@@ -6111,8 +6108,8 @@ class Team:
             self._upsert_session(session=session)
             log_debug(f"Created or updated TeamSession record: {session.session_id}")
 
-    def _update_session_state(self, session: TeamSession, session_state: Dict[str, Any]) -> Dict[str, Any]:
-        """Load the existing Agent from an AgentSession (from the database)"""
+    def _load_session_state(self, session: TeamSession, session_state: Dict[str, Any]) -> Dict[str, Any]:
+        """Load and return the stored session_state from the database, optionally merging it with the given one"""
 
         from agno.utils.merge_dict import merge_dictionaries
 
@@ -6125,6 +6122,7 @@ class Team:
                 session_state_from_db is not None
                 and isinstance(session_state_from_db, dict)
                 and len(session_state_from_db) > 0
+                and not self.overwrite_db_session_state
             ):
                 # This preserves precedence: run_params > db_state > agent_defaults
                 merged_state = session_state_from_db.copy()