agno 1.7.4__py3-none-any.whl → 1.7.6__py3-none-any.whl

agno/workflow/v2/workflow.py

@@ -1,7 +1,20 @@
+import asyncio
 from dataclasses import dataclass
 from datetime import datetime
 from os import getenv
-from typing import Any, AsyncIterator, Awaitable, Callable, Dict, Iterator, List, Literal, Optional, Union, overload
+from typing import (
+    Any,
+    AsyncIterator,
+    Awaitable,
+    Callable,
+    Dict,
+    Iterator,
+    List,
+    Literal,
+    Optional,
+    Union,
+    overload,
+)
 from uuid import uuid4
 
 from pydantic import BaseModel
@@ -47,7 +60,13 @@ from agno.workflow.v2.parallel import Parallel
 from agno.workflow.v2.router import Router
 from agno.workflow.v2.step import Step
 from agno.workflow.v2.steps import Steps
-from agno.workflow.v2.types import StepInput, StepMetrics, StepOutput, WorkflowExecutionInput, WorkflowMetrics
+from agno.workflow.v2.types import (
+    StepInput,
+    StepMetrics,
+    StepOutput,
+    WorkflowExecutionInput,
+    WorkflowMetrics,
+)
 
 WorkflowSteps = Union[
     Callable[
@@ -536,9 +555,7 @@ class Workflow:
                 workflow_run_response.content = f"Workflow execution failed: {e}"
 
             finally:
-                if self.workflow_session:
-                    self.workflow_session.add_run(workflow_run_response)
-                self.write_to_storage()
+                self._save_run_to_storage(workflow_run_response)
 
         return workflow_run_response
 
@@ -722,11 +739,7 @@ class Workflow:
         yield self._handle_event(workflow_completed_event, workflow_run_response)
 
         # Store the completed workflow response
-        if self.workflow_session:
-            self.workflow_session.add_run(workflow_run_response)
-
-        # Save to storage after complete execution
-        self.write_to_storage()
+        self._save_run_to_storage(workflow_run_response)
 
     async def _acall_custom_function(
         self, func: Callable, workflow: "Workflow", execution_input: WorkflowExecutionInput, **kwargs: Any
@@ -808,7 +821,7 @@ class Workflow:
                         content += str(chunk)
                 workflow_run_response.content = content
             else:
-                workflow_run_response.content = self.steps(self, execution_input, **kwargs)
+                workflow_run_response.content = self._call_custom_function(self.steps, self, execution_input, **kwargs)
             workflow_run_response.status = RunStatus.completed
 
         else:
@@ -900,9 +913,7 @@ class Workflow:
                 workflow_run_response.content = f"Workflow execution failed: {e}"
 
         # Store error response
-        if self.workflow_session:
-            self.workflow_session.add_run(workflow_run_response)
-        self.write_to_storage()
+        self._save_run_to_storage(workflow_run_response)
 
         return workflow_run_response
 
@@ -1095,11 +1106,7 @@ class Workflow:
         yield self._handle_event(workflow_completed_event, workflow_run_response)
 
         # Store the completed workflow response
-        if self.workflow_session:
-            self.workflow_session.add_run(workflow_run_response)
-
-        # Save to storage after complete execution
-        self.write_to_storage()
+        self._save_run_to_storage(workflow_run_response)
 
     def _update_workflow_session_state(self):
         if not self.workflow_session_state:
@@ -1118,6 +1125,96 @@ class Workflow:
 
         return self.workflow_session_state
 
+    async def _arun_background(
+        self,
+        message: Optional[Union[str, Dict[str, Any], List[Any], BaseModel]] = None,
+        additional_data: Optional[Dict[str, Any]] = None,
+        user_id: Optional[str] = None,
+        session_id: Optional[str] = None,
+        audio: Optional[List[Audio]] = None,
+        images: Optional[List[Image]] = None,
+        videos: Optional[List[Video]] = None,
+        **kwargs: Any,
+    ) -> WorkflowRunResponse:
+        """Execute workflow in background using asyncio.create_task()"""
+
+        if user_id is not None:
+            self.user_id = user_id
+        if session_id is not None:
+            self.session_id = session_id
+
+        if self.session_id is None:
+            self.session_id = str(uuid4())
+
+        if self.run_id is None:
+            self.run_id = str(uuid4())
+
+        self.initialize_workflow()
+        self.load_session()
+        self._prepare_steps()
+
+        # Create workflow run response with PENDING status
+        workflow_run_response = WorkflowRunResponse(
+            run_id=self.run_id,
+            session_id=self.session_id,
+            workflow_id=self.workflow_id,
+            workflow_name=self.name,
+            created_at=int(datetime.now().timestamp()),
+            status=RunStatus.pending,
+        )
+
+        # Store PENDING response immediately
+        self._save_run_to_storage(workflow_run_response)
+
+        # Prepare execution input
+        inputs = WorkflowExecutionInput(
+            message=message,
+            additional_data=additional_data,
+            audio=audio,  # type: ignore
+            images=images,  # type: ignore
+            videos=videos,  # type: ignore
+        )
+
+        self.update_agents_and_teams_session_info()
+
+        async def execute_workflow_background():
+            """Simple background execution"""
+            try:
+                # Update status to RUNNING and save
+                workflow_run_response.status = RunStatus.running
+                self._save_run_to_storage(workflow_run_response)
+
+                await self._aexecute(execution_input=inputs, workflow_run_response=workflow_run_response, **kwargs)
+
+                self._save_run_to_storage(workflow_run_response)
+
+                log_debug(f"Background execution completed with status: {workflow_run_response.status}")
+
+            except Exception as e:
+                logger.error(f"Background workflow execution failed: {e}")
+                workflow_run_response.status = RunStatus.error
+                workflow_run_response.content = f"Background execution failed: {str(e)}"
+                self._save_run_to_storage(workflow_run_response)
+
+        # Create and start asyncio task
+        loop = asyncio.get_running_loop()
+        loop.create_task(execute_workflow_background())
+
+        # Return SAME object that will be updated by background execution
+        return workflow_run_response
+
+    def get_run(self, run_id: str) -> Optional[WorkflowRunResponse]:
+        """Get the status and details of a background workflow run - SIMPLIFIED"""
+        if self.storage is not None and self.session_id is not None:
+            session = self.storage.read(session_id=self.session_id)
+            if session and isinstance(session, WorkflowSessionV2) and session.runs:
+                # Find the run by ID
+                for run in session.runs:
+                    if run.run_id == run_id:
+                        return run
+
+        return None
+
     @overload
     def run(
         self,
@@ -1130,6 +1227,7 @@ class Workflow:
         videos: Optional[List[Video]] = None,
         stream: Literal[False] = False,
         stream_intermediate_steps: Optional[bool] = None,
+        background: Optional[bool] = False,
     ) -> WorkflowRunResponse: ...
 
     @overload
@@ -1144,6 +1242,7 @@ class Workflow:
         videos: Optional[List[Video]] = None,
         stream: Literal[True] = True,
         stream_intermediate_steps: Optional[bool] = None,
+        background: Optional[bool] = False,
     ) -> Iterator[WorkflowRunResponseEvent]: ...
 
     def run(
@@ -1157,9 +1256,14 @@ class Workflow:
         videos: Optional[List[Video]] = None,
         stream: bool = False,
         stream_intermediate_steps: Optional[bool] = None,
+        background: Optional[bool] = False,
         **kwargs: Any,
     ) -> Union[WorkflowRunResponse, Iterator[WorkflowRunResponseEvent]]:
         """Execute the workflow synchronously with optional streaming"""
+
+        if background:
+            raise RuntimeError("Background execution is not supported for sync run()")
+
         self._set_debug()
 
         log_debug(f"Workflow Run Start: {self.name}", center=True)
@@ -1240,6 +1344,7 @@ class Workflow:
         videos: Optional[List[Video]] = None,
         stream: Literal[False] = False,
         stream_intermediate_steps: Optional[bool] = None,
+        background: Optional[bool] = False,
     ) -> WorkflowRunResponse: ...
 
     @overload
@@ -1254,6 +1359,7 @@ class Workflow:
         videos: Optional[List[Video]] = None,
         stream: Literal[True] = True,
         stream_intermediate_steps: Optional[bool] = None,
+        background: Optional[bool] = False,
     ) -> AsyncIterator[WorkflowRunResponseEvent]: ...
 
     async def arun(
@@ -1267,9 +1373,22 @@ class Workflow:
         videos: Optional[List[Video]] = None,
         stream: bool = False,
         stream_intermediate_steps: Optional[bool] = False,
+        background: Optional[bool] = False,
         **kwargs: Any,
     ) -> Union[WorkflowRunResponse, AsyncIterator[WorkflowRunResponseEvent]]:
         """Execute the workflow synchronously with optional streaming"""
