camel-ai 0.2.47__tar.gz → 0.2.49__tar.gz

{camel_ai-0.2.47 → camel_ai-0.2.49}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camel-ai
-Version: 0.2.47
+Version: 0.2.49
 Summary: Communicative Agents for AI Society Study
 Project-URL: Homepage, https://www.camel-ai.org/
 Project-URL: Repository, https://github.com/camel-ai/camel
@@ -750,7 +750,7 @@ For more information please contact camel-ai@eigent.ai
 - **WeChat Community:** Scan the QR code below to join our WeChat community.
 
   <div align="center">
-    <img src="misc/wechat.jpg" alt="WeChat QR Code" width="200">
+    <img src="misc/wechat.jpeg" alt="WeChat QR Code" width="200">
   </div>
 
 

{camel_ai-0.2.47 → camel_ai-0.2.49}/README.md

@@ -422,7 +422,7 @@ For more information please contact camel-ai@eigent.ai
 - **WeChat Community:** Scan the QR code below to join our WeChat community.
 
   <div align="center">
-    <img src="misc/wechat.jpg" alt="WeChat QR Code" width="200">
+    <img src="misc/wechat.jpeg" alt="WeChat QR Code" width="200">
   </div>
 
 

{camel_ai-0.2.47 → camel_ai-0.2.49}/camel/__init__.py

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

{camel_ai-0.2.47 → camel_ai-0.2.49}/camel/agents/chat_agent.py

@@ -715,11 +715,11 @@ class ChatAgent(BaseAgent):
                         if external_tool_call_requests is None:
                             external_tool_call_requests = []
                         external_tool_call_requests.append(tool_call_request)
-
-                    tool_call_record = await self._aexecute_tool(
-                        tool_call_request
-                    )
-                    tool_call_records.append(tool_call_record)
+                    else:
+                        tool_call_record = await self._aexecute_tool(
+                            tool_call_request
+                        )
+                        tool_call_records.append(tool_call_record)
 
                 # If we found an external tool call, break the loop
                 if external_tool_call_requests:

{camel_ai-0.2.47 → camel_ai-0.2.49}/camel/configs/__init__.py

@@ -25,6 +25,7 @@ from .lmstudio_config import LMSTUDIO_API_PARAMS, LMStudioConfig
 from .mistral_config import MISTRAL_API_PARAMS, MistralConfig
 from .modelscope_config import MODELSCOPE_API_PARAMS, ModelScopeConfig
 from .moonshot_config import MOONSHOT_API_PARAMS, MoonshotConfig
+from .netmind_config import NETMIND_API_PARAMS, NetmindConfig
 from .nvidia_config import NVIDIA_API_PARAMS, NvidiaConfig
 from .ollama_config import OLLAMA_API_PARAMS, OllamaConfig
 from .openai_config import OPENAI_API_PARAMS, ChatGPTConfig
