agno 0.1.2__py3-none-any.whl → 2.3.13__py3-none-any.whl

agno/models/huggingface/huggingface.py

@@ -1,70 +1,42 @@
-from dataclasses import dataclass
+import json
+from collections.abc import AsyncIterator
+from dataclasses import asdict, dataclass
 from os import getenv
-from typing import Any, Dict, Iterator, List, Optional, Union
+from typing import Any, Dict, Iterator, List, Optional, Type, Union
 
 import httpx
+from huggingface_hub import ChatCompletionInputStreamOptions
 from pydantic import BaseModel
 
-from agno.models.base import Metrics, Model
+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.tools.function import FunctionCall
-from agno.utils.log import logger
-from agno.utils.tools import get_function_call_for_tool_call
+from agno.run.agent import RunOutput
+from agno.utils.log import log_debug, log_error, log_warning
 
 try:
     from huggingface_hub import (
         AsyncInferenceClient,
         ChatCompletionOutput,
         ChatCompletionOutputMessage,
-        ChatCompletionOutputUsage,
         ChatCompletionStreamOutput,
         ChatCompletionStreamOutputDelta,
         ChatCompletionStreamOutputDeltaToolCall,
         InferenceClient,
     )
-except (ModuleNotFoundError, ImportError):
+    from huggingface_hub.errors import InferenceTimeoutError
+except ImportError:
     raise ImportError("`huggingface_hub` not installed. Please install using `pip install huggingface_hub`")
 
 
-@dataclass
-class StreamData:
-    response_content: str = ""
-    response_tool_calls: Optional[List[ChatCompletionStreamOutputDeltaToolCall]] = None
-
-
 @dataclass
 class HuggingFace(Model):
     """
     A class for interacting with HuggingFace Hub Inference models.
 
-    Attributes:
-        id (str): The id of the HuggingFace model to use. Default is "meta-llama/Meta-Llama-3-8B-Instruct".
-        name (str): The name of this chat model instance. Default is "HuggingFace".
-        provider (str): The provider of the model. Default is "HuggingFace".
-        store (Optional[bool]): Whether or not to store the output of this chat completion request for use in the model distillation or evals products.
-        frequency_penalty (Optional[float]): Penalizes new tokens based on their frequency in the text so far.
-        logit_bias (Optional[Any]): Modifies the likelihood of specified tokens appearing in the completion.
-        logprobs (Optional[bool]): Include the log probabilities on the logprobs most likely tokens.
-        max_tokens (Optional[int]): The maximum number of tokens to generate in the chat completion.
-        presence_penalty (Optional[float]): Penalizes new tokens based on whether they appear in the text so far.
-        response_format (Optional[Any]): An object specifying the format that the model must output.
-        seed (Optional[int]): A seed for deterministic sampling.
-        stop (Optional[Union[str, List[str]]]): Up to 4 sequences where the API will stop generating further tokens.
-        temperature (Optional[float]): Controls randomness in the model's output.
-        top_logprobs (Optional[int]): How many log probability results to return per token.
-        top_p (Optional[float]): Controls diversity via nucleus sampling.
-        request_params (Optional[Dict[str, Any]]): Additional parameters to include in the request.
-        api_key (Optional[str]): The Access Token for authenticating with HuggingFace.
-        base_url (Optional[Union[str, httpx.URL]]): The base URL for API requests.
-        timeout (Optional[float]): The timeout for API requests.
-        max_retries (Optional[int]): The maximum number of retries for failed requests.
-        default_headers (Optional[Any]): Default headers to include in all requests.
-        default_query (Optional[Any]): Default query parameters to include in all requests.
-        http_client (Optional[httpx.Client]): An optional pre-configured HTTP client.
-        client_params (Optional[Dict[str, Any]]): Additional parameters for client configuration.
-        client (Optional[InferenceClient]): The HuggingFace Hub Inference client instance.
-        async_client (Optional[AsyncInferenceClient]): The asynchronous HuggingFace Hub client instance.
+    For more information, see: https://huggingface.co/docs/api-inference/index
     """
 
     id: str = "meta-llama/Meta-Llama-3-8B-Instruct"
@@ -78,7 +50,6 @@ class HuggingFace(Model):
     logprobs: Optional[bool] = None
     max_tokens: Optional[int] = None
     presence_penalty: Optional[float] = None
-    response_format: Optional[Any] = None
     seed: Optional[int] = None
     stop: Optional[Union[str, List[str]]] = None
     temperature: Optional[float] = None
@@ -93,7 +64,6 @@ class HuggingFace(Model):
     max_retries: Optional[int] = None
     default_headers: Optional[Any] = None
     default_query: Optional[Any] = None
-    http_client: Optional[httpx.Client] = None
     client_params: Optional[Dict[str, Any]] = None
 
     # HuggingFace Hub Inference clients
@@ -103,7 +73,7 @@ class HuggingFace(Model):
     def get_client_params(self) -> Dict[str, Any]:
         self.api_key = self.api_key or getenv("HF_TOKEN")
         if not self.api_key:
-            logger.error("HF_TOKEN not set. Please set the HF_TOKEN environment variable.")
+            log_error("HF_TOKEN not set. Please set the HF_TOKEN environment variable.")
 
         _client_params: Dict[str, Any] = {}
         if self.api_key is not None:
@@ -133,9 +103,8 @@ class HuggingFace(Model):
             return self.client
 
         _client_params: Dict[str, Any] = self.get_client_params()
-        if self.http_client is not None:
-            _client_params["http_client"] = self.http_client
-        return InferenceClient(**_client_params)
+        self.client = InferenceClient(**_client_params)
+        return self.client
 
     def get_async_client(self) -> AsyncInferenceClient:
         """
@@ -148,18 +117,12 @@ class HuggingFace(Model):
             return self.async_client
 
         _client_params: Dict[str, Any] = self.get_client_params()
+        self.async_client = AsyncInferenceClient(**_client_params)
+        return self.async_client
 
-        if self.http_client:
-            _client_params["http_client"] = self.http_client
-        else:
-            # Create a new async HTTP client with custom limits
-            _client_params["http_client"] = httpx.AsyncClient(
-                limits=httpx.Limits(max_connections=1000, max_keepalive_connections=100)
-            )
-        return AsyncInferenceClient(**_client_params)
-
-    @property
-    def request_kwargs(self) -> Dict[str, Any]:
+    def get_request_params(
+        self, tools: Optional[List[Dict[str, Any]]] = None, tool_choice: Optional[Union[str, Dict[str, Any]]] = None
+    ) -> Dict[str, Any]:
         """
         Returns keyword arguments for inference model client requests.
 
@@ -179,8 +142,6 @@ class HuggingFace(Model):
             _request_params["max_tokens"] = self.max_tokens
         if self.presence_penalty is not None:
             _request_params["presence_penalty"] = self.presence_penalty
-        if self.response_format is not None:
-            _request_params["response_format"] = self.response_format
         if self.seed is not None:
             _request_params["seed"] = self.seed
         if self.stop is not None:
@@ -191,14 +152,17 @@ class HuggingFace(Model):
             _request_params["top_logprobs"] = self.top_logprobs
         if self.top_p is not None:
             _request_params["top_p"] = self.top_p
-        if self.tools is not None:
-            _request_params["tools"] = self.tools
-            if self.tool_choice is None:
+        if tools is not None:
+            _request_params["tools"] = tools
+            if tool_choice is None:
                 _request_params["tool_choice"] = "auto"
             else:
-                _request_params["tool_choice"] = self.tool_choice
+                _request_params["tool_choice"] = tool_choice
         if self.request_params is not None:
             _request_params.update(self.request_params)
+
+        if _request_params:
+            log_debug(f"Calling {self.provider} with request parameters: {_request_params}", log_level=2)
         return _request_params
 
     def to_dict(self) -> Dict[str, Any]:
@@ -217,558 +181,322 @@ class HuggingFace(Model):
                 "logprobs": self.logprobs,
                 "max_tokens": self.max_tokens,
                 "presence_penalty": self.presence_penalty,
-                "response_format": self.response_format,
                 "seed": self.seed,
                 "stop": self.stop,
                 "temperature": self.temperature,
                 "top_logprobs": self.top_logprobs,
                 "top_p": self.top_p,
-                "tools": self.tools,
-                "tool_choice": self.tool_choice
-                if (self.tools is not None and self.tool_choice is not None)
-                else "auto",
             }
         )
         cleaned_dict = {k: v for k, v in _dict.items() if v is not None}
         return cleaned_dict
 
-    def invoke(self, messages: List[Message]) -> Union[ChatCompletionOutput]:
+    def _format_message(self, message: Message, compress_tool_results: bool = False) -> Dict[str, Any]:
         """
-        Send a chat completion request to the HuggingFace Hub.
+        Format a message into the format expected by HuggingFace.
 
         Args:
-            messages (List[Message]): A list of messages to send to the model.
+            message (Message): The message to format.
+            compress_tool_results: Whether to compress tool results.
 
         Returns:
-            ChatCompletionOutput: The chat completion response from the Inference Client.
+            Dict[str, Any]: The formatted message.
         """
-        return self.get_client().chat.completions.create(
-            model=self.id,
-            messages=[m.to_dict() for m in messages],
-            **self.request_kwargs,
-        )
+        # Use compressed content for tool messages if compression is active
+        if message.role == "tool":
+            content = message.get_content(use_compressed_content=compress_tool_results)
+        else:
+            content = message.content if message.content is not None else ""
 
