agno 2.1.7__py3-none-any.whl → 2.1.9__py3-none-any.whl

agno/team/team.py

@@ -862,6 +862,9 @@ class Team:
         run_response: TeamRunOutput,
         run_input: TeamRunInput,
         session: TeamSession,
+        session_state: Optional[Dict[str, Any]] = None,
+        dependencies: Optional[Dict[str, Any]] = None,
+        metadata: Optional[Dict[str, Any]] = None,
         user_id: Optional[str] = None,
         debug_mode: Optional[bool] = None,
         **kwargs: Any,
@@ -876,6 +879,9 @@ class Team:
             "team": self,
             "session": session,
             "user_id": user_id,
+            "metadata": metadata,
+            "session_state": session_state,
+            "dependencies": dependencies,
             "debug_mode": debug_mode or self.debug_mode,
         }
         all_args.update(kwargs)
@@ -918,6 +924,9 @@ class Team:
         run_response: TeamRunOutput,
         run_input: TeamRunInput,
         session: TeamSession,
+        session_state: Optional[Dict[str, Any]] = None,
+        dependencies: Optional[Dict[str, Any]] = None,
+        metadata: Optional[Dict[str, Any]] = None,
         user_id: Optional[str] = None,
         debug_mode: Optional[bool] = None,
         **kwargs: Any,
@@ -932,6 +941,9 @@ class Team:
             "team": self,
             "session": session,
             "user_id": user_id,
+            "session_state": session_state,
+            "dependencies": dependencies,
+            "metadata": metadata,
             "debug_mode": debug_mode or self.debug_mode,
         }
         all_args.update(kwargs)
@@ -977,6 +989,9 @@ class Team:
         hooks: Optional[List[Callable[..., Any]]],
         run_output: TeamRunOutput,
         session: TeamSession,
+        session_state: Optional[Dict[str, Any]] = None,
+        dependencies: Optional[Dict[str, Any]] = None,
+        metadata: Optional[Dict[str, Any]] = None,
         user_id: Optional[str] = None,
         debug_mode: Optional[bool] = None,
         **kwargs: Any,
@@ -991,6 +1006,9 @@ class Team:
             "team": self,
             "session": session,
             "user_id": user_id,
+            "session_state": session_state,
+            "dependencies": dependencies,
+            "metadata": metadata,
             "debug_mode": debug_mode or self.debug_mode,
         }
         all_args.update(kwargs)
@@ -1014,6 +1032,9 @@ class Team:
         run_output: TeamRunOutput,
         session: TeamSession,
         user_id: Optional[str] = None,
+        session_state: Optional[Dict[str, Any]] = None,
+        dependencies: Optional[Dict[str, Any]] = None,
+        metadata: Optional[Dict[str, Any]] = None,
         debug_mode: Optional[bool] = None,
         **kwargs: Any,
     ) -> None:
@@ -1027,6 +1048,9 @@ class Team:
             "team": self,
             "session": session,
             "user_id": user_id,
+            "session_state": session_state,
+            "dependencies": dependencies,
+            "metadata": metadata,
             "debug_mode": debug_mode or self.debug_mode,
         }
         all_args.update(kwargs)
@@ -1091,6 +1115,9 @@ class Team:
                 run_response=run_response,
                 run_input=run_input,
                 session=session,
+                session_state=session_state,
+                dependencies=dependencies,
+                metadata=metadata,
                 user_id=user_id,
                 debug_mode=debug_mode,
                 **kwargs,
@@ -1182,26 +1209,29 @@ class Team:
         else:
             self._scrub_media_from_run_output(run_response)
 
-        run_response.status = RunStatus.completed
-
         # Parse team response model
         self._convert_response_to_structured_format(run_response=run_response)
 
-        # Set the run duration
-        if run_response.metrics:
-            run_response.metrics.stop_timer()
-
         # 6. Execute post-hooks after output is generated but before response is returned
         if self.post_hooks is not None:
             self._execute_post_hooks(
                 hooks=self.post_hooks,  # type: ignore
                 run_output=run_response,
                 session=session,
+                session_state=session_state,
+                dependencies=dependencies,
+                metadata=metadata,
                 user_id=user_id,
                 debug_mode=debug_mode,
                 **kwargs,
             )
 
