agno 1.7.7__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
 
@@ -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,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(
@@ -1208,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)
 
@@ -1289,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(
@@ -3155,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 ""
@@ -3180,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
                 ):
@@ -3188,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,
                         ),
@@ -5034,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:
@@ -6354,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 []
@@ -6875,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] = []
 
@@ -6941,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
@@ -7012,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
@@ -7324,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] = ""
 
@@ -7391,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")
@@ -7464,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/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/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
 

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/message.py

@@ -338,8 +338,12 @@ class Message(BaseModel):
                             if isinstance(tool_call_arguments, dict)
                             else json.loads(tool_call_arguments)
                         )
-                        arguments = ", ".join(f"{k}: {v}" for k, v in tool_call_args.items())
-                        tool_calls_list.append(f"    Arguments: '{arguments}'")
+                        # Ensure tool_call_args is a dictionary before calling .items()
+                        if isinstance(tool_call_args, dict):
+                            arguments = ", ".join(f"{k}: {v}" for k, v in tool_call_args.items())
+                            tool_calls_list.append(f"    Arguments: '{arguments}'")
+                        else:
+                            tool_calls_list.append(f"    Arguments: '{tool_call_args}'")
                     except json.JSONDecodeError:
                         tool_calls_list.append("    Arguments: 'Invalid JSON format'")
             tool_calls_str = "\n".join(tool_calls_list)

agno/models/openai/chat.py

@@ -62,6 +62,7 @@ class OpenAIChat(Model):
     temperature: Optional[float] = None
     user: Optional[str] = None
     top_p: Optional[float] = None
+    service_tier: Optional[str] = None  # "auto" | "default" | "flex" | "priority", defaults to "auto" when not set
     extra_headers: Optional[Any] = None
     extra_query: Optional[Any] = None
     request_params: Optional[Dict[str, Any]] = None
@@ -175,6 +176,7 @@ class OpenAIChat(Model):
             "extra_headers": self.extra_headers,
             "extra_query": self.extra_query,
             "metadata": self.metadata,
+            "service_tier": self.service_tier,
         }
 
         # Handle response format - always use JSON schema approach
@@ -241,6 +243,7 @@ class OpenAIChat(Model):
                 "user": self.user,
                 "extra_headers": self.extra_headers,
                 "extra_query": self.extra_query,
+                "service_tier": self.service_tier,
             }
         )
         cleaned_dict = {k: v for k, v in model_dict.items() if v is not None}

agno/models/openai/responses.py

@@ -47,7 +47,7 @@ class OpenAIResponses(Model):
     top_p: Optional[float] = None
     truncation: Optional[Literal["auto", "disabled"]] = None
     user: Optional[str] = None
-
+    service_tier: Optional[Literal["auto", "default", "flex", "priority"]] = None
     request_params: Optional[Dict[str, Any]] = None
 
     # Client parameters
@@ -178,6 +178,7 @@ class OpenAIResponses(Model):
             "top_p": self.top_p,
             "truncation": self.truncation,
             "user": self.user,
+            "service_tier": self.service_tier,
         }
         # Set the response format
         if response_format is not None:
@@ -310,11 +311,11 @@ class OpenAIResponses(Model):
         formatted_tools = []
         if tools:
             for _tool in tools:
-                if _tool["type"] == "function":
-                    _tool_dict = _tool["function"]
+                if _tool.get("type") == "function":
+                    _tool_dict = _tool.get("function", {})
                     _tool_dict["type"] = "function"
-                    for prop in _tool_dict["parameters"]["properties"].values():
-                        if isinstance(prop["type"], list):
+                    for prop in _tool_dict.get("parameters", {}).get("properties", {}).values():
+                        if isinstance(prop.get("type", ""), list):
                             prop["type"] = prop["type"][0]
 
                     formatted_tools.append(_tool_dict)

agno/run/response.py

@@ -37,6 +37,9 @@ class RunEvent(str, Enum):
     parser_model_response_started = "ParserModelResponseStarted"
     parser_model_response_completed = "ParserModelResponseCompleted"
 
+    output_model_response_started = "OutputModelResponseStarted"
+    output_model_response_completed = "OutputModelResponseCompleted"
+
 
 @dataclass
 class BaseAgentRunResponseEvent(BaseRunResponseEvent):
@@ -47,10 +50,23 @@ class BaseAgentRunResponseEvent(BaseRunResponseEvent):
     run_id: Optional[str] = None
     session_id: Optional[str] = None
     team_session_id: Optional[str] = None
+    tools: Optional[List[ToolExecution]] = None
 
     # For backwards compatibility
     content: Optional[Any] = None
 
+    @property
+    def tools_requiring_confirmation(self):
+        return [t for t in self.tools if t.requires_confirmation] if self.tools else []
+
+    @property
+    def tools_requiring_user_input(self):
+        return [t for t in self.tools if t.requires_user_input] if self.tools else []
+
+    @property
+    def tools_awaiting_external_execution(self):
+        return [t for t in self.tools if t.external_execution_required] if self.tools else []
+
 
 @dataclass
 class RunResponseStartedEvent(BaseAgentRunResponseEvent):
@@ -69,6 +85,7 @@ class RunResponseContentEvent(BaseAgentRunResponseEvent):
     content: Optional[Any] = None
     content_type: str = "str"
     thinking: Optional[str] = None
