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

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/document/reader/gcs/pdf_reader.py

@@ -0,0 +1,44 @@
+import asyncio
+from io import BytesIO
+from typing import List
+from uuid import uuid4
+
+from agno.document.base import Document
+from agno.document.reader.base import Reader
+from agno.utils.log import log_info
+
+try:
+    from google.cloud import storage
+except ImportError:
+    raise ImportError("`google-cloud-storage` not installed. Please install it via `pip install google-cloud-storage`.")
+
+try:
+    from pypdf import PdfReader as DocumentReader
+except ImportError:
+    raise ImportError("`pypdf` not installed. Please install it via `pip install pypdf`.")
+
+
+class GCSPDFReader(Reader):
+    def read(self, blob: storage.Blob) -> List[Document]:
+        log_info(f"Reading: gs://{blob.bucket.name}/{blob.name}")
+        data = blob.download_as_bytes()
+        doc_name = blob.name.split("/")[-1].split(".")[0].replace("/", "_").replace(" ", "_")
+        doc_reader = DocumentReader(BytesIO(data))
+        documents = [
+            Document(
+                name=doc_name,
+                id=str(uuid4()),
+                meta_data={"page": page_number},
+                content=page.extract_text(),
+            )
+            for page_number, page in enumerate(doc_reader.pages, start=1)
+        ]
+        if self.chunk:
+            chunked_documents = []
+            for document in documents:
+                chunked_documents.extend(self.chunk_document(document))
+            return chunked_documents
+        return documents
+
+    async def async_read(self, blob: storage.Blob) -> List[Document]:
+        return await asyncio.to_thread(self.read, blob)

agno/embedder/langdb.py

@@ -20,10 +20,8 @@ class LangDBEmbedder(Embedder):
     user: Optional[str] = None
     api_key: Optional[str] = getenv("LANGDB_API_KEY")
     project_id: Optional[str] = getenv("LANGDB_PROJECT_ID")
-    if not project_id:
-        logger.error("LANGDB_PROJECT_ID not set in the environment")
     organization: Optional[str] = None
-    base_url: Optional[str] = f"https://api.us-east-1.langdb.ai/{project_id}/v1"
+    base_url: Optional[str] = None
     request_params: Optional[Dict[str, Any]] = None
     client_params: Optional[Dict[str, Any]] = None
     openai_client: Optional[OpenAIClient] = None
@@ -33,13 +31,19 @@ class LangDBEmbedder(Embedder):
         if self.openai_client:
             return self.openai_client
 
+        if not self.project_id:
+            raise ValueError("LANGDB_PROJECT_ID not set in the environment")
+
         _client_params: Dict[str, Any] = {}
         if self.api_key:
             _client_params["api_key"] = self.api_key
         if self.organization:
             _client_params["organization"] = self.organization
-        if self.base_url:
-            _client_params["base_url"] = self.base_url
+
+        if not self.base_url:
+            self.base_url = f"https://api.us-east-1.langdb.ai/{self.project_id}/v1"
+        _client_params["base_url"] = self.base_url
+
         if self.client_params:
             _client_params.update(self.client_params)
         return OpenAIClient(**_client_params)

agno/knowledge/document.py

@@ -1,11 +1,12 @@
-from typing import AsyncIterator, Iterator, List
+from typing import Any, AsyncIterator, Dict, Iterator, List, Optional, Union
 
 from agno.document import Document
 from agno.knowledge.agent import AgentKnowledge
+from agno.utils.log import log_info, logger
 
 
 class DocumentKnowledgeBase(AgentKnowledge):
-    documents: List[Document]
+    documents: Optional[Union[List[Document], List[Dict[str, Any]]]] = None
 
     @property
     def document_lists(self) -> Iterator[List[Document]]:
@@ -15,18 +16,208 @@ class DocumentKnowledgeBase(AgentKnowledge):
         Returns:
             Iterator[List[Document]]: Iterator yielding list of documents
         """
+        if self.documents is None:
+            # Return empty iterator when no documents are set
+            return
 
-        for _document in self.documents:
-            yield [_document]
+        for item in self.documents:
+            if isinstance(item, dict) and "document" in item:
+                # Handle document with metadata
+                document: Document = item["document"]
+                config = item.get("metadata", {})
+                if config:
+                    log_info(f"Adding metadata {config} to document: {document.name}")
+                    # Create a copy of the document with updated metadata
+                    updated_document = Document(
+                        content=document.content,
+                        id=document.id,
+                        name=document.name,
+                        meta_data={**document.meta_data, **config},
+                        embedder=document.embedder,
+                        embedding=document.embedding,
+                        usage=document.usage,
+                        reranking_score=document.reranking_score,
+                    )
+                    yield [updated_document]
+                else:
+                    yield [document]
+            elif isinstance(item, Document):
+                # Handle direct document
+                yield [item]
+            else:
+                raise ValueError(f"Invalid document format: {type(item)}")
 
     @property
     async def async_document_lists(self) -> AsyncIterator[List[Document]]:
-        """Iterate over documents and yield lists of documents.
+        """Iterate over documents and yield lists of documents asynchronously.
         Each object yielded by the iterator is a list of documents.
 
         Returns:
-            Iterator[List[Document]]: Iterator yielding list of documents
+            AsyncIterator[List[Document]]: Iterator yielding list of documents
+        """
+        if self.documents is None:
+            # Return empty iterator when no documents are set
+            return
+
+        for item in self.documents:
+            if isinstance(item, dict) and "document" in item:
+                # Handle document with metadata
+                document: Document = item["document"]
+                config = item.get("metadata", {})
+                if config:
+                    log_info(f"Adding metadata {config} to document: {document.name}")
+                    # Create a copy of the document with updated metadata
+                    updated_document = Document(
+                        content=document.content,
+                        id=document.id,
+                        name=document.name,
+                        meta_data={**document.meta_data, **config},
+                        embedder=document.embedder,
+                        embedding=document.embedding,
+                        usage=document.usage,
+                        reranking_score=document.reranking_score,
+                    )
+                    yield [updated_document]
+                else:
+                    yield [document]
+            elif isinstance(item, Document):
+                # Handle direct document
+                yield [item]
+            else:
+                raise ValueError(f"Invalid document format: {type(item)}")
+
+    def _prepare_document_load(
+        self,
+        metadata: Optional[Dict[str, Any]] = None,
+        recreate: bool = False,
+    ) -> bool:
+        """Prepare collection for loading documents (no file validation needed).
+        Args:
+            metadata (Optional[Dict[str, Any]]): Metadata to track
+            recreate (bool): Whether to recreate the collection
+        Returns:
+            bool: True if preparation succeeded, False otherwise
+        """
+        # 1. Track metadata
+        if metadata:
+            self._track_metadata_structure(metadata)
+
+        # 2. Prepare vector DB
+        if self.vector_db is None:
+            logger.warning("Cannot load document: No vector db provided.")
+            return False
+
+        # Recreate collection if requested
+        if recreate:
+            self.vector_db.drop()
+
+        # Create collection if it doesn't exist
+        if not self.vector_db.exists():
+            self.vector_db.create()
+
+        return True
+
+    async def _aprepare_document_load(
+        self,
+        metadata: Optional[Dict[str, Any]] = None,
+        recreate: bool = False,
+    ) -> bool:
+        """Prepare collection for loading documents asynchronously (no file validation needed).
+        Args:
+            metadata (Optional[Dict[str, Any]]): Metadata to track
+            recreate (bool): Whether to recreate the collection
+        Returns:
+            bool: True if preparation succeeded, False otherwise
         """
