agno 1.8.1__py3-none-any.whl → 2.0.0__py3-none-any.whl

agno/models/message.py

@@ -1,13 +1,12 @@
 import json
-from dataclasses import asdict, dataclass
 from time import time
 from typing import Any, Dict, List, Optional, Sequence, Union
 
 from pydantic import BaseModel, ConfigDict, Field
 
-from agno.media import Audio, AudioResponse, File, Image, ImageArtifact, Video
+from agno.media import Audio, File, Image, Video
+from agno.models.metrics import Metrics
 from agno.utils.log import log_debug, log_error, log_info, log_warning
-from agno.utils.timer import Timer
 
 
 class MessageReferences(BaseModel):
@@ -49,118 +48,6 @@ class Citations(BaseModel):
     documents: Optional[List[DocumentCitation]] = None
 
 
-@dataclass
-class MessageMetrics:
-    input_tokens: int = 0
-    output_tokens: int = 0
-    total_tokens: int = 0
-
-    audio_tokens: int = 0
-    input_audio_tokens: int = 0
-    output_audio_tokens: int = 0
-    cached_tokens: int = 0
-    cache_write_tokens: int = 0
-    reasoning_tokens: int = 0
-    prompt_tokens: int = 0
-    completion_tokens: int = 0
-    prompt_tokens_details: Optional[dict] = None
-    completion_tokens_details: Optional[dict] = None
-
-    additional_metrics: Optional[dict] = None
-
-    time: Optional[float] = None
-    time_to_first_token: Optional[float] = None
-
-    timer: Optional[Timer] = None
-
-    def to_dict(self) -> Dict[str, Any]:
-        metrics_dict = asdict(self)
-        metrics_dict.pop("timer")
-        metrics_dict = {
-            k: v
-            for k, v in metrics_dict.items()
-            if v is not None and (not isinstance(v, (int, float)) or v != 0) and (not isinstance(v, dict) or len(v) > 0)
-        }
-        return metrics_dict
-
-    def start_timer(self):
-        if self.timer is None:
-            self.timer = Timer()
-        self.timer.start()
-
-    def stop_timer(self, set_time: bool = True):
-        if self.timer is not None:
-            self.timer.stop()
-            if set_time:
-                self.time = self.timer.elapsed
-
-    def set_time_to_first_token(self):
-        if self.timer is not None:
-            self.time_to_first_token = self.timer.elapsed
-
-    def __add__(self, other: "MessageMetrics") -> "MessageMetrics":
-        # Create new instance with summed basic metrics
-        result = MessageMetrics(
-            input_tokens=self.input_tokens + other.input_tokens,
-            output_tokens=self.output_tokens + other.output_tokens,
-            total_tokens=self.total_tokens + other.total_tokens,
-            prompt_tokens=self.prompt_tokens + other.prompt_tokens,
-            completion_tokens=self.completion_tokens + other.completion_tokens,
-            audio_tokens=self.audio_tokens + other.audio_tokens,
-            input_audio_tokens=self.input_audio_tokens + other.input_audio_tokens,
-            output_audio_tokens=self.output_audio_tokens + other.output_audio_tokens,
-            cached_tokens=self.cached_tokens + other.cached_tokens,
-            cache_write_tokens=self.cache_write_tokens + other.cache_write_tokens,
-            reasoning_tokens=self.reasoning_tokens + other.reasoning_tokens,
-        )
-
-        # Handle prompt_tokens_details
-        if self.prompt_tokens_details or other.prompt_tokens_details:
-            result.prompt_tokens_details = {}
-            # Merge from self
-            if self.prompt_tokens_details:
-                result.prompt_tokens_details.update(self.prompt_tokens_details)
-            # Add values from other
-            if other.prompt_tokens_details:
-                for key, value in other.prompt_tokens_details.items():
-                    result.prompt_tokens_details[key] = result.prompt_tokens_details.get(key, 0) + value
-
-        # Handle completion_tokens_details similarly
-        if self.completion_tokens_details or other.completion_tokens_details:
-            result.completion_tokens_details = {}
-            if self.completion_tokens_details:
-                result.completion_tokens_details.update(self.completion_tokens_details)
-            if other.completion_tokens_details:
-                for key, value in other.completion_tokens_details.items():
-                    result.completion_tokens_details[key] = result.completion_tokens_details.get(key, 0) + value
-
-        # Handle additional metrics
-        if self.additional_metrics or other.additional_metrics:
-            result.additional_metrics = {}
-            if self.additional_metrics:
-                result.additional_metrics.update(self.additional_metrics)
-            if other.additional_metrics:
-                result.additional_metrics.update(other.additional_metrics)
-
-        # Sum times if both exist
-        if self.time is not None and other.time is not None:
-            result.time = self.time + other.time
-        elif self.time is not None:
-            result.time = self.time
-        elif other.time is not None:
-            result.time = other.time
-
-        # Handle time_to_first_token (take the first non-None value)
-        result.time_to_first_token = self.time_to_first_token or other.time_to_first_token
-
-        return result
-
-    def __radd__(self, other: "MessageMetrics") -> "MessageMetrics":
-        if other == 0:  # Handle sum() starting value
-            return self
-        return self + other
-
-
 class Message(BaseModel):
     """Message sent to the Model"""
 
