agno 1.8.0__py3-none-any.whl → 2.0.0a1__py3-none-any.whl

agno/utils/prompts.py

@@ -6,28 +6,28 @@ from pydantic import BaseModel
 from agno.utils.log import log_warning
 
 
-def get_json_output_prompt(response_model: Union[str, list, BaseModel]) -> str:
+def get_json_output_prompt(output_schema: Union[str, list, BaseModel]) -> str:
     """Return the JSON output prompt for the Agent.
 
-    This is added to the system prompt when the response_model is set and structured_outputs is False.
+    This is added to the system prompt when the output_schema is set and structured_outputs is False.
     """
 
     json_output_prompt = "Provide your output as a JSON containing the following fields:"
-    if response_model is not None:
-        if isinstance(response_model, str):
+    if output_schema is not None:
+        if isinstance(output_schema, str):
             json_output_prompt += "\n<json_fields>"
-            json_output_prompt += f"\n{response_model}"
+            json_output_prompt += f"\n{output_schema}"
             json_output_prompt += "\n</json_fields>"
-        elif isinstance(response_model, list):
+        elif isinstance(output_schema, list):
             json_output_prompt += "\n<json_fields>"
-            json_output_prompt += f"\n{json.dumps(response_model)}"
+            json_output_prompt += f"\n{json.dumps(output_schema)}"
             json_output_prompt += "\n</json_fields>"
         elif (
-            issubclass(type(response_model), BaseModel)
-            or issubclass(response_model, BaseModel)  # type: ignore
-            or isinstance(response_model, BaseModel)
+            issubclass(type(output_schema), BaseModel)
+            or issubclass(output_schema, BaseModel)  # type: ignore
+            or isinstance(output_schema, BaseModel)
         ):  # type: ignore
-            json_schema = response_model.model_json_schema()
+            json_schema = output_schema.model_json_schema()
             if json_schema is not None:
                 response_model_properties = {}
                 json_schema_properties = json_schema.get("properties")
@@ -85,7 +85,7 @@ def get_json_output_prompt(response_model: Union[str, list, BaseModel]) -> str:
                     json_output_prompt += f"\n{json.dumps(response_model_properties, indent=2)}"
                     json_output_prompt += "\n</json_field_properties>"
         else:
-            log_warning(f"Could not build json schema for {response_model}")
+            log_warning(f"Could not build json schema for {output_schema}")
     else:
         json_output_prompt += "Provide the output as JSON."
 
@@ -95,13 +95,13 @@ def get_json_output_prompt(response_model: Union[str, list, BaseModel]) -> str:
     return json_output_prompt
 
 
-def get_response_model_format_prompt(response_model: Type[BaseModel]) -> str:
+def get_response_model_format_prompt(output_schema: Type[BaseModel]) -> str:
     """Return the format prompt for the response model."""
 
     message = "Make sure your response is a valid string (NOT JSON) that mentions the following topics:"
 
     # Extract field names and descriptions
-    for field_name, field_info in response_model.model_fields.items():
+    for field_name, field_info in output_schema.model_fields.items():
         description = field_info.description or ""
         if description:
             message += f"\n- {field_name}: {description}"

agno/utils/reasoning.py

