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

agno/models/ollama/chat.py

@@ -1,34 +1,27 @@
 import json
-from dataclasses import asdict, dataclass, field
-from typing import Any, Dict, Iterator, List, Mapping, Optional, Union
+from dataclasses import dataclass, field
+from os import getenv
+from typing import Any, AsyncIterator, Dict, Iterator, List, Optional, Type, Union
 
 from pydantic import BaseModel
 
-from agno.models.base import Metrics, Model
+from agno.agent import RunOutput
+from agno.models.base import Model
 from agno.models.message import Message
-from agno.models.response import ModelResponse, ModelResponseEvent
-from agno.utils.log import logger
+from agno.models.metrics import Metrics
+from agno.models.response import ModelResponse
+from agno.utils.log import log_debug, log_warning
+from agno.utils.reasoning import extract_thinking_content
 
 try:
     from ollama import AsyncClient as AsyncOllamaClient
     from ollama import Client as OllamaClient
-except (ModuleNotFoundError, ImportError):
+    from ollama._types import ChatResponse
+    from ollama._types import Message as OllamaMessage
+except ImportError:
     raise ImportError("`ollama` not installed. Please install using `pip install ollama`")
 
 
-@dataclass
-class MessageData:
-    response_role: Optional[str] = None
-    response_message: Optional[Dict[str, Any]] = None
-    response_content: Any = ""
-    response_content_chunk: str = ""
-    tool_calls: List[Dict[str, Any]] = field(default_factory=list)
-    tool_call_blocks: Any = field(default_factory=list)
-    tool_call_chunk: str = ""
-    in_tool_call: bool = False
-    response_usage: Optional[Mapping[str, Any]] = None
-
-
 @dataclass
 class Ollama(Model):
     """
@@ -40,7 +33,8 @@ class Ollama(Model):
     id: str = "llama3.1"
     name: str = "Ollama"
     provider: str = "Ollama"
-    supports_structured_outputs: bool = True
+
+    supports_native_structured_outputs: bool = True
 
     # Request parameters
     format: Optional[Any] = None
@@ -51,23 +45,35 @@ class Ollama(Model):
     # Client parameters
     host: Optional[str] = None
     timeout: Optional[Any] = None
+    api_key: Optional[str] = field(default_factory=lambda: getenv("OLLAMA_API_KEY"))
     client_params: Optional[Dict[str, Any]] = None
 
     # Ollama clients
     client: Optional[OllamaClient] = None
     async_client: Optional[AsyncOllamaClient] = None
 
-    # Internal parameters. Not used for API requests
-    # Whether to use the structured outputs with this Model.
-    structured_outputs: bool = False
-
-    def get_client_params(self) -> Dict[str, Any]:
-        client_params: Dict[str, Any] = {}
-        if self.host is not None:
-            client_params["host"] = self.host
-        if self.timeout is not None:
-            client_params["timeout"] = self.timeout
-        if self.client_params is not None:
+    def _get_client_params(self) -> Dict[str, Any]:
+        host = self.host
+        headers = {}
+
+        if self.api_key:
+            if not host:
+                host = "https://ollama.com"
+            headers["authorization"] = f"Bearer {self.api_key}"
+            log_debug(f"Using Ollama cloud endpoint: {host}")
+
+        base_params = {
+            "host": host,
+            "timeout": self.timeout,
+        }
+
+        if headers:
+            base_params["headers"] = headers
+
+        # 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
 
@@ -81,7 +87,8 @@ class Ollama(Model):
         if self.client is not None:
             return self.client
 
-        return OllamaClient(**self.get_client_params())
+        self.client = OllamaClient(**self._get_client_params())
+        return self.client
 
     def get_async_client(self) -> AsyncOllamaClient:
         """
@@ -93,32 +100,32 @@ class Ollama(Model):
         if self.async_client is not None:
             return self.async_client
 
-        return AsyncOllamaClient(**self.get_client_params())
+        self.async_client = AsyncOllamaClient(**self._get_client_params())
+        return self.async_client
 
