camel-ai 0.1.5.6__py3-none-any.whl → 0.1.6.1__py3-none-any.whl

camel/types/enums.py

@@ -29,11 +29,22 @@ class ModelType(Enum):
     GPT_4_32K = "gpt-4-32k"
     GPT_4_TURBO = "gpt-4-turbo"
     GPT_4O = "gpt-4o"
+    GPT_4O_MINI = "gpt-4o-mini"
+
     GLM_4 = "glm-4"
     GLM_4_OPEN_SOURCE = "glm-4-open-source"
     GLM_4V = 'glm-4v'
     GLM_3_TURBO = "glm-3-turbo"
 
+    GROQ_LLAMA_3_1_8B = "llama-3.1-8b-instant"
+    GROQ_LLAMA_3_1_70B = "llama-3.1-70b-versatile"
+    GROQ_LLAMA_3_1_405B = "llama-3.1-405b-reasoning"
+    GROQ_LLAMA_3_8B = "llama3-8b-8192"
+    GROQ_LLAMA_3_70B = "llama3-70b-8192"
+    GROQ_MIXTRAL_8_7B = "mixtral-8x7b-32768"
+    GROQ_GEMMA_7B_IT = "gemma-7b-it"
+    GROQ_GEMMA_2_9B_IT = "gemma2-9b-it"
+
     STUB = "stub"
 
     LLAMA_2 = "llama-2"
@@ -44,7 +55,7 @@ class ModelType(Enum):
     QWEN_2 = "qwen-2"
 
     # Legacy anthropic models
-    # NOTE: anthropic lagecy models only Claude 2.1 has system prompt support
+    # NOTE: anthropic legacy models only Claude 2.1 has system prompt support
     CLAUDE_2_1 = "claude-2.1"
     CLAUDE_2_0 = "claude-2.0"
     CLAUDE_INSTANT_1_2 = "claude-instant-1.2"
@@ -62,6 +73,15 @@ class ModelType(Enum):
     GEMINI_1_5_FLASH = "gemini-1.5-flash"
     GEMINI_1_5_PRO = "gemini-1.5-pro"
 
