camel-ai 0.2.67__py3-none-any.whl → 0.2.80a2__py3-none-any.whl

camel/models/sglang_model.py

@@ -21,7 +21,7 @@ from typing import Any, Dict, List, Optional, Type, Union
 from openai import AsyncOpenAI, AsyncStream, OpenAI, Stream
 from pydantic import BaseModel
 
-from camel.configs import SGLANG_API_PARAMS, SGLangConfig
+from camel.configs import SGLangConfig
 from camel.messages import OpenAIMessage
 from camel.models import BaseModelBackend
 from camel.types import (
@@ -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
 
@@ -209,21 +239,6 @@ class SGLangModel(BaseModelBackend):
             self._token_counter = OpenAITokenCounter(ModelType.GPT_4O_MINI)
         return self._token_counter
 
-    def check_model_config(self):
-        r"""Check whether the model configuration contains any
-        unexpected arguments to SGLang API.
-
-        Raises:
-            ValueError: If the model configuration dictionary contains any
-                unexpected arguments to OpenAI API.
-        """
-        for param in self.model_config_dict:
-            if param not in SGLANG_API_PARAMS:
-                raise ValueError(
-                    f"Unexpected argument `{param}` is "
-                    "input into SGLang model backend."
-                )
-
     @observe(as_type='generation')
     async def _arun(
         self,
@@ -271,15 +286,24 @@ class SGLangModel(BaseModelBackend):
         with self._lock:
             # Update last run time
             self.last_run_time = time.time()
+            async_client = self._async_client
 
-        if self._client is None:
+        if async_client is None:
             raise RuntimeError(
                 "Client is not initialized. Ensure the server is running."
             )
 
-        response = await self._async_client.chat.completions.create(
+        # Prepare additional parameters
+        extra_params: Dict[str, Any] = {}
+        if response_format is not None:
+            extra_params["response_format"] = response_format
+        if tools is not None:
+            extra_params["tools"] = tools
+
+        response = await async_client.chat.completions.create(
             messages=messages,
             model=self.model_type,
+            **extra_params,
             **self.model_config_dict,
         )
         update_current_observation(
@@ -337,15 +361,24 @@ class SGLangModel(BaseModelBackend):
         with self._lock:
             # Update last run time
             self.last_run_time = time.time()
+            client = self._client
 
-        if self._client is None:
+        if client is None:
             raise RuntimeError(
                 "Client is not initialized. Ensure the server is running."
             )
 
-        response = self._client.chat.completions.create(
+        # Prepare additional parameters
+        extra_params: Dict[str, Any] = {}
+        if response_format is not None:
+            extra_params["response_format"] = response_format
+        if tools is not None:
+            extra_params["tools"] = tools
+
+        response = client.chat.completions.create(
             messages=messages,
             model=self.model_type,
+            **extra_params,
             **self.model_config_dict,
         )
         update_current_observation(

camel/models/siliconflow_model.py

@@ -17,7 +17,7 @@ from typing import Any, Dict, List, Optional, Type, Union
 from openai import AsyncStream
 from pydantic import BaseModel
 
-from camel.configs import SILICONFLOW_API_PARAMS, SiliconFlowConfig
+from camel.configs import SiliconFlowConfig
 from camel.messages import OpenAIMessage
 from camel.models.openai_compatible_model import OpenAICompatibleModel
 from camel.types import (
@@ -104,18 +104,3 @@ class SiliconFlowModel(OpenAICompatibleModel):
         raise NotImplementedError(
             "SiliconFlow does not support async inference."
         )
-
-    def check_model_config(self):
-        r"""Check whether the model configuration contains any
-        unexpected arguments to SiliconFlow API.
-
-        Raises:
-            ValueError: If the model configuration dictionary contains any
-                unexpected arguments to SiliconFlow API.
-        """
-        for param in self.model_config_dict:
-            if param not in SILICONFLOW_API_PARAMS:
-                raise ValueError(
-                    f"Unexpected argument `{param}` is "
-                    "input into SiliconFlow model backend."
-                )

camel/models/stub_model.py

@@ -182,7 +182,3 @@ class StubModel(BaseModelBackend):
             ),
         )
         return response
-
-    def check_model_config(self):
-        r"""Directly pass the check on arguments to STUB model."""
-        pass

camel/models/togetherai_model.py

@@ -15,7 +15,7 @@
 import os
 from typing import Any, Dict, Optional, Union
 
-from camel.configs import TOGETHERAI_API_PARAMS, TogetherAIConfig
+from camel.configs import TogetherAIConfig
 from camel.models.openai_compatible_model import OpenAICompatibleModel
 from camel.types import ModelType
 from camel.utils import (
@@ -86,18 +86,3 @@ class TogetherAIModel(OpenAICompatibleModel):
             max_retries=max_retries,
             **kwargs,
         )
-
-    def check_model_config(self):
-        r"""Check whether the model configuration contains any
-        unexpected arguments to TogetherAI API.
-
-        Raises:
-            ValueError: If the model configuration dictionary contains any
-                unexpected arguments to TogetherAI API.
-        """
-        for param in self.model_config_dict:
-            if param not in TOGETHERAI_API_PARAMS:
-                raise ValueError(
-                    f"Unexpected argument `{param}` is "
-                    "input into TogetherAI model backend."
-                )

camel/models/vllm_model.py

@@ -15,7 +15,7 @@ import os
 import subprocess
 from typing import Any, Dict, Optional, Union
 
-from camel.configs import VLLM_API_PARAMS, VLLMConfig
+from camel.configs import VLLMConfig
 from camel.logger import get_logger
 from camel.models.openai_compatible_model import OpenAICompatibleModel
 from camel.types import ModelType
@@ -103,18 +103,3 @@ class VLLMModel(OpenAICompatibleModel):
             )
         except Exception as e:
             logger.error(f"Failed to start vllm server: {e}.")
-
-    def check_model_config(self):
-        r"""Check whether the model configuration contains any
-        unexpected arguments to vLLM API.
-
-        Raises:
-            ValueError: If the model configuration dictionary contains any
-                unexpected arguments to OpenAI API.
-        """
-        for param in self.model_config_dict:
-            if param not in VLLM_API_PARAMS:
-                raise ValueError(
-                    f"Unexpected argument `{param}` is "
-                    "input into vLLM model backend."
-                )

camel/models/volcano_model.py

@@ -15,7 +15,6 @@
 import os
 from typing import Any, Dict, Optional, Union
 
-from camel.configs import OPENAI_API_PARAMS
 from camel.models.openai_compatible_model import OpenAICompatibleModel
 from camel.types import ModelType
 from camel.utils import (
@@ -86,19 +85,3 @@ class VolcanoModel(OpenAICompatibleModel):
             max_retries,
             **kwargs,
         )
-
-    def check_model_config(self):
-        r"""Check whether the model configuration is valid for Volcano
-        model backends.
-
-        Raises:
-            ValueError: If the model configuration dictionary contains any
-                unexpected arguments to Volcano API.
-        """
-        # Using OpenAI API params as Volcano Engine API is OpenAI-compatible
-        for param in self.model_config_dict:
-            if param not in OPENAI_API_PARAMS:
-                raise ValueError(
-                    f"Unexpected argument `{param}` is "
-                    "input into Volcano model backend."
-                )

camel/models/watsonx_model.py

@@ -16,7 +16,7 @@ from typing import Any, Dict, List, Optional, Type, Union
 
 from pydantic import BaseModel
 
-from camel.configs import WATSONX_API_PARAMS, WatsonXConfig
+from camel.configs import WatsonXConfig
 from camel.logger import get_logger
 from camel.messages import OpenAIMessage
 from camel.models import BaseModelBackend
@@ -292,21 +292,6 @@ class WatsonXModel(BaseModelBackend):
             logger.error(f"Unexpected error when calling WatsonX API: {e!s}")
             raise
 
-    def check_model_config(self):
-        r"""Check whether the model configuration contains any unexpected
-        arguments to WatsonX API.
-
-        Raises:
-            ValueError: If the model configuration dictionary contains any
-                unexpected arguments to WatsonX API.
-        """
-        for param in self.model_config_dict:
-            if param not in WATSONX_API_PARAMS:
-                raise ValueError(
-                    f"Unexpected argument `{param}` is "
-                    "input into WatsonX model backend."
-                )
-
     @property
     def stream(self) -> bool:
         r"""Returns whether the model is in stream mode, which sends partial

camel/models/yi_model.py

@@ -15,7 +15,7 @@
 import os
 from typing import Any, Dict, Optional, Union
 
-from camel.configs import YI_API_PARAMS, YiConfig
+from camel.configs import YiConfig
 from camel.models.openai_compatible_model import OpenAICompatibleModel
 from camel.types import ModelType
 from camel.utils import (
@@ -85,18 +85,3 @@ class YiModel(OpenAICompatibleModel):
             max_retries=max_retries,
             **kwargs,
         )
-
-    def check_model_config(self):
-        r"""Check whether the model configuration contains any
-        unexpected arguments to Yi API.
-
-        Raises:
-            ValueError: If the model configuration dictionary contains any
-                unexpected arguments to Yi API.
-        """
-        for param in self.model_config_dict:
-            if param not in YI_API_PARAMS:
-                raise ValueError(
-                    f"Unexpected argument `{param}` is "
-                    "input into Yi model backend."
-                )

camel/models/zhipuai_model.py

@@ -13,16 +13,26 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 
 import os
-from typing import Any, Dict, Optional, Union
+from typing import Any, Dict, List, Optional, Type, Union
 
-from camel.configs import ZHIPUAI_API_PARAMS, ZhipuAIConfig
+from pydantic import BaseModel
+
+from camel.configs import ZhipuAIConfig
+from camel.logger import get_logger
+from camel.messages import OpenAIMessage
+from camel.models._utils import try_modify_message_with_format
 from camel.models.openai_compatible_model import OpenAICompatibleModel
-from camel.types import ModelType
+from camel.types import (
+    ChatCompletion,
+    ModelType,
+)
 from camel.utils import (
     BaseTokenCounter,
     api_keys_required,
 )
 
+logger = get_logger(__name__)
+
 
 class ZhipuAIModel(OpenAICompatibleModel):
     r"""ZhipuAI API in a unified OpenAICompatibleModel interface.
@@ -86,17 +96,51 @@ class ZhipuAIModel(OpenAICompatibleModel):
             **kwargs,
         )
 
-    def check_model_config(self):
-        r"""Check whether the model configuration contains any
-        unexpected arguments to OpenAI API.
+    def _request_parse(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Type[BaseModel],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> ChatCompletion:
+        import copy
+
+        request_config = copy.deepcopy(self.model_config_dict)
+        request_config.pop("stream", None)
+        if tools is not None:
+            request_config["tools"] = tools
+
+        try_modify_message_with_format(messages[-1], response_format)
+        request_config["response_format"] = {"type": "json_object"}
+        try:
+            return self._client.beta.chat.completions.parse(
+                messages=messages,
+                model=self.model_type,
+                **request_config,
+            )
+        except Exception as e:
+            logger.error(f"Fallback attempt also failed: {e}")
+            raise
+
+    async def _arequest_parse(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Type[BaseModel],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> ChatCompletion:
+        import copy
 
-        Raises:
-            ValueError: If the model configuration dictionary contains any
-                unexpected arguments to ZhipuAI API.
-        """
-        for param in self.model_config_dict:
-            if param not in ZHIPUAI_API_PARAMS:
-                raise ValueError(
-                    f"Unexpected argument `{param}` is "
-                    "input into ZhipuAI model backend."
-                )
+        request_config = copy.deepcopy(self.model_config_dict)
+        request_config.pop("stream", None)
+        if tools is not None:
+            request_config["tools"] = tools
+        try_modify_message_with_format(messages[-1], response_format)
+        request_config["response_format"] = {"type": "json_object"}
+        try:
+            return await self._async_client.beta.chat.completions.parse(
+                messages=messages,
+                model=self.model_type,
+                **request_config,
+            )
+        except Exception as e:
+            logger.error(f"Fallback attempt also failed: {e}")
+            raise

camel/parsers/__init__.py

@@ -0,0 +1,18 @@
+# ========= 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. =========
+"""Helper parsers used across the CAMEL project."""
+
+from .mcp_tool_call_parser import extract_tool_calls_from_text
+
+__all__ = ["extract_tool_calls_from_text"]

camel/parsers/mcp_tool_call_parser.py

@@ -0,0 +1,176 @@
+# ========= 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. =========
+"""Utility functions for parsing MCP tool calls from model output."""
+
+import ast
+import json
+import logging
+import re
+from typing import Any, Dict, List, Optional
+
+try:  # pragma: no cover - optional dependency
+    import yaml
+except ImportError:  # pragma: no cover
+    yaml = None  # type: ignore[assignment]
+
+
+CODE_BLOCK_PATTERN = re.compile(
+    r"```(?:[a-z0-9_-]+)?\s*([\s\S]+?)\s*```",
+    re.IGNORECASE,
+)
+
+JSON_START_PATTERN = re.compile(r"[{\[]")
+JSON_TOKEN_PATTERN = re.compile(
+    r"""
+    (?P<double>"(?:\\.|[^"\\])*")
+    |
+    (?P<single>'(?:\\.|[^'\\])*')
+    |
+    (?P<brace>[{}\[\]])
+    """,
+    re.VERBOSE,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def extract_tool_calls_from_text(content: str) -> List[Dict[str, Any]]:
+    """Extract tool call dictionaries from raw text output."""
+
+    if not content:
+        return []
+
+    tool_calls: List[Dict[str, Any]] = []
+    seen_ranges: List[tuple[int, int]] = []
+
+    for match in CODE_BLOCK_PATTERN.finditer(content):
+        snippet = match.group(1).strip()
+        if not snippet:
+            continue
+
+        parsed = _try_parse_json_like(snippet)
+        if parsed is None:
+            logger.warning(
+                "Failed to parse JSON payload from fenced block: %s",
+                snippet,
+            )
+            continue
+
+        _collect_tool_calls(parsed, tool_calls)
+        seen_ranges.append((match.start(1), match.end(1)))
+
+    for start_match in JSON_START_PATTERN.finditer(content):
+        start_idx = start_match.start()
+
+        if any(start <= start_idx < stop for start, stop in seen_ranges):
+            continue
+
+        segment = _find_json_candidate(content, start_idx)
+        if segment is None:
+            continue
+
+        end_idx = start_idx + len(segment)
+        if any(start <= start_idx < stop for start, stop in seen_ranges):
+            continue
+
+        parsed = _try_parse_json_like(segment)
+        if parsed is None:
+            logger.debug(
+                "Unable to parse JSON-like candidate: %s",
+                _truncate_snippet(segment),
+            )
+            continue
+
+        _collect_tool_calls(parsed, tool_calls)
+        seen_ranges.append((start_idx, end_idx))
+
+    return tool_calls
+
+
+def _collect_tool_calls(
+    payload: Any, accumulator: List[Dict[str, Any]]
+) -> None:
+    """Collect valid tool call dictionaries from parsed payloads."""
+
+    if isinstance(payload, dict):
+        if payload.get("tool_name") is None:
+            return
+        accumulator.append(payload)
+    elif isinstance(payload, list):
+        for item in payload:
+            _collect_tool_calls(item, accumulator)
+
+
+def _try_parse_json_like(snippet: str) -> Optional[Any]:
+    """Parse a JSON or JSON-like snippet into Python data."""
+
+    try:
+        return json.loads(snippet)
+    except json.JSONDecodeError as exc:
+        logger.debug(
+            "json.loads failed: %s | snippet=%s",
+            exc,
+            _truncate_snippet(snippet),
+        )
+
+    if yaml is not None:
+        try:
+            return yaml.safe_load(snippet)
+        except yaml.YAMLError:
+            pass
+
+    try:
+        return ast.literal_eval(snippet)
+    except (ValueError, SyntaxError):
+        return None
+
+
+def _find_json_candidate(content: str, start_idx: int) -> Optional[str]:
+    """Locate a balanced JSON-like segment starting at ``start_idx``."""
+
+    opening = content[start_idx]
+    if opening not in "{[":
+        return None
+
+    stack = ["}" if opening == "{" else "]"]
+
+    for token in JSON_TOKEN_PATTERN.finditer(content, start_idx + 1):
+        if token.lastgroup in {"double", "single"}:
+            continue
+
+        brace = token.group("brace")
+        if brace in "{[":
+            stack.append("}" if brace == "{" else "]")
+            continue
+
+        if not stack:
+            return None
+
+        expected = stack.pop()
+        if brace != expected:
+            return None
+
+        if not stack:
+            return content[start_idx : token.end()]
+
+    return None
+
+
+def _truncate_snippet(snippet: str, limit: int = 120) -> str:
+    """Return a truncated representation suitable for logging."""
+
+    compact = " ".join(snippet.strip().split())
+    if len(compact) <= limit:
+        return compact
+    return f"{compact[: limit - 3]}..."

camel/retrievers/auto_retriever.py

@@ -97,6 +97,7 @@ class AutoRetriever:
                     "URL (database url) and API key required for TiDB storage "
                     "are not provided. Format: "
                     "mysql+pymysql://<username>:<password>@<host>:4000/test"
+                    "You can get the database url from https://tidbcloud.com/console/clusters"
                 )
             return TiDBStorage(
                 vector_dim=self.embedding_model.get_output_dim(),