-    async def ainvoke(self, messages: List[Message]) -> Union[ChatCompletionOutput]:
-        """
-        Sends an asynchronous chat completion request to the HuggingFace Hub Inference.
+        message_dict: Dict[str, Any] = {
+            "role": message.role,
+            "content": content,
+            "name": message.name or message.tool_name,
+            "tool_call_id": message.tool_call_id,
+            "tool_calls": message.tool_calls,
+        }
 
-        Args:
-            messages (List[Message]): A list of messages to send to the model.
+        message_dict = {k: v for k, v in message_dict.items() if v is not None}
 
-        Returns:
-            ChatCompletionOutput: The chat completion response from the Inference Client.
-        """
-        return await self.get_async_client().chat.completions.create(
-            model=self.id,
-            messages=[m.to_dict() for m in messages],
-            **self.request_kwargs,
-        )
+        if message.tool_calls is None or len(message.tool_calls) == 0:
+            message_dict["tool_calls"] = None
 
-    def invoke_stream(self, messages: List[Message]) -> Iterator[ChatCompletionStreamOutput]:
-        """
-        Send a streaming chat completion request to the HuggingFace API.
+        if message.audio is not None and len(message.audio) > 0:
+            log_warning("Audio input is currently unsupported.")
 
-        Args:
-            messages (List[Message]): A list of messages to send to the model.
+        if message.files is not None and len(message.files) > 0:
+            log_warning("File input is currently unsupported.")
 
-        Returns:
-            Iterator[ChatCompletionStreamOutput]: An iterator of chat completion delta.
-        """
-        yield from self.get_client().chat.completions.create(
-            model=self.id,
-            messages=[m.to_dict() for m in messages],  # type: ignore
-            stream=True,
-            stream_options={"include_usage": True},
-            **self.request_kwargs,
-        )  # type: ignore
-
-    async def ainvoke_stream(self, messages: List[Message]) -> Any:
-        """
-        Sends an asynchronous streaming chat completion request to the HuggingFace API.
+        if message.images is not None and len(message.images) > 0:
+            log_warning("Image input is currently unsupported.")
 
-        Args:
-            messages (List[Message]): A list of messages to send to the model.
+        if message.videos is not None and len(message.videos) > 0:
+            log_warning("Video input is currently unsupported.")
 
-        Returns:
-            Any: An asynchronous iterator of chat completion chunks.
-        """
-        async_stream = await self.get_async_client().chat.completions.create(
-            model=self.id,
-            messages=[m.to_dict() for m in messages],
-            stream=True,
-            stream_options={"include_usage": True},
-            **self.request_kwargs,
-        )
-        async for chunk in async_stream:  # type: ignore
-            yield chunk
+        return message_dict
 
-    def _handle_tool_calls(
-        self, assistant_message: Message, messages: List[Message], model_response: ModelResponse
-    ) -> Optional[ModelResponse]:
+    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,
+        run_response: Optional[RunOutput] = None,
+        compress_tool_results: bool = False,
+    ) -> ModelResponse:
         """
-        Handle tool calls in the assistant message.
-
-        Args:
-            assistant_message (Message): The assistant message.
-            messages (List[Message]): The list of messages.
-            model_response (ModelResponse): The model response.
-
-        Returns:
-            Optional[ModelResponse]: The model response after handling tool calls.
+        Send a chat completion request to the HuggingFace Hub.
         """
-        if assistant_message.tool_calls is not None and len(assistant_message.tool_calls) > 0:
-            model_response.content = ""
-            tool_role: str = "tool"
-            function_calls_to_run: List[FunctionCall] = []
-            function_call_results: List[Message] = []
-            for tool_call in assistant_message.tool_calls:
-                _tool_call_id = tool_call.get("id")
-                _function_call = get_function_call_for_tool_call(tool_call, self._functions)
-                if _function_call is None:
-                    messages.append(
-                        Message(
-                            role="tool",
-                            tool_call_id=_tool_call_id,
-                            content="Could not find function to call.",
-                        )
-                    )
-                    continue
-                if _function_call.error is not None:
-                    messages.append(
-                        Message(
-                            role="tool",
-                            tool_call_id=_tool_call_id,
-                            content=_function_call.error,
-                        )
-                    )
-                    continue
-                function_calls_to_run.append(_function_call)
-
-            if self.show_tool_calls:
-                model_response.content += "\nRunning:"
-                for _f in function_calls_to_run:
-                    model_response.content += f"\n - {_f.get_call_str()}"
-                model_response.content += "\n\n"
-
-            for _ in self.run_function_calls(
-                function_calls=function_calls_to_run, function_call_results=function_call_results, tool_role=tool_role
-            ):
-                pass
-
-            if len(function_call_results) > 0:
-                messages.extend(function_call_results)
+        try:
+            if run_response and run_response.metrics:
+                run_response.metrics.set_time_to_first_token()
+
+            assistant_message.metrics.start_timer()
+            provider_response = self.get_client().chat.completions.create(
+                model=self.id,
+                messages=[self._format_message(m, compress_tool_results) for m in messages],
+                **self.get_request_params(tools=tools, tool_choice=tool_choice),
+            )
+            assistant_message.metrics.stop_timer()
 
-            return model_response
-        return None
+            return self._parse_provider_response(provider_response, response_format=response_format)
 
