agno 2.2.13__py3-none-any.whl → 2.4.3__py3-none-any.whl

agno/utils/string.py

@@ -2,13 +2,15 @@ import hashlib
 import json
 import re
 import uuid
-from typing import Optional, Type
+from typing import Any, Optional, Type, Union
 from uuid import uuid4
 
 from pydantic import BaseModel, ValidationError
 
 from agno.utils.log import logger
 
+POSTGRES_INVALID_CHARS_REGEX = re.compile(r"[\x00-\x08\x0b\x0c\x0e-\x1f\ufffe\uffff]")
+
 
 def is_valid_uuid(uuid_str: str) -> bool:
     """
@@ -87,7 +89,8 @@ def _clean_json_content(content: str) -> str:
     if "```json" in content:
         content = content.split("```json")[-1].strip()
         parts = content.split("```")
-        parts.pop(-1)
+        if len(parts) > 1:
+            parts.pop(-1)
         content = "".join(parts)
     elif "```" in content:
         content = content.split("```")[1].strip()
@@ -201,6 +204,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.
@@ -229,3 +278,43 @@ def generate_id_from_name(name: Optional[str] = None) -> str:
         return name.lower().replace(" ", "-").replace("_", "-")
     else:
         return str(uuid4())
+
+
+def sanitize_postgres_string(value: Optional[str]) -> Optional[str]:
+    """Remove illegal chars from string values to prevent PostgreSQL encoding errors.
+
+    This function all chars illegal in Postgres UTF-8 text fields.
+    Useful to prevent CharacterNotInRepertoireError when storing strings.
+
+    Args:
+        value: The string value to sanitize.
+
+    Returns:
+        The sanitized string with illegal chars removed, or None if input was None.
+    """
+    if value is None:
+        return None
+    if isinstance(value, str):
+        return POSTGRES_INVALID_CHARS_REGEX.sub("", value)
+
+
+def sanitize_postgres_strings(data: Union[dict, list, str, Any]) -> Union[dict, list, str, Any]:
+    """Recursively sanitize all string values in a dictionary or JSON structure.
+
+    This function traverses dictionaries, lists, and nested structures to find
+    and sanitize all string values, removing null bytes that PostgreSQL cannot handle.
+
+    Args:
+        data: The data structure to sanitize (dict, list, str or any other type).
+
+    Returns:
+        The sanitized data structure with all strings cleaned of null bytes.
+    """
+    if isinstance(data, dict):
+        return {key: sanitize_postgres_strings(value) for key, value in data.items()}
+    elif isinstance(data, list):
+        return [sanitize_postgres_strings(item) for item in data]
+    elif isinstance(data, str):
+        return sanitize_postgres_string(data)
+    else:
+        return data

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"] = []
@@ -73,14 +73,40 @@ def add_interaction_to_team_run_context(
     log_debug(f"Updated team run context with member name: {member_name}")
 
 
-def get_team_member_interactions_str(team_run_context: Dict[str, Any]) -> str:
+def get_team_member_interactions_str(
+    team_run_context: Dict[str, Any],
+    max_interactions: Optional[int] = None,
+) -> str:
+    """
+    Build a string representation of member interactions from the team run context.
+
+    Args:
+        team_run_context: The context containing member responses
+        max_interactions: Maximum number of recent interactions to include.
+                         None means include all interactions.
+                         If set, only the most recent N interactions are included.
+
+    Returns:
+        A formatted string with member interactions
+    """
     if not team_run_context:
         return ""
     team_member_interactions_str = ""
     if "member_responses" in team_run_context:
-        team_member_interactions_str += "<member_interaction_context>\nSee below interactions wit other team members.\n"
+        member_responses = team_run_context["member_responses"]
+
+        # If max_interactions is set, only include the most recent N interactions
+        if max_interactions is not None and len(member_responses) > max_interactions:
+            member_responses = member_responses[-max_interactions:]
 
-        for interaction in team_run_context["member_responses"]:
+        if not member_responses:
+            return ""
+
+        team_member_interactions_str += (
+            "<member_interaction_context>\nSee below interactions with other team members.\n"
+        )
+
+        for interaction in member_responses:
             response_dict = interaction["run_response"].to_dict()
             response_content = (
                 response_dict.get("content")
@@ -95,45 +121,69 @@ def get_team_member_interactions_str(team_run_context: Dict[str, Any]) -> str:
     return team_member_interactions_str
 
 
-def get_team_run_context_images(team_run_context: Dict[str, Any]) -> List[Image]:
+def get_team_run_context_images(
+    team_run_context: Dict[str, Any],
+    max_interactions: Optional[int] = None,
+) -> List[Image]:
     if not team_run_context:
         return []
     images = []
     if "member_responses" in team_run_context:
-        for interaction in team_run_context["member_responses"]:
+        member_responses = team_run_context["member_responses"]
+        if max_interactions is not None and len(member_responses) > max_interactions:
+            member_responses = member_responses[-max_interactions:]
+        for interaction in member_responses:
             if interaction["run_response"].images:
                 images.extend(interaction["run_response"].images)
     return images
 
 
-def get_team_run_context_videos(team_run_context: Dict[str, Any]) -> List[Video]:
+def get_team_run_context_videos(
+    team_run_context: Dict[str, Any],
+    max_interactions: Optional[int] = None,
+) -> List[Video]:
     if not team_run_context:
         return []
     videos = []
     if "member_responses" in team_run_context:
-        for interaction in team_run_context["member_responses"]:
+        member_responses = team_run_context["member_responses"]
+        if max_interactions is not None and len(member_responses) > max_interactions:
+            member_responses = member_responses[-max_interactions:]
+        for interaction in member_responses:
             if interaction["run_response"].videos:
                 videos.extend(interaction["run_response"].videos)
     return videos
 
 
-def get_team_run_context_audio(team_run_context: Dict[str, Any]) -> List[Audio]:
+def get_team_run_context_audio(
+    team_run_context: Dict[str, Any],
+    max_interactions: Optional[int] = None,
+) -> List[Audio]:
     if not team_run_context:
         return []
     audio = []
     if "member_responses" in team_run_context:
-        for interaction in team_run_context["member_responses"]:
+        member_responses = team_run_context["member_responses"]
+        if max_interactions is not None and len(member_responses) > max_interactions:
+            member_responses = member_responses[-max_interactions:]
+        for interaction in member_responses:
             if interaction["run_response"].audio:
                 audio.extend(interaction["run_response"].audio)
     return audio
 
 
-def get_team_run_context_files(team_run_context: Dict[str, Any]) -> List[File]:
+def get_team_run_context_files(
+    team_run_context: Dict[str, Any],
+    max_interactions: Optional[int] = None,
+) -> List[File]:
     if not team_run_context:
         return []
     files = []
     if "member_responses" in team_run_context:
-        for interaction in team_run_context["member_responses"]:
+        member_responses = team_run_context["member_responses"]
+        if max_interactions is not None and len(member_responses) > max_interactions:
+            member_responses = member_responses[-max_interactions:]
+        for interaction in member_responses:
             if interaction["run_response"].files:
                 files.extend(interaction["run_response"].files)
     return files