camel-ai 0.2.61__py3-none-any.whl → 0.2.64__py3-none-any.whl

camel/models/openai_model.py

@@ -30,8 +30,20 @@ from camel.utils import (
     BaseTokenCounter,
     OpenAITokenCounter,
     api_keys_required,
+    get_current_agent_session_id,
+    is_langfuse_available,
+    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
+
+
 UNSUPPORTED_PARAMS = {
     "temperature",
     "top_p",
@@ -90,18 +102,35 @@ class OpenAIModel(BaseModelBackend):
             model_type, model_config_dict, api_key, url, token_counter, timeout
         )
 
-        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,
-        )
+        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=3,
+                base_url=self._url,
+                api_key=self._api_key,
+            )
+            self._async_client = LangfuseAsyncOpenAI(
+                timeout=self._timeout,
+                max_retries=3,
+                base_url=self._url,
+                api_key=self._api_key,
+            )
+        else:
+            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,
+            )
 
     def _sanitize_config(self, config_dict: Dict[str, Any]) -> Dict[str, Any]:
         r"""Sanitize the model configuration for O1 models."""
@@ -185,6 +214,7 @@ class OpenAIModel(BaseModelBackend):
             self._token_counter = OpenAITokenCounter(self.model_type)
         return self._token_counter
 
+    @observe()
     def _run(
         self,
         messages: List[OpenAIMessage],
@@ -206,15 +236,35 @@ class OpenAIModel(BaseModelBackend):
                 `ChatCompletion` in the non-stream mode, or
                 `Stream[ChatCompletionChunk]` in the stream mode.
         """
+
+        # 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)],
+            )
+
         messages = self._adapt_messages_for_o1_models(messages)
         response_format = response_format or self.model_config_dict.get(
             "response_format", None
         )
         if response_format:
-            return self._request_parse(messages, response_format, tools)
+            result: Union[ChatCompletion, Stream[ChatCompletionChunk]] = (
+                self._request_parse(messages, response_format, tools)
+            )
         else:
-            return self._request_chat_completion(messages, tools)
+            result = self._request_chat_completion(messages, tools)
+
+        return result
 
+    @observe()
     async def _arun(
         self,
         messages: List[OpenAIMessage],
@@ -236,13 +286,33 @@ class OpenAIModel(BaseModelBackend):
                 `ChatCompletion` in the non-stream mode, or
                 `AsyncStream[ChatCompletionChunk]` in the stream mode.
         """
+
+        # 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)],
+            )
+
+        messages = self._adapt_messages_for_o1_models(messages)
         response_format = response_format or self.model_config_dict.get(
             "response_format", None
         )
         if response_format:
-            return await self._arequest_parse(messages, response_format, tools)
+            result: Union[
+                ChatCompletion, AsyncStream[ChatCompletionChunk]
+            ] = await self._arequest_parse(messages, response_format, tools)
         else:
-            return await self._arequest_chat_completion(messages, tools)
+            result = await self._arequest_chat_completion(messages, tools)
+
+        return result
 
     def _request_chat_completion(
         self,

camel/models/reka_model.py

@@ -11,6 +11,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+import os
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Type, Union
 
 from pydantic import BaseModel
@@ -24,8 +25,19 @@ from camel.utils import (
     OpenAITokenCounter,
     api_keys_required,
     dependencies_required,
+    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
+
 if TYPE_CHECKING:
     from reka.types import ChatMessage, ChatResponse
 
@@ -188,6 +200,7 @@ class RekaModel(BaseModelBackend):
             )
         return self._token_counter
 
+    @observe(as_type="generation")
     async def _arun(
         self,
         messages: List[OpenAIMessage],
@@ -203,6 +216,29 @@ class RekaModel(BaseModelBackend):
         Returns:
             ChatCompletion.
         """
+
+        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)],
+            )
+
         reka_messages = self._convert_openai_to_reka_messages(messages)
 
         response = await self._async_client.chat.create(
@@ -213,6 +249,10 @@ class RekaModel(BaseModelBackend):
 
         openai_response = self._convert_reka_to_openai_response(response)
 
+        update_current_observation(
+            usage=openai_response.usage,
+        )
+
         # Add AgentOps LLM Event tracking
         if LLMEvent:
             llm_event = LLMEvent(
@@ -229,6 +269,7 @@ class RekaModel(BaseModelBackend):
 
         return openai_response
 
+    @observe(as_type="generation")
     def _run(
         self,
         messages: List[OpenAIMessage],
@@ -244,6 +285,30 @@ class RekaModel(BaseModelBackend):
         Returns:
             ChatCompletion.
         """
+
+        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)],
+            )
+
         reka_messages = self._convert_openai_to_reka_messages(messages)
 
         response = self._client.chat.create(
@@ -254,6 +319,10 @@ class RekaModel(BaseModelBackend):
 
         openai_response = self._convert_reka_to_openai_response(response)
 
+        update_current_observation(
+            usage=openai_response.usage,
+        )
+
         # Add AgentOps LLM Event tracking
         if LLMEvent:
             llm_event = LLMEvent(

camel/models/samba_model.py

@@ -38,6 +38,9 @@ from camel.utils import (
     BaseTokenCounter,
     OpenAITokenCounter,
     api_keys_required,
+    get_current_agent_session_id,
+    update_current_observation,
+    update_langfuse_trace,
 )
 
 try:
@@ -48,6 +51,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.
@@ -161,6 +172,7 @@ class SambaModel(BaseModelBackend):
                 " SambaNova service"
             )
 
+    @observe(as_type="generation")
     async def _arun(  # type: ignore[misc]
         self,
         messages: List[OpenAIMessage],
@@ -178,13 +190,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 +243,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

@@ -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):
@@ -195,6 +209,7 @@ class SGLangModel(BaseModelBackend):
                     "input into SGLang model backend."
                 )
 
