camel-ai 0.1.5.5__py3-none-any.whl → 0.1.5.6__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.5.5'
+__version__ = '0.1.5.6'
 
 __all__ = [
     '__version__',

camel/agents/knowledge_graph_agent.py

@@ -78,17 +78,16 @@ Expected Output:
 
 Nodes:
 
-Node(id='John', type='Person', properties={'agent_generated'})
-Node(id='XYZ Corporation', type='Organization', properties={'agent_generated'})
-Node(id='New York City', type='Location', properties={'agent_generated'})
+Node(id='John', type='Person')
+Node(id='XYZ Corporation', type='Organization')
+Node(id='New York City', type='Location')
 
 Relationships:
 
 Relationship(subj=Node(id='John', type='Person'), obj=Node(id='XYZ 
-Corporation', type='Organization'), type='WorksAt', properties=
-{'agent_generated'})
+Corporation', type='Organization'), type='WorksAt')
 Relationship(subj=Node(id='John', type='Person'), obj=Node(id='New York City', 
-type='Location'), type='ResidesIn', properties={'agent_generated'})
+type='Location'), type='ResidesIn')
 
 ===== TASK =====
 Please extracts nodes and relationships from given content and structures them 
@@ -211,11 +210,10 @@ class KnowledgeGraphAgent(ChatAgent):
         import re
 
         # Regular expressions to extract nodes and relationships
-        node_pattern = r"Node\(id='(.*?)', type='(.*?)', properties=(.*?)\)"
+        node_pattern = r"Node\(id='(.*?)', type='(.*?)'\)"
         rel_pattern = (
             r"Relationship\(subj=Node\(id='(.*?)', type='(.*?)'\), "
-            r"obj=Node\(id='(.*?)', type='(.*?)'\), type='(.*?)', "
-            r"properties=\{(.*?)\}\)"
+            r"obj=Node\(id='(.*?)', type='(.*?)'\), type='(.*?)'\)"
         )
 
         nodes = {}
@@ -223,8 +221,8 @@ class KnowledgeGraphAgent(ChatAgent):
 
         # Extract nodes
         for match in re.finditer(node_pattern, input_string):
-            id, type, properties = match.groups()
-            properties = eval(properties)
+            id, type = match.groups()
+            properties = {'source': 'agent_created'}
             if id not in nodes:
                 node = Node(id, type, properties)
                 if self._validate_node(node):
@@ -232,10 +230,8 @@ class KnowledgeGraphAgent(ChatAgent):
 
         # Extract relationships
         for match in re.finditer(rel_pattern, input_string):
-            subj_id, subj_type, obj_id, obj_type, rel_type, properties_str = (
-                match.groups()
-            )
-            properties = eval(properties_str)
+            subj_id, subj_type, obj_id, obj_type, rel_type = match.groups()
+            properties = {'source': 'agent_created'}
             if subj_id in nodes and obj_id in nodes:
                 subj = nodes[subj_id]
                 obj = nodes[obj_id]

camel/agents/task_agent.py

@@ -100,7 +100,6 @@ class TaskSpecifyAgent(ChatAgent):
 
         if meta_dict is not None:
             task_specify_prompt = task_specify_prompt.format(**meta_dict)
-
         task_msg = BaseMessage.make_user_message(
             role_name="Task Specifier", content=task_specify_prompt
         )

camel/configs/__init__.py

@@ -13,6 +13,10 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 from .anthropic_config import ANTHROPIC_API_PARAMS, AnthropicConfig
 from .base_config import BaseConfig