-    def _update_usage_metrics(
-        self, assistant_message: Message, metrics: Metrics, response_usage: Optional[ChatCompletionOutputUsage]
-    ) -> None:
-        """
-        Update the usage metrics for the assistant message and the model.
+        except InferenceTimeoutError as e:
+            log_error(f"Error invoking HuggingFace model: {e}")
+            raise ModelProviderError(message=str(e), model_name=self.name, model_id=self.id) from e
+        except Exception as e:
+            log_error(f"Unexpected error invoking HuggingFace model: {e}")
+            raise ModelProviderError(message=str(e), model_name=self.name, model_id=self.id) from e
 
-        Args:
-            assistant_message (Message): The assistant message.
-            metrics (Metrics): The metrics.
-            response_usage (Optional[CompletionUsage]): The response usage.
-        """
-        # Update time taken to generate response
-        assistant_message.metrics["time"] = metrics.response_timer.elapsed
-        self.metrics.setdefault("response_times", []).append(metrics.response_timer.elapsed)
-        if response_usage:
-            prompt_tokens = response_usage.prompt_tokens
-            completion_tokens = response_usage.completion_tokens
-            total_tokens = response_usage.total_tokens
-
-            if prompt_tokens is not None:
-                metrics.input_tokens = prompt_tokens
-                metrics.prompt_tokens = prompt_tokens
-                assistant_message.metrics["input_tokens"] = prompt_tokens
-                assistant_message.metrics["prompt_tokens"] = prompt_tokens
-                self.metrics["input_tokens"] = self.metrics.get("input_tokens", 0) + prompt_tokens
-                self.metrics["prompt_tokens"] = self.metrics.get("prompt_tokens", 0) + prompt_tokens
-            if completion_tokens is not None:
-                metrics.output_tokens = completion_tokens
-                metrics.completion_tokens = completion_tokens
-                assistant_message.metrics["output_tokens"] = completion_tokens
-                assistant_message.metrics["completion_tokens"] = completion_tokens
-                self.metrics["output_tokens"] = self.metrics.get("output_tokens", 0) + completion_tokens
-                self.metrics["completion_tokens"] = self.metrics.get("completion_tokens", 0) + completion_tokens
-            if total_tokens is not None:
-                metrics.total_tokens = total_tokens
-                assistant_message.metrics["total_tokens"] = total_tokens
-                self.metrics["total_tokens"] = self.metrics.get("total_tokens", 0) + total_tokens
-            if response_usage.prompt_tokens_details is not None:
-                if isinstance(response_usage.prompt_tokens_details, dict):
-                    metrics.prompt_tokens_details = response_usage.prompt_tokens_details
-                elif isinstance(response_usage.prompt_tokens_details, BaseModel):
-                    metrics.prompt_tokens_details = response_usage.prompt_tokens_details.model_dump(exclude_none=True)
-                assistant_message.metrics["prompt_tokens_details"] = metrics.prompt_tokens_details
-                if metrics.prompt_tokens_details is not None:
-                    for k, v in metrics.prompt_tokens_details.items():
-                        self.metrics.get("prompt_tokens_details", {}).get(k, 0) + v
-            if response_usage.completion_tokens_details is not None:
-                if isinstance(response_usage.completion_tokens_details, dict):
-                    metrics.completion_tokens_details = response_usage.completion_tokens_details
-                elif isinstance(response_usage.completion_tokens_details, BaseModel):
-                    metrics.completion_tokens_details = response_usage.completion_tokens_details.model_dump(
-                        exclude_none=True
-                    )
-                assistant_message.metrics["completion_tokens_details"] = metrics.completion_tokens_details
-                if metrics.completion_tokens_details is not None:
-                    for k, v in metrics.completion_tokens_details.items():
-                        self.metrics.get("completion_tokens_details", {}).get(k, 0) + v
-
-    def _create_assistant_message(
+    async def ainvoke(
         self,
-        response_message: ChatCompletionOutputMessage,
-        metrics: Metrics,
-        response_usage: Optional[ChatCompletionOutputUsage],
-    ) -> Message:
+        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,
+        run_response: Optional[RunOutput] = None,
+        compress_tool_results: bool = False,
+    ) -> ModelResponse:
         """
-        Create an assistant message from the response.
-
-        Args:
-            response_message (ChatCompletionMessage): The response message.
-            metrics (Metrics): The metrics.
-            response_usage (Optional[CompletionUsage]): The response usage.
-
-        Returns:
-            Message: The assistant message.
+        Sends an asynchronous chat completion request to the HuggingFace Hub Inference.
         """
-        assistant_message = Message(
-            role=response_message.role or "assistant",
-            content=response_message.content,
-        )
-        if response_message.tool_calls is not None and len(response_message.tool_calls) > 0:
-            assistant_message.tool_calls = [t.model_dump() for t in response_message.tool_calls]
+        try:
+            if run_response and run_response.metrics:
+                run_response.metrics.set_time_to_first_token()
+
+            assistant_message.metrics.start_timer()
+            provider_response = await self.get_async_client().chat.completions.create(
+                model=self.id,
+                messages=[self._format_message(m, compress_tool_results) for m in messages],
+                **self.get_request_params(tools=tools, tool_choice=tool_choice),
+            )
+            assistant_message.metrics.stop_timer()
 