+        # 1. Track metadata
+        if metadata:
+            self._track_metadata_structure(metadata)
+
+        # 2. Prepare vector DB
+        if self.vector_db is None:
+            logger.warning("Cannot load document: No vector db provided.")
+            return False
+
+        # Recreate collection if requested
+        if recreate:
+            await self.vector_db.async_drop()
+
+        # Create collection if it doesn't exist
+        if not await self.vector_db.async_exists():
+            await self.vector_db.async_create()
+
+        return True
+
+    def load_document(
+        self,
+        document: Document,
+        metadata: Optional[Dict[str, Any]] = None,
+        recreate: bool = False,
+        upsert: bool = False,
+        skip_existing: bool = True,
+    ) -> None:
+        """Load a single document with specific metadata into the vector DB."""
+
+        # Use our document-specific preparation method
+        if not self._prepare_document_load(metadata, recreate):
+            return
+
+        # Apply metadata if provided
+        if metadata:
+            # Create a copy of the document with updated metadata
+            document = Document(
+                content=document.content,
+                id=document.id,
+                name=document.name,
+                meta_data={**document.meta_data, **metadata},
+                embedder=document.embedder,
+                embedding=document.embedding,
+                usage=document.usage,
+                reranking_score=document.reranking_score,
+            )
+
+        # Process documents
+        self.process_documents(
+            documents=[document],
+            metadata=metadata,
+            upsert=upsert,
+            skip_existing=skip_existing,
+            source_info=f"document: {document.name or document.id}",
+        )
+
+    async def aload_document(
+        self,
+        document: Document,
+        metadata: Optional[Dict[str, Any]] = None,
+        recreate: bool = False,
+        upsert: bool = False,
+        skip_existing: bool = True,
+    ) -> None:
+        """Load a single document with specific metadata into the vector DB asynchronously."""
+
+        # Use our document-specific preparation method
+        if not await self._aprepare_document_load(metadata, recreate):
+            return
+
+        # Apply metadata if provided
+        if metadata:
+            # Create a copy of the document with updated metadata
+            document = Document(
+                content=document.content,
+                id=document.id,
+                name=document.name,
+                meta_data={**document.meta_data, **metadata},
+                embedder=document.embedder,
+                embedding=document.embedding,
+                usage=document.usage,
+                reranking_score=document.reranking_score,
+            )
 
-        for _document in self.documents:
-            yield [_document]
+        # Process documents
+        await self.aprocess_documents(
+            documents=[document],
+            metadata=metadata,
+            upsert=upsert,
+            skip_existing=skip_existing,
+            source_info=f"document: {document.name or document.id}",
+        )

agno/knowledge/gcs/base.py

@@ -0,0 +1,39 @@
+from typing import AsyncIterator, Iterator, List, Optional
+
+from google.cloud import storage
+
+from agno.document import Document
+from agno.knowledge.agent import AgentKnowledge
+
+
+class GCSKnowledgeBase(AgentKnowledge):
+    bucket: Optional[storage.Bucket] = None
+    bucket_name: Optional[str] = None
+    blob_name: Optional[str] = None
+    prefix: Optional[str] = None
+
+    @property
+    def gcs_blobs(self) -> List[storage.Blob]:
+        if self.bucket is None and self.bucket_name is None:
+            raise ValueError("No bucket or bucket_name provided")
+        if self.bucket is not None and self.bucket_name is not None:
+            raise ValueError("Provide either bucket or bucket_name")
+        if self.bucket_name is not None:
+            client = storage.Client()
+            self.bucket = client.bucket(self.bucket_name)
+        blobs_to_read = []
+        if self.blob_name is not None:
+            blobs_to_read.append(self.bucket.blob(self.blob_name))  # type: ignore
+        elif self.prefix is not None:
+            blobs_to_read.extend(self.bucket.list_blobs(prefix=self.prefix))  # type: ignore
+        else:
+            blobs_to_read.extend(self.bucket.list_blobs())  # type: ignore
+        return list(blobs_to_read)
+
+    @property
+    def document_lists(self) -> Iterator[List[Document]]:
+        raise NotImplementedError
+
+    @property
+    def async_document_lists(self) -> AsyncIterator[List[Document]]:
+        raise NotImplementedError

agno/knowledge/gcs/pdf.py

@@ -0,0 +1,21 @@
+from typing import AsyncIterator, Iterator, List
+
+from agno.document import Document
+from agno.document.reader.gcs.pdf_reader import GCSPDFReader
+from agno.knowledge.gcs.base import GCSKnowledgeBase
+
+
+class GCSPDFKnowledgeBase(GCSKnowledgeBase):
+    reader: GCSPDFReader = GCSPDFReader()
+
+    @property
+    def document_lists(self) -> Iterator[List[Document]]:
+        for blob in self.gcs_blobs:
+            if blob.name.endswith(".pdf"):
+                yield self.reader.read(blob=blob)
+
+    @property
+    async def async_document_lists(self) -> AsyncIterator[List[Document]]:
+        for blob in self.gcs_blobs:
+            if blob.name.endswith(".pdf"):
+                yield await self.reader.async_read(blob=blob)