+        if background:
+            return await self._arun_background(
+                message=message,
+                additional_data=additional_data,
+                user_id=user_id,
+                session_id=session_id,
+                audio=audio,
+                images=images,
+                videos=videos,
+                **kwargs,
+            )
+
         self._set_debug()
 
         log_debug(f"Async Workflow Run Start: {self.name}", center=True)
@@ -3103,6 +3222,12 @@ class Workflow:
             # Update session_state with workflow_session_state
             executor.workflow_session_state = self.workflow_session_state
 
+    def _save_run_to_storage(self, workflow_run_response: WorkflowRunResponse) -> None:
+        """Helper method to save workflow run response to storage"""
+        if self.workflow_session:
+            self.workflow_session.upsert_run(workflow_run_response)
+            self.write_to_storage()
+
     def update_agents_and_teams_session_info(self):
         """Update agents and teams with workflow session information"""
         log_debug("Updating agents and teams with session information")

agno/workflow/workflow.py

@@ -5,7 +5,7 @@ import inspect
 from dataclasses import dataclass, field, fields
 from os import getenv
 from types import GeneratorType
-from typing import Any, AsyncGenerator, AsyncIterator, Callable, Dict, List, Optional, Union, cast, get_args
+from typing import Any, AsyncIterator, Callable, Dict, List, Optional, Union, cast, get_args
 from uuid import uuid4
 
 from pydantic import BaseModel