+        run_response.status = RunStatus.completed
+
+        # Set the run duration
+        if run_response.metrics:
+            run_response.metrics.stop_timer()
+
         # 7. Add the RunOutput to Team Session
         session.upsert_run(run_response=run_response)
 
@@ -1278,6 +1308,9 @@ class Team:
                 run_response=run_response,
                 run_input=run_input,
                 session=session,
+                session_state=session_state,
+                dependencies=dependencies,
+                metadata=metadata,
                 user_id=user_id,
                 debug_mode=debug_mode,
                 **kwargs,
@@ -1396,14 +1429,25 @@ class Team:
                 session=session, run_response=run_response, stream_intermediate_steps=stream_intermediate_steps
             )
 
-            run_response.status = RunStatus.completed
+            # Execute post-hooks after output is generated but before response is returned
+            if self.post_hooks is not None:
+                self._execute_post_hooks(
+                    hooks=self.post_hooks,  # type: ignore
+                    run_output=run_response,
+                    session_state=session_state,
+                    dependencies=dependencies,
+                    metadata=metadata,
+                    session=session,
+                    user_id=user_id,
+                    debug_mode=debug_mode,
+                    **kwargs,
+                )
 
+            run_response.status = RunStatus.completed
             # Set the run duration
             if run_response.metrics:
                 run_response.metrics.stop_timer()
 
-            # TODO: For now we don't run post-hooks during streaming
-
             # 5. Add the run to Team Session
             session.upsert_run(run_response=run_response)
 
@@ -1630,11 +1674,11 @@ class Team:
         )
         self.model = cast(Model, self.model)
 
-        if metadata is not None:
-            if self.metadata is not None:
-                merge_dictionaries(metadata, self.metadata)
-            else:
+        if self.metadata is not None:
+            if metadata is None:
                 metadata = self.metadata
+            else:
+                merge_dictionaries(metadata, self.metadata)
 
         # Create a new run_response for this attempt
         run_response = TeamRunOutput(
@@ -1799,6 +1843,9 @@ class Team:
 
         register_run(run_response.run_id)  # type: ignore
 
+        if dependencies is not None:
+            await self._aresolve_run_dependencies(dependencies=dependencies)
+
         # 1. Read or create session. Reads from the database if provided.
         if self._has_async_db():
             team_session = await self._aread_or_create_session(session_id=session_id, user_id=user_id)
@@ -1820,6 +1867,9 @@ class Team:
                 session=team_session,
                 user_id=user_id,
                 debug_mode=debug_mode,
+                session_state=session_state,
+                dependencies=dependencies,
+                metadata=metadata,
                 **kwargs,
             )
 
@@ -1907,21 +1957,35 @@ class Team:
         else:
             self._scrub_media_from_run_output(run_response)
 
-        # 9. Add the run to memory
-        team_session.upsert_run(run_response=run_response)
+        # 11. Parse team response model
+        self._convert_response_to_structured_format(run_response=run_response)
 
-        # 10. Calculate session metrics
-        self._update_session_metrics(session=team_session)
+        # Execute post-hooks after output is generated but before response is returned
+        if self.post_hooks is not None:
+            await self._aexecute_post_hooks(
+                hooks=self.post_hooks,  # type: ignore
+                run_output=run_response,
+                session=team_session,
+                user_id=user_id,
+                debug_mode=debug_mode,
+                session_state=session_state,
+                dependencies=dependencies,
+                metadata=metadata,
+                **kwargs,
+            )
 
         run_response.status = RunStatus.completed
 
-        # 11. Parse team response model
-        self._convert_response_to_structured_format(run_response=run_response)
-
         # Set the run duration
         if run_response.metrics:
             run_response.metrics.stop_timer()
 