agno/models/langdb/langdb.py

@@ -3,7 +3,6 @@ from os import getenv
 from typing import Any, Dict, Optional
 
 from agno.models.openai.like import OpenAILike
-from agno.utils.log import logger
 
 
 @dataclass
@@ -25,21 +24,25 @@ class LangDB(OpenAILike):
 
     api_key: Optional[str] = getenv("LANGDB_API_KEY")
     project_id: Optional[str] = getenv("LANGDB_PROJECT_ID")
-    if not project_id:
-        logger.warning("LANGDB_PROJECT_ID not set in the environment")
 
     base_host_url: str = getenv("LANGDB_API_BASE_URL", "https://api.us-east-1.langdb.ai")
 
-    base_url: str = f"{base_host_url}/{project_id}/v1"
+    base_url: Optional[str] = None
     label: Optional[str] = None
     default_headers: Optional[dict] = None
 
     def _get_client_params(self) -> Dict[str, Any]:
+        if not self.project_id:
+            raise ValueError("LANGDB_PROJECT_ID not set in the environment")
+
+        if not self.base_url:
+            self.base_url = f"{self.base_host_url}/{self.project_id}/v1"
+
         # Initialize headers with label if present
         if self.label and not self.default_headers:
             self.default_headers = {
                 "x-label": self.label,
             }
-        client_params = super()._get_client_params()
 
+        client_params = super()._get_client_params()
         return client_params

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"

agno/run/response.py

@@ -379,16 +379,16 @@ class RunResponse:
         messages = data.pop("messages", None)
         messages = [Message.model_validate(message) for message in messages] if messages else None
 
-        tools = data.pop("tools", None)
+        tools = data.pop("tools", [])
         tools = [ToolExecution.from_dict(tool) for tool in tools] if tools else None
 
-        images = data.pop("images", None)
+        images = data.pop("images", [])
         images = [ImageArtifact.model_validate(image) for image in images] if images else None
 
-        videos = data.pop("videos", None)
+        videos = data.pop("videos", [])
         videos = [VideoArtifact.model_validate(video) for video in videos] if videos else None
 
-        audio = data.pop("audio", None)
+        audio = data.pop("audio", [])
         audio = [AudioArtifact.model_validate(audio) for audio in audio] if audio else None
 
         response_audio = data.pop("response_audio", None)

agno/run/team.py

@@ -361,9 +361,9 @@ class TeamRunResponse:
         messages = data.pop("messages", None)
         messages = [Message.model_validate(message) for message in messages] if messages else None
 
-        member_responses = data.pop("member_responses", None)
+        member_responses = data.pop("member_responses", [])
         parsed_member_responses: List[Union["TeamRunResponse", RunResponse]] = []
-        if member_responses is not None:
+        if member_responses:
             for response in member_responses:
                 if "agent_id" in response:
                     parsed_member_responses.append(RunResponse.from_dict(response))
@@ -374,16 +374,16 @@ class TeamRunResponse:
         if extra_data is not None:
             extra_data = RunResponseExtraData.from_dict(extra_data)
 
-        images = data.pop("images", None)
+        images = data.pop("images", [])
         images = [ImageArtifact.model_validate(image) for image in images] if images else None
 
-        videos = data.pop("videos", None)
+        videos = data.pop("videos", [])
         videos = [VideoArtifact.model_validate(video) for video in videos] if videos else None
 
-        audio = data.pop("audio", None)
+        audio = data.pop("audio", [])
         audio = [AudioArtifact.model_validate(audio) for audio in audio] if audio else None
 
-        tools = data.pop("tools", None)
+        tools = data.pop("tools", [])
         tools = [ToolExecution.from_dict(tool) for tool in tools] if tools else None
 
         response_audio = data.pop("response_audio", None)