@@ -184,12 +71,12 @@ class Message(BaseModel):
     files: Optional[Sequence[File]] = None
 
     # Output from the models
-    audio_output: Optional[AudioResponse] = None
-    image_output: Optional[ImageArtifact] = None
+    audio_output: Optional[Audio] = None
+    image_output: Optional[Image] = None
+    video_output: Optional[Video] = None
 
     # The thinking content from the model
-    thinking: Optional[str] = None
-    redacted_thinking: Optional[str] = None
+    redacted_reasoning_content: Optional[str] = None
 
     # Data from the provider we might need on subsequent messages
     provider_data: Optional[Dict[str, Any]] = None
@@ -213,7 +100,7 @@ class Message(BaseModel):
     # This flag is enabled when a message is fetched from the agent's memory.
     from_history: bool = False
     # Metrics for the message.
-    metrics: MessageMetrics = Field(default_factory=MessageMetrics)
+    metrics: Metrics = Field(default_factory=Metrics)
     # The references added to the message for RAG
     references: Optional[MessageReferences] = None
     # The Unix timestamp the message was created.
@@ -232,6 +119,10 @@ class Message(BaseModel):
                 return json.dumps(self.content)
         return ""
 
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Message":
+        return cls(**data)
+
     def to_dict(self) -> Dict[str, Any]:
         """Returns the message as a dictionary."""
         message_dict = {
@@ -246,8 +137,7 @@ class Message(BaseModel):
             "tool_args": self.tool_args,
             "tool_call_error": self.tool_call_error,
             "tool_calls": self.tool_calls,
-            "thinking": self.thinking,
-            "redacted_thinking": self.redacted_thinking,
+            "redacted_reasoning_content": self.redacted_reasoning_content,
             "provider_data": self.provider_data,
         }
         # Filter out None and empty collections
@@ -316,8 +206,8 @@ class Message(BaseModel):
             _logger(f"Name: {self.name}")
         if self.tool_call_id:
             _logger(f"Tool call Id: {self.tool_call_id}")
-        if self.thinking:
-            _logger(f"<thinking>\n{self.thinking}\n</thinking>")
+        if self.reasoning_content:
+            _logger(f"<reasoning>\n{self.reasoning_content}\n</reasoning>")
         if self.content:
             if isinstance(self.content, str) or isinstance(self.content, list):
                 _logger(self.content)
@@ -338,12 +228,13 @@ class Message(BaseModel):
                             if isinstance(tool_call_arguments, dict)
                             else json.loads(tool_call_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}'")
+                        if tool_call_args:
+                            # 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)
@@ -359,42 +250,46 @@ class Message(BaseModel):
             _logger(f"Files added: {len(self.files)}")
 
         metrics_header = " TOOL METRICS " if self.role == "tool" else " METRICS "
-        if metrics and self.metrics is not None and self.metrics != MessageMetrics():
+        if metrics and self.metrics is not None and self.metrics != Metrics():
             _logger(metrics_header, center=True, symbol="*")
 
-            # Combine token metrics into a single line
+            # Token metrics
             token_metrics = []
-            if self.metrics.input_tokens:
+            if self.metrics.input_tokens and self.metrics.input_tokens > 0:
                 token_metrics.append(f"input={self.metrics.input_tokens}")
