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

agno/models/groq/groq.py

@@ -1,65 +1,32 @@
+from collections.abc import AsyncIterator
 from dataclasses import 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 pydantic import BaseModel
 
-from agno.models.base import Metrics as BaseMetrics
+from agno.exceptions import ModelAuthenticationError, ModelProviderError
 from agno.models.base import Model
 from agno.models.message import Message
-from agno.models.response import ModelResponse, ModelResponseEvent
-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.models.metrics import Metrics
+from agno.models.response import ModelResponse
+from agno.run.agent import RunOutput
+from agno.utils.http import get_default_async_client, get_default_sync_client
+from agno.utils.log import log_debug, log_error, log_warning
+from agno.utils.openai import images_to_message
 
 try:
+    from groq import APIError, APIResponseValidationError, APIStatusError
     from groq import AsyncGroq as AsyncGroqClient
     from groq import Groq as GroqClient
-    from groq.types.chat import ChatCompletion, ChatCompletionMessage
+    from groq.types.chat import ChatCompletion
     from groq.types.chat.chat_completion_chunk import ChatCompletionChunk, ChoiceDelta, ChoiceDeltaToolCall
     from groq.types.completion_usage import CompletionUsage
-except (ModuleNotFoundError, ImportError):
+except ImportError:
     raise ImportError("`groq` not installed. Please install using `pip install groq`")
 
 
-@dataclass
-class Metrics(BaseMetrics):
-    completion_time: Optional[float] = None
-    prompt_time: Optional[float] = None
-    queue_time: Optional[float] = None
-    total_time: Optional[float] = None
-
-    def log(self):
-        metric_lines = []
-        if self.time_to_first_token is not None:
-            metric_lines.append(f"* Time to first token:         {self.time_to_first_token:.4f}s")
-        metric_lines.extend(
-            [
-                f"* Time to generate response:   {self.response_timer.elapsed:.4f}s",
-                f"* Tokens per second:           {self.output_tokens / self.response_timer.elapsed:.4f} tokens/s",
-                f"* Input tokens:                {self.input_tokens or self.prompt_tokens}",
-                f"* Output tokens:               {self.output_tokens or self.completion_tokens}",
-                f"* Total tokens:                {self.total_tokens}",
-            ]
-        )
-        if self.completion_time is not None:
-            metric_lines.append(f"* Completion time:             {self.completion_time:.4f}s")
-        if self.prompt_time is not None:
-            metric_lines.append(f"* Prompt time:                 {self.prompt_time:.4f}s")
-        if self.queue_time is not None:
-            metric_lines.append(f"* Queue time:                  {self.queue_time:.4f}s")
-        if self.total_time is not None:
-            metric_lines.append(f"* Total time:                  {self.total_time:.4f}s")
-
-        self._log(metric_lines=metric_lines)
-
-
-@dataclass
-class StreamData:
-    response_content: str = ""
-    response_tool_calls: Optional[List[ChoiceDeltaToolCall]] = None
-
-
 @dataclass
 class Groq(Model):
     """
@@ -68,7 +35,7 @@ class Groq(Model):
     For more information, see: https://console.groq.com/docs/libraries
     """
 
-    id: str = "llama3-groq-70b-8192-tool-use-preview"
+    id: str = "llama-3.3-70b-versatile"
     name: str = "Groq"
     provider: str = "Groq"
 
@@ -78,7 +45,6 @@ class Groq(Model):
     logprobs: Optional[bool] = None
     max_tokens: Optional[int] = None
     presence_penalty: Optional[float] = None
-    response_format: Optional[Dict[str, Any]] = None
     seed: Optional[int] = None
     stop: Optional[Union[str, List[str]]] = None
     temperature: Optional[float] = None
@@ -96,115 +62,134 @@ class Groq(Model):
     max_retries: Optional[int] = None
     default_headers: Optional[Any] = None
     default_query: Optional[Any] = None
-    http_client: Optional[httpx.Client] = None
+    http_client: Optional[Union[httpx.Client, httpx.AsyncClient]] = None
     client_params: Optional[Dict[str, Any]] = None
 
     # Groq clients
     client: Optional[GroqClient] = None
     async_client: Optional[AsyncGroqClient] = None
 
-    def get_client_params(self) -> Dict[str, Any]:
-        self.api_key = self.api_key or getenv("GROQ_API_KEY")
+    def _get_client_params(self) -> Dict[str, Any]:
+        # Fetch API key from env if not already set
         if not self.api_key:
-            logger.error("GROQ_API_KEY not set. Please set the GROQ_API_KEY environment variable.")
-
-        client_params: Dict[str, Any] = {}
-        if self.api_key:
-            client_params["api_key"] = self.api_key
-        if self.base_url:
-            client_params["base_url"] = self.base_url
-        if self.timeout:
-            client_params["timeout"] = self.timeout
-        if self.max_retries:
-            client_params["max_retries"] = self.max_retries
-        if self.default_headers:
-            client_params["default_headers"] = self.default_headers
-        if self.default_query:
-            client_params["default_query"] = self.default_query
+            self.api_key = getenv("GROQ_API_KEY")
+            if not self.api_key:
+                raise ModelAuthenticationError(
+                    message="GROQ_API_KEY not set. Please set the GROQ_API_KEY environment variable.",
+                    model_name=self.name,
+                )
+
+        # Define base client params
+        base_params = {
+            "api_key": self.api_key,
+            "base_url": self.base_url,
+            "timeout": self.timeout,
+            "max_retries": self.max_retries,
+            "default_headers": self.default_headers,
+            "default_query": self.default_query,
+        }
+        # Create client_params dict with non-None values
+        client_params = {k: v for k, v in base_params.items() if v is not None}
+        # Add additional client params if provided
         if self.client_params:
             client_params.update(self.client_params)
         return client_params
 
     def get_client(self) -> GroqClient:
         """
-        Returns a Groq client.
+        Returns a Groq client. Caches the client to avoid recreating it on every request.
 
         Returns:
             GroqClient: An instance of the Groq client.
         """
-        if self.client:
+        if self.client and not self.client.is_closed():
             return self.client
 
-        client_params: Dict[str, Any] = self.get_client_params()
+        client_params: Dict[str, Any] = self._get_client_params()
         if self.http_client is not None:
-            client_params["http_client"] = self.http_client
-        return GroqClient(**client_params)
+            if isinstance(self.http_client, httpx.Client):
+                client_params["http_client"] = self.http_client
+            else:
+                log_warning("http_client is not an instance of httpx.Client. Using default global httpx.Client.")
+                # Use global sync client when user http_client is invalid
+                client_params["http_client"] = get_default_sync_client()
+        else:
+            # Use global sync client when no custom http_client is provided
+            client_params["http_client"] = get_default_sync_client()
+
+        self.client = GroqClient(**client_params)
+        return self.client
 
     def get_async_client(self) -> AsyncGroqClient:
         """
-        Returns an asynchronous Groq client.
+        Returns an asynchronous Groq client. Caches the client to avoid recreating it on every request.
 
         Returns:
             AsyncGroqClient: An instance of the asynchronous Groq client.
         """
-        if self.async_client:
+        if self.async_client and not self.async_client.is_closed():
             return self.async_client
 
-        client_params: Dict[str, Any] = self.get_client_params()
+        client_params: Dict[str, Any] = self._get_client_params()
         if self.http_client:
-            client_params["http_client"] = self.http_client
+            if isinstance(self.http_client, httpx.AsyncClient):
+                client_params["http_client"] = self.http_client
+            else:
+                log_warning(
+                    "http_client is not an instance of httpx.AsyncClient. Using default global httpx.AsyncClient."
+                )
+                # Use global async client when user http_client is invalid
+                client_params["http_client"] = get_default_async_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 AsyncGroqClient(**client_params)
+            # Use global async client when no custom http_client is provided
+            client_params["http_client"] = get_default_async_client()
 
-    @property
-    def request_kwargs(self) -> Dict[str, Any]:
+        # Create and cache the client
+        self.async_client = AsyncGroqClient(**client_params)
+        return self.async_client
+
+    def get_request_params(
+        self,
+        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]:
         """
         Returns keyword arguments for API requests.
 
         Returns:
             Dict[str, Any]: A dictionary of keyword arguments for API requests.
         """
