agno 1.7.6__py3-none-any.whl → 1.7.8__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
 
@@ -713,15 +721,6 @@ class Agent:
             if self.workflow_session_state is not None:
                 self.workflow_session_state["current_user_id"] = user_id
 
-    def _reset_session_state(self) -> None:
-        """Reset the session state for the agent."""
-        if self.team_session_state is not None:
-            self.team_session_state.pop("current_session_id", None)
-            self.team_session_state.pop("current_user_id", None)
-        if self.session_state is not None:
-            self.session_state.pop("current_session_id", None)
-            self.session_state.pop("current_user_id", None)
-
     def _initialize_session(
         self,
         session_id: Optional[str] = None,
@@ -800,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)
@@ -883,13 +884,33 @@ 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.utils.events import 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 event
+                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(
@@ -1162,8 +1183,6 @@ class Agent:
                     )
                 else:
                     return self.run_response
-            finally:
-                self._reset_session_state()
 
         # If we get here, all retries failed
         if last_exception is not None:
@@ -1219,6 +1238,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)
 
@@ -1300,13 +1322,36 @@ 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.utils.events import 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 event
+                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(
@@ -1540,8 +1585,6 @@ class Agent:
                     )
                 else:
                     return self.run_response
-            finally:
-                self._reset_session_state()
 
         # If we get here, all retries failed
         if last_exception is not None:
@@ -1797,8 +1840,6 @@ class Agent:
                     return self.create_run_response(
                         run_state=RunStatus.cancelled, content="Operation cancelled by user", run_response=run_response
                     )
-            finally:
-                self._reset_session_state()
 
         # If we get here, all retries failed
         if last_exception is not None:
@@ -2196,8 +2237,6 @@ class Agent:
                     return self.create_run_response(
                         run_state=RunStatus.cancelled, content="Operation cancelled by user", run_response=run_response
                     )
-            finally:
-                self._reset_session_state()
 
         # If we get here, all retries failed
         if last_exception is not None:
@@ -3172,6 +3211,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 ""
@@ -3197,6 +3242,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
                 ):
@@ -3205,6 +3251,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,
                         ),