-        return assistant_message
+            return self._parse_provider_response(provider_response, response_format=response_format)
 
-    def response(self, messages: List[Message]) -> ModelResponse:
-        """
-        Generate a response from HuggingFace Hub.
-
-        Args:
-            messages (List[Message]): A list of messages.
+        except InferenceTimeoutError as e:
+            log_error(f"Error invoking HuggingFace model: {e}")
+            raise ModelProviderError(message=str(e), model_name=self.name, model_id=self.id) from e
+        except Exception as e:
+            log_error(f"Unexpected error invoking HuggingFace model: {e}")
+            raise ModelProviderError(message=str(e), model_name=self.name, model_id=self.id) from e
 
-        Returns:
-            ModelResponse: The 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,
+        run_response: Optional[RunOutput] = None,
+        compress_tool_results: bool = False,
+    ) -> Iterator[ModelResponse]:
         """
-        logger.debug("---------- HuggingFace Response Start ----------")
-        self._log_messages(messages)
-        model_response = ModelResponse()
-        metrics = Metrics()
+        Send a streaming chat completion request to the HuggingFace API.
+        """
+        try:
+            if run_response and run_response.metrics:
+                run_response.metrics.set_time_to_first_token()
 
-        # -*- Generate response
-        metrics.start_response_timer()
-        response: Union[ChatCompletionOutput] = self.invoke(messages=messages)
-        metrics.stop_response_timer()
+            assistant_message.metrics.start_timer()
 
-        # -*- Parse response
-        response_message: ChatCompletionOutputMessage = response.choices[0].message
-        response_usage: Optional[ChatCompletionOutputUsage] = response.usage
+            stream = self.get_client().chat.completions.create(
+                model=self.id,
+                messages=[self._format_message(m, compress_tool_results) for m in messages],
+                stream=True,
+                stream_options=ChatCompletionInputStreamOptions(include_usage=True),  # type: ignore
+                **self.get_request_params(tools=tools, tool_choice=tool_choice),
+            )
 
-        # -*- Create assistant message
-        assistant_message = self._create_assistant_message(
-            response_message=response_message, metrics=metrics, response_usage=response_usage
-        )
+            for chunk in stream:
+                yield self._parse_provider_response_delta(chunk)
 
-        # -*- Add assistant message to messages
-        messages.append(assistant_message)
+            assistant_message.metrics.stop_timer()
 
-        # -*- Log response and metrics
-        assistant_message.log()
-        metrics.log()
+        except InferenceTimeoutError as e:
+            log_error(f"Error invoking HuggingFace model: {e}")
+            raise ModelProviderError(message=str(e), model_name=self.name, model_id=self.id) from e
+        except Exception as e:
+            log_error(f"Unexpected error invoking HuggingFace model: {e}")
+            raise ModelProviderError(message=str(e), model_name=self.name, model_id=self.id) from e
 
-        # -*- Handle tool calls
-        if self._handle_tool_calls(assistant_message, messages, model_response):
-            response_after_tool_calls = self.response(messages=messages)
-            if response_after_tool_calls.content is not None:
-                if model_response.content is None:
-                    model_response.content = ""
-                model_response.content += response_after_tool_calls.content
-            return model_response
+    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,
+        run_response: Optional[RunOutput] = None,
+        compress_tool_results: bool = False,
+    ) -> AsyncIterator[Any]:
+        """
+        Sends an asynchronous streaming chat completion request to the HuggingFace API.
+        """
+        try:
+            if run_response and run_response.metrics:
+                run_response.metrics.set_time_to_first_token()
+
+            assistant_message.metrics.start_timer()
+            provider_response = await self.get_async_client().chat.completions.create(
+                model=self.id,
+                messages=[self._format_message(m, compress_tool_results) for m in messages],
+                stream=True,
+                stream_options=ChatCompletionInputStreamOptions(include_usage=True),  # type: ignore
+                **self.get_request_params(tools=tools, tool_choice=tool_choice),
+            )
 
-        # -*- Update model response
-        if assistant_message.content is not None:
-            model_response.content = assistant_message.get_content_string()
+            async for chunk in provider_response:
+                yield self._parse_provider_response_delta(chunk)
 
-        logger.debug("---------- HuggingFace Response End ----------")
-        return model_response
+            assistant_message.metrics.stop_timer()
+
+        except InferenceTimeoutError as e:
+            log_error(f"Error invoking HuggingFace model: {e}")
+            raise ModelProviderError(message=str(e), model_name=self.name, model_id=self.id) from e
+        except Exception as e:
+            log_error(f"Unexpected error invoking HuggingFace model: {e}")
+            raise ModelProviderError(message=str(e), model_name=self.name, model_id=self.id) from e
 
-    async def aresponse(self, messages: List[Message]) -> ModelResponse:
+    # Override base method
+    @staticmethod
+    def parse_tool_calls(tool_calls_data: List[ChatCompletionStreamOutputDeltaToolCall]) -> List[Dict[str, Any]]:
         """