+from .gemini_config import (
+    Gemini_API_PARAMS,
+    GeminiConfig,
+)
 from .litellm_config import LITELLM_API_PARAMS, LiteLLMConfig
 from .ollama_config import OLLAMA_API_PARAMS, OllamaConfig
 from .openai_config import (
@@ -35,4 +39,6 @@ __all__ = [
     'OLLAMA_API_PARAMS',
     'ZhipuAIConfig',
     'ZHIPUAI_API_PARAMS',
+    'GeminiConfig',
+    'Gemini_API_PARAMS',
 ]

camel/configs/gemini_config.py

@@ -0,0 +1,97 @@
+# =========== 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 collections.abc import Iterable
+from dataclasses import asdict, dataclass
+from typing import Optional
+
+from camel.configs.base_config import BaseConfig
+
+
+@dataclass(frozen=True)
+class GeminiConfig(BaseConfig):
+    r"""A simple dataclass used to configure the generation parameters of
+    `GenerativeModel.generate_content`.
+
+    Args:
+        candidate_count (int, optional): Number of responses to return.
+        stop_sequences (Iterable[str], optional): The set of character
+            sequences (up to 5) that will stop output generation. If specified
+            the API will stop at the first appearance of a stop sequence.
+            The stop sequence will not be included as part of the response.
+        max_output_tokens (int, optional): The maximum number of tokens to
+            include in a candidate. If unset, this will default to
+            output_token_limit specified in the model's specification.
+        temperature (float, optional): Controls the randomness of the output.
+            Note: The default value varies by model, see the
+            `Model.temperature` attribute of the `Model` returned
+            the `genai.get_model` function. Values can range from [0.0,1.0],
+            inclusive. A value closer to 1.0 will produce responses that are
+            more varied and creative, while a value closer to 0.0 will
+            typically result in more straightforward responses from the model.
+        top_p (int, optional): The maximum cumulative probability of tokens to
+            consider when sampling. The model uses combined Top-k and nucleus
+            sampling. Tokens are sorted based on their assigned probabilities
+            so that only the most likely tokens are considered. Top-k sampling
+            directly limits the maximum number of tokens to consider, while
+            Nucleus sampling limits number of tokens
+            based on the cumulative probability. Note: The default value varies
+            by model, see the `Model.top_p` attribute of the `Model` returned
+            the `genai.get_model` function.
+        top_k (int, optional): The maximum number of tokens to consider when
+            sampling. The model uses combined Top-k and nucleus sampling.Top-k
+            sampling considers the set of `top_k` most probable tokens.
+            Defaults to 40. Note: The default value varies by model, see the
+            `Model.top_k` attribute of the `Model` returned the
+            `genai.get_model` function.
+        response_mime_type (str, optional): Output response mimetype of the
+            generated candidate text. Supported mimetype:
+            `text/plain`: (default) Text output.
+            `application/json`: JSON response in the candidates.
+        response_schema (Schema, optional): Specifies the format of the
+            JSON requested if response_mime_type is `application/json`.
+        safety_settings (SafetySettingOptions, optional):
+            Overrides for the model's safety settings.
+        tools (FunctionLibraryType, optional):
+            `protos.Tools` more info coming soon.
+        tool_config (ToolConfigType, optional):
+            more info coming soon.
+        request_options (RequestOptionsType, optional):
+            Options for the request.
+    """
+
+    from google.generativeai.protos import Schema
+    from google.generativeai.types.content_types import (
+        FunctionLibraryType,
+        ToolConfigType,
+    )
+    from google.generativeai.types.helper_types import RequestOptionsType
+    from google.generativeai.types.safety_types import SafetySettingOptions
+
+    candidate_count: Optional[int] = None
+    stop_sequences: Optional[Iterable[str]] = None
+    max_output_tokens: Optional[int] = None
+    temperature: Optional[float] = None
+    top_p: Optional[float] = None
+    top_k: Optional[int] = None
+    response_mime_type: Optional[str] = None
+    response_schema: Optional[Schema] = None
+    safety_settings: Optional[SafetySettingOptions] = None
+    tools: Optional[FunctionLibraryType] = None
+    tool_config: Optional[ToolConfigType] = None
+    request_options: Optional[RequestOptionsType] = None
+
+
+Gemini_API_PARAMS = {param for param in asdict(GeminiConfig()).keys()}

camel/models/__init__.py

@@ -13,6 +13,7 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 from .anthropic_model import AnthropicModel
 from .base_model import BaseModelBackend
+from .gemini_model import GeminiModel
 from .litellm_model import LiteLLMModel
 from .model_factory import ModelFactory
 from .nemotron_model import NemotronModel
@@ -35,4 +36,5 @@ __all__ = [
     'OpenAIAudioModels',
     'NemotronModel',
     'OllamaModel',
+    'GeminiModel',
 ]

camel/models/gemini_model.py

@@ -0,0 +1,203 @@
+# =========== 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 typing import TYPE_CHECKING, Any, Dict, List, Optional
+
+from camel.configs import Gemini_API_PARAMS
+from camel.messages import OpenAIMessage
+from camel.models import BaseModelBackend
+from camel.types import (
+    ChatCompletion,
+    ChatCompletionMessage,
+    Choice,
+    ModelType,
+)
+from camel.utils import (
+    BaseTokenCounter,
+    GeminiTokenCounter,
+    api_keys_required,
+)
+
+if TYPE_CHECKING:
+    from google.generativeai.types import ContentsType, GenerateContentResponse
+
+
+class GeminiModel(BaseModelBackend):
+    r"""Gemini API in a unified BaseModelBackend interface."""
+
+    # NOTE: Currently "stream": True is not supported with Gemini due to the
+    # limitation of the current camel design.
+
+    def __init__(
+        self,
+        model_type: ModelType,
+        model_config_dict: Dict[str, Any],
+        api_key: Optional[str] = None,
+        url: Optional[str] = None,
+    ) -> None:
+        r"""Constructor for Gemini backend.
+
+        Args:
+            model_type (ModelType): Model for which a backend is created.
+            model_config_dict (Dict[str, Any]): A dictionary that will
+                be fed into generate_content().
+            api_key (Optional[str]): The API key for authenticating with the
+                gemini service. (default: :obj:`None`)
+            url (Optional[str]): The url to the gemini service.
+        """
+        import os
+
+        import google.generativeai as genai
+        from google.generativeai.types.generation_types import GenerationConfig
+
+        super().__init__(model_type, model_config_dict, api_key, url)
+        self._api_key = api_key or os.environ.get("GOOGLE_API_KEY")
+        genai.configure(api_key=self._api_key)
+        self._client = genai.GenerativeModel(self.model_type.value)
+        self._token_counter: Optional[BaseTokenCounter] = None
+        keys = list(self.model_config_dict.keys())
+        generation_config_dict = {
+            k: self.model_config_dict.pop(k)
+            for k in keys
+            if hasattr(GenerationConfig, k)
+        }
+        generation_config = genai.types.GenerationConfig(
+            **generation_config_dict
+        )
+        self.model_config_dict["generation_config"] = generation_config
+
+    @property
+    def token_counter(self) -> BaseTokenCounter:
+        if not self._token_counter:
+            self._token_counter = GeminiTokenCounter(self.model_type)
+        return self._token_counter
+
+    @api_keys_required("GOOGLE_API_KEY")
+    def run(
+        self,
+        messages: List[OpenAIMessage],
+    ) -> ChatCompletion:
+        r"""Runs inference of Gemini model.
+        This method can handle multimodal input
+
+        Args:
+            messages: Message list or Message with the chat history
+                in OpenAi format.
+
+        Returns:
+            response: A ChatCompletion object formatted for the OpenAI API.
+        """
+        response = self._client.generate_content(
+            contents=self.to_gemini_req(messages),
+            **self.model_config_dict,
+        )
+        response.resolve()
+        return self.to_openai_response(response)
+
+    def check_model_config(self):
+        r"""Check whether the model configuration contains any
+        unexpected arguments to Gemini API.
+
+        Raises:
+            ValueError: If the model configuration dictionary contains any
+                unexpected arguments to OpenAI API.
+        """
+        if self.model_config_dict is not None:
+            for param in self.model_config_dict:
+                if param not in Gemini_API_PARAMS:
+                    raise ValueError(
+                        f"Unexpected argument `{param}` is "
+                        "input into Gemini model backend."
+                    )
+
+    @property
+    def stream(self) -> bool:
+        r"""Returns whether the model is in stream mode,
+            which sends partial results each time.
+
+        Returns:
+            bool: Whether the model is in stream mode.
+        """
+        return self.model_config_dict.get('stream', False)
+
+    def to_gemini_req(self, messages: List[OpenAIMessage]) -> 'ContentsType':
+        r"""Converts the request from the OpenAI API format to
+            the Gemini API request format.
+
+        Args:
+            messages: The request object from the OpenAI API.
+
+        Returns:
+            converted_messages: A list of messages formatted for Gemini API.
+        """
+        # role reference
+        # https://ai.google.dev/api/python/google/generativeai/protos/Content
+        converted_messages = []
+        for message in messages:
+            role = message.get('role')
+            if role == 'assistant':
+                role_to_gemini = 'model'
+            else:
+                role_to_gemini = 'user'
+            converted_message = {
+                "role": role_to_gemini,
+                "parts": message.get("content"),
+            }
+            converted_messages.append(converted_message)
+        return converted_messages
+
+    def to_openai_response(
+        self,
+        response: 'GenerateContentResponse',
+    ) -> ChatCompletion:
+        r"""Converts the response from the Gemini API to the OpenAI API
+        response format.
+
+        Args:
+            response: The response object returned by the Gemini API
+
+        Returns:
+            openai_response: A ChatCompletion object formatted for
+                the OpenAI API.
+        """
+        import time
+        import uuid
+
+        openai_response = ChatCompletion(
+            id=f"chatcmpl-{uuid.uuid4().hex!s}",
+            object="chat.completion",
+            created=int(time.time()),
+            model=self.model_type.value,
+            choices=[],
+        )
+        for i, candidate in enumerate(response.candidates):
+            content = ""
+            if candidate.content and len(candidate.content.parts) > 0:
+                content = candidate.content.parts[0].text
+            finish_reason = candidate.finish_reason
+            finish_reason_mapping = {
+                "FinishReason.STOP": "stop",
+                "FinishReason.SAFETY": "content_filter",
+                "FinishReason.RECITATION": "content_filter",
+                "FinishReason.MAX_TOKENS": "length",
+            }
+            finish_reason = finish_reason_mapping.get(finish_reason, "stop")
+            choice = Choice(
+                index=i,
+                message=ChatCompletionMessage(
+                    role="assistant", content=content
+                ),
+                finish_reason=finish_reason,
+            )
+        openai_response.choices.append(choice)
+        return openai_response

camel/models/model_factory.py

@@ -15,6 +15,7 @@ from typing import Any, Dict, Optional, Union
 
 from camel.models.anthropic_model import AnthropicModel
 from camel.models.base_model import BaseModelBackend
+from camel.models.gemini_model import GeminiModel
 from camel.models.litellm_model import LiteLLMModel
 from camel.models.ollama_model import OllamaModel
 from camel.models.open_source_model import OpenSourceModel
@@ -59,7 +60,6 @@ class ModelFactory:
             BaseModelBackend: The initialized backend.
         """
         model_class: Any
-
         if isinstance(model_type, ModelType):
             if model_platform.is_open_source and model_type.is_open_source:
                 model_class = OpenSourceModel
@@ -70,6 +70,8 @@ class ModelFactory:
                 model_class = AnthropicModel
             elif model_platform.is_zhipuai and model_type.is_zhipuai:
                 model_class = ZhipuAIModel
+            elif model_platform.is_gemini and model_type.is_gemini:
+                model_class = GeminiModel
             elif model_type == ModelType.STUB:
                 model_class = StubModel
             else:
@@ -90,5 +92,4 @@ class ModelFactory:
                 )
         else:
             raise ValueError(f"Invalid model type `{model_type}` provided.")
-
         return model_class(model_type, model_config_dict, api_key, url)

camel/types/enums.py

@@ -58,6 +58,10 @@ class ModelType(Enum):
     # Nvidia models
     NEMOTRON_4_REWARD = "nvidia/nemotron-4-340b-reward"
 
+    # Gemini models
+    GEMINI_1_5_FLASH = "gemini-1.5-flash"
+    GEMINI_1_5_PRO = "gemini-1.5-pro"
+
     @property
     def value_for_tiktoken(self) -> str:
         return (
@@ -126,6 +130,10 @@ class ModelType(Enum):
             ModelType.NEMOTRON_4_REWARD,
         }
 
+    @property
+    def is_gemini(self) -> bool:
+        return self in {ModelType.GEMINI_1_5_FLASH, ModelType.GEMINI_1_5_PRO}
+
     @property
     def token_limit(self) -> int:
         r"""Returns the maximum token limit for a given model.
@@ -142,6 +150,10 @@ class ModelType(Enum):
             return 128000
         elif self is ModelType.GPT_4O:
             return 128000
+        elif self == ModelType.GEMINI_1_5_FLASH:
+            return 1048576
+        elif self == ModelType.GEMINI_1_5_PRO:
+            return 1048576
         elif self == ModelType.GLM_4_OPEN_SOURCE:
             return 8192
         elif self == ModelType.GLM_3_TURBO:
@@ -331,6 +343,7 @@ class ModelPlatformType(Enum):
     LITELLM = "litellm"
     ZHIPU = "zhipuai"
     DEFAULT = "default"
+    GEMINI = "gemini"
 
     @property
     def is_openai(self) -> bool:
@@ -367,6 +380,11 @@ class ModelPlatformType(Enum):
         r"""Returns whether this platform is opensource."""
         return self is ModelPlatformType.OPENSOURCE
 
+    @property
+    def is_gemini(self) -> bool:
+        r"""Returns whether this platform is Gemini."""
+        return self is ModelPlatformType.GEMINI
+
 
 class AudioModelType(Enum):
     TTS_1 = "tts-1"

camel/utils/__init__.py

@@ -32,6 +32,7 @@ from .constants import Constants
 from .token_counting import (
     AnthropicTokenCounter,
     BaseTokenCounter,
+    GeminiTokenCounter,
     LiteLLMTokenCounter,
     OpenAITokenCounter,
     OpenSourceTokenCounter,
@@ -60,4 +61,5 @@ __all__ = [
     'dependencies_required',
     'api_keys_required',
     'is_docker_running',
+    'GeminiTokenCounter',
 ]

camel/utils/token_counting.py

@@ -342,6 +342,40 @@ class AnthropicTokenCounter(BaseTokenCounter):
         return num_tokens
 
 
+class GeminiTokenCounter(BaseTokenCounter):
+    def __init__(self, model_type: ModelType):
+        r"""Constructor for the token counter for Gemini models."""
+        import google.generativeai as genai
+
+        self.model_type = model_type
+        self._client = genai.GenerativeModel(self.model_type.value)
+
+    def count_tokens_from_messages(self, messages: List[OpenAIMessage]) -> int:
+        r"""Count number of tokens in the provided message list using
+        loaded tokenizer specific for this type of model.
+
+        Args:
+            messages (List[OpenAIMessage]): Message list with the chat history
+                in OpenAI API format.
+
+        Returns:
+            int: Number of tokens in the messages.
+        """
+        converted_messages = []
+        for message in messages:
+            role = message.get('role')
+            if role == 'assistant':
+                role_to_gemini = 'model'
+            else:
+                role_to_gemini = 'user'
+            converted_message = {
+                "role": role_to_gemini,
+                "parts": message.get("content"),
+            }
+            converted_messages.append(converted_message)
+        return self._client.count_tokens(converted_messages).total_tokens
+
+
 class LiteLLMTokenCounter:
     def __init__(self, model_type: str):
         r"""Constructor for the token counter for LiteLLM models.

{camel_ai-0.1.5.5.dist-info → camel_ai-0.1.5.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: camel-ai
-Version: 0.1.5.5
+Version: 0.1.5.6
 Summary: Communicative Agents for AI Society Study
 Home-page: https://www.camel-ai.org/
 License: Apache-2.0
@@ -36,6 +36,7 @@ Requires-Dist: docker (>=7.1.0,<8.0.0) ; extra == "tools" or extra == "all"
 Requires-Dist: docstring-parser (>=0.15,<0.16)
 Requires-Dist: docx2txt (>=0.8,<0.9) ; extra == "tools" or extra == "all"
 Requires-Dist: duckduckgo-search (>=6.1.0,<7.0.0) ; extra == "tools" or extra == "all"
+Requires-Dist: google-generativeai (>=0.6.0,<0.7.0) ; extra == "model-platforms" or extra == "all"
 Requires-Dist: googlemaps (>=4.10.0,<5.0.0) ; extra == "tools" or extra == "all"
 Requires-Dist: imageio[pyav] (>=2.34.2,<3.0.0) ; extra == "tools" or extra == "all"
 Requires-Dist: jsonschema (>=4,<5)
@@ -190,7 +191,7 @@ conda create --name camel python=3.9
 conda activate camel
 
 # Clone github repo
-git clone -b v0.1.5.5 https://github.com/camel-ai/camel.git
+git clone -b v0.1.5.6 https://github.com/camel-ai/camel.git
 
 # Change directory into project directory
 cd camel

{camel_ai-0.1.5.5.dist-info → camel_ai-0.1.5.6.dist-info}/RECORD

@@ -1,20 +1,21 @@
-camel/__init__.py,sha256=SpC9pRp8bm5IPRCPalmZqDISaDVcj64s9RpwgxSeg9E,780
+camel/__init__.py,sha256=AHqm3F6XPqSG9VS6iCkImH2Qma_1Sgv2ibfXqciniCQ,780
 camel/agents/__init__.py,sha256=SSU1wbhZXWwQnE0rRxkpyN57kEu72KklsZNcdLkXfTs,1551
 camel/agents/base.py,sha256=X39qWSiT1WnDqaJ9k3gQrTpOQSwUKzNEVpp5AY6fDH8,1130
 camel/agents/chat_agent.py,sha256=yeSSVTnKbRmA7DUFv2waaPz3rMM6z-Gevi0DoYQ8-Uo,27687
 camel/agents/critic_agent.py,sha256=M3XNxRS0wAs5URjc_0kvtXqUlD-KpXq3L5ADz-KCKGU,7199
 camel/agents/deductive_reasoner_agent.py,sha256=8R9hY_yCr_guq_ySuIE3eaYbiPeHVrsh6HKqIWrR0zY,13180
 camel/agents/embodied_agent.py,sha256=Mm2-wvcpduXOvsHMBcavroACyvK06Mxe6QYTf80tdfI,7160
-camel/agents/knowledge_graph_agent.py,sha256=h3LdqqX0KPPyq5v9O4WXZTdcyS2Exz5cMGZPei38ZNo,8818
+camel/agents/knowledge_graph_agent.py,sha256=YWJFVml8p6AE4WHxrXK01rMU0idey5SRbyuRYHEWFWQ,8559
 camel/agents/role_assignment_agent.py,sha256=IWfu5b2RW1gYziffskErhdmybJOusVvhb9gqLF9_5mw,4800
 camel/agents/search_agent.py,sha256=TMyV2LoBVB0hMnSex6q7xbyLRGsF_EMKxCZ8xbZBX9o,4404
-camel/agents/task_agent.py,sha256=aNpn8bYoe2VlVSlWfbV6ynI5zG9pXq6V5NcppqJGVlU,14253
+camel/agents/task_agent.py,sha256=Sn7TckR9p2WyzgFLBN2MfjXaRAzQtW0bgEqpcOqOgzo,14252
 camel/agents/tool_agents/__init__.py,sha256=ulTNWU2qoFGe3pvVmCq_sdfeSX3NKZ0due66TYvsL-M,862
 camel/agents/tool_agents/base.py,sha256=nQAhfWi8a_bCgzlf5-G-tmj1fKm6AjpRc89NQkWwpnc,1399
 camel/agents/tool_agents/hugging_face_tool_agent.py,sha256=1Z5tG6f_86eL0vmtRZ-BJvoLDFFLhoHt8JtDvgat1xU,8723
-camel/configs/__init__.py,sha256=WW7R8GtyeXqBdYDNbax6XK6M1BfEByQHdYT1K3kDPMo,1383
+camel/configs/__init__.py,sha256=momCJ2GkGVTwfNKmmBuJQZrz3hhsxkwLACxUT1-kLkE,1500
 camel/configs/anthropic_config.py,sha256=zD7VMFUw4s7wmBlr64oSXxpEUkhp7wj9mvAd0WK2zFc,3308
 camel/configs/base_config.py,sha256=CEF8ryl_dkH6LgOhwuP5_EgjaWCUCB-E3GcMWR-2YFE,870
+camel/configs/gemini_config.py,sha256=Der-kDsD2vLTLvsG4ju-BfIxPIFdL1xt-kjYJEhEdhg,4922
 camel/configs/litellm_config.py,sha256=tfLls2XkKfmejMuPZT-_k2XzMc0GaepDy31XGzPYJ0I,4885
 camel/configs/ollama_config.py,sha256=npjJMe1lIK_WpnVtSnnKzKE78i2bWb6FPPoPa-nJ3Fo,4396
 camel/configs/openai_config.py,sha256=tFEiPDQ8Cdvkfds83T7_5osNikwA3NuRGbpjV0wq4Ao,7593
@@ -83,11 +84,12 @@ camel/memories/records.py,sha256=zmZsYHVuq6fYqJDkzhNXF02uWLzdBemaEZeG0Ls90pU,361
 camel/messages/__init__.py,sha256=djLvpz6AmjeLzuUSQl7J6T2O4x8MwSdcH0l9fbj_3yg,1468
 camel/messages/base.py,sha256=1cyYITXxBsp2UCdOjF1Ky4W_PgRegEfitqbrF9PjUPs,13721
 camel/messages/func_message.py,sha256=CCVkbz-2pdxXV0vBETI0xt7d7uiN8zACpRI7lCnfTFQ,3841
-camel/models/__init__.py,sha256=RfAHcSSaBUAilObQIU07uICxaujjeO5EwLv4Pg0vrPc,1408
+camel/models/__init__.py,sha256=832nhDetpPm8tg7h9O18rtLQoyANu4VUXF6J6ElDqlU,1465
 camel/models/anthropic_model.py,sha256=mypGlcn2koBFf3FsgBAqOqWwxvY-c1prINr5nYvjvts,5540
 camel/models/base_model.py,sha256=TMbS44Fn-6m0OlrxYCtvwKqGUM_4Jz2y6kX-P28nOeI,4030
+camel/models/gemini_model.py,sha256=xawgEhLjUJCRFWbKRM6zojHbrwNBc2elqki85v9PvIA,7291
 camel/models/litellm_model.py,sha256=3o8ImWSYc_a_3rXA_y5Hh562SzNVyfCmVj9B2pMN78k,4902
-camel/models/model_factory.py,sha256=EFc5_M68AVfi34VhPeftaiWfTR9dDRHUxsJ1F81RxhQ,3949
+camel/models/model_factory.py,sha256=ScPN7stphd2J651VPTABMnh9tCSXS-bKMXwB65uDYYg,4107
 camel/models/nemotron_model.py,sha256=2Idf4wrZervxvfu6av42EKjefFtDnBb6cKnWCJUkqI4,2682
 camel/models/ollama_model.py,sha256=n6Ra4virpjqEZr3rnXwFVScN4WFj3psksEPGadvyk88,4151
 camel/models/open_source_model.py,sha256=r8TGq-9xAwOANZ5s_y3fJUGAvS0zDg03RmbZ8X2ga-E,6156
@@ -143,13 +145,13 @@ camel/toolkits/base.py,sha256=znjnZtgxA5gbT7OMnrKQF_a9FK3A7Xk5s_lP94u76vI,923
 camel/toolkits/code_execution.py,sha256=pwWwZQ5etSghdWUZAg5Wao7l2GC7FYHXiVJfr0tM66E,2426
 camel/toolkits/github_toolkit.py,sha256=NT6gGqy5kV7AGgiJVHAuhlcZxSkTiSJu6f1sm6n-0PU,11516
 camel/types/__init__.py,sha256=ArKXATj3z_Vv4ISmROVeo6Mv3tj5kE1dTkqfgwyxVY4,1975
-camel/types/enums.py,sha256=77O6gCE5YWgqRIND50QMHopsgQ8Ksu5iqfaY4HbOqRU,11876
+camel/types/enums.py,sha256=ojXbi6vmY3zJm4CslxMh3y9NKIhFpWaPtsGb8G1buwQ,12427
 camel/types/openai_types.py,sha256=BNQ6iCzKTjSvgcXFsAFIgrUS_YUFZBU6bDoyAp387hI,2045
-camel/utils/__init__.py,sha256=hD5gV-vYs_otMnQY0ZOuHoJ4iVkmCh2PgBCkYNgIm0Y,1817
+camel/utils/__init__.py,sha256=m85T6bXzNe_2ObpAlXRMAkud4Qz4886WdLp_SEmJwV8,1867
 camel/utils/async_func.py,sha256=q8t7vq_Yd_i5i0b2Mce9d7-hrH70WrtQbqa-T4wYwQU,1595
 camel/utils/commons.py,sha256=J7AOOh5huQkwTvjDt_gpiXNTXnuk0yM_hdtRU8clpNE,11298
 camel/utils/constants.py,sha256=ZIw5ILfOyJFyjEAYrbJMANeg1_EZI-zMK_xVrkwALbM,1105
-camel/utils/token_counting.py,sha256=umFg9UhUpmM9Fu5nbC29UhXuc9iy8b8aKWOYGDEeRcg,15856
-camel_ai-0.1.5.5.dist-info/METADATA,sha256=6y14QJuQrAcvFhszMRfROf3yB1ww3bWcFTChl0I43N8,21966
-camel_ai-0.1.5.5.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-camel_ai-0.1.5.5.dist-info/RECORD,,
+camel/utils/token_counting.py,sha256=euqt0g7WXrHYZTOTBDzcPDL5P4gLzaDpdibH9-8cC3g,17096
+camel_ai-0.1.5.6.dist-info/METADATA,sha256=NN6R_0dQiYI5C_e5KC0kdZmEx0PEtGgMQ_lNdMCUwes,22065
+camel_ai-0.1.5.6.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+camel_ai-0.1.5.6.dist-info/RECORD,,