-            if self.metrics.output_tokens:
+            if self.metrics.output_tokens and self.metrics.output_tokens > 0:
                 token_metrics.append(f"output={self.metrics.output_tokens}")
-            if self.metrics.total_tokens:
+            if self.metrics.total_tokens and self.metrics.total_tokens > 0:
                 token_metrics.append(f"total={self.metrics.total_tokens}")
-            if self.metrics.cached_tokens:
-                token_metrics.append(f"cached={self.metrics.cached_tokens}")
-            if self.metrics.cache_write_tokens:
+            if self.metrics.cache_read_tokens and self.metrics.cache_read_tokens > 0:
+                token_metrics.append(f"cached={self.metrics.cache_read_tokens}")
+            if self.metrics.cache_write_tokens and self.metrics.cache_write_tokens > 0:
                 token_metrics.append(f"cache_write_tokens={self.metrics.cache_write_tokens}")
-            if self.metrics.reasoning_tokens:
+            if self.metrics.reasoning_tokens and self.metrics.reasoning_tokens > 0:
                 token_metrics.append(f"reasoning={self.metrics.reasoning_tokens}")
-            if self.metrics.audio_tokens:
-                token_metrics.append(f"audio={self.metrics.audio_tokens}")
+            if self.metrics.audio_total_tokens and self.metrics.audio_total_tokens > 0:
+                token_metrics.append(f"audio={self.metrics.audio_total_tokens}")
             if token_metrics:
                 _logger(f"* Tokens:                      {', '.join(token_metrics)}")
-            if self.metrics.prompt_tokens_details:
-                _logger(f"* Prompt tokens details:       {self.metrics.prompt_tokens_details}")
-            if self.metrics.completion_tokens_details:
-                _logger(f"* Completion tokens details:   {self.metrics.completion_tokens_details}")
-            if self.metrics.time is not None:
-                _logger(f"* Time:                        {self.metrics.time:.4f}s")
-            if self.metrics.output_tokens and self.metrics.time:
-                _logger(f"* Tokens per second:           {self.metrics.output_tokens / self.metrics.time:.4f} tokens/s")
-            if self.metrics.time_to_first_token is not None:
+
+            # Time related metrics
+            if self.metrics.duration is not None and self.metrics.duration > 0:
+                _logger(f"* Duration:                    {self.metrics.duration:.4f}s")
+            if self.metrics.output_tokens and self.metrics.duration and self.metrics.duration > 0:
+                _logger(
+                    f"* Tokens per second:           {self.metrics.output_tokens / self.metrics.duration:.4f} tokens/s"
+                )
+            if self.metrics.time_to_first_token is not None and self.metrics.time_to_first_token > 0:
                 _logger(f"* Time to first token:         {self.metrics.time_to_first_token:.4f}s")
+
+            # Non-generic metrics
+            if self.metrics.provider_metrics:
+                _logger(f"* Provider metrics:            {self.metrics.provider_metrics}")
             if self.metrics.additional_metrics:
                 _logger(f"* Additional metrics:          {self.metrics.additional_metrics}")
+
             _logger(metrics_header, center=True, symbol="*")
 
     def content_is_valid(self) -> bool:
         """Check if the message content is valid."""
-
         return self.content is not None and len(self.content) > 0

agno/models/meta/llama.py

@@ -9,18 +9,21 @@ from pydantic import BaseModel
 from agno.exceptions import ModelProviderError
 from agno.models.base import Model
 from agno.models.message import Message
+from agno.models.metrics import Metrics
 from agno.models.response import ModelResponse
+from agno.run.agent import RunOutput
 from agno.utils.log import log_debug, log_error, log_warning
 from agno.utils.models.llama import format_message
 
 try:
     from llama_api_client import AsyncLlamaAPIClient, LlamaAPIClient
-    from llama_api_client.types.create_chat_completion_response import CreateChatCompletionResponse
+    from llama_api_client.types.create_chat_completion_response import CreateChatCompletionResponse, Metric
     from llama_api_client.types.create_chat_completion_response_stream_chunk import (
         CreateChatCompletionResponseStreamChunk,
         EventDeltaTextDelta,
         EventDeltaToolCallDelta,
         EventDeltaToolCallDeltaFunction,
+        EventMetric,
     )
     from llama_api_client.types.message_text_content_item import MessageTextContentItem
 except ImportError:
@@ -192,54 +195,84 @@ class Llama(Model):
     def invoke(
         self,
         messages: List[Message],
+        assistant_message: Message,
         response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
         tools: Optional[List[Dict[str, Any]]] = None,
         tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
-    ) -> CreateChatCompletionResponse:
+        run_response: Optional[RunOutput] = None,
+    ) -> ModelResponse:
         """
         Send a chat completion request to the Llama API.
         """
-        return self.get_client().chat.completions.create(
+        assistant_message.metrics.start_timer()
+
+        provider_response = self.get_client().chat.completions.create(
             model=self.id,
             messages=[format_message(m, tool_calls=bool(tools)) for m in messages],  # type: ignore
             **self.get_request_params(tools=tools, response_format=response_format),
         )
 
+        assistant_message.metrics.stop_timer()
+
+        model_response = self._parse_provider_response(provider_response, response_format=response_format)
+        return model_response
+
     async def ainvoke(
         self,
         messages: List[Message],
+        assistant_message: Message,
         response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
         tools: Optional[List[Dict[str, Any]]] = None,
         tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
-    ) -> CreateChatCompletionResponse:
+        run_response: Optional[RunOutput] = None,
+    ) -> ModelResponse:
         """
         Sends an asynchronous chat completion request to the Llama API.
         """
+        if run_response and run_response.metrics:
+            run_response.metrics.set_time_to_first_token()
 
-        return await self.get_async_client().chat.completions.create(
+        assistant_message.metrics.start_timer()
+
+        provider_response = await self.get_async_client().chat.completions.create(
             model=self.id,
             messages=[format_message(m, tool_calls=bool(tools)) for m in messages],  # type: ignore
             **self.get_request_params(tools=tools, response_format=response_format),
         )
 
+        assistant_message.metrics.stop_timer()
+
+        model_response = self._parse_provider_response(provider_response, response_format=response_format)
+        return model_response
+
     def invoke_stream(
         self,
         messages: List[Message],
+        assistant_message: Message,
         response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
         tools: Optional[List[Dict[str, Any]]] = None,
         tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
-    ) -> Iterator[CreateChatCompletionResponseStreamChunk]:
+        run_response: Optional[RunOutput] = None,
+    ) -> Iterator[ModelResponse]:
         """
         Send a streaming chat completion request to the Llama API.
         """
+        if run_response and run_response.metrics:
+            run_response.metrics.set_time_to_first_token()
 
         try:
-            yield from self.get_client().chat.completions.create(
+            assistant_message.metrics.start_timer()
+
+            for chunk in self.get_client().chat.completions.create(
                 model=self.id,
                 messages=[format_message(m, tool_calls=bool(tools)) for m in messages],  # type: ignore
                 stream=True,
                 **self.get_request_params(tools=tools, response_format=response_format),
-            )  # type: ignore
+            ):
+                yield self._parse_provider_response_delta(chunk)  # type: ignore
+
+            assistant_message.metrics.stop_timer()
+
         except Exception as e:
             log_error(f"Error from Llama API: {e}")
             raise ModelProviderError(message=str(e), model_name=self.name, model_id=self.id) from e
@@ -247,29 +280,36 @@ class Llama(Model):
     async def ainvoke_stream(
         self,
         messages: List[Message],
+        assistant_message: Message,
         response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
         tools: Optional[List[Dict[str, Any]]] = None,
         tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
-    ) -> AsyncIterator[CreateChatCompletionResponseStreamChunk]:
+        run_response: Optional[RunOutput] = None,
+    ) -> AsyncIterator[ModelResponse]:
         """
         Sends an asynchronous streaming chat completion request to the Llama API.
         """
+        if run_response and run_response.metrics:
+            run_response.metrics.set_time_to_first_token()
+
+        assistant_message.metrics.start_timer()
 
         try:
-            async_stream = await self.get_async_client().chat.completions.create(
+            async for chunk in await self.get_async_client().chat.completions.create(
                 model=self.id,
                 messages=[format_message(m, tool_calls=bool(tools)) for m in messages],  # type: ignore
                 stream=True,
                 **self.get_request_params(tools=tools, response_format=response_format),
-            )
-            async for chunk in async_stream:  # type: ignore
-                yield chunk  # type: ignore
+            ):
+                yield self._parse_provider_response_delta(chunk)  # type: ignore
+
+            assistant_message.metrics.stop_timer()
+
         except Exception as e:
             log_error(f"Error from Llama API: {e}")
             raise ModelProviderError(message=str(e), model_name=self.name, model_id=self.id) from e
 
-    @staticmethod
-    def parse_tool_calls(tool_calls_data: List[EventDeltaToolCallDeltaFunction]) -> List[Dict[str, Any]]:
+    def parse_tool_calls(self, tool_calls_data: List[EventDeltaToolCallDeltaFunction]) -> List[Dict[str, Any]]:
         """
         Parse the tool calls from the Llama API.
 
@@ -321,7 +361,7 @@ class Llama(Model):
 
         return tool_calls
 
-    def parse_provider_response(self, response: CreateChatCompletionResponse, **kwargs) -> ModelResponse:
+    def _parse_provider_response(self, response: CreateChatCompletionResponse, **kwargs) -> ModelResponse:
         """
         Parse the Llama response into a ModelResponse.
 
@@ -371,26 +411,12 @@ class Llama(Model):
 
         # Add metrics from the metrics list
         if hasattr(response, "metrics") and response.metrics is not None:
-            usage_data = {}
-            metric_map = {
-                "num_prompt_tokens": "input_tokens",
-                "num_completion_tokens": "output_tokens",
-                "num_total_tokens": "total_tokens",
-            }
-
-            for metric in response.metrics:
-                key = metric_map.get(metric.metric)
-                if key:
-                    value = int(metric.value)
-                    usage_data[key] = value
-
-                if usage_data:
-                    model_response.response_usage = usage_data
+            model_response.response_usage = self._get_metrics(response.metrics)
 
         return model_response
 
