Python: Azure chat client (#185)

* updated openai, fcc works, with sample

* reduced files in openai

* Add azure chat client

* fix tests

* Update python/packages/main/tests/unit/test_openai_chat_completion_base.py

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* Update python/packages/azure/agent_framework/azure/__init__.py

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* Update python/packages/azure/agent_framework/azure/_azure_openai_settings.py

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* PR comments

* fix bad merge

* disable tests for now

* actually disable tests for azure

* fix tests, align test files with merge changes

* update code for new project structure

* PR comments

* add streaming integration tests. Fix flakiness

---------

Co-authored-by: eavanvalkenburg <github@vanvalkenburg.eu>
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

python/packages/main/agent_framework/__init__.py

@@ -10,7 +10,6 @@ except importlib.metadata.PackageNotFoundError:
     __version__ = "0.0.0"  # Fallback for development mode
 
 _IMPORTS = {
-    "get_logger": "._logging",
     "AFBaseModel": "._pydantic",
     "AFBaseSettings": "._pydantic",
     "Agent": "._agents",
@@ -18,39 +17,41 @@ _IMPORTS = {
     "AgentRunResponseUpdate": "._types",
     "AgentThread": "._agents",
     "AITool": "._tools",
-    "ai_function": "._tools",
     "AIFunction": "._tools",
     "AIContent": "._types",
     "AIContents": "._types",
+    "ChatClient": "._clients",
     "ChatClientAgent": "._agents",
     "ChatClientAgentThread": "._agents",
     "ChatClientAgentThreadType": "._agents",
+    "ChatClientBase": "._clients",
+    "ChatFinishReason": "._types",
+    "ChatMessage": "._types",
+    "ChatOptions": "._types",
+    "ChatResponse": "._types",
+    "ChatResponseUpdate": "._types",
+    "ChatRole": "._types",
+    "ChatToolMode": "._types",
+    "DataContent": "._types",
+    "EmbeddingGenerator": "._clients",
+    "ErrorContent": "._types",
+    "FunctionCallContent": "._types",
+    "FunctionResultContent": "._types",
+    "GeneratedEmbeddings": "._types",
+    "HttpsUrl": "._pydantic",
+    "InputGuardrail": ".guard_rails",
+    "OutputGuardrail": ".guard_rails",
+    "SpeechToTextOptions": "._types",
+    "StructuredResponse": "._types",
     "TextContent": "._types",
     "TextReasoningContent": "._types",
-    "DataContent": "._types",
+    "TextToSpeechOptions": "._types",
     "UriContent": "._types",
     "UsageContent": "._types",
     "UsageDetails": "._types",
-    "FunctionCallContent": "._types",
-    "FunctionResultContent": "._types",
-    "ChatFinishReason": "._types",
-    "ChatMessage": "._types",
-    "ChatResponse": "._types",
-    "StructuredResponse": "._types",
-    "ChatResponseUpdate": "._types",
-    "ChatRole": "._types",
-    "ErrorContent": "._types",
-    "GeneratedEmbeddings": "._types",
-    "ChatOptions": "._types",
-    "ChatToolMode": "._types",
-    "ChatClient": "._clients",
-    "ChatClientBase": "._clients",
+    "ai_function": "._tools",
+    "get_logger": "._logging",
     "use_tool_calling": "._clients",
-    "EmbeddingGenerator": "._clients",
-    "InputGuardrail": ".guard_rails",
-    "OutputGuardrail": ".guard_rails",
-    "TextToSpeechOptions": "._types",
-    "SpeechToTextOptions": "._types",
 }
 
 

python/packages/main/agent_framework/__init__.pyi

@@ -4,7 +4,7 @@ from . import __version__  # type: ignore[attr-defined]
 from ._agents import Agent, AgentThread, ChatClientAgent, ChatClientAgentThread, ChatClientAgentThreadType
 from ._clients import ChatClient, ChatClientBase, EmbeddingGenerator, use_tool_calling
 from ._logging import get_logger
-from ._pydantic import AFBaseModel, AFBaseSettings
+from ._pydantic import AFBaseModel, AFBaseSettings, HttpsUrl
 from ._tools import AIFunction, AITool, ai_function
 from ._types import (
     AgentRunResponse,
@@ -63,6 +63,7 @@ __all__ = [
     "FunctionCallContent",
     "FunctionResultContent",
     "GeneratedEmbeddings",
+    "HttpsUrl",
     "InputGuardrail",
     "OutputGuardrail",
     "SpeechToTextOptions",

python/packages/main/agent_framework/_clients.py

@@ -112,7 +112,14 @@ def _tool_call_non_streaming(func: TInnerGetResponse) -> TInnerGetResponse:
         for attempt_idx in range(getattr(self, "__maximum_iterations_per_request", 10)):
             response = await func(self, messages=messages, chat_options=chat_options)
             # if there are function calls, we will handle them first
-            function_calls = [it for it in response.messages[0].contents if isinstance(it, FunctionCallContent)]
+            function_results = {
+                it.call_id for it in response.messages[0].contents if isinstance(it, FunctionResultContent)
+            }
+            function_calls = [
+                it
+                for it in response.messages[0].contents
+                if isinstance(it, FunctionCallContent) and it.call_id not in function_results
+            ]
             if function_calls:
                 # Run all function calls concurrently
                 results = await asyncio.gather(*[

python/packages/main/agent_framework/_pydantic.py

@@ -1,11 +1,14 @@
 # Copyright (c) Microsoft. All rights reserved.
 
 
-from typing import Any, ClassVar, TypeVar
+from typing import Annotated, Any, ClassVar, TypeVar
 
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import BaseModel, ConfigDict, Field, UrlConstraints
+from pydantic.networks import AnyUrl
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
+HttpsUrl = Annotated[AnyUrl, UrlConstraints(max_length=2083, allowed_schemes=["https"])]
+
 
 class AFBaseModel(BaseModel):
     """Base class for all pydantic models in the Agent Framework."""

python/packages/main/agent_framework/_types.py

@@ -16,7 +16,16 @@ from collections.abc import (
 )
 from typing import Annotated, Any, ClassVar, Generic, Literal, TypeVar, overload
 
-from pydantic import BaseModel, ConfigDict, Field, PrivateAttr, ValidationError, field_validator, model_validator
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    PrivateAttr,
+    ValidationError,
+    field_validator,
+    model_serializer,
+    model_validator,
+)
 
 from ._pydantic import AFBaseModel
 from ._tools import AITool, ai_function
@@ -1398,6 +1407,11 @@ class ChatToolMode(AFBaseModel):
             return self.mode == other.mode and self.required_function_name == other.required_function_name
         return False
 
+    @model_serializer
+    def serialize_model(self) -> str:
+        """Serializes the ChatToolMode to just the mode string."""
+        return self.mode
+
 
 ChatToolMode.AUTO = ChatToolMode(mode="auto")  # type: ignore[assignment]
 ChatToolMode.REQUIRED_ANY = ChatToolMode(mode="required")  # type: ignore[assignment]
@@ -1496,10 +1510,13 @@ class ChatOptions(AFBaseModel):
             Dictionary of settings for provider.
         """
         default_exclude = {"additional_properties"}
+        # No tool choice if no tools are defined
+        if self.tools is None or len(self.tools) == 0:
+            default_exclude.add("tool_choice")
         merged_exclude = default_exclude if exclude is None else default_exclude | set(exclude)
 
         settings = self.model_dump(exclude_none=True, by_alias=by_alias, exclude=merged_exclude)
-        settings = {k: v for k, v in settings.items() if v and not isinstance(v, dict)}
+        settings = {k: v for k, v in settings.items() if v}
         settings.update(self.additional_properties)
         for key in merged_exclude:
             settings.pop(key, None)

python/packages/main/agent_framework/azure/__init__.py

@@ -7,6 +7,8 @@ PACKAGE_EXTRA = "azure"
 
 _IMPORTS = {
     "__version__": "agent_framework_azure",
+    "AzureChatClient": "agent_framework_azure",
+    "get_entra_auth_token": "agent_framework_azure",
 }
 
 

python/packages/main/agent_framework/exceptions.py

@@ -46,6 +46,12 @@ class ServiceContentFilterException(ServiceResponseException):
     pass
 
 
+class ServiceInvalidAuthError(ServiceException):
+    """An error occurred while authenticating the service."""
+
+    pass
+
+
 class ServiceInvalidExecutionSettingsError(ServiceResponseException):
     """An error occurred while validating the execution settings of the service."""
 

python/packages/main/agent_framework/openai/__init__.py

@@ -2,9 +2,11 @@
 
 
 from ._chat_client import OpenAIChatClient
-from ._shared import OpenAISettings
+from ._shared import OpenAIHandler, OpenAIModelTypes, OpenAISettings
 
 __all__ = [
     "OpenAIChatClient",
+    "OpenAIHandler",
+    "OpenAIModelTypes",
     "OpenAISettings",
 ]

python/packages/main/agent_framework/openai/_chat_client.py

@@ -239,11 +239,11 @@ class OpenAIChatClientBase(OpenAIHandler, ChatClientBase):
                     function_call = self._openai_content_parser(content)
                     if "tool_calls" not in args:
                         args["tool_calls"] = []
-                    args["tool_calls"].append(function_call)
+                    args["tool_calls"].append(function_call)  # type: ignore
                 case _:
                     if "content" not in args:
                         args["content"] = []
-                    args["content"].append(self._openai_content_parser(content))
+                    args["content"].append(self._openai_content_parser(content))  # type: ignore
         if "content" in args or "tool_calls" in args:
             all_messages.append(args)
         return all_messages

python/packages/main/tests/conftest.py

@@ -0,0 +1,57 @@
+# Copyright (c) Microsoft. All rights reserved.
+from typing import Any
+
+from pytest import fixture
+
+from agent_framework import ChatMessage
+
+
+# region: Connector Settings fixtures
+@fixture
+def exclude_list(request: Any) -> list[str]:
+    """Fixture that returns a list of environment variables to exclude."""
+    return request.param if hasattr(request, "param") else []
+
+
+@fixture
+def override_env_param_dict(request: Any) -> dict[str, str]:
+    """Fixture that returns a dict of environment variables to override."""
+    return request.param if hasattr(request, "param") else {}
+
+
+@fixture()
+def openai_unit_test_env(monkeypatch, exclude_list, override_env_param_dict):  # type: ignore
+    """Fixture to set environment variables for OpenAISettings."""
+    if exclude_list is None:
+        exclude_list = []
+
+    if override_env_param_dict is None:
+        override_env_param_dict = {}
+
+    env_vars = {
+        "OPENAI_API_KEY": "test_api_key",
+        "OPENAI_ORG_ID": "test_org_id",
+        "OPENAI_RESPONSES_MODEL_ID": "test_responses_model_id",
+        "OPENAI_CHAT_MODEL_ID": "test_chat_model_id",
+        "OPENAI_TEXT_MODEL_ID": "test_text_model_id",
+        "OPENAI_EMBEDDING_MODEL_ID": "test_embedding_model_id",
+        "OPENAI_TEXT_TO_IMAGE_MODEL_ID": "test_text_to_image_model_id",
+        "OPENAI_AUDIO_TO_TEXT_MODEL_ID": "test_audio_to_text_model_id",
+        "OPENAI_TEXT_TO_AUDIO_MODEL_ID": "test_text_to_audio_model_id",
+        "OPENAI_REALTIME_MODEL_ID": "test_realtime_model_id",
+    }
+
+    env_vars.update(override_env_param_dict)  # type: ignore
+
+    for key, value in env_vars.items():
+        if key not in exclude_list:
+            monkeypatch.setenv(key, value)  # type: ignore
+        else:
+            monkeypatch.delenv(key, raising=False)  # type: ignore
+
+    return env_vars
+
+
+@fixture(scope="function")
+def chat_history() -> list[ChatMessage]:
+    return []

python/packages/main/tests/integration/test_openai_chat_client.py

@@ -0,0 +1,120 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+from agent_framework import ChatClient, ChatMessage, ChatResponse, ChatResponseUpdate, TextContent, ai_function
+from agent_framework.openai import OpenAIChatClient
+
+
+@ai_function
+def get_story_text() -> str:
+    """Returns a story about Emily and David."""
+    return (
+        "Emily and David, two passionate scientists, met during a research expedition to Antarctica. "
+        "Bonded by their love for the natural world and shared curiosity, they uncovered a "
+        "groundbreaking phenomenon in glaciology that could potentially reshape our understanding "
+        "of climate change."
+    )
+
+
+async def test_openai_chat_completion_response() -> None:
+    """Test OpenAI chat completion responses."""
+    openai_chat_client = OpenAIChatClient(ai_model_id="gpt-4.1-mini")
+
+    assert isinstance(openai_chat_client, ChatClient)
+
+    messages: list[ChatMessage] = []
+    messages.append(
+        ChatMessage(
+            role="user",
+            text="Emily and David, two passionate scientists, met during a research expedition to Antarctica. "
+            "Bonded by their love for the natural world and shared curiosity, they uncovered a "
+            "groundbreaking phenomenon in glaciology that could potentially reshape our understanding "
+            "of climate change.",
+        )
+    )
+    messages.append(ChatMessage(role="user", text="who are Emily and David?"))
+
+    # Test that the client can be used to get a response
+    response = await openai_chat_client.get_response(messages=messages)
+
+    assert response is not None
+    assert isinstance(response, ChatResponse)
+    assert "scientists" in response.text
+
+
+async def test_openai_chat_completion_response_tools() -> None:
+    """Test OpenAI chat completion responses."""
+    openai_chat_client = OpenAIChatClient(ai_model_id="gpt-4.1-mini")
+
+    assert isinstance(openai_chat_client, ChatClient)
+
+    messages: list[ChatMessage] = []
+    messages.append(ChatMessage(role="user", text="who are Emily and David?"))
+
+    # Test that the client can be used to get a response
+    response = await openai_chat_client.get_response(
+        messages=messages,
+        tools=[get_story_text],
+        tool_choice="auto",
+    )
+
+    assert response is not None
+    assert isinstance(response, ChatResponse)
+    assert "scientists" in response.text
+
+
+async def test_openai_chat_client_streaming() -> None:
+    """Test Azure OpenAI chat completion responses."""
+    openai_chat_client = OpenAIChatClient(ai_model_id="gpt-4.1-mini")
+
+    assert isinstance(openai_chat_client, ChatClient)
+
+    messages: list[ChatMessage] = []
+    messages.append(
+        ChatMessage(
+            role="user",
+            text="Emily and David, two passionate scientists, met during a research expedition to Antarctica. "
+            "Bonded by their love for the natural world and shared curiosity, they uncovered a "
+            "groundbreaking phenomenon in glaciology that could potentially reshape our understanding "
+            "of climate change.",
+        )
+    )
+    messages.append(ChatMessage(role="user", text="who are Emily and David?"))
+
+    # Test that the client can be used to get a response
+    response = openai_chat_client.get_streaming_response(messages=messages)
+
+    full_message: str = ""
+    async for chunk in response:
+        assert chunk is not None
+        assert isinstance(chunk, ChatResponseUpdate)
+        for content in chunk.contents:
+            if isinstance(content, TextContent) and content.text:
+                full_message += content.text
+
+    assert "scientists" in full_message
+
+
+async def test_openai_chat_client_streaming_tools() -> None:
+    """Test AzureOpenAI chat completion responses."""
+    openai_chat_client = OpenAIChatClient(ai_model_id="gpt-4.1-mini")
+
+    assert isinstance(openai_chat_client, ChatClient)
+
+    messages: list[ChatMessage] = []
+    messages.append(ChatMessage(role="user", text="who are Emily and David?"))
+
+    # Test that the client can be used to get a response
+    response = openai_chat_client.get_streaming_response(
+        messages=messages,
+        tools=[get_story_text],
+        tool_choice="auto",
+    )
+    full_message: str = ""
+    async for chunk in response:
+        assert chunk is not None
+        assert isinstance(chunk, ChatResponseUpdate)
+        for content in chunk.contents:
+            if isinstance(content, TextContent) and content.text:
+                full_message += content.text
+
+    assert "scientists" in full_message

python/packages/main/tests/unit/test_openai_chat_client.py

@@ -0,0 +1,103 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import pytest
+
+from agent_framework import ChatClient
+from agent_framework.exceptions import ServiceInitializationError
+from agent_framework.openai import OpenAIChatClient
+
+
+def test_init(openai_unit_test_env: dict[str, str]) -> None:
+    # Test successful initialization
+    open_ai_chat_completion = OpenAIChatClient()
+
+    assert open_ai_chat_completion.ai_model_id == openai_unit_test_env["OPENAI_CHAT_MODEL_ID"]
+    assert isinstance(open_ai_chat_completion, ChatClient)
+
+
+def test_init_validation_fail() -> None:
+    # Test successful initialization
+    with pytest.raises(ServiceInitializationError):
+        OpenAIChatClient(api_key="34523", ai_model_id={"test": "dict"})  # type: ignore
+
+
+def test_init_ai_model_id_constructor(openai_unit_test_env: dict[str, str]) -> None:
+    # Test successful initialization
+    ai_model_id = "test_model_id"
+    open_ai_chat_completion = OpenAIChatClient(ai_model_id=ai_model_id)
+
+    assert open_ai_chat_completion.ai_model_id == ai_model_id
+    assert isinstance(open_ai_chat_completion, ChatClient)
+
+
+def test_init_with_default_header(openai_unit_test_env: dict[str, str]) -> None:
+    default_headers = {"X-Unit-Test": "test-guid"}
+
+    # Test successful initialization
+    open_ai_chat_completion = OpenAIChatClient(
+        default_headers=default_headers,
+    )
+
+    assert open_ai_chat_completion.ai_model_id == openai_unit_test_env["OPENAI_CHAT_MODEL_ID"]
+    assert isinstance(open_ai_chat_completion, ChatClient)
+
+    # Assert that the default header we added is present in the client's default headers
+    for key, value in default_headers.items():
+        assert key in open_ai_chat_completion.client.default_headers
+        assert open_ai_chat_completion.client.default_headers[key] == value
+
+
+@pytest.mark.parametrize("exclude_list", [["OPENAI_CHAT_MODEL_ID"]], indirect=True)
+def test_init_with_empty_model_id(openai_unit_test_env: dict[str, str]) -> None:
+    with pytest.raises(ServiceInitializationError):
+        OpenAIChatClient(
+            env_file_path="test.env",
+        )
+
+
+@pytest.mark.parametrize("exclude_list", [["OPENAI_API_KEY"]], indirect=True)
+def test_init_with_empty_api_key(openai_unit_test_env: dict[str, str]) -> None:
+    ai_model_id = "test_model_id"
+
+    with pytest.raises(ServiceInitializationError):
+        OpenAIChatClient(
+            ai_model_id=ai_model_id,
+            env_file_path="test.env",
+        )
+
+
+def test_serialize(openai_unit_test_env: dict[str, str]) -> None:
+    default_headers = {"X-Unit-Test": "test-guid"}
+
+    settings = {
+        "ai_model_id": openai_unit_test_env["OPENAI_CHAT_MODEL_ID"],
+        "api_key": openai_unit_test_env["OPENAI_API_KEY"],
+        "default_headers": default_headers,
+    }
+
+    open_ai_chat_completion = OpenAIChatClient.from_dict(settings)
+    dumped_settings = open_ai_chat_completion.to_dict()
+    assert dumped_settings["ai_model_id"] == openai_unit_test_env["OPENAI_CHAT_MODEL_ID"]
+    assert dumped_settings["api_key"] == openai_unit_test_env["OPENAI_API_KEY"]
+    # Assert that the default header we added is present in the dumped_settings default headers
+    for key, value in default_headers.items():
+        assert key in dumped_settings["default_headers"]
+        assert dumped_settings["default_headers"][key] == value
+    # Assert that the 'User-Agent' header is not present in the dumped_settings default headers
+    assert "User-Agent" not in dumped_settings["default_headers"]
+
+
+def test_serialize_with_org_id(openai_unit_test_env: dict[str, str]) -> None:
+    settings = {
+        "ai_model_id": openai_unit_test_env["OPENAI_CHAT_MODEL_ID"],
+        "api_key": openai_unit_test_env["OPENAI_API_KEY"],
+        "org_id": openai_unit_test_env["OPENAI_ORG_ID"],
+    }
+
+    open_ai_chat_completion = OpenAIChatClient.from_dict(settings)
+    dumped_settings = open_ai_chat_completion.to_dict()
+    assert dumped_settings["ai_model_id"] == openai_unit_test_env["OPENAI_CHAT_MODEL_ID"]
+    assert dumped_settings["api_key"] == openai_unit_test_env["OPENAI_API_KEY"]
+    assert dumped_settings["org_id"] == openai_unit_test_env["OPENAI_ORG_ID"]
+    # Assert that the 'User-Agent' header is not present in the dumped_settings default headers
+    assert "User-Agent" not in dumped_settings["default_headers"]

python/packages/main/tests/unit/test_openai_chat_client_base.py

@@ -0,0 +1,348 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+from copy import deepcopy
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+from openai import AsyncStream
+from openai.resources.chat.completions import AsyncCompletions as AsyncChatCompletions
+from openai.types.chat import ChatCompletion, ChatCompletionChunk
+from openai.types.chat.chat_completion import Choice
+from openai.types.chat.chat_completion_chunk import Choice as ChunkChoice
+from openai.types.chat.chat_completion_chunk import ChoiceDelta as ChunkChoiceDelta
+from openai.types.chat.chat_completion_message import ChatCompletionMessage
+from pydantic import BaseModel
+
+from agent_framework import ChatMessage, ChatResponseUpdate
+from agent_framework.exceptions import (
+    ServiceInvalidResponseError,
+    ServiceResponseException,
+)
+from agent_framework.openai import OpenAIChatClient
+
+
+async def mock_async_process_chat_stream_response(_):
+    mock_content = MagicMock(spec=ChatResponseUpdate)
+    yield mock_content, None
+
+
+@pytest.fixture
+def mock_chat_completion_response() -> ChatCompletion:
+    return ChatCompletion(
+        id="test_id",
+        choices=[
+            Choice(index=0, message=ChatCompletionMessage(content="test", role="assistant"), finish_reason="stop")
+        ],
+        created=0,
+        model="test",
+        object="chat.completion",
+    )
+
+
+@pytest.fixture
+def mock_streaming_chat_completion_response() -> AsyncStream[ChatCompletionChunk]:
+    content = ChatCompletionChunk(
+        id="test_id",
+        choices=[ChunkChoice(index=0, delta=ChunkChoiceDelta(content="test", role="assistant"), finish_reason="stop")],
+        created=0,
+        model="test",
+        object="chat.completion.chunk",
+    )
+    stream = MagicMock(spec=AsyncStream)
+    stream.__aiter__.return_value = [content]
+    return stream
+
+
+# region Chat Message Content
+
+
+@patch.object(AsyncChatCompletions, "create", new_callable=AsyncMock)
+async def test_cmc(
+    mock_create: AsyncMock,
+    chat_history: list[ChatMessage],
+    mock_chat_completion_response: ChatCompletion,
+    openai_unit_test_env: dict[str, str],
+):
+    mock_create.return_value = mock_chat_completion_response
+    chat_history.append(ChatMessage(role="user", text="hello world"))
+
+    openai_chat_completion = OpenAIChatClient()
+    await openai_chat_completion.get_response(
+        messages=chat_history,
+    )
+    mock_create.assert_awaited_once_with(
+        model=openai_unit_test_env["OPENAI_CHAT_MODEL_ID"],
+        stream=False,
+        messages=openai_chat_completion._prepare_chat_history_for_request(chat_history),  # type: ignore
+    )
+
+
+@patch.object(AsyncChatCompletions, "create", new_callable=AsyncMock)
+async def test_cmc_chat_options(
+    mock_create: AsyncMock,
+    chat_history: list[ChatMessage],
+    mock_chat_completion_response: ChatCompletion,
+    openai_unit_test_env: dict[str, str],
+):
+    mock_create.return_value = mock_chat_completion_response
+    chat_history.append(ChatMessage(role="user", text="hello world"))
+
+    openai_chat_completion = OpenAIChatClient()
+    await openai_chat_completion.get_response(
+        messages=chat_history,
+    )
+    mock_create.assert_awaited_once_with(
+        model=openai_unit_test_env["OPENAI_CHAT_MODEL_ID"],
+        stream=False,
+        messages=openai_chat_completion._prepare_chat_history_for_request(chat_history),  # type: ignore
+    )
+
+
+@patch.object(AsyncChatCompletions, "create", new_callable=AsyncMock)
+async def test_cmc_no_fcc_in_response(
+    mock_create: AsyncMock,
+    chat_history: list[ChatMessage],
+    mock_chat_completion_response: ChatCompletion,
+    openai_unit_test_env: dict[str, str],
+):
+    mock_create.return_value = mock_chat_completion_response
+    chat_history.append(ChatMessage(role="user", text="hello world"))
+    orig_chat_history = deepcopy(chat_history)
+
+    openai_chat_completion = OpenAIChatClient()
+    await openai_chat_completion.get_response(
+        messages=chat_history,
+        arguments={},
+    )
+    mock_create.assert_awaited_once_with(
+        model=openai_unit_test_env["OPENAI_CHAT_MODEL_ID"],
+        stream=False,
+        messages=openai_chat_completion._prepare_chat_history_for_request(orig_chat_history),  # type: ignore
+    )
+
+
+@patch.object(AsyncChatCompletions, "create", new_callable=AsyncMock)
+async def test_cmc_structured_output_no_fcc(
+    mock_create: AsyncMock,
+    chat_history: list[ChatMessage],
+    mock_chat_completion_response: ChatCompletion,
+    openai_unit_test_env: dict[str, str],
+):
+    mock_create.return_value = mock_chat_completion_response
+    chat_history.append(ChatMessage(role="user", text="hello world"))
+
+    # Define a mock response format
+    class Test(BaseModel):
+        name: str
+
+    openai_chat_completion = OpenAIChatClient()
+    await openai_chat_completion.get_response(
+        messages=chat_history,
+        response_format=Test,
+    )
+    mock_create.assert_awaited_once()
+
+
+@patch.object(AsyncChatCompletions, "create", new_callable=AsyncMock)
+async def test_scmc_chat_options(
+    mock_create: AsyncMock,
+    chat_history: list[ChatMessage],
+    mock_streaming_chat_completion_response: AsyncStream[ChatCompletionChunk],
+    openai_unit_test_env: dict[str, str],
+):
+    mock_create.return_value = mock_streaming_chat_completion_response
+    chat_history.append(ChatMessage(role="user", text="hello world"))
+
+    openai_chat_completion = OpenAIChatClient()
+    async for msg in openai_chat_completion.get_streaming_response(
+        messages=chat_history,
+    ):
+        assert isinstance(msg, ChatResponseUpdate)
+    mock_create.assert_awaited_once_with(
+        model=openai_unit_test_env["OPENAI_CHAT_MODEL_ID"],
+        stream=True,
+        stream_options={"include_usage": True},
+        messages=openai_chat_completion._prepare_chat_history_for_request(chat_history),  # type: ignore
+    )
+
+
+@patch.object(AsyncChatCompletions, "create", new_callable=AsyncMock, side_effect=Exception)
+async def test_cmc_general_exception(
+    mock_create: AsyncMock,
+    chat_history: list[ChatMessage],
+    mock_chat_completion_response: ChatCompletion,
+    openai_unit_test_env: dict[str, str],
+):
+    mock_create.return_value = mock_chat_completion_response
+    chat_history.append(ChatMessage(role="user", text="hello world"))
+
+    openai_chat_completion = OpenAIChatClient()
+    with pytest.raises(ServiceResponseException):
+        await openai_chat_completion.get_response(
+            messages=chat_history,
+        )
+
+
+# region Streaming
+
+
+@patch.object(AsyncChatCompletions, "create", new_callable=AsyncMock)
+async def test_scmc(
+    mock_create: AsyncMock,
+    chat_history: list[ChatMessage],
+    openai_unit_test_env: dict[str, str],
+):
+    content1 = ChatCompletionChunk(
+        id="test_id",
+        choices=[],
+        created=0,
+        model="test",
+        object="chat.completion.chunk",
+    )
+    content2 = ChatCompletionChunk(
+        id="test_id",
+        choices=[ChunkChoice(index=0, delta=ChunkChoiceDelta(content="test", role="assistant"), finish_reason="stop")],
+        created=0,
+        model="test",
+        object="chat.completion.chunk",
+    )
+    stream = MagicMock(spec=AsyncStream)
+    stream.__aiter__.return_value = [content1, content2]
+    mock_create.return_value = stream
+    chat_history.append(ChatMessage(role="user", text="hello world"))
+    orig_chat_history = deepcopy(chat_history)
+
+    openai_chat_completion = OpenAIChatClient()
+    async for msg in openai_chat_completion.get_streaming_response(
+        messages=chat_history,
+    ):
+        assert isinstance(msg, ChatResponseUpdate)
+    mock_create.assert_awaited_once_with(
+        model=openai_unit_test_env["OPENAI_CHAT_MODEL_ID"],
+        stream=True,
+        stream_options={"include_usage": True},
+        messages=openai_chat_completion._prepare_chat_history_for_request(orig_chat_history),  # type: ignore
+    )
+
+
+@patch.object(AsyncChatCompletions, "create", new_callable=AsyncMock)
+async def test_scmc_singular(
+    mock_create: AsyncMock,
+    chat_history: list[ChatMessage],
+    openai_unit_test_env: dict[str, str],
+):
+    content1 = ChatCompletionChunk(
+        id="test_id",
+        choices=[],
+        created=0,
+        model="test",
+        object="chat.completion.chunk",
+    )
+    content2 = ChatCompletionChunk(
+        id="test_id",
+        choices=[ChunkChoice(index=0, delta=ChunkChoiceDelta(content="test", role="assistant"), finish_reason="stop")],
+        created=0,
+        model="test",
+        object="chat.completion.chunk",
+    )
+    stream = MagicMock(spec=AsyncStream)
+    stream.__aiter__.return_value = [content1, content2]
+    mock_create.return_value = stream
+    chat_history.append(ChatMessage(role="user", text="hello world"))
+    orig_chat_history = deepcopy(chat_history)
+
+    openai_chat_completion = OpenAIChatClient()
+    async for msg in openai_chat_completion.get_streaming_response(
+        messages=chat_history,
+    ):
+        assert isinstance(msg, ChatResponseUpdate)
+    mock_create.assert_awaited_once_with(
+        model=openai_unit_test_env["OPENAI_CHAT_MODEL_ID"],
+        stream=True,
+        stream_options={"include_usage": True},
+        messages=openai_chat_completion._prepare_chat_history_for_request(orig_chat_history),  # type: ignore
+    )
+
+
+@patch.object(AsyncChatCompletions, "create", new_callable=AsyncMock)
+async def test_scmc_structured_output_no_fcc(
+    mock_create: AsyncMock,
+    chat_history: list[ChatMessage],
+    openai_unit_test_env: dict[str, str],
+):
+    content1 = ChatCompletionChunk(
+        id="test_id",
+        choices=[],
+        created=0,
+        model="test",
+        object="chat.completion.chunk",
+    )
+    content2 = ChatCompletionChunk(
+        id="test_id",
+        choices=[ChunkChoice(index=0, delta=ChunkChoiceDelta(content="test", role="assistant"), finish_reason="stop")],
+        created=0,
+        model="test",
+        object="chat.completion.chunk",
+    )
+    stream = MagicMock(spec=AsyncStream)
+    stream.__aiter__.return_value = [content1, content2]
+    mock_create.return_value = stream
+    chat_history.append(ChatMessage(role="user", text="hello world"))
+
+    # Define a mock response format
+    class Test(BaseModel):
+        name: str
+
+    openai_chat_completion = OpenAIChatClient()
+    async for msg in openai_chat_completion.get_streaming_response(
+        messages=chat_history,
+        response_format=Test,
+    ):
+        assert isinstance(msg, ChatResponseUpdate)
+    mock_create.assert_awaited_once()
+
+
+@patch.object(AsyncChatCompletions, "create", new_callable=AsyncMock)
+async def test_scmc_no_fcc_in_response(
+    mock_create: AsyncMock,
+    chat_history: list[ChatMessage],
+    mock_streaming_chat_completion_response: ChatCompletion,
+    openai_unit_test_env: dict[str, str],
+):
+    mock_create.return_value = mock_streaming_chat_completion_response
+    chat_history.append(ChatMessage(role="user", text="hello world"))
+    orig_chat_history = deepcopy(chat_history)
+
+    openai_chat_completion = OpenAIChatClient()
+    [
+        msg
+        async for msg in openai_chat_completion.get_streaming_response(
+            messages=chat_history,
+        )
+    ]
+    mock_create.assert_awaited_once_with(
+        model=openai_unit_test_env["OPENAI_CHAT_MODEL_ID"],
+        stream=True,
+        stream_options={"include_usage": True},
+        messages=openai_chat_completion._prepare_chat_history_for_request(orig_chat_history),  # type: ignore
+    )
+
+
+@patch.object(AsyncChatCompletions, "create", new_callable=AsyncMock)
+async def test_scmc_no_stream(
+    mock_create: AsyncMock,
+    chat_history: list[ChatMessage],
+    openai_unit_test_env: dict[str, str],
+    mock_chat_completion_response: ChatCompletion,  # AsyncStream[ChatCompletionChunk]?
+):
+    mock_create.return_value = mock_chat_completion_response
+    chat_history.append(ChatMessage(role="user", text="hello world"))
+
+    openai_chat_completion = OpenAIChatClient()
+    with pytest.raises(ServiceInvalidResponseError):
+        [
+            msg
+            async for msg in openai_chat_completion.get_streaming_response(
+                messages=chat_history,
+            )
+        ]