camel-ai 0.2.38__py3-none-any.whl → 0.2.40__py3-none-any.whl

camel/embeddings/openai_compatible_embedding.py

@@ -30,6 +30,9 @@ class OpenAICompatibleEmbedding(BaseEmbedding[str]):
         model_type (str): The model type to be used for text embeddings.
         api_key (str): The API key for authenticating with the model service.
         url (str): The url to the model service.
+        output_dim (Optional[int]): The dimensionality of the embedding
+            vectors. If None, it will be determined during the first
+            embedding call.
     """
 
     @api_keys_required(
@@ -43,9 +46,10 @@ class OpenAICompatibleEmbedding(BaseEmbedding[str]):
         model_type: str,
         api_key: Optional[str] = None,
         url: Optional[str] = None,
+        output_dim: Optional[int] = None,
     ) -> None:
         self.model_type = model_type
-        self.output_dim: Optional[int] = None
+        self.output_dim: Optional[int] = output_dim
 
         self._api_key = api_key or os.environ.get(
             "OPENAI_COMPATIBILITY_API_KEY"
@@ -87,10 +91,14 @@ class OpenAICompatibleEmbedding(BaseEmbedding[str]):
 
         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:
-            raise ValueError(
-                "Output dimension is not yet determined. Call "
-                "'embed_list' first."
-            )
+            self.embed_list(["test"])
+
+        if self.output_dim is None:
+            raise ValueError("Failed to determine embedding dimension")
+
         return self.output_dim

camel/environments/models.py

@@ -33,7 +33,7 @@ class Action(BaseModel):
             generated (UTC).
     """
 
-    index: Optional[int] = Field(default=None, description="...")
+    index: int = Field(default=0, description="...")
 
     llm_response: str = Field(description="Generated response from the LLM")
     metadata: Dict[str, Any] = Field(

camel/environments/single_step.py

@@ -19,6 +19,7 @@ from camel.datasets import BaseGenerator, DataPoint, StaticDataset
 from camel.logger import get_logger
 from camel.verifiers.base import (
     BaseVerifier,
+    VerificationOutcome,
     VerificationResult,
 )
 
@@ -51,7 +52,7 @@ class SingleStepEnv:
         question="Episode ended. This is just a placeholder."
     )
 