@@ -125,6 +125,8 @@ class Workflow:
         # Private attributes to store the run method and its parameters
         # The run function provided by the subclass
         self._subclass_run: Optional[Callable] = None
+        self._subclass_arun: Optional[Callable] = None
+
         # Parameters of the run function
         self._run_parameters: Optional[Dict[str, Any]] = None
         # Return type of the run function
@@ -242,7 +244,6 @@ class Workflow:
             return None
 
     # Add to workflow.py after the run_workflow method
-
     async def arun_workflow(self, **kwargs: Any):
         """Run the Workflow asynchronously"""
 
@@ -269,60 +270,14 @@ class Workflow:
 
         log_debug(f"Workflow Run Start: {self.run_id}", center=True)
         try:
-            from inspect import isasyncgen, isasyncgenfunction
-
-            self._subclass_run = cast(Callable, self._subclass_run)
-            if isasyncgenfunction(self._subclass_run) or isasyncgen(self._subclass_run):
-                result = self._subclass_run(**kwargs)
-            else:
-                result = await self._subclass_run(**kwargs)
+            self._subclass_arun = cast(Callable, self._subclass_arun)
+            result = await self._subclass_arun(**kwargs)
         except Exception as e:
             logger.error(f"Workflow.arun() failed: {e}")
             raise e
 
