camel-ai 0.2.78__py3-none-any.whl → 0.2.79a1__py3-none-any.whl

camel/models/azure_openai_model.py

@@ -13,6 +13,7 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 import copy
 import os
+import warnings
 from typing import Any, Callable, Dict, List, Optional, Type, Union
 
 from openai import AsyncAzureOpenAI, AsyncStream, AzureOpenAI, Stream
@@ -60,7 +61,8 @@ class AzureOpenAIModel(BaseModelBackend):
 
     Args:
         model_type (Union[ModelType, str]): Model for which a backend is
-            created, one of GPT_* series.
+            created, Should be the deployment name you chose when you deployed
+            an azure model.
         model_config_dict (Optional[Dict[str, Any]], optional): A dictionary
             that will be fed into:obj:`openai.ChatCompletion.create()`. If
             :obj:`None`, :obj:`ChatGPTConfig().as_dict()` will be used.
@@ -71,8 +73,6 @@ class AzureOpenAIModel(BaseModelBackend):
             (default: :obj:`None`)
         api_version (Optional[str], optional): The api version for the model.
             (default: :obj:`None`)
-        azure_deployment_name (Optional[str], optional): The deployment name
-            you chose when you deployed an azure model. (default: :obj:`None`)
         azure_ad_token (Optional[str], optional): Your Azure Active Directory
             token, https://www.microsoft.com/en-us/security/business/
             identity-access/microsoft-entra-id. (default: :obj:`None`)
@@ -88,8 +88,23 @@ class AzureOpenAIModel(BaseModelBackend):
             (default: :obj:`None`)
         max_retries (int, optional): Maximum number of retries for API calls.
             (default: :obj:`3`)
+        client (Optional[Any], optional): A custom synchronous AzureOpenAI
+            client instance. If provided, this client will be used instead of
+            creating a new one. Useful for RL frameworks like AReaL or rLLM
+            that provide Azure OpenAI-compatible clients. The client should
+            implement the AzureOpenAI client interface with
+            `.chat.completions.create()` and `.beta.chat.completions.parse()`
+            methods. (default: :obj:`None`)
+        async_client (Optional[Any], optional): A custom asynchronous
+            AzureOpenAI client instance. If provided, this client will be
+            used instead of creating a new one. The client should implement
+            the AsyncAzureOpenAI client interface. (default: :obj:`None`)
+        azure_deployment_name (Optional[str], optional): **Deprecated**.
+            Use `model_type` parameter instead. This parameter is kept for
+            backward compatibility and will be removed in a future version.
+            (default: :obj:`None`)
         **kwargs (Any): Additional arguments to pass to the client
-            initialization.
+            initialization. Ignored if custom clients are provided.
 
     References:
         https://learn.microsoft.com/en-us/azure/ai-services/openai/
@@ -104,12 +119,35 @@ class AzureOpenAIModel(BaseModelBackend):
         timeout: Optional[float] = None,
         token_counter: Optional[BaseTokenCounter] = None,
         api_version: Optional[str] = None,
-        azure_deployment_name: Optional[str] = None,
         azure_ad_token_provider: Optional["AzureADTokenProvider"] = None,
         azure_ad_token: Optional[str] = None,
         max_retries: int = 3,
+        client: Optional[Any] = None,
+        async_client: Optional[Any] = None,
+        azure_deployment_name: Optional[str] = None,
         **kwargs: Any,
     ) -> None:
+        # Handle deprecated azure_deployment_name parameter
+        if azure_deployment_name is not None:
+            warnings.warn(
+                "The 'azure_deployment_name' parameter is deprecated. "
+                "Please use 'model_type' parameter instead. "
+                "The 'azure_deployment_name' parameter is being ignored.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+
+        # Handle deprecated AZURE_DEPLOYMENT_NAME environment variable
+        if os.environ.get("AZURE_DEPLOYMENT_NAME") is not None:
+            warnings.warn(
+                "The 'AZURE_DEPLOYMENT_NAME' environment variable is "
+                "deprecated. Please use the 'model_type' parameter "
+                "instead. The 'AZURE_DEPLOYMENT_NAME' environment "
+                "variable is being ignored.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+
         if model_config_dict is None:
             model_config_dict = ChatGPTConfig().as_dict()
         api_key = api_key or os.environ.get("AZURE_OPENAI_API_KEY")
@@ -120,9 +158,6 @@ class AzureOpenAIModel(BaseModelBackend):
         )
 
         self.api_version = api_version or os.environ.get("AZURE_API_VERSION")
-        self._azure_deployment_name = azure_deployment_name or os.environ.get(
-            "AZURE_DEPLOYMENT_NAME"
-        )
         self._azure_ad_token = azure_ad_token or os.environ.get(
             "AZURE_AD_TOKEN"
         )
@@ -132,62 +167,73 @@ class AzureOpenAIModel(BaseModelBackend):
                 "Must provide either the `api_version` argument "
                 "or `AZURE_API_VERSION` environment variable."
             )