+    # Mistral AI Model
+    MISTRAL_LARGE = "mistral-large-latest"
+    MISTRAL_NEMO = "open-mistral-nemo"
+    MISTRAL_CODESTRAL = "codestral-latest"
+    MISTRAL_7B = "open-mistral-7b"
+    MISTRAL_MIXTRAL_8x7B = "open-mixtral-8x7b"
+    MISTRAL_MIXTRAL_8x22B = "open-mixtral-8x22b"
+    MISTRAL_CODESTRAL_MAMBA = "open-codestral-mamba"
+
     @property
     def value_for_tiktoken(self) -> str:
         return (
@@ -73,6 +93,20 @@ class ModelType(Enum):
     @property
     def is_openai(self) -> bool:
         r"""Returns whether this type of models is an OpenAI-released model."""
+        return self in {
+            ModelType.GPT_3_5_TURBO,
+            ModelType.GPT_4,
+            ModelType.GPT_4_32K,
+            ModelType.GPT_4_TURBO,
+            ModelType.GPT_4O,
+            ModelType.GPT_4O_MINI,
+        }
+
+    @property
+    def is_azure_openai(self) -> bool:
+        r"""Returns whether this type of models is an OpenAI-released model
+        from Azure.
+        """
         return self in {
             ModelType.GPT_3_5_TURBO,
             ModelType.GPT_4,
@@ -119,6 +153,33 @@ class ModelType(Enum):
             ModelType.CLAUDE_3_5_SONNET,
         }
 
+    @property
+    def is_groq(self) -> bool:
+        r"""Returns whether this type of models is served by Groq."""
+        return self in {
+            ModelType.GROQ_LLAMA_3_1_8B,
+            ModelType.GROQ_LLAMA_3_1_70B,
+            ModelType.GROQ_LLAMA_3_1_405B,
+            ModelType.GROQ_LLAMA_3_8B,
+            ModelType.GROQ_LLAMA_3_70B,
+            ModelType.GROQ_MIXTRAL_8_7B,
+            ModelType.GROQ_GEMMA_7B_IT,
+            ModelType.GROQ_GEMMA_2_9B_IT,
+        }
+
+    @property
+    def is_mistral(self) -> bool:
+        r"""Returns whether this type of models is served by Mistral."""
+        return self in {
+            ModelType.MISTRAL_LARGE,
+            ModelType.MISTRAL_NEMO,
+            ModelType.MISTRAL_CODESTRAL,
+            ModelType.MISTRAL_7B,
+            ModelType.MISTRAL_MIXTRAL_8x7B,
+            ModelType.MISTRAL_MIXTRAL_8x22B,
+            ModelType.MISTRAL_CODESTRAL_MAMBA,
+        }
+
     @property
     def is_nvidia(self) -> bool:
         r"""Returns whether this type of models is Nvidia-released model.
@@ -137,46 +198,65 @@ class ModelType(Enum):
     @property
     def token_limit(self) -> int:
         r"""Returns the maximum token limit for a given model.
+
         Returns:
             int: The maximum token limit for the given model.
         """
-        if self is ModelType.GPT_3_5_TURBO:
-            return 16385
-        elif self is ModelType.GPT_4:
-            return 8192
-        elif self is ModelType.GPT_4_32K:
-            return 32768
-        elif self is ModelType.GPT_4_TURBO:
-            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:
-            return 8192
-        elif self == ModelType.GLM_4V:
+        if self is ModelType.GLM_4V:
             return 1024
-        elif self is ModelType.STUB:
-            return 4096
-        elif self is ModelType.LLAMA_2:
-            return 4096
-        elif self is ModelType.LLAMA_3:
-            return 8192
-        elif self is ModelType.QWEN_2:
-            return 128000
-        elif self is ModelType.GLM_4:
-            return 8192
         elif self is ModelType.VICUNA:
             # reference: https://lmsys.org/blog/2023-03-30-vicuna/
             return 2048
-        elif self is ModelType.VICUNA_16K:
-            return 16384
+        elif self in {
+            ModelType.LLAMA_2,
+            ModelType.NEMOTRON_4_REWARD,
+            ModelType.STUB,
+        }:
+            return 4_096
+        elif self in {
+            ModelType.GPT_4,
+            ModelType.GROQ_LLAMA_3_8B,
+            ModelType.GROQ_LLAMA_3_70B,
+            ModelType.GROQ_GEMMA_7B_IT,
+            ModelType.GROQ_GEMMA_2_9B_IT,
+            ModelType.LLAMA_3,
+            ModelType.GLM_3_TURBO,
+            ModelType.GLM_4,
+            ModelType.GLM_4_OPEN_SOURCE,
+        }:
+            return 8_192
+        elif self in {
+            ModelType.GPT_3_5_TURBO,
+            ModelType.VICUNA_16K,
+        }:
+            return 16_384
+        elif self in {
+            ModelType.GPT_4_32K,
+            ModelType.MISTRAL_CODESTRAL,
+            ModelType.MISTRAL_7B,
+            ModelType.MISTRAL_MIXTRAL_8x7B,
+            ModelType.GROQ_MIXTRAL_8_7B,
+        }:
+            return 32_768
+        elif self in {ModelType.MISTRAL_MIXTRAL_8x22B}:
+            return 64_000
         elif self in {ModelType.CLAUDE_2_0, ModelType.CLAUDE_INSTANT_1_2}:
             return 100_000
+        elif self in {
+            ModelType.GPT_4O,
+            ModelType.GPT_4O_MINI,
+            ModelType.GPT_4_TURBO,
+            ModelType.MISTRAL_LARGE,
+            ModelType.MISTRAL_NEMO,
+            ModelType.QWEN_2,
+        }:
+            return 128_000
+        elif self in {
+            ModelType.GROQ_LLAMA_3_1_8B,
+            ModelType.GROQ_LLAMA_3_1_70B,
+            ModelType.GROQ_LLAMA_3_1_405B,
+        }:
+            return 131_072
         elif self in {
             ModelType.CLAUDE_2_1,
             ModelType.CLAUDE_3_OPUS,
@@ -185,8 +265,12 @@ class ModelType(Enum):
             ModelType.CLAUDE_3_5_SONNET,
         }:
             return 200_000
-        elif self is ModelType.NEMOTRON_4_REWARD:
-            return 4096
+        elif self in {
+            ModelType.MISTRAL_CODESTRAL_MAMBA,
+        }:
+            return 256_000
+        elif self in {ModelType.GEMINI_1_5_FLASH, ModelType.GEMINI_1_5_PRO}:
+            return 1_048_576
         else:
             raise ValueError("Unknown model type")
 
@@ -195,8 +279,9 @@ class ModelType(Enum):
 
         Args:
             model_name (str): The name of the model, e.g. "vicuna-7b-v1.5".
+
         Returns:
-            bool: Whether the model type mathches the model name.
+            bool: Whether the model type matches the model name.
         """
         if self is ModelType.VICUNA:
             pattern = r'^vicuna-\d+b-v\d+\.\d+$'
@@ -232,6 +317,8 @@ class EmbeddingModelType(Enum):
     TEXT_EMBEDDING_3_SMALL = "text-embedding-3-small"
     TEXT_EMBEDDING_3_LARGE = "text-embedding-3-large"
 
+    MISTRAL_EMBED = "mistral-embed"
+
     @property
     def is_openai(self) -> bool:
         r"""Returns whether this type of models is an OpenAI-released model."""
@@ -241,6 +328,15 @@ class EmbeddingModelType(Enum):
             EmbeddingModelType.TEXT_EMBEDDING_3_LARGE,
         }
 