-    @property
-    def request_kwargs(self) -> Dict[str, Any]:
+    def get_request_params(
+        self,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Dict[str, Any]:
         """
         Returns keyword arguments for API requests.
 
         Returns:
             Dict[str, Any]: The API kwargs for the model.
         """
-        request_params: Dict[str, Any] = {}
-        if self.format is not None:
-            request_params["format"] = self.format
-        if self.options is not None:
-            request_params["options"] = self.options
-        if self.keep_alive is not None:
-            request_params["keep_alive"] = self.keep_alive
-        if self.tools is not None:
-            request_params["tools"] = self.tools
-            # Ensure types are valid strings
-            for tool in request_params["tools"]:
-                for prop, obj in tool["function"]["parameters"]["properties"].items():
-                    if isinstance(obj["type"], list):
-                        obj["type"] = obj["type"][0]
-        if self.request_params is not None:
+        base_params = {"format": self.format, "options": self.options, "keep_alive": self.keep_alive}
+        # 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 and len(tools) > 0:
+            request_params["tools"] = tools
+
+        # 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]:
@@ -140,226 +147,232 @@ class Ollama(Model):
         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, compress_tool_results: bool = False) -> Dict[str, Any]:
         """
         Format a message into the format expected by Ollama.
 
         Args:
             message (Message): The message to format.
+            compress_tool_results: Whether to compress tool results.
 
         Returns:
             Dict[str, Any]: The formatted message.
         """
+        # 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
+
         _message: Dict[str, Any] = {
             "role": message.role,
-            "content": message.content,
+            "content": content,
         }
+
+        if message.role == "assistant" and message.tool_calls is not None:
+            # Format tool calls for assistant messages
+            formatted_tool_calls = []
+            for tool_call in message.tool_calls:
+                if "function" in tool_call:
+                    function_data = tool_call["function"]
+                    formatted_tool_call = {
+                        "id": tool_call.get("id"),
+                        "type": "function",
+                        "function": {
+                            "name": function_data["name"],
+                            "arguments": json.loads(function_data["arguments"])
+                            if isinstance(function_data["arguments"], str)
+                            else function_data["arguments"],
+                        },
+                    }
+                    formatted_tool_calls.append(formatted_tool_call)
+
+            if formatted_tool_calls:
+                _message["tool_calls"] = formatted_tool_calls
+
         if message.role == "user":
             if message.images is not None:
                 message_images = []
                 for image in message.images:
                     if image.url is not None:
-                        message_images.append(image.image_url_content)
+                        message_images.append(image.get_content_bytes())
                     if image.filepath is not None:
                         message_images.append(image.filepath)  # type: ignore
                     if image.content is not None and isinstance(image.content, bytes):
                         message_images.append(image.content)
                 if message_images:
                     _message["images"] = message_images
+
+            if message.audio is not None and len(message.audio) > 0:
+                log_warning("Audio input is currently unsupported.")
+
+            if message.files is not None and len(message.files) > 0:
+                log_warning("File input is currently unsupported.")
+
+            if message.videos is not None and len(message.videos) > 0:
+                log_warning("Video input is currently unsupported.")
+
         return _message
 