-        # Handle async iterator results
-        if isinstance(result, (AsyncIterator, AsyncGenerator)):
-            # Initialize the run_response content
-            self.run_response.content = ""
-
-            async def result_generator():
-                self.run_response = cast(RunResponse, self.run_response)
-                if isinstance(self.memory, WorkflowMemory):
-                    self.memory = cast(WorkflowMemory, self.memory)
-                elif isinstance(self.memory, Memory):
-                    self.memory = cast(Memory, self.memory)
-
-                async for item in result:
-                    if (
-                        isinstance(item, tuple(get_args(RunResponseEvent)))
-                        or isinstance(item, tuple(get_args(TeamRunResponseEvent)))
-                        or isinstance(item, tuple(get_args(WorkflowRunResponseEvent)))
-                        or isinstance(item, RunResponse)
-                    ):
-                        # Update the run_id, session_id and workflow_id of the RunResponseEvent
-                        item.run_id = self.run_id
-                        item.session_id = self.session_id
-                        item.workflow_id = self.workflow_id
-
-                        # Update the run_response with the content from the result
-                        if hasattr(item, "content") and item.content is not None and isinstance(item.content, str):
-                            self.run_response.content += item.content
-                    else:
-                        logger.warning(f"Workflow.arun() should only yield RunResponseEvent objects, got: {type(item)}")
-                    yield item
-
-                # Add the run to the memory
-                if isinstance(self.memory, WorkflowMemory):
-                    self.memory.add_run(WorkflowRun(input=self.run_input, response=self.run_response))
-                elif isinstance(self.memory, Memory):
-                    self.memory.add_run(session_id=self.session_id, run=self.run_response)  # type: ignore
-                # Write this run to the database
-                self.write_to_storage()
-                log_debug(f"Workflow Run End: {self.run_id}", center=True)
-
-            return result_generator()
         # Handle single RunResponse result
-        elif isinstance(result, RunResponse):
+        if isinstance(result, RunResponse):
             # Update the result with the run_id, session_id and workflow_id of the workflow run
             result.run_id = self.run_id
             result.session_id = self.session_id
@@ -345,6 +300,66 @@ class Workflow:
             logger.warning(f"Workflow.arun() should only return RunResponse objects, got: {type(result)}")
             return None
 
+    async def arun_workflow_generator(self, **kwargs: Any) -> AsyncIterator[RunResponse]:
+        """Run the Workflow asynchronously for async generators"""
+
+        # Set mode, debug, workflow_id, session_id, initialize memory
+        self.set_storage_mode()
+        self.set_debug()
+        self.set_monitoring()
+        self.set_workflow_id()  # Ensure workflow_id is set
+        self.set_session_id()
+        self.initialize_memory()
+
+        # Create a run_id
+        self.run_id = str(uuid4())
+
+        # Set run_input, run_response
+        self.run_input = kwargs
+        self.run_response = RunResponse(run_id=self.run_id, session_id=self.session_id, workflow_id=self.workflow_id)
+
+        # Read existing session from storage
+        self.read_from_storage()
+
+        # Update the session_id for all Agent instances
+        self.update_agent_session_ids()
+
+        log_debug(f"Workflow Run Start: {self.run_id}", center=True)
+        # Initialize the run_response content
+        self.run_response.content = ""
+        try:
+            self._subclass_arun = cast(Callable, self._subclass_arun)
+            async for item in self._subclass_arun(**kwargs):
+                if (
+                    isinstance(item, tuple(get_args(RunResponseEvent)))
+                    or isinstance(item, tuple(get_args(TeamRunResponseEvent)))
+                    or isinstance(item, tuple(get_args(WorkflowRunResponseEvent)))
+                    or isinstance(item, RunResponse)
+                ):
+                    # Update the run_id, session_id and workflow_id of the RunResponseEvent
+                    item.run_id = self.run_id
+                    item.session_id = self.session_id
+                    item.workflow_id = self.workflow_id
+
+                    # Update the run_response with the content from the result
+                    if hasattr(item, "content") and item.content is not None and isinstance(item.content, str):
+                        self.run_response.content += item.content
+                else:
+                    logger.warning(f"Workflow.run() should only yield RunResponseEvent objects, got: {type(item)}")
+                yield item
+
+            # Add the run to the memory
+            if isinstance(self.memory, WorkflowMemory):
+                self.memory.add_run(WorkflowRun(input=self.run_input, response=self.run_response))
+            elif isinstance(self.memory, Memory):
+                self.memory.add_run(session_id=self.session_id, run=self.run_response)  # type: ignore
+            # Write this run to the database
+            self.write_to_storage()
+            log_debug(f"Workflow Run End: {self.run_id}", center=True)
+        except Exception as e:
+            logger.error(f"Workflow.arun() failed: {e}")
+            raise e
+
     async def arun(self, **kwargs: Any):
         """Async version of run() that calls arun_workflow()"""
         logger.error(f"{self.__class__.__name__}.arun() method not implemented.")
