agno 2.0.2__py3-none-any.whl → 2.0.4__py3-none-any.whl

agno/tools/workflow.py

@@ -0,0 +1,279 @@
+import json
+from textwrap import dedent
+from typing import Any, Dict, Optional
+
+from pydantic import BaseModel
+
+from agno.tools import Toolkit
+from agno.utils.log import log_debug, log_error
+from agno.workflow.workflow import Workflow, WorkflowRunOutput
+
+
+class RunWorkflowInput(BaseModel):
+    input_data: str
+    additional_data: Optional[Dict[str, Any]] = None
+
+
+class WorkflowTools(Toolkit):
+    def __init__(
+        self,
+        workflow: Workflow,
+        enable_run_workflow: bool = True,
+        enable_think: bool = False,
+        enable_analyze: bool = False,
+        all: bool = False,
+        instructions: Optional[str] = None,
+        add_instructions: bool = True,
+        add_few_shot: bool = False,
+        few_shot_examples: Optional[str] = None,
+        async_mode: bool = False,
+        **kwargs,
+    ):
+        # Add instructions for using this toolkit
+        if instructions is None:
+            self.instructions = self.DEFAULT_INSTRUCTIONS
+            if add_few_shot:
+                if few_shot_examples is not None:
+                    self.instructions += "\n" + few_shot_examples
+        else:
+            self.instructions = instructions
+
+        # The workflow to execute
+        self.workflow: Workflow = workflow
+
+        super().__init__(
+            name="workflow_tools",
+            instructions=self.instructions,
+            add_instructions=add_instructions,
+            auto_register=False,
+            **kwargs,
+        )
+
+        if enable_think or all:
+            if async_mode:
+                self.register(self.async_think, name="think")
+            else:
+                self.register(self.think, name="think")
+        if enable_run_workflow or all:
+            if async_mode:
+                self.register(self.async_run_workflow, name="run_workflow")
+            else:
+                self.register(self.run_workflow, name="run_workflow")
+        if enable_analyze or all:
+            if async_mode:
+                self.register(self.async_analyze, name="analyze")
+            else:
+                self.register(self.analyze, name="analyze")
+
+    def think(self, session_state: Dict[str, Any], thought: str) -> str:
+        """Use this tool as a scratchpad to reason about the workflow execution, refine your approach, brainstorm workflow inputs, or revise your plan.
+        Call `Think` whenever you need to figure out what to do next, analyze the user's requirements, plan workflow inputs, or decide on execution strategy.
+        You should use this tool as frequently as needed.
+        Args:
+            thought: Your thought process and reasoning about workflow execution.
+        """
+        try:
+            log_debug(f"Workflow Thought: {thought}")
+
+            # Add the thought to the session state
+            if session_state is None:
+                session_state = {}
+            if "workflow_thoughts" not in session_state:
+                session_state["workflow_thoughts"] = []
+            session_state["workflow_thoughts"].append(thought)
+
+            # Return the full log of thoughts and the new thought
+            thoughts = "\n".join([f"- {t}" for t in session_state["workflow_thoughts"]])
+            formatted_thoughts = dedent(
+                f"""Workflow Thoughts:
+                {thoughts}
+                """
+            ).strip()
+            return formatted_thoughts
+        except Exception as e:
+            log_error(f"Error recording workflow thought: {e}")
+            return f"Error recording workflow thought: {e}"
+
+    async def async_think(self, session_state: Dict[str, Any], thought: str) -> str:
+        """Use this tool as a scratchpad to reason about the workflow execution, refine your approach, brainstorm workflow inputs, or revise your plan.
+        Call `Think` whenever you need to figure out what to do next, analyze the user's requirements, plan workflow inputs, or decide on execution strategy.
+        You should use this tool as frequently as needed.
+        Args:
+            thought: Your thought process and reasoning about workflow execution.
+        """
+        try:
+            log_debug(f"Workflow Thought: {thought}")
+
+            # Add the thought to the session state
+            if session_state is None:
+                session_state = {}
+            if "workflow_thoughts" not in session_state:
+                session_state["workflow_thoughts"] = []
+            session_state["workflow_thoughts"].append(thought)
+
+            # Return the full log of thoughts and the new thought
+            thoughts = "\n".join([f"- {t}" for t in session_state["workflow_thoughts"]])
+            formatted_thoughts = dedent(
+                f"""Workflow Thoughts:
+                {thoughts}
+                """
+            ).strip()
+            return formatted_thoughts
+        except Exception as e:
+            log_error(f"Error recording workflow thought: {e}")
+            return f"Error recording workflow thought: {e}"
+
+    def run_workflow(
+        self,
+        session_state: Dict[str, Any],
+        input: RunWorkflowInput,
+    ) -> str:
+        """Use this tool to execute the workflow with the specified inputs and parameters.
+        After thinking through the requirements, use this tool to run the workflow with appropriate inputs.
+        Args:
+            input_data: The input data for the workflow (use a `str` for a simple input)
+            additional_data: The additional data for the workflow. This is a dictionary of key-value pairs that will be passed to the workflow. E.g. {"topic": "food", "style": "Humour"}
+        """
+        try:
+            log_debug(f"Running workflow with input: {input.input_data}")
+
+            user_id = session_state.get("current_user_id")
+            session_id = session_state.get("current_session_id")
+
+            # Execute the workflow
+            result: WorkflowRunOutput = self.workflow.run(
+                input=input.input_data,
+                user_id=user_id,
+                session_id=session_id,
+                session_state=session_state,
+                additional_data=input.additional_data,
+            )
+
+            if "workflow_results" not in session_state:
+                session_state["workflow_results"] = []
+
+            session_state["workflow_results"].append(result.to_dict())
+
+            return json.dumps(result.to_dict(), indent=2)
+
+        except Exception as e:
+            log_error(f"Error running workflow: {e}")
+            return f"Error running workflow: {e}"
+
+    async def async_run_workflow(
+        self,
+        session_state: Dict[str, Any],
+        input: RunWorkflowInput,
+    ) -> str:
+        """Use this tool to execute the workflow with the specified inputs and parameters.
+        After thinking through the requirements, use this tool to run the workflow with appropriate inputs.
+        Args:
+            input_data: The input data for the workflow (use a `str` for a simple input)
+            additional_data: The additional data for the workflow. This is a dictionary of key-value pairs that will be passed to the workflow. E.g. {"topic": "food", "style": "Humour"}
+        """
+        try:
+            log_debug(f"Running workflow with input: {input.input_data}")
+
+            user_id = session_state.get("current_user_id")
+            session_id = session_state.get("current_session_id")
+
+            # Execute the workflow
+            result: WorkflowRunOutput = await self.workflow.arun(
+                input=input.input_data,
+                user_id=user_id,
+                session_id=session_id,
+                session_state=session_state,
+                additional_data=input.additional_data,
+            )
+
+            if "workflow_results" not in session_state:
+                session_state["workflow_results"] = []
+
+            session_state["workflow_results"].append(result.to_dict())
+
+            return json.dumps(result.to_dict(), indent=2)
+
+        except Exception as e:
+            log_error(f"Error running workflow: {e}")
+            return f"Error running workflow: {e}"
+
+    def analyze(self, session_state: Dict[str, Any], analysis: str) -> str:
+        """Use this tool to evaluate whether the workflow execution results are correct and sufficient.
+        If not, go back to "Think" or "Run" with refined inputs or parameters.
+        Args:
+            analysis: Your analysis of the workflow execution results.
+        """
+        try:
+            log_debug(f"Workflow Analysis: {analysis}")
+
+            # Add the analysis to the session state
+            if session_state is None:
+                session_state = {}
+            if "workflow_analysis" not in session_state:
+                session_state["workflow_analysis"] = []
+            session_state["workflow_analysis"].append(analysis)
+
+            # Return the full log of analysis and the new analysis
+            analysis_log = "\n".join([f"- {a}" for a in session_state["workflow_analysis"]])
+            formatted_analysis = dedent(
+                f"""Workflow Analysis:
+                {analysis_log}
+                """
+            ).strip()
+            return formatted_analysis
+        except Exception as e:
+            log_error(f"Error recording workflow analysis: {e}")
+            return f"Error recording workflow analysis: {e}"
+
+    async def async_analyze(self, session_state: Dict[str, Any], analysis: str) -> str:
+        """Use this tool to evaluate whether the workflow execution results are correct and sufficient.
+        If not, go back to "Think" or "Run" with refined inputs or parameters.
+        Args:
+            analysis: Your analysis of the workflow execution results.
+        """
+        try:
+            log_debug(f"Workflow Analysis: {analysis}")
+
+            # Add the analysis to the session state
+            if session_state is None:
+                session_state = {}
+            if "workflow_analysis" not in session_state:
+                session_state["workflow_analysis"] = []
+            session_state["workflow_analysis"].append(analysis)
+
+            # Return the full log of analysis and the new analysis
+            analysis_log = "\n".join([f"- {a}" for a in session_state["workflow_analysis"]])
+            formatted_analysis = dedent(
+                f"""Workflow Analysis:
+                {analysis_log}
+                """
+            ).strip()
+            return formatted_analysis
+        except Exception as e:
+            log_error(f"Error recording workflow analysis: {e}")
+            return f"Error recording workflow analysis: {e}"
+
+    DEFAULT_INSTRUCTIONS = dedent("""\
+        You have access to the Think, Run Workflow, and Analyze tools that will help you execute workflows and analyze their results. Use these tools as frequently as needed to successfully complete workflow-based tasks.
+        ## How to use the Think, Run Workflow, and Analyze tools:
+        
+        1. **Think**
+        - Purpose: A scratchpad for planning workflow execution, brainstorming inputs, and refining your approach. You never reveal your "Think" content to the user.
+        - Usage: Call `think` whenever you need to figure out what workflow inputs to use, analyze requirements, or decide on execution strategy before (or after) you run the workflow.
+        2. **Run Workflow**
+        - Purpose: Executes the workflow with specified inputs and parameters.
+        - Usage: Call `run_workflow` with appropriate input data whenever you want to execute the workflow.
+            - For all workflows, start with simple inputs and gradually increase complexity
+        3. **Analyze**
+        - Purpose: Evaluate whether the workflow execution results are correct and sufficient. If not, go back to "Think" or "Run Workflow" with refined inputs.
+        - Usage: Call `analyze` after getting workflow results to verify the quality and correctness of the execution. Consider:
+            - Completeness: Did the workflow complete all expected steps?
+            - Quality: Are the results accurate and meet the requirements?
+            - Errors: Were there any failures or unexpected behaviors?
+        **Important Guidelines**:
+        - Do not include your internal chain-of-thought in direct user responses.
+        - Use "Think" to reason internally. These notes are never exposed to the user.
+        - When you provide a final answer to the user, be clear, concise, and based on the workflow results.
+        - If workflow execution fails or produces unexpected results, acknowledge limitations and explain what went wrong.
+        - Synthesize information from multiple workflow runs if you execute the workflow several times with different inputs.\
+    """)