+    @property
+    def is_mistral(self) -> bool:
+        r"""Returns whether this type of models is an Mistral-released
+        model.
+        """
+        return self in {
+            EmbeddingModelType.MISTRAL_EMBED,
+        }
+
     @property
     def output_dim(self) -> int:
         if self is EmbeddingModelType.TEXT_EMBEDDING_ADA_2:
@@ -249,6 +345,8 @@ class EmbeddingModelType(Enum):
             return 1536
         elif self is EmbeddingModelType.TEXT_EMBEDDING_3_LARGE:
             return 3072
+        elif self is EmbeddingModelType.MISTRAL_EMBED:
+            return 1024
         else:
             raise ValueError(f"Unknown model type {self}.")
 
@@ -263,6 +361,8 @@ class TaskType(Enum):
     ROLE_DESCRIPTION = "role_description"
     GENERATE_TEXT_EMBEDDING_DATA = "generate_text_embedding_data"
     OBJECT_RECOGNITION = "object_recognition"
+    IMAGE_CRAFT = "image_craft"
+    MULTI_CONDITION_IMAGE_CRAFT = "multi_condition_image_craft"
     DEFAULT = "default"
     VIDEO_DESCRIPTION = "video_description"
 
@@ -285,6 +385,7 @@ class OpenAIBackendRole(Enum):
     SYSTEM = "system"
     USER = "user"
     FUNCTION = "function"
+    TOOL = "tool"
 
 
 class TerminationMode(Enum):
@@ -338,12 +439,15 @@ class ModelPlatformType(Enum):
     OPENAI = "openai"
     AZURE = "azure"
     ANTHROPIC = "anthropic"
+    GROQ = "groq"
     OPENSOURCE = "opensource"
     OLLAMA = "ollama"
     LITELLM = "litellm"
     ZHIPU = "zhipuai"
     DEFAULT = "default"
     GEMINI = "gemini"
+    VLLM = "vllm"
+    MISTRAL = "mistral"
 
     @property
     def is_openai(self) -> bool:
@@ -360,11 +464,21 @@ class ModelPlatformType(Enum):
         r"""Returns whether this platform is anthropic."""
         return self is ModelPlatformType.ANTHROPIC
 
