agno 1.7.4__py3-none-any.whl → 1.7.6__py3-none-any.whl

agno/document/chunking/row.py

@@ -0,0 +1,39 @@
+from typing import List
+
+from agno.document.base import Document
+from agno.document.chunking.strategy import ChunkingStrategy
+
+
+class RowChunking(ChunkingStrategy):
+    def __init__(self, skip_header: bool = False, clean_rows: bool = True):
+        self.skip_header = skip_header
+        self.clean_rows = clean_rows
+
+    def chunk(self, document: Document) -> List[Document]:
+        if not document or not document.content:
+            return []
+
+        if not isinstance(document.content, str):
+            raise ValueError("Document content must be a string")
+
+        rows = document.content.splitlines()
+
+        if self.skip_header and rows:
+            rows = rows[1:]
+            start_index = 2
+        else:
+            start_index = 1
+
+        chunks = []
+        for i, row in enumerate(rows):
+            if self.clean_rows:
+                chunk_content = " ".join(row.split())  # Normalize internal whitespace
+            else:
+                chunk_content = row.strip()
+
+            if chunk_content:  # Skip empty rows
+                meta_data = document.meta_data.copy()
+                meta_data["row_number"] = start_index + i  # Preserve logical row numbering
+                chunk_id = f"{document.id}_row_{start_index + i}" if document.id else None
+                chunks.append(Document(id=chunk_id, name=document.name, meta_data=meta_data, content=chunk_content))
+        return chunks

agno/document/reader/base.py

@@ -16,13 +16,6 @@ class Reader:
     separators: List[str] = field(default_factory=lambda: ["\n", "\n\n", "\r", "\r\n", "\n\r", "\t", " ", "  "])
     chunking_strategy: Optional[ChunkingStrategy] = None
 
-    def __init__(
-        self, chunk: bool = True, chunk_size: int = 5000, chunking_strategy: Optional[ChunkingStrategy] = None
-    ) -> None:
-        self.chunk = chunk
-        self.chunk_size = chunk_size
-        self.chunking_strategy = chunking_strategy
-
     def read(self, obj: Any) -> List[Document]:
         raise NotImplementedError
 

agno/embedder/jina.py

@@ -0,0 +1,73 @@
+from dataclasses import dataclass
+from os import getenv
+from typing import Any, Dict, List, Optional, Tuple
+
+from typing_extensions import Literal
+
+from agno.embedder.base import Embedder
+from agno.utils.log import logger
+
+try:
+    import requests
+except ImportError:
+    raise ImportError("requests not installed, use pip install requests")
+
+
+@dataclass
+class JinaEmbedder(Embedder):
+    id: str = "jina-embeddings-v3"
+    dimensions: int = 1024
+    embedding_type: Literal["float", "base64", "int8"] = "float"
+    late_chunking: bool = False
+    user: Optional[str] = None
+    api_key: Optional[str] = getenv("JINA_API_KEY")
+    base_url: str = "https://api.jina.ai/v1/embeddings"
+    headers: Optional[Dict[str, str]] = None
+    request_params: Optional[Dict[str, Any]] = None
+    timeout: Optional[float] = None
+
+    def _get_headers(self) -> Dict[str, str]:
+        if not self.api_key:
+            raise ValueError(
+                "API key is required for Jina embedder. Set JINA_API_KEY environment variable or pass api_key parameter."
+            )
+
+        headers = {"Content-Type": "application/json", "Authorization": f"Bearer {self.api_key}"}
+        if self.headers:
+            headers.update(self.headers)
+        return headers
+
+    def _response(self, text: str) -> Dict[str, Any]:
+        data = {
+            "model": self.id,
+            "late_chunking": self.late_chunking,
+            "dimensions": self.dimensions,
+            "embedding_type": self.embedding_type,
+            "input": [text],  # Jina API expects a list
+        }
+        if self.user is not None:
+            data["user"] = self.user
+        if self.request_params:
+            data.update(self.request_params)
+
+        response = requests.post(self.base_url, headers=self._get_headers(), json=data, timeout=self.timeout)
+        response.raise_for_status()
+        return response.json()
+
+    def get_embedding(self, text: str) -> List[float]:
+        try:
+            result = self._response(text)
+            return result["data"][0]["embedding"]
+        except Exception as e:
+            logger.warning(f"Failed to get embedding: {e}")
+            return []
+
+    def get_embedding_and_usage(self, text: str) -> Tuple[List[float], Optional[Dict]]:
+        try:
+            result = self._response(text)
+            embedding = result["data"][0]["embedding"]
+            usage = result.get("usage")
+            return embedding, usage
+        except Exception as e:
+            logger.warning(f"Failed to get embedding and usage: {e}")
+            return [], None