@@ -392,23 +407,32 @@ class Workflow:
             self.memory = Memory()
 
     def update_run_method(self):
+        run_type = None
         # Update the run() method to call run_workflow() instead of the subclass's run()
         # First, check if the subclass has a run method
         #   If the run() method has been overridden by the subclass,
         #   then self.__class__.run is not Workflow.run will be True
-        run_type = "sync"
-        if self.__class__.run is not Workflow.run or self.__class__.arun is not Workflow.arun:
+        if self.__class__.run is not Workflow.run:
             # Store the original run methods bound to the instance
-            if self.__class__.run is not Workflow.run:
-                self._subclass_run = self.__class__.run.__get__(self)
-                # Get the parameters of the sync run method
-                sig = inspect.signature(self.__class__.run)
-            if self.__class__.arun is not Workflow.arun:
-                self._subclass_run = self.__class__.arun.__get__(self)
-                # Get the parameters of the async run method
-                sig = inspect.signature(self.__class__.arun)
-                run_type = "async"
+            self._subclass_run = self.__class__.run.__get__(self)
+            run_type = "sync"
+            # Get the parameters of the sync run method
+            sig = inspect.signature(self.__class__.run)
+
+        if self.__class__.arun is not Workflow.arun:
+            self._subclass_arun = self.__class__.arun.__get__(self)
+            run_type = "coroutine"
+
+            # Get the parameters of the async run method
+            sig = inspect.signature(self.__class__.arun)
+
+            # Check if the async method is a coroutine or async generator
+            from inspect import isasyncgenfunction
+
+            if isasyncgenfunction(self.__class__.arun):
+                run_type = "async_generator"
 