-        if self._azure_deployment_name is None:
-            raise ValueError(
-                "Must provide either the `azure_deployment_name` argument "
-                "or `AZURE_DEPLOYMENT_NAME` environment variable."
-            )
 
-        if is_langfuse_available():
-            from langfuse.openai import AsyncAzureOpenAI as LangfuseAsyncOpenAI
-            from langfuse.openai import AzureOpenAI as LangfuseOpenAI
-
-            self._client = LangfuseOpenAI(
-                azure_endpoint=str(self._url),
-                azure_deployment=self._azure_deployment_name,
-                api_version=self.api_version,
-                api_key=self._api_key,
-                azure_ad_token=self._azure_ad_token,
-                azure_ad_token_provider=self.azure_ad_token_provider,
-                timeout=self._timeout,
-                max_retries=max_retries,
-                **kwargs,
-            )
-            self._async_client = LangfuseAsyncOpenAI(
-                azure_endpoint=str(self._url),
-                azure_deployment=self._azure_deployment_name,
-                api_version=self.api_version,
-                api_key=self._api_key,
-                azure_ad_token=self._azure_ad_token,
-                azure_ad_token_provider=self.azure_ad_token_provider,
-                timeout=self._timeout,
-                max_retries=max_retries,
-                **kwargs,
-            )
+        # Use custom clients if provided, otherwise create new ones
+        if client is not None:
+            # Use the provided custom sync client
+            self._client = client
         else:
-            self._client = AzureOpenAI(
-                azure_endpoint=str(self._url),
-                azure_deployment=self._azure_deployment_name,
-                api_version=self.api_version,
-                api_key=self._api_key,
-                azure_ad_token=self._azure_ad_token,
-                azure_ad_token_provider=self.azure_ad_token_provider,
-                timeout=self._timeout,
-                max_retries=max_retries,
-                **kwargs,
-            )
+            # Create default sync client
+            if is_langfuse_available():
+                from langfuse.openai import AzureOpenAI as LangfuseOpenAI
+
+                self._client = LangfuseOpenAI(
+                    azure_endpoint=str(self._url),
+                    azure_deployment=str(self.model_type),
+                    api_version=self.api_version,
+                    api_key=self._api_key,
+                    azure_ad_token=self._azure_ad_token,
+                    azure_ad_token_provider=self.azure_ad_token_provider,
+                    timeout=self._timeout,
+                    max_retries=max_retries,
+                    **kwargs,
+                )
+            else:
+                self._client = AzureOpenAI(
+                    azure_endpoint=str(self._url),
+                    azure_deployment=str(self.model_type),
+                    api_version=self.api_version,
+                    api_key=self._api_key,
+                    azure_ad_token=self._azure_ad_token,
+                    azure_ad_token_provider=self.azure_ad_token_provider,
+                    timeout=self._timeout,
+                    max_retries=max_retries,
+                    **kwargs,
+                )
 
-            self._async_client = AsyncAzureOpenAI(
-                azure_endpoint=str(self._url),
-                azure_deployment=self._azure_deployment_name,
-                api_version=self.api_version,
-                api_key=self._api_key,
-                azure_ad_token=self._azure_ad_token,
-                azure_ad_token_provider=self.azure_ad_token_provider,
-                timeout=self._timeout,
-                max_retries=max_retries,
-                **kwargs,
-            )
+        if async_client is not None:
+            # Use the provided custom async client
+            self._async_client = async_client
+        else:
+            # Create default async client
+            if is_langfuse_available():
+                from langfuse.openai import (
+                    AsyncAzureOpenAI as LangfuseAsyncOpenAI,
+                )
+
+                self._async_client = LangfuseAsyncOpenAI(
+                    azure_endpoint=str(self._url),
+                    azure_deployment=str(self.model_type),
+                    api_version=self.api_version,
+                    api_key=self._api_key,
+                    azure_ad_token=self._azure_ad_token,
+                    azure_ad_token_provider=self.azure_ad_token_provider,
+                    timeout=self._timeout,
+                    max_retries=max_retries,
+                    **kwargs,
+                )
+            else:
+                self._async_client = AsyncAzureOpenAI(
+                    azure_endpoint=str(self._url),
+                    azure_deployment=str(self.model_type),
+                    api_version=self.api_version,
+                    api_key=self._api_key,
+                    azure_ad_token=self._azure_ad_token,
+                    azure_ad_token_provider=self.azure_ad_token_provider,
+                    timeout=self._timeout,
+                    max_retries=max_retries,
+                    **kwargs,
+                )
 
     @property
     def token_counter(self) -> BaseTokenCounter:
@@ -330,7 +376,7 @@ class AzureOpenAIModel(BaseModelBackend):
 
         return self._client.chat.completions.create(
             messages=messages,
-            model=self._azure_deployment_name,  # type:ignore[arg-type]
+            model=str(self.model_type),
             **request_config,
         )
 
@@ -346,7 +392,7 @@ class AzureOpenAIModel(BaseModelBackend):
 
         return await self._async_client.chat.completions.create(
             messages=messages,
-            model=self._azure_deployment_name,  # type:ignore[arg-type]
+            model=str(self.model_type),
             **request_config,
         )
 
@@ -367,7 +413,7 @@ class AzureOpenAIModel(BaseModelBackend):
 
         return self._client.beta.chat.completions.parse(
             messages=messages,
-            model=self._azure_deployment_name,  # type:ignore[arg-type]
+            model=str(self.model_type),
             **request_config,
         )
 
@@ -388,7 +434,7 @@ class AzureOpenAIModel(BaseModelBackend):
 
         return await self._async_client.beta.chat.completions.parse(
             messages=messages,
-            model=self._azure_deployment_name,  # type:ignore[arg-type]
+            model=str(self.model_type),
             **request_config,
         )
 
@@ -414,7 +460,7 @@ class AzureOpenAIModel(BaseModelBackend):
         # Use the beta streaming API for structured outputs
         return self._client.beta.chat.completions.stream(
             messages=messages,
-            model=self.model_type,
+            model=str(self.model_type),
             response_format=response_format,
             **request_config,
         )
@@ -441,7 +487,7 @@ class AzureOpenAIModel(BaseModelBackend):
         # Use the beta streaming API for structured outputs
         return self._async_client.beta.chat.completions.stream(
             messages=messages,
-            model=self.model_type,
+            model=str(self.model_type),
             response_format=response_format,
             **request_config,
         )

camel/models/model_factory.py

@@ -13,7 +13,7 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 import json
 import os
-from typing import ClassVar, Dict, Optional, Type, Union
+from typing import Any, ClassVar, Dict, Optional, Type, Union
 
 from camel.models.aiml_model import AIMLModel
 from camel.models.amd_model import AMDModel
@@ -119,6 +119,8 @@ class ModelFactory:
         url: Optional[str] = None,
         timeout: Optional[float] = None,
         max_retries: int = 3,
+        client: Optional[Any] = None,
+        async_client: Optional[Any] = None,
         **kwargs,
     ) -> BaseModelBackend:
         r"""Creates an instance of `BaseModelBackend` of the specified type.
@@ -145,6 +147,14 @@ class ModelFactory:
                 for API calls. (default: :obj:`None`)
             max_retries (int, optional): Maximum number of retries
                 for API calls. (default: :obj:`3`)
+            client (Optional[Any], optional): A custom synchronous client
+                instance. Supported by models that use OpenAI-compatible APIs
+                . The client should implement the appropriate client interface
+                for the platform. (default: :obj:`None`)
+            async_client (Optional[Any], optional): A custom asynchronous
+                client instance. Supported by models that use OpenAI-compatible
+                APIs. The client should implement the appropriate async client
+                interface for the platform. (default: :obj:`None`)
             **kwargs: Additional model-specific parameters that will be passed
                 to the model constructor. For example, Azure OpenAI models may
                 require `api_version`, `azure_deployment_name`,
@@ -190,6 +200,12 @@ class ModelFactory:
         if model_class is None:
             raise ValueError(f"Unknown model platform `{model_platform}`")
 
+        # Pass client and async_client via kwargs if provided
+        if client is not None:
+            kwargs['client'] = client
+        if async_client is not None:
+            kwargs['async_client'] = async_client
+
         return model_class(
             model_type=model_type,
             model_config_dict=model_config_dict,

camel/models/moonshot_model.py

@@ -12,6 +12,7 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 
+import copy
 import os
 from typing import Any, Dict, List, Optional, Type, Union
 
@@ -19,6 +20,7 @@ from openai import AsyncStream
 from pydantic import BaseModel
 
 from camel.configs import MoonshotConfig
+from camel.logger import get_logger
 from camel.messages import OpenAIMessage
 from camel.models._utils import try_modify_message_with_format
 from camel.models.openai_compatible_model import OpenAICompatibleModel
@@ -34,6 +36,8 @@ from camel.utils import (
     update_langfuse_trace,
 )
 
+logger = get_logger(__name__)
+
 if os.environ.get("LANGFUSE_ENABLED", "False").lower() == "true":
     try:
         from langfuse.decorators import observe
@@ -84,7 +88,7 @@ class MoonshotModel(OpenAICompatibleModel):
         model_type: Union[ModelType, str],
         model_config_dict: Optional[Dict[str, Any]] = None,
         api_key: Optional[str] = None,
-        url: Optional[str] = "https://api.moonshot.ai/v1",
+        url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
         timeout: Optional[float] = None,
         max_retries: int = 3,
@@ -93,7 +97,12 @@ class MoonshotModel(OpenAICompatibleModel):
         if model_config_dict is None:
             model_config_dict = MoonshotConfig().as_dict()
         api_key = api_key or os.environ.get("MOONSHOT_API_KEY")
-        url = url or os.environ.get("MOONSHOT_API_BASE_URL")
+        # Preserve default URL if not provided
+        if url is None:
+            url = (
+                os.environ.get("MOONSHOT_API_BASE_URL")
+                or "https://api.moonshot.ai/v1"
+            )
         timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
         super().__init__(
             model_type=model_type,
@@ -125,12 +134,12 @@ class MoonshotModel(OpenAICompatibleModel):
         Returns:
             Dict[str, Any]: The prepared request configuration.
         """