+        # 9. Add the run to memory
+        team_session.upsert_run(run_response=run_response)
+
+        # 10. Calculate session metrics
+        self._update_session_metrics(session=team_session)
+
         # 12. Update Team Memory
         async for _ in self._amake_memories_and_summaries(
             run_response=run_response,
@@ -1944,17 +2008,6 @@ class Team:
         #  Log Team Telemetry
         await self._alog_team_telemetry(session_id=team_session.session_id, run_id=run_response.run_id)
 
-        # 15. Execute post-hooks after output is generated but before response is returned
-        if self.post_hooks is not None:
-            await self._aexecute_post_hooks(
-                hooks=self.post_hooks,  # type: ignore
-                run_output=run_response,
-                session=team_session,
-                user_id=user_id,
-                debug_mode=debug_mode,
-                **kwargs,
-            )
-
         log_debug(f"Team Run End: {run_response.run_id}", center=True, symbol="*")
 
         cleanup_run(run_response.run_id)  # type: ignore
@@ -2005,7 +2058,7 @@ class Team:
 
         # 1. Resolve dependencies
         if dependencies is not None:
-            self._resolve_run_dependencies(dependencies=dependencies)
+            await self._aresolve_run_dependencies(dependencies=dependencies)
 
         # 2. Read or create session. Reads from the database if provided.
         if self._has_async_db():
@@ -2028,6 +2081,9 @@ class Team:
                 session=team_session,
                 user_id=user_id,
                 debug_mode=debug_mode,
+                session_state=session_state,
+                dependencies=dependencies,
+                metadata=metadata,
                 **kwargs,
             )
             async for pre_hook_event in pre_hook_iterator:
@@ -2143,6 +2199,24 @@ class Team:
             ):
                 yield event
 
+            # Execute post-hooks after output is generated but before response is returned
+            if self.post_hooks is not None:
+                await self._aexecute_post_hooks(
+                    hooks=self.post_hooks,  # type: ignore
+                    run_output=run_response,
+                    session_state=session_state,
+                    dependencies=dependencies,
+                    metadata=metadata,
+                    session=team_session,
+                    user_id=user_id,
+                    debug_mode=debug_mode,
+                    **kwargs,
+                )
+
+            # Set the run duration
+            if run_response.metrics:
+                run_response.metrics.stop_timer()
+
             run_response.status = RunStatus.completed
 
             # 10. Add the run to memory
@@ -2353,12 +2427,12 @@ class Team:
         )
 
         self.model = cast(Model, self.model)
-
-        if metadata is not None:
-            if self.metadata is not None:
-                merge_dictionaries(metadata, self.metadata)
-            else:
+        
+        if self.metadata is not None:
+            if metadata is None:
                 metadata = self.metadata
+            else:
+                merge_dictionaries(metadata, self.metadata)
 
         #  Get knowledge filters
         effective_filters = knowledge_filters

agno/tools/googlecalendar.py

@@ -4,7 +4,7 @@ import uuid
 from functools import wraps
 from os import getenv
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, cast
 
 from agno.tools import Toolkit
 from agno.utils.log import log_debug, log_error, log_info
@@ -164,8 +164,10 @@ class GoogleCalendarTools(Toolkit):
                 )
 
         try:
