agno 2.1.7__py3-none-any.whl → 2.1.8__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)
 
@@ -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:
+                self._execute_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

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,18 @@ 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 +352,28 @@ 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 +399,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 +447,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/step.py

@@ -5,6 +5,7 @@ from typing import Any, AsyncIterator, Awaitable, Callable, Dict, Iterator, List
 from uuid import uuid4
 
 from pydantic import BaseModel
+from typing_extensions import TypeGuard
 
 from agno.agent import Agent
 from agno.media import Audio, Image, Video
@@ -191,9 +192,8 @@ class Step:
         session_state: Optional[Dict[str, Any]] = None,
     ) -> Any:
         """Call custom async function with session_state support if the function accepts it"""
-        import inspect
 
-        if inspect.isasyncgenfunction(func):
+        if _is_async_generator_function(func):
             if session_state is not None and self._function_has_session_state_param():
                 return func(step_input, session_state)
             else:
@@ -231,16 +231,16 @@ class Step:
             try:
                 response: Union[RunOutput, TeamRunOutput, StepOutput]
                 if self._executor_type == "function":
-                    if inspect.iscoroutinefunction(self.active_executor) or inspect.isasyncgenfunction(
-                        self.active_executor
-                    ):
+                    if _is_async_callable(self.active_executor) or _is_async_generator_function(self.active_executor):
                         raise ValueError("Cannot use async function with synchronous execution")