-    def parse_provider_response_delta(
-        self, response_delta: CreateChatCompletionResponseStreamChunk, **kwargs
+    def _parse_provider_response_delta(
+        self, response: CreateChatCompletionResponseStreamChunk, **kwargs
     ) -> ModelResponse:
         """
         Parse the Llama streaming response into a ModelResponse.
@@ -403,25 +429,12 @@ class Llama(Model):
         """
         model_response = ModelResponse()
 
-        if response_delta is not None:
-            delta = response_delta.event
+        if response is not None:
+            delta = response.event
 
             # Capture metrics event
             if delta.event_type == "metrics" and delta.metrics is not None:
-                usage_data = {}
-                metric_map = {
-                    "num_prompt_tokens": "input_tokens",
-                    "num_completion_tokens": "output_tokens",
-                    "num_total_tokens": "total_tokens",
-                }
-
-                for metric in delta.metrics:
-                    key = metric_map.get(metric.metric)
-                    if key:
-                        usage_data[key] = int(metric.value)
-
-                if usage_data:
-                    model_response.response_usage = usage_data
+                model_response.response_usage = self._get_metrics(delta.metrics)
 
             if isinstance(delta.delta, EventDeltaTextDelta):
                 model_response.content = delta.delta.text
@@ -431,3 +444,26 @@ class Llama(Model):
                 model_response.tool_calls = delta.delta  # type: ignore
 
         return model_response
+
+    def _get_metrics(self, response_usage: Union[List[Metric], List[EventMetric]]) -> Metrics:
+        """
+        Parse the given Llama usage into an Agno Metrics object.
+
+        Args:
+            response_usage: Usage data from Llama
+
+        Returns:
+            Metrics: Parsed metrics data
+        """
+        metrics = Metrics()
+
+        for metric in response_usage:
+            metrics_field = metric.metric
+            if metrics_field == "num_prompt_tokens":
+                metrics.input_tokens = int(metric.value)
+            elif metrics_field == "num_completion_tokens":
+                metrics.output_tokens = int(metric.value)
+
+        metrics.total_tokens = metrics.input_tokens + metrics.output_tokens
+
+        return metrics

agno/models/metrics.py

@@ -0,0 +1,120 @@
+from dataclasses import asdict, dataclass
+from typing import Any, Dict, Optional
+
+from agno.utils.timer import Timer
+
+
+@dataclass
+class Metrics:
+    """All relevant metrics for a session, run or message."""
+
+    # Main token consumption values
+    input_tokens: int = 0
+    output_tokens: int = 0
+    total_tokens: int = 0
+
+    # Audio token usage
+    audio_input_tokens: int = 0
+    audio_output_tokens: int = 0
+    audio_total_tokens: int = 0
+
+    # Cache token usage
+    cache_read_tokens: int = 0
+    cache_write_tokens: int = 0
+
+    # Tokens employed in reasoning
+    reasoning_tokens: int = 0
+
+    # Time metrics
+    # Internal timer utility for tracking execution time
+    timer: Optional[Timer] = None
+    # Time from run start to first token generation, in seconds
+    time_to_first_token: Optional[float] = None
+    # Total run time, in seconds
+    duration: Optional[float] = None
+
+    # Provider-specific metrics
+    provider_metrics: Optional[dict] = None
+
+    # Any additional metrics
+    additional_metrics: Optional[dict] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        metrics_dict = asdict(self)
+        # Remove the timer util if present
+        metrics_dict.pop("timer", None)
+        metrics_dict = {
+            k: v
+            for k, v in metrics_dict.items()
+            if v is not None and (not isinstance(v, (int, float)) or v != 0) and (not isinstance(v, dict) or len(v) > 0)
+        }
+        return metrics_dict
+
+    def __add__(self, other: "Metrics") -> "Metrics":
+        # Create new instance of the same type as self
+        result_class = type(self)
+        result = result_class(
+            input_tokens=self.input_tokens + other.input_tokens,
+            output_tokens=self.output_tokens + other.output_tokens,
+            total_tokens=self.total_tokens + other.total_tokens,
+            audio_total_tokens=self.audio_total_tokens + other.audio_total_tokens,
+            audio_input_tokens=self.audio_input_tokens + other.audio_input_tokens,
+            audio_output_tokens=self.audio_output_tokens + other.audio_output_tokens,
+            cache_read_tokens=self.cache_read_tokens + other.cache_read_tokens,
+            cache_write_tokens=self.cache_write_tokens + other.cache_write_tokens,
+            reasoning_tokens=self.reasoning_tokens + other.reasoning_tokens,
+        )
+
+        # Handle provider_metrics
+        if self.provider_metrics or other.provider_metrics:
+            result.provider_metrics = {}
+            if self.provider_metrics:
+                result.provider_metrics.update(self.provider_metrics)
+            if other.provider_metrics:
+                result.provider_metrics.update(other.provider_metrics)
+
+        # Handle additional metrics
+        if self.additional_metrics or other.additional_metrics:
+            result.additional_metrics = {}
+            if self.additional_metrics:
+                result.additional_metrics.update(self.additional_metrics)
+            if other.additional_metrics:
+                result.additional_metrics.update(other.additional_metrics)
+
+        # Sum durations if both exist
+        if self.duration is not None and other.duration is not None:
+            result.duration = self.duration + other.duration
+        elif self.duration is not None:
+            result.duration = self.duration
+        elif other.duration is not None:
+            result.duration = other.duration
+
+        # Sum time to first token if both exist
+        if self.time_to_first_token is not None and other.time_to_first_token is not None:
+            result.time_to_first_token = self.time_to_first_token + other.time_to_first_token
+        elif self.time_to_first_token is not None:
+            result.time_to_first_token = self.time_to_first_token
+        elif other.time_to_first_token is not None:
+            result.time_to_first_token = other.time_to_first_token
+
+        return result
+
+    def __radd__(self, other: "Metrics") -> "Metrics":
+        if other == 0:  # Handle sum() starting value
+            return self
+        return self + other
+
+    def start_timer(self):
+        if self.timer is None:
+            self.timer = Timer()
+        self.timer.start()
+
+    def stop_timer(self, set_duration: bool = True):
+        if self.timer is not None:
+            self.timer.stop()
+            if set_duration:
+                self.duration = self.timer.elapsed
+
+    def set_time_to_first_token(self):
+        if self.timer is not None:
+            self.time_to_first_token = self.timer.elapsed