+            service = cast(Resource, self.service)
+
             events_result = (
-                self.service.events()  # type: ignore
+                service.events()
                 .list(
                     calendarId=self.calendar_id,
                     timeMin=start_date,
@@ -194,6 +196,7 @@ class GoogleCalendarTools(Toolkit):
         timezone: Optional[str] = "UTC",
         attendees: Optional[List[str]] = None,
         add_google_meet_link: Optional[bool] = False,
+        notify_attendees: Optional[bool] = False,
     ) -> str:
         """
         Create a new event in the Google Calendar.
@@ -207,6 +210,7 @@ class GoogleCalendarTools(Toolkit):
             timezone (Optional[str]): Timezone for the event (default: UTC)
             attendees (Optional[List[str]]): List of email addresses of the attendees
             add_google_meet_link (Optional[bool]): Whether to add a Google Meet video link to the event
+            notify_attendees (Optional[bool]): Whether to send email notifications to attendees (default: False)
 
         Returns:
             str: JSON string containing the created Google Calendar event or error message
@@ -241,12 +245,18 @@ class GoogleCalendarTools(Toolkit):
             # Remove None values
             event = {k: v for k, v in event.items() if v is not None}
 
+            # Determine sendUpdates value based on notify_attendees parameter
+            send_updates = "all" if notify_attendees and attendees else "none"
+
+            service = cast(Resource, self.service)
+
             event_result = (
-                self.service.events()  # type: ignore
+                service.events()
                 .insert(
                     calendarId=self.calendar_id,
                     body=event,
                     conferenceDataVersion=1 if add_google_meet_link else 0,
+                    sendUpdates=send_updates,
                 )
                 .execute()
             )
@@ -267,6 +277,7 @@ class GoogleCalendarTools(Toolkit):
         end_date: Optional[str] = None,
         timezone: Optional[str] = None,
         attendees: Optional[List[str]] = None,
+        notify_attendees: Optional[bool] = False,
     ) -> str:
         """
         Update an existing event in the Google Calendar.
@@ -280,13 +291,16 @@ class GoogleCalendarTools(Toolkit):
             end_date (Optional[str]): New end date and time in ISO format (YYYY-MM-DDTHH:MM:SS)
             timezone (Optional[str]): New timezone for the event
             attendees (Optional[List[str]]): Updated list of attendee email addresses
+            notify_attendees (Optional[bool]): Whether to send email notifications to attendees (default: False)
 
         Returns:
             str: JSON string containing the updated Google Calendar event or error message
         """
         try:
+            service = cast(Resource, self.service)
+
             # First get the existing event to preserve its structure
-            event = self.service.events().get(calendarId=self.calendar_id, eventId=event_id).execute()  # type: ignore
+            event = service.events().get(calendarId=self.calendar_id, eventId=event_id).execute()
 
             # Update only the fields that are provided
             if title is not None:
@@ -317,9 +331,15 @@ class GoogleCalendarTools(Toolkit):
                 except ValueError:
                     return json.dumps({"error": f"Invalid end datetime format: {end_date}. Use ISO format."})
 
+            # Determine sendUpdates value based on notify_attendees parameter
+            send_updates = "all" if notify_attendees and attendees else "none"
+
             # Update the event
+
             updated_event = (
-                self.service.events().update(calendarId=self.calendar_id, eventId=event_id, body=event).execute()  # type: ignore
+                service.events()
+                .update(calendarId=self.calendar_id, eventId=event_id, body=event, sendUpdates=send_updates)
+                .execute()
             )
 
             log_debug(f"Event {event_id} updated successfully.")
@@ -329,18 +349,24 @@ class GoogleCalendarTools(Toolkit):
             return json.dumps({"error": f"An error occurred: {error}"})
 
     @authenticate
-    def delete_event(self, event_id: str) -> str:
+    def delete_event(self, event_id: str, notify_attendees: Optional[bool] = True) -> str:
         """
         Delete an event from the Google Calendar.
 
         Args:
             event_id (str): ID of the event to delete
+            notify_attendees (Optional[bool]): Whether to send email notifications to attendees (default: False)
 
         Returns:
             str: JSON string containing success message or error message
         """
         try:
-            self.service.events().delete(calendarId=self.calendar_id, eventId=event_id).execute()  # type: ignore
+            # Determine sendUpdates value based on notify_attendees parameter
+            send_updates = "all" if notify_attendees else "none"
+
+            service = cast(Resource, self.service)
+
+            service.events().delete(calendarId=self.calendar_id, eventId=event_id, sendUpdates=send_updates).execute()
 
             log_debug(f"Event {event_id} deleted successfully.")
             return json.dumps({"success": True, "message": f"Event {event_id} deleted successfully."})
@@ -366,6 +392,8 @@ class GoogleCalendarTools(Toolkit):
             str: JSON string containing all Google Calendar events or error message
         """
         try:
+            service = cast(Resource, self.service)
+
             params = {
                 "calendarId": self.calendar_id,
                 "maxResults": min(max_results, 100),
@@ -412,7 +440,7 @@ class GoogleCalendarTools(Toolkit):
                 if page_token:
                     params["pageToken"] = page_token
 
-                events_result = self.service.events().list(**params).execute()  # type: ignore
+                events_result = service.events().list(**params).execute()
                 all_events.extend(events_result.get("items", []))
 
                 page_token = events_result.get("nextPageToken")

agno/tools/jira.py

@@ -22,6 +22,7 @@ class JiraTools(Toolkit):
         enable_create_issue: bool = True,
         enable_search_issues: bool = True,
         enable_add_comment: bool = True,
+        enable_add_worklog: bool = True,
         all: bool = False,
         **kwargs,
     ):
@@ -55,6 +56,8 @@ class JiraTools(Toolkit):
             tools.append(self.search_issues)
         if enable_add_comment or all:
             tools.append(self.add_comment)
+        if enable_add_worklog or all:
+            tools.append(self.add_worklog)
 
         super().__init__(name="jira_tools", tools=tools, **kwargs)
 
@@ -148,3 +151,20 @@ class JiraTools(Toolkit):
         except Exception as e:
             logger.error(f"Error adding comment to issue {issue_key}: {e}")
             return json.dumps({"error": str(e)})
+
+    def add_worklog(self, issue_key: str, time_spent: str, comment: Optional[str] = None) -> str:
+        """
+        Adds a worklog entry to log time spent on a specific Jira issue.
+
+        :param issue_key: The key of the issue to log work against (e.g., 'PROJ-123').
+        :param time_spent: The amount of time spent. Use Jira's format, e.g., '2h', '30m', '1d 4h'.
+        :param comment: An optional comment describing the work done.
+        :return: A JSON string indicating success or containing an error message.
+        """
+        try:
+            self.jira.add_worklog(issue=issue_key, timeSpent=time_spent, comment=comment)
+            log_debug(f"Worklog of '{time_spent}' added to issue {issue_key}")
+            return json.dumps({"status": "success", "issue_key": issue_key, "time_spent": time_spent})
+        except Exception as e:
+            logger.error(f"Error adding worklog to issue {issue_key}: {e}")
+            return json.dumps({"error": str(e)})

agno/workflow/condition.py

@@ -111,13 +111,16 @@ class Condition:
             audio=current_audio + all_audio,
         )
 
