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

camel/models/samba_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,7 +10,7 @@
 # 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
 import os
 import time
@@ -22,8 +22,6 @@ from openai import AsyncOpenAI, AsyncStream, OpenAI, Stream
 from pydantic import BaseModel
 
 from camel.configs import (
-    SAMBA_CLOUD_API_PARAMS,
-    SAMBA_VERSE_API_PARAMS,
     SambaCloudAPIConfig,
 )
 from camel.messages import OpenAIMessage
@@ -38,6 +36,9 @@ from camel.utils import (
     BaseTokenCounter,
     OpenAITokenCounter,
     api_keys_required,
+    get_current_agent_session_id,
+    update_current_observation,
+    update_langfuse_trace,
 )
 
 try:
@@ -48,6 +49,14 @@ try:
 except (ImportError, AttributeError):
     LLMEvent = None
 
+if os.environ.get("LANGFUSE_ENABLED", "False").lower() == "true":
+    try:
+        from langfuse.decorators import observe
+    except ImportError:
+        from camel.utils import observe
+else:
+    from camel.utils import observe
+
 
 class SambaModel(BaseModelBackend):
     r"""SambaNova service interface.
@@ -77,6 +86,18 @@ class SambaModel(BaseModelBackend):
             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`)
+        client (Optional[Any], optional): A custom synchronous
+            OpenAI-compatible client instance. If provided, this client will
+            be used instead of creating a new one. Only applicable when using
+            SambaNova Cloud API. (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. Only applicable when using
+            SambaNova Cloud API. (default: :obj:`None`)
+        **kwargs (Any): Additional arguments to pass to the client
+            initialization. Ignored if custom clients are provided.
     """
 
     @api_keys_required(
@@ -92,6 +113,10 @@ class SambaModel(BaseModelBackend):
         url: Optional[str] = None,
         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:
         if model_config_dict is None:
             model_config_dict = SambaCloudAPIConfig().as_dict()
@@ -102,22 +127,39 @@ class SambaModel(BaseModelBackend):
         )
         timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
         super().__init__(
-            model_type, model_config_dict, api_key, url, token_counter, timeout
+            model_type,
+            model_config_dict,
+            api_key,
+            url,
+            token_counter,
+            timeout,
+            max_retries,
         )
 
+        # Only create clients for Cloud API mode
         if self._url == "https://api.sambanova.ai/v1":
-            self._client = OpenAI(
-                timeout=self._timeout,
-                max_retries=3,
-                base_url=self._url,
-                api_key=self._api_key,
-            )
-            self._async_client = AsyncOpenAI(
-                timeout=self._timeout,
-                max_retries=3,
-                base_url=self._url,
-                api_key=self._api_key,
-            )
+            # Use custom clients if provided, otherwise create new ones
+            if client is not None:
+                self._client = client
+            else:
+                self._client = OpenAI(
+                    timeout=self._timeout,
+                    max_retries=self._max_retries,
+                    base_url=self._url,
+                    api_key=self._api_key,
+                    **kwargs,
+                )
+
+            if async_client is not None:
+                self._async_client = async_client
+            else:
+                self._async_client = AsyncOpenAI(
+                    timeout=self._timeout,
+                    max_retries=self._max_retries,
+                    base_url=self._url,
+                    api_key=self._api_key,
+                    **kwargs,
+                )
 
     @property
     def token_counter(self) -> BaseTokenCounter:
@@ -131,36 +173,7 @@ class SambaModel(BaseModelBackend):
             self._token_counter = OpenAITokenCounter(ModelType.GPT_4O_MINI)
         return self._token_counter
 