-    def _prepare_request_kwargs_for_invoke(self) -> Dict[str, Any]:
-        request_kwargs = self.request_kwargs
-        if self.response_format is not None and self.structured_outputs:
-            if isinstance(self.response_format, type) and issubclass(self.response_format, BaseModel):
-                logger.debug("Using structured outputs")
-                format_schema = self.response_format.model_json_schema()
-                if "format" not in request_kwargs:
-                    request_kwargs["format"] = format_schema
+    def _prepare_request_kwargs_for_invoke(
+        self,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Dict[str, Any]:
+        request_kwargs = self.get_request_params(tools=tools)
+        if response_format is not None and isinstance(response_format, type) and issubclass(response_format, BaseModel):
+            log_debug("Using structured outputs")
+            format_schema = response_format.model_json_schema()
+            if "format" not in request_kwargs:
+                request_kwargs["format"] = format_schema
         return request_kwargs
 
-    def invoke(self, messages: List[Message]) -> Mapping[str, Any]:
+    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 chat request to the Ollama API.
+        """
+        request_kwargs = self._prepare_request_kwargs_for_invoke(response_format=response_format, tools=tools)
 
-        Args:
-            messages (List[Message]): A list of messages to send to the model.
+        if run_response and run_response.metrics:
+            run_response.metrics.set_time_to_first_token()
 
-        Returns:
-            Mapping[str, Any]: The response from the API.
-        """
-        request_kwargs = self._prepare_request_kwargs_for_invoke()
+        assistant_message.metrics.start_timer()
 
-        return self.get_client().chat(
+        provider_response = self.get_client().chat(
             model=self.id.strip(),
-            messages=[self.format_message(m) for m in messages],  # type: ignore
+            messages=[self._format_message(m, compress_tool_results) for m in messages],  # type: ignore
             **request_kwargs,
         )  # type: ignore
 
-    async def ainvoke(self, messages: List[Message]) -> Mapping[str, Any]:
+        assistant_message.metrics.stop_timer()
+
+        model_response = self._parse_provider_response(provider_response)  # type: ignore
+        return model_response
+
+    async def ainvoke(
+        self,
+        messages: List[Message],
+        assistant_message: Message,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+        tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+        run_response: Optional[RunOutput] = None,
+        compress_tool_results: bool = False,
+    ) -> ModelResponse:
         """
         Sends an asynchronous chat request to the Ollama API.
+        """
+        request_kwargs = self._prepare_request_kwargs_for_invoke(response_format=response_format, tools=tools)
 
-        Args:
-            messages (List[Message]): A list of messages to send to the model.
+        if run_response and run_response.metrics:
+            run_response.metrics.set_time_to_first_token()
 
-        Returns:
-            Mapping[str, Any]: The response from the API.
-        """
-        request_kwargs = self._prepare_request_kwargs_for_invoke()
+        assistant_message.metrics.start_timer()
 
-        return await self.get_async_client().chat(
+        provider_response = await self.get_async_client().chat(
             model=self.id.strip(),
-            messages=[self.format_message(m) for m in messages],  # type: ignore
+            messages=[self._format_message(m, compress_tool_results) for m in messages],  # type: ignore
             **request_kwargs,
         )  # type: ignore
 
-    def invoke_stream(self, messages: List[Message]) -> Iterator[Mapping[str, Any]]:
-        """
-        Sends a streaming chat request to the Ollama API.
+        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)  # type: ignore
+        return model_response
 
-        Returns:
-            Iterator[Mapping[str, Any]]: An iterator of chunks from the API.
+    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]:
         """
-        yield from self.get_client().chat(
-            model=self.id,
-            messages=[self.format_message(m) for m in messages],  # type: ignore
-            stream=True,
-            **self.request_kwargs,
-        )  # type: ignore
-
-    async def ainvoke_stream(self, messages: List[Message]) -> Any:
+        Sends a streaming chat request to the Ollama API.
         """
-        Sends an asynchronous streaming chat completion request to the Ollama API.
+        if run_response and run_response.metrics:
+            run_response.metrics.set_time_to_first_token()
 
-        Args:
-            messages (List[Message]): A list of messages to send to the model.
+        assistant_message.metrics.start_timer()
 
-        Returns:
-            Any: An asynchronous iterator of chunks from the API.
-        """
-        async_stream = await self.get_async_client().chat(
-            model=self.id.strip(),
-            messages=[self.format_message(m) for m in messages],  # type: ignore
+        for chunk in self.get_client().chat(
+            model=self.id,
+            messages=[self._format_message(m, compress_tool_results) for m in messages],  # type: ignore
             stream=True,
-            **self.request_kwargs,
-        )
-        async for chunk in async_stream:  # type: ignore
-            yield chunk
+            **self.get_request_params(tools=tools),
+        ):
+            yield self._parse_provider_response_delta(chunk)
 
-    def handle_tool_calls(
+        assistant_message.metrics.stop_timer()
+
+    async def ainvoke_stream(
         self,
-        assistant_message: Message,
         messages: List[Message],
-        model_response: ModelResponse,
-    ) -> 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,
+    ) -> AsyncIterator[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.
+        Sends an asynchronous streaming chat completion request to the Ollama API.
         """
-        if assistant_message.tool_calls is not None and len(assistant_message.tool_calls) > 0:
-            if model_response.tool_calls is None:
-                model_response.tool_calls = []
+        if run_response and run_response.metrics:
+            run_response.metrics.set_time_to_first_token()
 
-            model_response.content = assistant_message.get_content_string()
-            model_response.content += "\n\n"
-            function_calls_to_run = self._get_function_calls_to_run(assistant_message, messages)
-            function_call_results: List[Message] = []
-
-            if self.show_tool_calls:
-                if len(function_calls_to_run) == 1:
-                    model_response.content += f" - Running: {function_calls_to_run[0].get_call_str()}\n\n"
-                elif len(function_calls_to_run) > 1:
-                    model_response.content += "Running:"
-                    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,
-            ):
-                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)
-
-            self.format_function_call_results(function_call_results, messages)
-
-            return model_response
-        return None
-
-    def update_usage_metrics(
-        self,
-        assistant_message: Message,
-        metrics: Metrics,
-        response: Optional[Mapping[str, Any]] = None,
-    ) -> None:
-        """
-        Update usage metrics for the assistant message.
+        assistant_message.metrics.start_timer()
 
-        Args:
-            assistant_message (Message): The assistant message.
-            metrics (Optional[Metrics]): The metrics for this response.
-            response (Optional[Mapping[str, Any]]): The response from Ollama.
-        """
-        # Update time taken to generate response
-        if response:
-            metrics.input_tokens = response.get("prompt_eval_count", 0)
-            metrics.output_tokens = response.get("eval_count", 0)
-            metrics.total_tokens = metrics.input_tokens + metrics.output_tokens
+        async for chunk in await self.get_async_client().chat(
+            model=self.id.strip(),
+            messages=[self._format_message(m, compress_tool_results) for m in messages],  # type: ignore
+            stream=True,
+            **self.get_request_params(tools=tools),
+        ):
+            yield self._parse_provider_response_delta(chunk)
 
-        self._update_model_metrics(metrics_for_run=metrics)
-        self._update_assistant_message_metrics(assistant_message=assistant_message, metrics_for_run=metrics)
+        assistant_message.metrics.stop_timer()
 
-    def format_function_call_results(self, function_call_results: List[Message], messages: List[Message]) -> None:
+    def _parse_provider_response(self, response: dict) -> ModelResponse:
         """
-        Format the function call results and append them to the messages.
-
-        Args:
-            function_call_results (List[Message]): The list of function call results.
-            messages (List[Message]): The list of messages.
+        Parse the provider response.
         """
-        if len(function_call_results) > 0:
-            for _fcr in function_call_results:
-                messages.append(_fcr)
+        model_response = ModelResponse()
+        # Get response message
+        response_message: OllamaMessage = response.get("message")  # type: ignore
 
-    def create_assistant_message(self, response: Mapping[str, Any], metrics: Metrics) -> Message:
-        """
-        Create an assistant message from the response.
+        if response_message.get("role") is not None:
+            model_response.role = response_message.get("role")
 
-        Args:
-            response: The response from Ollama.
-            metrics: The metrics for this response.
+        if response_message.get("content") is not None:
+            model_response.content = response_message.get("content")
 
-        Returns:
-            Message: The assistant message.
-        """
-        message_data = MessageData()
+        # Extract thinking content between <think> tags if present
+        if model_response.content and model_response.content.find("<think>") != -1:
+            reasoning_content, clean_content = extract_thinking_content(model_response.content)
 
-        message_data.response_message = response.get("message")
-        if message_data.response_message:
-            message_data.response_content = message_data.response_message.get("content")
-            message_data.response_role = message_data.response_message.get("role")
-            message_data.tool_call_blocks = message_data.response_message.get("tool_calls")
+            if reasoning_content:
+                # Store extracted thinking content separately
+                model_response.reasoning_content = reasoning_content
+                # Update main content with clean version
+                model_response.content = clean_content
 
-        assistant_message = Message(
-            role=message_data.response_role or "assistant",
-            content=message_data.response_content,
-        )
-        if message_data.tool_call_blocks is not None:
-            for block in message_data.tool_call_blocks:
+        if response_message.get("tool_calls") is not None:
+            if model_response.tool_calls is None:
+                model_response.tool_calls = []
+            for block in response_message.get("tool_calls", []):
                 tool_call = block.get("function")
                 tool_name = tool_call.get("name")
                 tool_args = tool_call.get("arguments")
@@ -368,320 +381,72 @@ class Ollama(Model):
                     "name": tool_name,
                     "arguments": (json.dumps(tool_args) if tool_args is not None else None),
                 }
-                message_data.tool_calls.append({"type": "function", "function": function_def})
-
-        if message_data.tool_calls is not None:
-            assistant_message.tool_calls = message_data.tool_calls
-
-        # TODO: Handle Audio
-
-        # Update metrics
-        self.update_usage_metrics(assistant_message=assistant_message, metrics=metrics, response=response)
-        return assistant_message
-
-    def _parse_structured_outputs(self, response: Mapping[str, Any], model_response: ModelResponse) -> None:
-        try:
-            if (
-                self.response_format is not None
-                and self.structured_outputs
-                and issubclass(self.response_format, BaseModel)
-            ):
-                parsed_object = self.response_format.model_validate_json(response.get("message", {}).get("content", ""))
-                if parsed_object is not None:
-                    model_response.parsed = parsed_object.model_dump_json()
-        except Exception as e:
-            logger.warning(f"Error parsing structured outputs: {e}")
-
-    def response(self, messages: List[Message]) -> ModelResponse:
-        """
-        Generate a response from Ollama.
+                model_response.tool_calls.append({"type": "function", "function": function_def})
 
-        Args:
-            messages (List[Message]): A list of messages.
+        # if response_message.get("images") is not None:
+        #     model_response.images = response_message.get("images")
 
-        Returns:
-            ModelResponse: The model response.
-        """
-        logger.debug("---------- Ollama Response Start ----------")
-        self._log_messages(messages)
-        model_response = ModelResponse()
-        metrics = Metrics()
+        # Get response usage
+        if response.get("done"):
+            model_response.response_usage = self._get_metrics(response)
 
-        # -*- Generate response
-        metrics.start_response_timer()
-        response: Mapping[str, Any] = self.invoke(messages=messages)
-        metrics.stop_response_timer()
-
-        # -*- Parse structured outputs
-        self._parse_structured_outputs(response=response, model_response=model_response)
-
-        # -*- Create assistant message
-        assistant_message = self.create_assistant_message(response=response, metrics=metrics)
-
-        # -*- Add assistant message to messages
-        messages.append(assistant_message)
-
-        # -*- Log response and metrics
-        assistant_message.log()
-        metrics.log()
-
-        # -*- 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()
-        # TODO: Handle audio
-        # if assistant_message.audio is not None:
-        #     # add the audio to the model response
-        #     model_response.audio = assistant_message.audio
-
-        # -*- Handle tool calls
-        if (
-            self.handle_tool_calls(
-                assistant_message=assistant_message,
-                messages=messages,
-                model_response=model_response,
-            )
-            is not None
-        ):
-            return self.handle_post_tool_call_messages(messages=messages, model_response=model_response)
-
-        logger.debug("---------- Ollama Response End ----------")
-        return model_response
-
-    async def aresponse(self, messages: List[Message]) -> ModelResponse:
-        """
-        Generate an asynchronous response from Ollama.
-
-        Args:
-            messages (List[Message]): A list of messages.
-
-        Returns:
-            ModelResponse: The model response.
-        """
-        logger.debug("---------- Ollama Async Response Start ----------")
-        self._log_messages(messages)
-        model_response = ModelResponse()
-        metrics = Metrics()
-
-        # -*- Generate response
-        metrics.start_response_timer()
-        response: Mapping[str, Any] = await self.ainvoke(messages=messages)
-        metrics.stop_response_timer()
-
-        # -*- Parse structured outputs
-        self._parse_structured_outputs(response=response, model_response=model_response)
-
-        # -*- Create assistant message
-        assistant_message = self.create_assistant_message(response=response, metrics=metrics)
-
-        # -*- Add assistant message to messages
-        messages.append(assistant_message)
-
-        # -*- Log response and metrics
-        assistant_message.log()
-        metrics.log()
-
-        # -*- 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()
-        # if assistant_message.audio is not None
-        #     # add the audio to the model response
-        #     model_response.audio = assistant_message.audio
-
-        # -*- Handle tool calls
-        if (
-            self.handle_tool_calls(
-                assistant_message=assistant_message,
-                messages=messages,
-                model_response=model_response,
-            )
-            is not None
-        ):
-            return await self.ahandle_post_tool_call_messages(messages=messages, model_response=model_response)
-
-        logger.debug("---------- Ollama Async Response End ----------")
         return model_response
 
