agno 2.3.13__py3-none-any.whl → 2.3.14__py3-none-any.whl

agno/utils/events.py

@@ -16,6 +16,7 @@ from agno.run.agent import (
     PreHookCompletedEvent,
     PreHookStartedEvent,
     ReasoningCompletedEvent,
+    ReasoningContentDeltaEvent,
     ReasoningStartedEvent,
     ReasoningStepEvent,
     RunCancelledEvent,
@@ -47,6 +48,7 @@ from agno.run.team import PostHookStartedEvent as TeamPostHookStartedEvent
 from agno.run.team import PreHookCompletedEvent as TeamPreHookCompletedEvent
 from agno.run.team import PreHookStartedEvent as TeamPreHookStartedEvent
 from agno.run.team import ReasoningCompletedEvent as TeamReasoningCompletedEvent
+from agno.run.team import ReasoningContentDeltaEvent as TeamReasoningContentDeltaEvent
 from agno.run.team import ReasoningStartedEvent as TeamReasoningStartedEvent
 from agno.run.team import ReasoningStepEvent as TeamReasoningStepEvent
 from agno.run.team import RunCancelledEvent as TeamRunCancelledEvent
@@ -161,23 +163,41 @@ def create_run_continued_event(from_run_response: RunOutput) -> RunContinuedEven
     )
 
 
-def create_team_run_error_event(from_run_response: TeamRunOutput, error: str) -> TeamRunErrorEvent:
+def create_team_run_error_event(
+    from_run_response: TeamRunOutput,
+    error: str,
+    error_type: Optional[str] = None,
+    error_id: Optional[str] = None,
+    additional_data: Optional[Dict[str, Any]] = None,
+) -> TeamRunErrorEvent:
     return TeamRunErrorEvent(
         session_id=from_run_response.session_id,
         team_id=from_run_response.team_id,  # type: ignore
         team_name=from_run_response.team_name,  # type: ignore
         run_id=from_run_response.run_id,
         content=error,
+        error_type=error_type,
+        error_id=error_id,
+        additional_data=additional_data,
     )
 
 
-def create_run_error_event(from_run_response: RunOutput, error: str) -> RunErrorEvent:
+def create_run_error_event(
+    from_run_response: RunOutput,
+    error: str,
+    error_type: Optional[str] = None,
+    error_id: Optional[str] = None,
+    additional_data: Optional[Dict[str, Any]] = None,
+) -> RunErrorEvent:
     return RunErrorEvent(
         session_id=from_run_response.session_id,
         agent_id=from_run_response.agent_id,  # type: ignore
         agent_name=from_run_response.agent_name,  # type: ignore
         run_id=from_run_response.run_id,
         content=error,
+        error_type=error_type,
+        error_id=error_id,
+        additional_data=additional_data,
     )
 
 
@@ -421,6 +441,19 @@ def create_reasoning_step_event(
     )
 
 
+def create_reasoning_content_delta_event(
+    from_run_response: RunOutput, reasoning_content: str
+) -> ReasoningContentDeltaEvent:
+    """Create an event for streaming reasoning content chunks."""
+    return ReasoningContentDeltaEvent(
+        session_id=from_run_response.session_id,
+        agent_id=from_run_response.agent_id,  # type: ignore
+        agent_name=from_run_response.agent_name,  # type: ignore
+        run_id=from_run_response.run_id,
+        reasoning_content=reasoning_content,
+    )
+
+
 def create_team_reasoning_step_event(
     from_run_response: TeamRunOutput, reasoning_step: ReasoningStep, reasoning_content: str
 ) -> TeamReasoningStepEvent:
@@ -435,6 +468,19 @@ def create_team_reasoning_step_event(
     )
 
 
+def create_team_reasoning_content_delta_event(
+    from_run_response: TeamRunOutput, reasoning_content: str
+) -> TeamReasoningContentDeltaEvent:
+    """Create an event for streaming reasoning content chunks for Team."""
+    return TeamReasoningContentDeltaEvent(
+        session_id=from_run_response.session_id,
+        team_id=from_run_response.team_id,  # type: ignore
+        team_name=from_run_response.team_name,  # type: ignore
+        run_id=from_run_response.run_id,
+        reasoning_content=reasoning_content,
+    )
+
+
 def create_reasoning_completed_event(
     from_run_response: RunOutput, content: Optional[Any] = None, content_type: Optional[str] = None
 ) -> ReasoningCompletedEvent:
@@ -698,3 +744,24 @@ def handle_event(
             run_response.events = []
         run_response.events.append(event)  # type: ignore
     return event
+
+
+def add_error_event(
+    error: RunErrorEvent,
+    events: Optional[List[RunOutputEvent]],
+):
+    if events is None:
+        events = []
+    events.append(error)
+
+    return events
+
+
+def add_team_error_event(
+    error: TeamRunErrorEvent,
+    events: Optional[List[Union[RunOutputEvent, TeamRunOutputEvent]]],
+):
+    if events is None:
+        events = []
+    events.append(error)
+    return events

agno/utils/hooks.py

@@ -1,9 +1,7 @@
 from copy import deepcopy
-from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Union
-
-if TYPE_CHECKING:
-    from agno.eval.base import BaseEval
+from typing import Any, Callable, Dict, List, Optional, Union
 
+from agno.eval.base import BaseEval
 from agno.guardrails.base import BaseGuardrail
 from agno.hooks.decorator import HOOK_RUN_IN_BACKGROUND_ATTR
 from agno.utils.log import log_warning
@@ -57,7 +55,7 @@ def should_run_hook_in_background(hook: Callable[..., Any]) -> bool:
 
 
 def normalize_pre_hooks(
-    hooks: Optional[List[Union[Callable[..., Any], BaseGuardrail, "BaseEval"]]],
+    hooks: Optional[List[Union[Callable[..., Any], BaseGuardrail, BaseEval]]],
     async_mode: bool = False,
 ) -> Optional[List[Callable[..., Any]]]:
     """Normalize pre-hooks to a list format.
@@ -66,8 +64,6 @@ def normalize_pre_hooks(
         hooks: List of hook functions, guardrails, or eval instances
         async_mode: Whether to use async versions of methods
     """
-    from agno.eval.base import BaseEval
-
     result_hooks: List[Callable[..., Any]] = []
 
     if hooks is not None:
@@ -102,7 +98,7 @@ def normalize_pre_hooks(
 
 
 def normalize_post_hooks(
-    hooks: Optional[List[Union[Callable[..., Any], BaseGuardrail, "BaseEval"]]],
+    hooks: Optional[List[Union[Callable[..., Any], BaseGuardrail, BaseEval]]],
     async_mode: bool = False,
 ) -> Optional[List[Callable[..., Any]]]:
     """Normalize post-hooks to a list format.
@@ -111,8 +107,6 @@ def normalize_post_hooks(
         hooks: List of hook functions, guardrails, or eval instances
         async_mode: Whether to use async versions of methods
     """
-    from agno.eval.base import BaseEval
-
     result_hooks: List[Callable[..., Any]] = []
 
     if hooks is not None:

agno/utils/print_response/agent.py

@@ -134,6 +134,11 @@ def print_response_stream(
                                 )
                             except Exception as e:
                                 log_warning(f"Failed to convert response to JSON: {e}")
+                        elif agent.output_schema is not None and isinstance(response_event.content, dict):
+                            try:
+                                response_content_batch = JSON(json.dumps(response_event.content), indent=2)  # type: ignore
+                            except Exception as e:
+                                log_warning(f"Failed to convert response to JSON: {e}")
                         else:
                             try:
                                 response_content_batch = JSON(json.dumps(response_event.content), indent=4)
@@ -141,6 +146,12 @@ def print_response_stream(
                                 log_warning(f"Failed to convert response to JSON: {e}")
                     if hasattr(response_event, "reasoning_content") and response_event.reasoning_content is not None:  # type: ignore
                         _response_reasoning_content += response_event.reasoning_content  # type: ignore
+
+                # Handle streaming reasoning content delta events
+                if response_event.event == RunEvent.reasoning_content_delta:  # type: ignore
+                    if hasattr(response_event, "reasoning_content") and response_event.reasoning_content is not None:  # type: ignore
+                        _response_reasoning_content += response_event.reasoning_content  # type: ignore
+
                 if hasattr(response_event, "reasoning_steps") and response_event.reasoning_steps is not None:  # type: ignore
                     reasoning_steps = response_event.reasoning_steps  # type: ignore
 
@@ -325,6 +336,11 @@ async def aprint_response_stream(
                             response_content_batch = JSON(resp.content.model_dump_json(exclude_none=True), indent=2)  # type: ignore
                         except Exception as e:
                             log_warning(f"Failed to convert response to JSON: {e}")
+                    elif agent.output_schema is not None and isinstance(resp.content, dict):
+                        try:
+                            response_content_batch = JSON(json.dumps(resp.content), indent=2)  # type: ignore
+                        except Exception as e:
+                            log_warning(f"Failed to convert response to JSON: {e}")
                     else:
                         try:
                             response_content_batch = JSON(json.dumps(resp.content), indent=4)
@@ -333,6 +349,11 @@ async def aprint_response_stream(
                     if resp.reasoning_content is not None:  # type: ignore
                         _response_reasoning_content += resp.reasoning_content  # type: ignore
 
+                # Handle streaming reasoning content delta events
+                if resp.event == RunEvent.reasoning_content_delta:  # type: ignore
+                    if hasattr(resp, "reasoning_content") and resp.reasoning_content is not None:  # type: ignore
+                        _response_reasoning_content += resp.reasoning_content  # type: ignore
+
                 if hasattr(resp, "reasoning_steps") and resp.reasoning_steps is not None:  # type: ignore
                     reasoning_steps = resp.reasoning_steps  # type: ignore
 
@@ -883,6 +904,11 @@ def build_panels(
                 response_content_batch = JSON(run_response.content.model_dump_json(exclude_none=True), indent=2)
             except Exception as e:
                 log_warning(f"Failed to convert response to JSON: {e}")
+        elif output_schema is not None and isinstance(run_response.content, dict):
+            try:
+                response_content_batch = JSON(json.dumps(run_response.content), indent=2)
+            except Exception as e:
+                log_warning(f"Failed to convert response to JSON: {e}")
         else:
             try:
                 response_content_batch = JSON(json.dumps(run_response.content), indent=4)

agno/utils/print_response/team.py

@@ -1,3 +1,4 @@
+import json
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Sequence, Set, Union, get_args
 
 from pydantic import BaseModel
@@ -488,6 +489,11 @@ def print_response_stream(
                             _response_content = JSON(resp.content.model_dump_json(exclude_none=True), indent=2)  # type: ignore
                         except Exception as e:
                             log_warning(f"Failed to convert response to JSON: {e}")
+                    elif team.output_schema is not None and isinstance(resp.content, dict):
+                        try:
+                            _response_content = JSON(json.dumps(resp.content), indent=2)  # type: ignore
+                        except Exception as e:
+                            log_warning(f"Failed to convert response to JSON: {e}")
                     if hasattr(resp, "reasoning_content") and resp.reasoning_content is not None:  # type: ignore
                         _response_reasoning_content += resp.reasoning_content  # type: ignore
                 if hasattr(resp, "reasoning_steps") and resp.reasoning_steps is not None:  # type: ignore
@@ -1412,6 +1418,11 @@ async def aprint_response_stream(
                             _response_content = JSON(resp.content.model_dump_json(exclude_none=True), indent=2)  # type: ignore
                         except Exception as e:
                             log_warning(f"Failed to convert response to JSON: {e}")
+                    elif team.output_schema is not None and isinstance(resp.content, dict):
+                        try:
+                            _response_content = JSON(json.dumps(resp.content), indent=2)  # type: ignore
+                        except Exception as e:
+                            log_warning(f"Failed to convert response to JSON: {e}")
                     if hasattr(resp, "reasoning_content") and resp.reasoning_content is not None:  # type: ignore
                         _response_reasoning_content += resp.reasoning_content  # type: ignore
                 if hasattr(resp, "reasoning_steps") and resp.reasoning_steps is not None:  # type: ignore

agno/utils/prompts.py

@@ -6,7 +6,7 @@ from pydantic import BaseModel
 from agno.utils.log import log_warning
 
 
-def get_json_output_prompt(output_schema: Union[str, list, BaseModel]) -> str:
+def get_json_output_prompt(output_schema: Union[str, list, dict, BaseModel]) -> str:
     """Return the JSON output prompt for the Agent.
 
     This is added to the system prompt when the output_schema is set and structured_outputs is False.
@@ -22,11 +22,13 @@ def get_json_output_prompt(output_schema: Union[str, list, BaseModel]) -> str:
             json_output_prompt += "\n<json_fields>"
             json_output_prompt += f"\n{json.dumps(output_schema)}"
             json_output_prompt += "\n</json_fields>"
-        elif (
-            issubclass(type(output_schema), BaseModel)
-            or issubclass(output_schema, BaseModel)  # type: ignore
-            or isinstance(output_schema, BaseModel)
-        ):  # type: ignore
+        elif isinstance(output_schema, dict):
+            json_output_prompt += "\n<json_fields>"
+            json_output_prompt += f"\n{json.dumps(output_schema)}"
+            json_output_prompt += "\n</json_fields>"
+        elif (isinstance(output_schema, type) and issubclass(output_schema, BaseModel)) or isinstance(
+            output_schema, BaseModel
+        ):
             json_schema = output_schema.model_json_schema()
             if json_schema is not None:
                 response_model_properties = {}

agno/utils/string.py

@@ -201,6 +201,52 @@ def parse_response_model_str(content: str, output_schema: Type[BaseModel]) -> Op
     return structured_output
 
 
+def parse_response_dict_str(content: str) -> Optional[dict]:
+    """Parse dict from string content, extracting JSON if needed"""
+    from agno.utils.reasoning import extract_thinking_content
+
+    # Handle thinking content b/w <think> tags
+    if "</think>" in content:
+        reasoning_content, output_content = extract_thinking_content(content)
+        if reasoning_content:
+            content = output_content
+
+    # Clean content first to simplify all parsing attempts
+    cleaned_content = _clean_json_content(content)
+
+    try:
+        # First attempt: direct JSON parsing on cleaned content
+        return json.loads(cleaned_content)
+    except json.JSONDecodeError as e:
+        logger.warning(f"Failed to parse cleaned JSON: {e}")
+
+        # Second attempt: Extract individual JSON objects
+        candidate_jsons = _extract_json_objects(cleaned_content)
+
+        if len(candidate_jsons) == 1:
+            # Single JSON object - try to parse it directly
+            try:
+                return json.loads(candidate_jsons[0])
+            except json.JSONDecodeError:
+                pass
+
+        if len(candidate_jsons) > 1:
+            # Final attempt: Merge multiple JSON objects
+            merged_data: dict = {}
+            for candidate in candidate_jsons:
+                try:
+                    obj = json.loads(candidate)
+                    if isinstance(obj, dict):
+                        merged_data.update(obj)
+                except json.JSONDecodeError:
+                    continue
+            if merged_data:
+                return merged_data
+
+        logger.warning("All parsing attempts failed.")
+        return None
+
+
 def generate_id(seed: Optional[str] = None) -> str:
     """
     Generate a deterministic UUID5 based on a seed string.

agno/utils/team.py

@@ -59,7 +59,7 @@ def add_interaction_to_team_run_context(
     team_run_context: Dict[str, Any],
     member_name: str,
     task: str,
-    run_response: Union[RunOutput, TeamRunOutput],
+    run_response: Optional[Union[RunOutput, TeamRunOutput]],
 ) -> None:
     if "member_responses" not in team_run_context:
         team_run_context["member_responses"] = []

agno/vectordb/milvus/milvus.py

@@ -651,7 +651,11 @@ class Milvus(VectorDb):
         return MILVUS_DISTANCE_MAP.get(self.distance, "COSINE")
 
     def search(
-        self, query: str, limit: int = 5, filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None
+        self,
+        query: str,
+        limit: int = 5,
+        filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None,
+        search_params: Optional[Dict[str, Any]] = None,
     ) -> List[Document]:
         """
         Search for documents matching the query.
@@ -660,6 +664,10 @@ class Milvus(VectorDb):
             query (str): Query string to search for
             limit (int): Maximum number of results to return
             filters (Optional[Dict[str, Any]]): Filters to apply to the search
+            search_params (Optional[Dict[str, Any]]): Milvus search parameters including:
+                - radius (float): Minimum similarity threshold for range search
+                - range_filter (float): Maximum similarity threshold for range search
+                - params (dict): Index-specific search params (e.g., nprobe, ef)
 
         Returns:
             List[Document]: List of matching documents
@@ -681,6 +689,7 @@ class Milvus(VectorDb):
             filter=self._build_expr(filters),
             output_fields=["*"],
             limit=limit,
+            search_params=search_params,
         )
 
         # Build search results
@@ -708,8 +717,27 @@ class Milvus(VectorDb):
         return search_results
 
     async def async_search(
-        self, query: str, limit: int = 5, filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None
+        self,
+        query: str,
+        limit: int = 5,
+        filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None,
+        search_params: Optional[Dict[str, Any]] = None,
     ) -> List[Document]:
+        """
+        Asynchronously search for documents matching the query.
+
+        Args:
+            query (str): Query string to search for
+            limit (int): Maximum number of results to return
+            filters (Optional[Dict[str, Any]]): Filters to apply to the search
+            search_params (Optional[Dict[str, Any]]): Milvus search parameters including:
+                - radius (float): Minimum similarity threshold for range search
+                - range_filter (float): Maximum similarity threshold for range search
+                - params (dict): Index-specific search params (e.g., nprobe, ef)
+
+        Returns:
+            List[Document]: List of matching documents
+        """
         if isinstance(filters, List):
             log_warning("Filters Expressions are not supported in Milvus. No filters will be applied.")
             filters = None
@@ -727,6 +755,7 @@ class Milvus(VectorDb):
             filter=self._build_expr(filters),
             output_fields=["*"],
             limit=limit,
+            search_params=search_params,
         )
 
         # Build search results
@@ -1073,7 +1102,7 @@ class Milvus(VectorDb):
             if isinstance(v, (list, tuple)):
                 # For array values, use json_contains_any
                 values_str = json.dumps(v)
-                expr = f'json_contains_any(meta_data, {values_str}, "{k}")'
+                expr = f'json_contains_any(meta_data["{k}"], {values_str})'
             elif isinstance(v, str):
                 # For string values
                 expr = f'meta_data["{k}"] == "{v}"'

{agno-2.3.13.dist-info → agno-2.3.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agno
-Version: 2.3.13
+Version: 2.3.14
 Summary: Agno: a lightweight library for building Multi-Agent Systems
 Author-email: Ashpreet Bedi <ashpreet@agno.com>
 Project-URL: homepage, https://agno.com
@@ -212,7 +212,7 @@ Provides-Extra: firestore
 Requires-Dist: google-cloud-firestore; extra == "firestore"
 Provides-Extra: redis
 Requires-Dist: redis; extra == "redis"
-Requires-Dist: redisvl; extra == "redis"
+Requires-Dist: redisvl>=0.12.1; extra == "redis"
 Provides-Extra: mysql
 Requires-Dist: pymysql; extra == "mysql"
 Requires-Dist: asyncmy; extra == "mysql"
@@ -364,6 +364,7 @@ Requires-Dist: agno[pinecone]; extra == "vectordbs"
 Requires-Dist: agno[surrealdb]; extra == "vectordbs"
 Requires-Dist: agno[upstash]; extra == "vectordbs"
 Requires-Dist: agno[pylance]; extra == "vectordbs"
+Requires-Dist: agno[redis]; extra == "vectordbs"
 Provides-Extra: knowledge
 Requires-Dist: agno[pdf]; extra == "knowledge"
 Requires-Dist: agno[docx]; extra == "knowledge"