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

camel/models/deepseek_model.py

@@ -28,7 +28,21 @@ from camel.types import (
     ChatCompletionChunk,
     ModelType,
 )
-from camel.utils import BaseTokenCounter, api_keys_required
+from camel.utils import (
+    BaseTokenCounter,
+    api_keys_required,
+    get_current_agent_session_id,
+    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__)
 
@@ -176,6 +190,7 @@ class DeepSeekModel(OpenAICompatibleModel):
             )
         return response
 
+    @observe()
     def _run(
         self,
         messages: List[OpenAIMessage],
@@ -193,6 +208,19 @@ class DeepSeekModel(OpenAICompatibleModel):
                 `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={
+                    "agent_id": agent_session_id,
+                    "model_type": str(self.model_type),
+                },
+                tags=["CAMEL-AI", str(self.model_type)],
+            )
+
         request_config = self._prepare_request(
             messages, response_format, tools
         )
@@ -205,6 +233,7 @@ class DeepSeekModel(OpenAICompatibleModel):
 
         return self._post_handle_response(response)
 
+    @observe()
     async def _arun(
         self,
         messages: List[OpenAIMessage],
@@ -222,6 +251,19 @@ class DeepSeekModel(OpenAICompatibleModel):
                 `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={
+                    "agent_id": agent_session_id,
+                    "model_type": str(self.model_type),
+                },
+                tags=["CAMEL-AI", str(self.model_type)],
+            )
+
         request_config = self._prepare_request(
             messages, response_format, tools
         )

camel/models/gemini_model.py

@@ -28,8 +28,18 @@ from camel.types import (
 from camel.utils import (
     BaseTokenCounter,
     api_keys_required,
+    get_current_agent_session_id,
+    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 GeminiModel(OpenAICompatibleModel):
     r"""Gemini API in a unified OpenAICompatibleModel interface.
@@ -99,6 +109,7 @@ class GeminiModel(OpenAICompatibleModel):
             processed_messages.append(msg_copy)
         return processed_messages
 
+    @observe()
     def _run(
         self,
         messages: List[OpenAIMessage],
@@ -120,6 +131,19 @@ class GeminiModel(OpenAICompatibleModel):
                 `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={
+                    "agent_id": agent_session_id,
+                    "model_type": str(self.model_type),
+                },
+                tags=["CAMEL-AI", str(self.model_type)],
+            )
+
         response_format = response_format or self.model_config_dict.get(
             "response_format", None
         )
@@ -130,10 +154,15 @@ class GeminiModel(OpenAICompatibleModel):
                     "Gemini does not support function calling with "
                     "response format."
                 )
-            return self._request_parse(messages, response_format)
+            result: Union[ChatCompletion, Stream[ChatCompletionChunk]] = (
+                self._request_parse(messages, response_format)
+            )
         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],
@@ -155,6 +184,19 @@ class GeminiModel(OpenAICompatibleModel):
                 `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={
+                    "agent_id": agent_session_id,
+                    "model_type": str(self.model_type),
+                },
+                tags=["CAMEL-AI", str(self.model_type)],
+            )
+
         response_format = response_format or self.model_config_dict.get(
             "response_format", None
         )
@@ -165,9 +207,13 @@ class GeminiModel(OpenAICompatibleModel):
                     "Gemini does not support function calling with "
                     "response format."
                 )
-            return await self._arequest_parse(messages, response_format)
+            result: Union[
+                ChatCompletion, AsyncStream[ChatCompletionChunk]
+            ] = await self._arequest_parse(messages, response_format)
         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/litellm_model.py

@@ -24,8 +24,19 @@ from camel.utils import (
     BaseTokenCounter,
     LiteLLMTokenCounter,
     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
+
 
 class LiteLLMModel(BaseModelBackend):
     r"""Constructor for LiteLLM backend with OpenAI compatibility.
@@ -117,6 +128,7 @@ class LiteLLMModel(BaseModelBackend):
     async def _arun(self) -> None:  # type: ignore[override]
         raise NotImplementedError
 
+    @observe(as_type='generation')
     def _run(
         self,
         messages: List[OpenAIMessage],
@@ -132,6 +144,28 @@ class LiteLLMModel(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)],
+            )
+
         response = self.client(
             timeout=self._timeout,
             api_key=self._api_key,
@@ -141,6 +175,10 @@ class LiteLLMModel(BaseModelBackend):
             **self.model_config_dict,
         )
         response = self._convert_response_from_litellm_to_openai(response)
+
+        update_current_observation(
+            usage=response.usage,
+        )
         return response
 
     def check_model_config(self):

camel/models/mistral_model.py

@@ -35,6 +35,9 @@ from camel.utils import (
     OpenAITokenCounter,
     api_keys_required,
     dependencies_required,
+    get_current_agent_session_id,
+    update_current_observation,
+    update_langfuse_trace,
 )
 
 logger = get_logger(__name__)
@@ -47,6 +50,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 MistralModel(BaseModelBackend):
     r"""Mistral API in a unified BaseModelBackend interface.
@@ -232,6 +243,7 @@ class MistralModel(BaseModelBackend):
             )
         return self._token_counter
 
+    @observe(as_type="generation")
     async def _arun(
         self,
         messages: List[OpenAIMessage],
@@ -242,6 +254,29 @@ class MistralModel(BaseModelBackend):
             "Mistral does not support async inference, using sync "
             "inference instead."
         )
+        update_current_observation(
+            input={
+                "messages": messages,
+                "response_format": response_format,
+                "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)],
+            )
+
         request_config = self._prepare_request(
             messages, response_format, tools
         )
@@ -255,6 +290,10 @@ class MistralModel(BaseModelBackend):
 
         openai_response = self._to_openai_response(response)  # type: ignore[arg-type]
 
+        update_current_observation(
+            usage=openai_response.usage,
+        )
+
         # Add AgentOps LLM Event tracking
         if LLMEvent:
             llm_event = LLMEvent(
@@ -271,6 +310,7 @@ class MistralModel(BaseModelBackend):
 
         return openai_response
 
+    @observe(as_type="generation")
     def _run(
         self,
         messages: List[OpenAIMessage],
@@ -290,6 +330,28 @@ class MistralModel(BaseModelBackend):
         Returns:
             ChatCompletion: The response from the model.
         """
+        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)],
+            )
+
         request_config = self._prepare_request(
             messages, response_format, tools
         )