-    def handle_stream_tool_calls(
-        self,
-        assistant_message: Message,
-        messages: List[Message],
-    ) -> Iterator[ModelResponse]:
+    def _parse_provider_response_delta(self, response: ChatResponse) -> ModelResponse:
         """
-        Handle tool calls for response stream.
+        Parse the provider response delta.
 
         Args:
-            assistant_message (Message): The assistant message.
-            messages (List[Message]): The list of messages.
+            response (ChatResponse): The response from the provider.
 
         Returns:
             Iterator[ModelResponse]: An iterator of the model response.
         """
-        if assistant_message.tool_calls is not None and len(assistant_message.tool_calls) > 0:
-            yield ModelResponse(content="\n\n")
-            function_calls_to_run = self._get_function_calls_to_run(assistant_message, messages)
-            function_call_results: List[Message] = []
-
-            if self.show_tool_calls:
-                if len(function_calls_to_run) == 1:
-                    yield ModelResponse(content=f" - Running: {function_calls_to_run[0].get_call_str()}\n\n")
-                elif len(function_calls_to_run) > 1:
-                    yield ModelResponse(content="Running:")
-                    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,
-            ):
-                yield intermediate_model_response
-
-            self.format_function_call_results(function_call_results, messages)
-
-    def response_stream(self, messages: List[Message]) -> Iterator[ModelResponse]:
-        """
-        Generate a streaming response from Ollama.
+        model_response = ModelResponse()
 
-        Args:
-            messages (List[Message]): A list of messages.
+        response_message = response.get("message")
 
-        Returns:
-            Iterator[ModelResponse]: An iterator of the model responses.
-        """
-        logger.debug("---------- Ollama Response Start ----------")
-        self._log_messages(messages)
-        message_data = MessageData()
-        metrics: Metrics = Metrics()
-
-        # -*- Generate response
-        metrics.start_response_timer()
-        for response in self.invoke_stream(messages=messages):
-            message_data.response_message = response.get("message", {})
-            if message_data.response_message:
-                metrics.output_tokens += 1
-                if metrics.output_tokens == 1:
-                    metrics.time_to_first_token = metrics.response_timer.elapsed
-
-                message_data.response_content_chunk = message_data.response_message.get("content", "")
-                if message_data.response_content_chunk is not None and message_data.response_content_chunk != "":
-                    message_data.response_content += message_data.response_content_chunk
-                    yield ModelResponse(content=message_data.response_content_chunk)
-
-                message_data.tool_call_blocks = message_data.response_message.get("tool_calls")  # type: ignore
-                if message_data.tool_call_blocks is not None:
-                    for block in message_data.tool_call_blocks:
-                        tool_call = block.get("function")
-                        tool_name = tool_call.get("name")
-                        tool_args = tool_call.get("arguments")
-                        function_def = {
-                            "name": tool_name,
-                            "arguments": json.dumps(tool_args) if tool_args is not None else None,
-                        }
-                        message_data.tool_calls.append({"type": "function", "function": function_def})
-
-            if response.get("done"):
-                message_data.response_usage = response
-        metrics.stop_response_timer()
-
-        # -*- Create assistant message
-        assistant_message = Message(role="assistant", content=message_data.response_content)
-
-        if len(message_data.tool_calls) > 0:
-            assistant_message.tool_calls = message_data.tool_calls
-
-        # -*- Update usage metrics
-        self.update_usage_metrics(
-            assistant_message=assistant_message, metrics=metrics, response=message_data.response_usage
-        )
+        if response_message is not None:
+            content_delta = response_message.get("content")
+            if content_delta is not None and content_delta != "":
+                model_response.content = content_delta
 