-    def check_model_config(self):
-        r"""Check whether the model configuration contains any
-        unexpected arguments to SambaNova API.
-
-        Raises:
-            ValueError: If the model configuration dictionary contains any
-                unexpected arguments to SambaNova API.
-        """
-        if self._url == "https://sambaverse.sambanova.ai/api/predict":
-            for param in self.model_config_dict:
-                if param not in SAMBA_VERSE_API_PARAMS:
-                    raise ValueError(
-                        f"Unexpected argument `{param}` is "
-                        "input into SambaVerse API."
-                    )
-
-        elif self._url == "https://api.sambanova.ai/v1":
-            for param in self.model_config_dict:
-                if param not in SAMBA_CLOUD_API_PARAMS:
-                    raise ValueError(
-                        f"Unexpected argument `{param}` is "
-                        "input into SambaCloud API."
-                    )
-
-        else:
-            raise ValueError(
-                f"{self._url} is not supported, please check the url to the"
-                " SambaNova service"
-            )
-
+    @observe(as_type="generation")
     async def _arun(  # type: ignore[misc]
         self,
         messages: List[OpenAIMessage],
@@ -178,13 +191,42 @@ class SambaModel(BaseModelBackend):
                 `ChatCompletion` in the non-stream mode, or
                 `AsyncStream[ChatCompletionChunk]` in the stream mode.
         """
+
+        update_current_observation(
+            input={
+                "messages": messages,
+                "tools": tools,
+            },
+            model=str(self.model_type),
+            model_parameters=self.model_config_dict,
+        )
+
+        # Update Langfuse trace with current agent session and metadata
+        agent_session_id = get_current_agent_session_id()
+        if agent_session_id:
+            update_langfuse_trace(
+                session_id=agent_session_id,
+                metadata={
+                    "source": "camel",
+                    "agent_id": agent_session_id,
+                    "agent_type": "camel_chat_agent",
+                    "model_type": str(self.model_type),
+                },
+                tags=["CAMEL-AI", str(self.model_type)],
+            )
+
         if "tools" in self.model_config_dict:
             del self.model_config_dict["tools"]
         if self.model_config_dict.get("stream") is True:
             return await self._arun_streaming(messages)
         else:
-            return await self._arun_non_streaming(messages)
+            response = await self._arun_non_streaming(messages)
+            update_current_observation(
+                usage=response.usage,
+            )
+            return response
 
+    @observe(as_type="generation")
     def _run(  # type: ignore[misc]
         self,
         messages: List[OpenAIMessage],
@@ -202,12 +244,38 @@ class SambaModel(BaseModelBackend):
                 `ChatCompletion` in the non-stream mode, or
                 `Stream[ChatCompletionChunk]` in the stream mode.
         """
+        update_current_observation(
+            input={
+                "messages": messages,
+                "tools": tools,
+            },
+            model=str(self.model_type),
+            model_parameters=self.model_config_dict,
+        )
+        # Update Langfuse trace with current agent session and metadata
+        agent_session_id = get_current_agent_session_id()
+        if agent_session_id:
+            update_langfuse_trace(
+                session_id=agent_session_id,
+                metadata={
+                    "source": "camel",
+                    "agent_id": agent_session_id,
+                    "agent_type": "camel_chat_agent",
+                    "model_type": str(self.model_type),
+                },
+                tags=["CAMEL-AI", str(self.model_type)],
+            )
+
         if "tools" in self.model_config_dict:
             del self.model_config_dict["tools"]
         if self.model_config_dict.get("stream") is True:
             return self._run_streaming(messages)
         else:
-            return self._run_non_streaming(messages)
+            response = self._run_non_streaming(messages)
+            update_current_observation(
+                usage=response.usage,
+            )
+            return response
 
     def _run_streaming(
         self, messages: List[OpenAIMessage]

camel/models/sglang_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,7 +10,7 @@
 # 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 logging
 import os
 import subprocess
@@ -21,7 +21,7 @@ from typing import Any, Dict, List, Optional, Type, Union
 from openai import AsyncOpenAI, AsyncStream, OpenAI, Stream
 from pydantic import BaseModel
 
-from camel.configs import SGLANG_API_PARAMS, SGLangConfig
+from camel.configs import SGLangConfig
 from camel.messages import OpenAIMessage
 from camel.models import BaseModelBackend
 from camel.types import (
@@ -29,7 +29,21 @@ from camel.types import (
     ChatCompletionChunk,
     ModelType,
 )
-from camel.utils import BaseTokenCounter, OpenAITokenCounter
+from camel.utils import (
+    BaseTokenCounter,
+    OpenAITokenCounter,
+    get_current_agent_session_id,
+    update_current_observation,
+    update_langfuse_trace,
+)
+
+if os.environ.get("LANGFUSE_ENABLED", "False").lower() == "true":
+    try:
+        from langfuse.decorators import observe
+    except ImportError:
+        from camel.utils import observe
+else:
+    from camel.utils import observe
 
 
 class SGLangModel(BaseModelBackend):
@@ -56,8 +70,21 @@ class SGLangModel(BaseModelBackend):
             API calls. If not provided, will fall back to the MODEL_TIMEOUT
             environment variable or default to 180 seconds.
             (default: :obj:`None`)
-
-    Reference: https://sgl-project.github.io/backend/openai_api_completions.html
+        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. Note: When using custom
+            clients with SGLang, server auto-start features will be disabled.
+            (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. (default: :obj:`None`)
+        **kwargs (Any): Additional arguments to pass to the client
+            initialization. Ignored if custom clients are provided.
+
+    Reference: https://sgl-project.github.io/backend/openai_api_completions.
+    html
     """
 
     def __init__(
@@ -68,6 +95,10 @@ class SGLangModel(BaseModelBackend):
         url: Optional[str] = None,
         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:
         if model_config_dict is None:
             model_config_dict = SGLangConfig().as_dict()
@@ -81,25 +112,42 @@ class SGLangModel(BaseModelBackend):
 
         timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
         super().__init__(
-            model_type, model_config_dict, api_key, url, token_counter, timeout
+            model_type,
+            model_config_dict,
+            api_key,
+            url,
+            token_counter,
+            timeout,
+            max_retries,
         )
 
-        self._client = None
-
-        if self._url:
+        # Use custom clients if provided, otherwise create new ones
+        if client is not None:
+            self._client = client
+        elif self._url:
             # Initialize the client if an existing URL is provided
             self._client = OpenAI(
                 timeout=self._timeout,
-                max_retries=3,
+                max_retries=self._max_retries,
                 api_key="Set-but-ignored",  # required but ignored
                 base_url=self._url,
+                **kwargs,
             )
+        else:
+            self._client = None
+
+        if async_client is not None:
+            self._async_client = async_client
+        elif self._url:
             self._async_client = AsyncOpenAI(
                 timeout=self._timeout,
-                max_retries=3,
+                max_retries=self._max_retries,
                 api_key="Set-but-ignored",  # required but ignored
                 base_url=self._url,
+                **kwargs,
             )
+        else:
+            self._async_client = None
 
     def _start_server(self) -> None:
         try:
@@ -130,13 +178,24 @@ class SGLangModel(BaseModelBackend):
                 )
                 self._inactivity_thread.start()
             self.last_run_time = time.time()
-            # Initialize the client after the server starts
-            self._client = OpenAI(
-                timeout=self._timeout,
-                max_retries=3,
-                api_key="Set-but-ignored",  # required but ignored
-                base_url=self._url,
-            )
+            # Initialize client after server starts if not already set
+            if self._client is None:
+                self._client = OpenAI(
+                    timeout=self._timeout,
+                    max_retries=self._max_retries,
+                    api_key="Set-but-ignored",  # required but ignored
+                    base_url=self._url,
+                )
+            if (
+                not hasattr(self, '_async_client')
+                or self._async_client is None
+            ):
+                self._async_client = AsyncOpenAI(
+                    timeout=self._timeout,
+                    max_retries=self._max_retries,
+                    api_key="Set-but-ignored",  # required but ignored
+                    base_url=self._url,
+                )
         except Exception as e:
             raise RuntimeError(f"Failed to start SGLang server: {e}") from e
 
@@ -180,21 +239,7 @@ class SGLangModel(BaseModelBackend):
             self._token_counter = OpenAITokenCounter(ModelType.GPT_4O_MINI)
         return self._token_counter
 
-    def check_model_config(self):
-        r"""Check whether the model configuration contains any
-        unexpected arguments to SGLang API.
-
-        Raises:
-            ValueError: If the model configuration dictionary contains any
-                unexpected arguments to OpenAI API.
-        """
-        for param in self.model_config_dict:
-            if param not in SGLANG_API_PARAMS:
-                raise ValueError(
-                    f"Unexpected argument `{param}` is "
-                    "input into SGLang model backend."
-                )
-
+    @observe(as_type='generation')
     async def _arun(
         self,
         messages: List[OpenAIMessage],
@@ -213,26 +258,64 @@ class SGLangModel(BaseModelBackend):
                 `AsyncStream[ChatCompletionChunk]` in the stream mode.
         """
 
+        update_current_observation(
+            input={
+                "messages": messages,
+                "tools": tools,
+            },
+            model=str(self.model_type),
+            model_parameters=self.model_config_dict,
+        )
+        # Update Langfuse trace with current agent session and metadata
+        agent_session_id = get_current_agent_session_id()
+        if agent_session_id:
+            update_langfuse_trace(
+                session_id=agent_session_id,
+                metadata={
+                    "source": "camel",
+                    "agent_id": agent_session_id,
+                    "agent_type": "camel_chat_agent",
+                    "model_type": str(self.model_type),
+                },
+                tags=["CAMEL-AI", str(self.model_type)],
+            )
+
         # Ensure server is running
         self._ensure_server_running()
 
         with self._lock:
             # Update last run time
             self.last_run_time = time.time()
+            async_client = self._async_client
 
-        if self._client is None:
+        if async_client is None:
             raise RuntimeError(
                 "Client is not initialized. Ensure the server is running."
             )
 
-        response = await self._async_client.chat.completions.create(
+        # Prepare additional parameters
+        extra_params: Dict[str, Any] = {}
+        if response_format is not None:
+            extra_params["response_format"] = response_format
+        if tools is not None:
+            extra_params["tools"] = tools
+
+        response = await async_client.chat.completions.create(
             messages=messages,
             model=self.model_type,
+            **extra_params,
             **self.model_config_dict,
         )
-
+        update_current_observation(
+            usage_details={
+                "prompt_tokens": response.usage.prompt_tokens,
+                "completion_tokens": response.usage.completion_tokens,
+                "total_tokens": response.usage.total_tokens,
+            },
+        )
         return response
 
+    @observe(as_type='generation')
     def _run(
         self,
         messages: List[OpenAIMessage],
@@ -250,6 +333,27 @@ class SGLangModel(BaseModelBackend):
                 `ChatCompletion` in the non-stream mode, or
                 `Stream[ChatCompletionChunk]` in the stream mode.
         """
+        update_current_observation(
+            input={
+                "messages": messages,
+                "tools": tools,
+            },
+            model=str(self.model_type),
+            model_parameters=self.model_config_dict,
+        )
+        # Update Langfuse trace with current agent session and metadata
+        agent_session_id = get_current_agent_session_id()
+        if agent_session_id:
+            update_langfuse_trace(
+                session_id=agent_session_id,
+                metadata={
+                    "source": "camel",
+                    "agent_id": agent_session_id,
+                    "agent_type": "camel_chat_agent",
+                    "model_type": str(self.model_type),
+                },
+                tags=["CAMEL-AI", str(self.model_type)],
+            )
 
         # Ensure server is running
         self._ensure_server_running()
@@ -257,17 +361,33 @@ class SGLangModel(BaseModelBackend):
         with self._lock:
             # Update last run time
             self.last_run_time = time.time()
+            client = self._client
 
-        if self._client is None:
+        if client is None:
             raise RuntimeError(
                 "Client is not initialized. Ensure the server is running."
             )
 
-        response = self._client.chat.completions.create(
+        # Prepare additional parameters
+        extra_params: Dict[str, Any] = {}
+        if response_format is not None:
+            extra_params["response_format"] = response_format
+        if tools is not None:
+            extra_params["tools"] = tools
+
+        response = client.chat.completions.create(
             messages=messages,
             model=self.model_type,
+            **extra_params,
             **self.model_config_dict,
         )
+        update_current_observation(
+            usage_details={
+                "prompt_tokens": response.usage.prompt_tokens,
+                "completion_tokens": response.usage.completion_tokens,
+                "total_tokens": response.usage.total_tokens,
+            },
+        )
 
         return response
 
@@ -384,10 +504,10 @@ def _wait_for_server(base_url: str, timeout: Optional[float] = 30) -> None:
                 print(
                     """\n
                     NOTE: Typically, the server runs in a separate terminal.
-                    In this notebook, we run the server and notebook code 
+                    In this notebook, we run the server and notebook code
                     together, so their outputs are combined.
-                    To improve clarity, the server logs are displayed in the 
-                    original black color, while the notebook outputs are 
+                    To improve clarity, the server logs are displayed in the
+                    original black color, while the notebook outputs are
                     highlighted in blue.
                     """
                 )

camel/models/siliconflow_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,19 +10,13 @@
 # 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
-from typing import Any, Dict, List, Optional, Type, Union
+from typing import Any, Dict, Optional, Union
 
-from openai import AsyncStream
-from pydantic import BaseModel
-
-from camel.configs import SILICONFLOW_API_PARAMS, SiliconFlowConfig
-from camel.messages import OpenAIMessage
+from camel.configs import SiliconFlowConfig
 from camel.models.openai_compatible_model import OpenAICompatibleModel
 from camel.types import (
-    ChatCompletion,
-    ChatCompletionChunk,
     ModelType,
 )
 from camel.utils import (
@@ -54,6 +48,10 @@ class SiliconFlowModel(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(
@@ -69,6 +67,8 @@ class SiliconFlowModel(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 = SiliconFlowConfig().as_dict()
@@ -85,29 +85,6 @@ class SiliconFlowModel(OpenAICompatibleModel):
             url=url,
             token_counter=token_counter,
             timeout=timeout,
+            max_retries=max_retries,
+            **kwargs,
         )
-
-    async def _arun(
-        self,
-        messages: List[OpenAIMessage],
-        response_format: Optional[Type[BaseModel]] = None,
-        tools: Optional[List[Dict[str, Any]]] = None,
-    ) -> Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
-        raise NotImplementedError(
-            "SiliconFlow does not support async inference."
-        )
-
-    def check_model_config(self):
-        r"""Check whether the model configuration contains any
-        unexpected arguments to SiliconFlow API.
-
-        Raises:
-            ValueError: If the model configuration dictionary contains any
-                unexpected arguments to SiliconFlow API.
-        """
-        for param in self.model_config_dict:
-            if param not in SILICONFLOW_API_PARAMS:
-                raise ValueError(
-                    f"Unexpected argument `{param}` is "
-                    "input into SiliconFlow model backend."
-                )