@@ -303,6 +365,10 @@ class MistralModel(BaseModelBackend):
 
         openai_response = self._to_openai_response(response)  # type: ignore[arg-type]
 
+        update_current_observation(
+            usage=openai_response.usage,
+        )
+
         # Add AgentOps LLM Event tracking
         if LLMEvent:
             llm_event = LLMEvent(

camel/models/model_factory.py

@@ -12,6 +12,7 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 import json
+import os
 from typing import ClassVar, Dict, Optional, Type, Union
 
 from camel.models.aiml_model import AIMLModel
@@ -20,6 +21,7 @@ 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.cohere_model import CohereModel
+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
@@ -50,7 +52,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:
@@ -96,6 +98,7 @@ class ModelFactory:
         ModelPlatformType.MODELSCOPE: ModelScopeModel,
         ModelPlatformType.NOVITA: NovitaModel,
         ModelPlatformType.WATSONX: WatsonXModel,
+        ModelPlatformType.CRYNUX: CrynuxModel,
     }
 
     @staticmethod
@@ -142,6 +145,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:

camel/models/openai_compatible_model.py

@@ -31,8 +31,20 @@ from camel.types import (
 from camel.utils import (
     BaseTokenCounter,
     OpenAITokenCounter,
+    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
+
+
 logger = get_logger(__name__)
 
 
@@ -72,20 +84,37 @@ class OpenAICompatibleModel(BaseModelBackend):
         super().__init__(
             model_type, model_config_dict, api_key, url, token_counter, timeout
         )
-        self._client = OpenAI(
-            timeout=self._timeout,
-            max_retries=3,
-            api_key=self._api_key,
-            base_url=self._url,
-        )
-
-        self._async_client = AsyncOpenAI(
-            timeout=self._timeout,
-            max_retries=3,
-            api_key=self._api_key,
-            base_url=self._url,
-        )
+        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,
+            )
 
+    @observe()
     def _run(
         self,
         messages: List[OpenAIMessage],
@@ -107,14 +136,32 @@ class OpenAICompatibleModel(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={
+                    "agent_id": agent_session_id,
+                    "model_type": str(self.model_type),
+                },
+                tags=["CAMEL-AI", str(self.model_type)],
+            )
+
         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],
@@ -136,13 +183,30 @@ class OpenAICompatibleModel(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={
+                    "agent_id": agent_session_id,
+                    "model_type": str(self.model_type),
+                },
+                tags=["CAMEL-AI", str(self.model_type)],
+            )
+
         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,