-        # -*- Add assistant message to messages
-        messages.append(assistant_message)
+            tool_calls = response_message.get("tool_calls")
+            if tool_calls is not None:
+                for tool_call in tool_calls:
+                    tc = tool_call.get("function")
+                    tool_name = tc.get("name")
+                    tool_args = tc.get("arguments")
+                    function_def = {
+                        "name": tool_name,
+                        "arguments": json.dumps(tool_args) if tool_args is not None else None,
+                    }
+                    model_response.tool_calls.append({"type": "function", "function": function_def})
 
-        # -*- Log response and metrics
-        assistant_message.log()
-        metrics.log()
+        if response.get("done"):
+            model_response.response_usage = self._get_metrics(response)
 
-        # -*- 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.handle_post_tool_call_messages_stream(messages=messages)
-        logger.debug("---------- Ollama Response End ----------")
+        return model_response
 
-    async def aresponse_stream(self, messages: List[Message]) -> Any:
+    def _get_metrics(self, response: Union[dict, ChatResponse]) -> Metrics:
         """
-        Generate an asynchronous streaming response from Ollama.
+        Parse the given Ollama usage into an Agno Metrics object.
 
         Args:
-            messages (List[Message]): A list of messages.
+            response: The response from the provider.
 
         Returns:
-            Any: An asynchronous iterator of the model responses.
+            Metrics: Parsed metrics data
         """
-        logger.debug("---------- Ollama Async Response Start ----------")
-        self._log_messages(messages)
-        message_data = MessageData()
-        metrics: Metrics = Metrics()
-
-        # -*- Generate response
-        metrics.start_response_timer()
-        async for response in self.ainvoke_stream(messages=messages):
-            message_data.response_message = response.get("message", {})
-            if message_data.response_message:
-                metrics.output_tokens += 1
-                if metrics.output_tokens == 1:
-                    metrics.time_to_first_token = metrics.response_timer.elapsed
-
-                message_data.response_content_chunk = message_data.response_message.get("content", "")
-                if message_data.response_content_chunk is not None and message_data.response_content_chunk != "":
-                    message_data.response_content += message_data.response_content_chunk
-                    yield ModelResponse(content=message_data.response_content_chunk)
-
-                message_data.tool_call_blocks = message_data.response_message.get("tool_calls")
-                if message_data.tool_call_blocks is not None:
-                    for block in message_data.tool_call_blocks:
-                        tool_call = block.get("function")
-                        tool_name = tool_call.get("name")
-                        tool_args = tool_call.get("arguments")
-                        function_def = {
-                            "name": tool_name,
-                            "arguments": json.dumps(tool_args) if tool_args is not None else None,
-                        }
-                        message_data.tool_calls.append({"type": "function", "function": function_def})
-
-            if response.get("done"):
-                message_data.response_usage = response
-        metrics.stop_response_timer()
-
-        # -*- Create assistant message
-        assistant_message = Message(role="assistant", content=message_data.response_content)
-
-        if len(message_data.tool_calls) > 0:
-            assistant_message.tool_calls = message_data.tool_calls
-
-        # -*- Update usage metrics
-        self.update_usage_metrics(
-            assistant_message=assistant_message, metrics=metrics, response=message_data.response_usage
-        )
-
-        # -*- Add assistant message to messages
-        messages.append(assistant_message)
-
-        # -*- Log response and metrics
-        assistant_message.log()
-        metrics.log()
+        metrics = Metrics()
 
-        # -*- Handle tool calls
-        if assistant_message.tool_calls is not None and len(assistant_message.tool_calls) > 0:
-            for tool_call_response in self.handle_stream_tool_calls(assistant_message, messages):
-                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("---------- Ollama Async Response End ----------")
+        # Safely handle None values from Ollama Cloud responses
+        input_tokens = response.get("prompt_eval_count")
+        output_tokens = response.get("eval_count")
 
-    def model_copy(self, *, update: Optional[Mapping[str, Any]] = None, deep: bool = False) -> "Ollama":
-        data = asdict(self)
-        data.pop("client", None)
+        # Default to 0 if None
+        metrics.input_tokens = input_tokens if input_tokens is not None else 0
+        metrics.output_tokens = output_tokens if output_tokens is not None else 0
+        metrics.total_tokens = metrics.input_tokens + metrics.output_tokens
 
-        return Ollama(client=self.client, **data)
+        return metrics