camel-ai 0.2.16__py3-none-any.whl → 0.2.18__py3-none-any.whl

camel/__init__.py

@@ -14,7 +14,7 @@
 
 from camel.logger import disable_logging, enable_logging, set_log_level
 
-__version__ = '0.2.16'
+__version__ = '0.2.18'
 
 __all__ = [
     '__version__',

camel/agents/chat_agent.py

@@ -94,11 +94,13 @@ class FunctionCallingRecord(BaseModel):
         args (Dict[str, Any]): The dictionary of arguments passed to
             the function.
         result (Any): The execution result of calling this function.
+        tool_call_id (str): The ID of the tool call, if available.
     """
 
     func_name: str
     args: Dict[str, Any]
     result: Any
+    tool_call_id: str
 
     def __str__(self) -> str:
         r"""Overridden version of the string function.
@@ -109,7 +111,7 @@ class FunctionCallingRecord(BaseModel):
         return (
             f"Function Execution: {self.func_name}\n"
             f"\tArgs: {self.args}\n"
-            f"\tResult: {self.result}"
+            f"\tResult: {self.result}\n"
         )
 
     def as_dict(self) -> dict[str, Any]:
@@ -577,13 +579,18 @@ class ChatAgent(BaseAgent):
             )
 
         self.original_model_dict = self.model_backend.model_config_dict
-        if response_format and self.model_type in {"gpt-4o", "gpt-4o-mini"}:
+        model_response_format_modified = False
+        if (
+            response_format
+            and self.model_type.support_native_structured_output
+        ):
             self.model_backend.model_config_dict = (
                 self.original_model_dict.copy()
             )
             self.model_backend.model_config_dict["response_format"] = (
                 response_format
             )
+            model_response_format_modified = True
 
         # Convert input message to BaseMessage if necessary
         if isinstance(input_message, str):
@@ -602,7 +609,12 @@ class ChatAgent(BaseAgent):
         # Add user input to memory
         self.update_memory(input_message, OpenAIBackendRole.USER)
 
-        return self._handle_step(response_format, self.single_iteration)
+        try:
+            return self._handle_step(response_format, self.single_iteration)
+        finally:
+            if model_response_format_modified:
+                # Reset model config back to original state
+                self.model_backend.model_config_dict = self.original_model_dict
 
     def _inject_tool_prompt(self) -> None:
         r"""Generate and add the tool prompt to memory."""
@@ -824,7 +836,7 @@ class ChatAgent(BaseAgent):
             return True
 
         if self.model_type.support_native_tool_calling:
-            return response.choices[0].message.tool_calls is None
+            return not response.choices[0].message.tool_calls
 
         return "</function>" not in str(
             response.choices[0].message.content or ""
@@ -1384,6 +1396,7 @@ class ChatAgent(BaseAgent):
 
         tool = self.tool_dict[func_name]
         result = tool(**args)
+        tool_call_id = choice.message.tool_calls[0].id
 
         assist_msg = FunctionCallingMessage(
             role_name=self.role_name,
@@ -1392,6 +1405,7 @@ class ChatAgent(BaseAgent):
             content="",
             func_name=func_name,
             args=args,
+            tool_call_id=tool_call_id,
         )
         func_msg = FunctionCallingMessage(
             role_name=self.role_name,
@@ -1400,11 +1414,15 @@ class ChatAgent(BaseAgent):
             content="",
             func_name=func_name,
             result=result,
+            tool_call_id=tool_call_id,
         )
 
         # Record information about this function call
         func_record = FunctionCallingRecord(
-            func_name=func_name, args=args, result=result
+            func_name=func_name,
+            args=args,
+            result=result,
+            tool_call_id=tool_call_id,
         )
         return assist_msg, func_msg, func_record
 
@@ -1448,6 +1466,7 @@ class ChatAgent(BaseAgent):
         args = json.loads(choice.message.tool_calls[0].function.arguments)
         tool = self.tool_dict[func_name]
         result = await tool(**args)
+        tool_call_id = choice.message.tool_calls[0].id
 
         assist_msg = FunctionCallingMessage(
             role_name=self.role_name,
@@ -1456,6 +1475,7 @@ class ChatAgent(BaseAgent):
             content="",
             func_name=func_name,
             args=args,
+            tool_call_id=tool_call_id,
         )
         func_msg = FunctionCallingMessage(
             role_name=self.role_name,
@@ -1464,11 +1484,15 @@ class ChatAgent(BaseAgent):
             content="",
             func_name=func_name,
             result=result,
+            tool_call_id=tool_call_id,
         )
 
         # Record information about this function call
         func_record = FunctionCallingRecord(
-            func_name=func_name, args=args, result=result
+            func_name=func_name,
+            args=args,
+            result=result,
+            tool_call_id=tool_call_id,
         )
         return assist_msg, func_msg, func_record
 

camel/agents/multi_hop_generator_agent.py

@@ -0,0 +1,85 @@
+# ========= 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 textwrap
+from typing import Any
+
+from pydantic import ConfigDict
+
+from camel.agents.programmed_agent_instruction import (
+    ProgrammableChatAgent,
+    ProgrammedAgentInstructionResult,
+    programmable_capability,
+)
+from camel.messages import BaseMessage
+from camel.synthetic_datagen.source2synth.models import (
+    ContextPrompt,
+    MultiHopQA,
+)
+
+
+class MultiHopGeneratorAgent(ProgrammableChatAgent):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    def __init__(self, **kwargs: Any):
+        super().__init__(**kwargs)
+
+        system_text: str = textwrap.dedent(
+            """\
+            You are an expert at generating 
+            multi-hop question-answer pairs.
+            For each context, you should:
+            1. Identify multiple related facts or pieces of information
+            2. Create questions that require reasoning across these multiple pieces
+            3. Ensure the reasoning chain is clear and logical
+            4. Generate questions that require at least 2-3 steps of reasoning
+            5. Include the reasoning steps in the answer
+
+            Give your response with this information:
+            Question: [Complex question requiring multiple reasoning steps]
+            Reasoning Steps:
+            1. [First reasoning step]
+            2. [Second reasoning step]
+            3. [Final reasoning step]
+            Answer: [Final answer]
+            Supporting Facts: [List of relevant text segments used]
+            """  # noqa: E501
+        )
+        self.system_message = BaseMessage.make_assistant_message(
+            role_name='Assistant', content=system_text
+        )
+
+    @programmable_capability
+    def generate_multi_hop_qa(
+        self, context: str
+    ) -> ProgrammedAgentInstructionResult[MultiHopQA]:
+        context_prompt = ContextPrompt(
+            main_context=context, related_contexts=None
+        )
+
+        user_message = BaseMessage.make_user_message(
+            content=context_prompt.model_dump_json(), role_name="User"
+        )
+        response = self.step(
+            input_message=user_message, response_format=MultiHopQA
+        )
+        value = MultiHopQA.model_validate_json(response.msgs[0].content)
+
+        if response.msgs:
+            return ProgrammedAgentInstructionResult(
+                user_message=user_message,
+                agent_message=response.msgs[0],
+                value=value,
+            )
+        raise RuntimeError("No response from agent")

camel/agents/programmed_agent_instruction.py

@@ -0,0 +1,148 @@
+# ========= 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 abc
+import threading
+from enum import Enum
+from functools import wraps
+from typing import Any, Callable, Generic, Optional, TypeVar
+
+from pydantic import BaseModel, ConfigDict
+
+from camel.agents import ChatAgent
+from camel.messages import BaseMessage
+
+T = TypeVar('T')
+
+
+class ProgrammableAgentRequirement(Enum):
+    LAST_MESSAGE_NOT_USER = "LAST_MESSAGE_NOT_USER"
+
+
+class ProgrammedAgentInstructionResult(BaseModel, Generic[T]):
+    r"""Result of a programmable agent instruction execution.
+
+    Contains the messages exchanged during execution and the computed value.
+    The value type is specified by the generic type parameter T.
+    """
+
+    user_message: BaseMessage
+    agent_message: BaseMessage
+    value: T
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+
+class AbstractProgrammableAgent(abc.ABC):
+    r"""Abstract class for a programmable agent.
+
+    A programmable agent is an agent that can be programmed to perform a
+    specific function or task. This class defines the interface for a
+    programmable
+    agent.
+
+    These methods should be implemented in order to ensure the agent supports
+    the necessary guarantees to enable a programming interface while
+    maintaining compatibility in a multi-agent system.
+
+    A programmable agent is responsible for providing and maintaining a
+    programming interface for its functionality.
+    """
+
+    @abc.abstractmethod
+    def run_atomic(
+        self, callback: Callable[[], ProgrammedAgentInstructionResult[T]]
+    ) -> ProgrammedAgentInstructionResult[T]:
+        r"""Run an atomic operation on the agent.
+
+        An atomic operation is an operation that is guaranteed to
+        be executed without interruption by any other operation.
+
+        If the operation fails or times out the agents state should be
+        unchanged.
+
+        If an operation is already in progress, this method should throw an
+        exception. (It is up to the caller to do any queuing)
+
+        If the agent is in a state where it can perform the operation,
+        it must leave the agent in a state where it can perform the
+        operation again. Though if state changes in successful operation
+        improve its ability to perform the operation, it should keep them.
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def repair_state(self, requirement: ProgrammableAgentRequirement) -> None:
+        r"""Repair the state of the agent.
+
+        Agents may have other non-atomic interfaces, such as a user interface,
+        or chat between other agents.
+
+        This method should restore the agent to a state where it can perform
+        operations according to the specified requirement.
+        """
+        raise NotImplementedError
+
+
+def programmable_capability(
+    func: Callable[..., ProgrammedAgentInstructionResult[T]],
+) -> Callable[..., ProgrammedAgentInstructionResult[T]]:
+    r"""Decorator for programmable agent capabilities.
+
+    Wraps a method to ensure it is executed atomically via the agent's
+    run_atomic interface.
+    The decorated method must return a ProgrammedAgentInstructionResult with
+    appropriate type parameter.
+    """
+
+    @wraps(func)
+    def wrapper(
+        self, *args: Any, **kwargs: Any
+    ) -> ProgrammedAgentInstructionResult[T]:
+        return self.run_atomic(lambda: func(self, *args, **kwargs))
+
+    return wrapper
+
+
+class ProgrammableChatAgent(ChatAgent, AbstractProgrammableAgent):
+    r"""A chat agent that can be programmed to perform specific tasks.
+
+    Provides a default implementation of atomic execution using threading locks
+    and basic state tracking for message roles. Implementing classes need to
+    provide specific repair logic for their use cases.
+    """
+
+    def __init__(self, **kwargs: Any):
+        super().__init__(**kwargs)
+        self._operation_lock = threading.Lock()
+        self._last_message_role: Optional[str] = None
+
+    def run_atomic(
+        self, callback: Callable[[], ProgrammedAgentInstructionResult[T]]
+    ) -> ProgrammedAgentInstructionResult[T]:
+        if not self._operation_lock.acquire(blocking=False):
+            raise RuntimeError("Operation already in progress")
+
+        try:
+            result = callback()
+            self._last_message_role = result.agent_message.role_name
+            return result
+        finally:
+            self._operation_lock.release()
+
+    def repair_state(self, requirement: ProgrammableAgentRequirement) -> None:
+        if requirement == ProgrammableAgentRequirement.LAST_MESSAGE_NOT_USER:
+            if self._last_message_role == "user":
+                raise NotImplementedError(
+                    "Must implement repair for LAST_MESSAGE_NOT_USER"
+                )

camel/benchmarks/__init__.py

@@ -17,6 +17,7 @@ from .apibench import APIBenchBenchmark
 from .base import BaseBenchmark
 from .gaia import DefaultGAIARetriever, GAIABenchmark
 from .nexus import NexusBenchmark
+from .ragbench import RAGBenchBenchmark
 
 __all__ = [
     "BaseBenchmark",
@@ -25,4 +26,5 @@ __all__ = [
     "NexusBenchmark",
     "APIBenchBenchmark",
     "APIBankBenchmark",
+    "RAGBenchBenchmark",
 ]

camel/benchmarks/apibank.py

@@ -32,6 +32,11 @@ from camel.utils import download_github_subdirectory
 
 logger = logging.getLogger(__name__)
 
+# Add current folder to sys.path to enable relative import
+current_folder = os.getcwd()
+if current_folder not in sys.path:
+    sys.path.append(current_folder)
+
 
 def process_messages(
     chat_history: List[Dict[str, Any]],

camel/benchmarks/apibench.py

@@ -29,24 +29,28 @@ from camel.utils import download_github_subdirectory
 
 logger = logging.getLogger(__name__)
 
+
+# Mapping of dataset names to file names
+# 'Oracle' retriver used here which means all the full
+# API documentation will be included in the prompt
 dataset_mapping = {
     "huggingface": {
         "api": "huggingface_api.jsonl",
         "eval": "huggingface_eval.json",
         "train": "huggingface_train.json",
-        "questions": "questions_huggingface_0_shot.jsonl",
+        "questions": "questions_huggingface_oracle.jsonl",
     },
     "tensorflowhub": {
         "api": "tensorflowhub_api.jsonl",
         "eval": "tensorflow_eval.json",
         "train": "tensorflow_train.json",
-        "questions": "questions_tensorflowhub_0_shot.jsonl",
+        "questions": "questions_tensorflowhub_oracle.jsonl",
     },
     "torchhub": {
         "api": "torchhub_api.jsonl",
         "eval": "torchhub_eval.json",
         "train": "torchhub_train.json",
-        "questions": "questions_torchhub_0_shot.jsonl",
+        "questions": "questions_torchhub_oracle.jsonl",
     },
 }
 
@@ -173,7 +177,7 @@ class APIBenchBenchmark(BaseBenchmark):
         )
 
         repo = "ShishirPatil/gorilla"
-        subdir = "eval/eval-data/questions"
+        subdir = "/gorilla/eval/eval-data/questions"
         data_dir = self.data_dir
 
         download_github_subdirectory(repo, subdir, data_dir)

camel/benchmarks/gaia.py

@@ -280,11 +280,11 @@ class GAIABenchmark(BaseBenchmark):
                     f"Skipping task because file not found: {file_path}"
                 )
                 return False
-            if file_path.suffix in ['.pdf', '.docx', '.doc', '.txt']:
+            if file_path.suffix in [".pdf", ".docx", ".doc", ".txt"]:
                 if not self.retriever.reset(task_id=task["task_id"]):
                     return False
                 retrieved_info = self.retriever.retrieve(
-                    query=task["Question"], contents=[task['file_name']]
+                    query=task["Question"], contents=[task["file_name"]]
                 )
                 retrieved_content = [
                     item["text"]