camel-ai 0.1.5.7__py3-none-any.whl → 0.1.6.0__py3-none-any.whl

camel/interpreters/ipython_interpreter.py

@@ -0,0 +1,167 @@
+# =========== Copyright 2023 @ 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 @ CAMEL-AI.org. All Rights Reserved. ===========
+
+import queue
+import re
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
+
+from camel.interpreters.base import BaseInterpreter
+from camel.interpreters.interpreter_error import InterpreterError
+
+if TYPE_CHECKING:
+    from jupyter_client import BlockingKernelClient, KernelManager
+
+TIMEOUT = 30
+
+
+class JupyterKernelInterpreter(BaseInterpreter):
+    r"""A class for executing code strings in a Jupyter Kernel.
+
+    Args:
+        require_confirm (bool, optional): If `True`, prompt user before
+            running code strings for security. Defaults to `True`.
+        print_stdout (bool, optional): If `True`, print the standard
+            output of the executed code. Defaults to `False`.
+        print_stderr (bool, optional): If `True`, print the standard error
+            of the executed code. Defaults to `True`.
+    """
+
+    def __init__(
+        self,
+        require_confirm: bool = True,
+        print_stdout: bool = False,
+        print_stderr: bool = True,
+    ) -> None:
+        self.require_confirm = require_confirm
+        self.print_stdout = print_stdout
+        self.print_stderr = print_stderr
+
+        self.kernel_manager: Optional[KernelManager] = None
+        self.client: Optional[BlockingKernelClient] = None
+
+    def __del__(self) -> None:
+        r"""Clean up the kernel and client."""
+
+        if self.kernel_manager:
+            self.kernel_manager.shutdown_kernel()
+        if self.client:
+            self.client.stop_channels()
+
+    def _initialize_if_needed(self) -> None:
+        r"""Initialize the kernel manager and client if they are not already
+        initialized.
+        """
+
+        if self.kernel_manager is not None:
+            return
+
+        from jupyter_client.manager import start_new_kernel
+
+        self.kernel_manager, self.client = start_new_kernel()
+
+    @staticmethod
+    def _clean_ipython_output(output: str) -> str:
+        r"""Remove ANSI escape sequences from the output."""
+
+        ansi_escape = re.compile(r'\x1B[@-_][0-?]*[ -/]*[@-~]')
+        return ansi_escape.sub('', output)
+
+    def _execute(self, code: str, timeout: float) -> str:
+        r"""Execute the code in the Jupyter kernel and return the result."""
+
+        if not self.kernel_manager or not self.client:
+            raise InterpreterError("Jupyter client is not initialized.")
+
+        self.client.execute(code)
+        outputs = []
+        while True:
+            try:
+                msg = self.client.get_iopub_msg(timeout=timeout)
+                msg_content = msg["content"]
+                msg_type = msg.get("msg_type", None)
+
+                if msg_content.get("execution_state", None) == "idle":
+                    break
+
+                if msg_type == "error":
+                    print(msg_content.keys())
+                    print(msg_content)
+                    traceback = "\n".join(msg_content["traceback"])
+                    outputs.append(traceback)
+                elif msg_type == "stream":
+                    outputs.append(msg_content["text"])
+                elif msg_type in ["execute_result", "display_data"]:
+                    outputs.append(msg_content["data"]["text/plain"])
+                    if "image/png" in msg_content["data"]:
+                        outputs.append(
+                            f"\n![image](data:image/png;base64,{msg_content['data']['image/png']})\n"
+                        )
+            except queue.Empty:
+                outputs.append("Time out")
+                break
+            except Exception as e:
+                outputs.append(f"Exception occurred: {e!s}")
+                break
+
+        exec_result = "\n".join(outputs)
+        return self._clean_ipython_output(exec_result)
+
+    def run(self, code: str, code_type: str) -> str:
+        r"""Executes the given code in the Jupyter kernel.
+
+        Args:
+            code (str): The code string to execute.
+            code_type (str): The type of code to execute (e.g., 'python',
+                'bash').
+
+        Returns:
+            str: A string containing the captured result of the
+                executed code.
+
+        Raises:
+            InterpreterError: If there is an error when doing code execution.
+        """
+        self._initialize_if_needed()
+
+        if code_type == "bash":
+            code = f"%%bash\n({code})"
+        try:
+            result = self._execute(code, timeout=TIMEOUT)
+        except Exception as e:
+            raise InterpreterError(f"Execution failed: {e!s}")
+
+        return result
+
+    def supported_code_types(self) -> List[str]:
+        r"""Provides supported code types by the interpreter.
+
+        Returns:
+            List[str]: Supported code types.
+        """
+        return ["python", "bash"]
+
+    def update_action_space(self, action_space: Dict[str, Any]) -> None:
+        r"""Updates the action space for the interpreter.
+
+        Args:
+            action_space (Dict[str, Any]): A dictionary representing the
+                new or updated action space.
+
+        Raises:
+            RuntimeError: Always raised because `JupyterKernelInterpreter`
+                does not support updating the action space.
+        """
+        raise RuntimeError(
+            "SubprocessInterpreter doesn't support " "`action_space`."
+        )

