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

agno/tools/memory.py

@@ -95,13 +95,28 @@ class MemoryTools(Toolkit):
 
     def get_memories(self, session_state: Dict[str, Any]) -> str:
         """
-        Use this tool to get a list of memories from the database.
+        Use this tool to get a list of memories for the current user from the database.
         """
         try:
             # Get user info from session state
             user_id = session_state.get("current_user_id") if session_state else None
 
             memories = self.db.get_user_memories(user_id=user_id)
+
+            # Store the result in session state for analysis
+            if session_state is None:
+                session_state = {}
+            if "memory_operations" not in session_state:
+                session_state["memory_operations"] = []
+
+            operation_result = {
+                "operation": "get_memories",
+                "success": True,
+                "memories": [memory.to_dict() for memory in memories],  # type: ignore
+                "error": None,
+            }
+            session_state["memory_operations"].append(operation_result)
+
             return json.dumps([memory.to_dict() for memory in memories], indent=2)  # type: ignore
         except Exception as e:
             log_error(f"Error getting memories: {e}")
@@ -328,19 +343,23 @@ class MemoryTools(Toolkit):
         - Purpose: A scratchpad for planning memory operations, brainstorming memory content, and refining your approach. You never reveal your "Think" content to the user.
         - Usage: Call `think` whenever you need to figure out what memory operations to perform, analyze requirements, or decide on strategy.
 
-        2. **Add Memory**
+        2. **Get Memories**
+        - Purpose: Retrieves a list of memories from the database for the current user.
+        - Usage: Call `get_memories` when you need to retrieve memories for the current user.
+
+        3. **Add Memory**
         - Purpose: Creates new memories in the database with specified content and metadata.
         - Usage: Call `add_memory` with memory content and optional topics when you need to store new information.
 
-        3. **Update Memory**
+        4. **Update Memory**
         - Purpose: Modifies existing memories in the database by memory ID.
         - Usage: Call `update_memory` with a memory ID and the fields you want to change. Only specify the fields that need updating.
 
-        4. **Delete Memory**
+        5. **Delete Memory**
         - Purpose: Removes memories from the database by memory ID.
         - Usage: Call `delete_memory` with a memory ID when a memory is no longer needed or requested to be removed.
 
-        5. **Analyze**
+        6. **Analyze**
         - Purpose: Evaluate whether the memory operations results are correct and sufficient. If not, go back to "Think" or use memory operations with refined parameters.
         - Usage: Call `analyze` after performing memory operations to verify:
             - Success: Did the operation complete successfully?
@@ -387,5 +406,14 @@ class MemoryTools(Toolkit):
         Delete Memory: memory_id="work_schedule_memory_id"
         Analyze: Successfully deleted the outdated work schedule memory. The old information won't interfere with future scheduling requests.
 
-        Final Answer: I've removed your old work schedule information. Feel free to share your new schedule when you're ready, and I'll store the updated information.\
+        Final Answer: I've removed your old work schedule information. Feel free to share your new schedule when you're ready, and I'll store the updated information.
+        
+        #### Example 4: Retrieving Memories
+
+        User: What have you remembered about me?
+        Think: The user wants to retrieve memories about themselves. I should use the get_memories tool to retrieve the memories.
+        Get Memories: 
+        Analyze: Successfully retrieved the memories about the user. The memories are relevant to the user's preferences and activities.
+
+        Final Answer: I've retrieved the memories about you. You like to hike in the mountains on weekends and travel to new places and experience different cultures. You are planning to travel to Africa in December.\
     """)

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/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:

agno/workflow/step.py

@@ -164,6 +164,38 @@ class Step:
             return response.metrics
         return None
 
