camel-ai 0.2.67__py3-none-any.whl → 0.2.80a2__py3-none-any.whl

camel/models/anthropic_model.py

@@ -12,19 +12,63 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 import os
-from typing import Any, Dict, Optional, Union
+from typing import Any, Dict, List, Optional, Union
 
-from camel.configs import ANTHROPIC_API_PARAMS, AnthropicConfig
+from openai import AsyncStream, Stream
+
+from camel.configs import AnthropicConfig
+from camel.messages import OpenAIMessage
 from camel.models.openai_compatible_model import OpenAICompatibleModel
-from camel.types import ModelType
+from camel.types import ChatCompletion, ChatCompletionChunk, ModelType
 from camel.utils import (
-    AnthropicTokenCounter,
     BaseTokenCounter,
+    OpenAITokenCounter,
     api_keys_required,
     dependencies_required,
 )
 
 
+def strip_trailing_whitespace_from_messages(
+    messages: List[OpenAIMessage],
+) -> List[OpenAIMessage]:
+    r"""Strip trailing whitespace from all message contents in a list of
+    messages. This is necessary because the Anthropic API doesn't allow
+    trailing whitespace in message content.
+
+    Args:
+        messages (List[OpenAIMessage]): List of messages to process
+
+    Returns:
+        List[OpenAIMessage]: The processed messages with trailing whitespace
+            removed
+    """
+    if not messages:
+        return messages
+
+    # Create a deep copy to avoid modifying the original messages
+    processed_messages = [dict(msg) for msg in messages]
+
+    # Process each message
+    for msg in processed_messages:
+        if "content" in msg and msg["content"] is not None:
+            if isinstance(msg["content"], str):
+                msg["content"] = msg["content"].rstrip()
+            elif isinstance(msg["content"], list):
+                # Handle content that's a list of content parts (e.g., for
+                # multimodal content)
+                for i, part in enumerate(msg["content"]):
+                    if (
+                        isinstance(part, dict)
+                        and "text" in part
+                        and isinstance(part["text"], str)
+                    ):
+                        part["text"] = part["text"].rstrip()
+                    elif isinstance(part, str):
+                        msg["content"][i] = part.rstrip()
+
+    return processed_messages  # type: ignore[return-value]
+
+
 class AnthropicModel(OpenAICompatibleModel):
     r"""Anthropic API in a unified OpenAICompatibleModel interface.
 
@@ -89,29 +133,84 @@ class AnthropicModel(OpenAICompatibleModel):
             **kwargs,
         )
 
+        # Monkey patch the AnthropicTokenCounter to handle trailing whitespace
+        self._patch_anthropic_token_counter()
+
     @property
     def token_counter(self) -> BaseTokenCounter:
         r"""Initialize the token counter for the model backend.
 
         Returns:
