camel-ai 0.2.78__py3-none-any.whl → 0.2.79a1__py3-none-any.whl

camel/models/openai_model.py

@@ -90,9 +90,21 @@ class OpenAIModel(BaseModelBackend):
             (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 client
+            instance. If provided, this client will be used instead of
+            creating a new one. Useful for RL frameworks like AReaL or rLLM
+            that provide OpenAI-compatible clients. The client should
+            implement the OpenAI client interface with
+            `.chat.completions.create()` and `.beta.chat.completions.parse()`
+            methods. (default: :obj:`None`)
+        async_client (Optional[Any], optional): A custom asynchronous OpenAI
+            client instance. If provided, this client will be used instead of
+            creating a new one. The client should implement the AsyncOpenAI
+            client interface. (default: :obj:`None`)
         **kwargs (Any): Additional arguments to pass to the
             OpenAI client initialization. These can include parameters like
             'organization', 'default_headers', 'http_client', etc.
+            Ignored if custom clients are provided.
     """
 
     @api_keys_required(
@@ -109,6 +121,8 @@ class OpenAIModel(BaseModelBackend):
         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:
@@ -124,42 +138,54 @@ class OpenAIModel(BaseModelBackend):
             model_type, model_config_dict, api_key, url, token_counter, timeout
         )
 
-        if is_langfuse_available():
-            from langfuse.openai import AsyncOpenAI as LangfuseAsyncOpenAI
-            from langfuse.openai import OpenAI as LangfuseOpenAI
-
-            # Create Langfuse client with base parameters and additional
-            # arguments
-            self._client = LangfuseOpenAI(
-                timeout=self._timeout,
-                max_retries=self._max_retries,
-                base_url=self._url,
-                api_key=self._api_key,
-                **kwargs,
-            )
-            self._async_client = LangfuseAsyncOpenAI(
-                timeout=self._timeout,
-                max_retries=self._max_retries,
-                base_url=self._url,
-                api_key=self._api_key,
-                **kwargs,
-            )
+        # Use custom clients if provided, otherwise create new ones
+        if client is not None:
+            # Use the provided custom sync client
+            self._client = client
         else:
-            # Create client with base parameters and additional arguments
-            self._client = OpenAI(
-                timeout=self._timeout,
-                max_retries=self._max_retries,
-                base_url=self._url,
-                api_key=self._api_key,
-                **kwargs,
-            )
-            self._async_client = AsyncOpenAI(
-                timeout=self._timeout,
-                max_retries=self._max_retries,
-                base_url=self._url,
-                api_key=self._api_key,
-                **kwargs,
-            )
+            # Create default sync client
+            if is_langfuse_available():
+                from langfuse.openai import OpenAI as LangfuseOpenAI
+
+                self._client = LangfuseOpenAI(
+                    timeout=self._timeout,
+                    max_retries=self._max_retries,
+                    base_url=self._url,
+                    api_key=self._api_key,
+                    **kwargs,
+                )
+            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:
+            # Use the provided custom async client
+            self._async_client = async_client
+        else:
+            # Create default async client
+            if is_langfuse_available():
+                from langfuse.openai import AsyncOpenAI as LangfuseAsyncOpenAI
+
+                self._async_client = LangfuseAsyncOpenAI(
+                    timeout=self._timeout,
+                    max_retries=self._max_retries,
+                    base_url=self._url,
+                    api_key=self._api_key,
+                    **kwargs,
+                )
+            else:
+                self._async_client = AsyncOpenAI(
+                    timeout=self._timeout,
+                    max_retries=self._max_retries,
+                    base_url=self._url,
+                    api_key=self._api_key,
+                    **kwargs,
+                )
 
     def _sanitize_config(self, config_dict: Dict[str, Any]) -> Dict[str, Any]:
         r"""Sanitize the model configuration for O1 models."""

camel/models/samba_model.py

@@ -88,8 +88,16 @@ class SambaModel(BaseModelBackend):
             (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.
+            initialization. Ignored if custom clients are provided.
     """
 
     @api_keys_required(
@@ -106,6 +114,8 @@ class SambaModel(BaseModelBackend):
         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:
@@ -126,21 +136,30 @@ class SambaModel(BaseModelBackend):
             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=self._max_retries,
-                base_url=self._url,
-                api_key=self._api_key,
-                **kwargs,
-            )
-            self._async_client = AsyncOpenAI(
-                timeout=self._timeout,
-                max_retries=self._max_retries,
-                base_url=self._url,
-                api_key=self._api_key,
-                **kwargs,
-            )
+            # 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:

camel/models/sglang_model.py

@@ -72,8 +72,16 @@ class SGLangModel(BaseModelBackend):
             (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. 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.
+            initialization. Ignored if custom clients are provided.
 
     Reference: https://sgl-project.github.io/backend/openai_api_completions.
     html
@@ -88,6 +96,8 @@ class SGLangModel(BaseModelBackend):
         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:
@@ -111,9 +121,10 @@ class SGLangModel(BaseModelBackend):
             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,
@@ -122,6 +133,12 @@ class SGLangModel(BaseModelBackend):
                 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=self._max_retries,
@@ -129,6 +146,8 @@ class SGLangModel(BaseModelBackend):
                 base_url=self._url,
                 **kwargs,
             )
+        else:
+            self._async_client = None
 
     def _start_server(self) -> None:
         try:
@@ -159,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=self._max_retries,
-                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
 

camel/societies/workforce/__init__.py

@@ -14,10 +14,12 @@
 
 from .role_playing_worker import RolePlayingWorker
 from .single_agent_worker import SingleAgentWorker
+from .workflow_memory_manager import WorkflowSelectionMethod
 from .workforce import Workforce
 
 __all__ = [
     "Workforce",
     "SingleAgentWorker",
     "RolePlayingWorker",
+    "WorkflowSelectionMethod",
 ]

camel/societies/workforce/events.py

@@ -0,0 +1,122 @@
+# ========= 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. =========
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Literal, Optional, Union
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class WorkforceEventBase(BaseModel):
+    model_config = ConfigDict(frozen=True, extra='forbid')
+    event_type: Literal[
+        "task_decomposed",
+        "task_created",
+        "task_assigned",
+        "task_started",
+        "task_completed",
+        "task_failed",
+        "worker_created",
+        "worker_deleted",
+        "queue_status",
+        "all_tasks_completed",
+    ]
+    metadata: Optional[Dict[str, Any]] = None
+    timestamp: datetime = Field(
+        default_factory=lambda: datetime.now(timezone.utc)
+    )
+
+
+class WorkerCreatedEvent(WorkforceEventBase):
+    event_type: Literal["worker_created"] = "worker_created"
+    worker_id: str
+    worker_type: str
+    role: str
+
+
+class WorkerDeletedEvent(WorkforceEventBase):
+    event_type: Literal["worker_deleted"] = "worker_deleted"
+    worker_id: str
+    reason: Optional[str] = None
+
+
+class TaskDecomposedEvent(WorkforceEventBase):
+    event_type: Literal["task_decomposed"] = "task_decomposed"
+    parent_task_id: str
+    subtask_ids: List[str]
+
+
+class TaskCreatedEvent(WorkforceEventBase):
+    event_type: Literal["task_created"] = "task_created"
+    task_id: str
+    description: str
+    parent_task_id: Optional[str] = None
+    task_type: Optional[str] = None
+
+
+class TaskAssignedEvent(WorkforceEventBase):
+    event_type: Literal["task_assigned"] = "task_assigned"
+    task_id: str
+    worker_id: str
+    queue_time_seconds: Optional[float] = None
+    dependencies: Optional[List[str]] = None
+
+
+class TaskStartedEvent(WorkforceEventBase):
+    event_type: Literal["task_started"] = "task_started"
+    task_id: str
+    worker_id: str
+
+
+class TaskCompletedEvent(WorkforceEventBase):
+    event_type: Literal["task_completed"] = "task_completed"
+    task_id: str
+    worker_id: str
+    result_summary: Optional[str] = None
+    processing_time_seconds: Optional[float] = None
+    token_usage: Optional[Dict[str, int]] = None
+
+
+class TaskFailedEvent(WorkforceEventBase):
+    event_type: Literal["task_failed"] = "task_failed"
+    task_id: str
+    error_message: str
+    worker_id: Optional[str] = None
+
+
+class AllTasksCompletedEvent(WorkforceEventBase):
+    event_type: Literal["all_tasks_completed"] = "all_tasks_completed"
+
+
+class QueueStatusEvent(WorkforceEventBase):
+    event_type: Literal["queue_status"] = "queue_status"
+    queue_name: str
+    length: int
+    pending_task_ids: Optional[List[str]] = None
+    metadata: Optional[Dict[str, Any]] = None
+
+
+WorkforceEvent = Union[
+    TaskDecomposedEvent,
+    TaskCreatedEvent,
+    TaskAssignedEvent,
+    TaskStartedEvent,
+    TaskCompletedEvent,
+    TaskFailedEvent,
+    WorkerCreatedEvent,
+    WorkerDeletedEvent,
+    AllTasksCompletedEvent,
+    QueueStatusEvent,
+]

camel/societies/workforce/role_playing_worker.py

@@ -119,11 +119,13 @@ class RolePlayingWorker(Worker):
                 `TaskState.FAILED`.
         """
         dependency_tasks_info = self._get_dep_tasks_info(dependencies)
-        prompt = ROLEPLAY_PROCESS_TASK_PROMPT.format(
-            content=task.content,
-            parent_task_content=task.parent.content if task.parent else "",
-            dependency_tasks_info=dependency_tasks_info,
-            additional_info=task.additional_info,
+        prompt = str(
+            ROLEPLAY_PROCESS_TASK_PROMPT.format(
+                content=task.content,
+                parent_task_content=task.parent.content if task.parent else "",
+                dependency_tasks_info=dependency_tasks_info,
+                additional_info=task.additional_info,
+            )
         )
         role_play_session = RolePlaying(
             assistant_role_name=self.assistant_role_name,
@@ -183,12 +185,14 @@ class RolePlayingWorker(Worker):
             input_msg = assistant_response.msg
 
         chat_history_str = "\n".join(chat_history)
-        prompt = ROLEPLAY_SUMMARIZE_PROMPT.format(
-            user_role=self.user_role_name,
-            assistant_role=self.assistant_role_name,
-            content=task.content,
-            chat_history=chat_history_str,
-            additional_info=task.additional_info,
+        prompt = str(
+            ROLEPLAY_SUMMARIZE_PROMPT.format(
+                user_role=self.user_role_name,
+                assistant_role=self.assistant_role_name,
+                content=task.content,
+                chat_history=chat_history_str,
+                additional_info=task.additional_info,
+            )
         )
         if self.use_structured_output_handler and self.structured_handler:
             # Use structured output handler for prompt-based extraction