agno/knowledge/agent.py

@@ -184,7 +184,7 @@ class AgentKnowledge(BaseModel):
                 # Filter out documents which already exist in the vector db
                 if skip_existing:
                     log_debug("Filtering out existing documents before insertion.")
-                    documents_to_load = self.filter_existing_documents(document_list)
+                    documents_to_load = await self.async_filter_existing_documents(document_list)
 
                 if documents_to_load:
                     for doc in documents_to_load:
@@ -439,6 +439,43 @@ class AgentKnowledge(BaseModel):
 
         return filtered_documents
 
+    async def async_filter_existing_documents(self, documents: List[Document]) -> List[Document]:
+        """Filter out documents that already exist in the vector database.
+
+        This helper method is used across various knowledge base implementations
+        to avoid inserting duplicate documents.
+
+        Args:
+            documents (List[Document]): List of documents to filter
+
+        Returns:
+            List[Document]: Filtered list of documents that don't exist in the database
+        """
+        from agno.utils.log import log_debug, log_info
+
+        if not self.vector_db:
+            log_debug("No vector database configured, skipping document filtering")
+            return documents
+
+        # Use set for O(1) lookups
+        seen_content = set()
+        original_count = len(documents)
+        filtered_documents = []
+
+        for doc in documents:
+            # Check hash and existence in DB
+            content_hash = doc.content  # Assuming doc.content is reliable hash key
+            if content_hash not in seen_content and not await self.vector_db.async_doc_exists(doc):
+                seen_content.add(content_hash)
+                filtered_documents.append(doc)
+            else:
+                log_debug(f"Skipping existing document: {doc.name} (or duplicate content)")
+
+        if len(filtered_documents) < original_count:
+            log_info(f"Skipped {original_count - len(filtered_documents)} existing/duplicate documents.")
+
+        return filtered_documents
+
     def _track_metadata_structure(self, metadata: Optional[Dict[str, Any]]) -> None:
         """Track metadata structure to enable filter extraction from queries
 
@@ -655,7 +692,7 @@ class AgentKnowledge(BaseModel):
             documents_to_insert = documents
             if skip_existing:
                 log_debug("Filtering out existing documents before insertion.")
-                documents_to_insert = self.filter_existing_documents(documents)
+                documents_to_insert = await self.async_filter_existing_documents(documents)
 
             if documents_to_insert:  # type: ignore
                 log_debug(f"Inserting {len(documents_to_insert)} new documents.")

agno/knowledge/combined.py

@@ -32,5 +32,5 @@ class CombinedKnowledgeBase(AgentKnowledge):
 
         for kb in self.sources:
             log_debug(f"Loading documents from {kb.__class__.__name__}")
-            async for document in await kb.async_document_lists:
+            async for document in kb.async_document_lists:  # type: ignore
                 yield document

agno/memory/agent.py

@@ -273,7 +273,7 @@ class AgentMemory(BaseModel):
 
         self.classifier.existing_memories = self.memories
         classifier_response = self.classifier.run(input)
-        if classifier_response == "yes":
+        if classifier_response and classifier_response.lower() == "yes":
             return True
         return False
 
@@ -286,7 +286,7 @@ class AgentMemory(BaseModel):
 
         self.classifier.existing_memories = self.memories
         classifier_response = await self.classifier.arun(input)
-        if classifier_response == "yes":
+        if classifier_response and classifier_response.lower() == "yes":
             return True
         return False
 

agno/memory/team.py

@@ -313,7 +313,7 @@ class TeamMemory:
 
         self.classifier.existing_memories = self.memories
         classifier_response = self.classifier.run(input)
-        if classifier_response == "yes":
+        if classifier_response and classifier_response.lower() == "yes":
             return True
         return False
 
@@ -326,7 +326,7 @@ class TeamMemory:
 
         self.classifier.existing_memories = self.memories
         classifier_response = await self.classifier.arun(input)
-        if classifier_response == "yes":
+        if classifier_response and classifier_response.lower() == "yes":
             return True
         return False
 

agno/models/aws/bedrock.py

@@ -1,7 +1,7 @@
 import json
 from dataclasses import dataclass
 from os import getenv
-from typing import Any, Dict, Iterator, List, Optional, Tuple, Type, Union
+from typing import Any, AsyncIterator, Dict, Iterator, List, Optional, Tuple, Type, Union
 
 from pydantic import BaseModel
 
@@ -18,6 +18,14 @@ try:
 except ImportError:
     raise ImportError("`boto3` not installed. Please install using `pip install boto3`")
 
+try:
+    import aioboto3
+
+    AIOBOTO3_AVAILABLE = True
+except ImportError:
+    aioboto3 = None
+    AIOBOTO3_AVAILABLE = False
+
 
 @dataclass
 class AwsBedrock(Model):
@@ -31,6 +39,9 @@ class AwsBedrock(Model):
        - AWS_REGION
     2. Or provide a boto3 Session object
 
+    For async support, you also need aioboto3 installed:
+       pip install aioboto3
+
     Not all Bedrock models support all features. See this documentation for more information: https://docs.aws.amazon.com/bedrock/latest/userguide/conversation-inference-supported-models-features.html
 
     Args:
@@ -59,6 +70,8 @@ class AwsBedrock(Model):
     request_params: Optional[Dict[str, Any]] = None
 
     client: Optional[AwsClient] = None
+    async_client: Optional[Any] = None
+    async_session: Optional[Any] = None
 
     def get_client(self) -> AwsClient:
         """
