agno 1.8.2__py3-none-any.whl → 2.0.0__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