camel-ai 0.2.71a3__py3-none-any.whl → 0.2.71a5__py3-none-any.whl

camel/agents/repo_agent.py

@@ -21,6 +21,7 @@ if TYPE_CHECKING:
 from pydantic import BaseModel
 
 from camel.agents import ChatAgent
+from camel.agents.chat_agent import StreamingChatAgentResponse
 from camel.logger import get_logger
 from camel.messages import BaseMessage
 from camel.models import BaseModelBackend, ModelFactory
@@ -442,7 +443,7 @@ class RepoAgent(ChatAgent):
 
     def step(
         self, input_message: Union[BaseMessage, str], *args, **kwargs
-    ) -> ChatAgentResponse:
+    ) -> Union[ChatAgentResponse, StreamingChatAgentResponse]:
         r"""Overrides `ChatAgent.step()` to first retrieve relevant context
         from the vector store before passing the input to the language model.
         """

camel/benchmarks/browsecomp.py

@@ -619,20 +619,20 @@ class BrowseCompBenchmark(BaseBenchmark):
                         assistant_response, user_response = pipeline.step(
                             input_msg
                         )
-                        if assistant_response.terminated:  # type: ignore[attr-defined]
+                        if assistant_response.terminated:  # type: ignore[union-attr]
                             break
-                        if user_response.terminated:  # type: ignore[attr-defined]
+                        if user_response.terminated:  # type: ignore[union-attr]
                             break
-                        if "CAMEL_TASK_DONE" in user_response.msg.content:  # type: ignore[attr-defined]
+                        if "CAMEL_TASK_DONE" in user_response.msg.content:  # type: ignore[union-attr]
                             break
 
                         chat_history.append(
-                            f"AI User: {user_response.msg.content}"  # type: ignore[attr-defined]
+                            f"AI User: {user_response.msg.content}"  # type: ignore[union-attr]
                         )
                         chat_history.append(
-                            f"AI Assistant: {assistant_response.msg.content}"  # type: ignore[attr-defined]
+                            f"AI Assistant: {assistant_response.msg.content}"  # type: ignore[union-attr]
                         )
-                        input_msg = assistant_response.msg  # type: ignore[attr-defined]
+                        input_msg = assistant_response.msg  # type: ignore[union-attr]
 
                     chat_history_str = "\n".join(chat_history)
                     if roleplaying_summarizer:

camel/interpreters/docker_interpreter.py

@@ -146,8 +146,9 @@ class DockerInterpreter(BaseInterpreter):
         tar_stream = io.BytesIO()
         with tarfile.open(fileobj=tar_stream, mode='w') as tar:
             tarinfo = tarfile.TarInfo(name=filename)
-            tarinfo.size = len(content)
-            tar.addfile(tarinfo, io.BytesIO(content.encode('utf-8')))
+            encoded_content = content.encode('utf-8')
+            tarinfo.size = len(encoded_content)
+            tar.addfile(tarinfo, io.BytesIO(encoded_content))
         tar_stream.seek(0)
 
         # copy the tar into the container

camel/loaders/base_loader.py

@@ -0,0 +1,85 @@
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Any, Dict, List, Union
+
+
+class BaseLoader(ABC):
+    r"""Abstract base class for all data loaders in CAMEL."""
+
+    @abstractmethod
+    def _load_single(self, source: Union[str, Path]) -> Dict[str, Any]:
+        r"""Load data from a single source.
+
+        Args:
+            source (Union[str, Path]): The data source to load from.
+
+        Returns:
+            Dict[str, Any]: A dictionary containing the loaded data. It is
+                recommended that the dictionary includes a "content" key with
+                the primary data and optional metadata keys.
+        """
+        pass
+
+    def load(
+        self,
+        source: Union[str, Path, List[Union[str, Path]]],
+    ) -> Dict[str, List[Dict[str, Any]]]:
+        r"""Load data from one or multiple sources.
+
+        Args:
+            source (Union[str, Path, List[Union[str, Path]]]): The data source
+                (s) to load from. Can be:
+                - A single path/URL (str or Path)
+                - A list of paths/URLs
+
+        Returns:
+            Dict[str, List[Dict[str, Any]]]: A dictionary with a single key
+                "contents" containing a list of loaded data. If a single source
+                is provided, the list will contain a single item.
+
+        Raises:
+            ValueError: If no sources are provided
+            Exception: If loading fails for any source
+        """
+        if not source:
+            raise ValueError("At least one source must be provided")
+
+        # Convert single source to list for uniform processing
+        sources = [source] if isinstance(source, (str, Path)) else list(source)
+
+        # Process all sources
+        results = []
+        for i, src in enumerate(sources, 1):
+            try:
+                content = self._load_single(src)
+                results.append(content)
+            except Exception as e:
+                raise RuntimeError(
+                    f"Error loading source {i}/{len(sources)}: {src}"
+                ) from e
+
+        return {"contents": results}
+
+    @property
+    @abstractmethod
+    def supported_formats(self) -> set[str]:
+        r"""Get the set of supported file formats or data sources.
+
+        Returns:
+            set[str]: A set of strings representing the supported formats/
+            sources.
+        """
+        pass

camel/logger.py

@@ -155,7 +155,7 @@ def set_log_level(level):
     _logger.debug(f"Logging level set to: {logging.getLevelName(level)}")
 
 
-def get_logger(name):
+def get_logger(name: str):
     r"""Get a logger with the specified name, prefixed with 'camel.'.
 
 

camel/messages/base.py

@@ -533,7 +533,18 @@ class BaseMessage:
             OpenAIAssistantMessage: The converted :obj:`OpenAIAssistantMessage`
                 object.
         """
-        return {"role": "assistant", "content": self.content}
+        message_dict: Dict[str, Any] = {
+            "role": "assistant",
+            "content": self.content,
+        }
+
+        # Check if meta_dict contains tool_calls
+        if self.meta_dict and "tool_calls" in self.meta_dict:
+            tool_calls = self.meta_dict["tool_calls"]
+            if tool_calls:
+                message_dict["tool_calls"] = tool_calls
+
+        return message_dict  # type: ignore[return-value]
 
     def to_dict(self) -> Dict:
         r"""Converts the message to a dictionary.

camel/models/azure_openai_model.py

@@ -11,10 +11,15 @@
 # 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
 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
@@ -41,6 +46,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
 
@@ -197,7 +207,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 +226,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 +245,17 @@ 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 +267,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 +283,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 +306,19 @@ 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)
 
@@ -323,8 +362,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
@@ -346,8 +383,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
@@ -363,6 +398,60 @@ class AzureOpenAIModel(BaseModelBackend):
             **request_config,
         )
 
+    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.
+
+        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._client.beta.chat.completions.stream(
+            messages=messages,
+            model=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=self.model_type,
+            response_format=response_format,
+            **request_config,
+        )
+
     def check_model_config(self):
         r"""Check whether the model configuration contains any
         unexpected arguments to Azure OpenAI API.

camel/models/base_model.py

@@ -18,6 +18,10 @@ from abc import ABC, abstractmethod
 from typing import Any, Dict, List, Optional, Type, Union
 
 from openai import AsyncStream, Stream
+from openai.lib.streaming.chat import (
+    AsyncChatCompletionStreamManager,
+    ChatCompletionStreamManager,
+)
 from pydantic import BaseModel
 
 from camel.messages import OpenAIMessage
@@ -307,7 +311,28 @@ class BaseModelBackend(ABC, metaclass=ModelBackendMeta):
         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 the query to the backend model in a non-stream mode.