@@ -95,6 +108,57 @@ class AwsBedrock(Model):
             )
         return self.client
 
+    def get_async_client(self):
+        """
+        Get the async Bedrock client context manager.
+
+        Returns:
+            The async Bedrock client context manager.
+        """
+        if not AIOBOTO3_AVAILABLE:
+            raise ImportError(
+                "`aioboto3` not installed. Please install using `pip install aioboto3` for async support."
+            )
+
+        if self.async_session is None:
+            self.aws_access_key_id = self.aws_access_key_id or getenv("AWS_ACCESS_KEY_ID")
+            self.aws_secret_access_key = self.aws_secret_access_key or getenv("AWS_SECRET_ACCESS_KEY")
+            self.aws_region = self.aws_region or getenv("AWS_REGION")
+
+            self.async_session = aioboto3.Session()
+
+        client_kwargs = {
+            "service_name": "bedrock-runtime",
+            "region_name": self.aws_region,
+        }
+
+        if self.aws_sso_auth:
+            pass
+        else:
+            if not self.aws_access_key_id or not self.aws_secret_access_key:
+                import os
+
+                env_access_key = os.environ.get("AWS_ACCESS_KEY_ID")
+                env_secret_key = os.environ.get("AWS_SECRET_ACCESS_KEY")
+                env_region = os.environ.get("AWS_REGION")
+
+                if env_access_key and env_secret_key:
+                    self.aws_access_key_id = env_access_key
+                    self.aws_secret_access_key = env_secret_key
+                    if env_region:
+                        self.aws_region = env_region
+                        client_kwargs["region_name"] = self.aws_region
+
+            if self.aws_access_key_id and self.aws_secret_access_key:
+                client_kwargs.update(
+                    {
+                        "aws_access_key_id": self.aws_access_key_id,
+                        "aws_secret_access_key": self.aws_secret_access_key,
+                    }
+                )
+
+        return self.async_session.client(**client_kwargs)
+
     def _format_tools_for_request(self, tools: Optional[List[Dict[str, Any]]]) -> List[Dict[str, Any]]:
         """
         Format the tools for the request.
@@ -170,18 +234,29 @@ class AwsBedrock(Model):
                 if isinstance(message.content, list):
                     formatted_message["content"].extend(message.content)
                 elif message.tool_calls:
-                    formatted_message["content"].extend(
-                        [
+                    tool_use_content = []
+                    for tool_call in message.tool_calls:
+                        try:
+                            # Parse arguments with error handling for empty or invalid JSON
+                            arguments = tool_call["function"]["arguments"]
+                            if not arguments or arguments.strip() == "":
+                                tool_input = {}
+                            else:
+                                tool_input = json.loads(arguments)
+                        except (json.JSONDecodeError, KeyError) as e:
+                            log_warning(f"Failed to parse tool call arguments: {e}")
+                            tool_input = {}
+
+                        tool_use_content.append(
                             {
                                 "toolUse": {
                                     "toolUseId": tool_call["id"],
                                     "name": tool_call["function"]["name"],
-                                    "input": json.loads(tool_call["function"]["arguments"]),
+                                    "input": tool_input,
                                 }
                             }
-                            for tool_call in message.tool_calls
-                        ]
-                    )
+                        )
+                    formatted_message["content"].extend(tool_use_content)
                 else:
                     formatted_message["content"].append({"text": message.content})
 
@@ -312,9 +387,84 @@ class AwsBedrock(Model):
             log_error(f"Unexpected error calling Bedrock API: {str(e)}")
             raise ModelProviderError(message=str(e), model_name=self.name, model_id=self.id) from e
 
+    async def ainvoke(
+        self,
+        messages: List[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,
+    ) -> Dict[str, Any]:
+        """
+        Async invoke the Bedrock API.
+        """
+        try:
+            formatted_messages, system_message = self._format_messages(messages)
+
+            tool_config = None
+            if tools is not None and tools:
+                tool_config = {"tools": self._format_tools_for_request(tools)}
+
+            body = {
+                "system": system_message,
+                "toolConfig": tool_config,
+                "inferenceConfig": self._get_inference_config(),
+            }
+            body = {k: v for k, v in body.items() if v is not None}
+
+            if self.request_params:
+                log_debug(f"Calling {self.provider} with request parameters: {self.request_params}", log_level=2)
+                body.update(**self.request_params)
+
+            async with self.get_async_client() as client:
+                return await client.converse(modelId=self.id, messages=formatted_messages, **body)
+        except ClientError as e:
+            log_error(f"Unexpected error calling Bedrock API: {str(e)}")
+            raise ModelProviderError(message=str(e.response), model_name=self.name, model_id=self.id) from e
+        except Exception as e:
+            log_error(f"Unexpected error calling Bedrock API: {str(e)}")
+            raise ModelProviderError(message=str(e), model_name=self.name, model_id=self.id) from e
+
+    async def ainvoke_stream(
+        self,
+        messages: List[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,
+    ):
+        """
+        Async invoke the Bedrock API with streaming.
+        """
+        try:
+            formatted_messages, system_message = self._format_messages(messages)
+
+            tool_config = None
+            if tools is not None and tools:
+                tool_config = {"tools": self._format_tools_for_request(tools)}
+
+            body = {
+                "system": system_message,
+                "toolConfig": tool_config,
+                "inferenceConfig": self._get_inference_config(),
+            }
+            body = {k: v for k, v in body.items() if v is not None}
+
+            if self.request_params:
+                body.update(**self.request_params)
+
+            async with self.get_async_client() as client:
+                response = await client.converse_stream(modelId=self.id, messages=formatted_messages, **body)
+                async for chunk in response["stream"]:
+                    yield chunk
+        except ClientError as e:
+            log_error(f"Unexpected error calling Bedrock API: {str(e)}")
+            raise ModelProviderError(message=str(e.response), model_name=self.name, model_id=self.id) from e
+        except Exception as e:
+            log_error(f"Unexpected error calling Bedrock API: {str(e)}")
+            raise ModelProviderError(message=str(e), model_name=self.name, model_id=self.id) from e
+
     # Overwrite the default from the base model
     def format_function_call_results(
-        self, messages: List[Message], function_call_results: List[Message], tool_ids: List[str]
+        self, messages: List[Message], function_call_results: List[Message], **kwargs
     ) -> None:
         """
         Handle the results of function calls.