-        Generate an asynchronous response from HuggingFace.
+        Build tool calls from streamed tool call data.
 
         Args:
-            messages (List[Message]): A list of messages.
+            tool_calls_data (List[ChatCompletionStreamOutputDeltaToolCall]): The tool call data to build from.
 
         Returns:
-            ModelResponse: The model response from the API.
+            List[Dict[str, Any]]: The built tool calls.
+        """
+        tool_calls: List[Dict[str, Any]] = []
+        for tool_call in tool_calls_data:
+            _tool_call = tool_call[0]
+            _index = _tool_call.index
+            _tool_call_id = _tool_call.id
+            _tool_call_type = _tool_call.type
+            _function_name = _tool_call.function.name if _tool_call.function else None
+            _function_arguments = _tool_call.function.arguments if _tool_call.function else None
+
+            if len(tool_calls) <= _index:
+                tool_calls.extend([{}] * (_index - len(tool_calls) + 1))
+            tool_call_entry = tool_calls[_index]
+            if not tool_call_entry:
+                tool_call_entry["id"] = _tool_call_id
+                tool_call_entry["type"] = _tool_call_type
+                tool_call_entry["function"] = {
+                    "name": _function_name or "",
+                    "arguments": _function_arguments or "",
+                }
+            else:
+                if _function_name:
+                    tool_call_entry["function"]["name"] += _function_name
+                if _function_arguments:
+                    tool_call_entry["function"]["arguments"] += _function_arguments
+                if _tool_call_id:
+                    tool_call_entry["id"] = _tool_call_id
+                if _tool_call_type:
+                    tool_call_entry["type"] = _tool_call_type
+        return tool_calls
+
+    def _parse_provider_response(
+        self,
+        response: ChatCompletionOutput,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+    ) -> ModelResponse:
+        """
+        Parse the provider response into a ModelResponse.
         """
-        logger.debug("---------- HuggingFace Async Response Start ----------")
-        self._log_messages(messages)
         model_response = ModelResponse()
-        metrics = Metrics()
 
-        # -*- Generate response
-        metrics.start_response_timer()
-        response: Union[ChatCompletionOutput] = await self.ainvoke(messages=messages)
-        metrics.stop_response_timer()
-
-        # -*- Parse response
         response_message: ChatCompletionOutputMessage = response.choices[0].message
-        response_usage: Optional[ChatCompletionOutputUsage] = response.usage
 
-        # -*- Parse structured outputs
+        model_response.role = response_message.role
+        if response_message.content is not None:
+            model_response.content = response_message.content
+
+        if response_message.tool_calls is not None and len(response_message.tool_calls) > 0:
+            model_response.tool_calls = [asdict(t) for t in response_message.tool_calls]
+            for tool_call in model_response.tool_calls:
+                if isinstance(tool_call["function"]["arguments"], dict):
+                    tool_call["function"]["arguments"] = json.dumps(tool_call["function"]["arguments"])
+
         try:
             if (
-                self.response_format is not None
-                and self.structured_outputs
-                and issubclass(self.response_format, BaseModel)
+                response_format is not None
+                and isinstance(response_format, type)
+                and issubclass(response_format, BaseModel)
             ):
                 parsed_object = response_message.parsed  # type: ignore
                 if parsed_object is not None:
                     model_response.parsed = parsed_object
         except Exception as e:
-            logger.warning(f"Error retrieving structured outputs: {e}")
-
-        # -*- Create assistant message
-        assistant_message = self._create_assistant_message(
-            response_message=response_message, metrics=metrics, response_usage=response_usage
-        )
-
-        # -*- Add assistant message to messages
-        messages.append(assistant_message)
+            log_warning(f"Error retrieving structured outputs: {e}")
 
-        # -*- Log response and metrics
-        assistant_message.log()
-        metrics.log()
+        if response.usage is not None:
+            model_response.response_usage = self._get_metrics(response)
 
-        # -*- Handle tool calls
-        if self._handle_tool_calls(assistant_message, messages, model_response):
-            response_after_tool_calls = await self.aresponse(messages=messages)
-            if response_after_tool_calls.content is not None:
-                if model_response.content is None:
-                    model_response.content = ""
-                model_response.content += response_after_tool_calls.content
-            return model_response
-
-        # -*- Update model response
-        if assistant_message.content is not None:
-            model_response.content = assistant_message.get_content_string()
-
-        logger.debug("---------- HuggingFace Async Response End ----------")
         return model_response
 
-    def _update_stream_metrics(self, assistant_message: Message, metrics: Metrics):
+    def _parse_provider_response_delta(self, response_delta: ChatCompletionStreamOutput) -> ModelResponse:
         """
