camel-ai 0.2.62__py3-none-any.whl → 0.2.65__py3-none-any.whl

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/societies/workforce/role_playing_worker.py

@@ -25,7 +25,7 @@ from camel.societies.workforce.prompts import (
     ROLEPLAY_PROCESS_TASK_PROMPT,
     ROLEPLAY_SUMMARIZE_PROMPT,
 )
-from camel.societies.workforce.utils import TaskResult
+from camel.societies.workforce.utils import TaskResult, validate_task_content
 from camel.societies.workforce.worker import Worker
 from camel.tasks.task import Task, TaskState
 from camel.utils import print_text_animated
@@ -48,7 +48,7 @@ class RolePlayingWorker(Worker):
             initialize the summarize agent, like the model name, etc.
             (default: :obj:`None`)
         chat_turn_limit (int): The maximum number of chat turns in the role
-            playing. (default: :obj:`3`)
+            playing. (default: :obj:`20`)
     """
 
     def __init__(
@@ -59,7 +59,7 @@ class RolePlayingWorker(Worker):
         assistant_agent_kwargs: Optional[Dict] = None,
         user_agent_kwargs: Optional[Dict] = None,
         summarize_agent_kwargs: Optional[Dict] = None,
-        chat_turn_limit: int = 3,
+        chat_turn_limit: int = 20,
     ) -> None:
         super().__init__(description)
         self.summarize_agent_kwargs = summarize_agent_kwargs
@@ -182,6 +182,14 @@ class RolePlayingWorker(Worker):
         )
         result_dict = json.loads(response.msg.content)
         task_result = TaskResult(**result_dict)
+
+        if not validate_task_content(task_result.content, task.id):
+            print(
+                f"{Fore.RED}Task {task.id}: Content validation failed - "
+                f"task marked as failed{Fore.RESET}"
+            )
+            return TaskState.FAILED
+
         task.result = task_result.content
 
         print(f"Task result: {task.result}\n")

camel/societies/workforce/single_agent_worker.py

@@ -13,6 +13,7 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 from __future__ import annotations
 
+import datetime
 import json
 from typing import Any, List
 
@@ -20,7 +21,7 @@ from colorama import Fore
 
 from camel.agents import ChatAgent
 from camel.societies.workforce.prompts import PROCESS_TASK_PROMPT
-from camel.societies.workforce.utils import TaskResult
+from camel.societies.workforce.utils import TaskResult, validate_task_content
 from camel.societies.workforce.worker import Worker
 from camel.tasks.task import Task, TaskState
 from camel.utils import print_text_animated
@@ -83,6 +84,28 @@ class SingleAgentWorker(Worker):
             )
             return TaskState.FAILED
 
+        # Populate additional_info with worker attempt details
+        if task.additional_info is None:
+            task.additional_info = {}
+
+        # Create worker attempt details with descriptive keys
+        worker_attempt_details = {
+            "agent_id": getattr(
+                self.worker, "agent_id", self.worker.role_name
+            ),
+            "timestamp": str(datetime.datetime.now()),
+            "description": f"Attempt by "
+            f"{getattr(self.worker, 'agent_id', self.worker.role_name)} "
+            f"to process task {task.content}",
+            "response_content": response.msg.content,
+            "tool_calls": response.info["tool_calls"],
+        }
+
+        # Store the worker attempt in additional_info
+        if "worker_attempts" not in task.additional_info:
+            task.additional_info["worker_attempts"] = []
+        task.additional_info["worker_attempts"].append(worker_attempt_details)
+
         print(f"======\n{Fore.GREEN}Reply from {self}:{Fore.RESET}")
 
         result_dict = json.loads(response.msg.content)
@@ -97,5 +120,12 @@ class SingleAgentWorker(Worker):
         if task_result.failed:
             return TaskState.FAILED
 
+        if not validate_task_content(task_result.content, task.id):
+            print(
+                f"{Fore.RED}Task {task.id}: Content validation failed - "
+                f"task marked as failed{Fore.RESET}"
+            )
+            return TaskState.FAILED
+
         task.result = task_result.content
         return TaskState.DONE

camel/societies/workforce/utils.py

@@ -16,6 +16,10 @@ from typing import Callable
 
 from pydantic import BaseModel, Field
 
+from camel.logger import get_logger
+
+logger = get_logger(__name__)
+
 
 class WorkerConf(BaseModel):
     r"""The configuration of a worker."""
@@ -71,3 +75,50 @@ def check_if_running(running: bool) -> Callable:
         return wrapper
 
     return decorator
+
+
+def validate_task_content(
+    content: str, task_id: str = "unknown", min_length: int = 10
+) -> bool:
+    r"""Validates task result content to avoid silent failures.
+    It performs basic checks to ensure the content meets minimum
+    quality standards.
+
+    Args:
+        content (str): The task result content to validate.
+        task_id (str): Task ID for logging purposes.
+            (default: :obj:`"unknown"`)
+        min_length (int): Minimum content length after stripping whitespace.
+            (default: :obj:`10`)
+
+    Returns:
+        bool: True if content passes validation, False otherwise.
+    """
+    # 1: Content must not be None
+    if content is None:
+        logger.warning(f"Task {task_id}: None content rejected")
+        return False
+
+    # 2: Content must not be empty after stripping whitespace
+    stripped_content = content.strip()
+    if not stripped_content:
+        logger.warning(
+            f"Task {task_id}: Empty or whitespace-only content rejected."
+        )
+        return False
+
+    # 3: Content must meet minimum meaningful length
+    if len(stripped_content) < min_length:
+        logger.warning(
+            f"Task {task_id}: Content too short ({len(stripped_content)} "
+            f"chars < {min_length} minimum). Content preview: "
+            f"'{stripped_content[:50]}...'"
+        )
+        return False
+
+    # All validation checks passed
+    logger.debug(
+        f"Task {task_id}: Content validation passed "
+        f"({len(stripped_content)} chars)"
+    )
+    return True