camel-ai 0.2.75a5__py3-none-any.whl → 0.2.76__py3-none-any.whl

camel/models/ollama_model.py

@@ -35,8 +35,8 @@ class OllamaModel(OpenAICompatibleModel):
             If:obj:`None`, :obj:`OllamaConfig().as_dict()` will be used.
             (default: :obj:`None`)
         api_key (Optional[str], optional): The API key for authenticating with
-            the model service.  Ollama doesn't need API key, it would be
-            ignored if set. (default: :obj:`None`)
+            the model service. Required for Ollama cloud services. If not
+            provided, defaults to "Not_Provided". (default: :obj:`None`)
         url (Optional[str], optional): The url to the model service.
             (default: :obj:`None`)
         token_counter (Optional[BaseTokenCounter], optional): Token counter to
@@ -79,7 +79,7 @@ class OllamaModel(OpenAICompatibleModel):
         super().__init__(
             model_type=self._model_type,
             model_config_dict=model_config_dict,
-            api_key="Not_Used",
+            api_key=api_key or "Not_Provided",
             url=self._url,
             token_counter=token_counter,
             timeout=timeout,

camel/models/openai_compatible_model.py

@@ -190,9 +190,6 @@ class OpenAICompatibleModel(BaseModelBackend):
         is_streaming = self.model_config_dict.get("stream", False)
 
         if response_format:
-            result: Union[ChatCompletion, Stream[ChatCompletionChunk]] = (
-                self._request_parse(messages, response_format, tools)
-            )
             if is_streaming:
                 # Use streaming parse for structured output
                 return self._request_stream_parse(
@@ -256,9 +253,6 @@ class OpenAICompatibleModel(BaseModelBackend):
         is_streaming = self.model_config_dict.get("stream", False)
 
         if response_format:
-            result: Union[
-                ChatCompletion, AsyncStream[ChatCompletionChunk]
-            ] = await self._arequest_parse(messages, response_format, tools)
             if is_streaming:
                 # Use streaming parse for structured output
                 return await self._arequest_stream_parse(

camel/models/openai_model.py

@@ -303,9 +303,6 @@ class OpenAIModel(BaseModelBackend):
         is_streaming = self.model_config_dict.get("stream", False)
 
         if response_format:
-            result: Union[ChatCompletion, Stream[ChatCompletionChunk]] = (
-                self._request_parse(messages, response_format, tools)
-            )
             if is_streaming:
                 # Use streaming parse for structured output
                 return self._request_stream_parse(
@@ -377,9 +374,6 @@ class OpenAIModel(BaseModelBackend):
         is_streaming = self.model_config_dict.get("stream", False)
 
         if response_format:
-            result: Union[
-                ChatCompletion, AsyncStream[ChatCompletionChunk]
-            ] = await self._arequest_parse(messages, response_format, tools)
             if is_streaming:
                 # Use streaming parse for structured output
                 return await self._arequest_stream_parse(

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 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.
@@ -85,3 +95,52 @@ class ZhipuAIModel(OpenAICompatibleModel):
             max_retries=max_retries,
             **kwargs,
         )
+
+    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
+
+        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(),

camel/runtimes/daytona_runtime.py

@@ -16,7 +16,7 @@ import inspect
 import json
 import os
 from functools import wraps
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Callable, Dict, List, Optional, Union
 
 from pydantic import BaseModel
 
@@ -49,7 +49,7 @@ class DaytonaRuntime(BaseRuntime):
         api_url: Optional[str] = None,
         language: Optional[str] = "python",
     ):
-        from daytona_sdk import Daytona, DaytonaConfig
+        from daytona_sdk import Daytona, DaytonaConfig, Sandbox
 
         super().__init__()
         self.api_key = api_key or os.environ.get('DAYTONA_API_KEY')
@@ -57,7 +57,7 @@ class DaytonaRuntime(BaseRuntime):
         self.language = language
         self.config = DaytonaConfig(api_key=self.api_key, api_url=self.api_url)
         self.daytona = Daytona(self.config)
-        self.sandbox = None
+        self.sandbox: Optional[Sandbox] = None
         self.entrypoint: Dict[str, str] = dict()
 
     def build(self) -> "DaytonaRuntime":
@@ -66,10 +66,10 @@ class DaytonaRuntime(BaseRuntime):
         Returns:
             DaytonaRuntime: The current runtime.
         """
-        from daytona_sdk import CreateSandboxParams
+        from daytona_sdk import CreateSandboxBaseParams
 
         try:
-            params = CreateSandboxParams(language=self.language)
+            params = CreateSandboxBaseParams(language=self.language)
             self.sandbox = self.daytona.create(params)
             if self.sandbox is None:
                 raise RuntimeError("Failed to create sandbox.")
@@ -83,7 +83,7 @@ class DaytonaRuntime(BaseRuntime):
         r"""Clean up the sandbox when exiting."""
         if self.sandbox:
             try:
-                self.daytona.remove(self.sandbox)
+                self.daytona.delete(self.sandbox)
                 logger.info(f"Sandbox {self.sandbox.id} removed")
                 self.sandbox = None
             except Exception as e:
@@ -112,7 +112,7 @@ class DaytonaRuntime(BaseRuntime):
         if arguments is not None:
             entrypoint += json.dumps(arguments, ensure_ascii=False)
 
-        def make_wrapper(inner_func, func_name, func_code):
+        def make_wrapper(inner_func: Callable, func_name: str, func_code: str):
             r"""Creates a wrapper for a function to execute it in the
             Daytona sandbox.
 
@@ -208,12 +208,11 @@ class DaytonaRuntime(BaseRuntime):
             RuntimeError: If the sandbox is not initialized.
         """
         if self.sandbox is None:
-            raise RuntimeError("Failed to create sandbox.")
-        info = self.sandbox.info()
+            raise RuntimeError("Sandbox not initialized.")
         return (
-            f"Sandbox {info.name}:\n"
-            f"State: {info.state}\n"
-            f"Resources: {info.resources.cpu} CPU, {info.resources.memory} RAM"
+            f"Sandbox {self.sandbox.id}:\n"
+            f"State: {self.sandbox.state}\n"
+            f"Resources: {self.sandbox.cpu} CPU, {self.sandbox.memory} RAM"
         )
 
     def __del__(self):

camel/societies/workforce/prompts.py

@@ -293,58 +293,139 @@ Each subtask should be:
 - Written without any relative references (e.g., "the previous task").
 """
 
-FAILURE_ANALYSIS_PROMPT = TextPrompt(
-    """You need to analyze a task failure and decide on the best recovery strategy.
-
-**TASK FAILURE DETAILS:**
-Task ID: {task_id}
-Task Content: {task_content}
-Failure Count: {failure_count}/3
-Error Message: {error_message}
-Worker ID: {worker_id}
-Task Depth: {task_depth}
-Additional Info: {additional_info}
-
-**AVAILABLE RECOVERY STRATEGIES:**
-
-1. **RETRY**: Attempt the same task again without changes
-   - Use for: Network errors, temporary API issues, random failures
-   - Avoid for: Fundamental task misunderstanding, capability gaps
-
-2. **REPLAN**: Modify the task content to address the underlying issue
-   - Use for: Unclear requirements, insufficient context, correctable errors
-   - Provide: Modified task content that addresses the failure cause
-   - **CRITICAL**: The replanned task MUST be a clear, actionable
-     instruction for an AI agent, not a question or request for a human.
-
-3. **DECOMPOSE**: Break the task into smaller, more manageable subtasks
-   - Use for: Complex tasks, capability mismatches, persistent failures
-   - Consider: Whether the task is too complex for a single worker
-
-4. **CREATE_WORKER**: Create a new worker node to handle the task
-   - Use for: Fundamental task misunderstanding, capability gaps
-
-**ANALYSIS GUIDELINES:**
-
-- **Connection/Network Errors**: Almost always choose RETRY
-- **Model Processing Errors**: Consider REPLAN if the task can be clarified, otherwise DECOMPOSE
-- **Capability Gaps**: Choose DECOMPOSE to break into simpler parts. If a
-  replan can work, ensure the new task is a command for an agent, not a
-  request to a user.
-- **Ambiguous Requirements**: Choose REPLAN with clearer instructions
-- **High Failure Count**: Lean towards DECOMPOSE rather than repeated retries
-- **Deep Tasks (depth > 2)**: Prefer RETRY or REPLAN over further
-  decomposition
+TASK_ANALYSIS_PROMPT = TextPrompt(
+    """You are analyzing a task to evaluate its quality and determine recovery actions if needed.
+
+**TASK INFORMATION:**
+- Task ID: {task_id}
+- Task Content: {task_content}
+- Task Result: {task_result}
+- Failure Count: {failure_count}
+- Task Depth: {task_depth}
+- Assigned Worker: {assigned_worker}
+
+**ISSUE TYPE: {issue_type}**
+
+{issue_specific_analysis}
+
+**STEP 1: EVALUATE TASK QUALITY**
+
+First, assess whether the task was completed successfully and meets quality standards:
+
+**For Task Failures (with error messages):**
+- The task did not complete successfully
+- An error occurred during execution
+- Quality is automatically insufficient
+- Focus on analyzing the error cause
+
+**For Quality Issues (task completed but needs evaluation):**
+Evaluate the task result based on these criteria:
+1. **Completeness**: Does the result fully address all task requirements?
+2. **Accuracy**: Is the result correct and well-structured?
+3. **Missing Elements**: Are there any missing components or quality issues?
+
+Provide:
+- Quality score (0-100): Objective assessment of result quality
+- Specific issues list: Any problems found in the result
+- Quality sufficient: Boolean indicating if quality meets standards
+
+**STEP 2: DETERMINE RECOVERY STRATEGY (if quality insufficient)**
+
+If the task quality is insufficient, select the best recovery strategy:
+
+**Available Strategies:**
+
+1. **retry** - Retry with the same worker and task content
+   - **Best for**:
+     * Network errors, connection timeouts, temporary API issues
+     * Random failures that are likely temporary
+     * Minor quality issues that may resolve on retry
+   - **Not suitable for**:
+     * Fundamental task misunderstandings
+     * Worker capability gaps
+     * Persistent quality problems
+
+2. **reassign** - Assign to a different worker
+   - **Best for**:
+     * Current worker lacks required skills/expertise
+     * Worker-specific quality issues
+     * Task requires different specialization
+   - **Not suitable for**:
+     * Task description is unclear (use replan instead)
+     * Task is too complex (use decompose instead)
+   - **Note**: Only available for quality issues, not failures
+
+3. **replan** - Modify task content with clearer instructions
+   - **Best for**:
+     * Unclear or ambiguous requirements
+     * Missing context or information
+     * Task description needs improvement
+   - **Requirements**:
+     * Provide modified_task_content with enhanced, clear instructions
+     * Modified task must be actionable for an AI agent
+     * Address the root cause identified in issues
+
+4. **decompose** - Break into smaller, manageable subtasks
+   - **Best for**:
+     * Task is too complex for a single worker
+     * Multiple distinct sub-problems exist
+     * Persistent failures despite retries
+     * Capability mismatches that need specialization
+   - **Consider**:
+     * Task depth (avoid if depth > 2)
+     * Whether subtasks can run in parallel
+
+5. **create_worker** - Create new specialized worker
+   - **Best for**:
+     * No existing worker has required capabilities
+     * Need specialized skills not currently available
+   - **Consider**:
+     * Whether decomposition could work instead
+     * Cost of creating new worker vs alternatives
+   - **Note**: Only available for task failures, not quality issues
+
+**DECISION GUIDELINES:**
+
+**Priority Rules:**
+1. Connection/Network Errors → **retry** (almost always)
+2. Deep Tasks (depth > 2) → Avoid decompose, prefer **retry** or **replan**
+3. Worker Skill Mismatch → **reassign** (quality) or **decompose** (failure)
+4. Unclear Requirements → **replan** with specifics
+5. Task Too Complex → **decompose** into subtasks
 
 **RESPONSE FORMAT:**
-You must return a valid JSON object with these fields:
-- "strategy": one of "retry", "replan", or "decompose" 
-- "reasoning": explanation for your choice (1-2 sentences)
-- "modified_task_content": new task content if strategy is "replan", null otherwise
+{response_format}
 
-**Example Response:**
-{{"strategy": "retry", "reasoning": "The connection error appears to be temporary and network-related, a simple retry should resolve this.", "modified_task_content": null}}
-
-**CRITICAL**: Return ONLY the JSON object. No explanations or text outside the JSON structure.
+**CRITICAL**:
+- Return ONLY a valid JSON object
+- No explanations or text outside the JSON structure
+- Ensure all required fields are included
+- Use null for optional fields when not applicable
 """
 )
+
+FAILURE_ANALYSIS_RESPONSE_FORMAT = """JSON format:
+{
+  "reasoning": "explanation (1-2 sentences)",
+  "recovery_strategy": "retry|replan|decompose|create_worker",
+  "modified_task_content": "new content if replan, else null",
+  "issues": ["error1", "error2"]
+}"""
+
+QUALITY_EVALUATION_RESPONSE_FORMAT = """JSON format:
+{
+  "quality_score": 0-100,
+  "reasoning": "explanation (1-2 sentences)", 
+  "issues": ["issue1", "issue2"],
+  "recovery_strategy": "retry|reassign|replan|decompose or null",
+  "modified_task_content": "new content if replan, else null"
+}"""
+
+TASK_AGENT_SYSTEM_MESSAGE = """You are an intelligent task management assistant responsible for planning, analyzing, and quality control.
+
+Your responsibilities include:
+1. **Task Decomposition**: Breaking down complex tasks into manageable subtasks that can be executed efficiently and in parallel when possible.
+2. **Failure Analysis**: Analyzing task failures to determine the root cause and recommend appropriate recovery strategies (retry, replan, decompose, or create new worker).
+3. **Quality Evaluation**: Assessing completed task results to ensure they meet quality standards and recommending recovery strategies if quality is insufficient (retry, reassign, replan, or decompose).
+
+You must provide structured, actionable analysis based on the task context, failure history, worker capabilities, and quality criteria. Your decisions directly impact the efficiency and success of the workforce system."""