-            BaseTokenCounter: The token counter following the model's
+            OpenAITokenCounter: The token counter following the model's
                 tokenization style.
         """
+        # TODO: use anthropic token counter
+
         if not self._token_counter:
-            self._token_counter = AnthropicTokenCounter(self.model_type)
+            self._token_counter = OpenAITokenCounter(ModelType.GPT_4O_MINI)
         return self._token_counter
 
-    def check_model_config(self):
-        r"""Check whether the model configuration is valid for anthropic
-        model backends.
+    def _request_chat_completion(
+        self,
+        messages: List[OpenAIMessage],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+        # Strip trailing whitespace from all message contents to prevent
+        # Anthropic API errors
+        processed_messages = strip_trailing_whitespace_from_messages(messages)
+
+        # Call the parent class method
+        return super()._request_chat_completion(processed_messages, tools)
+
+    async def _arequest_chat_completion(
+        self,
+        messages: List[OpenAIMessage],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+        # Strip trailing whitespace from all message contents to prevent
+        # Anthropic API errors
+        processed_messages = strip_trailing_whitespace_from_messages(messages)
 
-        Raises:
-            ValueError: If the model configuration dictionary contains any
-                unexpected arguments to Anthropic API.
+        # Call the parent class method
+        return await super()._arequest_chat_completion(
+            processed_messages, tools
+        )
+
+    def _patch_anthropic_token_counter(self):
+        r"""Monkey patch the AnthropicTokenCounter class to handle trailing
+        whitespace.
+
+        This patches the count_tokens_from_messages method to strip trailing
+        whitespace from message content before sending to the Anthropic API.
         """
-        for param in self.model_config_dict:
-            if param not in ANTHROPIC_API_PARAMS:
-                raise ValueError(
-                    f"Unexpected argument `{param}` is "
-                    "input into Anthropic model backend."
-                )
+        import functools
+
+        from anthropic.types import MessageParam
+
+        from camel.utils import AnthropicTokenCounter
+
+        original_count_tokens = (
+            AnthropicTokenCounter.count_tokens_from_messages
+        )
+
+        @functools.wraps(original_count_tokens)
+        def patched_count_tokens(self, messages):
+            # Process messages to remove trailing whitespace
+            processed_messages = strip_trailing_whitespace_from_messages(
+                messages
+            )
+
+            # Use the processed messages with the original method
+            return self.client.messages.count_tokens(
+                messages=[
+                    MessageParam(
+                        content=str(msg["content"]),
+                        role="user" if msg["role"] == "user" else "assistant",
+                    )
+                    for msg in processed_messages
+                ],
+                model=self.model,
+            ).input_tokens
+
+        # Apply the monkey patch
+        AnthropicTokenCounter.count_tokens_from_messages = patched_count_tokens

camel/models/aws_bedrock_model.py

@@ -13,17 +13,11 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 
 import os
-from typing import Any, Dict, List, Optional, Type, Union
+from typing import Any, Dict, Optional, Union
 
-from openai import AsyncStream
-from pydantic import BaseModel
-
-from camel.configs import BEDROCK_API_PARAMS, BedrockConfig
-from camel.messages import OpenAIMessage
+from camel.configs import BedrockConfig
 from camel.models.openai_compatible_model import OpenAICompatibleModel
 from camel.types import (
-    ChatCompletion,
-    ChatCompletionChunk,
     ModelType,
 )
 from camel.utils import BaseTokenCounter, api_keys_required
@@ -93,28 +87,3 @@ class AWSBedrockModel(OpenAICompatibleModel):
             max_retries=max_retries,
             **kwargs,
         )
-
-    async def _arun(
-        self,
-        messages: List[OpenAIMessage],
-        response_format: Optional[Type[BaseModel]] = None,
-        tools: Optional[List[Dict[str, Any]]] = None,
-    ) -> Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
-        raise NotImplementedError(
-            "AWS Bedrock does not support async inference."
-        )
-
-    def check_model_config(self):
-        r"""Check whether the input model configuration contains unexpected
-        arguments.
-
-        Raises:
-            ValueError: If the model configuration dictionary contains any
-                unexpected argument for this model class.
-        """
-        for param in self.model_config_dict:
-            if param not in BEDROCK_API_PARAMS:
-                raise ValueError(
-                    f"Invalid parameter '{param}' in model_config_dict. "
-                    f"Valid parameters are: {BEDROCK_API_PARAMS}"
-                )

camel/models/azure_openai_model.py

@@ -11,13 +11,19 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+import copy
 import os
+import warnings
 from typing import Any, Callable, Dict, List, Optional, Type, Union
 
 from openai import AsyncAzureOpenAI, AsyncStream, AzureOpenAI, Stream
+from openai.lib.streaming.chat import (
+    AsyncChatCompletionStreamManager,
+    ChatCompletionStreamManager,
+)
 from pydantic import BaseModel
 
-from camel.configs import OPENAI_API_PARAMS, ChatGPTConfig
+from camel.configs import ChatGPTConfig
 from camel.messages import OpenAIMessage
 from camel.models.base_model import BaseModelBackend
 from camel.types import (
@@ -41,6 +47,11 @@ if os.environ.get("LANGFUSE_ENABLED", "False").lower() == "true":
         from langfuse.decorators import observe
     except ImportError:
         from camel.utils import observe
+elif os.environ.get("TRACEROOT_ENABLED", "False").lower() == "true":
+    try:
+        from traceroot import trace as observe  # type: ignore[import]
+    except ImportError:
+        from camel.utils import observe
 else:
     from camel.utils import observe
 
@@ -50,7 +61,8 @@ class AzureOpenAIModel(BaseModelBackend):
 
     Args:
         model_type (Union[ModelType, str]): Model for which a backend is
-            created, one of GPT_* series.
+            created, Should be the deployment name you chose when you deployed
+            an azure model.
         model_config_dict (Optional[Dict[str, Any]], optional): A dictionary
             that will be fed into:obj:`openai.ChatCompletion.create()`. If
             :obj:`None`, :obj:`ChatGPTConfig().as_dict()` will be used.
@@ -61,8 +73,6 @@ class AzureOpenAIModel(BaseModelBackend):
             (default: :obj:`None`)
         api_version (Optional[str], optional): The api version for the model.
             (default: :obj:`None`)
-        azure_deployment_name (Optional[str], optional): The deployment name
-            you chose when you deployed an azure model. (default: :obj:`None`)
         azure_ad_token (Optional[str], optional): Your Azure Active Directory
             token, https://www.microsoft.com/en-us/security/business/
             identity-access/microsoft-entra-id. (default: :obj:`None`)
@@ -78,8 +88,23 @@ class AzureOpenAIModel(BaseModelBackend):
             (default: :obj:`None`)
         max_retries (int, optional): Maximum number of retries for API calls.
             (default: :obj:`3`)
+        client (Optional[Any], optional): A custom synchronous AzureOpenAI
+            client instance. If provided, this client will be used instead of
+            creating a new one. Useful for RL frameworks like AReaL or rLLM
+            that provide Azure OpenAI-compatible clients. The client should
+            implement the AzureOpenAI client interface with
+            `.chat.completions.create()` and `.beta.chat.completions.parse()`
+            methods. (default: :obj:`None`)
+        async_client (Optional[Any], optional): A custom asynchronous
+            AzureOpenAI client instance. If provided, this client will be
+            used instead of creating a new one. The client should implement
+            the AsyncAzureOpenAI client interface. (default: :obj:`None`)
+        azure_deployment_name (Optional[str], optional): **Deprecated**.
+            Use `model_type` parameter instead. This parameter is kept for
+            backward compatibility and will be removed in a future version.
+            (default: :obj:`None`)
         **kwargs (Any): Additional arguments to pass to the client
-            initialization.
+            initialization. Ignored if custom clients are provided.
 
     References:
         https://learn.microsoft.com/en-us/azure/ai-services/openai/
@@ -94,12 +119,35 @@ class AzureOpenAIModel(BaseModelBackend):
         timeout: Optional[float] = None,
         token_counter: Optional[BaseTokenCounter] = None,
         api_version: Optional[str] = None,
-        azure_deployment_name: Optional[str] = None,
         azure_ad_token_provider: Optional["AzureADTokenProvider"] = None,
         azure_ad_token: Optional[str] = None,
         max_retries: int = 3,
+        client: Optional[Any] = None,
+        async_client: Optional[Any] = None,
+        azure_deployment_name: Optional[str] = None,
         **kwargs: Any,
     ) -> None:
+        # Handle deprecated azure_deployment_name parameter
+        if azure_deployment_name is not None:
+            warnings.warn(
+                "The 'azure_deployment_name' parameter is deprecated. "
+                "Please use 'model_type' parameter instead. "
+                "The 'azure_deployment_name' parameter is being ignored.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+
+        # Handle deprecated AZURE_DEPLOYMENT_NAME environment variable
+        if os.environ.get("AZURE_DEPLOYMENT_NAME") is not None:
+            warnings.warn(
+                "The 'AZURE_DEPLOYMENT_NAME' environment variable is "
+                "deprecated. Please use the 'model_type' parameter "
+                "instead. The 'AZURE_DEPLOYMENT_NAME' environment "
+                "variable is being ignored.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+
         if model_config_dict is None:
             model_config_dict = ChatGPTConfig().as_dict()
         api_key = api_key or os.environ.get("AZURE_OPENAI_API_KEY")
@@ -110,9 +158,6 @@ class AzureOpenAIModel(BaseModelBackend):
         )
 
         self.api_version = api_version or os.environ.get("AZURE_API_VERSION")
-        self._azure_deployment_name = azure_deployment_name or os.environ.get(
-            "AZURE_DEPLOYMENT_NAME"
-        )
         self._azure_ad_token = azure_ad_token or os.environ.get(
             "AZURE_AD_TOKEN"
         )
@@ -122,62 +167,73 @@ class AzureOpenAIModel(BaseModelBackend):
                 "Must provide either the `api_version` argument "
                 "or `AZURE_API_VERSION` environment variable."
             )
-        if self._azure_deployment_name is None:
-            raise ValueError(
-                "Must provide either the `azure_deployment_name` argument "
-                "or `AZURE_DEPLOYMENT_NAME` environment variable."
-            )
 
-        if is_langfuse_available():
-            from langfuse.openai import AsyncAzureOpenAI as LangfuseAsyncOpenAI
-            from langfuse.openai import AzureOpenAI as LangfuseOpenAI
-
-            self._client = LangfuseOpenAI(
-                azure_endpoint=str(self._url),
-                azure_deployment=self._azure_deployment_name,
-                api_version=self.api_version,
-                api_key=self._api_key,
-                azure_ad_token=self._azure_ad_token,
-                azure_ad_token_provider=self.azure_ad_token_provider,
-                timeout=self._timeout,
-                max_retries=max_retries,
-                **kwargs,
-            )
-            self._async_client = LangfuseAsyncOpenAI(
-                azure_endpoint=str(self._url),
-                azure_deployment=self._azure_deployment_name,
-                api_version=self.api_version,
-                api_key=self._api_key,
-                azure_ad_token=self._azure_ad_token,
-                azure_ad_token_provider=self.azure_ad_token_provider,
-                timeout=self._timeout,
-                max_retries=max_retries,
-                **kwargs,
-            )
+        # Use custom clients if provided, otherwise create new ones
+        if client is not None:
+            # Use the provided custom sync client
+            self._client = client
         else:
-            self._client = AzureOpenAI(
-                azure_endpoint=str(self._url),
-                azure_deployment=self._azure_deployment_name,
-                api_version=self.api_version,
-                api_key=self._api_key,
-                azure_ad_token=self._azure_ad_token,
-                azure_ad_token_provider=self.azure_ad_token_provider,
-                timeout=self._timeout,
-                max_retries=max_retries,
-                **kwargs,
-            )
+            # Create default sync client
+            if is_langfuse_available():
+                from langfuse.openai import AzureOpenAI as LangfuseOpenAI
+
+                self._client = LangfuseOpenAI(
+                    azure_endpoint=str(self._url),
+                    azure_deployment=str(self.model_type),
+                    api_version=self.api_version,
+                    api_key=self._api_key,
+                    azure_ad_token=self._azure_ad_token,
+                    azure_ad_token_provider=self.azure_ad_token_provider,
+                    timeout=self._timeout,
+                    max_retries=max_retries,
+                    **kwargs,
+                )
+            else:
+                self._client = AzureOpenAI(
+                    azure_endpoint=str(self._url),
+                    azure_deployment=str(self.model_type),
+                    api_version=self.api_version,
+                    api_key=self._api_key,
+                    azure_ad_token=self._azure_ad_token,
+                    azure_ad_token_provider=self.azure_ad_token_provider,
+                    timeout=self._timeout,
+                    max_retries=max_retries,
+                    **kwargs,
+                )
 
-            self._async_client = AsyncAzureOpenAI(
-                azure_endpoint=str(self._url),
-                azure_deployment=self._azure_deployment_name,
-                api_version=self.api_version,
-                api_key=self._api_key,
-                azure_ad_token=self._azure_ad_token,
-                azure_ad_token_provider=self.azure_ad_token_provider,
-                timeout=self._timeout,
-                max_retries=max_retries,
-                **kwargs,
-            )
+        if async_client is not None:
+            # Use the provided custom async client
+            self._async_client = async_client
+        else:
+            # Create default async client
+            if is_langfuse_available():
+                from langfuse.openai import (
+                    AsyncAzureOpenAI as LangfuseAsyncOpenAI,
+                )
+
+                self._async_client = LangfuseAsyncOpenAI(
+                    azure_endpoint=str(self._url),
+                    azure_deployment=str(self.model_type),
+                    api_version=self.api_version,
+                    api_key=self._api_key,
+                    azure_ad_token=self._azure_ad_token,
+                    azure_ad_token_provider=self.azure_ad_token_provider,
+                    timeout=self._timeout,
+                    max_retries=max_retries,
+                    **kwargs,
+                )
+            else:
+                self._async_client = AsyncAzureOpenAI(
+                    azure_endpoint=str(self._url),
+                    azure_deployment=str(self.model_type),
+                    api_version=self.api_version,
+                    api_key=self._api_key,
+                    azure_ad_token=self._azure_ad_token,
+                    azure_ad_token_provider=self.azure_ad_token_provider,
+                    timeout=self._timeout,
+                    max_retries=max_retries,
+                    **kwargs,
+                )
 
     @property
     def token_counter(self) -> BaseTokenCounter:
@@ -197,7 +253,11 @@ class AzureOpenAIModel(BaseModelBackend):
         messages: List[OpenAIMessage],
         response_format: Optional[Type[BaseModel]] = None,
         tools: Optional[List[Dict[str, Any]]] = None,
-    ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+    ) -> Union[
+        ChatCompletion,
+        Stream[ChatCompletionChunk],
+        ChatCompletionStreamManager[BaseModel],
+    ]:
         r"""Runs inference of Azure OpenAI chat completion.
 
         Args:
@@ -212,6 +272,8 @@ class AzureOpenAIModel(BaseModelBackend):
             Union[ChatCompletion, Stream[ChatCompletionChunk]]:
                 `ChatCompletion` in the non-stream mode, or
                 `Stream[ChatCompletionChunk]` in the stream mode.
+                `ChatCompletionStreamManager[BaseModel]` for
+                structured output streaming.
         """
 
         # Update Langfuse trace with current agent session and metadata
@@ -229,10 +291,14 @@ class AzureOpenAIModel(BaseModelBackend):
         response_format = response_format or self.model_config_dict.get(
             "response_format", None
         )
+        is_streaming = self.model_config_dict.get("stream", False)
         if response_format:
-            result: Union[ChatCompletion, Stream[ChatCompletionChunk]] = (
-                self._request_parse(messages, response_format, tools)
-            )
+            if is_streaming:
+                return self._request_stream_parse(
+                    messages, response_format, tools
+                )
+            else:
+                return self._request_parse(messages, response_format, tools)
         else:
             result = self._request_chat_completion(messages, tools)
 
@@ -244,7 +310,11 @@ class AzureOpenAIModel(BaseModelBackend):
         messages: List[OpenAIMessage],
         response_format: Optional[Type[BaseModel]] = None,
         tools: Optional[List[Dict[str, Any]]] = None,
-    ) -> Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+    ) -> Union[
+        ChatCompletion,
+        AsyncStream[ChatCompletionChunk],
+        AsyncChatCompletionStreamManager[BaseModel],
+    ]:
         r"""Runs inference of Azure OpenAI chat completion.
 
         Args:
@@ -256,9 +326,12 @@ class AzureOpenAIModel(BaseModelBackend):
                 use for the request.
 
         Returns:
-            Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+            Union[ChatCompletion, AsyncStream[ChatCompletionChunk],
+                  AsyncChatCompletionStreamManager[BaseModel]]:
                 `ChatCompletion` in the non-stream mode, or
                 `AsyncStream[ChatCompletionChunk]` in the stream mode.
+                `AsyncChatCompletionStreamManager[BaseModel]` for
+                structured output streaming.
         """
 
         # Update Langfuse trace with current agent session and metadata