-        request_params: Dict[str, Any] = {}
-        if self.frequency_penalty:
-            request_params["frequency_penalty"] = self.frequency_penalty
-        if self.logit_bias:
-            request_params["logit_bias"] = self.logit_bias
-        if self.logprobs:
-            request_params["logprobs"] = self.logprobs
-        if self.max_tokens:
-            request_params["max_tokens"] = self.max_tokens
-        if self.presence_penalty:
-            request_params["presence_penalty"] = self.presence_penalty
-        if self.response_format:
-            request_params["response_format"] = self.response_format
-        if self.seed:
-            request_params["seed"] = self.seed
-        if self.stop:
-            request_params["stop"] = self.stop
-        if self.temperature:
-            request_params["temperature"] = self.temperature
-        if self.top_logprobs:
-            request_params["top_logprobs"] = self.top_logprobs
-        if self.top_p:
-            request_params["top_p"] = self.top_p
-        if self.user:
-            request_params["user"] = self.user
-        if self.extra_headers:
-            request_params["extra_headers"] = self.extra_headers
-        if self.extra_query:
-            request_params["extra_query"] = self.extra_query
-        if self.tools:
-            request_params["tools"] = self.tools
-            if self.tool_choice is None:
-                request_params["tool_choice"] = "auto"
-            else:
-                request_params["tool_choice"] = self.tool_choice
+        # Define base request parameters
+        base_params = {
+            "frequency_penalty": self.frequency_penalty,
+            "logit_bias": self.logit_bias,
+            "logprobs": self.logprobs,
+            "max_tokens": self.max_tokens,
+            "presence_penalty": self.presence_penalty,
+            "response_format": response_format,
+            "seed": self.seed,
+            "stop": self.stop,
+            "temperature": self.temperature,
+            "top_logprobs": self.top_logprobs,
+            "top_p": self.top_p,
+            "user": self.user,
+            "extra_headers": self.extra_headers,
+            "extra_query": self.extra_query,
+        }
+        # Filter out None values
+        request_params = {k: v for k, v in base_params.items() if v is not None}
+        # Add tools
+        if tools is not None:
+            request_params["tools"] = tools
+            if tool_choice is not None:
+                request_params["tool_choice"] = tool_choice
+        # Add additional request params if provided
         if self.request_params:
             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]:
@@ -214,15 +199,14 @@ class Groq(Model):
         Returns:
             Dict[str, Any]: The dictionary representation of the model.
         """
-        _dict = super().to_dict()
-        _dict.update(
+        model_dict = super().to_dict()
+        model_dict.update(
             {
                 "frequency_penalty": self.frequency_penalty,
                 "logit_bias": self.logit_bias,
                 "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,
@@ -231,631 +215,372 @@ class Groq(Model):
                 "user": self.user,
                 "extra_headers": self.extra_headers,
                 "extra_query": self.extra_query,
-                "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}
+        cleaned_dict = {k: v for k, v in model_dict.items() if v is not None}
         return cleaned_dict
 
-    def format_message(self, message: Message) -> Dict[str, Any]:
+    def format_message(
+        self,
+        message: Message,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+        compress_tool_results: bool = False,
+    ) -> Dict[str, Any]:
         """
-        Format a message into the format expected by OpenAI.
+        Format a message into the format expected by Groq.
 
         Args:
             message (Message): The message to format.
+            response_format: Optional response format specification.
+            compress_tool_results: Whether to compress tool results.
 
         Returns:
             Dict[str, Any]: The formatted message.
         """
-        if message.role == "user":
-            if message.images is not None:
-                message = self.add_images_to_message(message=message, images=message.images)
-            # TODO: Add audio support
-            # if message.audio is not None:
-            #     message = self.add_audio_to_message(message=message, audio=message.audio)
+        # 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
 
-        return message.to_dict()
+        message_dict: Dict[str, Any] = {
+            "role": message.role,
+            "content": content,
+            "name": message.name,
+            "tool_call_id": message.tool_call_id,
+            "tool_calls": message.tool_calls,
+        }
+        message_dict = {k: v for k, v in message_dict.items() if v is not None}
 
-    def invoke(self, messages: List[Message]) -> ChatCompletion:
-        """
-        Send a chat completion request to the Groq API.
+        if (
+            message.role == "system"
+            and isinstance(message.content, str)
+            and response_format is not None
+            and isinstance(response_format, dict)
+            and response_format.get("type") == "json_object"
+        ):
+            # This is required by Groq to ensure the model outputs in the correct format
+            message.content += "\n\nYour output should be in JSON format."
 
-        Args:
-            messages (List[Message]): A list of messages to send to the model.
+        if message.images is not None and len(message.images) > 0:
+            # Ignore non-string message content
+            # because we assume that the images/audio are already added to the message
+            if isinstance(message.content, str):
+                message_dict["content"] = [{"type": "text", "text": message.content}]
+                message_dict["content"].extend(images_to_message(images=message.images))
 
