camel-ai 0.1.6.6__py3-none-any.whl → 0.1.6.8__py3-none-any.whl

camel/__init__.py

@@ -12,7 +12,7 @@
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 
-__version__ = '0.1.6.6'
+__version__ = '0.1.6.8'
 
 __all__ = [
     '__version__',

camel/agents/chat_agent.py

@@ -14,6 +14,7 @@
 from __future__ import annotations
 
 import json
+import logging
 from collections import defaultdict
 from typing import (
     TYPE_CHECKING,
@@ -61,6 +62,9 @@ if TYPE_CHECKING:
     from camel.terminators import ResponseTerminator
     from camel.toolkits import OpenAIFunction
 
+
+logger = logging.getLogger(__name__)
+
 # AgentOps decorator setting
 try:
     import os
@@ -112,9 +116,6 @@ class ChatAgent(BaseAgent):
         model (BaseModelBackend, optional): The model backend to use for
             generating responses. (default: :obj:`OpenAIModel` with
             `GPT_4O_MINI`)
-        api_key (str, optional): The API key for authenticating with the
-            LLM service. Only OpenAI and Anthropic model supported (default:
-            :obj:`None`)
         memory (AgentMemory, optional): The agent memory for managing chat
             messages. If `None`, a :obj:`ChatHistoryMemory` will be used.
             (default: :obj:`None`)
@@ -138,7 +139,6 @@ class ChatAgent(BaseAgent):
         self,
         system_message: BaseMessage,
         model: Optional[BaseModelBackend] = None,
-        api_key: Optional[str] = None,
         memory: Optional[AgentMemory] = None,
         message_window_size: Optional[int] = None,
         token_limit: Optional[int] = None,
@@ -150,7 +150,6 @@ class ChatAgent(BaseAgent):
         self.system_message = system_message
         self.role_name: str = system_message.role_name
         self.role_type: RoleType = system_message.role_type
-        self._api_key = api_key
         self.model_backend: BaseModelBackend = (
             model
             if model is not None
@@ -158,7 +157,6 @@ class ChatAgent(BaseAgent):
                 model_platform=ModelPlatformType.OPENAI,
                 model_type=ModelType.GPT_4O_MINI,
                 model_config_dict=ChatGPTConfig().as_dict(),
-                api_key=self._api_key,
             )
         )
         self.output_language: Optional[str] = output_language
@@ -443,10 +441,22 @@ class ChatAgent(BaseAgent):
             for base_message_item in output_messages:
                 base_message_item.content = str(info['tool_calls'][-1].result)
 
-        return ChatAgentResponse(
+        chat_agent_response = ChatAgentResponse(
             msgs=output_messages, terminated=self.terminated, info=info
         )
 
+        # If the output result is single message, it will be
+        # automatically added to the memory.
+        if len(chat_agent_response.msgs) == 1:
+            self.record_message(chat_agent_response.msg)
+        else:
+            logger.warning(
+                "Multiple messages are available in `ChatAgentResponse`. "
+                "Please manually run the `record_message` function to "
+                "record the selected message."
+            )
+        return chat_agent_response
+
     async def step_async(
         self,
         input_message: BaseMessage,
@@ -569,10 +579,23 @@ class ChatAgent(BaseAgent):
             for base_message_item in output_messages:
                 base_message_item.content = str(info['tool_calls'][0].result)
 
-        return ChatAgentResponse(
+        chat_agent_response = ChatAgentResponse(
             msgs=output_messages, terminated=self.terminated, info=info
         )
 
+        # If the output result is single message, it will be
+        # automatically added to the memory.
+        if len(chat_agent_response.msgs) == 1:
+            self.record_message(chat_agent_response.msg)
+        else:
+            logger.warning(
+                "Multiple messages are presented in `chat_agent_response`. "
+                "Please manually call the `record_message` function to "
+                "record the chosen message."
+            )
+
+        return chat_agent_response
+
     def _add_tools_for_func_call(
         self,
         response: ChatCompletion,
@@ -742,7 +765,9 @@ class ChatAgent(BaseAgent):
             str(choice.finish_reason) for choice in response.choices
         ]
         usage = (
-            response.usage.model_dump() if response.usage is not None else {}
+            self._safe_model_dump(response.usage)
+            if response.usage is not None
+            else {}
         )
         return (
             output_messages,
@@ -751,6 +776,16 @@ class ChatAgent(BaseAgent):
             response.id,
         )
 
+    def _safe_model_dump(self, obj):
+        # Check if the `model_dump` method exists (Pydantic v2)
+        if hasattr(obj, 'model_dump'):
+            return obj.model_dump()
+        # Fallback to `dict()` method (Pydantic v1)
+        elif hasattr(obj, 'dict'):
+            return obj.dict()
+        else:
+            raise TypeError("The object is not a Pydantic model")
+
     def handle_stream_response(
         self,
         response: Stream[ChatCompletionChunk],

camel/agents/critic_agent.py

@@ -123,7 +123,6 @@ class CriticAgent(ChatAgent):
                 raise RuntimeError("Critic step failed.")
 
             critic_msg = critic_response.msg
-            self.record_message(critic_msg)
             if self.verbose:
                 print_text_animated(
                     self.logger_color + "\n> Critic response: "

camel/configs/__init__.py

@@ -19,6 +19,9 @@ from .litellm_config import LITELLM_API_PARAMS, LiteLLMConfig
 from .mistral_config import MISTRAL_API_PARAMS, MistralConfig
 from .ollama_config import OLLAMA_API_PARAMS, OllamaConfig
 from .openai_config import OPENAI_API_PARAMS, ChatGPTConfig, OpenSourceConfig
+from .reka_config import REKA_API_PARAMS, RekaConfig
+from .samba_config import SAMBA_API_PARAMS, SambaConfig
+from .togetherai_config import TOGETHERAI_API_PARAMS, TogetherAIConfig
 from .vllm_config import VLLM_API_PARAMS, VLLMConfig
 from .zhipuai_config import ZHIPUAI_API_PARAMS, ZhipuAIConfig
 
@@ -43,4 +46,10 @@ __all__ = [
     'VLLM_API_PARAMS',
     'MistralConfig',
     'MISTRAL_API_PARAMS',
+    'RekaConfig',
+    'REKA_API_PARAMS',
+    'SambaConfig',
+    'SAMBA_API_PARAMS',
+    'TogetherAIConfig',
+    'TOGETHERAI_API_PARAMS',
 ]

camel/configs/reka_config.py

@@ -0,0 +1,74 @@
+# =========== 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. ===========
+from __future__ import annotations
+
+from typing import Any, Optional, Union
+
+from camel.configs.base_config import BaseConfig
+
+
+class RekaConfig(BaseConfig):
+    r"""Defines the parameters for generating chat completions using the
+    Reka API.
+
+    Reference: https://docs.reka.ai/api-reference/chat/create
+
+    Args:
+        temperature (Optional[float], optional): temperature the temperature
+            to use for sampling, e.g. 0.5.
+        top_p (Optional[float], optional): the cumulative probability of
+            tokens to generate, e.g. 0.9. Defaults to None.
+        top_k (Optional[int], optional): Parameter which forces the model to
+            only consider the tokens with the `top_k` highest probabilities at
+            the next step. Defaults to 1024.
+        max_tokens (Optional[int], optional): the maximum number of tokens to
+            generate, e.g. 100. Defaults to None.
+        stop (Optional[Union[str,list[str]]]): Stop generation if this token
+            is detected. Or if one of these tokens is detected when providing
+            a string list.
+        seed (Optional[int], optional): the random seed to use for sampling, e.
+            g. 42. Defaults to None.
+        presence_penalty (float, optional): Number between :obj:`-2.0` and
+            :obj:`2.0`. Positive values penalize new tokens based on whether
+            they appear in the text so far, increasing the model's likelihood
+            to talk about new topics. See more information about frequency and
+            presence penalties. (default: :obj:`0.0`)
+        frequency_penalty (float, optional): Number between :obj:`-2.0` and
+            :obj:`2.0`. Positive values penalize new tokens based on their
+            existing frequency in the text so far, decreasing the model's
+            likelihood to repeat the same line verbatim. See more information
+            about frequency and presence penalties. (default: :obj:`0.0`)
+        use_search_engine (Optional[bool]): Whether to consider using search
+            engine to complete the request. Note that even if this is set to
+            `True`, the model might decide to not use search.
+    """
+
+    temperature: Optional[float] = None
+    top_p: Optional[float] = None
+    top_k: Optional[int] = None
+    max_tokens: Optional[int] = None
+    stop: Optional[Union[str, list[str]]] = None
+    seed: Optional[int] = None
+    frequency_penalty: float = 0.0
+    presence_penalty: float = 0.0
+    use_search_engine: Optional[bool] = False
+
+    def as_dict(self) -> dict[str, Any]:
+        config_dict = super().as_dict()
+        if "tools" in config_dict:
+            del config_dict["tools"]  # Reka does not support tool calling
+        return config_dict
+
+
+REKA_API_PARAMS = {param for param in RekaConfig().model_fields.keys()}

camel/configs/samba_config.py

@@ -0,0 +1,50 @@
+# =========== 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. ===========
+from __future__ import annotations
+
+from typing import Any, Dict, Optional, Union
+
+from camel.configs.base_config import BaseConfig
+
+
+class SambaConfig(BaseConfig):
+    r"""Defines the parameters for generating chat completions using the
+    SambaNova API.
+
+    Args:
+        max_tokens (Optional[int], optional): the maximum number of tokens to
+            generate, e.g. 100. Defaults to `None`.
+        stop (Optional[Union[str,list[str]]]): Stop generation if this token
+            is detected. Or if one of these tokens is detected when providing
+            a string list. Defaults to `None`.
+        stream (Optional[bool]): If True, partial message deltas will be sent
+            as data-only server-sent events as they become available.
+            Currently SambaNova only support stream mode. Defaults to `True`.
+        stream_options (Optional[Dict]): Additional options for streaming.
+            Defaults to `{"include_usage": True}`.
+    """
+
+    max_tokens: Optional[int] = None
+    stop: Optional[Union[str, list[str]]] = None
+    stream: Optional[bool] = True
+    stream_options: Optional[Dict] = {"include_usage": True}  # noqa: RUF012
+
+    def as_dict(self) -> dict[str, Any]:
+        config_dict = super().as_dict()
+        if "tools" in config_dict:
+            del config_dict["tools"]  # SambaNova does not support tool calling
+        return config_dict
+
+
+SAMBA_API_PARAMS = {param for param in SambaConfig().model_fields.keys()}

camel/configs/togetherai_config.py

@@ -0,0 +1,107 @@
+# =========== 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. ===========
+from __future__ import annotations
+
+from typing import Any, Sequence, Union
+
+from openai._types import NOT_GIVEN, NotGiven
+from pydantic import Field
+
+from camel.configs.base_config import BaseConfig
+
+
+class TogetherAIConfig(BaseConfig):
+    r"""Defines the parameters for generating chat completions using the
+    OpenAI API.
+
+    Args:
+        temperature (float, optional): Sampling temperature to use, between
+            :obj:`0` and :obj:`2`. Higher values make the output more random,
+            while lower values make it more focused and deterministic.
+            (default: :obj:`0.2`)
+        top_p (float, optional): An alternative to sampling with temperature,
+            called nucleus sampling, where the model considers the results of
+            the tokens with top_p probability mass. So :obj:`0.1` means only
+            the tokens comprising the top 10% probability mass are considered.
+            (default: :obj:`1.0`)
+        n (int, optional): How many chat completion choices to generate for
+            each input message. (default: :obj:`1`)
+        response_format (object, optional): An object specifying the format
+            that the model must output. Compatible with GPT-4 Turbo and all
+            GPT-3.5 Turbo models newer than gpt-3.5-turbo-1106. Setting to
+            {"type": "json_object"} enables JSON mode, which guarantees the
+            message the model generates is valid JSON. Important: when using
+            JSON mode, you must also instruct the model to produce JSON
+            yourself via a system or user message. Without this, the model
+            may generate an unending stream of whitespace until the generation
+            reaches the token limit, resulting in a long-running and seemingly
+            "stuck" request. Also note that the message content may be
+            partially cut off if finish_reason="length", which indicates the
+            generation exceeded max_tokens or the conversation exceeded the
+            max context length.
+        stream (bool, optional): If True, partial message deltas will be sent
+            as data-only server-sent events as they become available.
+            (default: :obj:`False`)
+        stop (str or list, optional): Up to :obj:`4` sequences where the API
+            will stop generating further tokens. (default: :obj:`None`)
+        max_tokens (int, optional): The maximum number of tokens to generate
+            in the chat completion. The total length of input tokens and
+            generated tokens is limited by the model's context length.
+            (default: :obj:`None`)
+        presence_penalty (float, optional): Number between :obj:`-2.0` and
+            :obj:`2.0`. Positive values penalize new tokens based on whether
+            they appear in the text so far, increasing the model's likelihood
+            to talk about new topics. See more information about frequency and
+            presence penalties. (default: :obj:`0.0`)
+        frequency_penalty (float, optional): Number between :obj:`-2.0` and
+            :obj:`2.0`. Positive values penalize new tokens based on their
+            existing frequency in the text so far, decreasing the model's
+            likelihood to repeat the same line verbatim. See more information
+            about frequency and presence penalties. (default: :obj:`0.0`)
+        logit_bias (dict, optional): Modify the likelihood of specified tokens
+            appearing in the completion. Accepts a json object that maps tokens
+            (specified by their token ID in the tokenizer) to an associated
+            bias value from :obj:`-100` to :obj:`100`. Mathematically, the bias
+            is added to the logits generated by the model prior to sampling.
+            The exact effect will vary per model, but values between:obj:` -1`
+            and :obj:`1` should decrease or increase likelihood of selection;
+            values like :obj:`-100` or :obj:`100` should result in a ban or
+            exclusive selection of the relevant token. (default: :obj:`{}`)
+        user (str, optional): A unique identifier representing your end-user,
+            which can help OpenAI to monitor and detect abuse.
+            (default: :obj:`""`)
+    """
+
+    temperature: float = 0.2  # openai default: 1.0
+    top_p: float = 1.0
+    n: int = 1
+    stream: bool = False
+    stop: Union[str, Sequence[str], NotGiven] = NOT_GIVEN
+    max_tokens: Union[int, NotGiven] = NOT_GIVEN
+    presence_penalty: float = 0.0
+    response_format: Union[dict, NotGiven] = NOT_GIVEN
+    frequency_penalty: float = 0.0
+    logit_bias: dict = Field(default_factory=dict)
+    user: str = ""
+
+    def as_dict(self) -> dict[str, Any]:
+        config_dict = super().as_dict()
+        if "tools" in config_dict:
+            del config_dict["tools"]  # Currently does not support tool calling
+        return config_dict
+
+
+TOGETHERAI_API_PARAMS = {
+    param for param in TogetherAIConfig.model_fields.keys()
+}

camel/models/__init__.py

@@ -25,7 +25,10 @@ from .open_source_model import OpenSourceModel
 from .openai_audio_models import OpenAIAudioModels
 from .openai_compatibility_model import OpenAICompatibilityModel
 from .openai_model import OpenAIModel
+from .reka_model import RekaModel
+from .samba_model import SambaModel
 from .stub_model import StubModel
+from .togetherai_model import TogetherAIModel
 from .vllm_model import VLLMModel
 from .zhipuai_model import ZhipuAIModel
 
@@ -47,4 +50,7 @@ __all__ = [
     'VLLMModel',
     'GeminiModel',
     'OpenAICompatibilityModel',
+    'RekaModel',
+    'SambaModel',
+    'TogetherAIModel',
 ]

camel/models/groq_model.py

@@ -51,21 +51,21 @@ class GroqModel(BaseModelBackend):
             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`)
+                :obj:`"https://api.groq.com/openai/v1"`)
             token_counter (Optional[BaseTokenCounter]): Token counter to use
                 for the model. If not provided, `OpenAITokenCounter(ModelType.
-                GPT_3_5_TURBO)` will be used.
+                GPT_4O_MINI)` 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._url = url or os.environ.get("GROQ_API_BASE_URL")
         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,
+            base_url=self._url or "https://api.groq.com/openai/v1",
         )
         self._token_counter = token_counter
 
@@ -80,7 +80,7 @@ class GroqModel(BaseModelBackend):
         # 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)
+            self._token_counter = OpenAITokenCounter(ModelType.GPT_4O_MINI)
         return self._token_counter
 
     @api_keys_required("GROQ_API_KEY")

camel/models/litellm_model.py

@@ -147,7 +147,7 @@ class LiteLLMModel:
 
     @property
     def token_limit(self) -> int:
-        """Returns the maximum token limit for the given model.
+        r"""Returns the maximum token limit for the given model.
 
         Returns:
             int: The maximum token limit for the given model.

camel/models/model_factory.py

@@ -24,7 +24,10 @@ from camel.models.ollama_model import OllamaModel
 from camel.models.open_source_model import OpenSourceModel
 from camel.models.openai_compatibility_model import OpenAICompatibilityModel
 from camel.models.openai_model import OpenAIModel
+from camel.models.reka_model import RekaModel
+from camel.models.samba_model import SambaModel
 from camel.models.stub_model import StubModel
+from camel.models.togetherai_model import TogetherAIModel
 from camel.models.vllm_model import VLLMModel
 from camel.models.zhipuai_model import ZhipuAIModel
 from camel.types import ModelPlatformType, ModelType
@@ -91,6 +94,10 @@ class ModelFactory:
                 model_class = GeminiModel
             elif model_platform.is_mistral and model_type.is_mistral:
                 model_class = MistralModel
+            elif model_platform.is_reka and model_type.is_reka:
+                model_class = RekaModel
+            elif model_platform.is_samba and model_type.is_samba:
+                model_class = SambaModel
             elif model_type == ModelType.STUB:
                 model_class = StubModel
             else:
@@ -110,6 +117,11 @@ class ModelFactory:
                 model_class = LiteLLMModel
             elif model_platform.is_openai_compatibility_model:
                 model_class = OpenAICompatibilityModel
+            elif model_platform.is_together:
+                model_class = TogetherAIModel
+                return model_class(
+                    model_type, model_config_dict, api_key, token_counter
+                )
             else:
                 raise ValueError(
                     f"Unknown pair of model platform `{model_platform}` "

camel/models/ollama_model.py

@@ -11,6 +11,7 @@
 # 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
@@ -40,18 +41,19 @@ class OllamaModel:
             model_config_dict (Dict[str, Any]): A dictionary that will
                 be fed into openai.ChatCompletion.create().
             url (Optional[str]): The url to the model service. (default:
-                :obj:`None`)
+                :obj:`"http://localhost:11434/v1"`)
             token_counter (Optional[BaseTokenCounter]): Token counter to use
                 for the model. If not provided, `OpenAITokenCounter(ModelType.
-                GPT_3_5_TURBO)` will be used.
+                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("OLLAMA_BASE_URL")
         # Use OpenAI cilent as interface call Ollama
         self._client = OpenAI(
             timeout=60,
             max_retries=3,
-            base_url=url,
+            base_url=self._url or "http://localhost:11434/v1",
             api_key="ollama",  # required but ignored
         )
         self._token_counter = token_counter
@@ -66,7 +68,7 @@ class OllamaModel:
                 tokenization style.
         """
         if not self._token_counter:
-            self._token_counter = OpenAITokenCounter(ModelType.GPT_3_5_TURBO)
+            self._token_counter = OpenAITokenCounter(ModelType.GPT_4O_MINI)
         return self._token_counter
 
     def check_model_config(self):

camel/models/openai_compatibility_model.py

@@ -38,7 +38,7 @@ class OpenAICompatibilityModel:
         r"""Constructor for model backend.
 
         Args:
-            model_type (ModelType): Model for which a backend is created.
+            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
@@ -47,7 +47,7 @@ class OpenAICompatibilityModel:
                 :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.
+                GPT_4O_MINI)` will be used.
         """
         self.model_type = model_type
         self.model_config_dict = model_config_dict
@@ -91,7 +91,7 @@ class OpenAICompatibilityModel:
         """
 
         if not self._token_counter:
-            self._token_counter = OpenAITokenCounter(ModelType.GPT_3_5_TURBO)
+            self._token_counter = OpenAITokenCounter(ModelType.GPT_4O_MINI)
         return self._token_counter
 
     @property