camel/models/__init__.py

@@ -12,9 +12,12 @@
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 from .anthropic_model import AnthropicModel
+from .azure_openai_model import AzureOpenAIModel
 from .base_model import BaseModelBackend
 from .gemini_model import GeminiModel
+from .groq_model import GroqModel
 from .litellm_model import LiteLLMModel
+from .mistral_model import MistralModel
 from .model_factory import ModelFactory
 from .nemotron_model import NemotronModel
 from .ollama_model import OllamaModel
@@ -22,12 +25,16 @@ from .open_source_model import OpenSourceModel
 from .openai_audio_models import OpenAIAudioModels
 from .openai_model import OpenAIModel
 from .stub_model import StubModel
+from .vllm_model import VLLMModel
 from .zhipuai_model import ZhipuAIModel
 
 __all__ = [
     'BaseModelBackend',
     'OpenAIModel',
+    'AzureOpenAIModel',
     'AnthropicModel',
+    'MistralModel',
+    'GroqModel',
     'StubModel',
     'ZhipuAIModel',
     'OpenSourceModel',
@@ -36,5 +43,6 @@ __all__ = [
     'OpenAIAudioModels',
     'NemotronModel',
     'OllamaModel',
+    'VLLMModel',
     'GeminiModel',
 ]

camel/models/anthropic_model.py

@@ -36,6 +36,7 @@ class AnthropicModel(BaseModelBackend):
         model_config_dict: Dict[str, Any],
         api_key: Optional[str] = None,
         url: Optional[str] = None,
+        token_counter: Optional[BaseTokenCounter] = None,
     ) -> None:
         r"""Constructor for Anthropic backend.
 
@@ -48,12 +49,16 @@ class AnthropicModel(BaseModelBackend):
                 Anthropic service. (default: :obj:`None`)
             url (Optional[str]): The url to the Anthropic service. (default:
                 :obj:`None`)
+            token_counter (Optional[BaseTokenCounter]): Token counter to use
+                for the model. If not provided, `AnthropicTokenCounter` will
+                be used.
         """
-        super().__init__(model_type, model_config_dict, api_key, url)
+        super().__init__(
+            model_type, model_config_dict, api_key, url, token_counter
+        )
         self._api_key = api_key or os.environ.get("ANTHROPIC_API_KEY")
         self._url = url or os.environ.get("ANTHROPIC_API_BASE_URL")
         self.client = Anthropic(api_key=self._api_key, base_url=self._url)
-        self._token_counter: Optional[BaseTokenCounter] = None
 
     def _convert_response_from_anthropic_to_openai(self, response):
         # openai ^1.0.0 format, reference openai/types/chat/chat_completion.py

camel/models/azure_openai_model.py