+
+        Args:
+            messages (List[OpenAIMessage]): Message list with the chat history
+                in OpenAI API format.
+            response_format (Optional[Type[BaseModel]]): The format of the
+                response.
+            tools (Optional[List[Dict[str, Any]]]): The schema of the tools to
+                use for the request.
+
+        Returns:
+            Union[ChatCompletion, Stream[ChatCompletionChunk], Any]:
+                `ChatCompletion` in the non-stream mode, or
+                `Stream[ChatCompletionChunk]` in the stream mode,
+                or `ChatCompletionStreamManager[BaseModel]` in the structured
+                stream mode.
+        """
         pass
 
     @abstractmethod
@@ -316,7 +341,28 @@ class BaseModelBackend(ABC, metaclass=ModelBackendMeta):
         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 the query to the backend model in async non-stream mode.
+
+        Args:
+            messages (List[OpenAIMessage]): Message list with the chat history
+                in OpenAI API format.
+            response_format (Optional[Type[BaseModel]]): The format of the
+                response.
+            tools (Optional[List[Dict[str, Any]]]): The schema of the tools to
+                use for the request.
+
+        Returns:
+            Union[ChatCompletion, AsyncStream[ChatCompletionChunk], Any]:
+                `ChatCompletion` in the non-stream mode, or
+                `AsyncStream[ChatCompletionChunk]` in the stream mode,
+                or `AsyncChatCompletionStreamManager[BaseModel]` in the
+                structured stream mode.
+        """
         pass
 
     def run(
@@ -324,7 +370,11 @@ class BaseModelBackend(ABC, metaclass=ModelBackendMeta):
         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 the query to the backend model.
 
         Args:
@@ -338,9 +388,11 @@ class BaseModelBackend(ABC, metaclass=ModelBackendMeta):
                 (default: :obj:`None`)
 
         Returns:
-            Union[ChatCompletion, Stream[ChatCompletionChunk]]:
-                `ChatCompletion` in the non-stream mode, or
-                `Stream[ChatCompletionChunk]` in the stream mode.
+            Union[ChatCompletion, Stream[ChatCompletionChunk], Any]:
+                `ChatCompletion` in the non-stream mode,
+                `Stream[ChatCompletionChunk]` in the stream mode, or
+                `ChatCompletionStreamManager[BaseModel]` in the structured
+                stream mode.
         """
         # Log the request if logging is enabled
         log_path = self._log_request(messages)
@@ -365,7 +417,11 @@ class BaseModelBackend(ABC, metaclass=ModelBackendMeta):
         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 the query to the backend model asynchronously.
 
         Args:
@@ -379,9 +435,11 @@ class BaseModelBackend(ABC, metaclass=ModelBackendMeta):
                 (default: :obj:`None`)
 
         Returns:
-            Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
-                `ChatCompletion` in the non-stream mode, or
-                `AsyncStream[ChatCompletionChunk]` in the stream mode.
+            Union[ChatCompletion, AsyncStream[ChatCompletionChunk], Any]:
+                `ChatCompletion` in the non-stream mode,
+                `AsyncStream[ChatCompletionChunk]` in the stream mode, or
+                `AsyncChatCompletionStreamManager[BaseModel]` in the structured
+                stream mode.
         """
         # Log the request if logging is enabled
         log_path = self._log_request(messages)

camel/models/deepseek_model.py

@@ -40,6 +40,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
 

camel/models/gemini_model.py

@@ -37,6 +37,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
 

camel/models/litellm_model.py

@@ -12,6 +12,7 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 import os
+import uuid
 from typing import Any, Dict, List, Optional, Type, Union
 
 from pydantic import BaseModel
@@ -98,23 +99,47 @@ class LiteLLMModel(BaseModelBackend):
         Returns:
             ChatCompletion: The response object in OpenAI's format.
         """
-        return ChatCompletion.construct(
-            id=response.id,
-            choices=[
+
+        converted_choices = []
+        for choice in response.choices:
+            # Build the assistant message dict
+            msg_dict: Dict[str, Any] = {
+                "role": choice.message.role,
+                "content": choice.message.content,
+            }
+
+            if getattr(choice.message, "tool_calls", None):
+                msg_dict["tool_calls"] = choice.message.tool_calls
+
+            elif getattr(choice.message, "function_call", None):
+                func_call = choice.message.function_call
+                msg_dict["tool_calls"] = [
+                    {
+                        "id": f"call_{uuid.uuid4().hex[:24]}",
+                        "type": "function",
+                        "function": {
+                            "name": getattr(func_call, "name", None),
+                            "arguments": getattr(func_call, "arguments", "{}"),
+                        },
+                    }
+                ]
+
+            converted_choices.append(
                 {
-                    "index": response.choices[0].index,
-                    "message": {
-                        "role": response.choices[0].message.role,
-                        "content": response.choices[0].message.content,
-                    },
-                    "finish_reason": response.choices[0].finish_reason,
+                    "index": choice.index,
+                    "message": msg_dict,
+                    "finish_reason": choice.finish_reason,
                 }
-            ],
-            created=response.created,
-            model=response.model,
-            object=response.object,
-            system_fingerprint=response.system_fingerprint,
-            usage=response.usage,
+            )
+
+        return ChatCompletion.construct(
+            id=response.id,
+            choices=converted_choices,
+            created=getattr(response, "created", None),
+            model=getattr(response, "model", None),
+            object=getattr(response, "object", None),
+            system_fingerprint=getattr(response, "system_fingerprint", None),
+            usage=getattr(response, "usage", None),
         )
 
     @property
@@ -148,6 +173,13 @@ class LiteLLMModel(BaseModelBackend):
         Returns:
             ChatCompletion
         """
+
+        request_config = self.model_config_dict.copy()
+        if tools:
+            request_config['tools'] = tools
+        if response_format:
+            request_config['response_format'] = response_format
+
         update_current_observation(
             input={
                 "messages": messages,
@@ -176,7 +208,7 @@ class LiteLLMModel(BaseModelBackend):
             base_url=self._url,
             model=self.model_type,
             messages=messages,
-            **self.model_config_dict,
+            **request_config,
             **self.kwargs,
         )
         response = self._convert_response_from_litellm_to_openai(response)

camel/models/model_manager.py

@@ -27,6 +27,10 @@ from typing import (
 )
 
 from openai import AsyncStream, Stream
+from openai.lib.streaming.chat import (
+    AsyncChatCompletionStreamManager,
+    ChatCompletionStreamManager,
+)
 from pydantic import BaseModel
 
 from camel.messages import OpenAIMessage
@@ -196,7 +200,11 @@ class ModelManager:
         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"""Process a list of messages by selecting a model based on
             the scheduling strategy.
             Sends the entire list of messages to the selected model,
@@ -207,9 +215,12 @@ class ModelManager:
                 history in OpenAI API format.
 
         Returns:
-            Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+            Union[ChatCompletion, Stream[ChatCompletionChunk],
+                  ChatCompletionStreamManager[BaseModel]]:
                 `ChatCompletion` in the non-stream mode, or
-                `Stream[ChatCompletionChunk]` in the stream mode.
+                `Stream[ChatCompletionChunk]` in the stream mode, or
+                `ChatCompletionStreamManager[BaseModel]` for
+                structured-output stream.
         """
         self.current_model = self.scheduling_strategy()
 
@@ -233,7 +244,11 @@ class ModelManager:
         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"""Process a list of messages by selecting a model based on
             the scheduling strategy.
             Sends the entire list of messages to the selected model,
@@ -244,9 +259,12 @@ class ModelManager:
                 history in OpenAI API format.
 
         Returns:
-            Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+            Union[ChatCompletion, AsyncStream[ChatCompletionChunk],
+                  AsyncChatCompletionStreamManager[BaseModel]]:
                 `ChatCompletion` in the non-stream mode, or
-                `AsyncStream[ChatCompletionChunk]` in the stream mode.
+                `AsyncStream[ChatCompletionChunk]` in the stream mode, or
+                `AsyncChatCompletionStreamManager[BaseModel]` for
+                structured-output stream.
         """
         async with self.lock:
             self.current_model = self.scheduling_strategy()