-    def _evaluate_condition(self, step_input: StepInput) -> bool:
+    def _evaluate_condition(self, step_input: StepInput, session_state: Optional[Dict[str, Any]] = None) -> bool:
         """Evaluate the condition and return boolean result"""
         if isinstance(self.evaluator, bool):
             return self.evaluator
 
         if callable(self.evaluator):
-            result = self.evaluator(step_input)
+            if session_state is not None and self._evaluator_has_session_state_param():
+                result = self.evaluator(step_input, session_state=session_state)  # type: ignore[call-arg]
+            else:
+                result = self.evaluator(step_input)
 
             if isinstance(result, bool):
                 return result
@@ -127,16 +130,24 @@ class Condition:
 
         return False
 
-    async def _aevaluate_condition(self, step_input: StepInput) -> bool:
+    async def _aevaluate_condition(self, step_input: StepInput, session_state: Optional[Dict[str, Any]] = None) -> bool:
         """Async version of condition evaluation"""
         if isinstance(self.evaluator, bool):
             return self.evaluator
 
         if callable(self.evaluator):
+            has_session_state = session_state is not None and self._evaluator_has_session_state_param()
+
             if inspect.iscoroutinefunction(self.evaluator):
-                result = await self.evaluator(step_input)
+                if has_session_state:
+                    result = await self.evaluator(step_input, session_state=session_state)  # type: ignore[call-arg]
+                else:
+                    result = await self.evaluator(step_input)
             else:
-                result = self.evaluator(step_input)
+                if has_session_state:
+                    result = self.evaluator(step_input, session_state=session_state)  # type: ignore[call-arg]
+                else:
+                    result = self.evaluator(step_input)
 
             if isinstance(result, bool):
                 return result
@@ -146,6 +157,17 @@ class Condition:
 
         return False
 
+    def _evaluator_has_session_state_param(self) -> bool:
+        """Check if the evaluator function has a session_state parameter"""
+        if not callable(self.evaluator):
+            return False
+
+        try:
+            sig = inspect.signature(self.evaluator)
+            return "session_state" in sig.parameters
+        except Exception:
+            return False
+
     def execute(
         self,
         step_input: StepInput,
@@ -166,7 +188,7 @@ class Condition:
         self._prepare_steps()
 
         # Evaluate the condition
-        condition_result = self._evaluate_condition(step_input)
+        condition_result = self._evaluate_condition(step_input, session_state)
         log_debug(f"Condition {self.name} evaluated to: {condition_result}")
 
         if not condition_result:
@@ -275,7 +297,7 @@ class Condition:
         self._prepare_steps()
 
         # Evaluate the condition
-        condition_result = self._evaluate_condition(step_input)
+        condition_result = self._evaluate_condition(step_input, session_state)
         log_debug(f"Condition {self.name} evaluated to: {condition_result}")
 
         if stream_intermediate_steps and workflow_run_response:
@@ -434,7 +456,7 @@ class Condition:
         self._prepare_steps()
 
         # Evaluate the condition
-        condition_result = await self._aevaluate_condition(step_input)
+        condition_result = await self._aevaluate_condition(step_input, session_state)
         log_debug(f"Condition {self.name} evaluated to: {condition_result}")
 
         if not condition_result:
@@ -543,7 +565,7 @@ class Condition:
         self._prepare_steps()
 
         # Evaluate the condition
-        condition_result = await self._aevaluate_condition(step_input)
+        condition_result = await self._aevaluate_condition(step_input, session_state)
         log_debug(f"Condition {self.name} evaluated to: {condition_result}")
 
         if stream_intermediate_steps and workflow_run_response:

agno/workflow/router.py

@@ -108,10 +108,13 @@ class Router:
             audio=current_audio + all_audio,
         )
 