@@ -0,0 +1,152 @@
+# =========== Copyright 2023 @ 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 @ CAMEL-AI.org. All Rights Reserved. ===========
+import os
+from typing import Any, Dict, List, Optional, Union
+
+from openai import AzureOpenAI, Stream
+
+from camel.configs import OPENAI_API_PARAMS
+from camel.messages import OpenAIMessage
+from camel.models.base_model import BaseModelBackend
+from camel.types import ChatCompletion, ChatCompletionChunk, ModelType
+from camel.utils import BaseTokenCounter, OpenAITokenCounter, api_keys_required
+
+
+class AzureOpenAIModel(BaseModelBackend):
+    r"""Azure OpenAI API in a unified BaseModelBackend interface.
+    Doc: https://learn.microsoft.com/en-us/azure/ai-services/openai/
+    """
+
+    def __init__(
+        self,
+        model_type: ModelType,
+        model_config_dict: Dict[str, Any],
+        api_key: Optional[str] = None,
+        url: Optional[str] = None,
+        api_version: Optional[str] = None,
+        azure_deployment_name: Optional[str] = None,
+    ) -> None:
+        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`)
+            api_version (Optional[str]): The api version for the model.
+            azure_deployment_name (Optional[str]): The deployment name you
+                chose when you deployed an azure model. (default: :obj:`None`)
+        """
+        super().__init__(model_type, model_config_dict, api_key, url)
+        self._url = url or os.environ.get("AZURE_OPENAI_ENDPOINT")
+        self._api_key = api_key or os.environ.get("AZURE_OPENAI_API_KEY")
+        self.api_version = api_version or os.environ.get("AZURE_API_VERSION")
+        self.azure_deployment_name = azure_deployment_name or os.environ.get(
+            "AZURE_DEPLOYMENT_NAME"
+        )
+
+        if self._url is None:
+            raise ValueError(
+                "Must provide either the `url` argument "
+                "or `AZURE_OPENAI_ENDPOINT` environment variable."
+            )
+        if self._api_key is None:
+            raise ValueError(
+                "Must provide either the `api_key` argument "
+                "or `AZURE_OPENAI_API_KEY` environment variable."
+            )
+        if self.api_version is None:
+            raise ValueError(
+                "Must provide either the `api_version` argument "
+                "or `AZURE_API_VERSION` environment variable."
+            )
+        if self.azure_deployment_name is None:
+            raise ValueError(
+                "Must provide either the `azure_deployment_name` argument "
+                "or `AZURE_DEPLOYMENT_NAME` environment variable."
+            )
+        self.model = str(self.azure_deployment_name)
+
+        self._client = AzureOpenAI(
+            azure_endpoint=str(self._url),
+            azure_deployment=self.azure_deployment_name,
+            api_version=self.api_version,
+            api_key=self._api_key,
+            timeout=60,
+            max_retries=3,
+        )
+        self._token_counter: Optional[BaseTokenCounter] = None
+
+    @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(self.model_type)
+        return self._token_counter
+
+    @api_keys_required("AZURE_OPENAI_API_KEY", "AZURE_API_VERSION")
+    def run(
+        self,
+        messages: List[OpenAIMessage],
+    ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+        r"""Runs inference of Azure 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,
+            **self.model_config_dict,
+        )
+        return response
+
+    def check_model_config(self):
+        r"""Check whether the model configuration contains any
+        unexpected arguments to Azure OpenAI API.
+
+        Raises:
+            ValueError: If the model configuration dictionary contains any
+                unexpected arguments to Azure OpenAI API.
+        """
+        for param in self.model_config_dict:
+            if param not in OPENAI_API_PARAMS:
+                raise ValueError(
+                    f"Unexpected argument `{param}` is "
+                    "input into Azure OpenAI model backend."
+                )
+
+    @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/base_model.py

@@ -32,6 +32,7 @@ class BaseModelBackend(ABC):
         model_config_dict: Dict[str, Any],
         api_key: Optional[str] = None,
         url: Optional[str] = None,
+        token_counter: Optional[BaseTokenCounter] = None,
     ) -> None:
         r"""Constructor for the model backend.
 
@@ -41,13 +42,16 @@ class BaseModelBackend(ABC):
             api_key (Optional[str]): The API key for authenticating with the
                 model service.
             url (Optional[str]): The url to the model service.
+            token_counter (Optional[BaseTokenCounter]): Token counter to use
+                for the model. If not provided, `OpenAITokenCounter` will
+                be used.
         """
         self.model_type = model_type
-
         self.model_config_dict = model_config_dict
         self._api_key = api_key
         self._url = url
         self.check_model_config()
+        self._token_counter = token_counter
 
     @property
     @abstractmethod

camel/models/gemini_model.py

@@ -44,6 +44,7 @@ class GeminiModel(BaseModelBackend):
         model_config_dict: Dict[str, Any],
         api_key: Optional[str] = None,
         url: Optional[str] = None,
+        token_counter: Optional[BaseTokenCounter] = None,
     ) -> None:
         r"""Constructor for Gemini backend.
 
@@ -54,17 +55,22 @@ class GeminiModel(BaseModelBackend):
             api_key (Optional[str]): The API key for authenticating with the
                 gemini service. (default: :obj:`None`)
             url (Optional[str]): The url to the gemini service.
+            token_counter (Optional[BaseTokenCounter]): Token counter to use
+                for the model. If not provided, `GeminiTokenCounter` will be
+                used.
         """
         import os
 
         import google.generativeai as genai
         from google.generativeai.types.generation_types import GenerationConfig
 
-        super().__init__(model_type, model_config_dict, api_key, url)
+        super().__init__(
+            model_type, model_config_dict, api_key, url, token_counter
+        )
         self._api_key = api_key or os.environ.get("GOOGLE_API_KEY")
         genai.configure(api_key=self._api_key)
         self._client = genai.GenerativeModel(self.model_type.value)
-        self._token_counter: Optional[BaseTokenCounter] = None
+
         keys = list(self.model_config_dict.keys())
         generation_config_dict = {
             k: self.model_config_dict.pop(k)
@@ -78,6 +84,12 @@ class GeminiModel(BaseModelBackend):
 
     @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 = GeminiTokenCounter(self.model_type)
         return self._token_counter

camel/models/groq_model.py

@@ -0,0 +1,131 @@
+# =========== Copyright 2023 @ 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 @ CAMEL-AI.org. All Rights Reserved. ===========
+import os
+from typing import Any, Dict, List, Optional, Union
+
+from openai import OpenAI, Stream
+
+from camel.configs import GROQ_API_PARAMS
+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 GroqModel(BaseModelBackend):
+    r"""LLM API served by Groq in a unified BaseModelBackend interface."""
+
+    def __init__(
+        self,
+        model_type: ModelType,
+        model_config_dict: Dict[str, Any],
+        api_key: Optional[str] = None,
+        url: Optional[str] = None,
+        token_counter: Optional[BaseTokenCounter] = None,
+    ) -> None:
+        r"""Constructor for Groq backend.
+
+        Args:
+            model_type (str): Model for which a backend is created.
+            model_config_dict (Dict[str, Any]): A dictionary of parameters for
+                the model configuration.
+            api_key (Optional[str]): The API key for authenticating with the
+                Groq service. (default: :obj:`None`).
+            url (Optional[str]): The url to the Groq service. (default:
+                :obj:`None`)
+            token_counter (Optional[BaseTokenCounter]): Token counter to use
+                for the model. If not provided, `OpenAITokenCounter(ModelType.
+                GPT_3_5_TURBO)` will be used.
+        """
+        super().__init__(
+            model_type, model_config_dict, api_key, url, token_counter
+        )
+        self._url = url or "https://api.groq.com/openai/v1"
+        self._api_key = api_key or os.environ.get("GROQ_API_KEY")
+        self._client = OpenAI(
+            timeout=60,
+            max_retries=3,
+            api_key=self._api_key,
+            base_url=self._url,
+        )
+        self._token_counter = token_counter
+
+    @property
+    def token_counter(self) -> BaseTokenCounter:
+        r"""Initialize the token counter for the model backend.
+
+        Returns:
+            BaseTokenCounter: The token counter following the model's
+                tokenization style.
+        """
+        # Make sure you have the access to these open-source model in
+        # HuggingFace
+        if not self._token_counter:
+            self._token_counter = OpenAITokenCounter(ModelType.GPT_3_5_TURBO)
+        return self._token_counter
+
+    @api_keys_required("GROQ_API_KEY")
+    def run(
+        self,
+        messages: List[OpenAIMessage],
+    ) -> 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.value,
+            **self.model_config_dict,
+        )
+
+        return response
+
+    def check_model_config(self):
+        r"""Check whether the model configuration contains any unexpected
+        arguments to Groq API. But Groq API does not have any additional
+        arguments to check.
+
+        Raises:
+            ValueError: If the model configuration dictionary contains any
+                unexpected arguments to Groq API.
+        """
+        for param in self.model_config_dict:
+            if param not in GROQ_API_PARAMS:
+                raise ValueError(
+                    f"Unexpected argument `{param}` is "
+                    "input into Groq model backend."
+                )
+
+    @property
+    def stream(self) -> bool:
+        r"""Returns whether the model supports streaming. But Groq API does
+        not support streaming.
+        """
+        return False

camel/models/litellm_model.py

@@ -16,7 +16,7 @@ from typing import Any, Dict, List, Optional
 from camel.configs import LITELLM_API_PARAMS
 from camel.messages import OpenAIMessage
 from camel.types import ChatCompletion
-from camel.utils import LiteLLMTokenCounter
+from camel.utils import BaseTokenCounter, LiteLLMTokenCounter
 
 
 class LiteLLMModel:
@@ -30,6 +30,7 @@ class LiteLLMModel:
         model_config_dict: Dict[str, Any],
         api_key: Optional[str] = None,
         url: Optional[str] = None,
+        token_counter: Optional[BaseTokenCounter] = None,
     ) -> None:
         r"""Constructor for LiteLLM backend.
 
@@ -42,11 +43,14 @@ class LiteLLMModel:
                 model service. (default: :obj:`None`)
             url (Optional[str]): The url to the model service. (default:
                 :obj:`None`)
+            token_counter (Optional[BaseTokenCounter]): Token counter to use
+                for the model. If not provided, `LiteLLMTokenCounter` will
+                be used.
         """
         self.model_type = model_type
         self.model_config_dict = model_config_dict
         self._client = None
-        self._token_counter: Optional[LiteLLMTokenCounter] = None
+        self._token_counter = token_counter
         self.check_model_config()
         self._url = url
         self._api_key = api_key
@@ -98,8 +102,10 @@ class LiteLLMModel:
                 tokenization style.
         """
         if not self._token_counter:
-            self._token_counter = LiteLLMTokenCounter(self.model_type)
-        return self._token_counter
+            self._token_counter = LiteLLMTokenCounter(  # type: ignore[assignment]
+                self.model_type
+            )
+        return self._token_counter  # type: ignore[return-value]
 
     def run(
         self,