-        Returns:
-            ChatCompletion: The chat completion response from the API.
-        """
-        return self.get_client().chat.completions.create(
-            model=self.id,
-            messages=[self.format_message(m) for m in messages],  # type: ignore
-            **self.request_kwargs,
-        )
+        if message.files is not None and len(message.files) > 0:
+            log_warning("File input is currently unsupported.")
 
-    async def ainvoke(self, messages: List[Message]) -> ChatCompletion:
-        """
-        Sends an asynchronous chat completion request to the Groq 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.videos is not None and len(message.videos) > 0:
+            log_warning("Video input is currently unsupported.")
 
-        Returns:
-            ChatCompletion: The chat completion response from the API.
-        """
-        return await self.get_async_client().chat.completions.create(
-            model=self.id,
-            messages=[self.format_message(m) for m in messages],  # type: ignore
-            **self.request_kwargs,
-        )
+        return message_dict
 
-    def invoke_stream(self, messages: List[Message]) -> Iterator[ChatCompletionChunk]:
+    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:
         """
-        Send a streaming chat completion request to the Groq API.
-
-        Args:
-            messages (List[Message]): A list of messages to send to the model.
-
-        Returns:
-            Iterator[ChatCompletionChunk]: An iterator of chat completion chunks.
+        Send a chat completion request to the Groq API.
         """
-        yield from self.get_client().chat.completions.create(
-            model=self.id,
-            messages=[self.format_message(m) for m in messages],  # type: ignore
-            stream=True,
-            **self.request_kwargs,
-        )
+        try:
+            if run_response and run_response.metrics:
+                run_response.metrics.set_time_to_first_token()
 
-    async def ainvoke_stream(self, messages: List[Message]) -> Any:
-        """
-        Sends an asynchronous streaming chat completion request to the Groq API.
+            assistant_message.metrics.start_timer()
+            provider_response = self.get_client().chat.completions.create(
+                model=self.id,
+                messages=[self.format_message(m, response_format, compress_tool_results) for m in messages],  # type: ignore
+                **self.get_request_params(response_format=response_format, tools=tools, tool_choice=tool_choice),
+            )
+            assistant_message.metrics.stop_timer()
 
-        Args:
-            messages (List[Message]): A list of messages to send to the model.
+            model_response = self._parse_provider_response(provider_response, response_format=response_format)
 
-        Returns:
-            Any: An asynchronous iterator of chat completion chunks.
-        """
-        async_stream = await self.get_async_client().chat.completions.create(
-            model=self.id,
-            messages=[self.format_message(m) for m in messages],  # type: ignore
-            stream=True,
-            **self.request_kwargs,
-        )
-        async for chunk in async_stream:  # type: ignore
-            yield chunk
+            return model_response
 
-    def handle_tool_calls(
+        except (APIResponseValidationError, APIStatusError) as e:
+            log_error(f"Error calling Groq API: {str(e)}")
+            raise ModelProviderError(
+                message=e.response.text, status_code=e.response.status_code, model_name=self.name, model_id=self.id
+            ) from e
+        except APIError as e:
+            log_error(f"Error calling Groq API: {str(e)}")
+            raise ModelProviderError(message=e.message, model_name=self.name, model_id=self.id) from e
+        except Exception as e:
+            log_error(f"Unexpected error calling Groq API: {str(e)}")
+            raise ModelProviderError(message=str(e), model_name=self.name, model_id=self.id) from e
+
+    async def ainvoke(
         self,
-        assistant_message: Message,
         messages: List[Message],
-        model_response: ModelResponse,
-        tool_role: str = "tool",
-    ) -> Optional[ModelResponse]:
+        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.
-            tool_role (str): The role of the tool call. Defaults to "tool".
-
-        Returns:
-            Optional[ModelResponse]: The model response after handling tool calls.
+        Sends an asynchronous chat completion request to the Groq API.
         """
-        if assistant_message.tool_calls is not None and len(assistant_message.tool_calls) > 0:
-            if model_response.content is None:
-                model_response.content = ""
-            if model_response.tool_calls is None:
-                model_response.tool_calls = []
-            function_call_results: List[Message] = []
-            function_calls_to_run: List[FunctionCall] = []
-            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 function_call_response in self.run_function_calls(
-                function_calls=function_calls_to_run, function_call_results=function_call_results, tool_role=tool_role
-            ):
-                if (
-                    function_call_response.event == ModelResponseEvent.tool_call_completed.value
-                    and function_call_response.tool_calls is not None
-                ):
-                    model_response.tool_calls.extend(function_call_response.tool_calls)
+        try:
+            if run_response and run_response.metrics:
+                run_response.metrics.set_time_to_first_token()
+
+            assistant_message.metrics.start_timer()
+            response = await self.get_async_client().chat.completions.create(
+                model=self.id,
+                messages=[self.format_message(m, response_format, compress_tool_results) for m in messages],  # type: ignore
+                **self.get_request_params(response_format=response_format, tools=tools, tool_choice=tool_choice),
+            )
+            assistant_message.metrics.stop_timer()
 