@@ -0,0 +1,87 @@
+from typing import TYPE_CHECKING, List, Union
+
+from agno.models.message import Message
+from agno.models.metrics import Metrics
+from agno.reasoning.step import ReasoningStep
+
+if TYPE_CHECKING:
+    from agno.run.agent import RunOutput
+    from agno.team.team import TeamRunOutput
+
+
+def append_to_reasoning_content(run_response: Union["RunOutput", "TeamRunOutput"], content: str) -> None:
+    """Helper to append content to the reasoning_content field."""
+    if not hasattr(run_response, "reasoning_content") or not run_response.reasoning_content:  # type: ignore
+        run_response.reasoning_content = content  # type: ignore
+    else:
+        run_response.reasoning_content += content  # type: ignore
+
+
+def add_reasoning_step_to_metadata(
+    run_response: Union["RunOutput", "TeamRunOutput"], reasoning_step: ReasoningStep
+) -> None:
+    if run_response.reasoning_steps is None:
+        run_response.reasoning_steps = []
+
+    run_response.reasoning_steps.append(reasoning_step)
+
+
+def add_reasoning_metrics_to_metadata(
+    run_response: Union["RunOutput", "TeamRunOutput"], reasoning_time_taken: float
+) -> None:
+    try:
+        # Initialize reasoning_messages if it doesn't exist
+        if run_response.reasoning_messages is None:
+            run_response.reasoning_messages = []
+
+        metrics_message = Message(
+            role="assistant",
+            content=run_response.reasoning_content,
+            metrics=Metrics(duration=reasoning_time_taken),
+        )
+
+        # Add the metrics message to the reasoning_messages
+        run_response.reasoning_messages.append(metrics_message)
+
+    except Exception as e:
+        # Log the error but don't crash
+        from agno.utils.log import log_error
+
+        log_error(f"Failed to add reasoning metrics to metadata: {str(e)}")
+
+
+def update_run_output_with_reasoning(
+    run_response: Union["RunOutput", "TeamRunOutput"],
+    reasoning_steps: List[ReasoningStep],
+    reasoning_agent_messages: List[Message],
+) -> None:
+    # Update reasoning_steps
+    if run_response.reasoning_steps is None:
+        run_response.reasoning_steps = reasoning_steps
+    else:
+        run_response.reasoning_steps.extend(reasoning_steps)
+
+    # Update reasoning_messages
+    if run_response.reasoning_messages is None:
+        run_response.reasoning_messages = reasoning_agent_messages
+    else:
+        run_response.reasoning_messages.extend(reasoning_agent_messages)
+
+    # Create and store reasoning_content
+    reasoning_content = ""
+    for step in reasoning_steps:
+        if step.title:
+            reasoning_content += f"## {step.title}\n"
+        if step.reasoning:
+            reasoning_content += f"{step.reasoning}\n"
+        if step.action:
+            reasoning_content += f"Action: {step.action}\n"
+        if step.result:
+            reasoning_content += f"Result: {step.result}\n"
+        reasoning_content += "\n"
+
+    # Add to existing reasoning_content or set it
+    if not run_response.reasoning_content:
+        run_response.reasoning_content = reasoning_content
+    else:
+        run_response.reasoning_content += reasoning_content

agno/utils/response.py

@@ -1,12 +1,10 @@
 from typing import AsyncIterator, Iterator, List, Set, Union
 
 from agno.exceptions import RunCancelledException
-from agno.models.message import Message
 from agno.models.response import ToolExecution
 from agno.reasoning.step import ReasoningStep
-from agno.run.base import RunResponseExtraData
-from agno.run.response import RunResponse, RunResponseEvent, RunResponsePausedEvent
-from agno.run.team import TeamRunResponse, TeamRunResponseEvent
+from agno.run.agent import RunOutput, RunOutputEvent, RunPausedEvent
+from agno.run.team import TeamRunOutput, TeamRunOutputEvent
 
 
 def create_panel(content, title, border_style="blue"):
@@ -18,6 +16,29 @@ def create_panel(content, title, border_style="blue"):
     )
 
 
+def build_reasoning_step_panel(
+    step_idx: int, step: ReasoningStep, show_full_reasoning: bool = False, color: str = "green"
+):
+    from rich.text import Text
+
+    # Build step content
+    step_content = Text.assemble()
+    if step.title is not None:
+        step_content.append(f"{step.title}\n", "bold")
+    if step.action is not None:
+        step_content.append(Text.from_markup(f"[bold]Action:[/bold] {step.action}\n", style="dim"))
+    if step.result is not None:
+        step_content.append(Text.from_markup(step.result, style="dim"))
+
+    if show_full_reasoning:
+        # Add detailed reasoning information if available
+        if step.reasoning is not None:
+            step_content.append(Text.from_markup(f"\n[bold]Reasoning:[/bold] {step.reasoning}", style="dim"))
+        if step.confidence is not None:
+            step_content.append(Text.from_markup(f"\n[bold]Confidence:[/bold] {step.confidence}", style="dim"))
+    return create_panel(content=step_content, title=f"Reasoning step {step_idx}", border_style=color)
+
+
 def escape_markdown_tags(content: str, tags: Set[str]) -> str:
     """Escape special tags in markdown content."""
     escaped_content = content