+    @property
+    def is_groq(self) -> bool:
+        r"""Returns whether this platform is groq."""
+        return self is ModelPlatformType.GROQ
+
     @property
     def is_ollama(self) -> bool:
         r"""Returns whether this platform is ollama."""
         return self is ModelPlatformType.OLLAMA
 
+    @property
+    def is_vllm(self) -> bool:
+        r"""Returns whether this platform is vllm."""
+        return self is ModelPlatformType.VLLM
+
     @property
     def is_litellm(self) -> bool:
         r"""Returns whether this platform is litellm."""
@@ -375,6 +489,11 @@ class ModelPlatformType(Enum):
         r"""Returns whether this platform is zhipu."""
         return self is ModelPlatformType.ZHIPU
 
+    @property
+    def is_mistral(self) -> bool:
+        r"""Returns whether this platform is mistral."""
+        return self is ModelPlatformType.MISTRAL
+
     @property
     def is_open_source(self) -> bool:
         r"""Returns whether this platform is opensource."""

camel/utils/__init__.py

@@ -13,17 +13,22 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 
 from .commons import (
-    PYDANTIC_V2,
+    AgentOpsMeta,
+    agentops_decorator,
     api_keys_required,
     check_server_running,
     create_chunks,
     dependencies_required,
     download_tasks,
+    func_string_to_callable,
     get_first_int,
     get_prompt_template_key_words,
+    get_pydantic_major_version,
+    get_pydantic_object_schema,
     get_system_information,
     get_task_list,
     is_docker_running,
+    json_to_function_code,
     print_text_animated,
     text_extract_from_web,
     to_pascal,
@@ -34,6 +39,7 @@ from .token_counting import (
     BaseTokenCounter,
     GeminiTokenCounter,
     LiteLLMTokenCounter,
+    MistralTokenCounter,
     OpenAITokenCounter,
     OpenSourceTokenCounter,
     get_model_encoding,
@@ -49,7 +55,6 @@ __all__ = [
     'AnthropicTokenCounter',
     'get_system_information',
     'to_pascal',
-    'PYDANTIC_V2',
     'get_model_encoding',
     'BaseTokenCounter',
     'OpenAITokenCounter',
@@ -62,4 +67,11 @@ __all__ = [
     'api_keys_required',
     'is_docker_running',
     'GeminiTokenCounter',
+    'MistralTokenCounter',
+    'get_pydantic_major_version',
+    'get_pydantic_object_schema',
+    'func_string_to_callable',
+    'json_to_function_code',
+    'agentops_decorator',
+    'AgentOpsMeta',
 ]

camel/utils/async_func.py

@@ -14,7 +14,7 @@
 import asyncio
 from copy import deepcopy
 
-from camel.functions.openai_function import OpenAIFunction
+from camel.toolkits import OpenAIFunction
 
 
 def sync_funcs_to_async(funcs: list[OpenAIFunction]) -> list[OpenAIFunction]:

camel/utils/commons.py

@@ -20,14 +20,27 @@ import subprocess
 import time
 import zipfile
 from functools import wraps
-from typing import Any, Callable, List, Optional, Set, TypeVar, cast
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    List,
+    Mapping,
+    Optional,
+    Set,
+    TypeVar,
+    cast,
+)
 from urllib.parse import urlparse
 
 import pydantic
 import requests
+from pydantic import BaseModel
 
 from camel.types import TaskType
 
+from .constants import Constants
+
 F = TypeVar('F', bound=Callable[..., Any])
 
 
@@ -303,7 +316,97 @@ def to_pascal(snake: str) -> str:
     )
 
 
-PYDANTIC_V2 = pydantic.VERSION.startswith("2.")
+def get_pydantic_major_version() -> int:
+    r"""Get the major version of Pydantic.
+
+    Returns:
+        int: The major version number of Pydantic if installed, otherwise 0.
+    """
+    try:
+        return int(pydantic.__version__.split(".")[0])
+    except ImportError:
+        return 0
+
+
+def get_pydantic_object_schema(pydantic_params: BaseModel) -> Dict:
+    r"""Get the JSON schema of a Pydantic model.
+
+    Args:
+        pydantic_params (BaseModel): The Pydantic model to retrieve the schema
+            for.
+
+    Returns:
+        dict: The JSON schema of the Pydantic model.
+    """
+    return pydantic_params.model_json_schema()
+
+
+def func_string_to_callable(code: str):
+    r"""Convert a function code string to a callable function object.
+
+    Args:
+        code (str): The function code as a string.
+
+    Returns:
+        Callable[..., Any]: The callable function object extracted from the
+            code string.
+    """
+    local_vars: Mapping[str, object] = {}
+    exec(code, globals(), local_vars)
+    func = local_vars.get(Constants.FUNC_NAME_FOR_STRUCTURE_OUTPUT)
+    return func
+
+
+def json_to_function_code(json_obj: Dict) -> str:
+    r"""Generate a Python function code from a JSON schema.
+
+    Args:
+        json_obj (dict): The JSON schema object containing properties and
+            required fields, and json format is follow openai tools schema
+
+    Returns:
+        str: The generated Python function code as a string.
+    """
+    properties = json_obj.get('properties', {})
+    required = json_obj.get('required', [])
+
+    if not properties or not required:
+        raise ValueError(
+            "JSON schema must contain 'properties' and 'required' fields"
+        )
+
+    args = []
+    docstring_args = []
+    return_keys = []
+
+    for prop in required:
+        description = properties[prop]['description']
+        prop_type = properties[prop]['type']
+        python_type = 'str' if prop_type == 'string' else prop_type
+        args.append(f"{prop}: {python_type}")
+        docstring_args.append(
+            f"        {prop} ({python_type}): {description}."
+        )
+        return_keys.append(prop)
+
+    # extract entity of schema
+    args_str = ", ".join(args)
+    docstring_args_str = "\n".join(docstring_args)
+    return_keys_str = ", ".join(return_keys)
+
+    # function template
+    function_code = f'''
+def {Constants.FUNC_NAME_FOR_STRUCTURE_OUTPUT}({args_str}):
+    r"""Return response with a specified json format.
+    Args:
+{docstring_args_str}
+    Returns:
+        Dict: A dictionary containing {return_keys_str}.
+    """
+    return {{{", ".join([f'"{prop}": {prop}' for prop in required])}}}
+    '''
+
+    return function_code
 
 
 def text_extract_from_web(url: str) -> str:
@@ -382,3 +485,50 @@ def is_docker_running() -> bool:
         return result.returncode == 0
     except (subprocess.CalledProcessError, FileNotFoundError):
         return False
+
+
+try:
+    from agentops import ToolEvent, record
+except ImportError:
+    ToolEvent = None
+
+
+def agentops_decorator(func):
+    r"""Decorator that records the execution of a function if ToolEvent is
+    available.
+
+    Parameters:
+        func (callable): The function to be decorated.
+
+    Returns:
+        callable: The wrapped function which records its execution details.
+    """
+
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        if ToolEvent:
+            tool_event = ToolEvent(name=func.__name__, params=kwargs)
+            result = func(*args, **kwargs)
+            tool_event.returns = result
+            record(tool_event)
+            return result
+        return func(*args, **kwargs)
+
+    return wrapper
+
+
+class AgentOpsMeta(type):
+    r"""Metaclass that automatically decorates all callable attributes with
+    the agentops_decorator,
+    except for the 'get_tools' method.
+
+    Methods:
+    __new__(cls, name, bases, dct):
+        Creates a new class with decorated methods.
+    """
+
+    def __new__(cls, name, bases, dct):
+        for attr, value in dct.items():
+            if callable(value) and attr != 'get_tools':
+                dct[attr] = agentops_decorator(value)
+        return super(AgentOpsMeta, cls).__new__(cls, name, bases, dct)

camel/utils/constants.py

@@ -24,3 +24,6 @@ class Constants:
 
     # default plug of imageio to read video
     VIDEO_DEFAULT_PLUG_PYAV = "pyav"
+
+    # return response with json format
+    FUNC_NAME_FOR_STRUCTURE_OUTPUT = "return_json_response"