@@ -322,14 +472,17 @@ class AwsBedrock(Model):
         Args:
             messages (List[Message]): The list of conversation messages.
             function_call_results (List[Message]): The results of the function calls.
-            tool_ids (List[str]): The tool ids.
+            **kwargs: Additional arguments including tool_ids.
         """
         if function_call_results:
+            tool_ids = kwargs.get("tool_ids", [])
             tool_result_content: List = []
 
             for _fc_message_index, _fc_message in enumerate(function_call_results):
+                # Use tool_call_id from message if tool_ids list is insufficient
+                tool_id = tool_ids[_fc_message_index] if _fc_message_index < len(tool_ids) else _fc_message.tool_call_id
                 tool_result = {
-                    "toolUseId": tool_ids[_fc_message_index],
+                    "toolUseId": tool_id,
                     "content": [{"json": {"result": _fc_message.content}}],
                 }
                 tool_result_content.append({"toolResult": tool_result})
@@ -497,11 +650,154 @@ class AwsBedrock(Model):
                 stream_data.extra = {}
             stream_data.extra["tool_ids"] = tool_ids
 
+    async def aprocess_response_stream(
+        self,
+        messages: List[Message],
+        assistant_message: Message,
+        stream_data: MessageData,
+        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[ModelResponse]:
+        """
+        Process the asynchronous response stream.
+
+        Args:
+            messages (List[Message]): The messages to include in the request.
+            assistant_message (Message): The assistant message.
+            stream_data (MessageData): The stream data.
+        """
+        tool_use: Dict[str, Any] = {}
+        content = []
+        tool_ids = []
+
+        async for response_delta in self.ainvoke_stream(
+            messages=messages, response_format=response_format, tools=tools, tool_choice=tool_choice
+        ):
+            model_response = ModelResponse(role="assistant")
+            should_yield = False
+            if "contentBlockStart" in response_delta:
+                # Handle tool use requests
+                tool = response_delta["contentBlockStart"]["start"].get("toolUse")
+                if tool:
+                    tool_use["toolUseId"] = tool["toolUseId"]
+                    tool_use["name"] = tool["name"]
+
+            elif "contentBlockDelta" in response_delta:
+                delta = response_delta["contentBlockDelta"]["delta"]
+                if "toolUse" in delta:
+                    if "input" not in tool_use:
+                        tool_use["input"] = ""
+                    tool_use["input"] += delta["toolUse"]["input"]
+                elif "text" in delta:
+                    model_response.content = delta["text"]
+
+            elif "contentBlockStop" in response_delta:
+                if "input" in tool_use:
+                    # Finish collecting tool use input
+                    try:
+                        tool_use["input"] = json.loads(tool_use["input"])
+                    except json.JSONDecodeError as e:
+                        log_error(f"Failed to parse tool input as JSON: {e}")
+                        tool_use["input"] = {}
+                    content.append({"toolUse": tool_use})
+                    tool_ids.append(tool_use["toolUseId"])
+                    # Prepare the tool call
+                    tool_call = {
+                        "id": tool_use["toolUseId"],
+                        "type": "function",
+                        "function": {
+                            "name": tool_use["name"],
+                            "arguments": json.dumps(tool_use["input"]),
+                        },
+                    }
+                    # Append the tool call to the list of "done" tool calls
+                    model_response.tool_calls.append(tool_call)
+                    # Reset the tool use
+                    tool_use = {}
+                else:
+                    # Finish collecting text content
+                    content.append({"text": stream_data.response_content})
+
+            elif "messageStop" in response_delta or "metadata" in response_delta:
+                body = response_delta.get("metadata") or response_delta.get("messageStop") or {}
+                if "usage" in body:
+                    usage = body["usage"]
+                    model_response.response_usage = {
+                        "input_tokens": usage.get("inputTokens", 0),
+                        "output_tokens": usage.get("outputTokens", 0),
+                        "total_tokens": usage.get("totalTokens", 0),
+                    }
+
+            # Update metrics
+            if not assistant_message.metrics.time_to_first_token:
+                assistant_message.metrics.set_time_to_first_token()
+
+            if model_response.content:
+                stream_data.response_content += model_response.content
+                should_yield = True
+
+            if model_response.tool_calls:
+                if stream_data.response_tool_calls is None:
+                    stream_data.response_tool_calls = []
+                stream_data.response_tool_calls.extend(model_response.tool_calls)
+                should_yield = True
+
+            if model_response.response_usage is not None:
+                _add_usage_metrics_to_assistant_message(
+                    assistant_message=assistant_message, response_usage=model_response.response_usage
+                )
+
+            if should_yield:
+                yield model_response
+
+        if tool_ids:
+            if stream_data.extra is None:
+                stream_data.extra = {}
+            stream_data.extra["tool_ids"] = tool_ids
+
     def parse_provider_response_delta(self, response_delta: Dict[str, Any]) -> ModelResponse:  # type: ignore
-        pass
+        """Parse the provider response delta for streaming.
+
+        Args:
+            response_delta: The streaming response delta from AWS Bedrock
 