@@ -5051,6 +5098,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:
@@ -5299,6 +5364,8 @@ class Agent:
         """
         from agno.document import Document
 
+        if num_documents is None and self.knowledge is not None:
+            num_documents = self.knowledge.num_documents
         # Validate the filters against known valid filter keys
         if self.knowledge is not None:
             valid_filters, invalid_keys = self.knowledge.validate_filters(filters)  # type: ignore
@@ -5338,9 +5405,6 @@ class Agent:
             ):
                 return None
 
-            if num_documents is None:
-                num_documents = self.knowledge.num_documents
-
             log_debug(f"Searching knowledge base with filters: {filters}")
             relevant_docs: List[Document] = self.knowledge.search(
                 query=query, num_documents=num_documents, filters=filters
@@ -5361,6 +5425,9 @@ class Agent:
         """Get relevant documents from knowledge base asynchronously."""
         from agno.document import Document
 
+        if num_documents is None and self.knowledge is not None:
+            num_documents = self.knowledge.num_documents
+
         # Validate the filters against known valid filter keys
         if self.knowledge is not None:
             valid_filters, invalid_keys = self.knowledge.validate_filters(filters)  # type: ignore
@@ -5404,9 +5471,6 @@ class Agent:
             ):
                 return None
 
-            if num_documents is None:
-                num_documents = self.knowledge.num_documents
-
             log_debug(f"Searching knowledge base with filters: {filters}")
             relevant_docs: List[Document] = await self.knowledge.async_search(
                 query=query, num_documents=num_documents, filters=filters
@@ -6372,6 +6436,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 []
@@ -6893,6 +7050,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] = []
 
@@ -6959,6 +7117,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
@@ -7030,6 +7190,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
@@ -7342,6 +7514,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] = ""
 
@@ -7409,6 +7582,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")
@@ -7482,6 +7657,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

agno/app/playground/app.py

@@ -1,5 +1,5 @@
 from os import getenv
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Callable, Dict, List, Optional, Union
 from urllib.parse import quote
 from uuid import uuid4
 
@@ -110,13 +110,14 @@ class Playground:
     def get_async_router(self) -> APIRouter:
         return get_async_playground_router(self.agents, self.workflows, self.teams, self.app_id)
 
-    def get_app(self, use_async: bool = True, prefix: str = "/v1") -> FastAPI:
+    def get_app(self, use_async: bool = True, prefix: str = "/v1", lifespan: Optional[Callable] = None) -> FastAPI:
         if not self.api_app:
             self.api_app = FastAPI(
                 title=self.settings.title,
                 docs_url="/docs" if self.settings.docs_enabled else None,
                 redoc_url="/redoc" if self.settings.docs_enabled else None,
                 openapi_url="/openapi.json" if self.settings.docs_enabled else None,
+                lifespan=lifespan,
             )
 
         if not self.api_app:

agno/document/reader/youtube_reader.py

@@ -3,7 +3,7 @@ from typing import List
 
 from agno.document.base import Document
 from agno.document.reader.base import Reader
-from agno.utils.log import log_info, logger
+from agno.utils.log import log_debug, log_info, logger
 
 try:
     from youtube_transcript_api import YouTubeTranscriptApi
@@ -23,12 +23,16 @@ class YouTubeReader(Reader):
             log_info(f"Reading transcript for video: {video_id}")
 
             # Get transcript
-            transcript_list = YouTubeTranscriptApi.get_transcript(video_id)
+            log_debug(f"Fetching transcript for video: {video_id}")
+            # Create an instance of YouTubeTranscriptApi
+            ytt_api = YouTubeTranscriptApi()
+            transcript_data = ytt_api.fetch(video_id)
 
             # Combine transcript segments into full text
             transcript_text = ""
-            for segment in transcript_list:
-                transcript_text += f"{segment['text']} "
+
+            for segment in transcript_data:
+                transcript_text += f"{segment.text} "
 
             documents = [
                 Document(

agno/embedder/openai.py

@@ -16,7 +16,7 @@ except ImportError:
 @dataclass
 class OpenAIEmbedder(Embedder):
     id: str = "text-embedding-3-small"
-    dimensions: int = 1536
+    dimensions: Optional[int] = None
     encoding_format: Literal["float", "base64"] = "float"
     user: Optional[str] = None
     api_key: Optional[str] = None
@@ -26,6 +26,10 @@ class OpenAIEmbedder(Embedder):
     client_params: Optional[Dict[str, Any]] = None
     openai_client: Optional[OpenAIClient] = None
 
+    def __post_init__(self):
+        if self.dimensions is None:
+            self.dimensions = 3072 if self.id == "text-embedding-3-large" else 1536
+
     @property
     def client(self) -> OpenAIClient:
         if self.openai_client:

agno/models/anthropic/claude.py

@@ -449,7 +449,7 @@ class Claude(Model):
 
     def get_system_message_for_model(self, tools: Optional[List[Any]] = None) -> Optional[str]:
         if tools is not None and len(tools) > 0:
-            tool_call_prompt = "Do not reflect on the quality of the returned search results in your response"
+            tool_call_prompt = "Do not reflect on the quality of the returned search results in your response\n\n"
             return tool_call_prompt
         return None
 
@@ -570,8 +570,16 @@ class Claude(Model):
                 }
 
         elif isinstance(response, ContentBlockStopEvent):
+            # Handle completed thinking content
+            if response.content_block.type == "thinking":  # type: ignore
+                model_response.thinking = response.content_block.thinking  # type: ignore
+                # Store signature if available
+                if hasattr(response.content_block, "signature"):  # type: ignore
+                    model_response.provider_data = {
+                        "signature": response.content_block.signature,  # type: ignore
+                    }
             # Handle tool calls
-            if response.content_block.type == "tool_use":  # type: ignore
+            elif response.content_block.type == "tool_use":  # type: ignore
                 tool_use = response.content_block  # type: ignore
                 tool_name = tool_use.name
                 tool_input = tool_use.input

agno/models/base.py

@@ -1025,6 +1025,10 @@ class Model(ABC):
             stream_data.response_thinking += model_response_delta.thinking
             should_yield = True
 
+        if model_response_delta.reasoning_content is not None:
+            stream_data.response_thinking += model_response_delta.reasoning_content
+            should_yield = True
+
         if model_response_delta.redacted_thinking is not None:
             stream_data.response_redacted_thinking += model_response_delta.redacted_thinking
             should_yield = True

agno/models/google/gemini.py

@@ -713,15 +713,29 @@ class Gemini(Model):
                     if isinstance(text_content, str):
                         # Check if this is a thought summary
                         if hasattr(part, "thought") and part.thought:
-                            model_response.reasoning_content = text_content
+                            # Add all parts as single message
+                            if model_response.reasoning_content is None:
+                                model_response.reasoning_content = text_content
+                            else:
+                                model_response.reasoning_content += text_content
                         else:
-                            model_response.content = text_content
+                            if model_response.content is None:
+                                model_response.content = text_content
+                            else:
+                                model_response.content += text_content
                     else:
                         content_str = str(text_content) if text_content is not None else ""
                         if hasattr(part, "thought") and part.thought:
-                            model_response.reasoning_content = content_str
+                            # Add all parts as single message
+                            if model_response.reasoning_content is None:
+                                model_response.reasoning_content = content_str
+                            else:
+                                model_response.reasoning_content += content_str
                         else:
-                            model_response.content = content_str
+                            if model_response.content is None:
+                                model_response.content = content_str
+                            else:
+                                model_response.content += content_str
 
                 if hasattr(part, "inline_data") and part.inline_data is not None:
                     model_response.image = ImageArtifact(
@@ -803,9 +817,15 @@ class Gemini(Model):
                         text_content = str(part.text) if part.text is not None else ""
                         # Check if this is a thought summary
                         if hasattr(part, "thought") and part.thought:
-                            model_response.reasoning_content = text_content
+                            if model_response.reasoning_content is None:
+                                model_response.reasoning_content = text_content
+                            else:
+                                model_response.reasoning_content += text_content
                         else:
-                            model_response.content = text_content
+                            if model_response.content is None:
+                                model_response.content = text_content
+                            else:
+                                model_response.content += text_content
 
                     if hasattr(part, "inline_data") and part.inline_data is not None:
                         model_response.image = ImageArtifact(

agno/models/litellm/chat.py

@@ -9,6 +9,7 @@ from agno.models.base import Model
 from agno.models.message import Message
 from agno.models.response import ModelResponse
 from agno.utils.log import log_debug, log_error, log_warning
+from agno.utils.openai import _format_file_for_message, audio_to_message, images_to_message
 
 try:
     import litellm
@@ -73,6 +74,31 @@ class LiteLLM(Model):
         for m in messages:
             msg = {"role": m.role, "content": m.content if m.content is not None else ""}
 
+            # Handle media
+            if (m.images is not None and len(m.images) > 0) or (m.audio is not None and len(m.audio) > 0):
+                if isinstance(m.content, str):
+                    content_list = [{"type": "text", "text": m.content}]
+                    if m.images is not None:
+                        content_list.extend(images_to_message(images=m.images))
+                    if m.audio is not None:
+                        content_list.extend(audio_to_message(audio=m.audio))
+                    msg["content"] = content_list
+
+            if m.videos is not None and len(m.videos) > 0:
+                log_warning("Video input is currently unsupported by LLM providers.")
+
+            # Handle files
+            if m.files is not None:
+                if isinstance(msg["content"], str):
+                    content_list = [{"type": "text", "text": msg["content"]}]
+                else:
+                    content_list = msg["content"]
+                for file in m.files:
+                    file_part = _format_file_for_message(file)
+                    if file_part:
+                        content_list.append(file_part)
+                msg["content"] = content_list
+
             # Handle tool calls in assistant messages
             if m.role == "assistant" and m.tool_calls:
                 msg["tool_calls"] = [
@@ -95,12 +121,8 @@ class LiteLLM(Model):
                 if m.images is not None and len(m.images) > 0:
                     log_warning("Image input is currently unsupported.")
 
-                if m.files is not None and len(m.files) > 0:
-                    log_warning("File input is currently unsupported.")
-
                 if m.videos is not None and len(m.videos) > 0:
                     log_warning("Video input is currently unsupported.")
-
             formatted_messages.append(msg)
 
         return formatted_messages