-        Update the usage metrics for the assistant message and the model.
-
-        Args:
-            assistant_message (Message): The assistant message.
-            metrics (Metrics): The metrics.
-        """
-        # Update time taken to generate response
-        assistant_message.metrics["time"] = metrics.response_timer.elapsed
-        self.metrics.setdefault("response_times", []).append(metrics.response_timer.elapsed)
-
-        if metrics.time_to_first_token is not None:
-            assistant_message.metrics["time_to_first_token"] = metrics.time_to_first_token
-            self.metrics.setdefault("time_to_first_token", []).append(metrics.time_to_first_token)
-
-        if metrics.input_tokens is not None:
-            assistant_message.metrics["input_tokens"] = metrics.input_tokens
-            self.metrics["input_tokens"] = self.metrics.get("input_tokens", 0) + metrics.input_tokens
-        if metrics.output_tokens is not None:
-            assistant_message.metrics["output_tokens"] = metrics.output_tokens
-            self.metrics["output_tokens"] = self.metrics.get("output_tokens", 0) + metrics.output_tokens
-        if metrics.prompt_tokens is not None:
-            assistant_message.metrics["prompt_tokens"] = metrics.prompt_tokens
-            self.metrics["prompt_tokens"] = self.metrics.get("prompt_tokens", 0) + metrics.prompt_tokens
-        if metrics.completion_tokens is not None:
-            assistant_message.metrics["completion_tokens"] = metrics.completion_tokens
-            self.metrics["completion_tokens"] = self.metrics.get("completion_tokens", 0) + metrics.completion_tokens
-        if metrics.total_tokens is not None:
-            assistant_message.metrics["total_tokens"] = metrics.total_tokens
-            self.metrics["total_tokens"] = self.metrics.get("total_tokens", 0) + metrics.total_tokens
-        if metrics.prompt_tokens_details is not None:
-            assistant_message.metrics["prompt_tokens_details"] = metrics.prompt_tokens_details
-            for k, v in metrics.prompt_tokens_details.items():
-                self.metrics.get("prompt_tokens_details", {}).get(k, 0) + v
-        if metrics.completion_tokens_details is not None:
-            assistant_message.metrics["completion_tokens_details"] = metrics.completion_tokens_details
-            for k, v in metrics.completion_tokens_details.items():
-                self.metrics.get("completion_tokens_details", {}).get(k, 0) + v
-
-    def _handle_stream_tool_calls(
-        self,
-        assistant_message: Message,
-        messages: List[Message],
-    ) -> Iterator[ModelResponse]:
+        Parse the provider response delta into a ModelResponse.
         """
-        Handle tool calls for response stream.
+        model_response = ModelResponse()
+        if response_delta.choices and len(response_delta.choices) > 0:
+            response_delta_message: ChatCompletionStreamOutputDelta = response_delta.choices[0].delta
 
-        Args:
-            assistant_message (Message): The assistant message.
-            messages (List[Message]): The list of messages.
+            model_response.role = response_delta_message.role
 
-        Returns:
-            Iterator[ModelResponse]: An iterator of the model response.
-        """
-        if assistant_message.tool_calls is not None and len(assistant_message.tool_calls) > 0:
-            tool_role: str = "tool"
-            function_calls_to_run: List[FunctionCall] = []
-            function_call_results: List[Message] = []
-            for tool_call in assistant_message.tool_calls:
-                _tool_call_id = tool_call.get("id")
-                _function_call = get_function_call_for_tool_call(tool_call, self._functions)
-                if _function_call is None:
-                    messages.append(
-                        Message(
-                            role=tool_role,
-                            tool_call_id=_tool_call_id,
-                            content="Could not find function to call.",
-                        )
-                    )
-                    continue
-                if _function_call.error is not None:
-                    messages.append(
-                        Message(
-                            role=tool_role,
-                            tool_call_id=_tool_call_id,
-                            content=_function_call.error,
-                        )
-                    )
-                    continue
-                function_calls_to_run.append(_function_call)
-
-            if self.show_tool_calls:
-                yield ModelResponse(content="\nRunning:")
-                for _f in function_calls_to_run:
-                    yield ModelResponse(content=f"\n - {_f.get_call_str()}")
-                yield ModelResponse(content="\n\n")
-
-            for intermediate_model_response in self.run_function_calls(
-                function_calls=function_calls_to_run, function_call_results=function_call_results, tool_role=tool_role
-            ):
-                yield intermediate_model_response
+            if response_delta_message.content is not None:
+                model_response.content = response_delta_message.content
+            if response_delta_message.tool_calls is not None and len(response_delta_message.tool_calls) > 0:
+                model_response.tool_calls = [response_delta_message.tool_calls]  # type: ignore
+        if response_delta.usage is not None:
+            model_response.response_usage = self._get_metrics(response_delta)
 
-            if len(function_call_results) > 0:
-                messages.extend(function_call_results)
+        return model_response
 
-    def response_stream(self, messages: List[Message]) -> Iterator[ModelResponse]:
+    def _get_metrics(self, response: Union[ChatCompletionOutput, ChatCompletionStreamOutput]) -> Metrics:
         """
