update example code wd

owl/camel/toolkits/search_toolkit.py

@@ -705,7 +705,7 @@ class SearchToolkit(BaseToolkit):
         search_agent = ChatAgent(
             "You are a helpful search agent.",
             model=self.model,
-            tools=[FunctionTool(self.search_wiki), FunctionTool(self.search_google), FunctionTool(self.search_archived_webpage)]
+            tools=[FunctionTool(self.search_duckduckgo),FunctionTool(self.search_wiki), FunctionTool(self.search_google), FunctionTool(self.search_archived_webpage)]
         )
 
         prompt = f"""

owl/camel/toolkits/web_toolkit.py

@@ -107,13 +107,25 @@ def _get_bool(d: Any, k: str) -> bool:
 
 def _parse_json_output(text: str) -> Dict[str, Any]:
     # judge if text is markdown format (```json ````)
-    if text.startswith("```json") and text.endswith("```"):
-        text = text.replace("```json", "").replace("```", "").strip()
+    if "```json" in text and "```" in text:
+        # Extract content between ```json and the last ```
+        start_idx = text.find("```json") + len("```json")
+        end_idx = text.rfind("```")
+        if start_idx > -1 and end_idx > start_idx:
+            text = text[start_idx:end_idx].strip()
+    
     try:
         return json.loads(text)
     except json.JSONDecodeError:
         logger.warning(f"Failed to parse JSON output: {text}")
-        return {}
+        # Try to clean the text further and attempt parsing again
+        try:
+            # Remove any extra whitespace or control characters
+            cleaned_text = text.strip()
+            return json.loads(cleaned_text)
+        except json.JSONDecodeError:
+            logger.error(f"Failed to parse JSON even after cleaning: {text}")
+            return {}
 
 
 def _reload_image(image: Image.Image):

owl/run.py

@@ -3,89 +3,123 @@ load_dotenv()
 
 from camel.models import ModelFactory
 from camel.toolkits import (
-    WebToolkit, 
-    DocumentProcessingToolkit, 
-    VideoAnalysisToolkit, 
-    AudioAnalysisToolkit, 
-    CodeExecutionToolkit, 
-    ImageAnalysisToolkit, 
+    AudioAnalysisToolkit,
+    CodeExecutionToolkit,
+    DocumentProcessingToolkit,
+    ExcelToolkit,
+    ImageAnalysisToolkit,
     SearchToolkit,
-    ExcelToolkit
-    )
+    VideoAnalysisToolkit,
+    WebToolkit,
+)
 from camel.types import ModelPlatformType, ModelType
-# from camel.configs import ChatGPTConfig
-
-
-from loguru import logger
 
 from utils import OwlRolePlaying, run_society
 
 
-
 def construct_society(question: str) -> OwlRolePlaying:
-    r"""Construct the society based on the question."""
-
-    user_role_name = "user"
-    assistant_role_name = "assistant"
+    r"""Construct a society of agents based on the given question.
     
-    user_model = ModelFactory.create(
-        model_platform=ModelPlatformType.OPENAI,
-        model_type=ModelType.GPT_4O,
-        # model_config_dict=ChatGPTConfig(temperature=0, top_p=1).as_dict(), # [Optional] the config for model
-    )
-
-    assistant_model = ModelFactory.create(
-        model_platform=ModelPlatformType.OPENAI,
-        model_type=ModelType.GPT_4O,
-        # model_config_dict=ChatGPTConfig(temperature=0, top_p=1).as_dict(), # [Optional] the config for model
-    )
-
-    tools_list = [
+    Args:
+        question (str): The task or question to be addressed by the society.
+        
+    Returns:
+        OwlRolePlaying: A configured society of agents ready to address the question.
+    """
+    
+    # Create models for different components
+    models = {
+        "user": ModelFactory.create(
+            model_platform=ModelPlatformType.OPENAI,
+            model_type=ModelType.GPT_4O,
+            model_config_dict={"temperature": 0},
+        ),
+        "assistant": ModelFactory.create(
+            model_platform=ModelPlatformType.OPENAI,
+            model_type=ModelType.GPT_4O,
+            model_config_dict={"temperature": 0},
+        ),
+        "web": ModelFactory.create(
+            model_platform=ModelPlatformType.OPENAI,
+            model_type=ModelType.GPT_4O,
+            model_config_dict={"temperature": 0},
+        ),
+        "planning": ModelFactory.create(
+            model_platform=ModelPlatformType.OPENAI,
+            model_type=ModelType.GPT_4O,
+            model_config_dict={"temperature": 0},
+        ),
+        "video": ModelFactory.create(
+            model_platform=ModelPlatformType.OPENAI,
+            model_type=ModelType.GPT_4O,
+            model_config_dict={"temperature": 0},
+        ),
+        "image": ModelFactory.create(
+            model_platform=ModelPlatformType.OPENAI,
+            model_type=ModelType.GPT_4O,
+            model_config_dict={"temperature": 0},
+        ),
+        "search": ModelFactory.create(
+            model_platform=ModelPlatformType.OPENAI,
+            model_type=ModelType.GPT_4O,
+            model_config_dict={"temperature": 0},
+        ),
+    }
+    
+    # Configure toolkits
+    tools = [
         *WebToolkit(
-            headless=False, # Set to True if you want to run in headless mode (e.g. on a remote server)
-            web_agent_model=assistant_model, 
-            planning_agent_model=assistant_model
+            headless=False,  # Set to True for headless mode (e.g., on remote servers)
+            web_agent_model=models["web"],
+            planning_agent_model=models["planning"],
         ).get_tools(),
         *DocumentProcessingToolkit().get_tools(),
-        *VideoAnalysisToolkit(model=assistant_model).get_tools(),  # This requires OpenAI Key
-        *AudioAnalysisToolkit().get_tools(),  # This requires OpenAI Key
+        *VideoAnalysisToolkit(model=models["video"]).get_tools(), # This requires OpenAI Key
+        *AudioAnalysisToolkit().get_tools(), # This requires OpenAI Key
         *CodeExecutionToolkit(sandbox="subprocess", verbose=True).get_tools(),
-        *ImageAnalysisToolkit(model=assistant_model).get_tools(),
-        *SearchToolkit(model=assistant_model).get_tools(),
-        *ExcelToolkit().get_tools()
+        *ImageAnalysisToolkit(model=models["image"]).get_tools(),
+        *SearchToolkit(model=models["search"]).get_tools(),
+        *ExcelToolkit().get_tools(),
     ]
-
-    user_role_name = 'user'
-    user_agent_kwargs = dict(model=user_model)
-    assistant_role_name = 'assistant'
-    assistant_agent_kwargs = dict(model=assistant_model,
-    tools=tools_list)
     
+    # Configure agent roles and parameters
+    user_agent_kwargs = {"model": models["user"]}
+    assistant_agent_kwargs = {"model": models["assistant"], "tools": tools}
+    
+    # Configure task parameters
     task_kwargs = {
-        'task_prompt': question,
-        'with_task_specify': False,
+        "task_prompt": question,
+        "with_task_specify": False,
     }
-
+    
+    # Create and return the society
     society = OwlRolePlaying(
         **task_kwargs,
-        user_role_name=user_role_name,
+        user_role_name="user",
         user_agent_kwargs=user_agent_kwargs,
-        assistant_role_name=assistant_role_name,
+        assistant_role_name="assistant",
         assistant_agent_kwargs=assistant_agent_kwargs,
     )
     
     return society
 
 
-# Example case
-question = "What was the volume in m^3 of the fish bag that was calculated in the University of Leicester paper `Can Hiccup Supply Enough Fish to Maintain a Dragon’s Diet?` "
-
-society = construct_society(question)
-answer, chat_history, token_count = run_society(society)
-
-logger.success(f"Answer: {answer}")
-
-
-
+def main():
+    r"""Main function to run the OWL system with an example question."""
+    # Example research question
+    question = (
+        "What was the volume in m^3 of the fish bag that was calculated in "
+        "the University of Leicester paper `Can Hiccup Supply Enough Fish "
+        "to Maintain a Dragon's Diet?`"
+    )
+    
+    # Construct and run the society
+    society = construct_society(question)
+    answer, chat_history, token_count = run_society(society)
+    
+    # Output the result
+    print(f"Answer: {answer}")
 
 
+if __name__ == "__main__":
+    main()

owl/run_deepseek.py

@@ -0,0 +1,121 @@
+from dotenv import load_dotenv
+load_dotenv()
+
+from camel.models import ModelFactory
+from camel.toolkits import (
+    CodeExecutionToolkit,
+    DocumentProcessingToolkit,
+    ExcelToolkit,
+    ImageAnalysisToolkit,
+    SearchToolkit,
+    WebToolkit,
+)
+from camel.types import ModelPlatformType, ModelType
+
+from utils import OwlRolePlaying, run_society
+
+
+def construct_society(question: str) -> OwlRolePlaying:
+    r"""Construct a society of agents based on the given question.
+    
+    Args:
+        question (str): The task or question to be addressed by the society.
+        
+    Returns:
+        OwlRolePlaying: A configured society of agents ready to address the question.
+    """
+    
+    # Create models for different components
+    models = {
+        "user": ModelFactory.create(
+            model_platform=ModelPlatformType.DEEPSEEK,
+            model_type=ModelType.DEEPSEEK_CHAT,
+            model_config_dict={"temperature": 0},
+        ),
+        "assistant": ModelFactory.create(
+            model_platform=ModelPlatformType.DEEPSEEK,
+            model_type=ModelType.DEEPSEEK_CHAT,
+            model_config_dict={"temperature": 0},
+        ),
+        "web": ModelFactory.create(
+            model_platform=ModelPlatformType.DEEPSEEK,
+            model_type=ModelType.DEEPSEEK_CHAT,
+            model_config_dict={"temperature": 0},
+        ),
+        "planning": ModelFactory.create(
+            model_platform=ModelPlatformType.DEEPSEEK,
+            model_type=ModelType.DEEPSEEK_CHAT,
+            model_config_dict={"temperature": 0},
+        ),
+        "video": ModelFactory.create(
+            model_platform=ModelPlatformType.DEEPSEEK,
+            model_type=ModelType.DEEPSEEK_CHAT,
+            model_config_dict={"temperature": 0},
+        ),
+        "image": ModelFactory.create(
+            model_platform=ModelPlatformType.DEEPSEEK,
+            model_type=ModelType.DEEPSEEK_CHAT,
+            model_config_dict={"temperature": 0},
+        ),
+        "search": ModelFactory.create(
+            model_platform=ModelPlatformType.DEEPSEEK,
+            model_type=ModelType.DEEPSEEK_CHAT,
+            model_config_dict={"temperature": 0},
+        ),
+    }
+    
+    # Configure toolkits
+    tools = [
+        *WebToolkit(
+            headless=False,  # Set to True for headless mode (e.g., on remote servers)
+            web_agent_model=models["web"],
+            planning_agent_model=models["planning"],
+        ).get_tools(),
+        *DocumentProcessingToolkit().get_tools(),
+        *CodeExecutionToolkit(sandbox="subprocess", verbose=True).get_tools(),
+        *ImageAnalysisToolkit(model=models["image"]).get_tools(),
+        *SearchToolkit(model=models["search"]).get_tools(),
+        *ExcelToolkit().get_tools(),
+    ]
+    
+    # Configure agent roles and parameters
+    user_agent_kwargs = {"model": models["user"]}
+    assistant_agent_kwargs = {"model": models["assistant"], "tools": tools}
+    
+    # Configure task parameters
+    task_kwargs = {
+        "task_prompt": question,
+        "with_task_specify": False,
+    }
+    
+    # Create and return the society
+    society = OwlRolePlaying(
+        **task_kwargs,
+        user_role_name="user",
+        user_agent_kwargs=user_agent_kwargs,
+        assistant_role_name="assistant",
+        assistant_agent_kwargs=assistant_agent_kwargs,
+    )
+    
+    return society
+
+
+def main():
+    r"""Main function to run the OWL system with an example question."""
+    # Example research question
+    question = (
+        "What was the volume in m^3 of the fish bag that was calculated in "
+        "the University of Leicester paper `Can Hiccup Supply Enough Fish "
+        "to Maintain a Dragon's Diet?`"
+    )
+    
+    # Construct and run the society
+    society = construct_society(question)
+    answer, chat_history, token_count = run_society(society)
+    
+    # Output the result
+    print(f"Answer: {answer}")
+
+
+if __name__ == "__main__":
+    main()

owl/run_deepseek_example.py

@@ -1,81 +0,0 @@
-from camel.models import ModelFactory
-from camel.toolkits import *
-from camel.types import ModelPlatformType, ModelType
-from camel.configs import DeepSeekConfig
-
-from dotenv import load_dotenv
-from loguru import logger
-
-from utils import OwlRolePlaying, run_society
-
-
-load_dotenv()
-
-
-def construct_society(question: str) -> OwlRolePlaying:
-    r"""Construct the society based on the question."""
-
-    user_role_name = "user"
-    assistant_role_name = "assistant"
-    
-    user_model = ModelFactory.create(
-        model_platform=ModelPlatformType.DEEPSEEK,
-        model_type=ModelType.DEEPSEEK_CHAT,
-        model_config_dict=DeepSeekConfig(temperature=0, top_p=1).as_dict(), # [Optional] the config for model
-    )
-
-    assistant_model = ModelFactory.create(
-        model_platform=ModelPlatformType.DEEPSEEK,
-        model_type=ModelType.DEEPSEEK_CHAT,
-        model_config_dict=DeepSeekConfig(temperature=0, top_p=1).as_dict(), # [Optional] the config for model
-    )
-
-    tools_list = [
-        *WebToolkit(
-            headless=False,  # Set to True if you want to run in headless mode (e.g. on a remote server)
-            web_agent_model=assistant_model, 
-            planning_agent_model=assistant_model
-        ).get_tools(),
-        *DocumentProcessingToolkit().get_tools(),
-        # *VideoAnalysisToolkit().get_tools(),  # This requires OpenAI and Qwen Key
-        *CodeExecutionToolkit(sandbox="subprocess", verbose=True).get_tools(),
-        *ImageAnalysisToolkit(model=assistant_model).get_tools(),
-        # *AudioAnalysisToolkit().get_tools(),  # This requires OpenAI Key
-        *SearchToolkit(model=assistant_model).get_tools(),
-        *ExcelToolkit().get_tools()
-    ]
-
-    user_role_name = 'user'
-    user_agent_kwargs = dict(model=user_model)
-    assistant_role_name = 'assistant'
-    assistant_agent_kwargs = dict(model=assistant_model,
-    tools=tools_list)
-    
-    task_kwargs = {
-        'task_prompt': question,
-        'with_task_specify': False,
-    }
-
-    society = OwlRolePlaying(
-        **task_kwargs,
-        user_role_name=user_role_name,
-        user_agent_kwargs=user_agent_kwargs,
-        assistant_role_name=assistant_role_name,
-        assistant_agent_kwargs=assistant_agent_kwargs,
-    )
-    
-    return society
-
-
-# Example case
-question = "What was the volume in m^3 of the fish bag that was calculated in the University of Leicester paper `Can Hiccup Supply Enough Fish to Maintain a Dragon’s Diet?` "
-
-society = construct_society(question)
-answer, chat_history, token_count = run_society(society)
-
-logger.success(f"Answer: {answer}")
-
-
-
-
-

owl/run_gaia_roleplaying.py

@@ -1,80 +1,120 @@
-from camel.models import ModelFactory
-from camel.toolkits import *
-from camel.types import ModelPlatformType, ModelType
-from camel.configs import ChatGPTConfig
-from utils import GAIABenchmark
-
 from dotenv import load_dotenv
-from loguru import logger
+load_dotenv()
 
 import os
+from loguru import logger
 
-load_dotenv()
+from camel.models import ModelFactory
+from camel.toolkits import (
+    AudioAnalysisToolkit,
+    CodeExecutionToolkit,
+    DocumentProcessingToolkit,
+    ExcelToolkit,
+    ImageAnalysisToolkit,
+    SearchToolkit,
+    VideoAnalysisToolkit,
+    WebToolkit,
+)
+from camel.types import ModelPlatformType, ModelType
+from camel.configs import ChatGPTConfig
+
+from utils import GAIABenchmark
 
 
+# Configuration
 LEVEL = 1
 SAVE_RESULT = True
 test_idx = [0]
 
 
 def main():
-
+    """Main function to run the GAIA benchmark."""
+    # Create cache directory
     cache_dir = "tmp/"
     os.makedirs(cache_dir, exist_ok=True)
 
-    user_model = ModelFactory.create(
-        model_platform=ModelPlatformType.OPENAI,
-        model_type=ModelType.GPT_4O,
-        model_config_dict=ChatGPTConfig(temperature=0, top_p=1).as_dict(), # [Optional] the config for model
-    )
-
-    assistant_model = ModelFactory.create(
-        model_platform=ModelPlatformType.OPENAI,
-        model_type=ModelType.GPT_4O,
-        model_config_dict=ChatGPTConfig(temperature=0, top_p=1).as_dict(), # [Optional] the config for model
-    )
-
-    tools_list = [
+    # Create models for different components
+    models = {
+        "user": ModelFactory.create(
+            model_platform=ModelPlatformType.OPENAI,
+            model_type=ModelType.GPT_4O,
+            model_config_dict=ChatGPTConfig(temperature=0, top_p=1).as_dict(),
+        ),
+        "assistant": ModelFactory.create(
+            model_platform=ModelPlatformType.OPENAI,
+            model_type=ModelType.GPT_4O,
+            model_config_dict=ChatGPTConfig(temperature=0, top_p=1).as_dict(),
+        ),
+        "web": ModelFactory.create(
+            model_platform=ModelPlatformType.OPENAI,
+            model_type=ModelType.GPT_4O,
+            model_config_dict=ChatGPTConfig(temperature=0, top_p=1).as_dict(),
+        ),
+        "planning": ModelFactory.create(
+            model_platform=ModelPlatformType.OPENAI,
+            model_type=ModelType.GPT_4O,
+            model_config_dict=ChatGPTConfig(temperature=0, top_p=1).as_dict(),
+        ),
+        "video": ModelFactory.create(
+            model_platform=ModelPlatformType.OPENAI,
+            model_type=ModelType.GPT_4O,
+            model_config_dict=ChatGPTConfig(temperature=0, top_p=1).as_dict(),
+        ),
+        "image": ModelFactory.create(
+            model_platform=ModelPlatformType.OPENAI,
+            model_type=ModelType.GPT_4O,
+            model_config_dict=ChatGPTConfig(temperature=0, top_p=1).as_dict(),
+        ),
+        "search": ModelFactory.create(
+            model_platform=ModelPlatformType.OPENAI,
+            model_type=ModelType.GPT_4O,
+            model_config_dict=ChatGPTConfig(temperature=0, top_p=1).as_dict(),
+        ),
+    }
+    
+    # Configure toolkits
+    tools = [
         *WebToolkit(
-            headless=False, # Set to True if you want to run in headless mode (e.g. on a remote server)
-            web_agent_model=assistant_model, 
-            planning_agent_model=assistant_model
+            headless=False,  # Set to True for headless mode (e.g., on remote servers)
+            web_agent_model=models["web"],
+            planning_agent_model=models["planning"],
         ).get_tools(),
         *DocumentProcessingToolkit().get_tools(),
-        *VideoAnalysisToolkit(model=assistant_model).get_tools(),  # This requires OpenAI Key
+        *VideoAnalysisToolkit(model=models["video"]).get_tools(),  # This requires OpenAI Key
         *AudioAnalysisToolkit().get_tools(),  # This requires OpenAI Key
         *CodeExecutionToolkit(sandbox="subprocess", verbose=True).get_tools(),
-        *ImageAnalysisToolkit(model=assistant_model).get_tools(),
-        *SearchToolkit(model=assistant_model).get_tools(),
-        *ExcelToolkit().get_tools()
+        *ImageAnalysisToolkit(model=models["image"]).get_tools(),
+        *SearchToolkit(model=models["search"]).get_tools(),
+        *ExcelToolkit().get_tools(),
     ]
+    
+    # Configure agent roles and parameters
+    user_agent_kwargs = {"model": models["user"]}
+    assistant_agent_kwargs = {"model": models["assistant"], "tools": tools}
 
-    user_role_name = 'user'
-    user_agent_kwargs = dict(model=user_model)
-    assistant_role_name = 'assistant'
-    assistant_agent_kwargs = dict(model=assistant_model,
-    tools=tools_list)
-
+    # Initialize benchmark
     benchmark = GAIABenchmark(
         data_dir="data/gaia",
         save_to=f"results/result.json"
     )
 
+    # Print benchmark information
     print(f"Number of validation examples: {len(benchmark.valid)}")
     print(f"Number of test examples: {len(benchmark.test)}")
 
+    # Run benchmark
     result = benchmark.run(
         on="valid", 
         level=LEVEL, 
         idx=test_idx,
         save_result=SAVE_RESULT,
-
-        user_role_name=user_role_name,
+        user_role_name="user",
         user_agent_kwargs=user_agent_kwargs,
-        assistant_role_name=assistant_role_name,
+        assistant_role_name="assistant",
         assistant_agent_kwargs=assistant_agent_kwargs,
-        )
+    )
 
+    # Output results
     logger.success(f"Correct: {result['correct']}, Total: {result['total']}")
     logger.success(f"Accuracy: {result['accuracy']}")
 

owl/run_mini.py

@@ -3,75 +3,101 @@ load_dotenv()
 
 from camel.models import ModelFactory
 from camel.toolkits import (
-    WebToolkit, 
     SearchToolkit,
-    FunctionTool
-    )
+    WebToolkit,
+)
 from camel.types import ModelPlatformType, ModelType
 
-
-from loguru import logger
-
 from utils import OwlRolePlaying, run_society
 
 
-
 def construct_society(question: str) -> OwlRolePlaying:
-    r"""Construct the society based on the question."""
-
-    user_role_name = "user"
-    assistant_role_name = "assistant"
+    r"""Construct a society of agents based on the given question.
     
-    user_model = ModelFactory.create(
-        model_platform=ModelPlatformType.OPENAI,
-        model_type=ModelType.GPT_4O,
-    )
-
-    assistant_model = ModelFactory.create(
-        model_platform=ModelPlatformType.OPENAI,
-        model_type=ModelType.GPT_4O,
-    )
-
-    tools_list = [
+    Args:
+        question (str): The task or question to be addressed by the society.
+        
+    Returns:
+        OwlRolePlaying: A configured society of agents ready to address the question.
+    """
+    
+    # Create models for different components
+    models = {
+        "user": ModelFactory.create(
+            model_platform=ModelPlatformType.OPENAI,
+            model_type=ModelType.GPT_4O,
+            model_config_dict={"temperature": 0},
+        ),
+        "assistant": ModelFactory.create(
+            model_platform=ModelPlatformType.OPENAI,
+            model_type=ModelType.GPT_4O,
+            model_config_dict={"temperature": 0},
+        ),
+        "web": ModelFactory.create(
+            model_platform=ModelPlatformType.OPENAI,
+            model_type=ModelType.GPT_4O,
+            model_config_dict={"temperature": 0},
+        ),
+        "planning": ModelFactory.create(
+            model_platform=ModelPlatformType.OPENAI,
+            model_type=ModelType.GPT_4O,
+            model_config_dict={"temperature": 0},
+        ),
+        "search": ModelFactory.create(
+            model_platform=ModelPlatformType.OPENAI,
+            model_type=ModelType.GPT_4O,
+            model_config_dict={"temperature": 0},
+        ),
+    }
+    
+    # Configure toolkits
+    tools = [
         *WebToolkit(
-            headless=False, 
-            web_agent_model=assistant_model, 
-            planning_agent_model=assistant_model
+            headless=False,  # Set to True for headless mode (e.g., on remote servers)
+            web_agent_model=models["web"],
+            planning_agent_model=models["planning"],
         ).get_tools(),
-        FunctionTool(SearchToolkit(model=assistant_model).search_duckduckgo),
+        *SearchToolkit(model=models["search"]).get_tools(),
     ]
-
-    user_role_name = 'user'
-    user_agent_kwargs = dict(model=user_model)
-    assistant_role_name = 'assistant'
-    assistant_agent_kwargs = dict(model=assistant_model,
-    tools=tools_list)
     
+    # Configure agent roles and parameters
+    user_agent_kwargs = {"model": models["user"]}
+    assistant_agent_kwargs = {"model": models["assistant"], "tools": tools}
+    
+    # Configure task parameters
     task_kwargs = {
-        'task_prompt': question,
-        'with_task_specify': False,
+        "task_prompt": question,
+        "with_task_specify": False,
     }
-
+    
+    # Create and return the society
     society = OwlRolePlaying(
         **task_kwargs,
-        user_role_name=user_role_name,
+        user_role_name="user",
         user_agent_kwargs=user_agent_kwargs,
-        assistant_role_name=assistant_role_name,
+        assistant_role_name="assistant",
         assistant_agent_kwargs=assistant_agent_kwargs,
     )
     
     return society
 
 
-# Example case
-question = "What was the volume in m^3 of the fish bag that was calculated in the University of Leicester paper `Can Hiccup Supply Enough Fish to Maintain a Dragon’s Diet?` "
-
-society = construct_society(question)
-answer, chat_history, token_count = run_society(society)
-
-logger.success(f"Answer: {answer}")
-
-
-
+def main():
+    r"""Main function to run the OWL system with an example question."""
+    # Example research question
+    question = (
+        "What was the volume in m^3 of the fish bag that was calculated in "
+        "the University of Leicester paper `Can Hiccup Supply Enough Fish "
+        "to Maintain a Dragon's Diet?`"
+    )
+    
+    # Construct and run the society
+    society = construct_society(question)
+    answer, chat_history, token_count = run_society(society)
+    
+    # Output the result
+    print(f"Answer: {answer}")
 
 
+if __name__ == "__main__":
+    main()

owl/run_openai_compatiable_model.py

@@ -1,92 +1,129 @@
-
 from dotenv import load_dotenv
 load_dotenv()
 
+import os
 from camel.models import ModelFactory
-from camel.toolkits import *
+from camel.toolkits import (
+    CodeExecutionToolkit,
+    DocumentProcessingToolkit,
+    ExcelToolkit,
+    ImageAnalysisToolkit,
+    SearchToolkit,
+    WebToolkit,
+)
 from camel.types import ModelPlatformType, ModelType
-from camel.configs import ChatGPTConfig
-
-from typing import List, Dict
-
-from retry import retry
-from loguru import logger
 
 from utils import OwlRolePlaying, run_society
-import os
-
-
 
 
 def construct_society(question: str) -> OwlRolePlaying:
-    r"""Construct the society based on the question."""
-
-    user_role_name = "user"
-    assistant_role_name = "assistant"
+    r"""Construct a society of agents based on the given question.
     
-    user_model = ModelFactory.create(
-        model_platform=ModelPlatformType.OPENAI_COMPATIBLE_MODEL,
-        model_type="qwen-max",
-        api_key=os.getenv("QWEN_API_KEY"),
-        url="https://dashscope.aliyuncs.com/compatible-mode/v1",
-        model_config_dict={"temperature": 0.4, "max_tokens": 4096},
-    )
-
-    assistant_model = ModelFactory.create(
-        model_platform=ModelPlatformType.OPENAI_COMPATIBLE_MODEL,
-        model_type="qwen-max",
-        api_key=os.getenv("QWEN_API_KEY"),
-        url="https://dashscope.aliyuncs.com/compatible-mode/v1",
-        model_config_dict={"temperature": 0.4, "max_tokens": 4096},
-    )
-
-
-    tools_list = [
+    Args:
+        question (str): The task or question to be addressed by the society.
+        
+    Returns:
+        OwlRolePlaying: A configured society of agents ready to address the question.
+    """
+    
+    # Create models for different components
+    models = {
+        "user": ModelFactory.create(
+            model_platform=ModelPlatformType.OPENAI_COMPATIBLE_MODEL,
+            model_type="qwen-max",
+            api_key=os.getenv("QWEN_API_KEY"),
+            url="https://dashscope.aliyuncs.com/compatible-mode/v1",
+            model_config_dict={"temperature": 0.4, "max_tokens": 4096},
+        ),
+        "assistant": ModelFactory.create(
+            model_platform=ModelPlatformType.OPENAI_COMPATIBLE_MODEL,
+            model_type="qwen-max",
+            api_key=os.getenv("QWEN_API_KEY"),
+            url="https://dashscope.aliyuncs.com/compatible-mode/v1",
+            model_config_dict={"temperature": 0.4, "max_tokens": 4096},
+        ),
+        "web": ModelFactory.create(
+            model_platform=ModelPlatformType.OPENAI_COMPATIBLE_MODEL,
+            model_type="qwen-max",
+            api_key=os.getenv("QWEN_API_KEY"),
+            url="https://dashscope.aliyuncs.com/compatible-mode/v1",
+            model_config_dict={"temperature": 0.4, "max_tokens": 4096},
+        ),
+        "planning": ModelFactory.create(
+            model_platform=ModelPlatformType.OPENAI_COMPATIBLE_MODEL,
+            model_type="qwen-max",
+            api_key=os.getenv("QWEN_API_KEY"),
+            url="https://dashscope.aliyuncs.com/compatible-mode/v1",
+            model_config_dict={"temperature": 0.4, "max_tokens": 4096},
+        ),
+        "image": ModelFactory.create(
+            model_platform=ModelPlatformType.OPENAI_COMPATIBLE_MODEL,
+            model_type="qwen-max",
+            api_key=os.getenv("QWEN_API_KEY"),
+            url="https://dashscope.aliyuncs.com/compatible-mode/v1",
+            model_config_dict={"temperature": 0.4, "max_tokens": 4096},
+        ),
+        "search": ModelFactory.create(
+            model_platform=ModelPlatformType.OPENAI_COMPATIBLE_MODEL,
+            model_type="qwen-max",
+            api_key=os.getenv("QWEN_API_KEY"),
+            url="https://dashscope.aliyuncs.com/compatible-mode/v1",
+            model_config_dict={"temperature": 0.4, "max_tokens": 4096},
+        ),
+    }
+    
+    # Configure toolkits
+    tools = [
         *WebToolkit(
-            headless=False,  # Set to True if you want to run in headless mode (e.g. on a remote server)
-            web_agent_model=assistant_model, 
-            planning_agent_model=assistant_model
+            headless=False,  # Set to True for headless mode (e.g., on remote servers)
+            web_agent_model=models["web"],
+            planning_agent_model=models["planning"],
         ).get_tools(),
         *DocumentProcessingToolkit().get_tools(),
-        # *VideoAnalysisToolkit(model=assistant_model).get_tools(),  # This requires OpenAI Key
-        # *AudioAnalysisToolkit().get_tools(),  # This requires OpenAI Key
-        *CodeExecutionToolkit().get_tools(),
-        *ImageAnalysisToolkit(model=assistant_model).get_tools(),
-        *SearchToolkit(model=assistant_model).get_tools(),
-        *ExcelToolkit().get_tools()
+        *CodeExecutionToolkit(sandbox="subprocess", verbose=True).get_tools(),
+        *ImageAnalysisToolkit(model=models["image"]).get_tools(),
+        *SearchToolkit(model=models["search"]).get_tools(),
+        *ExcelToolkit().get_tools(),
     ]
-
-    user_role_name = 'user'
-    user_agent_kwargs = dict(model=user_model)
-    assistant_role_name = 'assistant'
-    assistant_agent_kwargs = dict(model=assistant_model,
-    tools=tools_list)
     
+    # Configure agent roles and parameters
+    user_agent_kwargs = {"model": models["user"]}
+    assistant_agent_kwargs = {"model": models["assistant"], "tools": tools}
+    
+    # Configure task parameters
     task_kwargs = {
-        'task_prompt': question,
-        'with_task_specify': False,
+        "task_prompt": question,
+        "with_task_specify": False,
     }
-
+    
+    # Create and return the society
     society = OwlRolePlaying(
         **task_kwargs,
-        user_role_name=user_role_name,
+        user_role_name="user",
         user_agent_kwargs=user_agent_kwargs,
-        assistant_role_name=assistant_role_name,
+        assistant_role_name="assistant",
         assistant_agent_kwargs=assistant_agent_kwargs,
     )
     
     return society
 
 
-# Example case
-question = "what is the weather in beijing today?"
-
-society = construct_society(question)
-answer, chat_history, token_count = run_society(society)
-
-logger.success(f"Answer: {answer}")
-
-
-
+def main():
+    r"""Main function to run the OWL system with an example question."""
+    # Example research question
+    question = (
+        "What was the volume in m^3 of the fish bag that was calculated in "
+        "the University of Leicester paper `Can Hiccup Supply Enough Fish "
+        "to Maintain a Dragon's Diet?`"
+    )
+    
+    # Construct and run the society
+    society = construct_society(question)
+    answer, chat_history, token_count = run_society(society)
+    
+    # Output the result
+    print(f"Answer: {answer}")
 
 
+if __name__ == "__main__":
+    main()

owl/run_qwen.py

@@ -0,0 +1,121 @@
+from dotenv import load_dotenv
+load_dotenv()
+
+from camel.models import ModelFactory
+from camel.toolkits import (
+    CodeExecutionToolkit,
+    DocumentProcessingToolkit,
+    ExcelToolkit,
+    ImageAnalysisToolkit,
+    SearchToolkit,
+    WebToolkit,
+)
+from camel.types import ModelPlatformType, ModelType
+
+from utils import OwlRolePlaying, run_society
+
+
+def construct_society(question: str) -> OwlRolePlaying:
+    r"""Construct a society of agents based on the given question.
+    
+    Args:
+        question (str): The task or question to be addressed by the society.
+        
+    Returns:
+        OwlRolePlaying: A configured society of agents ready to address the question.
+    """
+    
+    # Create models for different components
+    models = {
+        "user": ModelFactory.create(
+            model_platform=ModelPlatformType.QWEN,
+            model_type=ModelType.QWEN_MAX,
+            model_config_dict={"temperature": 0},
+        ),
+        "assistant": ModelFactory.create(
+            model_platform=ModelPlatformType.QWEN,
+            model_type=ModelType.QWEN_MAX,
+            model_config_dict={"temperature": 0},
+        ),
+        "web": ModelFactory.create(
+            model_platform=ModelPlatformType.QWEN,
+            model_type=ModelType.QWEN_MAX,
+            model_config_dict={"temperature": 0},
+        ),
+        "planning": ModelFactory.create(
+            model_platform=ModelPlatformType.QWEN,
+            model_type=ModelType.QWEN_MAX,
+            model_config_dict={"temperature": 0},
+        ),
+        "video": ModelFactory.create(
+            model_platform=ModelPlatformType.QWEN,
+            model_type=ModelType.QWEN_MAX,
+            model_config_dict={"temperature": 0},
+        ),
+        "image": ModelFactory.create(
+            model_platform=ModelPlatformType.QWEN,
+            model_type=ModelType.QWEN_MAX,
+            model_config_dict={"temperature": 0},
+        ),
+        "search": ModelFactory.create(
+            model_platform=ModelPlatformType.QWEN,
+            model_type=ModelType.QWEN_MAX,
+            model_config_dict={"temperature": 0},
+        ),
+    }
+    
+    # Configure toolkits
+    tools = [
+        *WebToolkit(
+            headless=False,  # Set to True for headless mode (e.g., on remote servers)
+            web_agent_model=models["web"],
+            planning_agent_model=models["planning"],
+        ).get_tools(),
+        *DocumentProcessingToolkit().get_tools(),
+        *CodeExecutionToolkit(sandbox="subprocess", verbose=True).get_tools(),
+        *ImageAnalysisToolkit(model=models["image"]).get_tools(),
+        *SearchToolkit(model=models["search"]).get_tools(),
+        *ExcelToolkit().get_tools(),
+    ]
+    
+    # Configure agent roles and parameters
+    user_agent_kwargs = {"model": models["user"]}
+    assistant_agent_kwargs = {"model": models["assistant"], "tools": tools}
+    
+    # Configure task parameters
+    task_kwargs = {
+        "task_prompt": question,
+        "with_task_specify": False,
+    }
+    
+    # Create and return the society
+    society = OwlRolePlaying(
+        **task_kwargs,
+        user_role_name="user",
+        user_agent_kwargs=user_agent_kwargs,
+        assistant_role_name="assistant",
+        assistant_agent_kwargs=assistant_agent_kwargs,
+    )
+    
+    return society
+
+
+def main():
+    r"""Main function to run the OWL system with an example question."""
+    # Example research question
+    question = (
+        "What was the volume in m^3 of the fish bag that was calculated in "
+        "the University of Leicester paper `Can Hiccup Supply Enough Fish "
+        "to Maintain a Dragon's Diet?`"
+    )
+    
+    # Construct and run the society
+    society = construct_society(question)
+    answer, chat_history, token_count = run_society(society)
+    
+    # Output the result
+    print(f"Answer: {answer}")
+
+
+if __name__ == "__main__":
+    main()