@@ -29,32 +50,11 @@ def escape_markdown_tags(content: str, tags: Set[str]) -> str:
     return escaped_content
 
 
-def check_if_run_cancelled(run_response: Union[RunResponse, RunResponseEvent, TeamRunResponse, TeamRunResponseEvent]):
-    if run_response.is_cancelled:
+def check_if_run_cancelled(run_output: Union[RunOutput, RunOutputEvent, TeamRunOutput, TeamRunOutputEvent]):
+    if run_output.is_cancelled:
         raise RunCancelledException()
 
 
-def update_run_response_with_reasoning(
-    run_response: Union[RunResponse, TeamRunResponse],
-    reasoning_steps: List[ReasoningStep],
-    reasoning_agent_messages: List[Message],
-) -> None:
-    if run_response.extra_data is None:
-        run_response.extra_data = RunResponseExtraData()
-
-    # Update reasoning_steps
-    if run_response.extra_data.reasoning_steps is None:
-        run_response.extra_data.reasoning_steps = reasoning_steps
-    else:
-        run_response.extra_data.reasoning_steps.extend(reasoning_steps)
-
-    # Update reasoning_messages
-    if run_response.extra_data.reasoning_messages is None:
-        run_response.extra_data.reasoning_messages = reasoning_agent_messages
-    else:
-        run_response.extra_data.reasoning_messages.extend(reasoning_agent_messages)
-
-
 def format_tool_calls(tool_calls: List[ToolExecution]) -> List[str]:
     """Format tool calls for display in a readable format.
 
@@ -70,39 +70,39 @@ def format_tool_calls(tool_calls: List[ToolExecution]) -> List[str]:
         if tool_call.tool_name is not None:
             tool_name = tool_call.tool_name
             args_str = ""
-            if tool_call.tool_args is not None:
+            if tool_call.tool_args is not None and tool_call.tool_args:  # Check if args exist and are non-empty
                 args_str = ", ".join(f"{k}={v}" for k, v in tool_call.tool_args.items())
             formatted_tool_calls.append(f"{tool_name}({args_str})")
 
     return formatted_tool_calls
 
 
-def create_paused_run_response_panel(run_response: Union[RunResponsePausedEvent, RunResponse]):
+def create_paused_run_output_panel(run_output: Union[RunPausedEvent, RunOutput]):
     from rich.text import Text
 
     tool_calls_content = Text("Run is paused. ")
-    if run_response.tools is not None:
-        if any(tc.requires_confirmation for tc in run_response.tools):
+    if run_output.tools is not None:
+        if any(tc.requires_confirmation for tc in run_output.tools):
             tool_calls_content.append("The following tool calls require confirmation:\n")
-        for tool_call in run_response.tools:
+        for tool_call in run_output.tools:
             if tool_call.requires_confirmation:
                 args_str = ""
                 for arg, value in tool_call.tool_args.items() if tool_call.tool_args else {}:
                     args_str += f"{arg}={value}, "
                 args_str = args_str.rstrip(", ")
                 tool_calls_content.append(f"• {tool_call.tool_name}({args_str})\n")
-        if any(tc.requires_user_input for tc in run_response.tools):
+        if any(tc.requires_user_input for tc in run_output.tools):
             tool_calls_content.append("The following tool calls require user input:\n")
-        for tool_call in run_response.tools:
+        for tool_call in run_output.tools:
             if tool_call.requires_user_input:
                 args_str = ""
                 for arg, value in tool_call.tool_args.items() if tool_call.tool_args else {}:
                     args_str += f"{arg}={value}, "
                 args_str = args_str.rstrip(", ")
                 tool_calls_content.append(f"• {tool_call.tool_name}({args_str})\n")
-        if any(tc.external_execution_required for tc in run_response.tools):
+        if any(tc.external_execution_required for tc in run_output.tools):
             tool_calls_content.append("The following tool calls require external execution:\n")
-        for tool_call in run_response.tools:
+        for tool_call in run_output.tools:
             if tool_call.external_execution_required:
                 args_str = ""
                 for arg, value in tool_call.tool_args.items() if tool_call.tool_args else {}:
@@ -119,9 +119,9 @@ def create_paused_run_response_panel(run_response: Union[RunResponsePausedEvent,
     return response_panel
 
 
-def get_paused_content(run_response: RunResponse) -> str:
+def get_paused_content(run_output: RunOutput) -> str:
     paused_content = ""
-    for tool in run_response.tools or []:
+    for tool in run_output.tools or []:
         # Initialize flags for each tool
         confirmation_required = False
         user_input_required = False
@@ -152,12 +152,12 @@ def get_paused_content(run_response: RunResponse) -> str:
 
 
 def generator_wrapper(
-    event: Union[RunResponseEvent, TeamRunResponseEvent],
-) -> Iterator[Union[RunResponseEvent, TeamRunResponseEvent]]:
+    event: Union[RunOutputEvent, TeamRunOutputEvent],
+) -> Iterator[Union[RunOutputEvent, TeamRunOutputEvent]]:
     yield event
 
 
 async def async_generator_wrapper(
-    event: Union[RunResponseEvent, TeamRunResponseEvent],
-) -> AsyncIterator[Union[RunResponseEvent, TeamRunResponseEvent]]:
+    event: Union[RunOutputEvent, TeamRunOutputEvent],
+) -> AsyncIterator[Union[RunOutputEvent, TeamRunOutputEvent]]:
     yield event

agno/utils/string.py

@@ -27,20 +27,6 @@ def is_valid_uuid(uuid_str: str) -> bool:
         return False
 
 
-def safe_content_hash(content: str) -> str:
-    """
-    Return an MD5 hash of the input string, replacing null bytes and invalid surrogates for safe hashing.
-    """
-    cleaned_content = content.replace("\x00", "\ufffd")
-    try:
-        content_hash = hashlib.md5(cleaned_content.encode("utf-8")).hexdigest()
-    except UnicodeEncodeError:
-        cleaned_content = "".join("\ufffd" if "\ud800" <= c <= "\udfff" else c for c in cleaned_content)
-        content_hash = hashlib.md5(cleaned_content.encode("utf-8")).hexdigest()
-
-    return content_hash
-
-
 def url_safe_string(input_string):
     # Replace spaces with dashes
     safe_string = input_string.replace(" ", "-")
@@ -130,13 +116,13 @@ def _clean_json_content(content: str) -> str:
     return content
 
 
-def _parse_individual_json(content: str, response_model: Type[BaseModel]) -> Optional[BaseModel]:
+def _parse_individual_json(content: str, output_schema: Type[BaseModel]) -> Optional[BaseModel]:
     """Parse individual JSON objects from content and merge them based on response model fields."""
     candidate_jsons = _extract_json_objects(content)
     merged_data: dict = {}
 
     # Get the expected fields from the response model
-    model_fields = response_model.model_fields if hasattr(response_model, "model_fields") else {}
+    model_fields = output_schema.model_fields if hasattr(output_schema, "model_fields") else {}
 
     for candidate in candidate_jsons:
         try:
@@ -161,13 +147,13 @@ def _parse_individual_json(content: str, response_model: Type[BaseModel]) -> Opt
         return None
 
     try:
-        return response_model.model_validate(merged_data)
+        return output_schema.model_validate(merged_data)
     except ValidationError as e:
         logger.warning("Validation failed on merged data: %s", e)
         return None
 
 
-def parse_response_model_str(content: str, response_model: Type[BaseModel]) -> Optional[BaseModel]:
+def parse_response_model_str(content: str, output_schema: Type[BaseModel]) -> Optional[BaseModel]:
     structured_output = None
 
     # Clean content first to simplify all parsing attempts
@@ -175,12 +161,12 @@ def parse_response_model_str(content: str, response_model: Type[BaseModel]) -> O
 
     try:
         # First attempt: direct JSON validation on cleaned content
-        structured_output = response_model.model_validate_json(cleaned_content)
+        structured_output = output_schema.model_validate_json(cleaned_content)
     except (ValidationError, json.JSONDecodeError):
         try:
             # Second attempt: Parse as Python dict
             data = json.loads(cleaned_content)
-            structured_output = response_model.model_validate(data)
+            structured_output = output_schema.model_validate(data)
         except (ValidationError, json.JSONDecodeError) as e:
             logger.warning(f"Failed to parse cleaned JSON: {e}")
 
@@ -191,13 +177,13 @@ def parse_response_model_str(content: str, response_model: Type[BaseModel]) -> O
                 # Single JSON object - try to parse it directly
                 try:
                     data = json.loads(candidate_jsons[0])
-                    structured_output = response_model.model_validate(data)
+                    structured_output = output_schema.model_validate(data)
                 except (ValidationError, json.JSONDecodeError):
                     pass
 
             if structured_output is None:
                 # Final attempt: Handle concatenated JSON objects with field merging
-                structured_output = _parse_individual_json(cleaned_content, response_model)
+                structured_output = _parse_individual_json(cleaned_content, output_schema)
                 if structured_output is None:
                     logger.warning("All parsing attempts failed.")
 

agno/utils/team.py

@@ -0,0 +1,50 @@
+from typing import TYPE_CHECKING, Optional, Union
+
+from agno.agent import Agent
+from agno.utils.string import is_valid_uuid, url_safe_string
+
+if TYPE_CHECKING:
+    from agno.team.team import Team
+
+
+def format_member_agent_task(
+    task_description: str,
+    expected_output: Optional[str] = None,
+    team_member_interactions_str: Optional[str] = None,
+) -> str:
+    member_agent_task = "You are a member of a team of agents. Your goal is to complete the following task:"
+    member_agent_task += f"\n\n<task>\n{task_description}\n</task>"
+
+    if expected_output is not None:
+        member_agent_task += f"\n\n<expected_output>\n{expected_output}\n</expected_output>"
+
+    if team_member_interactions_str:
+        member_agent_task += f"\n\n{team_member_interactions_str}"
+
+    return member_agent_task
+
+
+def get_member_id(member: Union[Agent, "Team"]) -> str:
+    """
+    Get the ID of a member
+
+    If the member has an agent_id or team_id, use that if it is not a valid UUID.
+    Then if the member has a name, convert that to a URL safe string.
+    Then if the member has the default UUID ID, use that.
+    Otherwise, return None.
+    """
+    from agno.team.team import Team
+
+    if isinstance(member, Agent) and member.id is not None and (not is_valid_uuid(member.id)):
+        url_safe_member_id = url_safe_string(member.id)
+    elif isinstance(member, Team) and member.id is not None and (not is_valid_uuid(member.id)):
+        url_safe_member_id = url_safe_string(member.id)
+    elif member.name is not None:
+        url_safe_member_id = url_safe_string(member.name)
+    elif isinstance(member, Agent) and member.id is not None:
+        url_safe_member_id = member.id
+    elif isinstance(member, Team) and member.id is not None:
+        url_safe_member_id = member.id
+    else:
+        url_safe_member_id = None
+    return url_safe_member_id

agno/utils/timer.py

@@ -24,11 +24,11 @@ class Timer:
             self.elapsed_time = self.end_time - self.start_time
         return self.end_time
 
-    def __enter__(self):
+    def __enter__(self) -> "Timer":
         self.start_time = perf_counter()
         return self
 
-    def __exit__(self, *args):
+    def __exit__(self, *args) -> None:
         self.end_time = perf_counter()
         if self.start_time is not None:
             self.elapsed_time = self.end_time - self.start_time

agno/vectordb/base.py

@@ -1,7 +1,7 @@
 from abc import ABC, abstractmethod
 from typing import Any, Dict, List, Optional
 
-from agno.document import Document
+from agno.knowledge.document import Document
 
 
 class VectorDb(ABC):
@@ -16,41 +16,42 @@ class VectorDb(ABC):
         raise NotImplementedError
 
     @abstractmethod
-    def doc_exists(self, document: Document) -> bool:
+    def name_exists(self, name: str) -> bool:
         raise NotImplementedError
 
     @abstractmethod
-    async def async_doc_exists(self, document: Document) -> bool:
+    def async_name_exists(self, name: str) -> bool:
         raise NotImplementedError
 
     @abstractmethod
-    def name_exists(self, name: str) -> bool:
+    def id_exists(self, id: str) -> bool:
         raise NotImplementedError
 
     @abstractmethod
-    def async_name_exists(self, name: str) -> bool:
-        raise NotImplementedError
-
-    def id_exists(self, id: str) -> bool:
+    def content_hash_exists(self, content_hash: str) -> bool:
         raise NotImplementedError
 
     @abstractmethod
-    def insert(self, documents: List[Document], filters: Optional[Dict[str, Any]] = None) -> None:
+    def insert(self, content_hash: str, documents: List[Document], filters: Optional[Dict[str, Any]] = None) -> None:
         raise NotImplementedError
 
     @abstractmethod
-    async def async_insert(self, documents: List[Document], filters: Optional[Dict[str, Any]] = None) -> None:
+    async def async_insert(
+        self, content_hash: str, documents: List[Document], filters: Optional[Dict[str, Any]] = None
+    ) -> None:
         raise NotImplementedError
 
     def upsert_available(self) -> bool:
         return False
 
     @abstractmethod
-    def upsert(self, documents: List[Document], filters: Optional[Dict[str, Any]] = None) -> None:
+    def upsert(self, content_hash: str, documents: List[Document], filters: Optional[Dict[str, Any]] = None) -> None:
         raise NotImplementedError
 
     @abstractmethod
-    async def async_upsert(self, documents: List[Document], filters: Optional[Dict[str, Any]] = None) -> None:
+    async def async_upsert(
+        self, content_hash: str, documents: List[Document], filters: Optional[Dict[str, Any]] = None
+    ) -> None:
         raise NotImplementedError
 
     @abstractmethod
@@ -63,15 +64,6 @@ class VectorDb(ABC):
     ) -> List[Document]:
         raise NotImplementedError
 
-    def vector_search(self, query: str, limit: int = 5) -> List[Document]:
-        raise NotImplementedError
-
-    def keyword_search(self, query: str, limit: int = 5) -> List[Document]:
-        raise NotImplementedError
-
-    def hybrid_search(self, query: str, limit: int = 5) -> List[Document]:
-        raise NotImplementedError
-
     @abstractmethod
     def drop(self) -> None:
         raise NotImplementedError
@@ -94,3 +86,23 @@ class VectorDb(ABC):
     @abstractmethod
     def delete(self) -> bool:
         raise NotImplementedError
+
+    @abstractmethod
+    def delete_by_id(self, id: str) -> bool:
+        raise NotImplementedError
+
+    @abstractmethod
+    def delete_by_name(self, name: str) -> bool:
+        raise NotImplementedError
+
+    @abstractmethod
+    def delete_by_metadata(self, metadata: Dict[str, Any]) -> bool:
+        raise NotImplementedError
+
+    @abstractmethod
+    def update_metadata(self, content_id: str, metadata: Dict[str, Any]) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def delete_by_content_id(self, content_id: str) -> bool:
+        raise NotImplementedError