camel-ai 0.1.5.1__py3-none-any.whl → 0.1.5.3__py3-none-any.whl

camel/agents/__init__.py

@@ -17,6 +17,7 @@ from .critic_agent import CriticAgent
 from .embodied_agent import EmbodiedAgent
 from .knowledge_graph_agent import KnowledgeGraphAgent
 from .role_assignment_agent import RoleAssignmentAgent
+from .search_agent import SearchAgent
 from .task_agent import (
     TaskCreationAgent,
     TaskPlannerAgent,
@@ -38,5 +39,6 @@ __all__ = [
     'HuggingFaceToolAgent',
     'EmbodiedAgent',
     'RoleAssignmentAgent',
+    'SearchAgent',
     'KnowledgeGraphAgent',
 ]

camel/agents/chat_agent.py

@@ -32,6 +32,7 @@ from camel.responses import ChatAgentResponse
 from camel.types import (
     ChatCompletion,
     ChatCompletionChunk,
+    ModelPlatformType,
     ModelType,
     OpenAIBackendRole,
     RoleType,
@@ -41,7 +42,6 @@ from camel.utils import get_model_encoding
 if TYPE_CHECKING:
     from openai import Stream
 
-    from camel.configs import BaseConfig
     from camel.functions import OpenAIFunction
     from camel.terminators import ResponseTerminator
 
@@ -80,10 +80,9 @@ class ChatAgent(BaseAgent):
 
     Args:
         system_message (BaseMessage): The system message for the chat agent.
-        model_type (ModelType, optional): The LLM model to use for generating
-            responses. (default :obj:`ModelType.GPT_3_5_TURBO`)
-        model_config (BaseConfig, optional): Configuration options for the
-            LLM model. (default: :obj:`None`)
+        model (BaseModelBackend, optional): The model backend to use for
+            generating responses. (default: :obj:`OpenAIModel` with
+            `GPT_3_5_TURBO`)
         api_key (str, optional): The API key for authenticating with the
             LLM service. Only OpenAI and Anthropic model supported (default:
             :obj:`None`)
@@ -109,8 +108,7 @@ class ChatAgent(BaseAgent):
     def __init__(
         self,
         system_message: BaseMessage,
-        model_type: Optional[ModelType] = None,
-        model_config: Optional[BaseConfig] = None,
+        model: Optional[BaseModelBackend] = None,
         api_key: Optional[str] = None,
         memory: Optional[AgentMemory] = None,
         message_window_size: Optional[int] = None,
@@ -123,24 +121,30 @@ class ChatAgent(BaseAgent):
         self.system_message = system_message
         self.role_name: str = system_message.role_name
         self.role_type: RoleType = system_message.role_type
+        self._api_key = api_key
+        self.model_backend: BaseModelBackend = (
+            model
+            if model is not None
+            else ModelFactory.create(
+                model_platform=ModelPlatformType.OPENAI,
+                model_type=ModelType.GPT_3_5_TURBO,
+                model_config_dict=ChatGPTConfig().__dict__,
+                api_key=self._api_key,
+            )
+        )
         self.output_language: Optional[str] = output_language
         if self.output_language is not None:
             self.set_output_language(self.output_language)
 
-        self.model_type: ModelType = (
-            model_type if model_type is not None else ModelType.GPT_3_5_TURBO
-        )
+        self.model_type: ModelType = self.model_backend.model_type
 
         self.func_dict: Dict[str, Callable] = {}
         if tools is not None:
             for func in tools:
                 self.func_dict[func.get_function_name()] = func.func
 
-        self.model_config = model_config or ChatGPTConfig()
-        self._api_key = api_key
-        self.model_backend: BaseModelBackend = ModelFactory.create(
-            self.model_type, self.model_config.__dict__, self._api_key
-        )
+        self.model_config_dict = self.model_backend.model_config_dict
+
         self.model_token_limit = token_limit or self.model_backend.token_limit
         context_creator = ScoreBasedContextCreator(
             self.model_backend.token_counter,
@@ -306,7 +310,7 @@ class ChatAgent(BaseAgent):
         tool_calls: List[FunctionCallingRecord] = []
         while True:
             # Format messages and get the token number
-            openai_messages: Optional[List[OpenAIMessage]]
+            openai_messages: list[OpenAIMessage] | None
 
             try:
                 openai_messages, num_tokens = self.memory.get_context()
@@ -314,18 +318,13 @@ class ChatAgent(BaseAgent):
                 return self.step_token_exceed(
                     e.args[1], tool_calls, "max_tokens_exceeded"
                 )
-
-            # Obtain the model's response
-            response = self.model_backend.run(openai_messages)
-
-            if isinstance(response, ChatCompletion):
-                output_messages, finish_reasons, usage_dict, response_id = (
-                    self.handle_batch_response(response)
-                )
-            else:
-                output_messages, finish_reasons, usage_dict, response_id = (
-                    self.handle_stream_response(response, num_tokens)
-                )
+            (
+                response,
+                output_messages,
+                finish_reasons,
+                usage_dict,
+                response_id,
+            ) = self._step_model_response(openai_messages, num_tokens)
 
             if (
                 self.is_tools_added()
@@ -350,38 +349,165 @@ class ChatAgent(BaseAgent):
 
             else:
                 # Function calling disabled or not a function calling
+                info = self._step_get_info(
+                    output_messages,
+                    finish_reasons,
+                    usage_dict,
+                    response_id,
+                    tool_calls,
+                    num_tokens,
+                )
+                break
 
-                # Loop over responses terminators, get list of termination
-                # tuples with whether the terminator terminates the agent
-                # and termination reason
-                termination = [
-                    terminator.is_terminated(output_messages)
-                    for terminator in self.response_terminators
-                ]
-                # Terminate the agent if any of the terminator terminates
-                self.terminated, termination_reason = next(
-                    (
-                        (terminated, termination_reason)
-                        for terminated, termination_reason in termination
-                        if terminated
-                    ),
-                    (False, None),
+        return ChatAgentResponse(output_messages, self.terminated, info)
+
+    async def step_async(
+        self,
+        input_message: BaseMessage,
+    ) -> ChatAgentResponse:
+        r"""Performs a single step in the chat session by generating a response
+        to the input message. This agent step can call async function calls.
+
+        Args:
+            input_message (BaseMessage): The input message to the agent.
+            Its `role` field that specifies the role at backend may be either
+            `user` or `assistant` but it will be set to `user` anyway since
+            for the self agent any incoming message is external.
+
+        Returns:
+            ChatAgentResponse: A struct containing the output messages,
+                a boolean indicating whether the chat session has terminated,
+                and information about the chat session.
+        """
+        self.update_memory(input_message, OpenAIBackendRole.USER)
+
+        output_messages: List[BaseMessage]
+        info: Dict[str, Any]
+        tool_calls: List[FunctionCallingRecord] = []
+        while True:
+            # Format messages and get the token number
+            openai_messages: list[OpenAIMessage] | None
+
+            try:
+                openai_messages, num_tokens = self.memory.get_context()
+            except RuntimeError as e:
+                return self.step_token_exceed(
+                    e.args[1], tool_calls, "max_tokens_exceeded"
                 )
-                # For now only retain the first termination reason
-                if self.terminated and termination_reason is not None:
-                    finish_reasons = [termination_reason] * len(finish_reasons)
+            (
+                response,
+                output_messages,
+                finish_reasons,
+                usage_dict,
+                response_id,
+            ) = self._step_model_response(openai_messages, num_tokens)
 
-                info = self.get_info(
-                    response_id,
-                    usage_dict,
+            if (
+                self.is_tools_added()
+                and isinstance(response, ChatCompletion)
+                and response.choices[0].message.tool_calls is not None
+            ):
+                # Tools added for function calling and not in stream mode
+
+                # Do function calling
+                (
+                    func_assistant_msg,
+                    func_result_msg,
+                    func_record,
+                ) = await self.step_tool_call_async(response)
+
+                # Update the messages
+                self.update_memory(
+                    func_assistant_msg, OpenAIBackendRole.ASSISTANT
+                )
+                self.update_memory(func_result_msg, OpenAIBackendRole.FUNCTION)
+
+                # Record the function calling
+                tool_calls.append(func_record)
+
+            else:
+                # Function calling disabled or not a function calling
+                info = self._step_get_info(
+                    output_messages,
                     finish_reasons,
-                    num_tokens,
+                    usage_dict,
+                    response_id,
                     tool_calls,
+                    num_tokens,
                 )
                 break
 
         return ChatAgentResponse(output_messages, self.terminated, info)
 
+    def _step_model_response(
+        self,
+        openai_messages: list[OpenAIMessage],
+        num_tokens: int,
+    ) -> tuple[
+        ChatCompletion | Stream[ChatCompletionChunk],
+        list[BaseMessage],
+        list[str],
+        dict[str, int],
+        str,
+    ]:
+        r"""Internal function for agent step model response."""
+        # Obtain the model's response
+        response = self.model_backend.run(openai_messages)
+
+        if isinstance(response, ChatCompletion):
+            output_messages, finish_reasons, usage_dict, response_id = (
+                self.handle_batch_response(response)
+            )
+        else:
+            output_messages, finish_reasons, usage_dict, response_id = (
+                self.handle_stream_response(response, num_tokens)
+            )
+        return (
+            response,
+            output_messages,
+            finish_reasons,
+            usage_dict,
+            response_id,
+        )
+
+    def _step_get_info(
+        self,
+        output_messages: List[BaseMessage],
+        finish_reasons: List[str],
+        usage_dict: Dict[str, int],
+        response_id: str,
+        tool_calls: List[FunctionCallingRecord],
+        num_tokens: int,
+    ) -> Dict[str, Any]:
+        # Loop over responses terminators, get list of termination
+        # tuples with whether the terminator terminates the agent
+        # and termination reason
+        termination = [
+            terminator.is_terminated(output_messages)
+            for terminator in self.response_terminators
+        ]
+        # Terminate the agent if any of the terminator terminates
+        self.terminated, termination_reason = next(
+            (
+                (terminated, termination_reason)
+                for terminated, termination_reason in termination
+                if terminated
+            ),
+            (False, None),
+        )
+        # For now only retain the first termination reason
+        if self.terminated and termination_reason is not None:
+            finish_reasons = [termination_reason] * len(finish_reasons)
+
+        info = self.get_info(
+            response_id,
+            usage_dict,
+            finish_reasons,
+            num_tokens,
+            tool_calls,
+        )
+        return info
+
     def handle_batch_response(
         self, response: ChatCompletion
     ) -> Tuple[List[BaseMessage], List[str], Dict[str, int], str]:
@@ -516,12 +642,12 @@ class ChatAgent(BaseAgent):
         """
         choice = response.choices[0]
         if choice.message.tool_calls is None:
-            raise RuntimeError("Tool calls is None")
+            raise RuntimeError("Tool call is None")
         func_name = choice.message.tool_calls[0].function.name
         func = self.func_dict[func_name]
 
         args_str: str = choice.message.tool_calls[0].function.arguments
-        args = json.loads(args_str.replace("'", "\""))
+        args = json.loads(args_str)
 
         # Pass the extracted arguments to the indicated function
         try:
@@ -553,6 +679,65 @@ class ChatAgent(BaseAgent):
         func_record = FunctionCallingRecord(func_name, args, result)
         return assist_msg, func_msg, func_record
 
+    async def step_tool_call_async(
+        self,
+        response: ChatCompletion,
+    ) -> Tuple[
+        FunctionCallingMessage, FunctionCallingMessage, FunctionCallingRecord
+    ]:
+        r"""Execute the async function with arguments following the model's
+        response.
+
+        Args:
+            response (Dict[str, Any]): The response obtained by calling the
+                model.
+
+        Returns:
+            tuple: A tuple consisting of two obj:`FunctionCallingMessage`,
+                one about the arguments and the other about the execution
+                result, and a struct for logging information about this
+                function call.
+        """
+        # Note that when function calling is enabled, `n` is set to 1.
+        choice = response.choices[0]
+        if choice.message.tool_calls is None:
+            raise RuntimeError("Tool call is None")
+        func_name = choice.message.tool_calls[0].function.name
+        func = self.func_dict[func_name]
+
+        args_str: str = choice.message.tool_calls[0].function.arguments
+        args = json.loads(args_str)
+
+        # Pass the extracted arguments to the indicated function
+        try:
+            result = await func(**args)
+        except Exception:
+            raise ValueError(
+                f"Execution of function {func.__name__} failed with "
+                f"arguments being {args}."
+            )
+
+        assist_msg = FunctionCallingMessage(
+            role_name=self.role_name,
+            role_type=self.role_type,
+            meta_dict=None,
+            content="",
+            func_name=func_name,
+            args=args,
+        )
+        func_msg = FunctionCallingMessage(
+            role_name=self.role_name,
+            role_type=self.role_type,
+            meta_dict=None,
+            content="",
+            func_name=func_name,
+            result=result,
+        )
+
+        # Record information about this function call
+        func_record = FunctionCallingRecord(func_name, args, result)
+        return assist_msg, func_msg, func_record
+
     def get_usage_dict(
         self, output_messages: List[BaseMessage], prompt_tokens: int
     ) -> Dict[str, int]:

camel/agents/critic_agent.py

@@ -20,8 +20,8 @@ from colorama import Fore
 from camel.agents.chat_agent import ChatAgent
 from camel.memories import AgentMemory
 from camel.messages import BaseMessage
+from camel.models import BaseModelBackend
 from camel.responses import ChatAgentResponse
-from camel.types import ModelType
 from camel.utils import get_first_int, print_text_animated
 
 
@@ -31,10 +31,9 @@ class CriticAgent(ChatAgent):
     Args:
         system_message (BaseMessage): The system message for the critic
             agent.
-        model_type (ModelType, optional): The LLM model to use for generating
-            responses. (default :obj:`ModelType.GPT_3_5_TURBO`)
-        model_config (Any, optional): Configuration options for the LLM model.
-            (default: :obj:`None`)
+        model (BaseModelBackend, optional): The model backend to use for
+            generating responses. (default: :obj:`OpenAIModel` with
+            `GPT_3_5_TURBO`)
         message_window_size (int, optional): The maximum number of previous
             messages to include in the context window. If `None`, no windowing
             is performed. (default: :obj:`6`)
@@ -48,8 +47,7 @@ class CriticAgent(ChatAgent):
     def __init__(
         self,
         system_message: BaseMessage,
-        model_type: ModelType = ModelType.GPT_3_5_TURBO,
-        model_config: Optional[Any] = None,
+        model: Optional[BaseModelBackend] = None,
         memory: Optional[AgentMemory] = None,
         message_window_size: int = 6,
         retry_attempts: int = 2,
@@ -58,8 +56,7 @@ class CriticAgent(ChatAgent):
     ) -> None:
         super().__init__(
             system_message,
-            model_type=model_type,
-            model_config=model_config,
+            model=model,
             memory=memory,
             message_window_size=message_window_size,
         )

camel/agents/deductive_reasoner_agent.py

@@ -15,10 +15,10 @@ import re
 from typing import Dict, List, Optional, Union
 
 from camel.agents.chat_agent import ChatAgent
-from camel.configs import BaseConfig
 from camel.messages import BaseMessage
+from camel.models import BaseModelBackend
 from camel.prompts import TextPrompt
-from camel.types import ModelType, RoleType
+from camel.types import RoleType
 
 
 class DeductiveReasonerAgent(ChatAgent):
@@ -33,16 +33,14 @@ class DeductiveReasonerAgent(ChatAgent):
         - L represents the path or process from A to B.
 
     Args:
-        model_type (ModelType, optional): The type of model to use for the
-            agent. (default: :obj: `None`)
-        model_config (BaseConfig, optional): The configuration for the model.
-            (default: :obj:`None`)
+        model (BaseModelBackend, optional): The model backend to use for
+            generating responses. (default: :obj:`OpenAIModel` with
+            `GPT_3_5_TURBO`)
     """
 
     def __init__(
         self,
-        model_type: Optional[ModelType] = None,
-        model_config: Optional[BaseConfig] = None,
+        model: Optional[BaseModelBackend] = None,
     ) -> None:
         system_message = BaseMessage(
             role_name="Insight Agent",
@@ -50,7 +48,7 @@ class DeductiveReasonerAgent(ChatAgent):
             meta_dict=None,
             content="You assign roles based on tasks.",
         )
-        super().__init__(system_message, model_type, model_config)
+        super().__init__(system_message, model=model)
 
     def deduce_conditions_and_quality(
         self,
@@ -90,52 +88,106 @@ class DeductiveReasonerAgent(ChatAgent):
         """
         self.reset()
 
-        deduce_prompt = """You are a deductive reasoner. You are tasked to complete the TASK based on the THOUGHT OF DEDUCTIVE REASONING, the STARTING STATE A and the TARGET STATE B. You are given the CONTEXT CONTENT to help you complete the TASK.
-Your answer MUST strictly adhere to the structure of ANSWER TEMPLATE, ONLY fill in the BLANKs, and DO NOT alter or modify any other part of the template
+        deduce_prompt = """You are a deductive reasoner. You are tasked to 
+        complete the TASK based on the THOUGHT OF DEDUCTIVE REASONING, the 
+        STARTING STATE A and the TARGET STATE B. You are given the CONTEXT 
+        CONTENT to help you complete the TASK.
+Your answer MUST strictly adhere to the structure of ANSWER TEMPLATE, ONLY 
+fill in the BLANKs, and DO NOT alter or modify any other part of the template
 
 ===== MODELING OF DEDUCTIVE REASONING =====
-You are tasked with understanding a mathematical model based on the components ${A, B, C, Q, L}$. In this model: ``L: A ⊕ C -> q * B``.
+You are tasked with understanding a mathematical model based on the components 
+${A, B, C, Q, L}$. In this model: ``L: A ⊕ C -> q * B``.
 - $A$ represents the known starting state.
 - $B$ represents the known target state.
 - $C$ represents the conditions required to transition from $A$ to $B$.
-- $Q$ represents the quality or effectiveness of the transition from $A$ to $B$.
+- $Q$ represents the quality or effectiveness of the transition from $A$ to 
+$B$.
 - $L$ represents the path or process from $A$ to $B$.
 
 ===== THOUGHT OF DEDUCTIVE REASONING =====
 1. Define the Parameters of A and B:
-    - Characterization: Before delving into transitions, thoroughly understand the nature and boundaries of both $A$ and $B$. This includes the type, properties, constraints, and possible interactions between the two.
-    - Contrast and Compare: Highlight the similarities and differences between $A$ and $B$. This comparative analysis will give an insight into what needs changing and what remains constant.
+    - Characterization: Before delving into transitions, thoroughly understand 
+    the nature and boundaries of both $A$ and $B$. This includes the type, 
+    properties, constraints, and possible interactions between the two.
+    - Contrast and Compare: Highlight the similarities and differences between 
+    $A$ and $B$. This comparative analysis will give an insight into what 
+    needs changing and what remains constant.
 2. Historical & Empirical Analysis:
-    - Previous Transitions according to the Knowledge Base of GPT: (if applicable) Extract conditions and patterns from the historical instances where a similar transition from a state comparable to $A$ moved towards $B$.
-    - Scientific Principles: (if applicable) Consider the underlying scientific principles governing or related to the states and their transition. For example, if $A$ and $B$ are physical states, laws of physics might apply.
+    - Previous Transitions according to the Knowledge Base of GPT: (if 
+    applicable) Extract conditions and patterns from the historical instances 
+    where a similar transition from a state comparable to $A$ moved towards 
+    $B$.
+    - Scientific Principles: (if applicable) Consider the underlying 
+    scientific principles governing or related to the states and their 
+    transition. For example, if $A$ and $B$ are physical states, laws of 
+    physics might apply.
 3. Logical Deduction of Conditions ($C$):
-    - Direct Path Analysis: What are the immediate and direct conditions required to move from $A$ to $B$?
-    - Intermediate States: Are there states between $A$ and $B$ that must be transversed or can be used to make the transition smoother or more efficient? If yes, what is the content?
-    - Constraints & Limitations: Identify potential barriers or restrictions in moving from $A$ to $B$. These can be external (e.g., environmental factors) or internal (properties of $A$ or $B$).
-    - Resource and Information Analysis: What resources and information are required for the transition? This could be time, entity, factor, code language, software platform, unknowns, etc.
-    - External Influences: Consider socio-economic, political, or environmental factors (if applicable) that could influence the transition conditions.
-    - Creative/Heuristic Reasoning: Open your mind to multiple possible $C$'s, no matter how unconventional they might seem. Utilize analogies, metaphors, or brainstorming techniques to envision possible conditions or paths from $A$ to $B$.
-    - The conditions $C$ should be multiple but in one sentence. And each condition should be concerned with one aspect/entity.
+    - Direct Path Analysis: What are the immediate and direct conditions 
+    required to move from $A$ to $B$?
+    - Intermediate States: Are there states between $A$ and $B$ that must be 
+    transversed or can be used to make the transition smoother or more 
+    efficient? If yes, what is the content?
+    - Constraints & Limitations: Identify potential barriers or restrictions 
+    in moving from $A$ to $B$. These can be external (e.g., environmental 
+    factors) or internal (properties of $A$ or $B$).
+    - Resource and Information Analysis: What resources and information are 
+    required for the transition? This could be time, entity, factor, code 
+    language, software platform, unknowns, etc.
+    - External Influences: Consider socio-economic, political, or 
+    environmental factors (if applicable) that could influence the transition 
+    conditions.
+    - Creative/Heuristic Reasoning: Open your mind to multiple possible $C$'s, 
+    no matter how unconventional they might seem. Utilize analogies, 
+    metaphors, or brainstorming techniques to envision possible conditions or 
+    paths from $A$ to $B$.
+    - The conditions $C$ should be multiple but in one sentence. And each 
+    condition should be concerned with one aspect/entity.
 4. Entity/Label Recognition of Conditions ($C$):
-    - Identify and categorize entities of Conditions ($C$) such as the names, locations, dates, specific technical terms or contextual parameters that might be associated with events, innovations post-2022.
-    - The output of the entities/labels will be used as tags or labels for semantic similarity searches. The entities/labels may be the words, or phrases, each of them should contain valuable, high information entropy information, and should be independent.
-    - Ensure that the identified entities are formatted in a manner suitable for database indexing and retrieval. Organize the entities into categories, and combine the category with its instance into a continuous phrase, without using colons or other separators.
-    - Format these entities for database indexing: output the category rather than its instance/content into a continuous phrase. For example, instead of "Jan. 02", identify it as "Event time".
+    - Identify and categorize entities of Conditions ($C$) such as the names, 
+    locations, dates, specific technical terms or contextual parameters that 
+    might be associated with events, innovations post-2022.
+    - The output of the entities/labels will be used as tags or labels for 
+    semantic similarity searches. The entities/labels may be the words, or 
+    phrases, each of them should contain valuable, high information entropy 
+    information, and should be independent.
+    - Ensure that the identified entities are formatted in a manner suitable 
+    for database indexing and retrieval. Organize the entities into 
+    categories, and combine the category with its instance into a continuous 
+    phrase, without using colons or other separators.
+    - Format these entities for database indexing: output the category rather 
+    than its instance/content into a continuous phrase. For example, instead 
+    of "Jan. 02", identify it as "Event time".
 5. Quality Assessment ($Q$):
-    - Efficiency: How efficient is the transition from $A$ to $B$, which measures the resources used versus the desired outcome?
-    - Effectiveness: Did the transition achieve the desired outcome or was the target state achieved as intended?
-    - Safety & Risks: Assess any risks associated with the transition and the measures to mitigate them.
-    - Feedback Mechanisms: Incorporate feedback loops to continuously monitor and adjust the quality of transition, making it more adaptive.
+    - Efficiency: How efficient is the transition from $A$ to $B$, which 
+    measures the resources used versus the desired outcome?
+    - Effectiveness: Did the transition achieve the desired outcome or was the 
+    target state achieved as intended?
+    - Safety & Risks: Assess any risks associated with the transition and the 
+    measures to mitigate them.
+    - Feedback Mechanisms: Incorporate feedback loops to continuously monitor 
+    and adjust the quality of transition, making it more adaptive.
 6. Iterative Evaluation:
-    - Test & Refine: Based on the initially deduced conditions and assessed quality, iterate the process to refine and optimize the transition. This might involve tweaking conditions, employing different paths, or changing resources.
-    - Feedback Integration: Use feedback to make improvements and increase the quality of the transition.
-7. Real-world scenarios often present challenges that may not be captured by models and frameworks. While using the model, maintain an adaptive mindset:
-    - Scenario Exploration: Continuously imagine various possible scenarios, both positive and negative, to prepare for unexpected events.
-    - Flexibility: Be prepared to modify conditions ($C$) or alter the path/process ($L$) if unforeseen challenges arise.
-    - Feedback Integration: Rapidly integrate feedback from actual implementations to adjust the model's application, ensuring relevancy and effectiveness.
+    - Test & Refine: Based on the initially deduced conditions and assessed 
+    quality, iterate the process to refine and optimize the transition. This 
+    might involve tweaking conditions, employing different paths, or changing 
+    resources.
+    - Feedback Integration: Use feedback to make improvements and increase the 
+    quality of the transition.
+7. Real-world scenarios often present challenges that may not be captured by 
+models and frameworks. While using the model, maintain an adaptive mindset:
+    - Scenario Exploration: Continuously imagine various possible scenarios, 
+    both positive and negative, to prepare for unexpected events.
+    - Flexibility: Be prepared to modify conditions ($C$) or alter the path/
+    process ($L$) if unforeseen challenges arise.
+    - Feedback Integration: Rapidly integrate feedback from actual 
+    implementations to adjust the model's application, ensuring relevancy and 
+    effectiveness.
 
 ===== TASK =====
-Given the starting state $A$ and the target state $B$, assuming that a path $L$ always exists between $A$ and $B$, how can one deduce or identify the necessary conditions $C$ and the quality $Q$ of the transition?
+Given the starting state $A$ and the target state $B$, assuming that a path 
+$L$ always exists between $A$ and $B$, how can one deduce or identify the 
+necessary conditions $C$ and the quality $Q$ of the transition?
 
 ===== STARTING STATE $A$ =====
 {starting_state}
@@ -150,7 +202,8 @@ Given the starting state $A$ and the target state $B$, assuming that a path $L$
 - Logical Deduction of Conditions ($C$) (multiple conditions can be deduced):
     condition <NUM>:
         <BLANK>.
-- Entity/Label Recognition of Conditions:\n[<BLANK>, <BLANK>, ...] (include square brackets)
+- Entity/Label Recognition of Conditions:\n[<BLANK>, <BLANK>, ...] (include 
+square brackets)
 - Quality Assessment ($Q$) (do not use symbols):
     <BLANK>.
 - Iterative Evaluation:\n<BLANK>/None"""