-    def _route_steps(self, step_input: StepInput) -> List[Step]:  # type: ignore[return-value]
+    def _route_steps(self, step_input: StepInput, session_state: Optional[Dict[str, Any]] = None) -> List[Step]:  # type: ignore[return-value]
         """Route to the appropriate steps based on input"""
         if callable(self.selector):
-            result = self.selector(step_input)
+            if session_state is not None and self._selector_has_session_state_param():
+                result = self.selector(step_input, session_state)  # type: ignore[call-arg]
+            else:
+                result = self.selector(step_input)
 
             # Handle the result based on its type
             if isinstance(result, Step):
@@ -124,13 +127,21 @@ class Router:
 
         return []
 
-    async def _aroute_steps(self, step_input: StepInput) -> List[Step]:  # type: ignore[return-value]
+    async def _aroute_steps(self, step_input: StepInput, session_state: Optional[Dict[str, Any]] = None) -> List[Step]:  # type: ignore[return-value]
         """Async version of step routing"""
         if callable(self.selector):
+            has_session_state = session_state is not None and self._selector_has_session_state_param()
+            
             if inspect.iscoroutinefunction(self.selector):
-                result = await self.selector(step_input)
+                if has_session_state:
+                    result = await self.selector(step_input, session_state)  # type: ignore[call-arg]
+                else:
+                    result = await self.selector(step_input)
             else:
-                result = self.selector(step_input)
+                if has_session_state:
+                    result = self.selector(step_input, session_state)  # type: ignore[call-arg]
+                else:
+                    result = self.selector(step_input)
 
             # Handle the result based on its type
             if isinstance(result, Step):
@@ -143,6 +154,17 @@ class Router:
 
         return []
 
+    def _selector_has_session_state_param(self) -> bool:
+        """Check if the selector function has a session_state parameter"""
+        if not callable(self.selector):
+            return False
+
+        try:
+            sig = inspect.signature(self.selector)
+            return "session_state" in sig.parameters
+        except Exception:
+            return False
+
     def execute(
         self,
         step_input: StepInput,
@@ -163,7 +185,7 @@ class Router:
         self._prepare_steps()
 
         # Route to appropriate steps
-        steps_to_execute = self._route_steps(step_input)
+        steps_to_execute = self._route_steps(step_input, session_state)
         log_debug(f"Router {self.name}: Selected {len(steps_to_execute)} steps to execute")
 
         if not steps_to_execute:
@@ -263,7 +285,7 @@ class Router:
         router_step_id = str(uuid4())
 
         # Route to appropriate steps
-        steps_to_execute = self._route_steps(step_input)
+        steps_to_execute = self._route_steps(step_input, session_state)
         log_debug(f"Router {self.name}: Selected {len(steps_to_execute)} steps to execute")
 
         if stream_intermediate_steps and workflow_run_response:
@@ -413,7 +435,7 @@ class Router:
         self._prepare_steps()
 
         # Route to appropriate steps
-        steps_to_execute = await self._aroute_steps(step_input)
+        steps_to_execute = await self._aroute_steps(step_input, session_state)
         log_debug(f"Router {self.name} selected: {len(steps_to_execute)} steps to execute")
 
         if not steps_to_execute:
@@ -516,7 +538,7 @@ class Router:
         router_step_id = str(uuid4())
 
         # Route to appropriate steps
-        steps_to_execute = await self._aroute_steps(step_input)
+        steps_to_execute = await self._aroute_steps(step_input, session_state)
         log_debug(f"Router {self.name} selected: {len(steps_to_execute)} steps to execute")
 
         if stream_intermediate_steps and workflow_run_response: