camel-ai 0.2.42__py3-none-any.whl → 0.2.44__py3-none-any.whl

camel/models/ppio_model.py

@@ -0,0 +1,184 @@
+# ========= 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. =========
+
+import os
+from typing import Any, Dict, List, Optional, Type, Union
+
+from openai import AsyncOpenAI, AsyncStream, OpenAI, Stream
+from pydantic import BaseModel
+
+from camel.configs import PPIO_API_PARAMS, PPIOConfig
+from camel.messages import OpenAIMessage
+from camel.models import BaseModelBackend
+from camel.types import (
+    ChatCompletion,
+    ChatCompletionChunk,
+    ModelType,
+)
+from camel.utils import (
+    BaseTokenCounter,
+    OpenAITokenCounter,
+    api_keys_required,
+)
+
+
+class PPIOModel(BaseModelBackend):
+    r"""Constructor for PPIO backend with OpenAI compatibility.
+
+    Args:
+        model_type (Union[ModelType, str]): Model for which a backend is
+            created, supported model can be found here:
+            https://ppinfra.com/model-api/product/llm-api?utm_source=github_owl
+        model_config_dict (Optional[Dict[str, Any]], optional): A dictionary
+            that will be fed into:obj:`openai.ChatCompletion.create()`. If
+            :obj:`None`, :obj:`PPIOConfig().as_dict()` will be used.
+            (default: :obj:`None`)
+        api_key (Optional[str], optional): The API key for authenticating with
+            the PPIO service. (default: :obj:`None`)
+        url (Optional[str], optional): The url to the PPIO service.
+            If not provided, "https://api.ppinfra.com/v3/openai" will be used.
+            (default: :obj:`None`)
+        token_counter (Optional[BaseTokenCounter], optional): Token counter to
+            use for the model. If not provided, :obj:`OpenAITokenCounter(
+            ModelType.GPT_4O_MINI)` will be used.
+        timeout (Optional[float], optional): The timeout value in seconds for
+            API calls. If not provided, will fall back to the MODEL_TIMEOUT
+            environment variable or default to 180 seconds.
+            (default: :obj:`None`)
+    """
+
+    @api_keys_required(
+        [
+            ("api_key", 'PPIO_API_KEY'),
+        ]
+    )
+    def __init__(
+        self,
+        model_type: Union[ModelType, str],
+        model_config_dict: Optional[Dict[str, Any]] = None,
+        api_key: Optional[str] = None,
+        url: Optional[str] = None,
+        token_counter: Optional[BaseTokenCounter] = None,
+        timeout: Optional[float] = None,
+    ) -> None:
+        if model_config_dict is None:
+            model_config_dict = PPIOConfig().as_dict()
+        api_key = api_key or os.environ.get("PPIO_API_KEY")
+        url = url or os.environ.get(
+            "PPIO_API_BASE_URL", "https://api.ppinfra.com/v3/openai"
+        )
+        timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
+
+        super().__init__(
+            model_type, model_config_dict, api_key, url, token_counter, timeout
+        )
+
+        self._client = OpenAI(
+            timeout=self._timeout,
+            max_retries=3,
+            api_key=self._api_key,
+            base_url=self._url,
+        )
+        self._async_client = AsyncOpenAI(
+            timeout=self._timeout,
+            max_retries=3,
+            api_key=self._api_key,
+            base_url=self._url,
+        )
+
+    async def _arun(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Optional[Type[BaseModel]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+        r"""Runs inference of OpenAI chat completion.
+
+        Args:
+            messages (List[OpenAIMessage]): Message list with the chat history
+                in OpenAI API format.
+
+        Returns:
+            Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+                `ChatCompletion` in the non-stream mode, or
+                `AsyncStream[ChatCompletionChunk]` in the stream mode.
+        """
+        response = await self._async_client.chat.completions.create(
+            messages=messages,
+            model=self.model_type,
+            **self.model_config_dict,
+        )
+        return response
+
+    def _run(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Optional[Type[BaseModel]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+        r"""Runs inference of OpenAI chat completion.
+
+        Args:
+            messages (List[OpenAIMessage]): Message list with the chat history
+                in OpenAI API format.
+
+        Returns:
+            Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+                `ChatCompletion` in the non-stream mode, or
+                `Stream[ChatCompletionChunk]` in the stream mode.
+        """
+        response = self._client.chat.completions.create(
+            messages=messages,
+            model=self.model_type,
+            **self.model_config_dict,
+        )
+        return response
+
+    @property
+    def token_counter(self) -> BaseTokenCounter:
+        r"""Initialize the token counter for the model backend.
+
+        Returns:
+            OpenAITokenCounter: The token counter following the model's
+                tokenization style.
+        """
+
+        if not self._token_counter:
+            self._token_counter = OpenAITokenCounter(ModelType.GPT_4O_MINI)
+        return self._token_counter
+
+    def check_model_config(self):
+        r"""Check whether the model configuration contains any
+        unexpected arguments to PPIO API.
+
+        Raises:
+            ValueError: If the model configuration dictionary contains any
+                unexpected arguments to PPIO API.
+        """
+        for param in self.model_config_dict:
+            if param not in PPIO_API_PARAMS:
+                raise ValueError(
+                    f"Unexpected argument `{param}` is "
+                    "input into PPIO model backend."
+                )
+
+    @property
+    def stream(self) -> bool:
+        r"""Returns whether the model is in stream mode, which sends partial
+        results each time.
+
+        Returns:
+            bool: Whether the model is in stream mode.
+        """
+        return self.model_config_dict.get('stream', False)

camel/models/togetherai_model.py

@@ -96,70 +96,145 @@ class TogetherAIModel(BaseModelBackend):
             base_url=self._url,
         )
 
-    async def _arun(
+    @property
+    def token_counter(self) -> BaseTokenCounter:
+        r"""Initialize the token counter for the model backend.
+
+        Returns:
+            BaseTokenCounter: The token counter following the model's
+                tokenization style.
+        """
+        if not self._token_counter:
+            self._token_counter = OpenAITokenCounter(ModelType.GPT_4O_MINI)
+        return self._token_counter
+
+    def _run(
         self,
         messages: List[OpenAIMessage],
         response_format: Optional[Type[BaseModel]] = None,
         tools: Optional[List[Dict[str, Any]]] = None,
-    ) -> Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+    ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
         r"""Runs inference of OpenAI chat completion.
 
         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]]:
+            Union[ChatCompletion, Stream[ChatCompletionChunk]]:
                 `ChatCompletion` in the non-stream mode, or
-                `AsyncStream[ChatCompletionChunk]` in the stream mode.
+                `Stream[ChatCompletionChunk]` in the stream mode.
         """
-        # Use OpenAI client as interface call Together AI
-        # Reference: https://docs.together.ai/docs/openai-api-compatibility
-        response = await self._async_client.chat.completions.create(
-            messages=messages,
-            model=self.model_type,
-            **self.model_config_dict,
+        response_format = response_format or self.model_config_dict.get(
+            "response_format", None
         )
-        return response
+        if response_format:
+            return self._request_parse(messages, response_format, tools)
+        else:
+            return self._request_chat_completion(messages, tools)
 
-    def _run(
+    async def _arun(
         self,
         messages: List[OpenAIMessage],
         response_format: Optional[Type[BaseModel]] = None,
         tools: Optional[List[Dict[str, Any]]] = None,
-    ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
-        r"""Runs inference of OpenAI chat completion.
+    ) -> Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+        r"""Runs inference of OpenAI chat completion in async 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]]:
+            Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
                 `ChatCompletion` in the non-stream mode, or
-                `Stream[ChatCompletionChunk]` in the stream mode.
+                `AsyncStream[ChatCompletionChunk]` in the stream mode.
         """
-        # Use OpenAI client as interface call Together AI
-        # Reference: https://docs.together.ai/docs/openai-api-compatibility
-        response = self._client.chat.completions.create(
+        response_format = response_format or self.model_config_dict.get(
+            "response_format", None
+        )
+        if response_format:
+            return await self._arequest_parse(messages, response_format, tools)
+        else:
+            return await self._arequest_chat_completion(messages, tools)
+
+    def _request_chat_completion(
+        self,
+        messages: List[OpenAIMessage],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+        request_config = self.model_config_dict.copy()
+
+        if tools:
+            request_config["tools"] = tools
+
+        return self._client.chat.completions.create(
             messages=messages,
             model=self.model_type,
-            **self.model_config_dict,
+            **request_config,
         )
-        return response
 
-    @property
-    def token_counter(self) -> BaseTokenCounter:
-        r"""Initialize the token counter for the model backend.
+    async def _arequest_chat_completion(
+        self,
+        messages: List[OpenAIMessage],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+        request_config = self.model_config_dict.copy()
 
-        Returns:
-            OpenAITokenCounter: The token counter following the model's
-                tokenization style.
-        """
+        if tools:
+            request_config["tools"] = tools
 
-        if not self._token_counter:
-            self._token_counter = OpenAITokenCounter(ModelType.GPT_4O_MINI)
-        return self._token_counter
+        return await self._async_client.chat.completions.create(
+            messages=messages,
+            model=self.model_type,
+            **request_config,
+        )
+
+    def _request_parse(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Type[BaseModel],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> ChatCompletion:
+        request_config = self.model_config_dict.copy()
+
+        request_config["response_format"] = response_format
+
+        if tools is not None:
+            request_config["tools"] = tools
+
+        return self._client.beta.chat.completions.parse(
+            messages=messages,
+            model=self.model_type,
+            **request_config,
+        )
+
+    async def _arequest_parse(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Type[BaseModel],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> ChatCompletion:
+        request_config = self.model_config_dict.copy()
+
+        request_config["response_format"] = response_format
+
+        if tools is not None:
+            request_config["tools"] = tools
+
+        return await self._async_client.beta.chat.completions.parse(
+            messages=messages,
+            model=self.model_type,
+            **request_config,
+        )
 
     def check_model_config(self):
         r"""Check whether the model configuration contains any

camel/models/vllm_model.py

@@ -119,20 +119,34 @@ class VLLMModel(BaseModelBackend):
             self._token_counter = OpenAITokenCounter(ModelType.GPT_4O_MINI)
         return self._token_counter
 
-    def check_model_config(self):
-        r"""Check whether the model configuration contains any
-        unexpected arguments to vLLM API.
+    def _run(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Optional[Type[BaseModel]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+        r"""Runs inference of OpenAI chat completion.
 
-        Raises:
-            ValueError: If the model configuration dictionary contains any
-                unexpected arguments to OpenAI API.
+        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]]:
+                `ChatCompletion` in the non-stream mode, or
+                `Stream[ChatCompletionChunk]` in the stream mode.
         """
-        for param in self.model_config_dict:
-            if param not in VLLM_API_PARAMS:
-                raise ValueError(
-                    f"Unexpected argument `{param}` is "
-                    "input into vLLM model backend."
-                )
+        response_format = response_format or self.model_config_dict.get(
+            "response_format", None
+        )
+        if response_format:
+            return self._request_parse(messages, response_format, tools)
+        else:
+            return self._request_chat_completion(messages, tools)
 
     async def _arun(
         self,
@@ -140,85 +154,154 @@ class VLLMModel(BaseModelBackend):
         response_format: Optional[Type[BaseModel]] = None,
         tools: Optional[List[Dict[str, Any]]] = None,
     ) -> Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
-        r"""Runs inference of OpenAI chat completion.
+        r"""Runs inference of OpenAI chat completion in async mode.
 
         Args:
             messages (List[OpenAIMessage]): Message list with the chat history
                 in OpenAI API format.
-            response_format (Optional[Type[BaseModel]], optional): The format
-                to return the response in.
-            tools (Optional[List[Dict[str, Any]]], optional): List of tools
-                the model may call.
+            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]]:
                 `ChatCompletion` in the non-stream mode, or
                 `AsyncStream[ChatCompletionChunk]` in the stream mode.
         """
+        response_format = response_format or self.model_config_dict.get(
+            "response_format", None
+        )
+        if response_format:
+            return await self._arequest_parse(messages, response_format, tools)
+        else:
+            return await self._arequest_chat_completion(messages, tools)
+
+    def _request_chat_completion(
+        self,
+        messages: List[OpenAIMessage],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+        request_config = self.model_config_dict.copy()
 
-        kwargs = self.model_config_dict.copy()
         if tools:
-            kwargs["tools"] = tools
-        if response_format:
-            kwargs["response_format"] = {"type": "json_object"}
+            request_config["tools"] = tools
 
         # Remove additionalProperties from each tool's function parameters
-        if tools and "tools" in kwargs:
-            for tool in kwargs["tools"]:
+        if tools and "tools" in request_config:
+            for tool in request_config["tools"]:
                 if "function" in tool and "parameters" in tool["function"]:
                     tool["function"]["parameters"].pop(
                         "additionalProperties", None
                     )
 
-        response = await self._async_client.chat.completions.create(
+        return self._client.chat.completions.create(
             messages=messages,
             model=self.model_type,
-            **kwargs,
+            **request_config,
         )
-        return response
 
-    def _run(
+    async def _arequest_chat_completion(
         self,
         messages: List[OpenAIMessage],
-        response_format: Optional[Type[BaseModel]] = None,
         tools: Optional[List[Dict[str, Any]]] = None,
-    ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
-        r"""Runs inference of OpenAI chat completion.
+    ) -> Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+        request_config = self.model_config_dict.copy()
 
-        Args:
-            messages (List[OpenAIMessage]): Message list with the chat history
-                in OpenAI API format.
-            response_format (Optional[Type[BaseModel]], optional): The format
-                to return the response in.
-            tools (Optional[List[Dict[str, Any]]], optional): List of tools
-                the model may call.
+        if tools:
+            request_config["tools"] = tools
+            # Remove additionalProperties from each tool's function parameters
+            if "tools" in request_config:
+                for tool in request_config["tools"]:
+                    if "function" in tool and "parameters" in tool["function"]:
+                        tool["function"]["parameters"].pop(
+                            "additionalProperties", None
+                        )
 
-        Returns:
-            Union[ChatCompletion, Stream[ChatCompletionChunk]]:
-                `ChatCompletion` in the non-stream mode, or
-                `Stream[ChatCompletionChunk]` in the stream mode.
-        """
+        return await self._async_client.chat.completions.create(
+            messages=messages,
+            model=self.model_type,
+            **request_config,
+        )
 
-        kwargs = self.model_config_dict.copy()
-        if tools:
-            kwargs["tools"] = tools
-        if response_format:
-            kwargs["response_format"] = {"type": "json_object"}
+    def _request_parse(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Type[BaseModel],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> ChatCompletion:
+        request_config = self.model_config_dict.copy()
 
-        # Remove additionalProperties from each tool's function parameters
-        if tools and "tools" in kwargs:
-            for tool in kwargs["tools"]:
-                if "function" in tool and "parameters" in tool["function"]:
-                    tool["function"]["parameters"].pop(
-                        "additionalProperties", None
-                    )
+        request_config["response_format"] = response_format
+        request_config.pop("stream", None)
+        if tools is not None:
+            # Create a deep copy of tools to avoid modifying the original
+            import copy
+
+            request_config["tools"] = copy.deepcopy(tools)
+            # Remove additionalProperties and strict from each tool's function
+            # parameters since vLLM does not support them
+            if "tools" in request_config:
+                for tool in request_config["tools"]:
+                    if "function" in tool and "parameters" in tool["function"]:
+                        tool["function"]["parameters"].pop(
+                            "additionalProperties", None
+                        )
+                    if "strict" in tool.get("function", {}):
+                        tool["function"].pop("strict")
 
-        response = self._client.chat.completions.create(
+        return self._client.beta.chat.completions.parse(
             messages=messages,
             model=self.model_type,
-            **kwargs,
+            **request_config,
         )
-        return response
+
+    async def _arequest_parse(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Type[BaseModel],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> ChatCompletion:
+        request_config = self.model_config_dict.copy()
+
+        request_config["response_format"] = response_format
+        request_config.pop("stream", None)
+        if tools is not None:
+            # Create a deep copy of tools to avoid modifying the original
+            import copy
+
+            request_config["tools"] = copy.deepcopy(tools)
+            # Remove additionalProperties and strict from each tool's function
+            # parameters since vLLM does not support them
+            if "tools" in request_config:
+                for tool in request_config["tools"]:
+                    if "function" in tool and "parameters" in tool["function"]:
+                        tool["function"]["parameters"].pop(
+                            "additionalProperties", None
+                        )
+                    if "strict" in tool.get("function", {}):
+                        tool["function"].pop("strict")
+
+        return await self._async_client.beta.chat.completions.parse(
+            messages=messages,
+            model=self.model_type,
+            **request_config,
+        )
+
+    def check_model_config(self):
+        r"""Check whether the model configuration contains any
+        unexpected arguments to vLLM API.
+
+        Raises:
+            ValueError: If the model configuration dictionary contains any
+                unexpected arguments to OpenAI API.
+        """
+        for param in self.model_config_dict:
+            if param not in VLLM_API_PARAMS:
+                raise ValueError(
+                    f"Unexpected argument `{param}` is "
+                    "input into vLLM model backend."
+                )
 
     @property
     def stream(self) -> bool:

camel/societies/workforce/workforce.py

@@ -15,7 +15,6 @@ from __future__ import annotations
 
 import asyncio
 import json
-import logging
 from collections import deque
 from typing import Deque, Dict, List, Optional
 
@@ -23,6 +22,7 @@ from colorama import Fore
 
 from camel.agents import ChatAgent
 from camel.configs import ChatGPTConfig
+from camel.logger import get_logger
 from camel.messages.base import BaseMessage
 from camel.models import ModelFactory
 from camel.societies.workforce.base import BaseNode
@@ -44,7 +44,7 @@ from camel.tasks.task import Task, TaskState
 from camel.toolkits import GoogleMapsToolkit, SearchToolkit, WeatherToolkit
 from camel.types import ModelPlatformType, ModelType
 
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
 
 class Workforce(BaseNode):
@@ -60,13 +60,16 @@ class Workforce(BaseNode):
             another workforce node. (default: :obj:`None`)
         coordinator_agent_kwargs (Optional[Dict], optional): Keyword
             arguments for the coordinator agent, e.g. `model`, `api_key`,
-            `tools`, etc. (default: :obj:`None`)
+            `tools`, etc. If not provided, default model settings will be used.
+            (default: :obj:`None`)
         task_agent_kwargs (Optional[Dict], optional): Keyword arguments for
             the task agent, e.g. `model`, `api_key`, `tools`, etc.
+            If not provided, default model settings will be used.
             (default: :obj:`None`)
         new_worker_agent_kwargs (Optional[Dict]): Default keyword arguments
             for the worker agent that will be created during runtime to
             handle failed tasks, e.g. `model`, `api_key`, `tools`, etc.
+            If not provided, default model settings will be used.
             (default: :obj:`None`)
     """
 
@@ -83,6 +86,26 @@ class Workforce(BaseNode):
         self._children = children or []
         self.new_worker_agent_kwargs = new_worker_agent_kwargs
 
+        # Warning messages for default model usage
+        if coordinator_agent_kwargs is None:
+            logger.warning(
+                "No coordinator_agent_kwargs provided. "
+                "Using `ModelPlatformType.DEFAULT` and `ModelType.DEFAULT` "
+                "for coordinator agent."
+            )
+        if task_agent_kwargs is None:
+            logger.warning(
+                "No task_agent_kwargs provided. "
+                "Using `ModelPlatformType.DEFAULT` and `ModelType.DEFAULT` "
+                "for task agent."
+            )
+        if new_worker_agent_kwargs is None:
+            logger.warning(
+                "No new_worker_agent_kwargs provided. "
+                "Using `ModelPlatformType.DEFAULT` and `ModelType.DEFAULT` "
+                "for worker agents created during runtime."
+            )
+
         coord_agent_sys_msg = BaseMessage.make_assistant_message(
             role_name="Workforce Manager",
             content="You are coordinating a group of workers. A worker can be "