camel-ai 0.2.59__py3-none-any.whl → 0.2.82__py3-none-any.whl

camel/models/model_factory.py

@@ -1,4 +1,4 @@
-# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# ========= Copyright 2023-2025 @ 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
@@ -10,27 +10,33 @@
 # 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. =========
+# ========= Copyright 2023-2025 @ CAMEL-AI.org. All Rights Reserved. =========
 import json
-from typing import ClassVar, Dict, Optional, Type, Union
-
-import yaml
+import os
+from typing import Any, ClassVar, Dict, Optional, Type, Union
 
+from camel.models.aihubmix_model import AihubMixModel
 from camel.models.aiml_model import AIMLModel
+from camel.models.amd_model import AMDModel
 from camel.models.anthropic_model import AnthropicModel
 from camel.models.aws_bedrock_model import AWSBedrockModel
 from camel.models.azure_openai_model import AzureOpenAIModel
 from camel.models.base_model import BaseModelBackend
+from camel.models.cerebras_model import CerebrasModel
 from camel.models.cohere_model import CohereModel
+from camel.models.cometapi_model import CometAPIModel
+from camel.models.crynux_model import CrynuxModel
 from camel.models.deepseek_model import DeepSeekModel
 from camel.models.gemini_model import GeminiModel
 from camel.models.groq_model import GroqModel
 from camel.models.internlm_model import InternLMModel
 from camel.models.litellm_model import LiteLLMModel
 from camel.models.lmstudio_model import LMStudioModel
+from camel.models.minimax_model import MinimaxModel
 from camel.models.mistral_model import MistralModel
 from camel.models.modelscope_model import ModelScopeModel
 from camel.models.moonshot_model import MoonshotModel
+from camel.models.nebius_model import NebiusModel
 from camel.models.netmind_model import NetmindModel
 from camel.models.novita_model import NovitaModel
 from camel.models.nvidia_model import NvidiaModel
@@ -39,6 +45,7 @@ from camel.models.openai_compatible_model import OpenAICompatibleModel
 from camel.models.openai_model import OpenAIModel
 from camel.models.openrouter_model import OpenRouterModel
 from camel.models.ppio_model import PPIOModel
+from camel.models.qianfan_model import QianfanModel
 from camel.models.qwen_model import QwenModel
 from camel.models.reka_model import RekaModel
 from camel.models.samba_model import SambaModel
@@ -52,7 +59,7 @@ from camel.models.watsonx_model import WatsonXModel
 from camel.models.yi_model import YiModel
 from camel.models.zhipuai_model import ZhipuAIModel
 from camel.types import ModelPlatformType, ModelType, UnifiedModelType
-from camel.utils import BaseTokenCounter
+from camel.utils import BaseTokenCounter, configure_langfuse
 
 
 class ModelFactory:
@@ -75,6 +82,7 @@ class ModelFactory:
         ModelPlatformType.AWS_BEDROCK: AWSBedrockModel,
         ModelPlatformType.NVIDIA: NvidiaModel,
         ModelPlatformType.SILICONFLOW: SiliconFlowModel,
+        ModelPlatformType.AMD: AMDModel,
         ModelPlatformType.AIML: AIMLModel,
         ModelPlatformType.VOLCANO: VolcanoModel,
         ModelPlatformType.NETMIND: NetmindModel,
@@ -82,7 +90,11 @@ class ModelFactory:
         ModelPlatformType.AZURE: AzureOpenAIModel,
         ModelPlatformType.ANTHROPIC: AnthropicModel,
         ModelPlatformType.GROQ: GroqModel,
+        ModelPlatformType.CEREBRAS: CerebrasModel,
+        ModelPlatformType.COMETAPI: CometAPIModel,
+        ModelPlatformType.NEBIUS: NebiusModel,
         ModelPlatformType.LMSTUDIO: LMStudioModel,
+        ModelPlatformType.MINIMAX: MinimaxModel,
         ModelPlatformType.OPENROUTER: OpenRouterModel,
         ModelPlatformType.ZHIPU: ZhipuAIModel,
         ModelPlatformType.GEMINI: GeminiModel,
@@ -98,6 +110,9 @@ class ModelFactory:
         ModelPlatformType.MODELSCOPE: ModelScopeModel,
         ModelPlatformType.NOVITA: NovitaModel,
         ModelPlatformType.WATSONX: WatsonXModel,