+    def _call_custom_function(
+        self,
+        func: Callable,
+        step_input: StepInput,
+        session_state: Optional[Dict[str, Any]] = None,
+    ) -> Any:
+        """Call custom function with session_state support if the function accepts it"""
+        if session_state is not None and self._function_has_session_state_param():
+            return func(step_input, session_state)
+        else:
+            return func(step_input)
+
+    async def _acall_custom_function(
+        self,
+        func: Callable,
+        step_input: StepInput,
+        session_state: Optional[Dict[str, Any]] = None,
+    ) -> Any:
+        """Call custom async function with session_state support if the function accepts it"""
+        import inspect
+
+        if inspect.isasyncgenfunction(func):
+            if session_state is not None and self._function_has_session_state_param():
+                return func(step_input, session_state)
+            else:
+                return func(step_input)
+        else:
+            if session_state is not None and self._function_has_session_state_param():
+                return await func(step_input, session_state)
+            else:
+                return await func(step_input)
+
     def execute(
         self,
         step_input: StepInput,
@@ -191,8 +223,11 @@ class Step:
                     if inspect.isgeneratorfunction(self.active_executor):
                         content = ""
                         final_response = None
+                        session_state_copy = copy(session_state) if session_state else None
                         try:
-                            for chunk in self.active_executor(step_input):  # type: ignore
+                            for chunk in self._call_custom_function(
+                                self.active_executor, step_input, session_state_copy
+                            ):  # type: ignore
                                 if (
                                     hasattr(chunk, "content")
                                     and chunk.content is not None
@@ -208,13 +243,22 @@ class Step:
                             if hasattr(e, "value") and isinstance(e.value, StepOutput):
                                 final_response = e.value
 
+                        # Merge session_state changes back
+                        if session_state_copy and session_state:
+                            merge_dictionaries(session_state, session_state_copy)
+
                         if final_response is not None:
                             response = final_response
                         else:
                             response = StepOutput(content=content)
                     else:
-                        # Execute function directly with StepInput
-                        result = self.active_executor(step_input)  # type: ignore
+                        # Execute function with signature inspection for session_state support
+                        session_state_copy = copy(session_state) if session_state else None
+                        result = self._call_custom_function(self.active_executor, step_input, session_state_copy)  # type: ignore
+
+                        # Merge session_state changes back
+                        if session_state_copy and session_state:
+                            merge_dictionaries(session_state, session_state_copy)
 
                         # If function returns StepOutput, use it directly
                         if isinstance(result, StepOutput):
@@ -291,6 +335,19 @@ class Step:
 
         return StepOutput(content=f"Step {self.name} failed but skipped", success=False)
 
+    def _function_has_session_state_param(self) -> bool:
+        """Check if the custom function has a session_state parameter"""
+        if self._executor_type != "function":
+            return False
+
+        try:
+            from inspect import signature
+
+            sig = signature(self.active_executor)  # type: ignore
+            return "session_state" in sig.parameters
+        except Exception:
+            return False
+
     def execute_stream(
         self,
         step_input: StepInput,
@@ -338,8 +395,10 @@ class Step:
                     if inspect.isgeneratorfunction(self.active_executor):
                         log_debug("Function returned iterable, streaming events")
                         content = ""
+                        session_state_copy = copy(session_state) if session_state else None
                         try:
-                            for event in self.active_executor(step_input):  # type: ignore
+                            iterator = self._call_custom_function(self.active_executor, step_input, session_state_copy)  # type: ignore
+                            for event in iterator:  # type: ignore
                                 if (
                                     hasattr(event, "content")
                                     and event.content is not None
@@ -353,6 +412,11 @@ class Step:
                                     break
                                 else:
                                     yield event  # type: ignore[misc]
+
+                            # Merge session_state changes back
+                            if session_state_copy and session_state:
+                                merge_dictionaries(session_state, session_state_copy)
+
                             if not final_response:
                                 final_response = StepOutput(content=content)
                         except StopIteration as e:
@@ -360,7 +424,13 @@ class Step:
                                 final_response = e.value
 
                     else:
-                        result = self.active_executor(step_input)  # type: ignore
+                        session_state_copy = copy(session_state) if session_state else None
+                        result = self._call_custom_function(self.active_executor, step_input, session_state_copy)  # type: ignore
+
+                        # Merge session_state changes back
+                        if session_state_copy and session_state:
+                            merge_dictionaries(session_state, session_state_copy)
+
                         if isinstance(result, StepOutput):
                             final_response = result
                         else:
@@ -505,9 +575,13 @@ class Step:
                     ):
                         content = ""
                         final_response = None
+                        session_state_copy = copy(session_state) if session_state else None
                         try:
                             if inspect.isgeneratorfunction(self.active_executor):
-                                for chunk in self.active_executor(step_input):  # type: ignore
+                                iterator = self._call_custom_function(
+                                    self.active_executor, step_input, session_state_copy
+                                )  # type: ignore
+                                for chunk in iterator:  # type: ignore
                                     if (
                                         hasattr(chunk, "content")
                                         and chunk.content is not None
@@ -520,7 +594,10 @@ class Step:
                                         final_response = chunk
                             else:
                                 if inspect.isasyncgenfunction(self.active_executor):
-                                    async for chunk in self.active_executor(step_input):  # type: ignore
+                                    iterator = await self._acall_custom_function(
+                                        self.active_executor, step_input, session_state_copy
+                                    )  # type: ignore
+                                    async for chunk in iterator:  # type: ignore
                                         if (
                                             hasattr(chunk, "content")
                                             and chunk.content is not None
@@ -536,15 +613,26 @@ class Step:
                             if hasattr(e, "value") and isinstance(e.value, StepOutput):
                                 final_response = e.value
 
+                        # Merge session_state changes back
+                        if session_state_copy and session_state:
+                            merge_dictionaries(session_state, session_state_copy)
+
                         if final_response is not None:
                             response = final_response
                         else:
                             response = StepOutput(content=content)
                     else:
+                        session_state_copy = copy(session_state) if session_state else None
                         if inspect.iscoroutinefunction(self.active_executor):
-                            result = await self.active_executor(step_input)  # type: ignore
+                            result = await self._acall_custom_function(
+                                self.active_executor, step_input, session_state_copy
+                            )  # type: ignore
                         else:
-                            result = self.active_executor(step_input)  # type: ignore
+                            result = self._call_custom_function(self.active_executor, step_input, session_state_copy)  # type: ignore
+
+                        # Merge session_state changes back
+                        if session_state_copy and session_state:
+                            merge_dictionaries(session_state, session_state_copy)
 
                         # If function returns StepOutput, use it directly
                         if isinstance(result, StepOutput):
@@ -662,11 +750,16 @@ class Step:
                     log_debug(f"Executing async function executor for step: {self.name}")
                     import inspect
 
+                    session_state_copy = copy(session_state) if session_state else None
+
                     # Check if the function is an async generator
                     if inspect.isasyncgenfunction(self.active_executor):
                         content = ""
                         # It's an async generator - iterate over it
-                        async for event in self.active_executor(step_input):  # type: ignore
+                        iterator = await self._acall_custom_function(
+                            self.active_executor, step_input, session_state_copy
+                        )  # type: ignore
+                        async for event in iterator:  # type: ignore
                             if (
                                 hasattr(event, "content")
                                 and event.content is not None
@@ -684,7 +777,7 @@ class Step:
                             final_response = StepOutput(content=content)
                     elif inspect.iscoroutinefunction(self.active_executor):
                         # It's a regular async function - await it
-                        result = await self.active_executor(step_input)  # type: ignore
+                        result = await self._acall_custom_function(self.active_executor, step_input, session_state_copy)  # type: ignore
                         if isinstance(result, StepOutput):
                             final_response = result
                         else:
@@ -692,7 +785,8 @@ class Step:
                     elif inspect.isgeneratorfunction(self.active_executor):
                         content = ""
                         # It's a regular generator function - iterate over it
-                        for event in self.active_executor(step_input):  # type: ignore
+                        iterator = self._call_custom_function(self.active_executor, step_input, session_state_copy)  # type: ignore
+                        for event in iterator:  # type: ignore
                             if (
                                 hasattr(event, "content")
                                 and event.content is not None
@@ -710,11 +804,15 @@ class Step:
                             final_response = StepOutput(content=content)
                     else:
                         # It's a regular function - call it directly
-                        result = self.active_executor(step_input)  # type: ignore
+                        result = self._call_custom_function(self.active_executor, step_input, session_state_copy)  # type: ignore
                         if isinstance(result, StepOutput):
                             final_response = result
                         else:
                             final_response = StepOutput(content=str(result))
+
+                    # Merge session_state changes back
+                    if session_state_copy and session_state:
+                        merge_dictionaries(session_state, session_state_copy)
                 else:
                     # For agents and teams, prepare message with context
                     message = self._prepare_message(

agno/workflow/workflow.py

@@ -51,6 +51,7 @@ from agno.run.workflow import (
 )
 from agno.session.workflow import WorkflowSession
 from agno.team.team import Team
+from agno.utils.common import is_typed_dict, validate_typed_dict
 from agno.utils.log import (
     log_debug,
     log_warning,
@@ -217,14 +218,18 @@ class Workflow:
 
     def _validate_input(
         self, input: Optional[Union[str, Dict[str, Any], List[Any], BaseModel, List[Message]]]
-    ) -> Optional[BaseModel]:
+    ) -> Optional[Union[str, List, Dict, Message, BaseModel]]:
         """Parse and validate input against input_schema if provided"""
         if self.input_schema is None:
-            return None
+            return input  # Return input unchanged if no schema is set
 
         if input is None:
             raise ValueError("Input required when input_schema is set")
 
+        # Handle Message objects - extract content
+        if isinstance(input, Message):
+            input = input.content  # type: ignore
+
         # If input is a string, convert it to a dict
         if isinstance(input, str):
             import json
@@ -238,8 +243,6 @@ class Workflow:
         if isinstance(input, BaseModel):
             if isinstance(input, self.input_schema):
                 try:
-                    # Re-validate to catch any field validation errors
-                    input.model_validate(input.model_dump())
                     return input
                 except Exception as e:
                     raise ValueError(f"BaseModel validation failed: {str(e)}")
@@ -250,8 +253,13 @@ class Workflow:
         # Case 2: Message is a dict
         elif isinstance(input, dict):
             try:
-                validated_model = self.input_schema(**input)
-                return validated_model
+                # Check if the schema is a TypedDict
+                if is_typed_dict(self.input_schema):
+                    validated_dict = validate_typed_dict(input, self.input_schema)
+                    return validated_dict
+                else:
+                    validated_model = self.input_schema(**input)
+                    return validated_model
             except Exception as e:
                 raise ValueError(f"Failed to parse dict into {self.input_schema.__name__}: {str(e)}")
 
@@ -1924,10 +1932,7 @@ class Workflow:
     ) -> Union[WorkflowRunOutput, Iterator[WorkflowRunOutputEvent]]:
         """Execute the workflow synchronously with optional streaming"""
 
-        validated_input = self._validate_input(input)
-        if validated_input is not None:
-            input = validated_input
-
+        input = self._validate_input(input)
         if background:
             raise RuntimeError("Background execution is not supported for sync run()")
 
@@ -2059,9 +2064,7 @@ class Workflow:
     ) -> Union[WorkflowRunOutput, AsyncIterator[WorkflowRunOutputEvent]]:
         """Execute the workflow synchronously with optional streaming"""
 
-        validated_input = self._validate_input(input)
-        if validated_input is not None:
-            input = validated_input
+        input = self._validate_input(input)
 
         websocket_handler = None
         if websocket:

{agno-2.0.3.dist-info → agno-2.0.4.dist-info}/METADATA

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