-        Generate a streaming response from HuggingFace Hub.
+        Parse the given HuggingFace-specific usage into an Agno Metrics object.
 
         Args:
-            messages (List[Message]): A list of messages.
+            response: The HuggingFace response to parse.
 
         Returns:
-            Iterator[ModelResponse]: An iterator of model responses.
-        """
-        logger.debug("---------- HuggingFace Response Start ----------")
-        self._log_messages(messages)
-        stream_data: StreamData = StreamData()
-
-        # -*- Generate response
-        for response in self.invoke_stream(messages=messages):
-            if len(response.choices) > 0:
-                # metrics.completion_tokens += 1
-
-                response_delta: ChatCompletionStreamOutputDelta = response.choices[0].delta
-                response_content: Optional[str] = response_delta.content
-                response_tool_calls: Optional[List[ChatCompletionStreamOutputDeltaToolCall]] = response_delta.tool_calls
-
-                if response_content is not None:
-                    stream_data.response_content += response_content
-                    yield ModelResponse(content=response_content)
-
-                if response_tool_calls is not None:
-                    if stream_data.response_tool_calls is None:
-                        stream_data.response_tool_calls = []
-                    stream_data.response_tool_calls.extend(response_tool_calls)
-
-        # -*- Create assistant message
-        assistant_message = Message(role="assistant")
-        if stream_data.response_content != "":
-            assistant_message.content = stream_data.response_content
-
-        if stream_data.response_tool_calls is not None:
-            _tool_calls = self._build_tool_calls(stream_data.response_tool_calls)
-            if len(_tool_calls) > 0:
-                assistant_message.tool_calls = _tool_calls
-
-        # -*- Add assistant message to messages
-        messages.append(assistant_message)
-
-        # -*- Handle tool calls
-        if assistant_message.tool_calls is not None and len(assistant_message.tool_calls) > 0:
-            yield from self._handle_stream_tool_calls(assistant_message, messages)
-            yield from self.response_stream(messages=messages)
-        logger.debug("---------- HuggingFace Response End ----------")
-
-    async def aresponse_stream(self, messages: List[Message]) -> Any:
+            Metrics: Parsed metrics data
         """
-        Generate an asynchronous streaming response from HuggingFace Hub.
+        metrics = Metrics()
 
-        Args:
-            messages (List[Message]): A list of messages.
+        if not response.usage:
+            return metrics
 
-        Returns:
-            Any: An asynchronous iterator of model responses.
-        """
-        logger.debug("---------- HuggingFace Hub Async Response Start ----------")
-        self._log_messages(messages)
-        stream_data: StreamData = StreamData()
-        metrics: Metrics = Metrics()
-
-        # -*- Generate response
-        metrics.start_response_timer()
-        async for response in self.ainvoke_stream(messages=messages):
-            if len(response.choices) > 0:
-                metrics.completion_tokens += 1
-                if metrics.completion_tokens == 1:
-                    metrics.time_to_first_token = metrics.response_timer.elapsed
-
-                response_delta: ChatCompletionStreamOutputDelta = response.choices[0].delta
-                response_content = response_delta.content
-                response_tool_calls = response_delta.tool_calls
-
-                if response_content is not None:
-                    stream_data.response_content += response_content
-                    yield ModelResponse(content=response_content)
-
-                if response_tool_calls is not None:
-                    if stream_data.response_tool_calls is None:
-                        stream_data.response_tool_calls = []
-                    stream_data.response_tool_calls.extend(response_tool_calls)
-        metrics.stop_response_timer()
-
-        # -*- Create assistant message
-        assistant_message = Message(role="assistant")
-        if stream_data.response_content != "":
-            assistant_message.content = stream_data.response_content
-
-        if stream_data.response_tool_calls is not None:
-            _tool_calls = self._build_tool_calls(stream_data.response_tool_calls)
-            if len(_tool_calls) > 0:
-                assistant_message.tool_calls = _tool_calls
-
-        self._update_stream_metrics(assistant_message=assistant_message, metrics=metrics)
-
-        # -*- Add assistant message to messages
-        messages.append(assistant_message)
-
-        # -*- Log response and metrics
-        assistant_message.log()
-        metrics.log()
-
-        # -*- Handle tool calls
-        if assistant_message.tool_calls is not None and len(assistant_message.tool_calls) > 0:
-            for model_response in self._handle_stream_tool_calls(assistant_message, messages):
-                yield model_response
-            async for model_response in self.aresponse_stream(messages=messages):
-                yield model_response
-        logger.debug("---------- HuggingFace Hub Async Response End ----------")
+        metrics.input_tokens = response.usage.prompt_tokens or 0
+        metrics.output_tokens = response.usage.completion_tokens or 0
+        metrics.total_tokens = metrics.input_tokens + metrics.output_tokens
+
+        return metrics