-    ACCURACY_REWARD = 10
+    ACCURACY_REWARD = 1
 
     def __init__(
         self,
@@ -206,37 +207,66 @@ class SingleStepEnv:
             return observations[0] if batch_size == 1 else observations
 
         elif isinstance(self.dataset, BaseGenerator):
-            raise NotImplementedError(
-                "Reset not yet implemented for BaseGenerator datasets."
-            )
+            self._states = [
+                await self.dataset.async_sample() for _ in range(batch_size)
+            ]
+            self.current_batch_size = batch_size
+            self._states_done = [False] * batch_size
+
+            observations = [
+                Observation(question=sample.question, context={}, metadata={})
+                for sample in self._states
+            ]
+
+            return observations[0] if batch_size == 1 else observations
 
         else:
             raise TypeError(f"Unsupported dataset type: {type(self.dataset)}")
 
     async def step(
-        self, action: Union[Action, List[Action]]
+        self, action: Union[Action, List[Action], str]
     ) -> Union[
         Tuple[Observation, float, bool, Dict[str, Any]],
         List[Tuple[Observation, float, bool, Dict[str, Any]]],
     ]:
-        r"""Process actions for a subset of states and update their finished
-        status.
+        r"""Execute one interaction step in the environment using the
+        proposed solution.
+
+        This method processes the agent's response(s) to the current
+        observation(s), verifies the correctness of the responses using
+        the verifier, computes rewards, and returns the resulting
+        state transition(s).
+
+        The environment is strictly single-step. Once an action is
+        submitted for a state, that state is marked as done, and
+        the observation will not change.
 
         Args:
-            action: Single action (for batch_size=1 or micro-batch of size 1)
-                or list of actions (for batch_size>=2 with multiple actions).
-                Each action must have an index for batch_size>=2, indicating
-                which state it corresponds to.
+            action (Union[Action, List[Action], str]):
+                The action(s) taken by the agent,
+                    which should contain the response(s)
+                to the observation(s). Can be:
+                - A single `Action` object (for batch size 1),
+                - A list of `Action` objects (for batched evaluation),
+                - A raw string (only allowed when batch size is 1).
 
         Returns:
-            Union[StepResult, List[StepResult]]: StepResult or list of
-                StepResults for the processed states.
+            Union[Tuple[Observation, float, bool, Dict[str, Any]], List[...]]:
+                A tuple or list of tuples containing:
+                - `Observation`: Placeholder indicating episode end.
+                - `float`: The reward for the response.
+                - `bool`: Whether the episode is done
+                    (always `True` in this case).
+                - `dict`: Additional info including the proposed solution,
+                          verification result, and original data point.
 
         Raises:
-            RuntimeError: If environment isn't set up or episode has ended.
-            ValueError: If indices are invalid, duplicate, or correspond to
-                finished states.
+            RuntimeError: If the environment has not been set up,
+                or if `reset()` has not been called.
+            ValueError: If invalid action format, duplicate indices,
+                or out-of-bounds indices are detected.
         """
+
         if not self._is_setup:
             raise RuntimeError("Environment not set up. Call setup() first.")
         if self._batch_done():
@@ -246,64 +276,10 @@ class SingleStepEnv:
         if not self._states:
             raise RuntimeError("No current observation. Call reset() first.")
 
-        # Normalize actions into a list for uniform processing
-        if self.current_batch_size == 1:
-            if isinstance(action, list):
-                if len(action) != 1 or not isinstance(action[0], Action):
-                    raise ValueError(
-                        "For batch_size=1, expect a single Action or a "
-                        "list containing exactly one Action"
-                    )
-            elif not isinstance(action, Action):
-                raise ValueError(
-                    "For batch_size=1, expect a single Action or a "
-                    "list containing exactly one Action"
-                )
-            if isinstance(action, Action):
-                actions = [action]
-            else:
-                actions = action
-            if actions[0].index is None:
-                actions[0].index = 0
-            if actions[0].index != 0:
-                raise ValueError("For batch_size=1, index must be None or 0")
-
-        else:  # batch_size >= 2
-            if isinstance(action, Action):
-                if action.index is None:
-                    raise ValueError(
-                        "For batch_size>=2, each Action must have an index"
-                    )
-                if not isinstance(action.index, int):
-                    raise ValueError("Index must be an integer")
-                actions = [action]
-            elif isinstance(action, list):
-                if not action:  # Empty list
-                    raise ValueError("Action list cannot be empty")
-                actions = action
-                for act in actions:
-                    if not isinstance(act, Action):
-                        raise ValueError(
-                            "All elements in list must be Action objects"
-                        )
-                    if act.index is None:
-                        raise ValueError(
-                            "For batch_size>=2, each Action must have an index"
-                        )
-                    if not isinstance(act.index, int):
-                        raise ValueError("Index must be an integer")
-            else:
-                raise ValueError(
-                    "For batch_size>=2, expect an Action or list of Actions"
-                )
+        actions = self._normalize_actions(action)
+
+        indices = [a.index for a in actions]
 
-        # Validate indices
-        indices: List[int] = []
-        for act in actions:
-            assert act.index is not None
-            indices.append(act.index)
-        if len(set(indices)) != len(indices):
-            raise ValueError("Duplicate state indices in actions.")
         for idx in indices:
             if idx < 0 or idx >= len(self._states):
                 raise ValueError(f"Invalid state index {idx}.")
@@ -322,22 +298,30 @@ class SingleStepEnv:
         for idx in indices:
             ground_truths.append(self._states[idx].final_answer)
 
-        verification_results = await self.verifier.verify_batch(
-            solutions=proposed_solutions,
-            ground_truths=ground_truths,  # type: ignore [arg-type]
-            raise_on_error=True,
-        )
+        try:
+            verification_results = await self.verifier.verify_batch(
+                solutions=proposed_solutions,
+                reference_answers=ground_truths,  # type: ignore [arg-type]
+                raise_on_error=True,
+            )
+        except Exception as e:
+            logger.error(f"Verification failed: {e}")
+            # Return failed verification results with status=FAILURE
+            verification_results = [
+                VerificationResult(
+                    result="",
+                    status=VerificationOutcome.FAILURE,
+                    error_message=f"Verification error: {e}",
+                )
+                for _ in range(len(proposed_solutions))
+            ]
 
         total_rewards, rewards_dicts = await self._compute_reward_batch(
             proposed_solutions, verification_results
         )
-
-        # TODO Batch this
-        step_results = []
-        for i, action in enumerate(actions):
-            assert action.index is not None
-            idx = action.index
-            step_result = StepResult(
+        # Create and return step results in batch
+        step_results = [
+            StepResult(
                 observation=self.PLACEHOLDER_OBS,
                 reward=total_rewards[i],
                 rewards_dict=rewards_dicts[i],
@@ -345,14 +329,96 @@ class SingleStepEnv:
                 info={
                     "proposed_solution": proposed_solutions[i],
                     "verification_result": verification_results[i],
-                    "state": self._states[idx],
+                    "state": self._states[indices[i]],
                 },
-            )
-            step_results.append(step_result.as_tuple())
+            ).as_tuple()
+            for i in range(len(actions))
+        ]
+        for _, idx in enumerate(indices):
             self._states_done[idx] = True
 
         return step_results[0] if len(step_results) == 1 else step_results
 
+    def _normalize_actions(
+        self, action: Union[Action, List[Action], str]
+    ) -> List[Action]:
+        r"""Normalize the user-provided action(s) into a validated list
+        of `Action` objects.
+
+        This method handles flexibility in input format by converting
+        raw strings (only allowed when batch size is 1) and ensuring
+        all necessary structure and integrity checks on actions
+        (e.g., index bounds, duplicates).
+
+        Args:
+            action (Union[Action, List[Action], str]):
+                The raw input action(s) provided by the agent. Can be:
+                - A single `Action` object.
+                - A list of `Action` objects.
+                - A raw string (if `batch_size == 1`), auto-wrapped
+                    in an `Action`.
+
+        Returns:
+            List[Action]: A list of validated `Action` instances
+                ready for evaluation.
+
+        Raises:
+            ValueError: If:
+                - Action indices are invalid or duplicated,
+                - Action list is empty,
+                - Index mismatches expected values
+                    (e.g., 0 for batch size 1),
+                - Wrong structure is used
+                    (e.g., string used with batch size > 1).
+            TypeError: If the action is of an unsupported type.
+        """
+
+        if isinstance(action, str):
+            if self.current_batch_size != 1:
+                raise ValueError(
+                    "String input for action is only allowed"
+                    " when batch_size == 1"
+                )
+            logger.warning("Auto-converting from str to Action", stacklevel=2)
+            action = Action(index=0, llm_response=action)
+
+        if isinstance(action, Action):
+            actions = [action]
+        elif isinstance(action, list):
+            if not action:
+                raise ValueError("Action list cannot be empty")
+            if not all(isinstance(a, Action) for a in action):
+                raise ValueError(
+                    "All elements in the list must be Action objects"
+                )
+            actions = action
+        else:
+            raise TypeError("Action must be a str, Action, or list of Actions")
+
+        if self.current_batch_size == 1 and len(actions) != 1:
+            raise ValueError(
+                "For batch_size=1, expect a single Action or a "
+                "list containing exactly one Action"
+            )
+
+        # Validate indices
+        for a in actions:
+            if not isinstance(a.index, int):
+                raise ValueError(
+                    f"Action index must be an integer, got {a.index}"
+                )
+            if self.current_batch_size == 1:
+                if a.index != 0:
+                    raise ValueError(
+                        "For batch_size=1, Action index must be 0"
+                    )
+
+        indices = [a.index for a in actions]
+        if len(set(indices)) != len(indices):
+            raise ValueError("Duplicate state indices in actions.")
+
+        return actions
+
     async def _compute_reward_batch(
         self,
         proposed_solutions: List[str],
@@ -426,7 +492,7 @@ class SingleStepEnv:
         return all(self._states_done)
 
     def _batch_started(self) -> bool:
-        r"""Check if any state in the current batch is done.
+        r"""Check if the batch processing has started.
 
         Returns:
             bool: True if at least one state is marked as done, False

camel/interpreters/docker_interpreter.py

@@ -185,7 +185,7 @@ class DockerInterpreter(BaseInterpreter):
         code: str,
         code_type: str,
     ) -> str:
-        r"""Executes the given code in the conatiner attached to the
+        r"""Executes the given code in the container attached to the
         interpreter, and captures the stdout and stderr streams.
 
         Args:

camel/interpreters/internal_python_interpreter.py

@@ -421,7 +421,7 @@ class InternalPythonInterpreter(BaseInterpreter):
         result = None
         if not isinstance(if_statement.test, ast.Compare):
             raise InterpreterError(
-                "Only Campare expr supported in if statement, get"
+                "Only Compare expr supported in if statement, get"
                 f" {if_statement.test.__class__.__name__}"
             )
         if self._execute_condition(if_statement.test):

camel/loaders/unstructured_io.py

@@ -11,6 +11,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+import traceback
 import uuid
 import warnings
 from typing import (
@@ -151,7 +152,7 @@ class UnstructuredIO:
                     elements = partition(file=f, **kwargs)
                     return elements
             except Exception:
-                warnings.warn(f"Failed to partition the file: {input_path}")
+                warnings.warn(traceback.format_exc())
                 return None
 
     @staticmethod

camel/memories/blocks/chat_history_block.py

@@ -38,7 +38,7 @@ class ChatHistoryBlock(MemoryBlock):
         keep_rate (float, optional): In historical messages, the score of the
             last message is 1.0, and with each step taken backward, the score
             of the message is multiplied by the `keep_rate`. Higher `keep_rate`
-            leads to high possiblity to keep history messages during context
+            leads to high possibility to keep history messages during context
             creation.
     """
 

camel/memories/context_creators/score_based.py

@@ -168,8 +168,8 @@ class ScoreBasedContextCreator(BaseContextCreator):
         # 6. Output Assembly
         # ======================
 
-        # Incase system message is the only message in memory when sorted units
-        # are empty, raise an error
+        # In case system message is the only message in memory when sorted
+        # units are empty, raise an error
         if system_unit and len(remaining_units) == 0 and len(records) > 1:
             raise RuntimeError(
                 "System message and current message exceeds token limit ",

camel/models/__init__.py

@@ -26,6 +26,7 @@ from .litellm_model import LiteLLMModel
 from .mistral_model import MistralModel
 from .model_factory import ModelFactory
 from .model_manager import ModelManager, ModelProcessingError
+from .modelscope_model import ModelScopeModel
 from .moonshot_model import MoonshotModel
 from .nemotron_model import NemotronModel
 from .nvidia_model import NvidiaModel
@@ -77,6 +78,7 @@ __all__ = [
     'DeepSeekModel',
     'FishAudioModel',
     'InternLMModel',
+    'ModelScopeModel',
     'MoonshotModel',
     'AIMLModel',
     'BaseAudioModel',

camel/models/model_factory.py

@@ -11,8 +11,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+import json
 from typing import Dict, Optional, Type, Union
 
+import yaml
+
 from camel.models.aiml_model import AIMLModel
 from camel.models.anthropic_model import AnthropicModel
 from camel.models.azure_openai_model import AzureOpenAIModel
@@ -24,6 +27,7 @@ from camel.models.groq_model import GroqModel
 from camel.models.internlm_model import InternLMModel
 from camel.models.litellm_model import LiteLLMModel
 from camel.models.mistral_model import MistralModel
+from camel.models.modelscope_model import ModelScopeModel
 from camel.models.moonshot_model import MoonshotModel
 from camel.models.nvidia_model import NvidiaModel
 from camel.models.ollama_model import OllamaModel
@@ -145,6 +149,8 @@ class ModelFactory:
             model_class = InternLMModel
         elif model_platform.is_moonshot and model_type.is_moonshot:
             model_class = MoonshotModel
+        elif model_platform.is_modelscope:
+            model_class = ModelScopeModel
         elif model_type == ModelType.STUB:
             model_class = StubModel
 
@@ -162,3 +168,116 @@ class ModelFactory:
             token_counter=token_counter,
             timeout=timeout,
         )
+
+    @classmethod
+    def __parse_model_platform(
+        cls, model_platform_str: str
+    ) -> ModelPlatformType:
+        r"""Parses a string and returns the corresponding ModelPlatformType
+        enum.
+
+        Args:
+            model_platform_str (str): The platform name as a string. Can be in
+                the form "ModelPlatformType.<NAME>" or simply "<NAME>".
+
+        Returns:
+            ModelPlatformType: The matching enum value.
+
+        Raises:
+            ValueError: If the platform name is not a valid member of
+                ModelPlatformType.
+        """
+
+        try:
+            if model_platform_str.startswith("ModelPlatformType."):
+                platform_name = model_platform_str.split('.')[-1]
+            else:
+                platform_name = model_platform_str.upper()
+
+            if platform_name not in ModelPlatformType.__members__:
+                raise ValueError(
+                    f"Invalid model platform: {platform_name}. "
+                    f"Valid options: "
+                    f"{', '.join(ModelPlatformType.__members__.keys())}"
+                )
+
+            return ModelPlatformType[platform_name]
+
+        except KeyError:
+            raise KeyError(f"Invalid model platform: {model_platform_str}")
+
+    @classmethod
+    def __load_yaml(cls, filepath: str) -> Dict:
+        r"""Loads and parses a YAML file into a dictionary.
+
+        Args:
+            filepath (str): Path to the YAML configuration file.
+
+        Returns:
+            Dict: The parsed YAML content as a dictionary.
+        """
+        with open(filepath, 'r') as file:
+            config = yaml.safe_load(file)
+
+        return config
+
+    @classmethod
+    def __load_json(cls, filepath: str) -> Dict:
+        r"""Loads and parses a JSON file into a dictionary.
+
+        Args:
+            filepath (str): Path to the JSON configuration file.
+
+        Returns:
+            Dict: The parsed JSON content as a dictionary.
+        """
+        with open(filepath, 'r') as file:
+            config = json.load(file)
+
+        return config
+
+    @classmethod
+    def create_from_yaml(cls, filepath: str) -> BaseModelBackend:
+        r"""Creates and returns a model base backend instance
+        from a YAML configuration file.
+
+        Args:
+            filepath (str): Path to the YAML file containing model
+                configuration.
+
+        Returns:
+            BaseModelBackend: An instance of the model backend based on the
+                configuration.
+        """
+
+        config = cls.__load_yaml(filepath)
+        config["model_platform"] = cls.__parse_model_platform(
+            config["model_platform"]
+        )
+
+        model = ModelFactory.create(**config)
+
+        return model
+
+    @classmethod
+    def create_from_json(cls, filepath: str) -> BaseModelBackend:
+        r"""Creates and returns a base model backend instance
+        from a JSON configuration file.
+
+        Args:
+            filepath (str): Path to the JSON file containing model
+                configuration.
+
+        Returns:
+            BaseModelBackend: An instance of the model backend based on the
+                configuration.
+        """
+
+        config = cls.__load_json(filepath)
+        config["model_platform"] = cls.__parse_model_platform(
+            config["model_platform"]
+        )
+
+        model = ModelFactory.create(**config)
+
+        return model