@@ -55,6 +56,8 @@ __all__ = [
     'GroqConfig',
     'LiteLLMConfig',
     'LITELLM_API_PARAMS',
+    'NetmindConfig',
+    'NETMIND_API_PARAMS',
     'NvidiaConfig',
     'NVIDIA_API_PARAMS',
     'OllamaConfig',

camel_ai-0.2.49/camel/configs/netmind_config.py

@@ -0,0 +1,82 @@
+# ========= 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, List, Optional, Union
+
+from pydantic import Field
+
+from camel.configs.base_config import BaseConfig
+from camel.types import NotGiven
+
+
+class NetmindConfig(BaseConfig):
+    r"""Defines the parameters for generating chat completions using OpenAI
+    compatibility.
+
+    Reference: https://netmind-power.gitbook.io/netmind-power-documentation/
+    api/inference/chat
+
+     Args:
+        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`)
+        repetition_penalty (float, optional): Penalizes new tokens based on
+            their appearance in the prompt and generated text.
+            (default: :obj:`None`)
+        stream (bool, optional): Whether to stream the response.
+            (default: :obj:`None`)
+        temperature (float, optional): Controls randomness in the response.
+            Higher values make output more random, lower values make it more
+            deterministic. Range: [0.0, 2.0]. (default: :obj:`None`)
+        top_p (float, optional): Controls diversity via nucleus sampling.
+            Range: [0.0, 1.0]. (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`)
+        max_tokens (Union[int, NotGiven], optional): Maximum number of tokens
+            to generate. If not provided, model will use its default maximum.
+            (default: :obj:`None`)
+        stop (Optional[List[str]], optional): List of stop sequences.
+            (default: :obj:`None`)
+        n (Optional[int], optional): Number of chat completion choices to
+            generate for each input message. (default: :obj:`None`)
+    """
+
+    stream: Optional[bool] = Field(default=None)
+    temperature: Optional[float] = Field(default=None)
+    top_p: Optional[float] = Field(default=None)
+    presence_penalty: Optional[float] = Field(default=None)
+    frequency_penalty: Optional[float] = Field(default=None)
+    repetition_penalty: Optional[float] = Field(default=None)
+    max_tokens: Optional[Union[int, NotGiven]] = Field(default=None)
+    stop: Optional[List[str]] = Field(default=None)
+    n: Optional[int] = Field(default=None)
+    logit_bias: Optional[Dict[str, float]] = Field(default=None)
+
+
+NETMIND_API_PARAMS = {param for param in NetmindConfig.model_fields.keys()}

{camel_ai-0.2.47 → camel_ai-0.2.49}/camel/models/__init__.py

@@ -31,6 +31,7 @@ from .model_manager import ModelManager, ModelProcessingError
 from .modelscope_model import ModelScopeModel
 from .moonshot_model import MoonshotModel
 from .nemotron_model import NemotronModel
+from .netmind_model import NetmindModel
 from .nvidia_model import NvidiaModel
 from .ollama_model import OllamaModel
 from .openai_audio_models import OpenAIAudioModels
@@ -65,6 +66,7 @@ __all__ = [
     'ModelManager',
     'LiteLLMModel',
     'OpenAIAudioModels',
+    'NetmindModel',
     'NemotronModel',
     'NvidiaModel',
     'OllamaModel',

{camel_ai-0.2.47 → camel_ai-0.2.49}/camel/models/model_factory.py

@@ -31,6 +31,7 @@ from camel.models.lmstudio_model import LMStudioModel
 from camel.models.mistral_model import MistralModel
 from camel.models.modelscope_model import ModelScopeModel
 from camel.models.moonshot_model import MoonshotModel
+from camel.models.netmind_model import NetmindModel
 from camel.models.nvidia_model import NvidiaModel
 from camel.models.ollama_model import OllamaModel
 from camel.models.openai_compatible_model import OpenAICompatibleModel
@@ -123,6 +124,8 @@ class ModelFactory:
             model_class = AIMLModel
         elif model_platform.is_volcano:
             model_class = VolcanoModel
+        elif model_platform.is_netmind:
+            model_class = NetmindModel
 
         elif model_platform.is_openai and model_type.is_openai:
             model_class = OpenAIModel

camel_ai-0.2.49/camel/models/netmind_model.py

@@ -0,0 +1,96 @@
+# ========= 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, Dict, Optional, Union
+
+from camel.configs import NETMIND_API_PARAMS, NetmindConfig
+from camel.models.openai_compatible_model import OpenAICompatibleModel
+from camel.types import ModelType
+from camel.utils import (
+    BaseTokenCounter,
+    api_keys_required,
+)
+
+
+class NetmindModel(OpenAICompatibleModel):
+    r"""Constructor for Netmind backend with OpenAI compatibility.
+
+    Args:
+        model_type (Union[ModelType, str]): Model for which a backend is
+            created, supported model can be found here:
+            https://www.netmind.ai/modelsLibrary?expandList=Chat
+        model_config_dict (Optional[Dict[str, Any]], optional): A dictionary
+            that will be fed into:obj:`openai.ChatCompletion.create()`. If
+            :obj:`None`, :obj:`NetmindConfig().as_dict()` will be used.
+            (default: :obj:`None`)
+        api_key (Optional[str], optional): The API key for authenticating with
+            the Netmind service. (default: :obj:`None`)
+        url (Optional[str], optional): The url to the Netmind service.
+            If not provided, "https://api.netmind.ai/inference-api/openai/v1"
+            will be used.(default: :obj:`None`)
+        token_counter (Optional[BaseTokenCounter], optional): Token counter to
+            use for the model. If not provided, :obj:`OpenAITokenCounter(
+            ModelType.GPT_4O_MINI)` will be used.
+        timeout (Optional[float], optional): The timeout value in seconds for
+            API calls. If not provided, will fall back to the MODEL_TIMEOUT
+            environment variable or default to 180 seconds.
+            (default: :obj:`None`)
+    """
+
+    @api_keys_required(
+        [
+            ("api_key", 'NETMIND_API_KEY'),
+        ]
+    )
+    def __init__(
+        self,
+        model_type: Union[ModelType, str],
+        model_config_dict: Optional[Dict[str, Any]] = None,
+        api_key: Optional[str] = None,
+        url: Optional[str] = None,
+        token_counter: Optional[BaseTokenCounter] = None,
+        timeout: Optional[float] = None,
+    ) -> None:
+        if model_config_dict is None:
+            model_config_dict = NetmindConfig().as_dict()
+        api_key = api_key or os.environ.get("NETMIND_API_KEY")
+        url = url or os.environ.get(
+            "NETMIND_API_BASE_URL",
+            "https://api.netmind.ai/inference-api/openai/v1",
+        )
+        timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
+        super().__init__(
+            model_type=model_type,
+            model_config_dict=model_config_dict,
+            api_key=api_key,
+            url=url,
+            token_counter=token_counter,
+            timeout=timeout,
+        )
+
+    def check_model_config(self):
+        r"""Check whether the model configuration contains any
+        unexpected arguments to NETMIND API.
+
+        Raises:
+            ValueError: If the model configuration dictionary contains any
+                unexpected arguments to NETMIND API.
+        """
+        for param in self.model_config_dict:
+            if param not in NETMIND_API_PARAMS:
+                raise ValueError(
+                    f"Unexpected argument `{param}` is "
+                    "input into NETMIND model backend."
+                )

{camel_ai-0.2.47 → camel_ai-0.2.49}/camel/societies/workforce/role_playing_worker.py

@@ -112,7 +112,7 @@ class RolePlayingWorker(Worker):
         chat_history = []
         while n < self.chat_turn_limit:
             n += 1
-            assistant_response, user_response = role_play_session.step(
+            assistant_response, user_response = await role_play_session.astep(
                 input_msg
             )
 

{camel_ai-0.2.47 → camel_ai-0.2.49}/camel/societies/workforce/single_agent_worker.py

@@ -72,7 +72,9 @@ class SingleAgentWorker(Worker):
             additional_info=task.additional_info,
         )
         try:
-            response = self.worker.step(prompt, response_format=TaskResult)
+            response = await self.worker.astep(
+                prompt, response_format=TaskResult
+            )
         except Exception as e:
             print(
                 f"{Fore.RED}Error occurred while processing task {task.id}:"

{camel_ai-0.2.47 → camel_ai-0.2.49}/camel/storages/vectordb_storages/milvus.py

@@ -359,15 +359,16 @@ class MilvusStorage(BaseVectorStorage):
             **kwargs,
         )
         query_results = []
-        for point in search_result:
-            query_results.append(
-                VectorDBQueryResult.create(
-                    similarity=(point[0]['distance']),
-                    id=str(point[0]['id']),
-                    payload=(point[0]['entity'].get('payload')),
-                    vector=point[0]['entity'].get('vector'),
+        for points in search_result:
+            for point in points:
+                query_results.append(
+                    VectorDBQueryResult.create(
+                        similarity=point['distance'],
+                        id=str(point['id']),
+                        payload=(point['entity'].get('payload')),
+                        vector=point['entity'].get('vector'),
+                    )
                 )
-            )
 
         return query_results
 

{camel_ai-0.2.47 → camel_ai-0.2.49}/camel/toolkits/dalle_toolkit.py

@@ -20,10 +20,13 @@ from typing import List, Optional
 from openai import OpenAI
 from PIL import Image
 
+from camel.logger import get_logger
 from camel.toolkits import FunctionTool
 from camel.toolkits.base import BaseToolkit
 from camel.utils import MCPServer
 
+logger = get_logger(__name__)
+
 
 @MCPServer()
 class DalleToolkit(BaseToolkit):
@@ -63,7 +66,10 @@ class DalleToolkit(BaseToolkit):
             image = Image.open(image_buffer)
             return image
         except Exception as e:
-            print(f"An error occurred while converting base64 to image: {e}")
+            error_msg = (
+                f"An error occurred while converting base64 to image: {e}"
+            )
+            logger.error(error_msg)
             return None
 
     def image_path_to_base64(self, image_path: str) -> str:
@@ -80,10 +86,11 @@ class DalleToolkit(BaseToolkit):
             with open(image_path, "rb") as image_file:
                 return base64.b64encode(image_file.read()).decode('utf-8')
         except Exception as e:
-            print(
+            error_msg = (
                 f"An error occurred while converting image path to base64: {e}"
             )
-            return ""
+            logger.error(error_msg)
+            return error_msg
 
     def image_to_base64(self, image: Image.Image) -> str:
         r"""Converts an image into a base64-encoded string.
@@ -108,8 +115,9 @@ class DalleToolkit(BaseToolkit):
                 base64_str = base64.b64encode(image_bytes).decode('utf-8')
                 return base64_str
         except Exception as e:
-            print(f"An error occurred: {e}")
-            return ""
+            error_msg = f"An error occurred: {e}"
+            logger.error(error_msg)
+            return error_msg
 
     def get_dalle_img(self, prompt: str, image_dir: str = "img") -> str:
         r"""Generate an image using OpenAI's DALL-E model.
@@ -134,11 +142,17 @@ class DalleToolkit(BaseToolkit):
             n=1,  # NOTE: now dall-e-3 only supports n=1
             response_format="b64_json",
         )
+        if response.data is None or len(response.data) == 0:
+            error_msg = "No image data returned from DALL-E API."
+            logger.error(error_msg)
+            return error_msg
         image_b64 = response.data[0].b64_json
         image = self.base64_to_image(image_b64)  # type: ignore[arg-type]
 
         if image is None:
-            raise ValueError("Failed to convert base64 string to image.")
+            error_msg = "Failed to convert base64 string to image."
+            logger.error(error_msg)
+            return error_msg
 
         os.makedirs(image_dir, exist_ok=True)
         image_path = os.path.join(image_dir, f"{uuid.uuid4()}.png")

{camel_ai-0.2.47 → camel_ai-0.2.49}/camel/types/enums.py

@@ -149,6 +149,18 @@ class ModelType(UnifiedModelType, Enum):
     CLAUDE_3_5_HAIKU = "claude-3-5-haiku-latest"
     CLAUDE_3_7_SONNET = "claude-3-7-sonnet-latest"
 
+    # Netmind models
+    NETMIND_LLAMA_4_MAVERICK_17B_128E_INSTRUCT = (
+        "meta-llama/Llama-4-Maverick-17B-128E-Instruct"
+    )
+    NETMIND_LLAMA_4_SCOUT_17B_16E_INSTRUCT = (
+        "meta-llama/Llama-4-Scout-17B-16E-Instruct"
+    )
+    NETMIND_DEEPSEEK_R1 = "deepseek-ai/DeepSeek-R1"
+    NETMIND_DEEPSEEK_V3 = "deepseek-ai/DeepSeek-V3-0324"
+    NETMIND_DOUBAO_1_5_PRO = "doubao/Doubao-1.5-pro"
+    NETMIND_QWQ_32B = "Qwen/QwQ-32B"
+
     # Nvidia models
     NVIDIA_NEMOTRON_340B_INSTRUCT = "nvidia/nemotron-4-340b-instruct"
     NVIDIA_NEMOTRON_340B_REWARD = "nvidia/nemotron-4-340b-reward"
@@ -606,6 +618,17 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.DEEPSEEK_REASONER,
         }
 
+    @property
+    def is_netmind(self) -> bool:
+        return self in {
+            ModelType.NETMIND_LLAMA_4_MAVERICK_17B_128E_INSTRUCT,
+            ModelType.NETMIND_LLAMA_4_SCOUT_17B_16E_INSTRUCT,
+            ModelType.NETMIND_DEEPSEEK_R1,
+            ModelType.NETMIND_DEEPSEEK_V3,
+            ModelType.NETMIND_DOUBAO_1_5_PRO,
+            ModelType.NETMIND_QWQ_32B,
+        }
+
     @property
     def is_ppio(self) -> bool:
         return self in {
@@ -759,6 +782,11 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.PPIO_YI_1_5_34B_CHAT,
         }:
             return 16_384
+
+        elif self in {
+            ModelType.NETMIND_DOUBAO_1_5_PRO,
+        }:
+            return 32_000
         elif self in {
             ModelType.MISTRAL_CODESTRAL,
             ModelType.MISTRAL_7B,
@@ -814,6 +842,7 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.PPIO_DEEPSEEK_R1,
             ModelType.PPIO_DEEPSEEK_V3,
             ModelType.AWS_DEEPSEEK_R1,
+            ModelType.NETMIND_QWQ_32B,
         }:
             return 64_000
         elif self in {
@@ -863,6 +892,8 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.AWS_LLAMA_3_3_70B_INSTRUCT,
             ModelType.AWS_LLAMA_3_2_90B_INSTRUCT,
             ModelType.AWS_LLAMA_3_2_11B_INSTRUCT,
+            ModelType.NETMIND_DEEPSEEK_R1,
+            ModelType.NETMIND_DEEPSEEK_V3,
         }:
             return 128_000
         elif self in {
@@ -906,8 +937,14 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.OPENROUTER_LLAMA_4_MAVERICK_FREE,
         }:
             return 256_000
+
+        elif self in {
+            ModelType.NETMIND_LLAMA_4_SCOUT_17B_16E_INSTRUCT,
+        }:
+            return 320_000
         elif self in {
             ModelType.OPENROUTER_LLAMA_4_SCOUT_FREE,
+            ModelType.NETMIND_LLAMA_4_MAVERICK_17B_128E_INSTRUCT,
         }:
             return 512_000
         elif self in {
@@ -1121,6 +1158,7 @@ class ModelPlatformType(Enum):
     SILICONFLOW = "siliconflow"
     AIML = "aiml"
     VOLCANO = "volcano"
+    NETMIND = "netmind"
 
     @classmethod
     def from_name(cls, name):
@@ -1246,6 +1284,11 @@ class ModelPlatformType(Enum):
         r"""Returns whether this platform is DeepSeek."""
         return self is ModelPlatformType.DEEPSEEK
 
+    @property
+    def is_netmind(self) -> bool:
+        r"""Returns whether this platform is Netmind."""
+        return self is ModelPlatformType.NETMIND
+
     @property
     def is_ppio(self) -> bool:
         r"""Returns whether this platform is PPIO."""

{camel_ai-0.2.47 → camel_ai-0.2.49}/camel/types/unified_model_type.py

@@ -113,6 +113,11 @@ class UnifiedModelType(str):
         r"""Returns whether the model is a Mistral model."""
         return True
 
+    @property
+    def is_netmind(self) -> bool:
+        r"""Returns whether the model is a Netmind model."""
+        return True
+
     @property
     def is_reka(self) -> bool:
         r"""Returns whether the model is a Reka model."""

{camel_ai-0.2.47 → camel_ai-0.2.49}/camel/utils/mcp.py

@@ -69,7 +69,7 @@ class MCPServer:
                 func = getattr(instance, name, None)
                 if func is None or not callable(func):
                     raise ValueError(
-                        f"Method {name} not found in class {cls.__name} or "
+                        f"Method {name} not found in class {cls.__name__} or "
                         "cannot be called."
                     )
                 wrapper = self.make_wrapper(func)

{camel_ai-0.2.47 → camel_ai-0.2.49}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "camel-ai"
-version = "0.2.47"
+version = "0.2.49"
 description = "Communicative Agents for AI Society Study"
 authors = [{ name = "CAMEL-AI.org" }]
 requires-python = ">=3.10,<3.13"