+    reasoning_content: Optional[str] = None
     citations: Optional[Citations] = None
     response_audio: Optional[AudioResponse] = None  # Model audio response
     image: Optional[ImageArtifact] = None  # Image attached to the response
@@ -177,6 +194,16 @@ class ParserModelResponseCompletedEvent(BaseAgentRunResponseEvent):
     event: str = RunEvent.parser_model_response_completed.value
 
 
+@dataclass
+class OutputModelResponseStartedEvent(BaseAgentRunResponseEvent):
+    event: str = RunEvent.output_model_response_started.value
+
+
+@dataclass
+class OutputModelResponseCompletedEvent(BaseAgentRunResponseEvent):
+    event: str = RunEvent.output_model_response_completed.value
+
+
 RunResponseEvent = Union[
     RunResponseStartedEvent,
     RunResponseContentEvent,
@@ -194,6 +221,8 @@ RunResponseEvent = Union[
     ToolCallCompletedEvent,
     ParserModelResponseStartedEvent,
     ParserModelResponseCompletedEvent,
+    OutputModelResponseStartedEvent,
+    OutputModelResponseCompletedEvent,
 ]
 
 
@@ -215,6 +244,8 @@ RUN_EVENT_TYPE_REGISTRY = {
     RunEvent.tool_call_completed.value: ToolCallCompletedEvent,
     RunEvent.parser_model_response_started.value: ParserModelResponseStartedEvent,
     RunEvent.parser_model_response_completed.value: ParserModelResponseCompletedEvent,
+    RunEvent.output_model_response_started.value: OutputModelResponseStartedEvent,
+    RunEvent.output_model_response_completed.value: OutputModelResponseCompletedEvent,
 }
 
 

agno/run/team.py

@@ -34,6 +34,9 @@ class TeamRunEvent(str, Enum):
     parser_model_response_started = "TeamParserModelResponseStarted"
     parser_model_response_completed = "TeamParserModelResponseCompleted"
 
+    output_model_response_started = "TeamOutputModelResponseStarted"
+    output_model_response_completed = "TeamOutputModelResponseCompleted"
+
 
 @dataclass
 class BaseTeamRunResponseEvent(BaseRunResponseEvent):
@@ -175,6 +178,16 @@ class ParserModelResponseCompletedEvent(BaseTeamRunResponseEvent):
     event: str = TeamRunEvent.parser_model_response_completed.value
 
 
+@dataclass
+class OutputModelResponseStartedEvent(BaseTeamRunResponseEvent):
+    event: str = TeamRunEvent.output_model_response_started.value
+
+
+@dataclass
+class OutputModelResponseCompletedEvent(BaseTeamRunResponseEvent):
+    event: str = TeamRunEvent.output_model_response_completed.value
+
+
 TeamRunResponseEvent = Union[
     RunResponseStartedEvent,
     RunResponseContentEvent,
@@ -190,6 +203,8 @@ TeamRunResponseEvent = Union[
     ToolCallCompletedEvent,
     ParserModelResponseStartedEvent,
     ParserModelResponseCompletedEvent,
+    OutputModelResponseStartedEvent,
+    OutputModelResponseCompletedEvent,
 ]
 
 # Map event string to dataclass for team events
@@ -208,6 +223,8 @@ TEAM_RUN_EVENT_TYPE_REGISTRY = {
     TeamRunEvent.tool_call_completed.value: ToolCallCompletedEvent,
     TeamRunEvent.parser_model_response_started.value: ParserModelResponseStartedEvent,
     TeamRunEvent.parser_model_response_completed.value: ParserModelResponseCompletedEvent,
+    TeamRunEvent.output_model_response_started.value: OutputModelResponseStartedEvent,
+    TeamRunEvent.output_model_response_completed.value: OutputModelResponseCompletedEvent,
 }
 
 

agno/storage/gcs_json.py

@@ -222,7 +222,7 @@ class GCSJsonStorage(JsonStorage):
         try:
             data = session.to_dict()
             data["updated_at"] = int(time.time())
-            if "created_at" not in data:
+            if "created_at" not in data or data["created_at"] is None:
                 data["created_at"] = data["updated_at"]
             json_data = self.serialize(data)
             blob.upload_from_string(json_data, content_type="application/json")

agno/storage/json.py

@@ -206,8 +206,9 @@ class JsonStorage(Storage):
                 data = session.to_dict()
             else:
                 data = asdict(session)
+
             data["updated_at"] = int(time.time())
-            if "created_at" not in data:
+            if "created_at" not in data or data["created_at"] is None:
                 data["created_at"] = data["updated_at"]
 
             with open(self.dir_path / f"{session.session_id}.json", "w", encoding="utf-8") as f:

agno/storage/redis.py

@@ -294,7 +294,7 @@ class RedisStorage(Storage):
             else:
                 data = asdict(session)
             data["updated_at"] = int(time.time())
-            if "created_at" not in data:
+            if "created_at" not in data or data["created_at"] is None:
                 data["created_at"] = data["updated_at"]
 
             key = self._get_key(session.session_id)

agno/storage/yaml.py

@@ -213,7 +213,7 @@ class YamlStorage(Storage):
             else:
                 data = asdict(session)
             data["updated_at"] = int(time.time())
-            if "created_at" not in data:
+            if "created_at" not in data or data["created_at"] is None:
                 data["created_at"] = data["updated_at"]
             with open(self.dir_path / f"{session.session_id}.yaml", "w", encoding="utf-8") as f:
                 f.write(self.serialize(data))