-            if len(function_call_results) > 0:
-                messages.extend(function_call_results)
+            model_response = self._parse_provider_response(response, response_format=response_format)
 
             return model_response
-        return None
-
-    def update_usage_metrics(
-        self, assistant_message: Message, metrics: Metrics, response_usage: Optional[CompletionUsage]
-    ) -> None:
-        """
-        Update the usage metrics for the assistant message and the model.
 
-        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.completion_time is not None:
-                metrics.completion_time = response_usage.completion_time
-                assistant_message.metrics["completion_time"] = response_usage.completion_time
-                self.metrics["completion_time"] = (
-                    self.metrics.get("completion_time", 0) + response_usage.completion_time
-                )
-            if response_usage.prompt_time is not None:
-                metrics.prompt_time = response_usage.prompt_time
-                assistant_message.metrics["prompt_time"] = response_usage.prompt_time
-                self.metrics["prompt_time"] = self.metrics.get("prompt_time", 0) + response_usage.prompt_time
-            if response_usage.queue_time is not None:
-                metrics.queue_time = response_usage.queue_time
-                assistant_message.metrics["queue_time"] = response_usage.queue_time
-                self.metrics["queue_time"] = self.metrics.get("queue_time", 0) + response_usage.queue_time
-            if response_usage.total_time is not None:
-                metrics.total_time = response_usage.total_time
-                assistant_message.metrics["total_time"] = response_usage.total_time
-                self.metrics["total_time"] = self.metrics.get("total_time", 0) + response_usage.total_time
-
-    def create_assistant_message(
+        except (APIResponseValidationError, APIStatusError) as e:
+            log_error(f"Error calling Groq API: {str(e)}")
+            raise ModelProviderError(
+                message=e.response.text, status_code=e.response.status_code, model_name=self.name, model_id=self.id
+            ) from e
+        except APIError as e:
+            log_error(f"Error calling Groq API: {str(e)}")
+            raise ModelProviderError(message=e.message, model_name=self.name, model_id=self.id) from e
+        except Exception as e:
+            log_error(f"Unexpected error calling Groq API: {str(e)}")
+            raise ModelProviderError(message=str(e), model_name=self.name, model_id=self.id) from e
+
+    def invoke_stream(
         self,
-        response_message: ChatCompletionMessage,
-        metrics: Metrics,
-        response_usage: Optional[CompletionUsage],
-    ) -> 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,
+    ) -> Iterator[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.
+        Send a streaming chat completion request to the Groq API.
         """
-        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:
-            try:
-                assistant_message.tool_calls = [t.model_dump() for t in response_message.tool_calls]
-            except Exception as e:
-                logger.warning(f"Error processing tool calls: {e}")
+        try:
+            if run_response and run_response.metrics:
+                run_response.metrics.set_time_to_first_token()
 
-        # Update metrics
-        self.update_usage_metrics(assistant_message, metrics, response_usage)
-        return assistant_message
+            assistant_message.metrics.start_timer()
 