@@ -276,10 +349,16 @@ class AzureOpenAIModel(BaseModelBackend):
         response_format = response_format or self.model_config_dict.get(
             "response_format", None
         )
+        is_streaming = self.model_config_dict.get("stream", False)
         if response_format:
-            result: Union[
-                ChatCompletion, AsyncStream[ChatCompletionChunk]
-            ] = await self._arequest_parse(messages, response_format, tools)
+            if is_streaming:
+                return await self._arequest_stream_parse(
+                    messages, response_format, tools
+                )
+            else:
+                return await self._arequest_parse(
+                    messages, response_format, tools
+                )
         else:
             result = await self._arequest_chat_completion(messages, tools)
 
@@ -297,7 +376,7 @@ class AzureOpenAIModel(BaseModelBackend):
 
         return self._client.chat.completions.create(
             messages=messages,
-            model=self._azure_deployment_name,  # type:ignore[arg-type]
+            model=str(self.model_type),
             **request_config,
         )
 
@@ -313,7 +392,7 @@ class AzureOpenAIModel(BaseModelBackend):
 
         return await self._async_client.chat.completions.create(
             messages=messages,
-            model=self._azure_deployment_name,  # type:ignore[arg-type]
+            model=str(self.model_type),
             **request_config,
         )
 
@@ -323,8 +402,6 @@ class AzureOpenAIModel(BaseModelBackend):
         response_format: Type[BaseModel],
         tools: Optional[List[Dict[str, Any]]] = None,
     ) -> ChatCompletion:
-        import copy
-
         request_config = copy.deepcopy(self.model_config_dict)
 
         request_config["response_format"] = response_format
@@ -336,7 +413,7 @@ class AzureOpenAIModel(BaseModelBackend):
 
         return self._client.beta.chat.completions.parse(
             messages=messages,
-            model=self._azure_deployment_name,  # type:ignore[arg-type]
+            model=str(self.model_type),
             **request_config,
         )
 
@@ -346,8 +423,6 @@ class AzureOpenAIModel(BaseModelBackend):
         response_format: Type[BaseModel],
         tools: Optional[List[Dict[str, Any]]] = None,
     ) -> ChatCompletion:
-        import copy
-
         request_config = copy.deepcopy(self.model_config_dict)
 
         request_config["response_format"] = response_format
@@ -359,24 +434,63 @@ class AzureOpenAIModel(BaseModelBackend):
 
         return await self._async_client.beta.chat.completions.parse(
             messages=messages,
-            model=self._azure_deployment_name,  # type:ignore[arg-type]
+            model=str(self.model_type),
             **request_config,
         )
 
-    def check_model_config(self):
-        r"""Check whether the model configuration contains any
-        unexpected arguments to Azure OpenAI API.
+    def _request_stream_parse(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Type[BaseModel],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> ChatCompletionStreamManager[BaseModel]:
+        r"""Request streaming structured output parsing.
 
