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

camel/interpreters/e2b_interpreter.py

@@ -63,24 +63,27 @@ class E2BInterpreter(BaseInterpreter):
         This method ensures that the e2b sandbox is killed when the
         interpreter is deleted.
         """
-        if (
-            hasattr(self, '_sandbox')
-            and self._sandbox is not None
-            and self._sandbox.is_running()
-        ):
-            self._sandbox.kill()
+        try:
+            if (
+                hasattr(self, '_sandbox')
+                and self._sandbox is not None
+                and self._sandbox.is_running()
+            ):
+                self._sandbox.kill()
+        except ImportError as e:
+            logger.warning(f"Error during sandbox cleanup: {e}")
 
     def run(
         self,
         code: str,
-        code_type: str,
+        code_type: str = "python",
     ) -> str:
         r"""Executes the given code in the e2b sandbox.
 
         Args:
             code (str): The code string to execute.
             code_type (str): The type of code to execute (e.g., 'python',
-                'bash').
+                'bash'). (default: obj:`python`)
 
         Returns:
             str: The string representation of the output of the executed code.
@@ -138,3 +141,15 @@ class E2BInterpreter(BaseInterpreter):
     def update_action_space(self, action_space: Dict[str, Any]) -> None:
         r"""Updates action space for *python* interpreter"""
         raise RuntimeError("E2B doesn't support " "`action_space`.")
+
+    def execute_command(self, command: str) -> str:
+        r"""Execute a command can be used to resolve the dependency of the
+        code.
+
+        Args:
+            command (str): The command to execute.
+
+        Returns:
+            str: The output of the command.
+        """
+        return self._sandbox.commands.run(command)

camel/interpreters/internal_python_interpreter.py

@@ -14,6 +14,8 @@
 import ast
 import difflib
 import importlib
+import os
+import subprocess
 import typing
 from typing import Any, ClassVar, Dict, List, Optional
 
@@ -89,13 +91,15 @@ class InternalPythonInterpreter(BaseInterpreter):
         raise_error: bool = False,
     ) -> None:
         self.action_space = action_space or dict()
+        # Add print to action space
+        self.action_space['print'] = print
         self.state = self.action_space.copy()
         self.fuzz_state: Dict[str, Any] = dict()
         self.import_white_list = import_white_list or list()
         self.raise_error = raise_error
         self.unsafe_mode = unsafe_mode
 
-    def run(self, code: str, code_type: str) -> str:
+    def run(self, code: str, code_type: str = "python") -> str:
         r"""Executes the given code with specified code type in the
         interpreter.
 
@@ -111,7 +115,7 @@ class InternalPythonInterpreter(BaseInterpreter):
             code (str): The python code to be executed.
             code_type (str): The type of the code, which should be one of the
             supported code types (`python`, `py`, `python3`, `python2`).
-
+                (default: obj:`python`)
 
         Returns:
             str: The string representation of the output of the executed code.
@@ -531,3 +535,27 @@ class InternalPythonInterpreter(BaseInterpreter):
                 return self.fuzz_state[close_matches[0]]
             else:
                 raise InterpreterError(f"The variable `{key}` is not defined.")
+
+    def execute_command(self, command: str) -> tuple[str, str]:
+        r"""Execute a command in the internal python interpreter.
+
+        Args:
+            command (str): The command to execute.
+
+        Returns:
+            tuple: A tuple containing the stdout and stderr of the command.
+        """
+        try:
+            proc = subprocess.Popen(
+                command,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                env=os.environ,
+                shell=True,
+            )
+            stdout, stderr = proc.communicate()
+
+            return stdout, stderr
+        except Exception as e:
+            raise InterpreterError(f"Error executing command: {e}")

camel/interpreters/ipython_interpreter.py

@@ -118,13 +118,13 @@ class JupyterKernelInterpreter(BaseInterpreter):
         exec_result = "\n".join(outputs)
         return self._clean_ipython_output(exec_result)
 
-    def run(self, code: str, code_type: str) -> str:
+    def run(self, code: str, code_type: str = "python") -> str:
         r"""Executes the given code in the Jupyter kernel.
 
         Args:
             code (str): The code string to execute.
             code_type (str): The type of code to execute (e.g., 'python',
-                'bash').
+                'bash'). (default: obj:`python`)
 
         Returns:
             str: A string containing the captured result of the
@@ -144,6 +144,24 @@ class JupyterKernelInterpreter(BaseInterpreter):
 
         return result
 
+    def execute_command(self, command: str) -> str:
+        r"""Executes a shell command in the Jupyter kernel.
+
+        Args:
+            command (str): The shell command to execute.
+
+        Returns:
+            str: A string containing the captured result of the
+                executed command.
+
+        """
+        try:
+            self._initialize_if_needed()
+            system_command = f"!{command}"
+            return self._execute(system_command, TIMEOUT)
+        except Exception as e:
+            raise InterpreterError(f"Error executing command: {e}")
+
     def supported_code_types(self) -> List[str]:
         r"""Provides supported code types by the interpreter.
 
@@ -164,5 +182,5 @@ class JupyterKernelInterpreter(BaseInterpreter):
                 does not support updating the action space.
         """
         raise RuntimeError(
-            "SubprocessInterpreter doesn't support " "`action_space`."
+            "JupyterKernelInterpreter doesn't support " "`action_space`."
         )

camel/interpreters/subprocess_interpreter.py

@@ -87,14 +87,14 @@ class SubprocessInterpreter(BaseInterpreter):
     def run_file(
         self,
         file: Path,
-        code_type: str,
+        code_type: str = "python",
     ) -> str:
         r"""Executes a code file in a subprocess and captures its output.
 
         Args:
             file (Path): The path object of the file to run.
             code_type (str): The type of code to execute (e.g., 'python',
-                'bash').
+                'bash'). (default: obj:`python`)
 
         Returns:
             str: A string containing the captured stdout and stderr of the
@@ -425,3 +425,35 @@ class SubprocessInterpreter(BaseInterpreter):
                 return True
             except subprocess.CalledProcessError:
                 return False
+
+    def execute_command(self, command: str) -> tuple[str, str]:
+        r"""Executes a shell command in a subprocess and captures its output.
+
+        Args:
+            command (str): The shell command to execute.
+
+        Returns:
+            tuple: A tuple containing the captured stdout and stderr of the
+                executed command.
+
+        Raises:
+            InterpreterError: If the command execution fails.
+        """
+        try:
+            # Get current Python executable's environment
+            env = os.environ.copy()
+
+            proc = subprocess.Popen(
+                command,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                env=env,
+                shell=True,  # Use shell=True for command execution
+            )
+            # Add timeout to prevent hanging processes
+            stdout, stderr = proc.communicate(timeout=self.execution_timeout)
+
+            return stdout, stderr
+        except Exception as e:
+            raise InterpreterError(f"Error executing command: {e}")

camel/memories/records.py

@@ -15,8 +15,8 @@
 # Enables postponed evaluation of annotations (for string-based type hints)
 from __future__ import annotations
 
+import time
 from dataclasses import asdict
-from datetime import datetime, timezone
 from typing import Any, ClassVar, Dict
 from uuid import UUID, uuid4
 
@@ -53,7 +53,8 @@ class MemoryRecord(BaseModel):
     uuid: UUID = Field(default_factory=uuid4)
     extra_info: Dict[str, str] = Field(default_factory=dict)
     timestamp: float = Field(
-        default_factory=lambda: datetime.now(timezone.utc).timestamp()
+        default_factory=lambda: time.time_ns()
+        / 1_000_000_000  # Nanosecond precision
     )
     agent_id: str = Field(default="")
 
@@ -109,5 +110,6 @@ class ContextRecord(BaseModel):
     memory_record: MemoryRecord
     score: float
     timestamp: float = Field(
-        default_factory=lambda: datetime.now(timezone.utc).timestamp()
+        default_factory=lambda: time.time_ns()
+        / 1_000_000_000  # Nanosecond precision
     )

camel/models/__init__.py

@@ -18,6 +18,7 @@ from .azure_openai_model import AzureOpenAIModel
 from .base_audio_model import BaseAudioModel
 from .base_model import BaseModelBackend
 from .cohere_model import CohereModel
+from .crynux_model import CrynuxModel
 from .deepseek_model import DeepSeekModel
 from .fish_audio_model import FishAudioModel
 from .gemini_model import GeminiModel
@@ -96,4 +97,5 @@ __all__ = [
     'VolcanoModel',
     'LMStudioModel',
     'WatsonXModel',
+    'CrynuxModel',
 ]

camel/models/azure_openai_model.py

@@ -25,11 +25,26 @@ from camel.types import (
     ChatCompletionChunk,
     ModelType,
 )
-from camel.utils import BaseTokenCounter, OpenAITokenCounter
+from camel.utils import (
+    BaseTokenCounter,
+    OpenAITokenCounter,
+    get_current_agent_session_id,
+    is_langfuse_available,
+    update_langfuse_trace,
+)
 
 AzureADTokenProvider = Callable[[], str]
 
 
+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 AzureOpenAIModel(BaseModelBackend):
     r"""Azure OpenAI API in a unified BaseModelBackend interface.
 
@@ -108,27 +123,52 @@ class AzureOpenAIModel(BaseModelBackend):
                 "or `AZURE_DEPLOYMENT_NAME` environment variable."
             )
 
-        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=3,
-        )
+        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=3,
+            )
+            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=3,
+            )
+        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=3,
+            )
 
-        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=3,
-        )
+            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=3,
+            )
 
     @property
     def token_counter(self) -> BaseTokenCounter:
@@ -142,6 +182,7 @@ class AzureOpenAIModel(BaseModelBackend):
             self._token_counter = OpenAITokenCounter(self.model_type)
         return self._token_counter
 
+    @observe()
     def _run(
         self,
         messages: List[OpenAIMessage],
@@ -163,14 +204,32 @@ class AzureOpenAIModel(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],
@@ -192,13 +251,30 @@ class AzureOpenAIModel(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,

camel/models/cohere_model.py

@@ -32,8 +32,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
+
 try:
     if os.getenv("AGENTOPS_API_KEY") is not None:
         from agentops import LLMEvent, record
@@ -271,6 +282,7 @@ class CohereModel(BaseModelBackend):
 
         return request_config
 
+    @observe(as_type="generation")
     def _run(
         self,
         messages: List[OpenAIMessage],
@@ -285,6 +297,28 @@ class CohereModel(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)],
+            )
+
         from cohere.core.api_error import ApiError
 
         request_config = self._prepare_request(
@@ -309,6 +343,10 @@ class CohereModel(BaseModelBackend):
 
         openai_response = self._to_openai_response(response)
 
+        update_current_observation(
+            usage=openai_response.usage,
+        )
+
         # Add AgentOps LLM Event tracking
         if LLMEvent:
             llm_event = LLMEvent(
@@ -325,6 +363,7 @@ class CohereModel(BaseModelBackend):
 
         return openai_response
 
+    @observe(as_type="generation")
     async def _arun(
         self,
         messages: List[OpenAIMessage],
@@ -339,6 +378,28 @@ class CohereModel(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)],
+            )
+
         from cohere.core.api_error import ApiError
 
         request_config = self._prepare_request(
@@ -363,6 +424,10 @@ class CohereModel(BaseModelBackend):
 
         openai_response = self._to_openai_response(response)
 
+        update_current_observation(
+            usage=openai_response.usage,
+        )
+
         # Add AgentOps LLM Event tracking
         if LLMEvent:
             llm_event = LLMEvent(

camel/models/crynux_model.py

@@ -0,0 +1,94 @@
+# ========= Copyright 2023-2024 @ 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
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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. =========
+
+import os
+from typing import Any, Dict, Optional, Union
+
+from camel.configs import CRYNUX_API_PARAMS, CrynuxConfig
+from camel.models.openai_compatible_model import OpenAICompatibleModel
+from camel.types import ModelType
+from camel.utils import (
+    BaseTokenCounter,
+    api_keys_required,
+)
+
+
+class CrynuxModel(OpenAICompatibleModel):
+    r"""Constructor for Crynux backend with OpenAI compatibility.
+
+    Args:
+        model_type (Union[ModelType, str]): Model for which a backend is
+            created
+        model_config_dict (Optional[Dict[str, Any]], optional): A dictionary
+            that will be fed into:obj:`openai.ChatCompletion.create()`. If
+            :obj:`None`, :obj:`CrynuxConfig().as_dict()` will be used.
+            (default: :obj:`None`)
+        api_key (Optional[str], optional): The API key for authenticating with
+            the Crynux service. (default: :obj:`None`)
+        url (Optional[str], optional): The url to the Crynux service.
+            If not provided, "https://bridge.crynux.ai/v1/llm" will be used.
+            (default: :obj:`None`)
+        token_counter (Optional[BaseTokenCounter], optional): Token counter to
+            use for the model. If not provided, :obj:`OpenAITokenCounter(
+            ModelType.GPT_4O_MINI)` will be used.
+        timeout (Optional[float], optional): The timeout value in seconds for
+            API calls. If not provided, will fall back to the MODEL_TIMEOUT
+            environment variable or default to 180 seconds.
+            (default: :obj:`None`)
+    """
+
+    @api_keys_required(
+        [
+            ("api_key", 'CRYNUX_API_KEY'),
+        ]
+    )
+    def __init__(
+        self,
+        model_type: Union[ModelType, str],
+        model_config_dict: Optional[Dict[str, Any]] = None,
+        api_key: Optional[str] = None,
+        url: Optional[str] = None,
+        token_counter: Optional[BaseTokenCounter] = None,
+        timeout: Optional[float] = None,
+    ) -> None:
+        if model_config_dict is None:
+            model_config_dict = CrynuxConfig().as_dict()
+        api_key = api_key or os.environ.get("CRYNUX_API_KEY")
+        url = url or os.environ.get(
+            "CRYNUX_API_BASE_URL", "https://bridge.crynux.ai/v1/llm"
+        )
+        timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
+        super().__init__(
+            model_type=model_type,
+            model_config_dict=model_config_dict,
+            api_key=api_key,
+            url=url,
+            token_counter=token_counter,
+            timeout=timeout,
+        )
+
+    def check_model_config(self):
+        r"""Check whether the model configuration contains any
+        unexpected arguments to Crynux API.
+
+        Raises:
+            ValueError: If the model configuration dictionary contains any
+                unexpected arguments to Crynux API.
+        """
+        for param in self.model_config_dict:
+            if param not in CRYNUX_API_PARAMS:
+                raise ValueError(
+                    f"Unexpected argument `{param}` is "
+                    "input into Crynux model backend."
+                )