camel-ai 0.2.3__py3-none-any.whl → 0.2.3a0__py3-none-any.whl

camel/models/{openai_compatible_model.py → openai_compatibility_model.py}

@@ -18,54 +18,59 @@ from typing import Any, Dict, List, Optional, Union
 from openai import OpenAI, Stream
 
 from camel.messages import OpenAIMessage
-from camel.models import BaseModelBackend
-from camel.types import (
-    ChatCompletion,
-    ChatCompletionChunk,
-    ModelType,
-)
+from camel.types import ChatCompletion, ChatCompletionChunk, ModelType
 from camel.utils import (
     BaseTokenCounter,
     OpenAITokenCounter,
 )
 
 
-class OpenAICompatibleModel(BaseModelBackend):
-    r"""Constructor for model backend supporting OpenAI compatibility.
-
-    Args:
-        model_type (Union[ModelType, str]): Model for which a backend is
-            created.
-        model_config_dict (Optional[Dict[str, Any]], optional): A dictionary
-            that will be fed into:obj:`openai.ChatCompletion.create()`. If
-            :obj:`None`, :obj:`{}` will be used. (default: :obj:`None`)
-        api_key (str): The API key for authenticating with the model service.
-        url (str): The url to the model service.
-        token_counter (Optional[BaseTokenCounter], optional): Token counter to
-            use for the model. If not provided, :obj:`OpenAITokenCounter(
-            ModelType.GPT_4O_MINI)` will be used.
-            (default: :obj:`None`)
-    """
+class OpenAICompatibilityModel:
+    r"""LLM API served by OpenAI-compatible providers."""
 
     def __init__(
         self,
-        model_type: Union[ModelType, str],
-        model_config_dict: Optional[Dict[str, Any]] = None,
+        model_type: str,
+        model_config_dict: Dict[str, Any],
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
     ) -> None:
-        self.api_key = api_key or os.environ.get("OPENAI_COMPATIBILIY_API_KEY")
-        self.url = url or os.environ.get("OPENAI_COMPATIBILIY_API_BASE_URL")
-        super().__init__(
-            model_type, model_config_dict, api_key, url, token_counter
+        r"""Constructor for model backend.
+
+        Args:
+            model_type (str): Model for which a backend is created.
+            model_config_dict (Dict[str, Any]): A dictionary that will
+                be fed into openai.ChatCompletion.create().
+            api_key (str): The API key for authenticating with the
+                model service. (default: :obj:`None`)
+            url (str): The url to the model service. (default:
+                :obj:`None`)
+            token_counter (Optional[BaseTokenCounter]): Token counter to use
+                for the model. If not provided, `OpenAITokenCounter(ModelType.
+                GPT_4O_MINI)` will be used.
+        """
+        self.model_type = model_type
+        self.model_config_dict = model_config_dict
+        self._url = url or os.environ.get("OPENAI_COMPATIBILIY_API_BASE_URL")
+        self._api_key = api_key or os.environ.get(
+            "OPENAI_COMPATIBILIY_API_KEY"
         )
+        if self._url is None:
+            raise ValueError(
+                "For OpenAI-compatible models, you must provide the `url`."
+            )
+        if self._api_key is None:
+            raise ValueError(
+                "For OpenAI-compatible models, you must provide the `api_key`."
+            )
         self._client = OpenAI(
             timeout=60,
             max_retries=3,
-            api_key=self._api_key,
             base_url=self._url,
+            api_key=self._api_key,
         )
+        self._token_counter = token_counter
 
     def run(
         self,
@@ -112,5 +117,18 @@ class OpenAICompatibleModel(BaseModelBackend):
         """
         return self.model_config_dict.get('stream', False)
 
-    def check_model_config(self):
-        pass
+    @property
+    def token_limit(self) -> int:
+        r"""Returns the maximum token limit for the given model.
+
+        Returns:
+            int: The maximum token limit for the given model.
+        """
+        max_tokens = self.model_config_dict.get("max_tokens")
+        if isinstance(max_tokens, int):
+            return max_tokens
+        print(
+            "Must set `max_tokens` as an integer in `model_config_dict` when"
+            " setting up the model. Using 4096 as default value."
+        )
+        return 4096

camel/models/openai_model.py

@@ -12,19 +12,14 @@
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 import os
-import warnings
 from typing import Any, Dict, List, Optional, Union
 
 from openai import OpenAI, Stream
 
-from camel.configs import OPENAI_API_PARAMS, ChatGPTConfig
+from camel.configs import OPENAI_API_PARAMS
 from camel.messages import OpenAIMessage
 from camel.models import BaseModelBackend
-from camel.types import (
-    ChatCompletion,
-    ChatCompletionChunk,
-    ModelType,
-)
+from camel.types import ChatCompletion, ChatCompletionChunk, ModelType
 from camel.utils import (
     BaseTokenCounter,
     OpenAITokenCounter,
@@ -33,39 +28,36 @@ from camel.utils import (
 
 
 class OpenAIModel(BaseModelBackend):
-    r"""OpenAI API in a unified BaseModelBackend interface.
-
-    Args:
-        model_type (Union[ModelType, str]): Model for which a backend is
-            created, one of GPT_* series.
-        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.
-            (default: :obj:`None`)
-        api_key (Optional[str], optional): The API key for authenticating
-            with the OpenAI service. (default: :obj:`None`)
-        url (Optional[str], optional): The url to the OpenAI service.
-            (default: :obj:`None`)
-        token_counter (Optional[BaseTokenCounter], optional): Token counter to
-            use for the model. If not provided, :obj:`OpenAITokenCounter` will
-            be used. (default: :obj:`None`)
-    """
+    r"""OpenAI API in a unified BaseModelBackend interface."""
 
     def __init__(
         self,
-        model_type: Union[ModelType, str],
-        model_config_dict: Optional[Dict[str, Any]] = None,
+        model_type: ModelType,
+        model_config_dict: Dict[str, Any],
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
     ) -> None:
-        if model_config_dict is None:
-            model_config_dict = ChatGPTConfig().as_dict()
-        api_key = api_key or os.environ.get("OPENAI_API_KEY")
-        url = url or os.environ.get("OPENAI_API_BASE_URL")
+        r"""Constructor for OpenAI backend.
+
+        Args:
+            model_type (ModelType): Model for which a backend is created,
+                one of GPT_* series.
+            model_config_dict (Dict[str, Any]): A dictionary that will
+                be fed into openai.ChatCompletion.create().
+            api_key (Optional[str]): The API key for authenticating with the
+                OpenAI service. (default: :obj:`None`)
+            url (Optional[str]): The url to the OpenAI service. (default:
+                :obj:`None`)
+            token_counter (Optional[BaseTokenCounter]): Token counter to use
+                for the model. If not provided, `OpenAITokenCounter` will
+                be used.
+        """
         super().__init__(
             model_type, model_config_dict, api_key, url, token_counter
         )
+        self._url = url or os.environ.get("OPENAI_API_BASE_URL")
+        self._api_key = api_key or os.environ.get("OPENAI_API_KEY")
         self._client = OpenAI(
             timeout=60,
             max_retries=3,
@@ -104,23 +96,13 @@ class OpenAIModel(BaseModelBackend):
         # o1-preview and o1-mini have Beta limitations
         # reference: https://platform.openai.com/docs/guides/reasoning
         if self.model_type in [ModelType.O1_MINI, ModelType.O1_PREVIEW]:
-            warnings.warn(
-                "Warning: You are using an O1 model (O1_MINI or O1_PREVIEW), "
-                "which has certain limitations, reference: "
-                "`https://platform.openai.com/docs/guides/reasoning`.",
-                UserWarning,
-            )
-
             # Remove system message that is not supported in o1 model.
             messages = [msg for msg in messages if msg.get("role") != "system"]
 
-            # Check and remove unsupported parameters and reset the fixed
-            # parameters
-            unsupported_keys = ["stream", "tools", "tool_choice"]
-            for key in unsupported_keys:
-                if key in self.model_config_dict:
-                    del self.model_config_dict[key]
-
+            # Remove unsupported parameters and reset the fixed parameters
+            del self.model_config_dict["stream"]
+            del self.model_config_dict["tools"]
+            del self.model_config_dict["tool_choice"]
             self.model_config_dict["temperature"] = 1.0
             self.model_config_dict["top_p"] = 1.0
             self.model_config_dict["n"] = 1.0
@@ -129,7 +111,7 @@ class OpenAIModel(BaseModelBackend):
 
         response = self._client.chat.completions.create(
             messages=messages,
-            model=self.model_type,
+            model=self.model_type.value,
             **self.model_config_dict,
         )
         return response
@@ -151,9 +133,8 @@ class OpenAIModel(BaseModelBackend):
 
     @property
     def stream(self) -> bool:
-        r"""Returns whether the model is in stream mode, which sends partial
-        results each time.
-
+        r"""Returns whether the model is in stream mode,
+            which sends partial results each time.
         Returns:
             bool: Whether the model is in stream mode.
         """

camel/models/reka_model.py

@@ -11,9 +11,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
+import os
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
 
-from camel.configs import REKA_API_PARAMS, RekaConfig
+from camel.configs import REKA_API_PARAMS
 from camel.messages import OpenAIMessage
 from camel.models import BaseModelBackend
 from camel.types import ChatCompletion, ModelType
@@ -21,7 +22,6 @@ from camel.utils import (
     BaseTokenCounter,
     OpenAITokenCounter,
     api_keys_required,
-    dependencies_required,
 )
 
 if TYPE_CHECKING:
@@ -39,42 +39,40 @@ except (ImportError, AttributeError):
 
 
 class RekaModel(BaseModelBackend):
-    r"""Reka API in a unified BaseModelBackend interface.
-
-    Args:
-        model_type (Union[ModelType, str]): Model for which a backend is
-            created, one of REKA_* series.
-        model_config_dict (Optional[Dict[str, Any]], optional): A dictionary
-            that will be fed into:obj:`Reka.chat.create()`. If :obj:`None`,
-            :obj:`RekaConfig().as_dict()` will be used. (default: :obj:`None`)
-        api_key (Optional[str], optional): The API key for authenticating with
-            the Reka service. (default: :obj:`None`)
-        url (Optional[str], optional): The url to the Reka service.
-            (default: :obj:`None`)
-        token_counter (Optional[BaseTokenCounter], optional): Token counter to
-            use for the model. If not provided, :obj:`OpenAITokenCounter` will
-            be used. (default: :obj:`None`)
-    """
-
-    @dependencies_required('reka')
+    r"""Reka API in a unified BaseModelBackend interface."""
+
     def __init__(
         self,
-        model_type: Union[ModelType, str],
-        model_config_dict: Optional[Dict[str, Any]] = None,
+        model_type: ModelType,
+        model_config_dict: Dict[str, Any],
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
     ) -> None:
-        from reka.client import Reka
+        r"""Constructor for Reka backend.
 
-        if model_config_dict is None:
-            model_config_dict = RekaConfig().as_dict()
-        api_key = api_key or os.environ.get("REKA_API_KEY")
-        url = url or os.environ.get("REKA_API_BASE_URL")
+        Args:
+            model_type (ModelType): Model for which a backend is created,
+                one of REKA_* series.
+            model_config_dict (Dict[str, Any]): A dictionary that will
+                be fed into `Reka.chat.create`.
+            api_key (Optional[str]): The API key for authenticating with the
+                Reka service. (default: :obj:`None`)
+            url (Optional[str]): The url to the Reka service.
+            token_counter (Optional[BaseTokenCounter]): Token counter to use
+                for the model. If not provided, `OpenAITokenCounter` will be
+                used.
+        """
         super().__init__(
             model_type, model_config_dict, api_key, url, token_counter
         )
+        self._api_key = api_key or os.environ.get("REKA_API_KEY")
+        self._url = url or os.environ.get("REKA_SERVER_URL")
+
+        from reka.client import Reka
+
         self._client = Reka(api_key=self._api_key, base_url=self._url)
+        self._token_counter: Optional[BaseTokenCounter] = None
 
     def _convert_reka_to_openai_response(
         self, response: 'ChatResponse'
@@ -186,7 +184,7 @@ class RekaModel(BaseModelBackend):
 
         response = self._client.chat.create(
             messages=reka_messages,
-            model=self.model_type,
+            model=self.model_type.value,
             **self.model_config_dict,
         )
 
@@ -202,7 +200,7 @@ class RekaModel(BaseModelBackend):
                 prompt_tokens=openai_response.usage.input_tokens,  # type: ignore[union-attr]
                 completion=openai_response.choices[0].message.content,
                 completion_tokens=openai_response.usage.output_tokens,  # type: ignore[union-attr]
-                model=self.model_type,
+                model=self.model_type.value,
             )
             record(llm_event)