-        import copy
-
         request_config = copy.deepcopy(self.model_config_dict)
 
         if tools:
-            request_config["tools"] = tools
+            # Clean tools to remove null types (Moonshot API incompatibility)
+            cleaned_tools = self._clean_tool_schemas(tools)
+            request_config["tools"] = cleaned_tools
         elif response_format:
             # Use the same approach as DeepSeek for structured output
             try_modify_message_with_format(messages[-1], response_format)
@@ -138,6 +147,94 @@ class MoonshotModel(OpenAICompatibleModel):
 
         return request_config
 
+    def _clean_tool_schemas(
+        self, tools: List[Dict[str, Any]]
+    ) -> List[Dict[str, Any]]:
+        r"""Clean tool schemas to remove null types for Moonshot compatibility.
+
+        Moonshot API doesn't accept {"type": "null"} in anyOf schemas.
+        This method removes null type definitions from parameters.
+
+        Args:
+            tools (List[Dict[str, Any]]): Original tool schemas.
+
+        Returns:
+            List[Dict[str, Any]]: Cleaned tool schemas.
+        """
+
+        def remove_null_from_schema(schema: Any) -> Any:
+            """Recursively remove null types from schema."""
+            if isinstance(schema, dict):
+                # Create a copy to avoid modifying the original
+                result = {}
+
+                for key, value in schema.items():
+                    if key == 'type' and isinstance(value, list):
+                        # Handle type arrays like ["string", "null"]
+                        filtered_types = [t for t in value if t != 'null']
+                        if len(filtered_types) == 1:
+                            # Single type remains, convert to string
+                            result[key] = filtered_types[0]
+                        elif len(filtered_types) > 1:
+                            # Multiple types remain, keep as array
+                            result[key] = filtered_types
+                        else:
+                            # All were null, use string as fallback
+                            logger.warning(
+                                "All types in tool schema type array "
+                                "were null, falling back to 'string' "
+                                "type for Moonshot API compatibility. "
+                                "Original tool schema may need review."
+                            )
+                            result[key] = 'string'
+                    elif key == 'anyOf':
+                        # Handle anyOf with null types
+                        filtered = [
+                            item
+                            for item in value
+                            if not (
+                                isinstance(item, dict)
+                                and item.get('type') == 'null'
+                            )
+                        ]
+                        if len(filtered) == 1:
+                            # If only one type remains, flatten it
+                            return remove_null_from_schema(filtered[0])
+                        elif len(filtered) > 1:
+                            result[key] = [
+                                remove_null_from_schema(item)
+                                for item in filtered
+                            ]
+                        else:
+                            # All were null, return string type as fallback
+                            logger.warning(
+                                "All types in tool schema anyOf were null, "
+                                "falling back to 'string' type for "
+                                "Moonshot API compatibility. Original "
+                                "tool schema may need review."
+                            )
+                            return {"type": "string"}
+                    else:
+                        # Recursively process other values
+                        result[key] = remove_null_from_schema(value)
+
+                return result
+            elif isinstance(schema, list):
+                return [remove_null_from_schema(item) for item in schema]
+            else:
+                return schema
+
+        cleaned_tools = copy.deepcopy(tools)
+        for tool in cleaned_tools:
+            if 'function' in tool and 'parameters' in tool['function']:
+                params = tool['function']['parameters']
+                if 'properties' in params:
+                    params['properties'] = remove_null_from_schema(
+                        params['properties']
+                    )
+
+        return cleaned_tools
+
     @observe()
     async def _arun(
         self,

camel/models/openai_compatible_model.py

@@ -78,9 +78,21 @@ class OpenAICompatibleModel(BaseModelBackend):
             (default: :obj:`None`)
         max_retries (int, optional): Maximum number of retries for API calls.
             (default: :obj:`3`)
+        client (Optional[Any], optional): A custom synchronous
+            OpenAI-compatible client instance. If provided, this client will
+            be used instead of creating a new one. Useful for RL frameworks
+            like AReaL or rLLM that provide OpenAI-compatible clients (e.g.,
+            ArealOpenAI). The client should implement the OpenAI client
+            interface with `.chat.completions.create()` and `.beta.chat.
+            completions.parse()` methods. (default: :obj:`None`)
+        async_client (Optional[Any], optional): A custom asynchronous
+            OpenAI-compatible client instance. If provided, this client will
+            be used instead of creating a new one. The client should implement
+            the AsyncOpenAI client interface. (default: :obj:`None`)
         **kwargs (Any): Additional arguments to pass to the
             OpenAI client initialization. These can include parameters like
             'organization', 'default_headers', 'http_client', etc.
+            Ignored if custom clients are provided.
     """
 
     def __init__(
@@ -92,6 +104,8 @@ class OpenAICompatibleModel(BaseModelBackend):
         token_counter: Optional[BaseTokenCounter] = None,
         timeout: Optional[float] = None,
         max_retries: int = 3,
+        client: Optional[Any] = None,
+        async_client: Optional[Any] = None,
         **kwargs: Any,
     ) -> None:
         api_key = api_key or os.environ.get("OPENAI_COMPATIBILITY_API_KEY")
@@ -107,39 +121,55 @@ class OpenAICompatibleModel(BaseModelBackend):
             timeout,
             max_retries,
         )
-        if is_langfuse_available():
-            from langfuse.openai import AsyncOpenAI as LangfuseAsyncOpenAI
-            from langfuse.openai import OpenAI as LangfuseOpenAI
-
-            self._client = LangfuseOpenAI(
-                timeout=self._timeout,
-                max_retries=max_retries,
-                base_url=self._url,
-                api_key=self._api_key,
-                **kwargs,
-            )
-            self._async_client = LangfuseAsyncOpenAI(
-                timeout=self._timeout,
-                max_retries=max_retries,
-                base_url=self._url,
-                api_key=self._api_key,
-                **kwargs,
-            )
+
+        # Use custom clients if provided, otherwise create new ones
+        if client is not None:
+            # Use the provided custom sync client
+            self._client = client
         else:
-            self._client = OpenAI(
-                timeout=self._timeout,
-                max_retries=max_retries,
-                base_url=self._url,
-                api_key=self._api_key,
-                **kwargs,
-            )
-            self._async_client = AsyncOpenAI(
-                timeout=self._timeout,
-                max_retries=max_retries,
-                base_url=self._url,
-                api_key=self._api_key,
-                **kwargs,
-            )
+            # Create default sync client
+            if is_langfuse_available():
+                from langfuse.openai import OpenAI as LangfuseOpenAI
+
+                self._client = LangfuseOpenAI(
+                    timeout=self._timeout,
+                    max_retries=max_retries,
+                    base_url=self._url,
+                    api_key=self._api_key,
+                    **kwargs,
+                )
+            else:
+                self._client = OpenAI(
+                    timeout=self._timeout,
+                    max_retries=max_retries,
+                    base_url=self._url,
+                    api_key=self._api_key,
+                    **kwargs,
+                )
+
+        if async_client is not None:
+            # Use the provided custom async client
+            self._async_client = async_client
+        else:
+            # Create default async client
+            if is_langfuse_available():
+                from langfuse.openai import AsyncOpenAI as LangfuseAsyncOpenAI
+
+                self._async_client = LangfuseAsyncOpenAI(
+                    timeout=self._timeout,
+                    max_retries=max_retries,
+                    base_url=self._url,
+                    api_key=self._api_key,
+                    **kwargs,
+                )
+            else:
+                self._async_client = AsyncOpenAI(
+                    timeout=self._timeout,
+                    max_retries=max_retries,
+                    base_url=self._url,
+                    api_key=self._api_key,
+                    **kwargs,
+                )
 
     @observe()
     def _run(