agno/utils/audio.py

@@ -1,5 +1,6 @@
 import base64
 import os
+import wave
 
 from agno.utils.log import log_info
 
@@ -20,3 +21,29 @@ def write_audio_to_file(audio, filename: str):
     with open(filename, "wb") as f:
         f.write(wav_bytes)
     log_info(f"Audio file saved to {filename}")
+
+
+def write_wav_audio_to_file(
+    filename: str, pcm_data: bytes, channels: int = 1, rate: int = 24000, sample_width: int = 2
+):
+    """
+    Create a WAV file from raw PCM audio data.
+
+    Args:
+        filename: The filepath to save the WAV file to
+        pcm_data: Raw PCM audio data as bytes
+        channels: Number of audio channels (1 for mono, 2 for stereo)
+        rate: Sample rate in Hz (e.g., 24000, 44100, 48000)
+        sample_width: Sample width in bytes (1, 2, or 4)
+    """
+    # Create directory if it doesn't exist
+    if os.path.dirname(filename):
+        os.makedirs(os.path.dirname(filename), exist_ok=True)
+
+    with wave.open(filename, "wb") as wf:
+        wf.setnchannels(channels)
+        wf.setsampwidth(sample_width)
+        wf.setframerate(rate)
+        wf.writeframes(pcm_data)
+
+    log_info(f"WAV file saved to {filename}")

