camel-ai 0.2.71a4__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/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()