agno 1.7.7__py3-none-any.whl → 1.7.9__py3-none-any.whl

agno/agent/agent.py

@@ -274,6 +274,10 @@ class Agent:
     parser_model: Optional[Model] = None
     # Provide a prompt for the parser model
     parser_model_prompt: Optional[str] = None
+    # Provide an output model to structure the response from the main model
+    output_model: Optional[Model] = None
+    # Provide a prompt for the output model
+    output_model_prompt: Optional[str] = None
     # If True, the response from the Model is converted into the response_model
     # Otherwise, the response is returned as a JSON string
     parse_response: bool = True
@@ -414,6 +418,8 @@ class Agent:
         parser_model_prompt: Optional[str] = None,
         response_model: Optional[Type[BaseModel]] = None,
         parse_response: bool = True,
+        output_model: Optional[Model] = None,
+        output_model_prompt: Optional[str] = None,
         structured_outputs: Optional[bool] = None,
         use_json_mode: bool = False,
         save_response_to_file: Optional[str] = None,
@@ -517,6 +523,8 @@ class Agent:
         self.parser_model_prompt = parser_model_prompt
         self.response_model = response_model
         self.parse_response = parse_response
+        self.output_model = output_model
+        self.output_model_prompt = output_model_prompt
 
         self.structured_outputs = structured_outputs
 
@@ -791,6 +799,8 @@ class Agent:
             tool_call_limit=self.tool_call_limit,
             response_format=response_format,
         )
+        # If an output model is provided, generate output using the output model
+        self._generate_response_with_output_model(model_response, run_messages)
 
         # If a parser model is provided, structure the response separately
         self._parse_response_with_parser_model(model_response, run_messages)
@@ -874,13 +884,36 @@ class Agent:
         index_of_last_user_message = len(run_messages.messages)
 
         # 2. Process model response
-        for event in self._handle_model_response_stream(
-            run_response=run_response,
-            run_messages=run_messages,
-            response_format=response_format,
-            stream_intermediate_steps=stream_intermediate_steps,
-        ):
-            yield event
+        if self.output_model is None:
+            for event in self._handle_model_response_stream(
+                run_response=run_response,
+                run_messages=run_messages,
+                response_format=response_format,
+                stream_intermediate_steps=stream_intermediate_steps,
+            ):
+                yield event
+        else:
+            from agno.run.response import IntermediateRunResponseContentEvent, RunResponseContentEvent
+
+            for event in self._handle_model_response_stream(
+                run_response=run_response,
+                run_messages=run_messages,
+                response_format=response_format,
+                stream_intermediate_steps=stream_intermediate_steps,
+            ):
+                if isinstance(event, RunResponseContentEvent):
+                    if stream_intermediate_steps:
+                        yield IntermediateRunResponseContentEvent(
+                            content=event.content,
+                            content_type=event.content_type,
+                        )
+                else:
+                    yield event
+
+            # If an output model is provided, generate output using the output model
+            yield from self._generate_response_with_output_model_stream(
+                run_response=run_response, run_messages=run_messages
+            )
 
         # If a parser model is provided, structure the response separately
         yield from self._parse_response_with_parser_model_stream(
@@ -1208,6 +1241,9 @@ class Agent:
             response_format=response_format,
         )
 
+        # If an output model is provided, generate output using the output model
+        await self._agenerate_response_with_output_model(model_response=model_response, run_messages=run_messages)
+
         # If a parser model is provided, structure the response separately
         await self._aparse_response_with_parser_model(model_response=model_response, run_messages=run_messages)
 
@@ -1289,13 +1325,39 @@ class Agent:
         index_of_last_user_message = len(run_messages.messages)
 
         # 2. Generate a response from the Model
-        async for event in self._ahandle_model_response_stream(
-            run_response=run_response,
-            run_messages=run_messages,
-            response_format=response_format,
-            stream_intermediate_steps=stream_intermediate_steps,
-        ):
-            yield event
+        if self.output_model is None:
+            async for event in self._ahandle_model_response_stream(
+                run_response=run_response,
+                run_messages=run_messages,
+                response_format=response_format,
+                stream_intermediate_steps=stream_intermediate_steps,
+            ):
+                yield event
+        else:
+            from agno.run.response import IntermediateRunResponseContentEvent, RunResponseContentEvent
+
+            async for event in self._ahandle_model_response_stream(
+                run_response=run_response,
+                run_messages=run_messages,
+                response_format=response_format,
+                stream_intermediate_steps=stream_intermediate_steps,
+            ):
+                if isinstance(event, RunResponseContentEvent):
+                    if stream_intermediate_steps:
+                        yield IntermediateRunResponseContentEvent(
+                            content=event.content,
+                            content_type=event.content_type,
+                        )
+                else:
+                    yield event
+
+            # If an output model is provided, generate output using the output model
+            async for event in self._agenerate_response_with_output_model_stream(
+                run_response=run_response,
+                run_messages=run_messages,
+                stream_intermediate_steps=stream_intermediate_steps,
+            ):
+                yield event
 
         # If a parser model is provided, structure the response separately
         async for event in self._aparse_response_with_parser_model_stream(
@@ -3155,6 +3217,12 @@ class Agent:
                     model_response.thinking = (model_response.thinking or "") + model_response_event.thinking
                     run_response.thinking = model_response.thinking
 
+                if model_response_event.reasoning_content is not None:
+                    model_response.reasoning_content = (
+                        model_response.reasoning_content or ""
+                    ) + model_response_event.reasoning_content
+                    run_response.reasoning_content = model_response.reasoning_content
+
                 if model_response_event.redacted_thinking is not None:
                     model_response.redacted_thinking = (
                         model_response.redacted_thinking or ""
@@ -3180,6 +3248,7 @@ class Agent:
                 elif (
                     model_response_event.content is not None
                     or model_response_event.thinking is not None
+                    or model_response_event.reasoning_content is not None
                     or model_response_event.redacted_thinking is not None
                     or model_response_event.citations is not None
                 ):
@@ -3188,6 +3257,7 @@ class Agent:
                             from_run_response=run_response,
                             content=model_response_event.content,
                             thinking=model_response_event.thinking,
+                            reasoning_content=model_response_event.reasoning_content,
                             redacted_thinking=model_response_event.redacted_thinking,
                             citations=model_response_event.citations,
                         ),
@@ -4909,9 +4979,26 @@ class Agent:
 
                 run_messages.messages += history_copy
 
-        # 4.Add user message to run_messages
+        # 4. Add messages to run_messages if provided
+        if messages is not None and len(messages) > 0:
+            for _m in messages:
+                if isinstance(_m, Message):
+                    run_messages.messages.append(_m)
+                    if run_messages.extra_messages is None:
+                        run_messages.extra_messages = []
+                    run_messages.extra_messages.append(_m)
+                elif isinstance(_m, dict):
+                    try:
+                        run_messages.messages.append(Message.model_validate(_m))
+                        if run_messages.extra_messages is None:
+                            run_messages.extra_messages = []
+                        run_messages.extra_messages.append(Message.model_validate(_m))
+                    except Exception as e:
+                        log_warning(f"Failed to validate message: {e}")
+
+        # 5. Add user message to run_messages
         user_message: Optional[Message] = None
-        # 4.1 Build user message if message is None, str or list
+        # 5.1 Build user message if message is None, str or list
         if message is None or isinstance(message, str) or isinstance(message, list):
             user_message = self.get_user_message(
                 message=message,
@@ -4922,16 +5009,16 @@ class Agent:
                 knowledge_filters=knowledge_filters,
                 **kwargs,
             )
-        # 4.2 If message is provided as a Message, use it directly
+        # 5.2 If message is provided as a Message, use it directly
         elif isinstance(message, Message):
             user_message = message
-        # 4.3 If message is provided as a dict, try to validate it as a Message
+        # 5.3 If message is provided as a dict, try to validate it as a Message
         elif isinstance(message, dict):
             try:
                 user_message = Message.model_validate(message)
             except Exception as e:
                 log_warning(f"Failed to validate message: {e}")
-        # 4.4 If message is provided as a BaseModel, convert it to a Message
+        # 5.4 If message is provided as a BaseModel, convert it to a Message
         elif isinstance(message, BaseModel):
             try:
                 # Create a user message with the BaseModel content
@@ -4944,23 +5031,6 @@ class Agent:
             run_messages.user_message = user_message
             run_messages.messages.append(user_message)
 
-        # 5. Add messages to run_messages if provided
-        if messages is not None and len(messages) > 0:
-            for _m in messages:
-                if isinstance(_m, Message):
-                    run_messages.messages.append(_m)
-                    if run_messages.extra_messages is None:
-                        run_messages.extra_messages = []
-                    run_messages.extra_messages.append(_m)
-                elif isinstance(_m, dict):
-                    try:
-                        run_messages.messages.append(Message.model_validate(_m))
-                        if run_messages.extra_messages is None:
-                            run_messages.extra_messages = []
-                        run_messages.extra_messages.append(Message.model_validate(_m))
-                    except Exception as e:
-                        log_warning(f"Failed to validate message: {e}")
-
         return run_messages
 
     def get_continue_run_messages(
@@ -5034,6 +5104,24 @@ class Agent:
             Message(role="user", content=run_response.content),
         ]
 
+    def get_messages_for_output_model(self, messages: List[Message]) -> List[Message]:
+        """Get the messages for the output model."""
+
+        if self.output_model_prompt is not None:
+            system_message_exists = False
+            for message in messages:
+                if message.role == "system":
+                    system_message_exists = True
+                    message.content = self.output_model_prompt
+                    break
+            if not system_message_exists:
+                messages.insert(0, Message(role="system", content=self.output_model_prompt))
+
+        # Remove the last assistant message from the messages list
+        messages.pop(-1)
+
+        return messages
+
     def get_session_summary(self, session_id: Optional[str] = None, user_id: Optional[str] = None):
         """Get the session summary for the given session ID and user ID."""
         if self.memory is None:
@@ -6354,6 +6442,99 @@ class Agent:
             else:
                 log_warning("A response model is required to parse the response with a parser model")
 
+    def _generate_response_with_output_model(self, model_response: ModelResponse, run_messages: RunMessages) -> None:
+        """Parse the model response using the output model."""
+        if self.output_model is None:
+            return
+
+        messages_for_output_model = self.get_messages_for_output_model(run_messages.messages)
+        output_model_response: ModelResponse = self.output_model.response(messages=messages_for_output_model)
+        model_response.content = output_model_response.content
+
+    def _generate_response_with_output_model_stream(
+        self, run_response: RunResponse, run_messages: RunMessages, stream_intermediate_steps: bool = False
+    ):
+        """Parse the model response using the output model."""
+        from agno.utils.events import (
+            create_output_model_response_completed_event,
+            create_output_model_response_started_event,
+        )
+
+        if self.output_model is None:
+            return
+
+        if stream_intermediate_steps:
+            yield self._handle_event(create_output_model_response_started_event(run_response), run_response)
+
+        messages_for_output_model = self.get_messages_for_output_model(run_messages.messages)
+
+        model_response = ModelResponse(content="")
+
+        for model_response_event in self.output_model.response_stream(messages=messages_for_output_model):
+            yield from self._handle_model_response_chunk(
+                run_response=run_response,
+                model_response=model_response,
+                model_response_event=model_response_event,
+            )
+
+        if stream_intermediate_steps:
+            yield self._handle_event(create_output_model_response_completed_event(run_response), run_response)
+
+        # Build a list of messages that should be added to the RunResponse
+        messages_for_run_response = [m for m in run_messages.messages if m.add_to_agent_memory]
+        # Update the RunResponse messages
+        run_response.messages = messages_for_run_response
+        # Update the RunResponse metrics
+        run_response.metrics = self.aggregate_metrics_from_messages(messages_for_run_response)
+
+    async def _agenerate_response_with_output_model(self, model_response: ModelResponse, run_messages: RunMessages):
+        """Parse the model response using the output model."""
+        if self.output_model is None:
+            return
+
+        messages_for_output_model = self.get_messages_for_output_model(run_messages.messages)
+        output_model_response: ModelResponse = await self.output_model.aresponse(messages=messages_for_output_model)
+        model_response.content = output_model_response.content
+
+    async def _agenerate_response_with_output_model_stream(
+        self, run_response: RunResponse, run_messages: RunMessages, stream_intermediate_steps: bool = False
+    ):
+        """Parse the model response using the output model."""
+        from agno.utils.events import (
+            create_output_model_response_completed_event,
+            create_output_model_response_started_event,
+        )
+
+        if self.output_model is None:
+            return
+
+        if stream_intermediate_steps:
+            yield self._handle_event(create_output_model_response_started_event(run_response), run_response)
+
+        messages_for_output_model = self.get_messages_for_output_model(run_messages.messages)
+
+        model_response = ModelResponse(content="")
+
+        model_response_stream = self.output_model.aresponse_stream(messages=messages_for_output_model)
+
+        async for model_response_event in model_response_stream:
+            for event in self._handle_model_response_chunk(
+                run_response=run_response,
+                model_response=model_response,
+                model_response_event=model_response_event,
+            ):
+                yield event
+
+        if stream_intermediate_steps:
+            yield self._handle_event(create_output_model_response_completed_event(run_response), run_response)
+
+        # Build a list of messages that should be added to the RunResponse
+        messages_for_run_response = [m for m in run_messages.messages if m.add_to_agent_memory]
+        # Update the RunResponse messages
+        run_response.messages = messages_for_run_response
+        # Update the RunResponse metrics
+        run_response.metrics = self.aggregate_metrics_from_messages(messages_for_run_response)
+
     def _handle_event(self, event: RunResponseEvent, run_response: RunResponse):
         # We only store events that are not run_response_content events
         events_to_skip = [event.value for event in self.events_to_skip] if self.events_to_skip else []
@@ -6875,6 +7056,7 @@ class Agent:
         if stream:
             _response_content: str = ""
             _response_thinking: str = ""
+            _response_reasoning_content: str = ""
             response_content_batch: Union[str, JSON, Markdown] = ""
             reasoning_steps: List[ReasoningStep] = []
 
@@ -6941,6 +7123,8 @@ class Agent:
                                         log_warning(f"Failed to convert response to JSON: {e}")
                             if hasattr(resp, "thinking") and resp.thinking is not None:
                                 _response_thinking += resp.thinking
+                            if hasattr(resp, "reasoning_content") and resp.reasoning_content is not None:
+                                _response_reasoning_content += resp.reasoning_content
                         if (
                             hasattr(resp, "extra_data")
                             and resp.extra_data is not None
@@ -7012,6 +7196,18 @@ class Agent:
                     if render:
                         live_log.update(Group(*panels))
 
+                    if len(_response_reasoning_content) > 0:
+                        render = True
+                        # Create panel for reasoning content
+                        reasoning_panel = create_panel(
+                            content=Text(_response_reasoning_content),
+                            title=f"Reasoning ({response_timer.elapsed:.1f}s)",
+                            border_style="green",
+                        )
+                        panels.append(reasoning_panel)
+                    if render:
+                        live_log.update(Group(*panels))
+
                     # Add tool calls panel if available
                     if (
                         self.show_tool_calls
@@ -7324,6 +7520,7 @@ class Agent:
         if stream:
             _response_content: str = ""
             _response_thinking: str = ""
+            _response_reasoning_content: str = ""
             reasoning_steps: List[ReasoningStep] = []
             response_content_batch: Union[str, JSON, Markdown] = ""
 
@@ -7391,6 +7588,8 @@ class Agent:
                                     log_warning(f"Failed to convert response to JSON: {e}")
                             if resp.thinking is not None:
                                 _response_thinking += resp.thinking
+                            if hasattr(resp, "reasoning_content") and resp.reasoning_content is not None:
+                                _response_reasoning_content += resp.reasoning_content
 
                         if (
                             hasattr(resp, "extra_data")
@@ -7464,6 +7663,18 @@ class Agent:
                     if render:
                         live_log.update(Group(*panels))
 
+                    if len(_response_reasoning_content) > 0:
+                        render = True
+                        # Create panel for reasoning content
+                        reasoning_panel = create_panel(
+                            content=Text(_response_reasoning_content),
+                            title=f"Reasoning ({response_timer.elapsed:.1f}s)",
+                            border_style="green",
+                        )
+                        panels.append(reasoning_panel)
+                    if render:
+                        live_log.update(Group(*panels))
+
                     # Add tool calls panel if available
                     if (
                         self.show_tool_calls