-    def response(self, messages: List[Message]) -> ModelResponse:
+            for chunk in self.get_client().chat.completions.create(
+                model=self.id,
+                messages=[self.format_message(m, response_format, compress_tool_results) for m in messages],  # type: ignore
+                stream=True,
+                **self.get_request_params(response_format=response_format, tools=tools, tool_choice=tool_choice),
+            ):
+                yield self._parse_provider_response_delta(chunk)  # type: ignore
+
+            assistant_message.metrics.stop_timer()
+
+        except (APIResponseValidationError, APIStatusError) as e:
+            log_error(f"Error calling Groq API: {str(e)}")
+            raise ModelProviderError(
+                message=e.response.text, status_code=e.response.status_code, model_name=self.name, model_id=self.id
+            ) from e
+        except APIError as e:
+            log_error(f"Error calling Groq API: {str(e)}")
+            raise ModelProviderError(message=e.message, model_name=self.name, model_id=self.id) from e
+        except Exception as e:
+            log_error(f"Unexpected error calling Groq 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],
+        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[ModelResponse]:
         """
-        Generate a response from Groq.
-
-        Args:
-            messages (List[Message]): A list of messages.
-
-        Returns:
-            ModelResponse: The model response.
+        Sends an asynchronous streaming chat completion request to the Groq API.
         """
-        logger.debug("---------- Groq Response Start ----------")
-        self._log_messages(messages)
-        model_response = ModelResponse()
-        metrics = Metrics()
 
-        # -*- Generate response
-        metrics.start_response_timer()
-        response: ChatCompletion = self.invoke(messages=messages)
-        metrics.stop_response_timer()
+        try:
+            if run_response and run_response.metrics:
+                run_response.metrics.set_time_to_first_token()
 
-        # -*- Parse response
-        response_message: ChatCompletionMessage = response.choices[0].message
-        response_usage: Optional[CompletionUsage] = response.usage
+            assistant_message.metrics.start_timer()
 
-        # -*- Create assistant message
-        assistant_message = self.create_assistant_message(
-            response_message=response_message, metrics=metrics, response_usage=response_usage
-        )
+            async_stream = await self.get_async_client().chat.completions.create(
+                model=self.id,
+                messages=[self.format_message(m, response_format, compress_tool_results) for m in messages],  # type: ignore
+                stream=True,
+                **self.get_request_params(response_format=response_format, tools=tools, tool_choice=tool_choice),
+            )
+            async for chunk in async_stream:  # type: ignore
+                yield self._parse_provider_response_delta(chunk)  # type: ignore
 
-        # -*- Add assistant message to messages
-        messages.append(assistant_message)
+            assistant_message.metrics.stop_timer()
 
-        # -*- Log response and metrics
-        assistant_message.log()
-        metrics.log()
+        except (APIResponseValidationError, APIStatusError) as e:
+            log_error(f"Error calling Groq API: {str(e)}")
+            raise ModelProviderError(
+                message=e.response.text, status_code=e.response.status_code, model_name=self.name, model_id=self.id
+            ) from e
+        except APIError as e:
+            log_error(f"Error calling Groq API: {str(e)}")
+            raise ModelProviderError(message=e.message, model_name=self.name, model_id=self.id) from e
+        except Exception as e:
+            log_error(f"Unexpected error calling Groq API: {str(e)}")
+            raise ModelProviderError(message=str(e), model_name=self.name, model_id=self.id) from e
 
-        # -*- Update model response with assistant message content and audio
-        if assistant_message.content is not None:
-            # add the content to the model response
-            model_response.content = assistant_message.get_content_string()
+    # Override base method
+    @staticmethod
+    def parse_tool_calls(tool_calls_data: List[ChoiceDeltaToolCall]) -> List[Dict[str, Any]]:
+        """
+        Build tool calls from streamed tool call data.
 
-        # -*- Handle tool calls
-        tool_role = "tool"
-        if (
-            self.handle_tool_calls(
-                assistant_message=assistant_message,
-                messages=messages,
-                model_response=model_response,
-                tool_role=tool_role,
-            )
-            is not None
-        ):
-            return self.handle_post_tool_call_messages(messages=messages, model_response=model_response)
-        logger.debug("---------- Groq Response End ----------")
-        return model_response
+        Args:
+            tool_calls_data (List[ChoiceDeltaToolCall]): The tool call data to build from.
 
-    async def aresponse(self, messages: List[Message]) -> ModelResponse:
+        Returns:
+            List[Dict[str, Any]]: The built tool calls.
         """
-        Generate an asynchronous response from Groq.
+        tool_calls: List[Dict[str, Any]] = []
+        for _tool_call in tool_calls_data:
+            _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: ChatCompletion, **kwargs) -> ModelResponse:
+        """
+        Parse the Groq response into a ModelResponse.
 
         Args:
-            messages (List[Message]): A list of messages.
+            response: Raw response from Groq
 
         Returns:
-            ModelResponse: The model response from the API.
+            ModelResponse: Parsed response data
         """
-        logger.debug("---------- Groq Async Response Start ----------")
-        self._log_messages(messages)
         model_response = ModelResponse()
-        metrics = Metrics()
 
-        # -*- Generate response
-        metrics.start_response_timer()
-        response: ChatCompletion = await self.ainvoke(messages=messages)
-        metrics.stop_response_timer()
+        # Get response message
+        response_message = response.choices[0].message
 