-    async def ainvoke(self, *args, **kwargs) -> Any:
-        raise NotImplementedError(f"Async not supported on {self.name}.")
+        Returns:
+            ModelResponse: The parsed model response delta
+        """
+        model_response = ModelResponse(role="assistant")
+
+        # Handle contentBlockDelta - text content
+        if "contentBlockDelta" in response_delta:
+            delta = response_delta["contentBlockDelta"]["delta"]
+            if "text" in delta:
+                model_response.content = delta["text"]
+
+        # Handle contentBlockStart - tool use start
+        elif "contentBlockStart" in response_delta:
+            start = response_delta["contentBlockStart"]["start"]
+            if "toolUse" in start:
+                tool_use = start["toolUse"]
+                model_response.tool_calls = [
+                    {
+                        "id": tool_use.get("toolUseId", ""),
+                        "type": "function",
+                        "function": {
+                            "name": tool_use.get("name", ""),
+                            "arguments": "",  # Will be filled in subsequent deltas
+                        },
+                    }
+                ]
+
+        # Handle metadata/usage information
+        elif "metadata" in response_delta or "messageStop" in response_delta:
+            body = response_delta.get("metadata") or response_delta.get("messageStop") or {}
+            if "usage" in body:
+                usage = body["usage"]
+                model_response.response_usage = {
+                    "input_tokens": usage.get("inputTokens", 0),
+                    "output_tokens": usage.get("outputTokens", 0),
+                    "total_tokens": usage.get("totalTokens", 0),
+                }
 
-    async def ainvoke_stream(self, *args, **kwargs) -> Any:
-        raise NotImplementedError(f"Async not supported on {self.name}.")
+        return model_response

agno/models/litellm/chat.py

@@ -160,6 +160,7 @@ class LiteLLM(Model):
         completion_kwargs = self.get_request_params(tools=tools)
         completion_kwargs["messages"] = self._format_messages(messages)
         completion_kwargs["stream"] = True
+        completion_kwargs["stream_options"] = {"include_usage": True}
         return self.get_client().completion(**completion_kwargs)
 
     async def ainvoke(
@@ -185,6 +186,7 @@ class LiteLLM(Model):
         completion_kwargs = self.get_request_params(tools=tools)
         completion_kwargs["messages"] = self._format_messages(messages)
         completion_kwargs["stream"] = True
+        completion_kwargs["stream_options"] = {"include_usage": True}
 
         try:
             # litellm.acompletion returns a coroutine that resolves to an async iterator
@@ -234,9 +236,12 @@ class LiteLLM(Model):
 
                 if hasattr(choice_delta, "tool_calls") and choice_delta.tool_calls:
                     processed_tool_calls = []
-                    for i, tool_call in enumerate(choice_delta.tool_calls):
-                        # Create a basic structure with index
-                        tool_call_dict = {"index": i, "type": "function"}
+                    for tool_call in choice_delta.tool_calls:
+                        # Get the actual index from the tool call, defaulting to 0 if not available
+                        actual_index = getattr(tool_call, "index", 0) if hasattr(tool_call, "index") else 0
+
+                        # Create a basic structure with the correct index
+                        tool_call_dict = {"index": actual_index, "type": "function"}
 
                         # Extract ID if available
                         if hasattr(tool_call, "id") and tool_call.id is not None:
@@ -255,6 +260,10 @@ class LiteLLM(Model):
 
                     model_response.tool_calls = processed_tool_calls
 
+        # Add usage metrics if present in streaming response
+        if hasattr(response_delta, "usage") and response_delta.usage is not None:
+            model_response.response_usage = response_delta.usage
+
         return model_response
 
     @staticmethod