-        Raises:
-            ValueError: If the model configuration dictionary contains any
-                unexpected arguments to Azure OpenAI API.
+        Note: This uses OpenAI's beta streaming API for structured outputs.
         """
-        for param in self.model_config_dict:
-            if param not in OPENAI_API_PARAMS:
-                raise ValueError(
-                    f"Unexpected argument `{param}` is "
-                    "input into Azure OpenAI model backend."
-                )
+
+        request_config = copy.deepcopy(self.model_config_dict)
+
+        # Remove stream from config as it's handled by the stream method
+        request_config.pop("stream", None)
+
+        if tools is not None:
+            request_config["tools"] = tools
+
+        # Use the beta streaming API for structured outputs
+        return self._client.beta.chat.completions.stream(
+            messages=messages,
+            model=str(self.model_type),
+            response_format=response_format,
+            **request_config,
+        )
+
+    async def _arequest_stream_parse(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Type[BaseModel],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> AsyncChatCompletionStreamManager[BaseModel]:
+        r"""Request async streaming structured output parsing.
+
+        Note: This uses OpenAI's beta streaming API for structured outputs.
+        """
+
+        request_config = copy.deepcopy(self.model_config_dict)
+
+        # Remove stream from config as it's handled by the stream method
+        request_config.pop("stream", None)
+
+        if tools is not None:
+            request_config["tools"] = tools
+
+        # Use the beta streaming API for structured outputs
+        return self._async_client.beta.chat.completions.stream(
+            messages=messages,
+            model=str(self.model_type),
+            response_format=response_format,
+            **request_config,
+        )
 
     @property
     def stream(self) -> bool: