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

camel/__init__.py

@@ -14,7 +14,7 @@
 
 from camel.logger import disable_logging, enable_logging, set_log_level
 
-__version__ = '0.2.42'
+__version__ = '0.2.44'
 
 __all__ = [
     '__version__',

camel/configs/__init__.py

@@ -27,6 +27,7 @@ from .nvidia_config import NVIDIA_API_PARAMS, NvidiaConfig
 from .ollama_config import OLLAMA_API_PARAMS, OllamaConfig
 from .openai_config import OPENAI_API_PARAMS, ChatGPTConfig
 from .openrouter_config import OPENROUTER_API_PARAMS, OpenRouterConfig
+from .ppio_config import PPIO_API_PARAMS, PPIOConfig
 from .qwen_config import QWEN_API_PARAMS, QwenConfig
 from .reka_config import REKA_API_PARAMS, RekaConfig
 from .samba_config import (
@@ -82,6 +83,8 @@ __all__ = [
     'QWEN_API_PARAMS',
     'DeepSeekConfig',
     'DEEPSEEK_API_PARAMS',
+    'PPIOConfig',
+    'PPIO_API_PARAMS',
     'InternLMConfig',
     'INTERNLM_API_PARAMS',
     'MoonshotConfig',

camel/configs/anthropic_config.py

@@ -13,7 +13,7 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 from __future__ import annotations
 
-from typing import Any, List, Optional
+from typing import List, Optional
 
 from camel.configs.base_config import BaseConfig
 
@@ -23,6 +23,7 @@ class AnthropicConfig(BaseConfig):
     Anthropic API.
 
     See: https://docs.anthropic.com/en/api/messages
+
     Args:
         max_tokens (int, optional): The maximum number of tokens to
             generate before stopping. Note that Anthropic models may stop
@@ -75,28 +76,5 @@ class AnthropicConfig(BaseConfig):
     thinking: Optional[dict] = None
     tool_choice: Optional[dict] = None
 
-    def as_dict(self) -> dict[str, Any]:
-        config_dict = super().as_dict()
-        # Create a list of keys to remove to avoid modifying dict
-        keys_to_remove = [
-            key for key, value in config_dict.items() if value is None
-        ]
-
-        for key in keys_to_remove:
-            del config_dict[key]
-
-        # remove some keys if thinking is enabled
-        thinking_enabled = (
-            self.thinking is not None
-            and self.thinking.get("type") == "enabled"
-        )
-        if thinking_enabled:
-            # `top_p`, `top_k`, `temperature` must be unset when thinking is
-            # enabled.
-            config_dict.pop("top_k", None)
-            config_dict.pop("top_p", None)
-            config_dict.pop("temperature", None)
-        return config_dict
-
 
 ANTHROPIC_API_PARAMS = {param for param in AnthropicConfig.model_fields.keys()}

camel/configs/ppio_config.py

@@ -0,0 +1,102 @@
+# ========= 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. =========
+from __future__ import annotations
+
+from typing import Dict, Optional, Sequence, Type, Union
+
+from pydantic import BaseModel
+
+from camel.configs.base_config import BaseConfig
+
+
+class PPIOConfig(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:`None`)
+        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:`None`)
+        n (int, optional): How many chat completion choices to generate for
+            each input message. (default: :obj:`None`)
+        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:`None`)
+        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:`None`)
+        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:`None`)
+        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:`None`)
+        user (str, optional): A unique identifier representing your end-user,
+            which can help OpenAI to monitor and detect abuse.
+            (default: :obj:`None`)
+        tools (list[FunctionTool], optional): A list of tools the model may
+            call. Currently, only functions are supported as a tool. Use this
+            to provide a list of functions the model may generate JSON inputs
+            for. A max of 128 functions are supported.
+    """
+
+    temperature: Optional[float] = None
+    top_p: Optional[float] = None
+    n: Optional[int] = None
+    stream: Optional[bool] = None
+    stop: Optional[Union[str, Sequence[str]]] = None
+    max_tokens: Optional[int] = None
+    presence_penalty: Optional[float] = None
+    response_format: Optional[Union[Type[BaseModel], Dict]] = None
+    frequency_penalty: Optional[float] = None
+    logit_bias: Optional[Dict] = None
+    user: Optional[str] = None
+
+
+PPIO_API_PARAMS = {param for param in PPIOConfig.model_fields.keys()}

camel/configs/reka_config.py

@@ -13,7 +13,7 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 from __future__ import annotations
 
-from typing import Any, Optional, Union
+from typing import Optional, Union
 
 from camel.configs.base_config import BaseConfig
 
@@ -65,11 +65,5 @@ class RekaConfig(BaseConfig):
     presence_penalty: Optional[float] = None
     use_search_engine: Optional[bool] = None
 
-    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

@@ -13,7 +13,7 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 from __future__ import annotations
 
-from typing import Any, Optional, Sequence, Union
+from typing import Optional, Sequence, Union
 
 from pydantic import Field
 
@@ -63,12 +63,6 @@ class SambaVerseAPIConfig(BaseConfig):
     stop: Optional[Union[str, list[str]]] = None
     stream: Optional[bool] = None
 
-    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_VERSE_API_PARAMS = {
     param for param in SambaVerseAPIConfig().model_fields.keys()

camel/configs/togetherai_config.py

@@ -13,7 +13,7 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 from __future__ import annotations
 
-from typing import Any, Optional, Sequence, Union
+from typing import Optional, Sequence, Union
 
 from pydantic import Field
 
@@ -94,12 +94,6 @@ class TogetherAIConfig(BaseConfig):
     logit_bias: dict = Field(default_factory=dict)
     user: Optional[str] = None
 
-    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/datasets/few_shot_generator.py

@@ -235,6 +235,7 @@ class FewShotGenerator(BaseGenerator):
                             "synthetic": str(True),
                             "created": datetime.now().isoformat(),
                             "generator": "few_shot",
+                            "shots": [e.to_dict() for e in examples],
                         },
                     )
                 except ValidationError as e:

camel/embeddings/__init__.py

@@ -11,20 +11,24 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+from .azure_embedding import AzureEmbedding
 from .base import BaseEmbedding
 from .jina_embedding import JinaEmbedding
 from .mistral_embedding import MistralEmbedding
 from .openai_compatible_embedding import OpenAICompatibleEmbedding
 from .openai_embedding import OpenAIEmbedding
 from .sentence_transformers_embeddings import SentenceTransformerEncoder
+from .together_embedding import TogetherEmbedding
 from .vlm_embedding import VisionLanguageEmbedding
 
 __all__ = [
     "BaseEmbedding",
     "OpenAIEmbedding",
+    "AzureEmbedding",
     "SentenceTransformerEncoder",
     "VisionLanguageEmbedding",
     "MistralEmbedding",
     "OpenAICompatibleEmbedding",
     "JinaEmbedding",
+    "TogetherEmbedding",
 ]

camel/embeddings/azure_embedding.py

@@ -0,0 +1,119 @@
+# ========= 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. =========
+
+
+from __future__ import annotations
+
+import os
+from typing import Any, Union
+
+from openai import AzureOpenAI
+
+from camel.embeddings.base import BaseEmbedding
+from camel.types import EmbeddingModelType
+from camel.utils import api_keys_required  # Add this import
+
+
+class AzureEmbedding(BaseEmbedding[str]):
+    r"""Provides text embedding functionalities using Azure's OpenAI models.
+
+    Args:
+        model_type (EmbeddingModelType, optional): The model type to be
+            used for text embeddings.
+            (default: :obj:`TEXT_EMBEDDING_3_SMALL`)
+        url (Optional[str], optional): The url to the Azure OpenAI service.
+            (default: :obj:`None`)
+        api_key (str, optional): The API key for authenticating with the
+            Azure OpenAI service. (default: :obj:`None`)
+        api_version (str, optional): The API version for Azure OpenAI service.
+            (default: :obj:`None`)
+        dimensions (Optional[int], optional): The text embedding output
+            dimensions. (default: :obj:`None`)
+
+    Raises:
+        RuntimeError: If an unsupported model type is specified.
+        ValueError: If required API configuration is missing.
+    """
+
+    @api_keys_required(
+        [
+            ("api_key", 'AZURE_OPENAI_API_KEY'),
+            ("url", 'AZURE_OPENAI_BASE_URL'),
+        ]
+    )
+    def __init__(
+        self,
+        model_type: EmbeddingModelType = (
+            EmbeddingModelType.TEXT_EMBEDDING_3_SMALL
+        ),
+        url: Union[str, None] = None,
+        api_key: Union[str, None] = None,
+        api_version: Union[str, None] = None,
+        dimensions: Union[int, None] = None,
+    ) -> None:
+        self.model_type = model_type
+        self.api_version = api_version or os.environ.get("AZURE_API_VERSION")
+        if dimensions is None:
+            self.output_dim = model_type.output_dim
+        else:
+            if not isinstance(dimensions, int):
+                raise ValueError("dimensions must be an integer")
+            self.output_dim = dimensions
+
+        self._api_key = api_key or os.environ.get("AZURE_OPENAI_API_KEY")
+        self._url = url or os.environ.get("AZURE_OPENAI_BASE_URL")
+
+        self.client = AzureOpenAI(
+            api_key=self._api_key,
+            api_version=self.api_version,
+            azure_endpoint=str(self._url),
+        )
+
+    def embed_list(
+        self,
+        objs: list[str],
+        **kwargs: Any,
+    ) -> list[list[float]]:
+        r"""Embeds a list of texts using the Azure OpenAI model.
+
+        Args:
+            objs (list[str]): The list of texts to embed.
+            **kwargs (Any): Additional keyword arguments to pass to the API.
+
+        Returns:
+            list[list[float]]: The embeddings for the input texts.
+        """
+        if self.model_type == EmbeddingModelType.TEXT_EMBEDDING_ADA_2:
+            response = self.client.embeddings.create(
+                input=objs,
+                model=self.model_type.value,
+                **kwargs,
+            )
+            return [data.embedding for data in response.data]
+
+        response = self.client.embeddings.create(
+            input=objs,
+            model=self.model_type.value,
+            dimensions=self.output_dim,
+            **kwargs,
+        )
+        return [data.embedding for data in response.data]
+
+    def get_output_dim(self) -> int:
+        r"""Returns the output dimension of the embeddings.
+
+        Returns:
+            int: The dimensionality of the embedding for the current model.
+        """
+        return self.output_dim

camel/embeddings/together_embedding.py

@@ -0,0 +1,136 @@
+# ========= 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, Optional
+
+from openai import OpenAI
+
+from camel.embeddings.base import BaseEmbedding
+from camel.logger import get_logger
+from camel.utils import api_keys_required
+
+logger = get_logger(__name__)
+
+
+class TogetherEmbedding(BaseEmbedding[str]):
+    r"""Provides text embedding functionalities using Together AI's models.
+
+    Args:
+        model_name (str, optional): The model name to be used for text
+            embeddings.
+            (default: :obj:`togethercomputer/m2-bert-80M-8k-retrieval`)
+        api_key (str, optional): The API key for authenticating with the
+            Together service. (default: :obj:`None`)
+        dimensions (int, optional): The text embedding output dimensions.
+            (default: :obj:`None`)
+
+    Raises:
+        ValueError: If the model name format is invalid or if an empty input
+            list is provided.
+        RuntimeError: If the API request fails.
+    """
+
+    @api_keys_required([("api_key", 'TOGETHER_API_KEY')])
+    def __init__(
+        self,
+        model_name: str = "togethercomputer/m2-bert-80M-8k-retrieval",
+        api_key: Optional[str] = None,
+        dimensions: Optional[int] = None,
+    ) -> None:
+        if not isinstance(model_name, str) or not model_name.strip():
+            raise ValueError("Model name must be a non-empty string")
+
+        if dimensions is not None and dimensions <= 0:
+            raise ValueError("Dimensions must be a positive integer")
+
+        self.model_name = model_name
+        self._api_key = api_key or os.environ.get("TOGETHER_API_KEY")
+        self.output_dim = dimensions
+
+        # Initialize OpenAI client with Together AI configuration
+        self.client = OpenAI(
+            timeout=180,
+            max_retries=3,
+            api_key=self._api_key,
+            base_url="https://api.together.xyz/v1",
+        )
+
+    def embed_list(
+        self,
+        objs: list[str],
+        **kwargs: Any,
+    ) -> list[list[float]]:
+        r"""Generates embeddings for the given texts.
+
+        Args:
+            objs (list[str]): The texts for which to generate the embeddings.
+            **kwargs (Any): Extra kwargs passed to the embedding API.
+
+        Returns:
+            list[list[float]]: A list that represents the generated embedding
+                as a list of floating-point numbers.
+
+        Raises:
+            ValueError: If the input list is empty.
+            RuntimeError: If the API request fails.
+        """
+        if not objs:
+            raise ValueError("Input list cannot be empty")
+
+        try:
+            response = self.client.embeddings.create(
+                input=objs,
+                model=self.model_name,
+                **kwargs,
+            )
+
+            # Set output dimension if not already set
+            if self.output_dim is None and response.data:
+                self.output_dim = len(response.data[0].embedding)
+                logger.debug(
+                    f"Set output dimension to {self.output_dim} for model "
+                    f"{self.model_name}"
+                )
+
+            return [data.embedding for data in response.data]
+
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to get embeddings from Together AI: {e}"
+            )
+
+    def get_output_dim(self) -> int:
+        r"""Returns the output dimension of the embeddings.
+
+        Returns:
+            int: The dimensionality of the embedding for the current model.
+
+        Raises:
+            ValueError: If the embedding dimension cannot be determined.
+        """
+        if self.output_dim is None:
+            logger.debug(
+                "Output dimension not set, "
+                "making test embedding to determine it"
+            )
+            # Make a test embedding to determine the dimension
+            self.embed_list(["test"])
+
+        if self.output_dim is None:
+            raise ValueError(
+                "Failed to determine embedding dimension for model: "
+                f"{self.model_name}"
+            )
+
+        return self.output_dim

camel/environments/__init__.py

@@ -14,6 +14,7 @@
 from .models import Action, Environment, Observation, StepResult
 from .multi_step import MultiStepEnv
 from .single_step import SingleStepEnv
+from .tic_tac_toe import Opponent, TicTacToeEnv
 
 __all__ = [
     "Environment",
@@ -22,4 +23,6 @@ __all__ = [
     "Action",
     "Observation",
     "StepResult",
+    "TicTacToeEnv",
+    "Opponent",
 ]

camel/environments/multi_step.py

@@ -15,11 +15,10 @@
 from abc import ABC, abstractmethod
 from typing import Any, Dict, List, Optional, Tuple
 
+from camel.environments.models import Action, Observation, StepResult
 from camel.extractors.base import BaseExtractor
 from camel.logger import get_logger
 
-from .models import Action, Observation, StepResult
-
 logger = get_logger(__name__)
 
 
@@ -73,9 +72,8 @@ class MultiStepEnv(ABC):
             logger.error(f'Failed to setup environment: {e}')
             raise
 
-    @abstractmethod
     async def _setup(self) -> None:
-        pass
+        return
 
     async def close(self) -> None:
         r"""Clean up and close all resources used by the environment.
@@ -100,9 +98,8 @@ class MultiStepEnv(ABC):
             logger.error(f'Failed to teardown environment: {e}')
             raise
 
-    @abstractmethod
     async def _close(self) -> None:
-        pass
+        return
 
     async def reset(self) -> Observation:
         r"""Reset the environment to an initial state.
@@ -115,6 +112,9 @@ class MultiStepEnv(ABC):
         """
 
         if not self._is_setup:
+            logger.warning(
+                "reset() called on un-setup environment. Setting up..."
+            )
             await self.setup()
 
         # Reset state
@@ -132,7 +132,9 @@ class MultiStepEnv(ABC):
 
         return observation
 
-    async def step(self, action: Action) -> StepResult:
+    async def step(
+        self, action: Action
+    ) -> Tuple[Observation, float, bool, Dict[str, Any]]:
         r"""Take a step in the environment using the given action.
 
         This method updates the environment state based on the LLM's response,
@@ -157,7 +159,7 @@ class MultiStepEnv(ABC):
                 rewards_dict={},
                 done=True,
                 info={"reason": "max_steps_reached"},
-            )
+            ).as_tuple()
 
         if not self._is_setup:
             raise RuntimeError("Environment not set up. Call setup() first.")
@@ -196,13 +198,13 @@ class MultiStepEnv(ABC):
             rewards_dict=rewards_dict,
             done=done,
             info={
-                "extraction_result": self.extractor.extract(
+                "extraction_result": await self.extractor.extract(
                     action.llm_response
                 ),
                 "step": self._current_step,
                 "state": self._state,  # Updated state
             },
-        )
+        ).as_tuple()
 
     @abstractmethod
     def _get_initial_state(self) -> Dict[str, Any]:

camel/environments/single_step.py

@@ -200,7 +200,13 @@ class SingleStepEnv:
             self._states_done = [False] * self.current_batch_size
 
             observations = [
-                Observation(question=sample.question, context={}, metadata={})
+                Observation(
+                    question=sample.question,
+                    context={},
+                    metadata=sample.metadata
+                    if sample.metadata is not None
+                    else {},
+                )
                 for sample in self._states
             ]
 
@@ -214,7 +220,13 @@ class SingleStepEnv:
             self._states_done = [False] * batch_size
 
             observations = [
-                Observation(question=sample.question, context={}, metadata={})
+                Observation(
+                    question=sample.question,
+                    context={},
+                    metadata=sample.metadata
+                    if sample.metadata is not None
+                    else {},
+                )
                 for sample in self._states
             ]