agno 1.7.3__py3-none-any.whl → 1.7.5__py3-none-any.whl

agno/app/fastapi/sync_router.py

@@ -1,7 +1,7 @@
 import json
 from dataclasses import asdict
 from io import BytesIO
-from typing import Any, Dict, Generator, List, Optional, cast
+from typing import Any, Dict, Generator, List, Optional, Union, cast
 from uuid import uuid4
 
 from fastapi import APIRouter, File, Form, HTTPException, Query, UploadFile
@@ -15,8 +15,10 @@ from agno.run.base import RunStatus
 from agno.run.response import RunResponseEvent
 from agno.run.team import RunResponseErrorEvent as TeamRunResponseErrorEvent
 from agno.run.team import TeamRunResponseEvent
+from agno.run.v2.workflow import WorkflowErrorEvent
 from agno.team.team import Team
 from agno.utils.log import logger
+from agno.workflow.v2.workflow import Workflow as WorkflowV2
 from agno.workflow.workflow import Workflow
 
 
@@ -82,6 +84,42 @@ def team_chat_response_streamer(
         return
 
 
+def workflow_response_streamer(
+    workflow: WorkflowV2,
+    body: Union[Dict[str, Any], str],
+    session_id: Optional[str] = None,
+    user_id: Optional[str] = None,
+) -> Generator:
+    try:
+        if isinstance(body, dict):
+            run_response = workflow.run(
+                **body,
+                user_id=user_id,
+                session_id=session_id,
+                stream=True,
+                stream_intermediate_steps=True,
+            )
+        else:
+            run_response = workflow.run(
+                body,
+                user_id=user_id,
+                session_id=session_id,
+                stream=True,
+                stream_intermediate_steps=True,
+            )
+        for run_response_chunk in run_response:
+            yield run_response_chunk.to_json()
+    except Exception as e:
+        import traceback
+
+        traceback.print_exc(limit=3)
+        error_response = WorkflowErrorEvent(
+            error=str(e),
+        )
+        yield error_response.to_json()
+        return
+
+
 def get_sync_router(
     agents: Optional[List[Agent]] = None, teams: Optional[List[Team]] = None, workflows: Optional[List[Workflow]] = None
 ) -> APIRouter:
@@ -251,12 +289,12 @@ def get_sync_router(
     @router.post("/runs")
     def run_agent_or_team_or_workflow(
         message: str = Form(None),
-        stream: bool = Form(True),
+        stream: bool = Form(False),
         monitor: bool = Form(False),
         agent_id: Optional[str] = Query(None),
         team_id: Optional[str] = Query(None),
         workflow_id: Optional[str] = Query(None),
-        workflow_input: Optional[Dict[str, Any]] = Form(None),
+        workflow_input: Optional[str] = Form(None),
         session_id: Optional[str] = Form(None),
         user_id: Optional[str] = Form(None),
         files: Optional[List[UploadFile]] = File(None),
@@ -297,6 +335,13 @@ def get_sync_router(
             if not workflow_input:
                 raise HTTPException(status_code=400, detail="Workflow input is required")
 
+            # Parse workflow_input into a dict if it is a valid JSON
+            try:
+                parsed_workflow_input = json.loads(workflow_input)
+                workflow_input = parsed_workflow_input
+            except json.JSONDecodeError:
+                pass
+
         if agent:
             agent.monitoring = bool(monitor)
         elif team:
@@ -339,13 +384,25 @@ def get_sync_router(
                     media_type="text/event-stream",
                 )
             elif workflow:
-                workflow_instance = workflow.deep_copy(update={"workflow_id": workflow_id})
-                workflow_instance.user_id = user_id
-                workflow_instance.session_name = None
-                return StreamingResponse(
-                    (json.dumps(asdict(result)) for result in workflow_instance.run(**(workflow_input or {}))),
-                    media_type="text/event-stream",
-                )
+                if isinstance(workflow, Workflow):
+                    workflow_instance = workflow.deep_copy(update={"workflow_id": workflow_id})
+                    workflow_instance.user_id = user_id
+                    workflow_instance.session_name = None
+                    if isinstance(workflow_input, dict):
+                        return StreamingResponse(
+                            (json.dumps(asdict(result)) for result in workflow_instance.run(**workflow_input)),
+                            media_type="text/event-stream",
+                        )
+                    else:
+                        return StreamingResponse(
+                            (json.dumps(asdict(result)) for result in workflow_instance.run(workflow_input)),  # type: ignore
+                            media_type="text/event-stream",
+                        )
+                else:
+                    return StreamingResponse(
+                        workflow_response_streamer(workflow, workflow_input, session_id=session_id, user_id=user_id),
+                        media_type="text/event-stream",
+                    )
         else:
             if agent:
                 run_response = cast(
@@ -374,9 +431,18 @@ def get_sync_router(
                 )
                 return team_run_response.to_dict()
             elif workflow:
-                workflow_instance = workflow.deep_copy(update={"workflow_id": workflow_id})
-                workflow_instance.user_id = user_id
-                workflow_instance.session_name = None
-                return workflow_instance.run(**(workflow_input or {})).to_dict()
+                if isinstance(workflow, Workflow):
+                    workflow_instance = workflow.deep_copy(update={"workflow_id": workflow_id})
+                    workflow_instance.user_id = user_id
+                    workflow_instance.session_name = None
+                    if isinstance(workflow_input, dict):
+                        return workflow_instance.run(**workflow_input).to_dict()
+                    else:
+                        return workflow_instance.run(workflow_input).to_dict()  # type: ignore
+                else:
+                    if isinstance(workflow_input, dict):
+                        return workflow.run(**workflow_input, session_id=session_id, user_id=user_id).to_dict()
+                    else:
+                        return workflow.run(workflow_input, session_id=session_id, user_id=user_id).to_dict()
 
     return router

agno/app/playground/app.py

@@ -83,7 +83,7 @@ class Playground:
 
         if self.workflows:
             for workflow in self.workflows:
-                if not workflow.app_id:
+                if hasattr(workflow, "app_id") and not workflow.app_id:
                     workflow.app_id = self.app_id
                 if not workflow.workflow_id:
                     workflow.workflow_id = generate_id(workflow.name)
@@ -197,6 +197,7 @@ class Playground:
         # Print the panel
         console.print(panel)
         self.set_app_id()
+
         self.register_app_on_platform()
 
         uvicorn.run(app=app, host=host, port=port, reload=reload, **kwargs)

agno/app/playground/async_router.py

@@ -38,11 +38,13 @@ from agno.memory.agent import AgentMemory
 from agno.memory.v2 import Memory
 from agno.run.response import RunResponseErrorEvent, RunResponseEvent
 from agno.run.team import RunResponseErrorEvent as TeamRunResponseErrorEvent
+from agno.run.v2.workflow import WorkflowErrorEvent
 from agno.storage.session.agent import AgentSession
 from agno.storage.session.team import TeamSession
 from agno.storage.session.workflow import WorkflowSession
 from agno.team.team import Team
 from agno.utils.log import logger
+from agno.workflow.v2.workflow import Workflow as WorkflowV2
 from agno.workflow.workflow import Workflow
 
 
@@ -146,6 +148,31 @@ async def team_chat_response_streamer(
         return
 
 
+async def workflow_response_streamer(
+    workflow: WorkflowV2,
+    body: WorkflowRunRequest,
+) -> AsyncGenerator:
+    try:
+        run_response = await workflow.arun(
+            **body.input,
+            user_id=body.user_id,
+            session_id=body.session_id or str(uuid4()),
+            stream=True,
+            stream_intermediate_steps=True,
+        )
+        async for run_response_chunk in run_response:
+            yield run_response_chunk.to_json()
+    except Exception as e:
+        import traceback
+
+        traceback.print_exc(limit=3)
+        error_response = WorkflowErrorEvent(
+            error=str(e),
+        )
+        yield error_response.to_json()
+        return
+
+
 def get_async_playground_router(
     agents: Optional[List[Agent]] = None,
     workflows: Optional[List[Workflow]] = None,
@@ -616,13 +643,22 @@ def get_async_playground_router(
         if workflow is None:
             raise HTTPException(status_code=404, detail="Workflow not found")
 
-        return WorkflowGetResponse(
-            workflow_id=workflow.workflow_id,
-            name=workflow.name,
-            description=workflow.description,
-            parameters=workflow._run_parameters or {},
-            storage=workflow.storage.__class__.__name__ if workflow.storage else None,
-        )
+        if isinstance(workflow, Workflow):
+            return WorkflowGetResponse(
+                workflow_id=workflow.workflow_id,
+                name=workflow.name,
+                description=workflow.description,
+                parameters=workflow._run_parameters or {},
+                storage=workflow.storage.__class__.__name__ if workflow.storage else None,
+            )
+        else:
+            return WorkflowGetResponse(
+                workflow_id=workflow.workflow_id,
+                name=workflow.name,
+                description=workflow.description,
+                parameters=workflow.run_parameters,
+                storage=workflow.storage.__class__.__name__ if workflow.storage else None,
+            )
 
     @playground_router.post("/workflows/{workflow_id}/runs")
     async def create_workflow_run(workflow_id: str, body: WorkflowRunRequest):
@@ -637,24 +673,54 @@ def get_async_playground_router(
             logger.debug("Creating new session")
 
         # Create a new instance of this workflow
-        new_workflow_instance = workflow.deep_copy(update={"workflow_id": workflow_id, "session_id": body.session_id})
-        new_workflow_instance.user_id = body.user_id
-        new_workflow_instance.session_name = None
+        if isinstance(workflow, Workflow):
+            new_workflow_instance = workflow.deep_copy(
+                update={"workflow_id": workflow_id, "session_id": body.session_id}
+            )
+            new_workflow_instance.user_id = body.user_id
+            new_workflow_instance.session_name = None
 
-        # Return based on the response type
-        try:
-            if new_workflow_instance._run_return_type == "RunResponse":
-                # Return as a normal response
-                return new_workflow_instance.run(**body.input)
-            else:
-                # Return as a streaming response
-                return StreamingResponse(
-                    (result.to_json() for result in new_workflow_instance.run(**body.input)),
-                    media_type="text/event-stream",
-                )
-        except Exception as e:
-            # Handle unexpected runtime errors
-            raise HTTPException(status_code=500, detail=f"Error running workflow: {str(e)}")
+            # Return based on the response type
+            try:
+                if new_workflow_instance._run_return_type == "RunResponse":
+                    # Return as a normal response
+                    return new_workflow_instance.run(**body.input)
+                else:
+                    # Return as a streaming response
+                    return StreamingResponse(
+                        (result.to_json() for result in new_workflow_instance.run(**body.input)),
+                        media_type="text/event-stream",
+                        headers={
+                            "Access-Control-Allow-Origin": "*",
+                            "Access-Control-Allow-Methods": "POST, OPTIONS",
+                            "Access-Control-Allow-Headers": "Content-Type, Authorization",
+                        },
+                    )
+            except Exception as e:
+                # Handle unexpected runtime errors
+                raise HTTPException(status_code=500, detail=f"Error running workflow: {str(e)}")
+        else:
+            # Return based on the response type
+            try:
+                if body.stream:
+                    # Return as a streaming response
+                    return StreamingResponse(
+                        workflow_response_streamer(workflow, body),
+                        media_type="text/event-stream",
+                        headers={
+                            "Access-Control-Allow-Origin": "*",
+                            "Access-Control-Allow-Methods": "POST, OPTIONS",
+                            "Access-Control-Allow-Headers": "Content-Type, Authorization",
+                        },
+                    )
+                else:
+                    # Return as a normal response
+                    return await workflow.arun(
+                        **body.input, session_id=body.session_id or str(uuid4()), user_id=body.user_id
+                    )
+            except Exception as e:
+                # Handle unexpected runtime errors
+                raise HTTPException(status_code=500, detail=f"Error running workflow: {str(e)}")
 
     @playground_router.get("/workflows/{workflow_id}/sessions")
     async def get_all_workflow_sessions(workflow_id: str, user_id: Optional[str] = Query(None, min_length=1)):
@@ -689,7 +755,7 @@ def get_async_playground_router(
             )
         return workflow_sessions
 
-    @playground_router.get("/workflows/{workflow_id}/sessions/{session_id}", response_model=WorkflowSession)
+    @playground_router.get("/workflows/{workflow_id}/sessions/{session_id}")
     async def get_workflow_session(
         workflow_id: str, session_id: str, user_id: Optional[str] = Query(None, min_length=1)
     ):
@@ -704,15 +770,18 @@ def get_async_playground_router(
 
         # Retrieve the specific session
         try:
-            workflow_session: Optional[WorkflowSession] = workflow.storage.read(session_id, user_id)  # type: ignore
+            workflow_session = workflow.storage.read(session_id, user_id)  # type: ignore
         except Exception as e:
             raise HTTPException(status_code=500, detail=f"Error retrieving session: {str(e)}")
 
         if not workflow_session:
             raise HTTPException(status_code=404, detail="Session not found")
 
-        # Return the session
-        return workflow_session
+        workflow_session_dict = workflow_session.to_dict()
+        if "memory" not in workflow_session_dict:
+            workflow_session_dict["memory"] = {"runs": workflow_session_dict.pop("runs", [])}
+
+        return JSONResponse(content=workflow_session_dict)
 
     @playground_router.post("/workflows/{workflow_id}/sessions/{session_id}/rename")
     async def rename_workflow_session(workflow_id: str, session_id: str, body: WorkflowRenameRequest):

agno/app/playground/operator.py

@@ -92,30 +92,36 @@ def get_session_title_from_workflow_session(workflow_session: WorkflowSession) -
     )
     if session_name is not None:
         return session_name
-    memory = workflow_session.memory
-    if memory is not None:
-        runs = memory.get("runs")
-        runs = cast(List[Any], runs)
-        for _run in runs:
-            try:
-                # Try to get content directly from the run first (workflow structure)
-                content = _run.get("content")
-                if content:
-                    # Split content by newlines and take first line, but limit to 100 chars
-                    first_line = content.split("\n")[0]
-                    return first_line[:100] + "..." if len(first_line) > 100 else first_line
-
-                # Fallback to response.content structure (if it exists)
-                response = _run.get("response")
-                if response:
-                    content = response.get("content")
+    if hasattr(workflow_session, "memory"):
+        memory = workflow_session.memory
+        if memory is not None:
+            runs = memory.get("runs")
+            runs = cast(List[Any], runs)
+            for _run in runs:
+                try:
+                    # Try to get content directly from the run first (workflow structure)
+                    content = _run.get("content")
                     if content:
                         # Split content by newlines and take first line, but limit to 100 chars
                         first_line = content.split("\n")[0]
                         return first_line[:100] + "..." if len(first_line) > 100 else first_line
 
-            except Exception as e:
-                logger.error(f"Error parsing workflow session: {e}")
+                    # Fallback to response.content structure (if it exists)
+                    response = _run.get("response")
+                    if response:
+                        content = response.get("content")
+                        if content:
+                            # Split content by newlines and take first line, but limit to 100 chars
+                            first_line = content.split("\n")[0]
+                            return first_line[:100] + "..." if len(first_line) > 100 else first_line
+
+                except Exception as e:
+                    logger.error(f"Error parsing workflow session: {e}")
+    if hasattr(workflow_session, "runs"):
+        if workflow_session.runs is not None and len(workflow_session.runs) > 0:
+            for _run in workflow_session.runs:
+                if _run.content:
+                    return _run.content[:100] + "..." if len(_run.content) > 100 else _run.content
     return "Unnamed session"
 
 

agno/app/playground/schemas.py

@@ -107,6 +107,7 @@ class WorkflowRunRequest(BaseModel):
     input: Dict[str, Any]
     user_id: Optional[str] = None
     session_id: Optional[str] = None
+    stream: bool = True
 
 
 class WorkflowSessionResponse(BaseModel):

agno/app/playground/sync_router.py

@@ -38,11 +38,13 @@ from agno.memory.agent import AgentMemory
 from agno.memory.v2 import Memory
 from agno.run.response import RunResponseErrorEvent, RunResponseEvent
 from agno.run.team import RunResponseErrorEvent as TeamRunResponseErrorEvent
+from agno.run.v2.workflow import WorkflowErrorEvent
 from agno.storage.session.agent import AgentSession
 from agno.storage.session.team import TeamSession
 from agno.storage.session.workflow import WorkflowSession
 from agno.team.team import Team
 from agno.utils.log import logger
+from agno.workflow.v2.workflow import Workflow as WorkflowV2
 from agno.workflow.workflow import Workflow
 
 
@@ -147,6 +149,31 @@ def team_chat_response_streamer(
         return
 
 
+def workflow_response_streamer(
+    workflow: WorkflowV2,
+    body: WorkflowRunRequest,
+) -> Generator:
+    try:
+        run_response = workflow.run(
+            **body.input,
+            user_id=body.user_id,
+            session_id=body.session_id or str(uuid4()),
+            stream=True,
+            stream_intermediate_steps=True,
+        )
+        for run_response_chunk in run_response:
+            yield run_response_chunk.to_json()
+    except Exception as e:
+        import traceback
+
+        traceback.print_exc(limit=3)
+        error_response = WorkflowErrorEvent(
+            error=str(e),
+        )
+        yield error_response.to_json()
+        return
+
+
 def get_sync_playground_router(
     agents: Optional[List[Agent]] = None,
     workflows: Optional[List[Workflow]] = None,
@@ -615,13 +642,22 @@ def get_sync_playground_router(
         if workflow is None:
             raise HTTPException(status_code=404, detail="Workflow not found")
 
-        return WorkflowGetResponse(
-            workflow_id=workflow.workflow_id,
-            name=workflow.name,
-            description=workflow.description,
-            parameters=workflow._run_parameters or {},
-            storage=workflow.storage.__class__.__name__ if workflow.storage else None,
-        )
+        if isinstance(workflow, Workflow):
+            return WorkflowGetResponse(
+                workflow_id=workflow.workflow_id,
+                name=workflow.name,
+                description=workflow.description,
+                parameters=workflow._run_parameters or {},
+                storage=workflow.storage.__class__.__name__ if workflow.storage else None,
+            )
+        else:
+            return WorkflowGetResponse(
+                workflow_id=workflow.workflow_id,
+                name=workflow.name,
+                description=workflow.description,
+                parameters=workflow.run_parameters,
+                storage=workflow.storage.__class__.__name__ if workflow.storage else None,
+            )
 
     @playground_router.post("/workflows/{workflow_id}/runs")
     def create_workflow_run(workflow_id: str, body: WorkflowRunRequest):
@@ -631,24 +667,52 @@ def get_sync_playground_router(
             raise HTTPException(status_code=404, detail="Workflow not found")
 
         # Create a new instance of this workflow
-        new_workflow_instance = workflow.deep_copy(update={"workflow_id": workflow_id})
-        new_workflow_instance.user_id = body.user_id
-        new_workflow_instance.session_name = None
+        if isinstance(workflow, Workflow):
+            new_workflow_instance = workflow.deep_copy(
+                update={"workflow_id": workflow_id, "session_id": body.session_id}
+            )
+            new_workflow_instance.user_id = body.user_id
+            new_workflow_instance.session_name = None
 
-        # Return based on the response type
-        try:
-            if new_workflow_instance._run_return_type == "RunResponse":
-                # Return as a normal response
-                return new_workflow_instance.run(**body.input)
-            else:
-                # Return as a streaming response
-                return StreamingResponse(
-                    (result.to_json() for result in new_workflow_instance.run(**body.input)),
-                    media_type="text/event-stream",
-                )
-        except Exception as e:
-            # Handle unexpected runtime errors
-            raise HTTPException(status_code=500, detail=f"Error running workflow: {str(e)}")
+            # Return based on the response type
+            try:
+                if new_workflow_instance._run_return_type == "RunResponse":
+                    # Return as a normal response
+                    return new_workflow_instance.run(**body.input)
+                else:
+                    # Return as a streaming response
+                    return StreamingResponse(
+                        (result.to_json() for result in new_workflow_instance.run(**body.input)),
+                        media_type="text/event-stream",
+                        headers={
+                            "Access-Control-Allow-Origin": "*",
+                            "Access-Control-Allow-Methods": "POST, OPTIONS",
+                            "Access-Control-Allow-Headers": "Content-Type, Authorization",
+                        },
+                    )
+            except Exception as e:
+                # Handle unexpected runtime errors
+                raise HTTPException(status_code=500, detail=f"Error running workflow: {str(e)}")
+        else:
+            # Return based on the response type
+            try:
+                if body.stream:
+                    # Return as a streaming response
+                    return StreamingResponse(
+                        workflow_response_streamer(workflow, body),
+                        media_type="text/event-stream",
+                        headers={
+                            "Access-Control-Allow-Origin": "*",
+                            "Access-Control-Allow-Methods": "POST, OPTIONS",
+                            "Access-Control-Allow-Headers": "Content-Type, Authorization",
+                        },
+                    )
+                else:
+                    # Return as a normal response
+                    return workflow.arun(**body.input, session_id=body.session_id or str(uuid4()), user_id=body.user_id)
+            except Exception as e:
+                # Handle unexpected runtime errors
+                raise HTTPException(status_code=500, detail=f"Error running workflow: {str(e)}")
 
     @playground_router.get("/workflows/{workflow_id}/sessions")
     def get_all_workflow_sessions(workflow_id: str, user_id: Optional[str] = Query(None, min_length=1)):
@@ -703,8 +767,11 @@ def get_sync_playground_router(
         if not workflow_session:
             raise HTTPException(status_code=404, detail="Session not found")
 
-        # Return the session
-        return workflow_session
+        workflow_session_dict = workflow_session.to_dict()
+        if "memory" not in workflow_session_dict:
+            workflow_session_dict["memory"] = {"runs": workflow_session_dict.pop("runs", [])}
+
+        return JSONResponse(content=workflow_session_dict)
 
     @playground_router.post("/workflows/{workflow_id}/sessions/{session_id}/rename")
     def rename_workflow_session(

agno/knowledge/agent.py

@@ -184,7 +184,7 @@ class AgentKnowledge(BaseModel):
                 # Filter out documents which already exist in the vector db
                 if skip_existing:
                     log_debug("Filtering out existing documents before insertion.")
-                    documents_to_load = self.filter_existing_documents(document_list)
+                    documents_to_load = await self.async_filter_existing_documents(document_list)
 
                 if documents_to_load:
                     for doc in documents_to_load:
@@ -439,6 +439,43 @@ class AgentKnowledge(BaseModel):
 
         return filtered_documents
 
+    async def async_filter_existing_documents(self, documents: List[Document]) -> List[Document]:
+        """Filter out documents that already exist in the vector database.
+
+        This helper method is used across various knowledge base implementations
+        to avoid inserting duplicate documents.
+
+        Args:
+            documents (List[Document]): List of documents to filter
+
+        Returns:
+            List[Document]: Filtered list of documents that don't exist in the database
+        """
+        from agno.utils.log import log_debug, log_info
+
+        if not self.vector_db:
+            log_debug("No vector database configured, skipping document filtering")
+            return documents
+
+        # Use set for O(1) lookups
+        seen_content = set()
+        original_count = len(documents)
+        filtered_documents = []
+
+        for doc in documents:
+            # Check hash and existence in DB
+            content_hash = doc.content  # Assuming doc.content is reliable hash key
+            if content_hash not in seen_content and not await self.vector_db.async_doc_exists(doc):
+                seen_content.add(content_hash)
+                filtered_documents.append(doc)
+            else:
+                log_debug(f"Skipping existing document: {doc.name} (or duplicate content)")
+
+        if len(filtered_documents) < original_count:
+            log_info(f"Skipped {original_count - len(filtered_documents)} existing/duplicate documents.")
+
+        return filtered_documents
+
     def _track_metadata_structure(self, metadata: Optional[Dict[str, Any]]) -> None:
         """Track metadata structure to enable filter extraction from queries
 
@@ -655,7 +692,7 @@ class AgentKnowledge(BaseModel):
             documents_to_insert = documents
             if skip_existing:
                 log_debug("Filtering out existing documents before insertion.")
-                documents_to_insert = self.filter_existing_documents(documents)
+                documents_to_insert = await self.async_filter_existing_documents(documents)
 
             if documents_to_insert:  # type: ignore
                 log_debug(f"Inserting {len(documents_to_insert)} new documents.")

agno/knowledge/combined.py

@@ -32,5 +32,5 @@ class CombinedKnowledgeBase(AgentKnowledge):
 
         for kb in self.sources:
             log_debug(f"Loading documents from {kb.__class__.__name__}")
-            async for document in await kb.async_document_lists:
+            async for document in kb.async_document_lists:  # type: ignore
                 yield document

agno/run/base.py

@@ -206,7 +206,9 @@ class RunResponseExtraData:
 class RunStatus(str, Enum):
     """State of the main run response"""
 
+    pending = "PENDING"
     running = "RUNNING"
+    completed = "COMPLETED"
     paused = "PAUSED"
     cancelled = "CANCELLED"
     error = "ERROR"