+    @observe(as_type='generation')
     async def _arun(
         self,
         messages: List[OpenAIMessage],
@@ -213,6 +228,28 @@ 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()
 
@@ -230,9 +267,16 @@ class SGLangModel(BaseModelBackend):
             model=self.model_type,
             **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 +294,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()
@@ -268,6 +333,13 @@ class SGLangModel(BaseModelBackend):
             model=self.model_type,
             **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
 

camel/models/watsonx_model.py

@@ -26,8 +26,19 @@ from camel.utils import (
     BaseTokenCounter,
     OpenAITokenCounter,
     api_keys_required,
+    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
+
 logger = get_logger(__name__)
 
 
@@ -151,6 +162,7 @@ class WatsonXModel(BaseModelBackend):
 
         return request_config
 
+    @observe(as_type='generation')
     def _run(
         self,
         messages: List[OpenAIMessage],
@@ -170,6 +182,27 @@ class WatsonXModel(BaseModelBackend):
         Returns:
             ChatCompletion.
         """
+        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)],
+            )
         try:
             request_config = self._prepare_request(
                 messages, response_format, tools
@@ -183,12 +216,16 @@ class WatsonXModel(BaseModelBackend):
             )
 
             openai_response = self._to_openai_response(response)
+            update_current_observation(
+                usage=openai_response.usage,
+            )
             return openai_response
 
         except Exception as e:
             logger.error(f"Unexpected error when calling WatsonX API: {e!s}")
             raise
 
+    @observe(as_type='generation')
     async def _arun(
         self,
         messages: List[OpenAIMessage],
@@ -208,6 +245,28 @@ class WatsonXModel(BaseModelBackend):
         Returns:
             ChatCompletion.
         """
+        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)],
+            )
+
         try:
             request_config = self._prepare_request(
                 messages, response_format, tools
@@ -221,6 +280,9 @@ class WatsonXModel(BaseModelBackend):
             )
 
             openai_response = self._to_openai_response(response)
+            update_current_observation(
+                usage=openai_response.usage,
+            )
             return openai_response
 
         except Exception as e:

camel/retrievers/auto_retriever.py

@@ -128,12 +128,31 @@ class AutoRetriever:
         Returns:
             str: A sanitized, valid collection name suitable for use.
         """
+        import hashlib
+        import os
+
         from unstructured.documents.elements import Element
 
         if isinstance(content, Element):
             content = content.metadata.file_directory or str(uuid.uuid4())
 
-        collection_name = re.sub(r'[^a-zA-Z0-9]', '', content)[:20]
+        # For file paths, use a combination of directory hash and filename
+        if os.path.isfile(content):
+            # Get directory and filename
+            directory = os.path.dirname(content)
+            filename = os.path.basename(content)
+            # Create a short hash of the directory path
+            dir_hash = hashlib.md5(directory.encode()).hexdigest()[:6]
+            # Get filename without extension and remove special chars
+            base_name = os.path.splitext(filename)[0]
+            clean_name = re.sub(r'[^a-zA-Z0-9]', '', base_name)[:10]
+            # Combine for a unique name
+            collection_name = f"{clean_name}_{dir_hash}"
+        else:
+            # For URL content
+            content_hash = hashlib.md5(content.encode()).hexdigest()[:6]
+            clean_content = re.sub(r'[^a-zA-Z0-9]', '', content)[-10:]
+            collection_name = f"{clean_content}_{content_hash}"
 
         # Ensure the first character is either an underscore or a letter for
         # Milvus

camel/{runtime → runtimes}/daytona_runtime.py

@@ -21,7 +21,7 @@ from typing import Any, Dict, List, Optional, Union
 from pydantic import BaseModel
 
 from camel.logger import get_logger
-from camel.runtime import BaseRuntime
+from camel.runtimes import BaseRuntime
 from camel.toolkits.function_tool import FunctionTool
 
 logger = get_logger(__name__)

camel/{runtime → runtimes}/docker_runtime.py

@@ -26,7 +26,7 @@ import requests
 from pydantic import BaseModel
 from tqdm import tqdm
 
-from camel.runtime import BaseRuntime, TaskConfig
+from camel.runtimes import BaseRuntime, TaskConfig
 from camel.toolkits import FunctionTool
 
 if TYPE_CHECKING:

camel/{runtime → runtimes}/llm_guard_runtime.py

@@ -19,8 +19,8 @@ from typing import List, Optional, Union
 from camel.agents import ChatAgent
 from camel.configs import ChatGPTConfig
 from camel.models import BaseModelBackend, ModelFactory
-from camel.runtime import BaseRuntime
-from camel.runtime.utils import FunctionRiskToolkit, IgnoreRiskToolkit
+from camel.runtimes import BaseRuntime
+from camel.runtimes.utils import FunctionRiskToolkit, IgnoreRiskToolkit
 from camel.toolkits import FunctionTool
 from camel.types import ModelPlatformType, ModelType
 

camel/{runtime → runtimes}/remote_http_runtime.py

@@ -24,7 +24,7 @@ from typing import Any, Dict, List, Optional, Union
 import requests
 from pydantic import BaseModel
 
-from camel.runtime import BaseRuntime
+from camel.runtimes import BaseRuntime
 from camel.toolkits.function_tool import FunctionTool
 
 logger = logging.getLogger(__name__)