-                    if inspect.isgeneratorfunction(self.active_executor):
+                    if _is_generator_function(self.active_executor):
                         content = ""
                         final_response = None
                         try:
                             for chunk in self._call_custom_function(
-                                self.active_executor, step_input, session_state_copy
+                                self.active_executor,
+                                step_input,
+                                session_state_copy,  # type: ignore[arg-type]
                             ):  # type: ignore
                                 if (
                                     hasattr(chunk, "content")
@@ -368,9 +368,7 @@ class Step:
             return False
 
         try:
-            from inspect import signature
-
-            sig = signature(self.active_executor)  # type: ignore
+            sig = inspect.signature(self.active_executor)  # type: ignore
             return "session_state" in sig.parameters
         except Exception:
             return False
@@ -449,12 +447,10 @@ class Step:
                 if self._executor_type == "function":
                     log_debug(f"Executing function executor for step: {self.name}")
 
-                    if inspect.iscoroutinefunction(self.active_executor) or inspect.isasyncgenfunction(
-                        self.active_executor
-                    ):
+                    if _is_async_callable(self.active_executor) or _is_async_generator_function(self.active_executor):
                         raise ValueError("Cannot use async function with synchronous execution")
 
-                    if inspect.isgeneratorfunction(self.active_executor):
+                    if _is_generator_function(self.active_executor):
                         log_debug("Function returned iterable, streaming events")
                         content = ""
                         try:
@@ -652,17 +648,17 @@ class Step:
         for attempt in range(self.max_retries + 1):
             try:
                 if self._executor_type == "function":
-                    import inspect
-
-                    if inspect.isgeneratorfunction(self.active_executor) or inspect.isasyncgenfunction(
+                    if _is_generator_function(self.active_executor) or _is_async_generator_function(
                         self.active_executor
                     ):
                         content = ""
                         final_response = None
                         try:
-                            if inspect.isgeneratorfunction(self.active_executor):
+                            if _is_generator_function(self.active_executor):
                                 iterator = self._call_custom_function(
-                                    self.active_executor, step_input, session_state_copy
+                                    self.active_executor,
+                                    step_input,
+                                    session_state_copy,  # type: ignore[arg-type]
                                 )  # type: ignore
                                 for chunk in iterator:  # type: ignore
                                     if (
@@ -676,9 +672,11 @@ class Step:
                                     if isinstance(chunk, StepOutput):
                                         final_response = chunk
                             else:
-                                if inspect.isasyncgenfunction(self.active_executor):
+                                if _is_async_generator_function(self.active_executor):
                                     iterator = await self._acall_custom_function(
-                                        self.active_executor, step_input, session_state_copy
+                                        self.active_executor,
+                                        step_input,
+                                        session_state_copy,  # type: ignore[arg-type]
                                     )  # type: ignore
                                     async for chunk in iterator:  # type: ignore
                                         if (
@@ -705,7 +703,7 @@ class Step:
                         else:
                             response = StepOutput(content=content)
                     else:
-                        if inspect.iscoroutinefunction(self.active_executor):
+                        if _is_async_callable(self.active_executor):
                             result = await self._acall_custom_function(
                                 self.active_executor, step_input, session_state_copy
                             )  # type: ignore
@@ -854,14 +852,15 @@ class Step:
 
                 if self._executor_type == "function":
                     log_debug(f"Executing async function executor for step: {self.name}")
-                    import inspect
 
                     # Check if the function is an async generator
-                    if inspect.isasyncgenfunction(self.active_executor):
+                    if _is_async_generator_function(self.active_executor):
                         content = ""
                         # It's an async generator - iterate over it
                         iterator = await self._acall_custom_function(
-                            self.active_executor, step_input, session_state_copy
+                            self.active_executor,
+                            step_input,
+                            session_state_copy,  # type: ignore[arg-type]
                         )  # type: ignore
                         async for event in iterator:  # type: ignore
                             if (
@@ -885,14 +884,14 @@ class Step:
                                     yield enriched_event  # type: ignore[misc]
                         if not final_response:
                             final_response = StepOutput(content=content)
-                    elif inspect.iscoroutinefunction(self.active_executor):
+                    elif _is_async_callable(self.active_executor):
                         # It's a regular async function - await it
                         result = await self._acall_custom_function(self.active_executor, step_input, session_state_copy)  # type: ignore
                         if isinstance(result, StepOutput):
                             final_response = result
                         else:
                             final_response = StepOutput(content=str(result))
-                    elif inspect.isgeneratorfunction(self.active_executor):
+                    elif _is_generator_function(self.active_executor):
                         content = ""
                         # It's a regular generator function - iterate over it
                         iterator = self._call_custom_function(self.active_executor, step_input, session_state_copy)  # type: ignore
@@ -1252,3 +1251,28 @@ class Step:
                 continue
 
         return videos
+
+
+def _is_async_callable(obj: Any) -> TypeGuard[Callable[..., Any]]:
+    """Checks if obj is an async callable (coroutine function or callable with async __call__)"""
+    return inspect.iscoroutinefunction(obj) or (callable(obj) and inspect.iscoroutinefunction(obj.__call__))
+
+
+def _is_generator_function(obj: Any) -> TypeGuard[Callable[..., Any]]:
+    """Checks if obj is a generator function, including callable class instances with generator __call__ methods"""
+    if inspect.isgeneratorfunction(obj):
+        return True
+    # Check if it's a callable class instance with a generator __call__ method
+    if callable(obj) and hasattr(obj, "__call__"):
+        return inspect.isgeneratorfunction(obj.__call__)
+    return False
+
+
+def _is_async_generator_function(obj: Any) -> TypeGuard[Callable[..., Any]]:
+    """Checks if obj is an async generator function, including callable class instances"""
+    if inspect.isasyncgenfunction(obj):
+        return True
+    # Check if it's a callable class instance with an async generator __call__ method
+    if callable(obj) and hasattr(obj, "__call__"):
+        return inspect.isasyncgenfunction(obj.__call__)
+    return False

{agno-2.1.7.dist-info → agno-2.1.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agno
-Version: 2.1.7
+Version: 2.1.8
 Summary: Agno: a lightweight library for building Multi-Agent Systems
 Author-email: Ashpreet Bedi <ashpreet@agno.com>
 Project-URL: homepage, https://agno.com