-        # -*- Parse response
-        response_message: ChatCompletionMessage = response.choices[0].message
-        response_usage: Optional[CompletionUsage] = response.usage
+        # Add role
+        if response_message.role is not None:
+            model_response.role = response_message.role
 
-        # -*- Create assistant message
-        assistant_message = self.create_assistant_message(
-            response_message=response_message, metrics=metrics, response_usage=response_usage
-        )
+        # Add content
+        if response_message.content is not None:
+            model_response.content = response_message.content
 
-        # -*- Add assistant message to messages
-        messages.append(assistant_message)
-
-        # -*- Log response and metrics
-        assistant_message.log()
-        metrics.log()
+        # Add tool calls
+        if response_message.tool_calls is not None and len(response_message.tool_calls) > 0:
+            try:
+                model_response.tool_calls = [t.model_dump() for t in response_message.tool_calls]
+            except Exception as e:
+                log_warning(f"Error processing tool calls: {e}")
 
-        # -*- Update model response with assistant message content and audio
-        if assistant_message.content is not None:
-            # add the content to the model response
-            model_response.content = assistant_message.get_content_string()
+        # Add usage metrics if present
+        if response.usage is not None:
+            model_response.response_usage = self._get_metrics(response.usage)
 
-        # -*- Handle tool calls
-        tool_role = "tool"
-        if (
-            self.handle_tool_calls(
-                assistant_message=assistant_message,
-                messages=messages,
-                model_response=model_response,
-                tool_role=tool_role,
-            )
-            is not None
-        ):
-            return await self.ahandle_post_tool_call_messages(messages=messages, model_response=model_response)
-
-        logger.debug("---------- Groq Async Response End ----------")
         return model_response
 
-    def update_stream_metrics(self, assistant_message: Message, metrics: Metrics):
-        """
-        Update the usage metrics for the assistant message and the model.
-
-        Args:
-            assistant_message (Message): The assistant message.
-            metrics (Metrics): The metrics.
+    def _parse_provider_response_delta(self, response: ChatCompletionChunk) -> ModelResponse:
         """
-        # 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.completion_time is not None:
-            assistant_message.metrics["completion_time"] = metrics.completion_time
-            self.metrics["completion_time"] = self.metrics.get("completion_time", 0) + metrics.completion_time
-        if metrics.prompt_time is not None:
-            assistant_message.metrics["prompt_time"] = metrics.prompt_time
-            self.metrics["prompt_time"] = self.metrics.get("prompt_time", 0) + metrics.prompt_time
-        if metrics.queue_time is not None:
-            assistant_message.metrics["queue_time"] = metrics.queue_time
-            self.metrics["queue_time"] = self.metrics.get("queue_time", 0) + metrics.queue_time
-        if metrics.total_time is not None:
-            assistant_message.metrics["total_time"] = metrics.total_time
-            self.metrics["total_time"] = self.metrics.get("total_time", 0) + metrics.total_time
-
-    def add_response_usage_to_metrics(self, metrics: Metrics, response_usage: CompletionUsage):
-        metrics.input_tokens = response_usage.prompt_tokens
-        metrics.prompt_tokens = response_usage.prompt_tokens
-        metrics.output_tokens = response_usage.completion_tokens
-        metrics.completion_tokens = response_usage.completion_tokens
-        metrics.total_tokens = response_usage.total_tokens
-        metrics.completion_time = response_usage.completion_time
-        metrics.prompt_time = response_usage.prompt_time
-        metrics.queue_time = response_usage.queue_time
-        metrics.total_time = response_usage.total_time
-
-    def handle_stream_tool_calls(
-        self,
-        assistant_message: Message,
-        messages: List[Message],
-        tool_role: str = "tool",
-    ) -> Iterator[ModelResponse]:
-        """
-        Handle tool calls for response stream.
+        Parse the Groq streaming response into ModelResponse objects.
 
         Args:
-            assistant_message (Message): The assistant message.
-            messages (List[Message]): The list of messages.
-            tool_role (str): The role of the tool call. Defaults to "tool".
+            response: Raw response chunk from Groq
 
         Returns:
-            Iterator[ModelResponse]: An iterator of the model response.
+            ModelResponse: Iterator of parsed response data
         """
-        if assistant_message.tool_calls is not None and len(assistant_message.tool_calls) > 0:
-            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 function_call_response in self.run_function_calls(
-                function_calls=function_calls_to_run, function_call_results=function_call_results, tool_role=tool_role
-            ):
-                yield function_call_response
-
-            if len(function_call_results) > 0:
-                messages.extend(function_call_results)
+        model_response = ModelResponse()
 
-    def response_stream(self, messages: List[Message]) -> Iterator[ModelResponse]:
-        """
-        Generate a streaming response from Groq.
+        if len(response.choices) > 0:
+            choice_delta: ChoiceDelta = response.choices[0].delta
 
-        Args:
-            messages (List[Message]): A list of messages.
+            if choice_delta:
+                # Add content
+                if choice_delta.content is not None:
+                    model_response.content = choice_delta.content
 
-        Returns:
-            Iterator[ModelResponse]: An iterator of model responses.
-        """
-        logger.debug("---------- Groq Response Start ----------")
-        self._log_messages(messages)
-        stream_data: StreamData = StreamData()
-        metrics: Metrics = Metrics()
-
-        # -*- Generate response
-        metrics.start_response_timer()
-        for response in self.invoke_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: ChoiceDelta = response.choices[0].delta
-                response_content: Optional[str] = response_delta.content
-                response_tool_calls: Optional[List[ChoiceDeltaToolCall]] = 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)
-
-            if response.usage is not None:
-                self.add_response_usage_to_metrics(metrics=metrics, response_usage=response.usage)
-        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
-
-        # -*- Update usage metrics
-        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:
-            tool_role = "tool"
-            yield from self.handle_stream_tool_calls(
-                assistant_message=assistant_message, messages=messages, tool_role=tool_role
-            )
-            yield from self.handle_post_tool_call_messages_stream(messages=messages)
-        logger.debug("---------- Groq Response End ----------")
-
-    async def aresponse_stream(self, messages: List[Message]) -> Any:
-        """
-        Generate an asynchronous streaming response from Groq.
+                # Add tool calls
+                if choice_delta.tool_calls is not None:
+                    model_response.tool_calls = choice_delta.tool_calls  # type: ignore
 
-        Args:
-            messages (List[Message]): A list of messages.
+        # Add usage metrics if present
+        if response.x_groq is not None and response.x_groq.usage is not None:
+            model_response.response_usage = self._get_metrics(response.x_groq.usage)
 
-        Returns:
-            Any: An asynchronous iterator of model responses.
-        """
-        logger.debug("---------- Groq 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: ChoiceDelta = 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)
-
-            if response.usage is not None:
-                self.add_response_usage_to_metrics(metrics=metrics, response_usage=response.usage)
-        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:
-            tool_role = "tool"
-            for tool_call_response in self.handle_stream_tool_calls(
-                assistant_message=assistant_message, messages=messages, tool_role=tool_role
-            ):
-                yield tool_call_response
-            async for post_tool_call_response in self.ahandle_post_tool_call_messages_stream(messages=messages):
-                yield post_tool_call_response
-        logger.debug("---------- Groq Async Response End ----------")
+        return model_response
 
-    def build_tool_calls(self, tool_calls_data: List[ChoiceDeltaToolCall]) -> List[Dict[str, Any]]:
+    def _get_metrics(self, response_usage: CompletionUsage) -> Metrics:
         """
-        Build tool calls from tool call data.
+        Parse the given Groq usage into an Agno Metrics object.
 
         Args:
-            tool_calls_data (List[ChoiceDeltaToolCall]): The tool call data to build from.
+            response_usage: Usage data from Groq
 
         Returns:
-            List[Dict[str, Any]]: The built tool calls.
+            Metrics: Parsed metrics data
         """
-        return self._build_tool_calls(tool_calls_data)
+        metrics = Metrics()
+
+        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
+
+        # Additional time metrics offered by Groq
+        if completion_time := response_usage.completion_time:
+            metrics.provider_metrics = metrics.provider_metrics or {}
+            metrics.provider_metrics["completion_time"] = completion_time
+        if prompt_time := response_usage.prompt_time:
+            metrics.provider_metrics = metrics.provider_metrics or {}
+            metrics.provider_metrics["prompt_time"] = prompt_time
+        if queue_time := response_usage.queue_time:
+            metrics.provider_metrics = metrics.provider_metrics or {}
+            metrics.provider_metrics["queue_time"] = queue_time
+        if total_time := response_usage.total_time:
+            metrics.provider_metrics = metrics.provider_metrics or {}
+            metrics.provider_metrics["total_time"] = total_time
+
+        return metrics