+        ModelPlatformType.QIANFAN: QianfanModel,
+        ModelPlatformType.CRYNUX: CrynuxModel,
+        ModelPlatformType.AIHUBMIX: AihubMixModel,
     }
 
     @staticmethod
@@ -109,6 +124,9 @@ class ModelFactory:
         api_key: Optional[str] = None,
         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.
@@ -133,6 +151,16 @@ class ModelFactory:
                 (default: :obj:`None`)
             timeout (Optional[float], optional): The timeout value in seconds
                 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`,
@@ -144,6 +172,12 @@ class ModelFactory:
         Raises:
             ValueError: If there is no backend for the model.
         """
+
+        # Auto-configure Langfuse only if explicitly enabled
+        env_enabled_str = os.environ.get("LANGFUSE_ENABLED")
+        if env_enabled_str and env_enabled_str.lower() == "true":
+            configure_langfuse()
+
         # Convert string to ModelPlatformType enum if needed
         if isinstance(model_platform, str):
             try:
@@ -172,6 +206,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,
@@ -179,6 +219,7 @@ class ModelFactory:
             url=url,
             token_counter=token_counter,
             timeout=timeout,
+            max_retries=max_retries,
             **kwargs,
         )
 
@@ -221,6 +262,8 @@ class ModelFactory:
 
     @classmethod
     def __load_yaml(cls, filepath: str) -> Dict:
+        import yaml
+
         r"""Loads and parses a YAML file into a dictionary.
 
         Args:

camel/models/model_manager.py

@@ -1,4 +1,4 @@
-# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# ========= Copyright 2023-2025 @ 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
@@ -10,8 +10,9 @@
 # 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. =========
+# ========= Copyright 2023-2025 @ CAMEL-AI.org. All Rights Reserved. =========
 
+import asyncio
 import logging
 from itertools import cycle
 from random import choice
@@ -26,6 +27,10 @@ from typing import (
 )
 
 from openai import AsyncStream, Stream
+from openai.lib.streaming.chat import (
+    AsyncChatCompletionStreamManager,
+    ChatCompletionStreamManager,
+)
 from pydantic import BaseModel
 
 from camel.messages import OpenAIMessage
@@ -69,6 +74,7 @@ class ModelManager:
             self.models = [models]
         self.models_cycle = cycle(self.models)
         self.current_model = self.models[0]
+        self.lock = asyncio.Lock()
 
         # Set the scheduling strategy; default is round-robin
         try:
@@ -194,7 +200,11 @@ class ModelManager:
         messages: List[OpenAIMessage],
         response_format: Optional[Type[BaseModel]] = None,
         tools: Optional[List[Dict[str, Any]]] = None,
-    ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+    ) -> Union[
+        ChatCompletion,
+        Stream[ChatCompletionChunk],
+        ChatCompletionStreamManager[BaseModel],
+    ]:
         r"""Process a list of messages by selecting a model based on
             the scheduling strategy.
             Sends the entire list of messages to the selected model,
@@ -205,9 +215,12 @@ class ModelManager:
                 history in OpenAI API format.
 
         Returns:
-            Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+            Union[ChatCompletion, Stream[ChatCompletionChunk],
+                  ChatCompletionStreamManager[BaseModel]]:
                 `ChatCompletion` in the non-stream mode, or
-                `Stream[ChatCompletionChunk]` in the stream mode.
+                `Stream[ChatCompletionChunk]` in the stream mode, or
+                `ChatCompletionStreamManager[BaseModel]` for
+                structured-output stream.
         """
         self.current_model = self.scheduling_strategy()
 
@@ -231,7 +244,11 @@ class ModelManager:
         messages: List[OpenAIMessage],
         response_format: Optional[Type[BaseModel]] = None,
         tools: Optional[List[Dict[str, Any]]] = None,
-    ) -> Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+    ) -> Union[
+        ChatCompletion,
+        AsyncStream[ChatCompletionChunk],
+        AsyncChatCompletionStreamManager[BaseModel],
+    ]:
         r"""Process a list of messages by selecting a model based on
             the scheduling strategy.
             Sends the entire list of messages to the selected model,
@@ -242,11 +259,15 @@ class ModelManager:
                 history in OpenAI API format.
 
         Returns:
-            Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+            Union[ChatCompletion, AsyncStream[ChatCompletionChunk],
+                  AsyncChatCompletionStreamManager[BaseModel]]:
                 `ChatCompletion` in the non-stream mode, or
-                `AsyncStream[ChatCompletionChunk]` in the stream mode.
+                `AsyncStream[ChatCompletionChunk]` in the stream mode, or
+                `AsyncChatCompletionStreamManager[BaseModel]` for
+                structured-output stream.
         """
-        self.current_model = self.scheduling_strategy()
+        async with self.lock:
+            self.current_model = self.scheduling_strategy()
 
         # Pass all messages to the selected model and get the response
         try:
@@ -260,7 +281,8 @@ class ModelManager:
                 logger.warning(
                     "The scheduling strategy has been changed to 'round_robin'"
                 )
-                # Skip already used one
-                self.current_model = self.scheduling_strategy()
+                async with self.lock:
+                    # Skip already used one
+                    self.current_model = self.scheduling_strategy()
             raise exc
         return response

camel/models/modelscope_model.py

@@ -1,4 +1,4 @@
-# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# ========= Copyright 2023-2025 @ 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
@@ -10,22 +10,14 @@
 # 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. =========
+# ========= Copyright 2023-2025 @ CAMEL-AI.org. All Rights Reserved. =========
 
 import os
-import time
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, Optional, Union
 
-from openai import AsyncStream, Stream
-
-from camel.configs import MODELSCOPE_API_PARAMS, ModelScopeConfig
-from camel.messages import OpenAIMessage
+from camel.configs import ModelScopeConfig
 from camel.models.openai_compatible_model import OpenAICompatibleModel
-from camel.types import (
-    ChatCompletion,
-    ChatCompletionChunk,
-    ModelType,
-)
+from camel.types import ModelType
 from camel.utils import (
     BaseTokenCounter,
     api_keys_required,
@@ -56,6 +48,10 @@ class ModelScopeModel(OpenAICompatibleModel):
             API calls. If not provided, will fall back to the MODEL_TIMEOUT
             environment variable or default to 180 seconds.
             (default: :obj:`None`)
+        max_retries (int, optional): Maximum number of retries for API calls.
+            (default: :obj:`3`)
+        **kwargs (Any): Additional arguments to pass to the client
+            initialization.
     """
 
     @api_keys_required(
@@ -71,6 +67,8 @@ class ModelScopeModel(OpenAICompatibleModel):
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
         timeout: Optional[float] = None,
+        max_retries: int = 3,
+        **kwargs: Any,
     ) -> None:
         if model_config_dict is None:
             model_config_dict = ModelScopeConfig().as_dict()
@@ -87,184 +85,6 @@ class ModelScopeModel(OpenAICompatibleModel):
             url=url,
             token_counter=token_counter,
             timeout=timeout,
+            max_retries=max_retries,
+            **kwargs,
         )
-
-    def _post_handle_response(
-        self, response: Union[ChatCompletion, Stream[ChatCompletionChunk]]
-    ) -> ChatCompletion:
-        r"""Handle reasoning content with <think> tags at the beginning."""
-        if not isinstance(response, Stream):
-            # Handle non-streaming response (existing logic)
-            if self.model_config_dict.get("extra_body", {}).get(
-                "enable_thinking", False
-            ):
-                reasoning_content = response.choices[
-                    0
-                ].message.reasoning_content  # type: ignore[attr-defined]
-                combined_content = (
-                    f"<think>\n{reasoning_content}\n</think>\n"
-                    if reasoning_content
-                    else ""
-                )
-                response_content = response.choices[0].message.content or ""
-                combined_content += response_content
-
-                # Construct a new ChatCompletion with combined content
-                return ChatCompletion.construct(
-                    id=response.id,
-                    choices=[
-                        dict(
-                            finish_reason=response.choices[0].finish_reason,
-                            index=response.choices[0].index,
-                            logprobs=response.choices[0].logprobs,
-                            message=dict(
-                                role=response.choices[0].message.role,
-                                content=combined_content,
-                            ),
-                        )
-                    ],
-                    created=response.created,
-                    model=response.model,
-                    object="chat.completion",
-                    system_fingerprint=response.system_fingerprint,
-                    usage=response.usage,
-                )
-            else:
-                return response  # Return original if no thinking enabled
-
-        # Handle streaming response
-        accumulated_reasoning = ""
-        accumulated_content = ""
-        final_chunk = None
-        usage_data = None  # Initialize usage data
-        role = "assistant"  # Default role
-
-        for chunk in response:
-            final_chunk = chunk  # Keep track of the last chunk for metadata
-            if chunk.choices:
-                delta = chunk.choices[0].delta
-                if delta.role:
-                    role = delta.role  # Update role if provided
-                if (
-                    hasattr(delta, 'reasoning_content')
-                    and delta.reasoning_content
-                ):
-                    accumulated_reasoning += delta.reasoning_content
-                if delta.content:
-                    accumulated_content += delta.content
-
-            if hasattr(chunk, 'usage') and chunk.usage:
-                usage_data = chunk.usage
-
-        combined_content = (
-            f"<think>\n{accumulated_reasoning}\n</think>\n"
-            if accumulated_reasoning
-            else ""
-        ) + accumulated_content
-
-        # Construct the final ChatCompletion object from accumulated
-        # stream data
-        if final_chunk:
-            finish_reason = "stop"  # Default finish reason
-            logprobs = None
-            if final_chunk.choices:
-                finish_reason = (
-                    final_chunk.choices[0].finish_reason or finish_reason
-                )
-                if hasattr(final_chunk.choices[0], 'logprobs'):
-                    logprobs = final_chunk.choices[0].logprobs
-
-            return ChatCompletion.construct(
-                # Use data from the final chunk or defaults
-                id=final_chunk.id
-                if hasattr(final_chunk, 'id')
-                else "streamed-completion",
-                choices=[
-                    dict(
-                        finish_reason=finish_reason,
-                        index=0,
-                        logprobs=logprobs,
-                        message=dict(
-                            role=role,
-                            content=combined_content,
-                        ),
-                    )
-                ],
-                created=final_chunk.created
-                if hasattr(final_chunk, 'created')
-                else int(time.time()),
-                model=final_chunk.model
-                if hasattr(final_chunk, 'model')
-                else self.model_type,
-                object="chat.completion",
-                system_fingerprint=final_chunk.system_fingerprint
-                if hasattr(final_chunk, 'system_fingerprint')
-                else None,
-                usage=usage_data,
-            )
-        else:
-            # Handle cases where the stream was empty or invalid
-            return ChatCompletion.construct(
-                id="empty-stream",
-                choices=[
-                    dict(
-                        finish_reason="error",
-                        index=0,
-                        message=dict(role="assistant", content=""),
-                    )
-                ],
-                created=int(time.time()),
-                model=self.model_type,
-                object="chat.completion",
-                usage=usage_data,
-            )
-
-    def _request_chat_completion(
-        self,
-        messages: List[OpenAIMessage],
-        tools: Optional[List[Dict[str, Any]]] = None,
-    ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
-        request_config = self.model_config_dict.copy()
-
-        if tools:
-            request_config["tools"] = tools
-
-        return self._post_handle_response(
-            self._client.chat.completions.create(
-                messages=messages,
-                model=self.model_type,
-                **request_config,
-            )
-        )
-
-    async def _arequest_chat_completion(
-        self,
-        messages: List[OpenAIMessage],
-        tools: Optional[List[Dict[str, Any]]] = None,
-    ) -> Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
-        request_config = self.model_config_dict.copy()
-
-        if tools:
-            request_config["tools"] = tools
-
-        response = await self._async_client.chat.completions.create(
-            messages=messages,
-            model=self.model_type,
-            **request_config,
-        )
-        return self._post_handle_response(response)
-
-    def check_model_config(self):
-        r"""Check whether the model configuration contains any
-        unexpected arguments to ModelScope API.
-
-        Raises:
-            ValueError: If the model configuration dictionary contains any
-                unexpected arguments to ModelScope API.
-        """
-        for param in self.model_config_dict:
-            if param not in MODELSCOPE_API_PARAMS:
-                raise ValueError(
-                    f"Unexpected argument `{param}` is "
-                    "input into ModelScope model backend."
-                )