agno/utils/common.py

@@ -1,5 +1,5 @@
 from dataclasses import asdict
-from typing import Any, List, Optional, Type
+from typing import Any, List, Optional, Set, Type, Union, get_type_hints
 
 
 def isinstanceany(obj: Any, class_list: List[Type]) -> bool:
@@ -41,3 +41,92 @@ def nested_model_dump(value):
     elif isinstance(value, list):
         return [nested_model_dump(item) for item in value]
     return value
+
+
+def is_typed_dict(cls: Type[Any]) -> bool:
+    """Check if a class is a TypedDict"""
+    return (
+        hasattr(cls, "__annotations__")
+        and hasattr(cls, "__total__")
+        and hasattr(cls, "__required_keys__")
+        and hasattr(cls, "__optional_keys__")
+    )
+
+
+def check_type_compatibility(value: Any, expected_type: Type) -> bool:
+    """Basic type compatibility checking."""
+    from typing import get_args, get_origin
+
+    # Handle None/Optional types
+    if value is None:
+        return (
+            type(None) in get_args(expected_type) if hasattr(expected_type, "__args__") else expected_type is type(None)
+        )
+
+    # Handle Union types (including Optional)
+    origin = get_origin(expected_type)
+    if origin is Union:
+        return any(check_type_compatibility(value, arg) for arg in get_args(expected_type))
+
+    # Handle List types
+    if origin is list or expected_type is list:
+        if not isinstance(value, list):
+            return False
+        if origin is list and get_args(expected_type):
+            element_type = get_args(expected_type)[0]
+            return all(check_type_compatibility(item, element_type) for item in value)
+        return True
+
+    if expected_type in (str, int, float, bool):
+        return isinstance(value, expected_type)
+
+    if expected_type is Any:
+        return True
+
+    try:
+        return isinstance(value, expected_type)
+    except TypeError:
+        return True
+
+
+def validate_typed_dict(data: dict, schema_cls) -> dict:
+    """Validate input data against a TypedDict schema."""
+    if not isinstance(data, dict):
+        raise ValueError(f"Expected dict for TypedDict {schema_cls.__name__}, got {type(data)}")
+
+    # Get type hints from the TypedDict
+    try:
+        type_hints = get_type_hints(schema_cls)
+    except Exception as e:
+        raise ValueError(f"Could not get type hints for TypedDict {schema_cls.__name__}: {e}")
+
+    # Get required and optional keys
+    required_keys: Set[str] = getattr(schema_cls, "__required_keys__", set())
+    optional_keys: Set[str] = getattr(schema_cls, "__optional_keys__", set())
+    all_keys = required_keys | optional_keys
+
+    # Check for missing required fields
+    missing_required = required_keys - set(data.keys())
+    if missing_required:
+        raise ValueError(f"Missing required fields in TypedDict {schema_cls.__name__}: {missing_required}")
+
+    # Check for unexpected fields
+    unexpected_fields = set(data.keys()) - all_keys
+    if unexpected_fields:
+        raise ValueError(f"Unexpected fields in TypedDict {schema_cls.__name__}: {unexpected_fields}")
+
+    # Basic type checking for provided fields
+    validated_data = {}
+    for field_name, value in data.items():
+        if field_name in type_hints:
+            expected_type = type_hints[field_name]
+
+            # Handle simple type checking
+            if not check_type_compatibility(value, expected_type):
+                raise ValueError(
+                    f"Field '{field_name}' expected type {expected_type}, got {type(value)} with value {value}"
+                )
+
+            validated_data[field_name] = value
+
+    return validated_data