+        if run_type is not None:
             # Convert parameters to a serializable format
             self._run_parameters = {
                 param_name: {
@@ -445,12 +469,15 @@ class Workflow:
             # This is so we call run_workflow() instead of the subclass's run()
             if run_type == "sync":
                 object.__setattr__(self, "run", self.run_workflow.__get__(self))
-            elif run_type == "async":
+            elif run_type == "coroutine":
                 object.__setattr__(self, "arun", self.arun_workflow.__get__(self))
+            elif run_type == "async_generator":
+                object.__setattr__(self, "arun", self.arun_workflow_generator.__get__(self))
         else:
             # If the subclass does not override the run method,
             # the Workflow.run() method will be called and will log an error
             self._subclass_run = self.run
+            self._subclass_arun = self.arun
 
             self._run_parameters = {}
             self._run_return_type = None

{agno-1.7.4.dist-info → agno-1.7.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agno
-Version: 1.7.4
+Version: 1.7.6
 Summary: Agno: a lightweight library for building Multi-Agent Systems
 Author-email: Ashpreet Bedi <ashpreet@agno.com>
 License: Copyright (c) Agno, Inc.
@@ -443,6 +443,9 @@ Requires-Dist: opentelemetry-exporter-otlp-proto-grpc; extra == "arize"
 Requires-Dist: opentelemetry-distro; extra == "arize"
 Provides-Extra: langfuse
 Requires-Dist: langfuse; extra == "langfuse"
+Provides-Extra: aws-bedrock
+Requires-Dist: boto3; extra == "aws-bedrock"
+Requires-Dist: aioboto3; extra == "aws-bedrock"
 Provides-Extra: anthropic
 Requires-Dist: anthropic; extra == "anthropic"
 Provides-Extra: azure
@@ -472,6 +475,8 @@ Provides-Extra: ollama
 Requires-Dist: ollama; extra == "ollama"
 Provides-Extra: openai
 Requires-Dist: openai; extra == "openai"
+Provides-Extra: portkey
+Requires-Dist: portkey-ai; extra == "portkey"
 Provides-Extra: agentql
 Requires-Dist: agentql; extra == "agentql"
 Provides-Extra: apify
@@ -491,6 +496,8 @@ Provides-Extra: duckdb
 Requires-Dist: duckdb; extra == "duckdb"
 Provides-Extra: elevenlabs
 Requires-Dist: elevenlabs; extra == "elevenlabs"
+Provides-Extra: evm
+Requires-Dist: web3; extra == "evm"
 Provides-Extra: exa
 Requires-Dist: exa_py; extra == "exa"
 Provides-Extra: fal
@@ -521,6 +528,8 @@ Requires-Dist: newspaper4k; extra == "newspaper"
 Requires-Dist: lxml_html_clean; extra == "newspaper"
 Provides-Extra: opencv
 Requires-Dist: opencv-python; extra == "opencv"
+Provides-Extra: psycopg2
+Requires-Dist: psycopg2-binary; extra == "psycopg2"
 Provides-Extra: todoist
 Requires-Dist: todoist-api-python; extra == "todoist"
 Provides-Extra: valyu
@@ -533,6 +542,8 @@ Provides-Extra: youtube
 Requires-Dist: youtube_transcript_api; extra == "youtube"
 Provides-Extra: zep
 Requires-Dist: zep-cloud; extra == "zep"
+Provides-Extra: daytona
+Requires-Dist: daytona; extra == "daytona"
 Provides-Extra: oxylabs
 Requires-Dist: oxylabs; extra == "oxylabs"
 Provides-Extra: sql
@@ -573,6 +584,8 @@ Provides-Extra: clickhouse
 Requires-Dist: clickhouse-connect; extra == "clickhouse"
 Provides-Extra: pinecone
 Requires-Dist: pinecone==5.4.2; extra == "pinecone"
+Provides-Extra: surrealdb
+Requires-Dist: surrealdb>=1.0.4; extra == "surrealdb"
 Provides-Extra: pdf
 Requires-Dist: pypdf; extra == "pdf"
 Requires-Dist: rapidocr_onnxruntime; extra == "pdf"
@@ -601,6 +614,7 @@ Provides-Extra: aws
 Requires-Dist: agno-aws; extra == "aws"
 Requires-Dist: agno-docker; extra == "aws"
 Provides-Extra: models
+Requires-Dist: agno[aws-bedrock]; extra == "models"
 Requires-Dist: agno[anthropic]; extra == "models"
 Requires-Dist: agno[azure]; extra == "models"
 Requires-Dist: agno[cerebras]; extra == "models"
@@ -615,6 +629,7 @@ Requires-Dist: agno[meta]; extra == "models"
 Requires-Dist: agno[mistral]; extra == "models"
 Requires-Dist: agno[ollama]; extra == "models"
 Requires-Dist: agno[openai]; extra == "models"
+Requires-Dist: agno[portkey]; extra == "models"
 Provides-Extra: tools
 Requires-Dist: agno[apify]; extra == "tools"
 Requires-Dist: agno[brave]; extra == "tools"
@@ -632,6 +647,7 @@ Requires-Dist: agno[googlemaps]; extra == "tools"
 Requires-Dist: agno[todoist]; extra == "tools"
 Requires-Dist: agno[matplotlib]; extra == "tools"
 Requires-Dist: agno[elevenlabs]; extra == "tools"
+Requires-Dist: agno[evm]; extra == "tools"
 Requires-Dist: agno[fal]; extra == "tools"
 Requires-Dist: agno[webex]; extra == "tools"
 Requires-Dist: agno[mcp]; extra == "tools"
@@ -644,6 +660,7 @@ Requires-Dist: agno[oxylabs]; extra == "tools"
 Requires-Dist: agno[zep]; extra == "tools"
 Requires-Dist: agno[mem0]; extra == "tools"
 Requires-Dist: agno[google_bigquery]; extra == "tools"
+Requires-Dist: agno[psycopg2]; extra == "tools"
 Provides-Extra: storage
 Requires-Dist: agno[sql]; extra == "storage"
 Requires-Dist: agno[postgres]; extra == "storage"
@@ -664,6 +681,7 @@ Requires-Dist: agno[weaviate]; extra == "vectordbs"
 Requires-Dist: agno[milvusdb]; extra == "vectordbs"
 Requires-Dist: agno[clickhouse]; extra == "vectordbs"
 Requires-Dist: agno[pinecone]; extra == "vectordbs"
+Requires-Dist: agno[surrealdb]; extra == "vectordbs"
 Provides-Extra: knowledge
 Requires-Dist: agno[pdf]; extra == "knowledge"
 Requires-Dist: agno[docx]; extra == "knowledge"