agno/utils/print_response/agent.py

@@ -112,7 +112,9 @@ def print_response_stream(
                 if response_event.event == RunEvent.run_content:  # type: ignore
                     if hasattr(response_event, "content"):
                         if isinstance(response_event.content, str):
-                            _response_content += response_event.content
+                            # Don't accumulate text content, parser_model will replace it
+                            if not (agent.parser_model is not None and agent.output_schema is not None):
+                                _response_content += response_event.content
                         elif agent.output_schema is not None and isinstance(response_event.content, BaseModel):
                             try:
                                 response_content_batch = JSON(  # type: ignore
@@ -289,7 +291,9 @@ async def aprint_response_stream(
 
                 if resp.event == RunEvent.run_content:  # type: ignore
                     if isinstance(resp.content, str):
-                        _response_content += resp.content
+                        # Don't accumulate text content, parser_model will replace it
+                        if not (agent.parser_model is not None and agent.output_schema is not None):
+                            _response_content += resp.content
                     elif agent.output_schema is not None and isinstance(resp.content, BaseModel):
                         try:
                             response_content_batch = JSON(resp.content.model_dump_json(exclude_none=True), indent=2)  # type: ignore

agno/utils/streamlit.py

@@ -1,14 +1,20 @@
 from datetime import datetime
 from typing import Any, Callable, Dict, List, Optional
 
-import streamlit as st
-
-from agno.agent import Agent
-from agno.db.base import SessionType
-from agno.models.anthropic import Claude
-from agno.models.google import Gemini
-from agno.models.openai import OpenAIChat
-from agno.utils.log import logger
+try:
+    from agno.agent import Agent
+    from agno.db.base import SessionType
+    from agno.models.anthropic import Claude
+    from agno.models.google import Gemini
+    from agno.models.openai import OpenAIChat
+    from agno.utils.log import logger
+except ImportError:
+    raise ImportError("`agno` not installed. Please install using `pip install agno`")
+
+try:
+    import streamlit as st
+except ImportError:
+    raise ImportError("`streamlit` not installed. Please install using `pip install streamlit`")
 
 
 def add_message(role: str, content: str, tool_calls: Optional[List[Dict[str, Any]]] = None) -> None:

agno/vectordb/chroma/chromadb.py

@@ -766,9 +766,15 @@ class ChromaDb(VectorDb):
                     updated_metadatas.append(updated_meta)
 
                 # Update the documents
+                # Filter out None values from metadata as ChromaDB doesn't accept them
+                cleaned_metadatas = []
+                for meta in updated_metadatas:
+                    cleaned_meta = {k: v for k, v in meta.items() if v is not None}
+                    cleaned_metadatas.append(cleaned_meta)
+
                 # Convert to the expected type for ChromaDB
-                chroma_metadatas = cast(List[Mapping[str, Union[str, int, float, bool, None]]], updated_metadatas)
-                collection.update(ids=ids, metadatas=chroma_metadatas)
+                chroma_metadatas = cast(List[Mapping[str, Union[str, int, float, bool]]], cleaned_metadatas)
+                collection.update(ids=ids, metadatas=chroma_metadatas)  # type: ignore
                 logger.debug(f"Updated metadata for {len(ids)} documents with content_id: {content_id}")
 
             except TypeError as te: