opentools-->octotools; added remaining tools; polished the ui

.gitignore

@@ -0,0 +1,177 @@
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+# *.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# [Octotools] 
+octotools.egg-info/
+locals/
+results/
+logs/
+*.zip
+*.pt
+cache/
+tool_cache/
+detected_objects/
+
+# [Gradio]
+demo_solver_cache/

README.md

@@ -15,3 +15,10 @@ pinned: false
 - https://www.gradio.app/guides/agents-and-tool-usage
 
 - Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+
+### Example
+
+```
+How many baseballs are there?
+```

app.py

@@ -16,17 +16,12 @@ current_dir = os.path.dirname(os.path.abspath(__file__))
 project_root = os.path.dirname(os.path.dirname(os.path.dirname(current_dir)))
 sys.path.insert(0, project_root)
 
-from opentools.models.initializer import Initializer
-from opentools.models.planner import Planner
-from opentools.models.memory import Memory
-from opentools.models.executor import Executor
-from opentools.models.utils import make_json_serializable
-
-# class ChatMessage:
-#     def __init__(self, role: str, content: str, metadata: dict = None):
-#         self.role = role
-#         self.content = content
-#         self.metadata = metadata or {}
+from octotools.models.initializer import Initializer
+from octotools.models.planner import Planner
+from octotools.models.memory import Memory
+from octotools.models.executor import Executor
+from octotools.models.utils import make_json_serializable
+
 
 class Solver:
     def __init__(
@@ -59,9 +54,6 @@ class Solver:
         self.output_types = output_types.lower().split(',')
         assert all(output_type in ["base", "final", "direct"] for output_type in self.output_types), "Invalid output type. Supported types are 'base', 'final', 'direct'."
 
-        # self.benchmark_data = self.load_benchmark_data()
-
-
 
     def stream_solve_user_problem(self, user_query: str, user_image: Image.Image, api_key: str, messages: List[ChatMessage]) -> Iterator[List[ChatMessage]]:
         """
@@ -189,8 +181,9 @@ class Solver:
         messages.append(ChatMessage(role="assistant", content="✅ Problem-solving process complete."))
         yield messages
             
+
 def parse_arguments():
-    parser = argparse.ArgumentParser(description="Run the OpenTools demo with specified parameters.")
+    parser = argparse.ArgumentParser(description="Run the OctoTools demo with specified parameters.")
     parser.add_argument("--llm_engine_name", default="gpt-4o", help="LLM engine name.")
     parser.add_argument("--max_tokens", type=int, default=2000, help="Maximum tokens for LLM generation.")
     parser.add_argument("--run_baseline_only", type=bool, default=False, help="Run only the baseline (no toolbox).")
@@ -215,7 +208,7 @@ def solve_problem_gradio(user_query, user_image, max_steps=10, max_time=60, api_
     """
 
     if api_key is None:
-        return [["assistant", "⚠️ Error: API Key is required."]]
+        return [["assistant", "⚠️ Error: OpenAI API Key is required."]]
     
     # Initialize Tools
     enabled_tools = args.enabled_tools.split(",") if args.enabled_tools else []
@@ -271,16 +264,16 @@ def solve_problem_gradio(user_query, user_image, max_steps=10, max_time=60, api_
 
 
 def main(args):
-    # ========== Gradio Interface ==========
+    #################### Gradio Interface ####################
     with gr.Blocks() as demo:
-        gr.Markdown("# 🧠 OctoTools AI Solver")  # Title
+        gr.Markdown("# 🧠 The OctoTools Agentic Solver")  # Title
 
         with gr.Row():
             with gr.Column(scale=1):
                 api_key = gr.Textbox(show_label=False, placeholder="Your API key will not be stored in any way.", type="password", container=False)
                 user_image = gr.Image(type="pil", label="Upload an image")  # Accepts multiple formats
-                max_steps = gr.Slider(value=5, minimum=1, maximum=10, step=1)
-                max_time = gr.Slider(value=180, minimum=60, maximum=300, step=20)
+                max_steps = gr.Slider(value=5, minimum=1, maximum=10, step=1, label="Max Steps")
+                max_time = gr.Slider(value=150, minimum=60, maximum=300, step=30, label="Max Time (seconds)")
             with gr.Column(scale=3):
                 chatbot_output = gr.Chatbot(type="messages", label="Problem-Solving Output")
                 # chatbot_output.like(lambda x: print(f"User liked: {x}"))
@@ -296,13 +289,38 @@ def main(args):
 
         # Link button click to function
         run_button.click(fn=solve_problem_gradio, inputs=[user_query, user_image, max_steps, max_time, api_key], outputs=chatbot_output)
-    # ========== Gradio Interface ==========
+    #################### Gradio Interface ####################
 
     # Launch the Gradio app
     demo.launch()
 
 
-
 if __name__ == "__main__":
     args = parse_arguments()
-    main(args)
+
+    # Manually set enabled tools
+    # args.enabled_tools = "Generalist_Solution_Generator_Tool"
+
+
+    # All tools
+    all_tools = [
+        "Generalist_Solution_Generator_Tool",
+
+        "Image_Captioner_Tool",
+        "Object_Detector_Tool",
+        "Text_Detector_Tool",
+        "Relevant_Patch_Zoomer_Tool",
+
+        "Python_Code_Generator_Tool",
+
+        "ArXiv_Paper_Searcher_Tool",
+        "Google_Search_Tool",
+        "Nature_News_Fetcher_Tool",
+        "Pubmed_Search_Tool",
+        "URL_Text_Extractor_Tool",
+        "Wikipedia_Knowledge_Searcher_Tool"
+    ]
+    args.enabled_tools = ",".join(all_tools)
+
+    main(args)
+

app_bak_0215.py

@@ -0,0 +1,307 @@
+import os
+import sys
+import json
+import argparse
+import time
+import io
+import uuid
+from PIL import Image
+from typing import List, Dict, Any, Iterator
+import gradio as gr
+
+# Add the project root to the Python path
+current_dir = os.path.dirname(os.path.abspath(__file__))
+project_root = os.path.dirname(os.path.dirname(os.path.dirname(current_dir)))
+sys.path.insert(0, project_root)
+
+from opentools.models.initializer import Initializer
+from opentools.models.planner import Planner
+from opentools.models.memory import Memory
+from opentools.models.executor import Executor
+from opentools.models.utlis import make_json_serializable
+
+solver = None
+
+class ChatMessage:
+    def __init__(self, role: str, content: str, metadata: dict = None):
+        self.role = role
+        self.content = content
+        self.metadata = metadata or {}
+
+class Solver:
+    def __init__(
+        self,
+        planner,
+        memory,
+        executor,
+        task: str,
+        task_description: str,
+        output_types: str = "base,final,direct",
+        index: int = 0,
+        verbose: bool = True,
+        max_steps: int = 10,
+        max_time: int = 60,
+        output_json_dir: str = "results",
+        root_cache_dir: str = "cache"
+    ):
+        self.planner = planner
+        self.memory = memory
+        self.executor = executor
+        self.task = task
+        self.task_description = task_description
+        self.index = index
+        self.verbose = verbose
+        self.max_steps = max_steps
+        self.max_time = max_time
+        self.output_json_dir = output_json_dir
+        self.root_cache_dir = root_cache_dir
+
+        self.output_types = output_types.lower().split(',')
+        assert all(output_type in ["base", "final", "direct"] for output_type in self.output_types), "Invalid output type. Supported types are 'base', 'final', 'direct'."
+
+        # self.benchmark_data = self.load_benchmark_data()
+
+
+
+    def stream_solve_user_problem(self, user_query: str, user_image: Image.Image, messages: List[ChatMessage]) -> Iterator[List[ChatMessage]]:
+        """
+        Streams intermediate thoughts and final responses for the problem-solving process based on user input.
+        
+        Args:
+            user_query (str): The text query input from the user.
+            user_image (Image.Image): The uploaded image from the user (PIL Image object).
+            messages (list): A list of ChatMessage objects to store the streamed responses.
+        """
+
+        if user_image:
+            # # Convert PIL Image to bytes (for processing)
+            # img_bytes_io = io.BytesIO()
+            # user_image.save(img_bytes_io, format="PNG")  # Convert image to PNG bytes
+            # img_bytes = img_bytes_io.getvalue()  # Get bytes
+            
+            # Use image paths instead of bytes,
+            os.makedirs(os.path.join(self.root_cache_dir, 'images'), exist_ok=True)
+            img_path = os.path.join(self.root_cache_dir, 'images', str(uuid.uuid4()) + '.jpg')
+            user_image.save(img_path)
+        else:
+            img_path = None
+
+        # Set query cache
+        _cache_dir = os.path.join(self.root_cache_dir)
+        self.executor.set_query_cache_dir(_cache_dir)
+        
+        # Step 1: Display the received inputs
+        if user_image:
+            messages.append(ChatMessage(role="assistant", content=f"📝 Received Query: {user_query}\n🖼️ Image Uploaded"))
+        else:
+            messages.append(ChatMessage(role="assistant", content=f"📝 Received Query: {user_query}"))
+        yield messages
+
+        # Step 2: Add "thinking" status while processing
+        messages.append(ChatMessage(
+            role="assistant",
+            content="",
+            metadata={"title": "⏳ Thinking: Processing input..."}
+        ))
+
+        # Step 3: Initialize problem-solving state
+        start_time = time.time()
+        step_count = 0
+        json_data = {"query": user_query, "image": "Image received as bytes"}
+
+        # Step 4: Query Analysis
+        query_analysis = self.planner.analyze_query(user_query, img_path)
+        json_data["query_analysis"] = query_analysis
+        messages.append(ChatMessage(role="assistant", content=f"🔍 Query Analysis:\n{query_analysis}"))
+        yield messages
+
+        # Step 5: Execution loop (similar to your step-by-step solver)
+        while step_count < self.max_steps and (time.time() - start_time) < self.max_time:
+            step_count += 1
+            messages.append(ChatMessage(role="assistant", content=f"🔄 Step {step_count}: Generating next step..."))
+            yield messages
+
+            # Generate the next step
+            next_step = self.planner.generate_next_step(
+                user_query, img_path, query_analysis, self.memory, step_count, self.max_steps
+            )
+            context, sub_goal, tool_name = self.planner.extract_context_subgoal_and_tool(next_step)
+
+            # Display the step information
+            messages.append(ChatMessage(
+                role="assistant",
+                content=f"📌 Step {step_count} Details:\n- Context: {context}\n- Sub-goal: {sub_goal}\n- Tool: {tool_name}"
+            ))
+            yield messages
+
+            # Handle tool execution or errors
+            if tool_name not in self.planner.available_tools:
+                messages.append(ChatMessage(role="assistant", content=f"⚠️ Error: Tool '{tool_name}' is not available."))
+                yield messages
+                continue
+
+            # Execute the tool command
+            tool_command = self.executor.generate_tool_command(
+                user_query, img_path, context, sub_goal, tool_name, self.planner.toolbox_metadata[tool_name]
+            )
+            explanation, command = self.executor.extract_explanation_and_command(tool_command)
+            result = self.executor.execute_tool_command(tool_name, command)
+            result = make_json_serializable(result)
+
+            messages.append(ChatMessage(role="assistant", content=f"✅ Step {step_count} Result:\n{json.dumps(result, indent=4)}"))
+            yield messages
+
+            # Step 6: Memory update and stopping condition
+            self.memory.add_action(step_count, tool_name, sub_goal, tool_command, result)
+            stop_verification = self.planner.verificate_memory(user_query, img_path, query_analysis, self.memory)
+            conclusion = self.planner.extract_conclusion(stop_verification)
+
+            messages.append(ChatMessage(role="assistant", content=f"🛑 Step {step_count} Conclusion: {conclusion}"))
+            yield messages
+
+            if conclusion == 'STOP':
+                break
+
+        # Step 7: Generate Final Output (if needed)
+        if 'final' in self.output_types:
+            final_output = self.planner.generate_final_output(user_query, img_path, self.memory)
+            messages.append(ChatMessage(role="assistant", content=f"🎯 Final Output:\n{final_output}"))
+            yield messages
+
+        if 'direct' in self.output_types:
+            direct_output = self.planner.generate_direct_output(user_query, img_path, self.memory)
+            messages.append(ChatMessage(role="assistant", content=f"🔹 Direct Output:\n{direct_output}"))
+            yield messages
+
+        # Step 8: Completion Message
+        messages.append(ChatMessage(role="assistant", content="✅ Problem-solving process complete."))
+        yield messages
+            
+def parse_arguments():
+    parser = argparse.ArgumentParser(description="Run the OpenTools demo with specified parameters.")
+    parser.add_argument("--llm_engine_name", default="gpt-4o", help="LLM engine name.")
+    parser.add_argument("--max_tokens", type=int, default=2000, help="Maximum tokens for LLM generation.")
+    parser.add_argument("--run_baseline_only", type=bool, default=False, help="Run only the baseline (no toolbox).")
+    parser.add_argument("--task", default="minitoolbench", help="Task to run.")
+    parser.add_argument("--task_description", default="", help="Task description.")
+    parser.add_argument(
+        "--output_types",
+        default="base,final,direct",
+        help="Comma-separated list of required outputs (base,final,direct)"
+    )
+    parser.add_argument("--enabled_tools", default="Generalist_Solution_Generator_Tool", help="List of enabled tools.")
+    parser.add_argument("--root_cache_dir", default="demo_solver_cache", help="Path to solver cache directory.")
+    parser.add_argument("--output_json_dir", default="demo_results", help="Path to output JSON directory.")
+    parser.add_argument("--max_steps", type=int, default=10, help="Maximum number of steps to execute.")
+    parser.add_argument("--max_time", type=int, default=60, help="Maximum time allowed in seconds.")
+    parser.add_argument("--verbose", type=bool, default=True, help="Enable verbose output.")
+    return parser.parse_args()
+
+
+def solve_problem_gradio(user_query, user_image):
+    """
+    Wrapper function to connect the solver to Gradio.
+    Streams responses from `solver.stream_solve_user_problem` for real-time UI updates.
+    """
+    global solver  # Ensure we're using the globally defined solver
+
+    if solver is None:
+        return [["assistant", "⚠️ Error: Solver is not initialized. Please restart the application."]]
+
+    messages = []  # Initialize message list
+    for message_batch in solver.stream_solve_user_problem(user_query, user_image, messages):
+        yield [[msg.role, msg.content] for msg in message_batch]  # Ensure correct format for Gradio Chatbot
+
+
+
+def main(args):
+    global solver
+    # Initialize Tools
+    enabled_tools = args.enabled_tools.split(",") if args.enabled_tools else []
+
+
+    # Instantiate Initializer
+    initializer = Initializer(
+        enabled_tools=enabled_tools,
+        model_string=args.llm_engine_name
+    )
+
+    # Instantiate Planner
+    planner = Planner(
+        llm_engine_name=args.llm_engine_name,
+        toolbox_metadata=initializer.toolbox_metadata,
+        available_tools=initializer.available_tools
+    )
+
+    # Instantiate Memory
+    memory = Memory()
+
+    # Instantiate Executor
+    executor = Executor(
+        llm_engine_name=args.llm_engine_name,
+        root_cache_dir=args.root_cache_dir,
+        enable_signal=False
+    )
+
+    # Instantiate Solver
+    solver = Solver(
+        planner=planner,
+        memory=memory,
+        executor=executor,
+        task=args.task,
+        task_description=args.task_description,
+        output_types=args.output_types,  # Add new parameter
+        verbose=args.verbose,
+        max_steps=args.max_steps,
+        max_time=args.max_time,
+        output_json_dir=args.output_json_dir,
+        root_cache_dir=args.root_cache_dir
+    )
+
+    # Test Inputs
+    # user_query = "How many balls are there in the image?"
+    # user_image_path = "/home/sheng/toolbox-agent/mathvista_113.png"  # Replace with your actual image path
+
+    # # Load the image as a PIL object
+    # user_image = Image.open(user_image_path).convert("RGB")  # Ensure it's in RGB mode
+
+    # print("\n=== Starting Problem Solving ===\n")
+    # messages = []
+    # for message_batch in solver.stream_solve_user_problem(user_query, user_image, messages):
+    #     for message in message_batch:
+    #         print(f"{message.role}: {message.content}") 
+
+    # messages = []
+    # solver.stream_solve_user_problem(user_query, user_image, messages)
+
+
+    # def solve_problem_stream(user_query, user_image):
+    #     messages = []  # Ensure it's a list of [role, content] pairs
+
+    #     for message_batch in solver.stream_solve_user_problem(user_query, user_image, messages):
+    #         yield message_batch  # Stream messages correctly in tuple format
+
+    # solve_problem_stream(user_query, user_image)
+
+    # ========== Gradio Interface ==========
+    with gr.Blocks() as demo:
+        gr.Markdown("# 🧠 OctoTools AI Solver")  # Title
+
+        with gr.Row():
+            user_query = gr.Textbox(label="Enter your query", placeholder="Type your question here...")
+            user_image = gr.Image(type="pil", label="Upload an image")  # Accepts multiple formats
+
+        run_button = gr.Button("Run")  # Run button
+        chatbot_output = gr.Chatbot(label="Problem-Solving Output")
+
+        # Link button click to function
+        run_button.click(fn=solve_problem_gradio, inputs=[user_query, user_image], outputs=chatbot_output)
+
+    # Launch the Gradio app
+    demo.launch()
+
+
+
+if __name__ == "__main__":
+    args = parse_arguments()
+    main(args)

{opentools → octotools}/engine/openai.py

@@ -51,9 +51,9 @@ class ChatOpenAI(EngineLM, CachedEngine):
         :param is_multimodal:
         """
         if enable_cache:
-            root = platformdirs.user_cache_dir("opentools")
+            root = platformdirs.user_cache_dir("octotools")
             cache_path = os.path.join(root, f"cache_openai_{model_string}.db")
-            # For example, cache_path = /root/.cache/opentools/cache_openai_gpt-4o-mini.db
+            # For example, cache_path = /root/.cache/octotools/cache_openai_gpt-4o-mini.db
             # print(f"Cache path: {cache_path}")
             
             self.image_cache_dir = os.path.join(root, "image_cache")

{opentools → octotools}/models/executor.py

@@ -5,8 +5,8 @@ import re
 from typing import Dict, Any, List
 from datetime import datetime
 
-from opentools.engine.openai import ChatOpenAI 
-from opentools.models.formatters import ToolCommand
+from octotools.engine.openai import ChatOpenAI 
+from octotools.models.formatters import ToolCommand
 
 import signal
 from typing import Dict, Any, List, Optional

{opentools → octotools}/models/initializer.py

@@ -14,7 +14,7 @@ class Initializer:
         self.model_string = model_string # llm model string
         self.api_key = api_key
 
-        print("\nInitializing OpenTools...")
+        print("\nInitializing OctoTools...")
         print(f"Enabled tools: {self.enabled_tools}")
         print(f"LLM model string: {self.model_string}")
         self._set_up_tools()
@@ -22,8 +22,8 @@ class Initializer:
     def get_project_root(self):
         current_dir = os.path.dirname(os.path.abspath(__file__))
         while current_dir != '/':
-            if os.path.exists(os.path.join(current_dir, 'opentools')):
-                return os.path.join(current_dir, 'opentools')
+            if os.path.exists(os.path.join(current_dir, 'octotools')):
+                return os.path.join(current_dir, 'octotools')
             current_dir = os.path.dirname(current_dir)
         raise Exception("Could not find project root")
         
@@ -31,15 +31,15 @@ class Initializer:
         # Implementation of load_tools_and_get_metadata function
         print("Loading tools and getting metadata...")
         self.toolbox_metadata = {}
-        opentools_dir = self.get_project_root()
-        tools_dir = os.path.join(opentools_dir, 'tools')
+        octotools_dir = self.get_project_root()
+        tools_dir = os.path.join(octotools_dir, 'tools')
         
-        print(f"OpenTools directory: {opentools_dir}")
+        print(f"OctoTools directory: {octotools_dir}")
         print(f"Tools directory: {tools_dir}")
         
-        # Add the OpenTools directory and its parent to the Python path
-        sys.path.insert(0, opentools_dir)
-        sys.path.insert(0, os.path.dirname(opentools_dir))
+        # Add the OctoTools directory and its parent to the Python path
+        sys.path.insert(0, octotools_dir)
+        sys.path.insert(0, os.path.dirname(octotools_dir))
         print(f"Updated Python path: {sys.path}")
         
         if not os.path.exists(tools_dir):
@@ -52,7 +52,7 @@ class Initializer:
                 file = 'tool.py'
                 module_path = os.path.join(root, file)
                 module_name = os.path.splitext(file)[0]
-                relative_path = os.path.relpath(module_path, opentools_dir)
+                relative_path = os.path.relpath(module_path, octotools_dir)
                 import_path = '.'.join(os.path.split(relative_path)).replace(os.sep, '.')[:-3]
 
                 print(f"\nAttempting to import: {import_path}")

{opentools → octotools}/models/planner.py

@@ -4,9 +4,9 @@ from PIL import Image
 from io import BytesIO
 from typing import Dict, Any, List, Tuple
 
-from opentools.engine.openai import ChatOpenAI
-from opentools.models.memory import Memory
-from opentools.models.formatters import QueryAnalysis, NextStep, MemoryVerification
+from octotools.engine.openai import ChatOpenAI
+from octotools.models.memory import Memory
+from octotools.models.formatters import QueryAnalysis, NextStep, MemoryVerification
 
 class Planner:
     def __init__(self, llm_engine_name: str, toolbox_metadata: dict = None, available_tools: List = None, api_key: str = None):

{opentools → octotools}/tools/README.md

@@ -8,7 +8,7 @@ To test the text detection tool, follow these steps:
    Change your current directory to where the tools are located. Replace `your_path` with the actual path to your project directory.
 
    ```sh
-   cd your_path/toolbox-agent/opentools
+   cd your_path/toolbox-agent/octotools
    ```
 
 2. **Run the Text Detection Tool:**

octotools/tools/advanced_object_detector/test.log

@@ -0,0 +1,366 @@
+{'code': 0, 'msg': 'ok', 'data': {'task_uuid': '2d4337f5-403d-419b-9832-64b0f888f146'}}
+task_uuid:2d4337f5-403d-419b-9832-64b0f888f146
+[
+    {
+        "label": "baseball",
+        "confidence score": 0.73,
+        "box": [
+            614,
+            137,
+            671,
+            191
+        ],
+        "saved_image_path": "detected_objects/baseball_baseball_1.png"
+    },
+    {
+        "label": "baseball",
+        "confidence score": 0.73,
+        "box": [
+            114,
+            377,
+            171,
+            431
+        ],
+        "saved_image_path": "detected_objects/baseball_baseball_2.png"
+    },
+    {
+        "label": "baseball",
+        "confidence score": 0.72,
+        "box": [
+            632,
+            67,
+            689,
+            126
+        ],
+        "saved_image_path": "detected_objects/baseball_baseball_3.png"
+    },
+    {
+        "label": "baseball",
+        "confidence score": 0.72,
+        "box": [
+            132,
+            67,
+            189,
+            126
+        ],
+        "saved_image_path": "detected_objects/baseball_baseball_4.png"
+    },
+    {
+        "label": "baseball",
+        "confidence score": 0.71,
+        "box": [
+            382,
+            67,
+            439,
+            126
+        ],
+        "saved_image_path": "detected_objects/baseball_baseball_5.png"
+    },
+    {
+        "label": "baseball",
+        "confidence score": 0.71,
+        "box": [
+            364,
+            137,
+            421,
+            191
+        ],
+        "saved_image_path": "detected_objects/baseball_baseball_6.png"
+    },
+    {
+        "label": "baseball",
+        "confidence score": 0.71,
+        "box": [
+            132,
+            307,
+            189,
+            366
+        ],
+        "saved_image_path": "detected_objects/baseball_baseball_7.png"
+    },
+    {
+        "label": "baseball",
+        "confidence score": 0.71,
+        "box": [
+            114,
+            136,
+            171,
+            191
+        ],
+        "saved_image_path": "detected_objects/baseball_baseball_8.png"
+    },
+    {
+        "label": "baseball",
+        "confidence score": 0.7,
+        "box": [
+            57,
+            49,
+            115,
+            107
+        ],
+        "saved_image_path": "detected_objects/baseball_baseball_9.png"
+    },
+    {
+        "label": "baseball",
+        "confidence score": 0.69,
+        "box": [
+            307,
+            49,
+            365,
+            106
+        ],
+        "saved_image_path": "detected_objects/baseball_baseball_10.png"
+    },
+    {
+        "label": "baseball",
+        "confidence score": 0.68,
+        "box": [
+            57,
+            289,
+            115,
+            346
+        ],
+        "saved_image_path": "detected_objects/baseball_baseball_11.png"
+    },
+    {
+        "label": "baseball",
+        "confidence score": 0.68,
+        "box": [
+            86,
+            335,
+            143,
+            393
+        ],
+        "saved_image_path": "detected_objects/baseball_baseball_12.png"
+    },
+    {
+        "label": "baseball",
+        "confidence score": 0.68,
+        "box": [
+            557,
+            49,
+            615,
+            107
+        ],
+        "saved_image_path": "detected_objects/baseball_baseball_13.png"
+    },
+    {
+        "label": "baseball",
+        "confidence score": 0.68,
+        "box": [
+            35,
+            352,
+            92,
+            410
+        ],
+        "saved_image_path": "detected_objects/baseball_baseball_14.png"
+    },
+    {
+        "label": "baseball",
+        "confidence score": 0.68,
+        "box": [
+            86,
+            95,
+            143,
+            153
+        ],
+        "saved_image_path": "detected_objects/baseball_baseball_15.png"
+    },
+    {
+        "label": "baseball",
+        "confidence score": 0.67,
+        "box": [
+            586,
+            95,
+            643,
+            153
+        ],
+        "saved_image_path": "detected_objects/baseball_baseball_16.png"
+    },
+    {
+        "label": "baseball",
+        "confidence score": 0.66,
+        "box": [
+            285,
+            111,
+            342,
+            169
+        ],
+        "saved_image_path": "detected_objects/baseball_baseball_17.png"
+    },
+    {
+        "label": "baseball",
+        "confidence score": 0.66,
+        "box": [
+            35,
+            111,
+            91,
+            170
+        ],
+        "saved_image_path": "detected_objects/baseball_baseball_18.png"
+    },
+    {
+        "label": "baseball",
+        "confidence score": 0.66,
+        "box": [
+            535,
+            111,
+            592,
+            169
+        ],
+        "saved_image_path": "detected_objects/baseball_baseball_19.png"
+    },
+    {
+        "label": "baseball",
+        "confidence score": 0.66,
+        "box": [
+            337,
+            95,
+            393,
+            153
+        ],
+        "saved_image_path": "detected_objects/baseball_baseball_20.png"
+    },
+    {
+        "label": "basket",
+        "confidence score": 0.41,
+        "box": [
+            1,
+            2,
+            218,
+            216
+        ],
+        "saved_image_path": "detected_objects/baseball_basket_1.png"
+    },
+    {
+        "label": "basket",
+        "confidence score": 0.39,
+        "box": [
+            501,
+            2,
+            718,
+            216
+        ],
+        "saved_image_path": "detected_objects/baseball_basket_2.png"
+    },
+    {
+        "label": "basket",
+        "confidence score": 0.38,
+        "box": [
+            2,
+            242,
+            218,
+            456
+        ],
+        "saved_image_path": "detected_objects/baseball_basket_3.png"
+    },
+    {
+        "label": "basket",
+        "confidence score": 0.38,
+        "box": [
+            251,
+            2,
+            468,
+            216
+        ],
+        "saved_image_path": "detected_objects/baseball_basket_4.png"
+    }
+]
+Detected Objects:
+Detected baseball with confidence 0.73
+Bounding box: [614, 137, 671, 191]
+Saved image (with padding): detected_objects/baseball_baseball_1.png
+
+Detected baseball with confidence 0.73
+Bounding box: [114, 377, 171, 431]
+Saved image (with padding): detected_objects/baseball_baseball_2.png
+
+Detected baseball with confidence 0.72
+Bounding box: [632, 67, 689, 126]
+Saved image (with padding): detected_objects/baseball_baseball_3.png
+
+Detected baseball with confidence 0.72
+Bounding box: [132, 67, 189, 126]
+Saved image (with padding): detected_objects/baseball_baseball_4.png
+
+Detected baseball with confidence 0.71
+Bounding box: [382, 67, 439, 126]
+Saved image (with padding): detected_objects/baseball_baseball_5.png
+
+Detected baseball with confidence 0.71
+Bounding box: [364, 137, 421, 191]
+Saved image (with padding): detected_objects/baseball_baseball_6.png
+
+Detected baseball with confidence 0.71
+Bounding box: [132, 307, 189, 366]
+Saved image (with padding): detected_objects/baseball_baseball_7.png
+
+Detected baseball with confidence 0.71
+Bounding box: [114, 136, 171, 191]
+Saved image (with padding): detected_objects/baseball_baseball_8.png
+
+Detected baseball with confidence 0.7
+Bounding box: [57, 49, 115, 107]
+Saved image (with padding): detected_objects/baseball_baseball_9.png
+
+Detected baseball with confidence 0.69
+Bounding box: [307, 49, 365, 106]
+Saved image (with padding): detected_objects/baseball_baseball_10.png
+
+Detected baseball with confidence 0.68
+Bounding box: [57, 289, 115, 346]
+Saved image (with padding): detected_objects/baseball_baseball_11.png
+
+Detected baseball with confidence 0.68
+Bounding box: [86, 335, 143, 393]
+Saved image (with padding): detected_objects/baseball_baseball_12.png
+
+Detected baseball with confidence 0.68
+Bounding box: [557, 49, 615, 107]
+Saved image (with padding): detected_objects/baseball_baseball_13.png
+
+Detected baseball with confidence 0.68
+Bounding box: [35, 352, 92, 410]
+Saved image (with padding): detected_objects/baseball_baseball_14.png
+
+Detected baseball with confidence 0.68
+Bounding box: [86, 95, 143, 153]
+Saved image (with padding): detected_objects/baseball_baseball_15.png
+
+Detected baseball with confidence 0.67
+Bounding box: [586, 95, 643, 153]
+Saved image (with padding): detected_objects/baseball_baseball_16.png
+
+Detected baseball with confidence 0.66
+Bounding box: [285, 111, 342, 169]
+Saved image (with padding): detected_objects/baseball_baseball_17.png
+
+Detected baseball with confidence 0.66
+Bounding box: [35, 111, 91, 170]
+Saved image (with padding): detected_objects/baseball_baseball_18.png
+
+Detected baseball with confidence 0.66
+Bounding box: [535, 111, 592, 169]
+Saved image (with padding): detected_objects/baseball_baseball_19.png
+
+Detected baseball with confidence 0.66
+Bounding box: [337, 95, 393, 153]
+Saved image (with padding): detected_objects/baseball_baseball_20.png
+
+Detected basket with confidence 0.41
+Bounding box: [1, 2, 218, 216]
+Saved image (with padding): detected_objects/baseball_basket_1.png
+
+Detected basket with confidence 0.39
+Bounding box: [501, 2, 718, 216]
+Saved image (with padding): detected_objects/baseball_basket_2.png
+
+Detected basket with confidence 0.38
+Bounding box: [2, 242, 218, 456]
+Saved image (with padding): detected_objects/baseball_basket_3.png
+
+Detected basket with confidence 0.38
+Bounding box: [251, 2, 468, 216]
+Saved image (with padding): detected_objects/baseball_basket_4.png
+
+Done!

octotools/tools/advanced_object_detector/tool.py

@@ -0,0 +1,236 @@
+# Grounding DINO Object Detection Tool
+# https://huggingface.co/IDEA-Research/grounding-dino
+
+import os
+import time
+
+from octotools.tools.base import BaseTool
+from PIL import Image, ImageOps
+
+import os
+# Suppress stderr by redirecting it to /dev/null
+import sys
+import re
+import base64
+import requests
+sys.stderr = open(os.devnull, 'w')
+
+
+class Advanced_Object_Detector_Tool(BaseTool):
+    def __init__(self):
+        super().__init__(
+            tool_name="Advanced_Object_Detector_Tool",
+            tool_description="A tool that detects objects in an image using the Grounding DINO-X model and saves individual object images with empty padding.",
+            tool_version="1.0.0",
+            input_types={
+                "image": "str - The path to the image file.",
+                "labels": "list - A list of object labels to detect.",
+                "threshold": "float - The confidence threshold for detection (default: 0.35).",
+                "padding": "int - The number of pixels to add as empty padding around detected objects (default: 20)."
+            },
+            output_type="list - A list of detected objects with their scores, bounding boxes, and saved image paths.",
+            demo_commands=[
+                {
+                    "command": 'execution = tool.execute(image="path/to/image.png", labels=["baseball", "basket"])',
+                    "description": "Detect baseball and basket in an image, save the detected objects with default empty padding, and return their paths."
+                },
+                {
+                    "command": 'execution = tool.execute(image="path/to/image.png", labels=["car", "person"], threshold=0.5, model_size="base", padding=15)',
+                    "description": "Detect car and person in an image using the base model, save the detected objects with 15 pixels of empty padding, and return their paths."
+                }
+            ],
+            user_metadata={
+                "limitation": "The model may not always detect objects accurately, and its performance can vary depending on the input image and the associated labels. It typically struggles with detecting small objects, objects that are uncommon, or objects with limited or specific attributes. For improved accuracy or better detection in certain situations, consider using supplementary tools or image processing techniques to provide additional information for verification."
+            }
+        )
+        self.DINO_KEY = os.environ.get("DINO_KEY")
+
+    def preprocess_caption(self, caption):
+        result = caption.lower().strip()
+        if result.endswith("."):
+            return result
+        return result + "."
+
+    def build_tool(self, threshold=0.35):
+
+        params_dict = {
+                        'headers': {
+                                    "Content-Type": "application/json",
+                                    "Token"       : self.DINO_KEY
+                                    },
+                        'body':{
+                                    "image"  : None,
+                                    "prompts": [
+                                        {"type": "text", "text": None},
+                                    ],
+                                    "bbox_threshold": threshold 
+                                }
+
+                      }
+        return params_dict
+
+
+    def save_detected_object(self, image, box, image_name, label, index, padding):
+        object_image = image.crop(box)
+        padded_image = ImageOps.expand(object_image, border=padding, fill='white')
+        
+        filename = f"{image_name}_{label}_{index}.png"
+        os.makedirs(self.output_dir, exist_ok=True)
+        save_path = os.path.join(self.output_dir, filename)
+        
+        padded_image.save(save_path)
+        return save_path
+
+    def execute(self, image, labels, threshold=0.35, padding=20, max_retries=10, retry_delay=5):
+        retry_count = 0
+        params = self.build_tool(threshold)
+
+        def process_image(input_str):
+
+            def image_to_base64(image_path):
+                with open(image_path, "rb") as image_file:
+                    return base64.b64encode(image_file.read()).decode('utf-8')
+            # Define common image file extensions
+            image_extensions = {'.jpg', '.jpeg', '.png', '.gif', '.bmp', '.svg', '.tiff', '.webp'}
+
+            # Check if it is a URL
+            url_pattern = re.compile(r'^(http|https|ftp)://')
+            if url_pattern.match(input_str):
+                if input_str.lower().endswith(tuple(image_extensions)):
+                    return input_str
+                return input_str
+
+            # Check if it is a file path
+            _, ext = os.path.splitext(input_str)
+            if ext.lower() in image_extensions:
+                image_base64 = image_to_base64(input_str)
+                return f'data:image/png;base64,{image_base64}'
+            return None
+
+        if len(labels) < 1:
+            preprocessed_prompt = '<prompt_free>'
+        else:
+            preprocessed_prompt = ''
+            for label in labels:
+                preprocessed_prompt += self.preprocess_caption(label)
+
+
+        body = params['body']
+        body['image'] = process_image(image)
+        body['prompts'] =  [{"type": "text", "text": preprocessed_prompt}]
+
+        # send request
+        resp = requests.post(
+            'https://api.deepdataspace.com/tasks/dinox',
+            json=body,
+            headers=params['headers']
+        )
+
+        if resp.status_code == 200:
+            json_resp = resp.json()
+            print(json_resp)
+
+            # get task_uuid
+            task_uuid = json_resp["data"]["task_uuid"]
+            print(f'task_uuid:{task_uuid}')
+
+            # poll get task result
+            while retry_count < max_retries:
+                resp = requests.get(f'https://api.deepdataspace.com/task_statuses/{task_uuid}', headers=params['headers'])
+                
+
+                if resp.status_code != 200:
+                    break
+                json_resp = resp.json()
+
+                if json_resp["data"]["status"] not in ["waiting", "running"]:
+                    break
+                time.sleep(1)#retry_delay)
+                retry_count += 1
+
+            if json_resp["data"]["status"] == "failed":
+                print(f'failed resp: {json_resp}')
+            elif json_resp["data"]["status"] == "success":
+                # print(f'success resp: {json_resp}')
+                formatted_results = []
+                original_image = Image.open(image)
+                image_name = os.path.splitext(os.path.basename(image))[0]
+                
+                object_counts = {}
+
+                for result in json_resp['data']['result']['objects']:
+                    box = tuple(result["bbox"])
+                    try:
+                        box = [int(x) for x in box]
+                    except:
+                        continue
+                    label = result["category"]
+                    score = round(result["score"], 2)
+                    if label.endswith("."):
+                        label = label[:-1]
+                    
+                    object_counts[label] = object_counts.get(label, 0) + 1
+                    index = object_counts[label]
+
+                    save_path = self.save_detected_object(original_image, box, image_name, label, index, padding)
+            
+                    formatted_results.append({
+                        "label": label,
+                        "confidence score": score,
+                        "box": box,
+                        "saved_image_path": save_path
+                    })
+
+                return formatted_results
+            else:
+                print(f'get task resp: {resp.status_code} - {resp.text}')
+        else:
+            print(f'Error: {resp.status_code} - {resp.text}')
+        
+        print(f"Failed to detect objects after {max_retries} attempts.")
+        return []
+
+    def get_metadata(self):
+        metadata = super().get_metadata()
+        return metadata
+
+if __name__ == "__main__":
+    # Test command:
+    """
+    Run the following commands in the terminal to test the script:
+    
+    cd octotools/tools/advanced_object_detector
+    python tool.py
+    """
+
+    # Get the directory of the current script
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+
+    # Example usage of the Object_Detector_Tool
+    tool = Advanced_Object_Detector_Tool()
+    tool.set_custom_output_dir("detected_objects")
+
+    # Get tool metadata
+    metadata = tool.get_metadata()
+    # print(metadata)
+
+    # Construct the full path to the image using the script's directory
+    relative_image_path = "examples/baseball.png"
+    image_path = os.path.join(script_dir, relative_image_path)
+
+    import json
+
+    # Execute the tool
+    try:
+        execution = tool.execute(image=image_path, labels=["baseball", "basket"], padding=20)
+        print(json.dumps(execution, indent=4))
+        print("Detected Objects:")
+        for obj in execution:
+            print(f"Detected {obj['label']} with confidence {obj['confidence score']}")
+            print(f"Bounding box: {obj['box']}")
+            print(f"Saved image (with padding): {obj['saved_image_path']}")
+            print()
+    except ValueError as e: 
+        print(f"Execution failed: {e}")
+
+    print("Done!")

octotools/tools/arxiv_paper_searcher/test.log

@@ -0,0 +1,120 @@
+ArXiv Search Tool Test
+Tool Metadata:
+{'tool_name': 'ArXiv_Paper_Searcher_Tool', 'tool_description': 'A tool that searches arXiv for papers based on a given query.', 'tool_version': '1.0.0', 'input_types': {'query': 'str - The search query for arXiv papers.', 'size': 'int - The number of results per page (25, 50, 100, or 200). If None, use 25.', 'max_results': 'int - The maximum number of papers to return (default: 25). Should be less than or equal to 100.'}, 'output_type': 'list - A list of dictionaries containing paper information.', 'demo_commands': [{'command': 'execution = tool.execute(query="tool agents with large language models")', 'description': 'Search for papers about tool agents with large language models.'}, {'command': 'execution = tool.execute(query="quantum computing", size=100, max_results=50)', 'description': 'Search for quantum computing papers, with 100 results per page, returning a maximum of 50 papers.'}, {'command': 'execution = tool.execute(query="machine learning", max_results=75)', 'description': 'Search for machine learning papers, returning a maximum of 75 papers.'}], 'require_llm_engine': False, 'user_metadata': {'valid_sizes': [25, 50, 100, 200], 'base_url': 'https://arxiv.org/search/'}}
+
+==>> Execution:
+[
+    {
+        "title": "Position: Multimodal Large Language Models Can Significantly Advance Scientific Reasoning",
+        "authors": "Yibo Yan, Shen Wang, Jiahao Huo, Jingheng Ye, Zhendong Chu, Xuming Hu, Philip S. Yu, Carla Gomes, Bart Selman, Qingsong Wen",
+        "abstract": "Scientific reasoning, the process through which humans apply logic, evidence, and critical thinking to explore and interpret scientific phenomena, is essential in advancing knowledge reasoning across diverse fields. However, despite significant progress, current scientific reasoning models still struggle with generalization across domains and often fall short of multimodal perception. Multimodal Large Language Models (MLLMs), which integrate text, images, and other modalities, present an exciting opportunity to overcome these limitations and enhance scientific reasoning. Therefore, this position paper argues that MLLMs can significantly advance scientific reasoning across disciplines such as mathematics, physics, chemistry, and biology. First, we propose a four-stage research roadmap of scientific reasoning capabilities, and highlight the current state of MLLM applications in scientific reasoning, noting their ability to integrate and reason over diverse data types. Second, we summarize the key challenges that remain obstacles to achieving MLLM's full potential. To address these challenges, we propose actionable insights and suggestions for the future. Overall, our work offers a novel perspective on MLLM integration with scientific reasoning, providing the LLM community with a valuable vision for achieving Artificial General Intelligence (AGI).",
+        "link": "https://arxiv.org/abs/2502.02871"
+    },
+    {
+        "title": "Adaptive Graph of Thoughts: Test-Time Adaptive Reasoning Unifying Chain, Tree, and Graph Structures",
+        "authors": "Tushar Pandey, Ara Ghukasyan, Oktay Goktas, Santosh Kumar Radha",
+        "abstract": "Large Language Models (LLMs) have demonstrated impressive reasoning capabilities, yet their performance is highly dependent on the prompting strategy and model scale. While reinforcement learning and fine-tuning have been deployed to boost reasoning, these approaches incur substantial computational and data overhead. In this work, we introduce Adaptive Graph of Thoughts (AGoT), a dynamic, graph-based inference framework that enhances LLM reasoning solely at test time. Rather than relying on fixed-step methods like Chain of Thought (CoT) or Tree of Thoughts (ToT), AGoT recursively decomposes complex queries into structured subproblems, forming an dynamic directed acyclic graph (DAG) of interdependent reasoning steps. By selectively expanding only those subproblems that require further analysis, AGoT unifies the strengths of chain, tree, and graph paradigms into a cohesive framework that allocates computation where it is most needed. We validate our approach on diverse benchmarks spanning multi-hop retrieval, scientific reasoning, and mathematical problem-solving, achieving up to 46.2% improvement on scientific reasoning tasks (GPQA) - comparable to gains achieved through computationally intensive reinforcement learning approaches and outperforming state-of-the-art iterative approaches. These results suggest that dynamic decomposition and structured recursion offer a scalable, cost-effective alternative to post-training modifications, paving the way for more robust, general-purpose reasoning in LLMs.",
+        "link": "https://arxiv.org/abs/2502.05078"
+    },
+    {
+        "title": "VersaPRM: Multi-Domain Process Reward Model via Synthetic Reasoning Data",
+        "authors": "Thomas Zeng, Shuibai Zhang, Shutong Wu, Christian Classen, Daewon Chae, Ethan Ewer, Minjae Lee, Heeju Kim, Wonjun Kang, Jackson Kunde, Ying Fan, Jungtaek Kim, Hyung Il Koo, Kannan Ramchandran, Dimitris Papailiopoulos, Kangwook Lee",
+        "abstract": "Process Reward Models (PRMs) have proven effective at enhancing mathematical reasoning for Large Language Models (LLMs) by leveraging increased inference-time computation. However, they are predominantly trained on mathematical data and their generalizability to non-mathematical domains has not been rigorously studied. In response, this work first shows that current PRMs have poor performance in other domains. To address this limitation, we introduce VersaPRM, a multi-domain PRM trained on synthetic reasoning data generated using our novel data generation and annotation method. VersaPRM achieves consistent performance gains across diverse domains. For instance, in the MMLU-Pro category of Law, VersaPRM via weighted majority voting, achieves a 7.9% performance gain over the majority voting baseline -- surpassing Qwen2.5-Math-PRM's gain of 1.3%. We further contribute to the community by open-sourcing all data, code and models for VersaPRM.",
+        "link": "https://arxiv.org/abs/2502.06737"
+    },
+    {
+        "title": "Large Language Models for Multi-Robot Systems: A Survey",
+        "authors": "Peihan Li, Zijian An, Shams Abrar, Lifeng Zhou",
+        "abstract": "The rapid advancement of Large Language Models (LLMs) has opened new possibilities in Multi-Robot Systems (MRS), enabling enhanced communication, task planning, and human-robot interaction. Unlike traditional single-robot and multi-agent systems, MRS poses unique challenges, including coordination, scalability, and real-world adaptability. This survey provides the first comprehensive exploration of LLM integration into MRS. It systematically categorizes their applications across high-level task allocation, mid-level motion planning, low-level action generation, and human intervention. We highlight key applications in diverse domains, such as household robotics, construction, formation control, target tracking, and robot games, showcasing the versatility and transformative potential of LLMs in MRS. Furthermore, we examine the challenges that limit adapting LLMs in MRS, including mathematical reasoning limitations, hallucination, latency issues, and the need for robust benchmarking systems. Finally, we outline opportunities for future research, emphasizing advancements in fine-tuning, reasoning techniques, and task-specific models. This survey aims to guide researchers in the intelligence and real-world deployment of MRS powered by LLMs. Based on the fast-evolving nature of research in the field, we keep updating the papers in the open-source Github repository.",
+        "link": "https://arxiv.org/abs/2502.03814"
+    },
+    {
+        "title": "MergeME: Model Merging Techniques for Homogeneous and Heterogeneous MoEs",
+        "authors": "Yuhang Zhou, Giannis Karamanolakis, Victor Soto, Anna Rumshisky, Mayank Kulkarni, Furong Huang, Wei Ai, Jianhua Lu",
+        "abstract": "The recent success of specialized Large Language Models (LLMs) in domains such as mathematical reasoning and coding has led to growing interest in methods for merging these expert LLMs into a unified Mixture-of-Experts (MoE) model, with the goal of enhancing performance in each domain while retaining effectiveness on general tasks. However, the effective merging of expert models remains an open challenge, especially for models with highly divergent weight parameters or different architectures. State-of-the-art MoE merging methods only work with homogeneous model architectures and rely on simple unweighted averaging to merge expert layers, which does not address parameter interference and requires extensive fine-tuning of the merged MoE to restore performance. To address these limitations, this paper introduces new MoE merging techniques, including strategies to mitigate parameter interference, routing heuristics to reduce the need for MoE fine-tuning, and a novel method for merging experts with different architectures. Extensive experiments across multiple domains demonstrate the effectiveness of our proposed methods, reducing fine-tuning costs, improving performance over state-of-the-art methods, and expanding the applicability of MoE merging.",
+        "link": "https://arxiv.org/abs/2502.00997"
+    },
+    {
+        "title": "Satori: Reinforcement Learning with Chain-of-Action-Thought Enhances LLM Reasoning via Autoregressive Search",
+        "authors": "Maohao Shen, Guangtao Zeng, Zhenting Qi, Zhang-Wei Hong, Zhenfang Chen, Wei Lu, Gregory Wornell, Subhro Das, David Cox, Chuang Gan",
+        "abstract": "Large language models (LLMs) have demonstrated remarkable reasoning capabilities across diverse domains. Recent studies have shown that increasing test-time computation enhances LLMs' reasoning capabilities. This typically involves extensive sampling at inference time guided by an external LLM verifier, resulting in a two-player system. Despite external guidance, the effectiveness of this system demonstrates the potential of a single LLM to tackle complex tasks. Thus, we pose a new research problem: Can we internalize the searching capabilities to fundamentally enhance the reasoning abilities of a single LLM? This work explores an orthogonal direction focusing on post-training LLMs for autoregressive searching (i.e., an extended reasoning process with self-reflection and self-exploration of new strategies). To achieve this, we propose the Chain-of-Action-Thought (COAT) reasoning and a two-stage training paradigm: 1) a small-scale format tuning stage to internalize the COAT reasoning format and 2) a large-scale self-improvement stage leveraging reinforcement learning. Our approach results in Satori, a 7B LLM trained on open-source models and data. Extensive empirical evaluations demonstrate that Satori achieves state-of-the-art performance on mathematical reasoning benchmarks while exhibits strong generalization to out-of-domain tasks. Code, data, and models will be fully open-sourced.",
+        "link": "https://arxiv.org/abs/2502.02508"
+    },
+    {
+        "title": "Reasoning-as-Logic-Units: Scaling Test-Time Reasoning in Large Language Models Through Logic Unit Alignment",
+        "authors": "Cheryl Li, Tianyuan Xu, Yiwen Guo",
+        "abstract": "Chain-of-Thought (CoT) prompting has shown promise in enhancing the reasoning capabilities of large language models (LLMs) by generating natural language (NL) rationales that lead to the final answer. However, it struggles with numerical computation, which has somehow led to the development of program-aided techniques. Despite their potential, a persistent challenge remains: inconsistencies between LLM-reported reasoning steps and the logic in generated programs, which we term ``reasoning hallucinations.\" This stems from the inherent ambiguities of NL and the statistical nature of LLMs, which often lack rigorous logical coherence. To address this challenge, we propose a novel test-time scaling framework, Reasoning-as-Logic-Units (RaLU), which constructs a more reliable reasoning path by aligning logical units between the generated program and their corresponding NL descriptions. By decomposing the initially generated program into discrete units using static analysis, RaLU engages in an iterative dialogue with the LLM to judge, refine, and explain each unit. A rewind-and-correct mechanism ensures alignment between code statements and task requirements in each unit, ultimately forming a cohesive reasoning path under the program's logic, from which the model reaches a final solution. Our experiments demonstrate that RaLU significantly outperforms existing baselines in mathematical reasoning (GSM8K, MATH) and algorithmic reasoning (HumanEval+, MBPP+), underscoring its potential to advance LLM reasoning and programming by offering enhanced accuracy and interpretability.",
+        "link": "https://arxiv.org/abs/2502.07803"
+    },
+    {
+        "title": "Premise-Augmented Reasoning Chains Improve Error Identification in Math reasoning with LLMs",
+        "authors": "Sagnik Mukherjee, Abhinav Chinta, Takyoung Kim, Tarun Anoop Sharma, Dilek Hakkani-T\u00fcr",
+        "abstract": "Chain-of-Thought (CoT) prompting enhances mathematical reasoning in large language models (LLMs) by enabling detailed step-by-step solutions. However, due to the verbosity of LLMs, the resulting reasoning chains can be long, making it harder to verify the reasoning steps and trace issues resulting from dependencies between the steps that may be farther away in the sequence of steps. Importantly, mathematical reasoning allows each step to be derived from a small set of premises, which are a subset of the preceding steps in the reasoning chain. In this paper, we present a framework that identifies the premises for each step, to improve the evaluation of reasoning. We restructure conventional linear reasoning chains into Premise Augmented Reasoning Chains (PARC) by introducing premise links, resulting in a directed acyclic graph where the nodes are the steps and the edges are the premise links. Through experiments with a PARC-based dataset that we built, namely PERL (Premises and ERrors identification in LLMs), we demonstrate that LLMs can reliably identify premises within complex reasoning chains. In particular, even open-source LLMs achieve 90% recall in premise identification. We also show that PARC helps to identify errors in reasoning chains more reliably. The accuracy of error identification improves by 6% to 16% absolute when step-by-step verification is carried out in PARC under the premises. Our findings highlight the utility of premise-centric representations in addressing complex problem-solving tasks and open new avenues for improving the reliability of LLM-based reasoning evaluations.",
+        "link": "https://arxiv.org/abs/2502.02362"
+    },
+    {
+        "title": "Advanced Weakly-Supervised Formula Exploration for Neuro-Symbolic Mathematical Reasoning",
+        "authors": "Yuxuan Wu, Hideki Nakayama",
+        "abstract": "In recent years, neuro-symbolic methods have become a popular and powerful approach that augments artificial intelligence systems with the capability to perform abstract, logical, and quantitative deductions with enhanced precision and controllability. Recent studies successfully performed symbolic reasoning by leveraging various machine learning models to explicitly or implicitly predict intermediate labels that provide symbolic instructions. However, these intermediate labels are not always prepared for every task as a part of training data, and pre-trained models, represented by Large Language Models (LLMs), also do not consistently generate valid symbolic instructions with their intrinsic knowledge. On the other hand, existing work developed alternative learning techniques that allow the learning system to autonomously uncover optimal symbolic instructions. Nevertheless, their performance also exhibits limitations when faced with relatively huge search spaces or more challenging reasoning problems. In view of this, in this work, we put forward an advanced practice for neuro-symbolic reasoning systems to explore the intermediate labels with weak supervision from problem inputs and final outputs. Our experiments on the Mathematics dataset illustrated the effectiveness of our proposals from multiple aspects.",
+        "link": "https://arxiv.org/abs/2502.00629"
+    },
+    {
+        "title": "ARIES: Stimulating Self-Refinement of Large Language Models by Iterative Preference Optimization",
+        "authors": "Yongcheng Zeng, Xinyu Cui, Xuanfa Jin, Guoqing Liu, Zexu Sun, Quan He, Dong Li, Ning Yang, Jianye Hao, Haifeng Zhang, Jun Wang",
+        "abstract": "A truly intelligent Large Language Model (LLM) should be capable of correcting errors in its responses through external interactions. However, even the most advanced models often face challenges in improving their outputs. In this paper, we explore how to cultivate LLMs with the self-refinement capability through iterative preference training, and how this ability can be leveraged to improve model performance during inference. To this end, we introduce a novel post-training and inference framework, called ARIES: Adaptive Refinement and Iterative Enhancement Structure. This method iteratively performs preference training and self-refinement-based data collection. During training, ARIES strengthen the model's direct question-answering capability while simultaneously unlocking its self-refinement potential. During inference, ARIES harnesses this self-refinement capability to generate a series of progressively refined responses, which are then filtered using either the Reward Model Scoring or a simple yet effective Rule-Based Selection mechanism, specifically tailored to our approach, to construct a dataset for the next round of preference training. Experimental results demonstrate the remarkable performance of ARIES. When applied to the Llama-3.1-8B model and under the self-refinement setting, ARIES surpasses powerful models such as GPT-4o, achieving 62.3% length-controlled (LC) and a 63.3% raw win rates on AlpacaEval 2, outperforming Iterative DPO by 27.8% and 35.5% respectively, as well as a 50.3% win rate on Arena-Hard, surpassing Iterative DPO by 26.6%. Furthermore, ARIES consistently enhances performance on mathematical reasoning tasks like GSM8K and MATH.",
+        "link": "https://arxiv.org/abs/2502.05605"
+    }
+]
+
+==>> Search Results:
+1. Position: Multimodal Large Language Models Can Significantly Advance Scientific Reasoning
+   Authors: Yibo Yan, Shen Wang, Jiahao Huo, Jingheng Ye, Zhendong Chu, Xuming Hu, Philip S. Yu, Carla Gomes, Bart Selman, Qingsong Wen
+   Abstract: Scientific reasoning, the process through which humans apply logic, evidence, and critical thinking to explore and interpret scientific phenomena, is essential in advancing knowledge reasoning across diverse fields. However, despite significant progress, current scientific reasoning models still struggle with generalization across domains and often fall short of multimodal perception. Multimodal Large Language Models (MLLMs), which integrate text, images, and other modalities, present an exciting opportunity to overcome these limitations and enhance scientific reasoning. Therefore, this position paper argues that MLLMs can significantly advance scientific reasoning across disciplines such as mathematics, physics, chemistry, and biology. First, we propose a four-stage research roadmap of scientific reasoning capabilities, and highlight the current state of MLLM applications in scientific reasoning, noting their ability to integrate and reason over diverse data types. Second, we summarize the key challenges that remain obstacles to achieving MLLM's full potential. To address these challenges, we propose actionable insights and suggestions for the future. Overall, our work offers a novel perspective on MLLM integration with scientific reasoning, providing the LLM community with a valuable vision for achieving Artificial General Intelligence (AGI).
+   Link: https://arxiv.org/abs/2502.02871
+
+2. Adaptive Graph of Thoughts: Test-Time Adaptive Reasoning Unifying Chain, Tree, and Graph Structures
+   Authors: Tushar Pandey, Ara Ghukasyan, Oktay Goktas, Santosh Kumar Radha
+   Abstract: Large Language Models (LLMs) have demonstrated impressive reasoning capabilities, yet their performance is highly dependent on the prompting strategy and model scale. While reinforcement learning and fine-tuning have been deployed to boost reasoning, these approaches incur substantial computational and data overhead. In this work, we introduce Adaptive Graph of Thoughts (AGoT), a dynamic, graph-based inference framework that enhances LLM reasoning solely at test time. Rather than relying on fixed-step methods like Chain of Thought (CoT) or Tree of Thoughts (ToT), AGoT recursively decomposes complex queries into structured subproblems, forming an dynamic directed acyclic graph (DAG) of interdependent reasoning steps. By selectively expanding only those subproblems that require further analysis, AGoT unifies the strengths of chain, tree, and graph paradigms into a cohesive framework that allocates computation where it is most needed. We validate our approach on diverse benchmarks spanning multi-hop retrieval, scientific reasoning, and mathematical problem-solving, achieving up to 46.2% improvement on scientific reasoning tasks (GPQA) - comparable to gains achieved through computationally intensive reinforcement learning approaches and outperforming state-of-the-art iterative approaches. These results suggest that dynamic decomposition and structured recursion offer a scalable, cost-effective alternative to post-training modifications, paving the way for more robust, general-purpose reasoning in LLMs.
+   Link: https://arxiv.org/abs/2502.05078
+
+3. VersaPRM: Multi-Domain Process Reward Model via Synthetic Reasoning Data
+   Authors: Thomas Zeng, Shuibai Zhang, Shutong Wu, Christian Classen, Daewon Chae, Ethan Ewer, Minjae Lee, Heeju Kim, Wonjun Kang, Jackson Kunde, Ying Fan, Jungtaek Kim, Hyung Il Koo, Kannan Ramchandran, Dimitris Papailiopoulos, Kangwook Lee
+   Abstract: Process Reward Models (PRMs) have proven effective at enhancing mathematical reasoning for Large Language Models (LLMs) by leveraging increased inference-time computation. However, they are predominantly trained on mathematical data and their generalizability to non-mathematical domains has not been rigorously studied. In response, this work first shows that current PRMs have poor performance in other domains. To address this limitation, we introduce VersaPRM, a multi-domain PRM trained on synthetic reasoning data generated using our novel data generation and annotation method. VersaPRM achieves consistent performance gains across diverse domains. For instance, in the MMLU-Pro category of Law, VersaPRM via weighted majority voting, achieves a 7.9% performance gain over the majority voting baseline -- surpassing Qwen2.5-Math-PRM's gain of 1.3%. We further contribute to the community by open-sourcing all data, code and models for VersaPRM.
+   Link: https://arxiv.org/abs/2502.06737
+
+4. Large Language Models for Multi-Robot Systems: A Survey
+   Authors: Peihan Li, Zijian An, Shams Abrar, Lifeng Zhou
+   Abstract: The rapid advancement of Large Language Models (LLMs) has opened new possibilities in Multi-Robot Systems (MRS), enabling enhanced communication, task planning, and human-robot interaction. Unlike traditional single-robot and multi-agent systems, MRS poses unique challenges, including coordination, scalability, and real-world adaptability. This survey provides the first comprehensive exploration of LLM integration into MRS. It systematically categorizes their applications across high-level task allocation, mid-level motion planning, low-level action generation, and human intervention. We highlight key applications in diverse domains, such as household robotics, construction, formation control, target tracking, and robot games, showcasing the versatility and transformative potential of LLMs in MRS. Furthermore, we examine the challenges that limit adapting LLMs in MRS, including mathematical reasoning limitations, hallucination, latency issues, and the need for robust benchmarking systems. Finally, we outline opportunities for future research, emphasizing advancements in fine-tuning, reasoning techniques, and task-specific models. This survey aims to guide researchers in the intelligence and real-world deployment of MRS powered by LLMs. Based on the fast-evolving nature of research in the field, we keep updating the papers in the open-source Github repository.
+   Link: https://arxiv.org/abs/2502.03814
+
+5. MergeME: Model Merging Techniques for Homogeneous and Heterogeneous MoEs
+   Authors: Yuhang Zhou, Giannis Karamanolakis, Victor Soto, Anna Rumshisky, Mayank Kulkarni, Furong Huang, Wei Ai, Jianhua Lu
+   Abstract: The recent success of specialized Large Language Models (LLMs) in domains such as mathematical reasoning and coding has led to growing interest in methods for merging these expert LLMs into a unified Mixture-of-Experts (MoE) model, with the goal of enhancing performance in each domain while retaining effectiveness on general tasks. However, the effective merging of expert models remains an open challenge, especially for models with highly divergent weight parameters or different architectures. State-of-the-art MoE merging methods only work with homogeneous model architectures and rely on simple unweighted averaging to merge expert layers, which does not address parameter interference and requires extensive fine-tuning of the merged MoE to restore performance. To address these limitations, this paper introduces new MoE merging techniques, including strategies to mitigate parameter interference, routing heuristics to reduce the need for MoE fine-tuning, and a novel method for merging experts with different architectures. Extensive experiments across multiple domains demonstrate the effectiveness of our proposed methods, reducing fine-tuning costs, improving performance over state-of-the-art methods, and expanding the applicability of MoE merging.
+   Link: https://arxiv.org/abs/2502.00997
+
+6. Satori: Reinforcement Learning with Chain-of-Action-Thought Enhances LLM Reasoning via Autoregressive Search
+   Authors: Maohao Shen, Guangtao Zeng, Zhenting Qi, Zhang-Wei Hong, Zhenfang Chen, Wei Lu, Gregory Wornell, Subhro Das, David Cox, Chuang Gan
+   Abstract: Large language models (LLMs) have demonstrated remarkable reasoning capabilities across diverse domains. Recent studies have shown that increasing test-time computation enhances LLMs' reasoning capabilities. This typically involves extensive sampling at inference time guided by an external LLM verifier, resulting in a two-player system. Despite external guidance, the effectiveness of this system demonstrates the potential of a single LLM to tackle complex tasks. Thus, we pose a new research problem: Can we internalize the searching capabilities to fundamentally enhance the reasoning abilities of a single LLM? This work explores an orthogonal direction focusing on post-training LLMs for autoregressive searching (i.e., an extended reasoning process with self-reflection and self-exploration of new strategies). To achieve this, we propose the Chain-of-Action-Thought (COAT) reasoning and a two-stage training paradigm: 1) a small-scale format tuning stage to internalize the COAT reasoning format and 2) a large-scale self-improvement stage leveraging reinforcement learning. Our approach results in Satori, a 7B LLM trained on open-source models and data. Extensive empirical evaluations demonstrate that Satori achieves state-of-the-art performance on mathematical reasoning benchmarks while exhibits strong generalization to out-of-domain tasks. Code, data, and models will be fully open-sourced.
+   Link: https://arxiv.org/abs/2502.02508
+
+7. Reasoning-as-Logic-Units: Scaling Test-Time Reasoning in Large Language Models Through Logic Unit Alignment
+   Authors: Cheryl Li, Tianyuan Xu, Yiwen Guo
+   Abstract: Chain-of-Thought (CoT) prompting has shown promise in enhancing the reasoning capabilities of large language models (LLMs) by generating natural language (NL) rationales that lead to the final answer. However, it struggles with numerical computation, which has somehow led to the development of program-aided techniques. Despite their potential, a persistent challenge remains: inconsistencies between LLM-reported reasoning steps and the logic in generated programs, which we term ``reasoning hallucinations." This stems from the inherent ambiguities of NL and the statistical nature of LLMs, which often lack rigorous logical coherence. To address this challenge, we propose a novel test-time scaling framework, Reasoning-as-Logic-Units (RaLU), which constructs a more reliable reasoning path by aligning logical units between the generated program and their corresponding NL descriptions. By decomposing the initially generated program into discrete units using static analysis, RaLU engages in an iterative dialogue with the LLM to judge, refine, and explain each unit. A rewind-and-correct mechanism ensures alignment between code statements and task requirements in each unit, ultimately forming a cohesive reasoning path under the program's logic, from which the model reaches a final solution. Our experiments demonstrate that RaLU significantly outperforms existing baselines in mathematical reasoning (GSM8K, MATH) and algorithmic reasoning (HumanEval+, MBPP+), underscoring its potential to advance LLM reasoning and programming by offering enhanced accuracy and interpretability.
+   Link: https://arxiv.org/abs/2502.07803
+
+8. Premise-Augmented Reasoning Chains Improve Error Identification in Math reasoning with LLMs
+   Authors: Sagnik Mukherjee, Abhinav Chinta, Takyoung Kim, Tarun Anoop Sharma, Dilek Hakkani-Tür
+   Abstract: Chain-of-Thought (CoT) prompting enhances mathematical reasoning in large language models (LLMs) by enabling detailed step-by-step solutions. However, due to the verbosity of LLMs, the resulting reasoning chains can be long, making it harder to verify the reasoning steps and trace issues resulting from dependencies between the steps that may be farther away in the sequence of steps. Importantly, mathematical reasoning allows each step to be derived from a small set of premises, which are a subset of the preceding steps in the reasoning chain. In this paper, we present a framework that identifies the premises for each step, to improve the evaluation of reasoning. We restructure conventional linear reasoning chains into Premise Augmented Reasoning Chains (PARC) by introducing premise links, resulting in a directed acyclic graph where the nodes are the steps and the edges are the premise links. Through experiments with a PARC-based dataset that we built, namely PERL (Premises and ERrors identification in LLMs), we demonstrate that LLMs can reliably identify premises within complex reasoning chains. In particular, even open-source LLMs achieve 90% recall in premise identification. We also show that PARC helps to identify errors in reasoning chains more reliably. The accuracy of error identification improves by 6% to 16% absolute when step-by-step verification is carried out in PARC under the premises. Our findings highlight the utility of premise-centric representations in addressing complex problem-solving tasks and open new avenues for improving the reliability of LLM-based reasoning evaluations.
+   Link: https://arxiv.org/abs/2502.02362
+
+9. Advanced Weakly-Supervised Formula Exploration for Neuro-Symbolic Mathematical Reasoning
+   Authors: Yuxuan Wu, Hideki Nakayama
+   Abstract: In recent years, neuro-symbolic methods have become a popular and powerful approach that augments artificial intelligence systems with the capability to perform abstract, logical, and quantitative deductions with enhanced precision and controllability. Recent studies successfully performed symbolic reasoning by leveraging various machine learning models to explicitly or implicitly predict intermediate labels that provide symbolic instructions. However, these intermediate labels are not always prepared for every task as a part of training data, and pre-trained models, represented by Large Language Models (LLMs), also do not consistently generate valid symbolic instructions with their intrinsic knowledge. On the other hand, existing work developed alternative learning techniques that allow the learning system to autonomously uncover optimal symbolic instructions. Nevertheless, their performance also exhibits limitations when faced with relatively huge search spaces or more challenging reasoning problems. In view of this, in this work, we put forward an advanced practice for neuro-symbolic reasoning systems to explore the intermediate labels with weak supervision from problem inputs and final outputs. Our experiments on the Mathematics dataset illustrated the effectiveness of our proposals from multiple aspects.
+   Link: https://arxiv.org/abs/2502.00629
+
+10. ARIES: Stimulating Self-Refinement of Large Language Models by Iterative Preference Optimization
+   Authors: Yongcheng Zeng, Xinyu Cui, Xuanfa Jin, Guoqing Liu, Zexu Sun, Quan He, Dong Li, Ning Yang, Jianye Hao, Haifeng Zhang, Jun Wang
+   Abstract: A truly intelligent Large Language Model (LLM) should be capable of correcting errors in its responses through external interactions. However, even the most advanced models often face challenges in improving their outputs. In this paper, we explore how to cultivate LLMs with the self-refinement capability through iterative preference training, and how this ability can be leveraged to improve model performance during inference. To this end, we introduce a novel post-training and inference framework, called ARIES: Adaptive Refinement and Iterative Enhancement Structure. This method iteratively performs preference training and self-refinement-based data collection. During training, ARIES strengthen the model's direct question-answering capability while simultaneously unlocking its self-refinement potential. During inference, ARIES harnesses this self-refinement capability to generate a series of progressively refined responses, which are then filtered using either the Reward Model Scoring or a simple yet effective Rule-Based Selection mechanism, specifically tailored to our approach, to construct a dataset for the next round of preference training. Experimental results demonstrate the remarkable performance of ARIES. When applied to the Llama-3.1-8B model and under the self-refinement setting, ARIES surpasses powerful models such as GPT-4o, achieving 62.3% length-controlled (LC) and a 63.3% raw win rates on AlpacaEval 2, outperforming Iterative DPO by 27.8% and 35.5% respectively, as well as a 50.3% win rate on Arena-Hard, surpassing Iterative DPO by 26.6%. Furthermore, ARIES consistently enhances performance on mathematical reasoning tasks like GSM8K and MATH.
+   Link: https://arxiv.org/abs/2502.05605
+
+Done!

octotools/tools/arxiv_paper_searcher/tool.py

@@ -0,0 +1,165 @@
+import re
+import requests
+from bs4 import BeautifulSoup
+
+from octotools.tools.base import BaseTool
+
+class ArXiv_Paper_Searcher_Tool(BaseTool):
+    def __init__(self):
+        super().__init__(
+            tool_name="ArXiv_Paper_Searcher_Tool",
+            tool_description="A tool that searches arXiv for papers based on a given query.",
+            tool_version="1.0.0",
+            input_types={
+                "query": "str - The search query for arXiv papers.",
+                "size": "int - The number of results per page (25, 50, 100, or 200). If None, use 25.",
+                "max_results": "int - The maximum number of papers to return (default: 25). Should be less than or equal to 100."
+            },
+            output_type="list - A list of dictionaries containing paper information.",
+            demo_commands=[
+                {
+                    "command": 'execution = tool.execute(query="tool agents with large language models")',
+                    "description": "Search for papers about tool agents with large language models."
+                },
+                {
+                    "command": 'execution = tool.execute(query="quantum computing", size=100, max_results=50)',
+                    "description": "Search for quantum computing papers, with 100 results per page, returning a maximum of 50 papers."
+                },
+                {
+                    "command": 'execution = tool.execute(query="machine learning", max_results=75)',
+                    "description": "Search for machine learning papers, returning a maximum of 75 papers."
+                },
+            ],
+            user_metadata={
+                "valid_sizes": [25, 50, 100, 200],
+                "base_url": "https://arxiv.org/search/"
+            }
+        )
+
+    def build_tool(self):
+        """
+        No specific build required for this tool.
+        """
+        pass
+
+    def execute(self, query, size=None, max_results=25):
+        """
+        Executes the arXiv search tool to find papers based on the given query.
+
+        Parameters:
+            query (str): The search query for arXiv papers.
+            size (int): The number of results per page.
+            max_results (int): The maximum number of papers to return.
+
+        Returns:
+            list: A list of dictionaries containing paper information.
+        """
+        valid_sizes = self.user_metadata["valid_sizes"]
+        base_url = self.user_metadata["base_url"]
+
+        if size is None:
+            size = 25
+        elif size not in valid_sizes:
+            size = min(valid_sizes, key=lambda x: abs(x - size))
+
+        results = []
+        start = 0
+
+        max_results = min(max_results, 100) # NOTE: For traffic reasons, limit to 100 results
+
+        while len(results) < max_results:
+            params = {
+                "searchtype": "all",
+                "query": query,
+                "abstracts": "show",
+                "order": "",
+                "size": str(size),
+                "start": str(start)
+            }
+
+            try:
+                response = requests.get(base_url, params=params)
+                soup = BeautifulSoup(response.content, 'html.parser')
+
+                papers = soup.find_all("li", class_="arxiv-result")
+                if not papers:
+                    break
+
+                for paper in papers:
+                    if len(results) >= max_results:
+                        break
+
+                    title = paper.find("p", class_="title").text.strip()
+                    authors = paper.find("p", class_="authors").text.strip()
+                    authors = re.sub(r'^Authors:\s*', '', authors)
+                    authors = re.sub(r'\s+', ' ', authors).strip()
+                    
+                    abstract = paper.find("span", class_="abstract-full").text.strip()
+                    abstract = abstract.replace("△ Less", "").strip()
+                    
+                    link = paper.find("p", class_="list-title").find("a")["href"]
+
+                    results.append({
+                        "title": title,
+                        "authors": authors,
+                        "abstract": abstract,
+                        "link": f"{link}"
+                    })
+
+                start += size
+
+            except Exception as e:
+                print(f"Error searching arXiv: {e}")
+                break
+
+        return results[:max_results]
+
+    def get_metadata(self):
+        """
+        Returns the metadata for the ArXiv_Paper_Searcher_Tool.
+
+        Returns:
+            dict: A dictionary containing the tool's metadata.
+        """
+        metadata = super().get_metadata()
+        return metadata
+
+if __name__ == "__main__":
+    # Test command:
+    """
+    Run the following commands in the terminal to test the script:
+    
+    cd octotools/tools/arxiv_paper_searcher
+    python tool.py
+    """
+
+    import json
+
+    print("ArXiv Search Tool Test")
+
+    # Example usage of the ArXiv_Paper_Searcher_Tool
+    tool = ArXiv_Paper_Searcher_Tool()
+
+    # Get tool metadata
+    metadata = tool.get_metadata()
+    print("Tool Metadata:")
+    print(metadata)
+
+    # Sample query for searching arXiv
+    query = "enhance mathematical reasoning with large language models"
+    # Execute the tool
+    try:
+        execution = tool.execute(query=query, size=50, max_results=10)
+        print("\n==>> Execution:")
+        print(json.dumps(execution, indent=4))  # Pretty print JSON
+        print("\n==>> Search Results:")
+        for i, paper in enumerate(execution, 1):
+            print(f"{i}. {paper['title']}")
+            print(f"   Authors: {paper['authors']}")
+            print(f"   Abstract: {paper['abstract'][:2000]}")
+            print(f"   Link: {paper['link']}")
+            print()
+    except Exception as e:
+        print(f"Execution failed: {e}")
+
+    print("Done!")

{opentools → octotools}/tools/base.py

@@ -1,6 +1,6 @@
-# opentools/tools/base.py
+# octotools/tools/base.py
 
-from opentools.engine.openai import ChatOpenAI
+from octotools.engine.openai import ChatOpenAI
 
 class BaseTool:
     """

{opentools → octotools}/tools/generalist_solution_generator/tool.py

@@ -1,6 +1,6 @@
 import os
-from opentools.tools.base import BaseTool
-from opentools.engine.openai import ChatOpenAI
+from octotools.tools.base import BaseTool
+from octotools.engine.openai import ChatOpenAI
 
 class Generalist_Solution_Generator_Tool(BaseTool):
     require_llm_engine = True
@@ -109,7 +109,7 @@ if __name__ == "__main__":
     """
     Run the following commands in the terminal to test the script:
     
-    cd opentools
+    cd octotools
     python tools/default/tool.py
     """
 

octotools/tools/google_search/test.log

@@ -0,0 +1,29 @@
+{'tool_name': 'Google_Search_Tool', 'tool_description': 'A tool that performs Google searches based on a given text query.', 'tool_version': '1.0.0', 'input_types': {'query': 'str - The search query to be used for the Google search.', 'num_results': 'int - The number of search results to return (default: 10).'}, 'output_type': 'list - A list of dictionaries containing search result information.', 'demo_commands': [{'command': 'execution = tool.execute(query="Python programming")', 'description': "Perform a Google search for 'Python programming' and return the default number of results."}, {'command': 'execution = tool.execute(query="Machine learning tutorials", num_results=5)', 'description': "Perform a Google search for 'Machine learning tutorials' and return 5 results."}], 'require_llm_engine': False}
+{'kind': 'customsearch#search', 'url': {'type': 'application/json', 'template': 'https://www.googleapis.com/customsearch/v1?q={searchTerms}&num={count?}&start={startIndex?}&lr={language?}&safe={safe?}&cx={cx?}&sort={sort?}&filter={filter?}&gl={gl?}&cr={cr?}&googlehost={googleHost?}&c2coff={disableCnTwTranslation?}&hq={hq?}&hl={hl?}&siteSearch={siteSearch?}&siteSearchFilter={siteSearchFilter?}&exactTerms={exactTerms?}&excludeTerms={excludeTerms?}&linkSite={linkSite?}&orTerms={orTerms?}&dateRestrict={dateRestrict?}&lowRange={lowRange?}&highRange={highRange?}&searchType={searchType}&fileType={fileType?}&rights={rights?}&imgSize={imgSize?}&imgType={imgType?}&imgColorType={imgColorType?}&imgDominantColor={imgDominantColor?}&alt=json'}, 'queries': {'request': [{'title': 'Google Custom Search - nobel prize winners in chemistry 2024', 'totalResults': '1020000', 'searchTerms': 'nobel prize winners in chemistry 2024', 'count': 5, 'startIndex': 1, 'inputEncoding': 'utf8', 'outputEncoding': 'utf8', 'safe': 'off', 'cx': 'd5bb3fdd4b7fd4cd9'}], 'nextPage': [{'title': 'Google Custom Search - nobel prize winners in chemistry 2024', 'totalResults': '1020000', 'searchTerms': 'nobel prize winners in chemistry 2024', 'count': 5, 'startIndex': 6, 'inputEncoding': 'utf8', 'outputEncoding': 'utf8', 'safe': 'off', 'cx': 'd5bb3fdd4b7fd4cd9'}]}, 'context': {'title': 'toolbox-dev-pan'}, 'searchInformation': {'searchTime': 0.285868, 'formattedSearchTime': '0.29', 'totalResults': '1020000', 'formattedTotalResults': '1,020,000'}, 'items': [{'kind': 'customsearch#result', 'title': 'The Nobel Prize in Chemistry 2024', 'htmlTitle': 'The <b>Nobel Prize</b> in <b>Chemistry 2024</b>', 'link': 'https://www.nobelprize.org/prizes/chemistry/', 'displayLink': 'www.nobelprize.org', 'snippet': "The Nobel Prize in Chemistry 2024 is about proteins, life's ingenious chemical tools. David Baker has succeeded with the almost impossible feat of building\xa0...", 'htmlSnippet': 'The <b>Nobel Prize</b> in <b>Chemistry 2024</b> is about proteins, life&#39;s ingenious <b>chemical</b> tools. David Baker has succeeded with the almost impossible feat of building&nbsp;...', 'formattedUrl': 'https://www.nobelprize.org/prizes/chemistry/', 'htmlFormattedUrl': 'https://www.<b>nobelprize</b>.org/<b>prize</b>s/<b>chemistry</b>/', 'pagemap': {'hcard': [{'fn': 'Ernest Rutherford', 'url': 'https://www.nobelprize.org/prizes/chemistry/1908/rutherford/'}, {'fn': 'Marie Curie, née Skłodowska', 'url': 'https://www.nobelprize.org/prizes/physics/1903/marie-curie/'}, {'fn': 'Jacques Dubochet', 'url': 'https://www.nobelprize.org/prizes/chemistry/2017/dubochet/'}, {'fn': 'Dorothy Crowfoot Hodgkin', 'url': 'https://www.nobelprize.org/prizes/chemistry/1964/hodgkin/'}, {'fn': 'Linus Carl Pauling', 'url': 'https://www.nobelprize.org/prizes/chemistry/1954/pauling/'}, {'fn': 'Jean-Pierre Sauvage', 'url': 'https://www.nobelprize.org/prizes/chemistry/2016/sauvage/'}], 'cse_thumbnail': [{'src': 'https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcSOMs3quxSE4q1eWHocdDOr31q-aad13MSHgdUGUqpOG71sdtm6WGQ5BWAX&s', 'width': '276', 'height': '182'}], 'person': [{'name': 'Ernest Rutherford', 'url': 'Ernest Rutherford'}, {'name': 'Marie Curie, née Skłodowska', 'url': 'Marie Curie, née Skłodowska'}, {'name': 'Jacques Dubochet', 'url': 'Jacques Dubochet'}, {'name': 'Dorothy Crowfoot Hodgkin', 'url': 'Dorothy Crowfoot Hodgkin'}, {'name': 'Linus Carl Pauling', 'url': 'Linus Carl Pauling'}, {'name': 'Jean-Pierre Sauvage', 'url': 'Jean-Pierre Sauvage'}], 'organization': [{'url': 'https://www.nobelprize.org/'}, {'logo': 'Nobel Prize', 'url': 'Nobel Prize'}], 'metatags': [{'og:image': 'https://www.nobelprize.org/uploads/2018/09/New-will-fullsize-496x328.jpg', 'og:type': 'website', 'twitter:card': 'summary_large_image', 'twitter:title': 'Chemistry Prize', 'og:site_name': 'NobelPrize.org', 'og:title': 'Chemistry Prize', 'msapplication-tileimage': 'https://www.nobelprize.org/uploads/2018/08/Nobel-favicon.png', 'og:description': 'Chemistry Prize', 'twitter:image': 'https://www.nobelprize.org/uploads/2018/09/New-will-fullsize-496x328.jpg', 'viewport': 'width=device-width, initial-scale=1', 'twitter:description': 'Chemistry Prize', 'og:locale': 'en_US', 'og:url': 'https://www.nobelprize.org/chemistry-prize-2/'}], 'cse_image': [{'src': 'https://www.nobelprize.org/uploads/2018/09/New-will-fullsize-496x328.jpg'}], 'blogposting': [{'headline': 'They cracked the code for proteins’ amazing structures'}, {'headline': 'David Baker'}, {'headline': 'Demis Hassabis'}, {'headline': 'John Jumper'}, {'headline': 'The life of a chemist'}, {'headline': 'How many chemistry laureates can you match?'}, {'headline': 'What are the Nobel Prize categories?'}, {'headline': 'What did they discover?'}, {'headline': 'Who first predicted global warming?'}, {'headline': 'The world’s smallest machines'}, {'headline': 'Interview with a double awardee'}]}}, {'kind': 'customsearch#result', 'title': 'NSF congratulates laureates of the 2024 Nobel Prize in chemistry ...', 'htmlTitle': 'NSF congratulates <b>laureates</b> of the <b>2024 Nobel Prize</b> in <b>chemistry</b> ...', 'link': 'https://www.nsf.gov/news/nsf-congratulates-laureates-2024-nobel-prize-chemistry', 'displayLink': 'www.nsf.gov', 'snippet': 'Oct 9, 2024 ... The U.S. National Science Foundation congratulates David Baker, Demis Hassabis and John Jumper on being awarded the 2024 Nobel Prize in\xa0...', 'htmlSnippet': 'Oct 9, 2024 <b>...</b> The U.S. National Science Foundation congratulates David Baker, Demis Hassabis and John Jumper on being awarded the <b>2024 Nobel Prize</b> in&nbsp;...', 'formattedUrl': 'https://www.nsf.gov/.../nsf-congratulates-laureates-2024-nobel-prize-chemi...', 'htmlFormattedUrl': 'https://www.nsf.gov/.../nsf-congratulates-laureates-<b>2024</b>-<b>nobel</b>-<b>prize</b>-<b>chemi</b>...', 'pagemap': {'cse_thumbnail': [{'src': 'https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcRH1B2HTt4h0BsKt4cqcthiUWk5GDU2hX6k7mP1EQh0glR9n13NnR2pLX4&s', 'width': '360', 'height': '140'}], 'metatags': [{'og:image': 'https://nsf-gov-resources.nsf.gov/styles/_inline_image_full_width/s3/media_hub/nobel24-chemistry-news-hero-David-Baker-Demis-Hassabis-John-Jumper.jpg?VersionId=8Wa1DsrhgMw.SQEBdxmUOgtdCntLkWDb&itok=NIPtuWh-', 'og:image:width': '800', 'og:image:alt': 'sketch portraits of three men', 'twitter:card': 'summary_large_image', 'twitter:title': 'NSF congratulates laureates of the 2024 Nobel Prize in chemistry', 'og:site_name': 'NSF - National Science Foundation', 'handheldfriendly': 'true', 'og:title': 'NSF congratulates laureates of the 2024 Nobel Prize in chemistry', 'og:image:height': '312', 'og:description': 'The U.S. National Science Foundation congratulates David Baker, Demis Hassabis and John Jumper on being awarded the 2024 Nobel Prize in chemistry. Baker and his…', 'twitter:image': 'https://nsf-gov-resources.nsf.gov/styles/_inline_image_full_width/s3/media_hub/nobel24-chemistry-news-hero-David-Baker-Demis-Hassabis-John-Jumper.jpg?VersionId=8Wa1DsrhgMw.SQEBdxmUOgtdCntLkWDb&itok=NIPtuWh-', 'twitter:image:alt': 'sketch portraits of three men', 'twitter:site': '@NSF', 'viewport': 'width=device-width, initial-scale=1.0', 'twitter:description': 'The U.S. National Science Foundation congratulates David Baker, Demis Hassabis and John Jumper on being awarded the 2024 Nobel Prize in chemistry. Baker and his…', 'mobileoptimized': 'width', 'og:url': 'https://www.nsf.gov/news/nsf-congratulates-laureates-2024-nobel-prize-chemistry'}], 'cse_image': [{'src': 'https://nsf-gov-resources.nsf.gov/styles/_inline_image_full_width/s3/media_hub/nobel24-chemistry-news-hero-David-Baker-Demis-Hassabis-John-Jumper.jpg?VersionId=8Wa1DsrhgMw.SQEBdxmUOgtdCntLkWDb&itok=NIPtuWh-'}]}}, {'kind': 'customsearch#result', 'title': 'Press release: The Nobel Prize in Chemistry 2024 - NobelPrize.org', 'htmlTitle': 'Press release: The <b>Nobel Prize</b> in <b>Chemistry 2024</b> - <b>NobelPrize</b>.org', 'link': 'https://www.nobelprize.org/prizes/chemistry/2024/press-release/', 'displayLink': 'www.nobelprize.org', 'snippet': 'Oct 9, 2024 ... David Baker has succeeded with the almost impossible feat of building entirely new kinds of proteins. Demis Hassabis and John Jumper have\xa0...', 'htmlSnippet': 'Oct 9, 2024 <b>...</b> David Baker has succeeded with the almost impossible feat of building entirely new kinds of proteins. Demis Hassabis and John Jumper have&nbsp;...', 'formattedUrl': 'https://www.nobelprize.org/prizes/chemistry/2024/press-release/', 'htmlFormattedUrl': 'https://www.<b>nobelprize</b>.org/<b>prize</b>s/<b>chemistry</b>/<b>2024</b>/press-release/', 'pagemap': {'cse_thumbnail': [{'src': 'https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcQON_Hf1_dyrEACSiPsjRoTG2R4pjcDpbg7BAzGC9LovMbRHVei6GShrCM&s', 'width': '302', 'height': '167'}], 'organization': [{'url': 'https://www.nobelprize.org/'}, {'logo': 'Nobel Prize', 'url': 'Nobel Prize'}], 'metatags': [{'og:image': 'https://www.nobelprize.org/uploads/2024/10/popular-chemistryprize2024-carrier-1024x567.jpg', 'og:type': 'website', 'twitter:card': 'summary_large_image', 'twitter:title': 'Nobel Prize in Chemistry 2024', 'og:site_name': 'NobelPrize.org', 'og:title': 'Nobel Prize in Chemistry 2024', 'msapplication-tileimage': 'https://www.nobelprize.org/uploads/2018/08/Nobel-favicon.png', 'og:description': 'The Nobel Prize in Chemistry 2024 was divided, one half awarded to David Baker "for computational protein design", the other half jointly to Demis Hassabis and John Jumper "for protein structure prediction"', 'twitter:image': 'https://www.nobelprize.org/uploads/2024/10/popular-chemistryprize2024-carrier-1024x567.jpg', 'viewport': 'width=device-width, initial-scale=1', 'twitter:description': 'The Nobel Prize in Chemistry 2024 was divided, one half awarded to David Baker "for computational protein design", the other half jointly to Demis Hassabis and John Jumper "for protein structure prediction"', 'og:locale': 'en_US', 'og:url': 'https://www.nobelprize.org/prizes/chemistry/2024/press-release/'}], 'cse_image': [{'src': 'https://www.nobelprize.org/uploads/2024/10/popular-chemistryprize2024-carrier-1024x567.jpg'}]}}, {'kind': 'customsearch#result', 'title': 'AIP Congratulates 2024 Nobel Prize Winners in Chemistry - AIP.ORG', 'htmlTitle': 'AIP Congratulates <b>2024 Nobel Prize Winners in Chemistry</b> - AIP.ORG', 'link': 'https://ww2.aip.org/aip/2024-nobel-prize-in-chemistry', 'displayLink': 'ww2.aip.org', 'snippet': 'Oct 9, 2024 ... The 2024 Nobel Prize in chemistry was awarded with one half to David Baker “for computational protein design” and the other half jointly to Demis Hassabis and\xa0...', 'htmlSnippet': 'Oct 9, 2024 <b>...</b> The <b>2024 Nobel Prize</b> in <b>chemistry</b> was awarded with one half to David Baker “for computational protein design” and the other half jointly to Demis Hassabis and&nbsp;...', 'formattedUrl': 'https://ww2.aip.org/aip/2024-nobel-prize-in-chemistry', 'htmlFormattedUrl': 'https://ww2.aip.org/aip/<b>2024</b>-<b>nobel</b>-<b>prize</b>-in-<b>chemistry</b>', 'pagemap': {'cse_thumbnail': [{'src': 'https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcTyVGKJaR9X7VE3Y97Z_j8IXIconF0D0zUe88ATVyBuFSXya-CrM1qsveY&s', 'width': '300', 'height': '168'}], 'metatags': [{'og:image': 'https://aip.brightspotcdn.com/dims4/default/079290d/2147483647/strip/true/crop/1200x675+0+0/resize/1440x810!/quality/90/?url=https%3A%2F%2Fk1-prod-aip.s3.us-east-2.amazonaws.com%2Fbrightspot%2F07%2F96%2Fbc7d9a594949bc49f983177d6781%2Fnobel-2024-chem-i01.jpg', 'og:image:width': '1440', 'og:image:alt': 'Nobel-2024-Chem-i01.jpg', 'og:type': 'article', 'article:published_time': '2024-10-09T12:28:31.16', 'article:section': 'AIP', 'twitter:card': 'summary_large_image', 'og:site_name': 'AIP', 'og:image:url': 'https://aip.brightspotcdn.com/dims4/default/079290d/2147483647/strip/true/crop/1200x675+0+0/resize/1440x810!/quality/90/?url=https%3A%2F%2Fk1-prod-aip.s3.us-east-2.amazonaws.com%2Fbrightspot%2F07%2F96%2Fbc7d9a594949bc49f983177d6781%2Fnobel-2024-chem-i01.jpg', 'og:image:height': '810', 'og:image:type': 'image/jpeg', 'twitter:image': 'https://aip.brightspotcdn.com/dims4/default/079290d/2147483647/strip/true/crop/1200x675+0+0/resize/1440x810!/quality/90/?url=https%3A%2F%2Fk1-prod-aip.s3.us-east-2.amazonaws.com%2Fbrightspot%2F07%2F96%2Fbc7d9a594949bc49f983177d6781%2Fnobel-2024-chem-i01.jpg', 'twitter:image:alt': 'Nobel-2024-Chem-i01.jpg', 'fb:app_id': '643005150655973', 'article:modified_time': '2024-10-09T18:23:12.852', 'viewport': 'width=device-width, initial-scale=1, minimum-scale=1, maximum-scale=5', 'brightspot.contentid': '00000192-70e9-da7e-a1fe-fcff80d40000', 'og:url': 'https://ww2.aip.org/aip/2024-nobel-prize-in-chemistry'}], 'cse_image': [{'src': 'https://aip.brightspotcdn.com/dims4/default/079290d/2147483647/strip/true/crop/1200x675+0+0/resize/1440x810!/quality/90/?url=https%3A%2F%2Fk1-prod-aip.s3.us-east-2.amazonaws.com%2Fbrightspot%2F07%2F96%2Fbc7d9a594949bc49f983177d6781%2Fnobel-2024-chem-i01.jpg'}]}}, {'kind': 'customsearch#result', 'title': 'The Nobel Prize in Chemistry 2024 - NobelPrize.org', 'htmlTitle': 'The <b>Nobel Prize</b> in <b>Chemistry 2024</b> - <b>NobelPrize</b>.org', 'link': 'https://www.nobelprize.org/prizes/chemistry/2024/summary/', 'displayLink': 'www.nobelprize.org', 'snippet': 'David Baker · Demis Hassabis · John Jumper · Nobel Prizes and laureates\xa0...', 'htmlSnippet': 'David Baker &middot; Demis Hassabis &middot; John Jumper &middot; <b>Nobel Prizes</b> and <b>laureates</b>&nbsp;...', 'formattedUrl': 'https://www.nobelprize.org/prizes/chemistry/2024/summary/', 'htmlFormattedUrl': 'https://www.<b>nobelprize</b>.org/<b>prize</b>s/<b>chemistry</b>/<b>2024</b>/summary/', 'pagemap': {'hcard': [{'fn': 'David Baker', 'url': 'https://www.nobelprize.org/prizes/chemistry/2024/baker/facts/'}, {'fn': 'Demis Hassabis', 'url': 'https://www.nobelprize.org/prizes/chemistry/2024/hassabis/facts/'}, {'fn': 'John Jumper', 'url': 'https://www.nobelprize.org/prizes/chemistry/2024/jumper/facts/'}], 'cse_thumbnail': [{'src': 'https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcT4UpOxZHEJhIvhwQsypTDggUJ3pJf_wG3U3jZBDyK8l-Qyqx99fVknWr8Y&s', 'width': '259', 'height': '194'}], 'person': [{'name': 'David Baker', 'description': 'Prize share: 1/2', 'url': 'David Baker'}, {'name': 'Demis Hassabis', 'description': 'Prize share: 1/4', 'url': 'Demis Hassabis'}, {'name': 'John Jumper', 'description': 'Prize share: 1/4', 'url': 'John Jumper'}], 'organization': [{'url': 'https://www.nobelprize.org/'}, {'logo': 'Nobel Prize', 'url': 'Nobel Prize'}], 'metatags': [{'og:image': 'https://www.nobelprize.org/uploads/2024/10/fig_ke_24_4x3-1024x768.jpg', 'og:type': 'website', 'twitter:card': 'summary_large_image', 'twitter:title': 'Nobel Prize in Chemistry 2024', 'og:site_name': 'NobelPrize.org', 'og:title': 'Nobel Prize in Chemistry 2024', 'msapplication-tileimage': 'https://www.nobelprize.org/uploads/2018/08/Nobel-favicon.png', 'og:description': 'The Nobel Prize in Chemistry 2024 was divided, one half awarded to David Baker "for computational protein design", the other half jointly to Demis Hassabis and John Jumper "for protein structure prediction"', 'twitter:image': 'https://www.nobelprize.org/uploads/2024/10/fig_ke_24_4x3-1024x768.jpg', 'viewport': 'width=device-width, initial-scale=1', 'twitter:description': 'The Nobel Prize in Chemistry 2024 was divided, one half awarded to David Baker "for computational protein design", the other half jointly to Demis Hassabis and John Jumper "for protein structure prediction"', 'og:locale': 'en_US', 'og:url': 'https://www.nobelprize.org/prizes/chemistry/2024/summary/'}], 'cse_image': [{'src': 'https://www.nobelprize.org/uploads/2024/10/fig_ke_24_4x3-1024x768.jpg'}]}}]}
+
+Execution Result:
+Search query: nobel prize winners in chemistry 2024
+Number of results: 5
+
+Search Results:
+
+1. Title: The Nobel Prize in Chemistry 2024
+   URL: https://www.nobelprize.org/prizes/chemistry/
+   Snippet: The Nobel Prize in Chemistry 2024 is about proteins, life's ingenious chemical tools. David Baker has succeeded with the almost impossible feat of building ...
+
+2. Title: NSF congratulates laureates of the 2024 Nobel Prize in chemistry ...
+   URL: https://www.nsf.gov/news/nsf-congratulates-laureates-2024-nobel-prize-chemistry
+   Snippet: Oct 9, 2024 ... The U.S. National Science Foundation congratulates David Baker, Demis Hassabis and John Jumper on being awarded the 2024 Nobel Prize in ...
+
+3. Title: Press release: The Nobel Prize in Chemistry 2024 - NobelPrize.org
+   URL: https://www.nobelprize.org/prizes/chemistry/2024/press-release/
+   Snippet: Oct 9, 2024 ... David Baker has succeeded with the almost impossible feat of building entirely new kinds of proteins. Demis Hassabis and John Jumper have ...
+
+4. Title: AIP Congratulates 2024 Nobel Prize Winners in Chemistry - AIP.ORG
+   URL: https://ww2.aip.org/aip/2024-nobel-prize-in-chemistry
+   Snippet: Oct 9, 2024 ... The 2024 Nobel Prize in chemistry was awarded with one half to David Baker “for computational protein design” and the other half jointly to Demis Hassabis and ...
+
+5. Title: The Nobel Prize in Chemistry 2024 - NobelPrize.org
+   URL: https://www.nobelprize.org/prizes/chemistry/2024/summary/
+   Snippet: David Baker · Demis Hassabis · John Jumper · Nobel Prizes and laureates ...
+Done!

octotools/tools/google_search/tool.py

@@ -0,0 +1,136 @@
+import os
+import requests
+from typing import List, Dict, Any
+
+from octotools.tools.base import BaseTool
+
+from dotenv import load_dotenv
+load_dotenv()
+
+class Google_Search_Tool(BaseTool):
+    def __init__(self):
+        super().__init__(
+            tool_name="Google_Search_Tool",
+            tool_description="A tool that performs Google searches based on a given text query.",
+            tool_version="1.0.0",
+            input_types={
+                "query": "str - The search query to be used for the Google search.",
+                "num_results": "int - The number of search results to return (default: 10).",
+            },
+            output_type="list - A list of dictionaries containing search result information.",
+            demo_commands=[
+                {
+                    "command": 'execution = tool.execute(query="Python programming")',
+                    "description": "Perform a Google search for 'Python programming' and return the default number of results."
+                },
+                {
+                    "command": 'execution = tool.execute(query="Machine learning tutorials", num_results=5)',
+                    "description": "Perform a Google search for 'Machine learning tutorials' and return 5 results."
+                },
+            ],
+        )
+        # self.api_key = os.getenv("GOOGLE_API_KEY")
+        self.api_key = os.getenv("GOOGLE_API_KEY") # NOTE: Replace with your own API key (Ref: https://developers.google.com/custom-search/v1/introduction)
+        self.cx = os.getenv("GOOGLE_CX") # NOTE: Replace with your own custom search (Ref: https://programmablesearchengine.google.com/controlpanel/all)
+        self.base_url = "https://www.googleapis.com/customsearch/v1"
+
+    def google_search(self, query: str, num_results: int = 10) -> Dict[str, Any]:
+        """
+        Performs a Google search using the provided query.
+
+        Parameters:
+            query (str): The search query.
+            num_results (int): The number of search results to return.
+
+        Returns:
+            Dict[str, Any]: The raw search results from the Google API.
+        """
+        params = {
+            'q': query,
+            'key': self.api_key,
+            'cx': self.cx,
+            'num': num_results
+        }
+        
+        response = requests.get(self.base_url, params=params)
+        return response.json()
+
+    def execute(self, query: str, num_results: int = 10) -> List[Dict[str, Any]]:
+        """
+        Executes a Google search based on the provided query.
+
+        Parameters:
+            query (str): The search query.
+            num_results (int): The number of search results to return (default: 10).
+
+        Returns:
+            List[Dict[str, Any]]: A list of dictionaries containing search result information.
+        """
+        if not self.api_key:
+            return [{"error": "Google API key is not set. Please set the GOOGLE_API_KEY environment variable."}]
+
+        try:
+            results = self.google_search(query, num_results)
+            print(results)
+            
+            if 'items' in results:
+                return [
+                    {
+                        "title": item['title'],
+                        "link": item['link'],
+                        "snippet": item['snippet']
+                    }
+                    for item in results['items']
+                ]
+            else:
+                return [{"error": "No results found."}]
+        except Exception as e:
+            return [{"error": f"An error occurred: {str(e)}"}]
+
+    def get_metadata(self):
+        """
+        Returns the metadata for the Google_Search_Tool.
+
+        Returns:
+            dict: A dictionary containing the tool's metadata.
+        """
+        metadata = super().get_metadata()
+        return metadata
+
+
+if __name__ == "__main__":
+    # Test command:
+    """
+    Run the following commands in the terminal to test the script:
+
+    export GOOGLE_API_KEY=your_api_key_here
+    cd octotools/tools/google_search
+    python tool.py
+    """
+
+    # Example usage of the Google_Search_Tool
+    tool = Google_Search_Tool()
+
+    # Get tool metadata
+    metadata = tool.get_metadata()
+    print(metadata)
+
+    # Execute the tool to perform a Google search
+    query = "nobel prize winners in chemistry 2024"
+    try:
+        execution = tool.execute(query=query, num_results=5)
+        print("\nExecution Result:")
+        print(f"Search query: {query}")
+        print(f"Number of results: {len(execution)}")
+        print("\nSearch Results:")
+        if "error" in execution[0]:
+            print(f"Error: {execution[0]['error']}")
+        else:
+            for i, item in enumerate(execution, 1):
+                print(f"\n{i}. Title: {item['title']}")
+                print(f"   URL: {item['link']}")
+                print(f"   Snippet: {item['snippet']}")
+    except Exception as e:
+        print(f"Execution failed: {e}")
+
+    print("Done!")

octotools/tools/image_captioner/test.log

@@ -0,0 +1,7 @@
+
+Initializing Image Captioner Tool with model: gpt-4o
+!! Cache enabled for model: gpt-4o
+{'tool_name': 'Image_Captioner_Tool', 'tool_description': "A tool that generates captions for images using OpenAI's multimodal model.", 'tool_version': '1.0.0', 'input_types': {'image': 'str - The path to the image file.', 'prompt': "str - The prompt to guide the image captioning (default: 'Describe this image in detail.')."}, 'output_type': 'str - The generated caption for the image.', 'demo_commands': [{'command': 'execution = tool.execute(image="path/to/image.png")', 'description': 'Generate a caption for an image using the default prompt and model.'}, {'command': 'execution = tool.execute(image="path/to/image.png", prompt="Explain the mood of this scene.")', 'description': 'Generate a caption focusing on the mood using a specific prompt and model.'}], 'require_llm_engine': True, 'user_metadata': {'limitation': 'The Image_Captioner_Tool provides general image descriptions but has limitations: 1) May make mistakes in complex scenes, counting, attribute detection, and understanding object relationships. 2) Might not generate comprehensive captions, especially for images with multiple objects or abstract concepts. 3) Performance varies with image complexity. 4) Struggles with culturally specific or domain-specific content. 5) May overlook details or misinterpret object relationships. For precise descriptions, consider: using it with other tools for context/verification, as an initial step before refinement, or in multi-step processes for ambiguity resolution. Verify critical information with specialized tools or human expertise when necessary.'}}
+Generated Caption:
+"The image shows four blue buckets, each containing five baseballs. The buckets are arranged in a grid pattern with three on the top row and one on the bottom left. Each bucket has a handle on the side, and the baseballs inside are white with red stitching, typical of standard baseballs. The background is plain white, emphasizing the buckets and their contents."
+Done!

octotools/tools/image_captioner/tool.py

@@ -0,0 +1,96 @@
+import os
+from octotools.tools.base import BaseTool
+from octotools.engine.openai import ChatOpenAI
+
+class Image_Captioner_Tool(BaseTool):
+    require_llm_engine = True
+
+    def __init__(self, model_string="gpt-4o-mini"):
+        super().__init__(
+            tool_name="Image_Captioner_Tool",
+            tool_description="A tool that generates captions for images using OpenAI's multimodal model.",
+            tool_version="1.0.0",
+            input_types={
+                "image": "str - The path to the image file.",
+                "prompt": "str - The prompt to guide the image captioning (default: 'Describe this image in detail.').",
+            },
+            output_type="str - The generated caption for the image.",
+            demo_commands=[
+                {
+                    "command": 'execution = tool.execute(image="path/to/image.png")',
+                    "description": "Generate a caption for an image using the default prompt and model."
+                },
+                {
+                    "command": 'execution = tool.execute(image="path/to/image.png", prompt="Explain the mood of this scene.")',
+                    "description": "Generate a caption focusing on the mood using a specific prompt and model."
+                }
+            ],
+            user_metadata = {
+                "limitation": "The Image_Captioner_Tool provides general image descriptions but has limitations: 1) May make mistakes in complex scenes, counting, attribute detection, and understanding object relationships. 2) Might not generate comprehensive captions, especially for images with multiple objects or abstract concepts. 3) Performance varies with image complexity. 4) Struggles with culturally specific or domain-specific content. 5) May overlook details or misinterpret object relationships. For precise descriptions, consider: using it with other tools for context/verification, as an initial step before refinement, or in multi-step processes for ambiguity resolution. Verify critical information with specialized tools or human expertise when necessary."
+            },
+        )
+        print(f"\nInitializing Image Captioner Tool with model: {model_string}")
+        self.llm_engine = ChatOpenAI(model_string=model_string, is_multimodal=True) if model_string else None
+
+    def execute(self, image, prompt="Describe this image in detail."):
+        try:
+            if not self.llm_engine:
+                return "Error: LLM engine not initialized. Please provide a valid model_string."
+                
+            input_data = [prompt]
+            
+            if image and os.path.isfile(image):
+                try:
+                    with open(image, 'rb') as file:
+                        image_bytes = file.read()
+                    input_data.append(image_bytes)
+                except Exception as e:
+                    return f"Error reading image file: {str(e)}"
+            else:
+                return "Error: Invalid image file path."
+
+            caption = self.llm_engine(input_data)
+            return caption
+        except Exception as e:
+            return f"Error generating caption: {str(e)}"
+
+    def get_metadata(self):
+        metadata = super().get_metadata()
+        metadata['require_llm_engine'] = self.require_llm_engine # NOTE: can be removed if not needed
+        return metadata
+
+if __name__ == "__main__":
+    # Test command:
+    """
+    Run the following commands in the terminal to test the script:
+    
+    cd octotools/tools/image_captioner
+    python tool.py
+    """
+
+    import json
+
+    # Get the directory of the current script
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+
+    # Example usage of the Image_Captioner_Tool
+    # tool = Image_Captioner_Tool()
+    tool = Image_Captioner_Tool(model_string="gpt-4o")
+
+    # Get tool metadata
+    metadata = tool.get_metadata()
+    print(metadata)
+
+    # Construct the full path to the image using the script's directory
+    relative_image_path = "examples/baseball.png"
+    image_path = os.path.join(script_dir, relative_image_path)
+
+    # Execute the tool with default prompt
+    try:
+        execution = tool.execute(image=image_path)
+        print("Generated Caption:")
+        print(json.dumps(execution, indent=4)) 
+    except Exception as e: 
+        print(f"Execution failed: {e}")
+
+    print("Done!")

octotools/tools/nature_news_fetcher/test.log

@@ -0,0 +1,180 @@
+{'tool_name': 'Nature_News_Fetcher_Tool', 'tool_description': 'A tool that fetches the latest news articles from Nature.', 'tool_version': '1.0.0', 'input_types': {'num_articles': 'int - The number of articles to fetch (default: 100).', 'max_pages': 'int - The maximum number of pages to fetch (default: 5).'}, 'output_type': 'list - A list of dictionaries containing information about the latest Nature news articles.', 'demo_commands': [{'command': 'execution = tool.execute()', 'description': 'Fetch the latest 100 news articles from Nature.'}, {'command': 'execution = tool.execute(num_articles=50, max_pages=3)', 'description': 'Fetch the latest 50 news articles from Nature, searching up to 3 pages.'}], 'require_llm_engine': False}
+[
+    {
+        "title": "NASA embraced diversity. Trump\u2019s DEI purge is hitting space scientists hard",
+        "url": "https://www.nature.com/articles/d41586-025-00480-x",
+        "description": "Some researchers at NASA and outside it feel betrayed by the changes at the agency, which was known for promoting inclusion in science.",
+        "authors": [
+            "Alexandra Witze"
+        ],
+        "date": "2025-02-14",
+        "image_url": "https://media.springernature.com/w290h158/magazine-assets/d41586-025-00480-x/d41586-025-00480-x_50636314.jpg"
+    },
+    {
+        "title": "Are the Trump team\u2019s actions affecting your research? How to contact Nature",
+        "url": "https://www.nature.com/articles/d41586-025-00479-4",
+        "description": "Use this form to share information with Nature\u2019s news team, or to make suggestions for future coverage.",
+        "authors": [
+            "No authors found"
+        ],
+        "date": "2025-02-13",
+        "image_url": "https://media.springernature.com/w290h158/magazine-assets/d41586-025-00479-4/d41586-025-00479-4_50626000.jpg"
+    },
+    {
+        "title": "Scientists use AI to design life-like enzymes from scratch",
+        "url": "https://www.nature.com/articles/d41586-025-00488-3",
+        "description": "Combined approach takes AI-engineered enzymes one step closer to practical applications.",
+        "authors": [
+            "Miryam Naddaf"
+        ],
+        "date": "2025-02-13",
+        "image_url": "https://media.springernature.com/w290h158/magazine-assets/d41586-025-00488-3/d41586-025-00488-3_50636094.jpg"
+    },
+    {
+        "title": "Royal Society will meet amid campaign to revoke Elon Musk\u2019s fellowship",
+        "url": "https://www.nature.com/articles/d41586-025-00486-5",
+        "description": "More than 1,300 scientists have signed a letter calling on the world\u2019s oldest science society to reassess the billionaire\u2019s membership following cuts to US science.",
+        "authors": [
+            "Holly Else"
+        ],
+        "date": "2025-02-13",
+        "image_url": "https://media.springernature.com/w290h158/magazine-assets/d41586-025-00486-5/d41586-025-00486-5_50635956.jpg"
+    },
+    {
+        "title": "Vaccine sceptic RFK Jr is now a powerful force in US science: what will he do?",
+        "url": "https://www.nature.com/articles/d41586-025-00439-y",
+        "description": "Kennedy has expressed support for some fields, but has also declared he\u2019d like a \u2018break\u2019 in infectious-disease research.",
+        "authors": [
+            "Amanda Heidt",
+            "Heidi Ledford"
+        ],
+        "date": "2025-02-13",
+        "image_url": "https://media.springernature.com/w290h158/magazine-assets/d41586-025-00439-y/d41586-025-00439-y_50621992.jpg"
+    },
+    {
+        "title": "Are PhDs losing their lustre? Why fewer students are enrolling in doctoral degrees",
+        "url": "https://www.nature.com/articles/d41586-025-00425-4",
+        "description": "High living costs paired with stagnant stipends are being blamed for a drop in PhD enrolments in several countries.",
+        "authors": [
+            "Diana Kwon"
+        ],
+        "date": "2025-02-13",
+        "image_url": "https://media.springernature.com/w290h158/magazine-assets/d41586-025-00425-4/d41586-025-00425-4_50621644.jpg"
+    },
+    {
+        "title": "Quantum-computing technology that makes qubits from atoms wins mega investment",
+        "url": "https://www.nature.com/articles/d41586-025-00451-2",
+        "description": "Firms using \u2018neutral atoms\u2019 to create qubits are reentering the race to build useful quantum machines.",
+        "authors": [
+            "Elizabeth Gibney"
+        ],
+        "date": "2025-02-13",
+        "image_url": "https://media.springernature.com/w290h158/magazine-assets/d41586-025-00451-2/d41586-025-00451-2_50636260.jpg"
+    },
+    {
+        "title": "Cheap blood test detects pancreatic cancer before it spreads",
+        "url": "https://www.nature.com/articles/d41586-025-00438-z",
+        "description": "The deadly cancer is often not found until it has spread to other parts of the body.",
+        "authors": [
+            "Smriti Mallapaty"
+        ],
+        "date": "2025-02-12",
+        "image_url": "https://media.springernature.com/w290h158/magazine-assets/d41586-025-00438-z/d41586-025-00438-z_50621748.jpg"
+    },
+    {
+        "title": "How centuries of isolation shaped Greenlanders\u2019 unique genetics",
+        "url": "https://www.nature.com/articles/d41586-025-00443-2",
+        "description": "Centuries of isolation have given Greenlanders a genetic profile that includes Arctic-specific variants.",
+        "authors": [
+            "Freda Kreier"
+        ],
+        "date": "2025-02-12",
+        "image_url": "https://media.springernature.com/w290h158/magazine-assets/d41586-025-00443-2/d41586-025-00443-2_50625480.jpg"
+    },
+    {
+        "title": "Record-breaking neutrino is most energetic ever detected",
+        "url": "https://www.nature.com/articles/d41586-025-00444-1",
+        "description": "Although still under construction, the sea-floor KM3NeT detector spotted a neutrino 20 times more powerful than any previously detected.",
+        "authors": [
+            "Davide Castelvecchi"
+        ],
+        "date": "2025-02-12",
+        "image_url": "https://media.springernature.com/w290h158/magazine-assets/d41586-025-00444-1/d41586-025-00444-1_50625568.jpg"
+    }
+]
+
+Execution Result:
+Number of articles fetched: 10
+
+Sample articles:
+
+1. Title: NASA embraced diversity. Trump’s DEI purge is hitting space scientists hard
+   URL: https://www.nature.com/articles/d41586-025-00480-x
+   Description: Some researchers at NASA and outside it feel betrayed by the changes at the agency, which was known ...
+   Authors: Alexandra Witze
+   Date: 2025-02-14
+   Image URL: https://media.springernature.com/w290h158/magazine-assets/d41586-025-00480-x/d41586-025-00480-x_50636314.jpg
+
+2. Title: Are the Trump team’s actions affecting your research? How to contact Nature
+   URL: https://www.nature.com/articles/d41586-025-00479-4
+   Description: Use this form to share information with Nature’s news team, or to make suggestions for future covera...
+   Authors: No authors found
+   Date: 2025-02-13
+   Image URL: https://media.springernature.com/w290h158/magazine-assets/d41586-025-00479-4/d41586-025-00479-4_50626000.jpg
+
+3. Title: Scientists use AI to design life-like enzymes from scratch
+   URL: https://www.nature.com/articles/d41586-025-00488-3
+   Description: Combined approach takes AI-engineered enzymes one step closer to practical applications....
+   Authors: Miryam Naddaf
+   Date: 2025-02-13
+   Image URL: https://media.springernature.com/w290h158/magazine-assets/d41586-025-00488-3/d41586-025-00488-3_50636094.jpg
+
+4. Title: Royal Society will meet amid campaign to revoke Elon Musk’s fellowship
+   URL: https://www.nature.com/articles/d41586-025-00486-5
+   Description: More than 1,300 scientists have signed a letter calling on the world’s oldest science society to rea...
+   Authors: Holly Else
+   Date: 2025-02-13
+   Image URL: https://media.springernature.com/w290h158/magazine-assets/d41586-025-00486-5/d41586-025-00486-5_50635956.jpg
+
+5. Title: Vaccine sceptic RFK Jr is now a powerful force in US science: what will he do?
+   URL: https://www.nature.com/articles/d41586-025-00439-y
+   Description: Kennedy has expressed support for some fields, but has also declared he’d like a ‘break’ in infectio...
+   Authors: Amanda Heidt, Heidi Ledford
+   Date: 2025-02-13
+   Image URL: https://media.springernature.com/w290h158/magazine-assets/d41586-025-00439-y/d41586-025-00439-y_50621992.jpg
+
+6. Title: Are PhDs losing their lustre? Why fewer students are enrolling in doctoral degrees
+   URL: https://www.nature.com/articles/d41586-025-00425-4
+   Description: High living costs paired with stagnant stipends are being blamed for a drop in PhD enrolments in sev...
+   Authors: Diana Kwon
+   Date: 2025-02-13
+   Image URL: https://media.springernature.com/w290h158/magazine-assets/d41586-025-00425-4/d41586-025-00425-4_50621644.jpg
+
+7. Title: Quantum-computing technology that makes qubits from atoms wins mega investment
+   URL: https://www.nature.com/articles/d41586-025-00451-2
+   Description: Firms using ‘neutral atoms’ to create qubits are reentering the race to build useful quantum machine...
+   Authors: Elizabeth Gibney
+   Date: 2025-02-13
+   Image URL: https://media.springernature.com/w290h158/magazine-assets/d41586-025-00451-2/d41586-025-00451-2_50636260.jpg
+
+8. Title: Cheap blood test detects pancreatic cancer before it spreads
+   URL: https://www.nature.com/articles/d41586-025-00438-z
+   Description: The deadly cancer is often not found until it has spread to other parts of the body....
+   Authors: Smriti Mallapaty
+   Date: 2025-02-12
+   Image URL: https://media.springernature.com/w290h158/magazine-assets/d41586-025-00438-z/d41586-025-00438-z_50621748.jpg
+
+9. Title: How centuries of isolation shaped Greenlanders’ unique genetics
+   URL: https://www.nature.com/articles/d41586-025-00443-2
+   Description: Centuries of isolation have given Greenlanders a genetic profile that includes Arctic-specific varia...
+   Authors: Freda Kreier
+   Date: 2025-02-12
+   Image URL: https://media.springernature.com/w290h158/magazine-assets/d41586-025-00443-2/d41586-025-00443-2_50625480.jpg
+
+10. Title: Record-breaking neutrino is most energetic ever detected
+   URL: https://www.nature.com/articles/d41586-025-00444-1
+   Description: Although still under construction, the sea-floor KM3NeT detector spotted a neutrino 20 times more po...
+   Authors: Davide Castelvecchi
+   Date: 2025-02-12
+   Image URL: https://media.springernature.com/w290h158/magazine-assets/d41586-025-00444-1/d41586-025-00444-1_50625568.jpg
+Done!

octotools/tools/nature_news_fetcher/tool.py

@@ -0,0 +1,181 @@
+import os
+import requests
+from bs4 import BeautifulSoup
+import time
+
+from octotools.tools.base import BaseTool
+
+class Nature_News_Fetcher_Tool(BaseTool):
+    def __init__(self):
+        super().__init__(
+            tool_name="Nature_News_Fetcher_Tool",
+            tool_description="A tool that fetches the latest news articles from Nature.",
+            tool_version="1.0.0",
+            input_types={
+                "num_articles": "int - The number of articles to fetch (default: 100).",
+                "max_pages": "int - The maximum number of pages to fetch (default: 5).",
+            },
+            output_type="list - A list of dictionaries containing information about the latest Nature news articles.",
+            demo_commands=[
+                {
+                    "command": 'execution = tool.execute()',
+                    "description": "Fetch the latest 100 news articles from Nature."
+                },
+                {
+                    "command": 'execution = tool.execute(num_articles=50, max_pages=3)',
+                    "description": "Fetch the latest 50 news articles from Nature, searching up to 3 pages."
+                },
+            ],
+        )
+        self.base_url = "https://www.nature.com/nature/articles"
+
+    def fetch_page(self, page_number):
+        """
+        Fetches a single page of news articles from Nature's website.
+
+        Parameters:
+            page_number (int): The page number to fetch.
+
+        Returns:
+            str: The HTML content of the page.
+        """
+        params = {
+            "searchType": "journalSearch",
+            "sort": "PubDate",
+            "type": "news",
+            "page": str(page_number)
+        }
+        headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
+        }
+        response = requests.get(self.base_url, params=params, headers=headers)
+        response.raise_for_status()
+        return response.text
+
+    def parse_articles(self, html_content):
+        """
+        Parses the HTML content and extracts article information.
+
+        Parameters:
+            html_content (str): The HTML content of the page.
+
+        Returns:
+            list: A list of dictionaries containing article information.
+        """
+        soup = BeautifulSoup(html_content, 'html.parser')
+        articles_section = soup.find('section', id='new-article-list')
+        if not articles_section:
+            return []
+
+        articles = []
+        for article in articles_section.find_all('article', class_='c-card'):
+            title_elem = article.find('h3', class_='c-card__title')
+            title = title_elem.text.strip() if title_elem else "No title found"
+            
+            url_elem = title_elem.find('a') if title_elem else None
+            url = "https://www.nature.com" + url_elem['href'] if url_elem and 'href' in url_elem.attrs else "No URL found"
+            
+            description_elem = article.find('div', {'data-test': 'article-description'})
+            description = description_elem.text.strip() if description_elem else "No description available"
+            
+            authors_elem = article.find('ul', {'data-test': 'author-list'})
+            authors = [author.text.strip() for author in authors_elem.find_all('li')] if authors_elem else ["No authors found"]
+            
+            date_elem = article.find('time')
+            date = date_elem['datetime'] if date_elem and 'datetime' in date_elem.attrs else "No date found"
+
+            image_elem = article.find('img')
+            image_url = image_elem['src'] if image_elem and 'src' in image_elem.attrs else "No image found"
+
+            articles.append({
+                'title': title,
+                'url': url,
+                'description': description,
+                'authors': authors,
+                'date': date,
+                'image_url': image_url
+            })
+
+        return articles
+
+    def execute(self, num_articles=100, max_pages=5):
+        """
+        Fetches the latest news articles from Nature's website.
+
+        Parameters:
+            num_articles (int): The number of articles to fetch.
+            max_pages (int): The maximum number of pages to fetch.
+
+        Returns:
+            list: A list of dictionaries containing article information.
+        """
+        all_articles = []
+        page_number = 1
+
+        try:
+            while len(all_articles) < num_articles and page_number <= max_pages:
+                html_content = self.fetch_page(page_number)
+                page_articles = self.parse_articles(html_content)
+                
+                if not page_articles:
+                    break  # No more articles found
+
+                all_articles.extend(page_articles)
+                page_number += 1
+                time.sleep(1)  # Be polite to the server
+
+            return all_articles[:num_articles]
+        except Exception as e:
+            return [{"error": str(e)}]
+
+    def get_metadata(self):
+        """
+        Returns the metadata for the Nature_News_Fetcher_Tool.
+
+        Returns:
+            dict: A dictionary containing the tool's metadata.
+        """
+        metadata = super().get_metadata()
+        return metadata
+
+
+if __name__ == "__main__":
+    # Test command:
+    """
+    Run the following commands in the terminal to test the script:
+
+    cd octotools/tools/nature_news_fetcher
+    python tool.py
+    """
+
+    # Get the directory of the current script
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+
+    # Example usage of the Nature_News_Fetcher_Tool
+    tool = Nature_News_Fetcher_Tool()
+
+    # Get tool metadata
+    metadata = tool.get_metadata()
+    print(metadata)
+
+    import json
+  
+
+    # Execute the tool to fetch the latest 10 articles (for demonstration purposes)
+    try:
+        execution = tool.execute(num_articles=10, max_pages=1)
+        print(json.dumps(execution, indent=4))
+        print("\nExecution Result:")
+        print(f"Number of articles fetched: {len(execution)}")
+        print("\nSample articles:")
+        for i, article in enumerate(execution[:10], 1):
+            print(f"\n{i}. Title: {article['title']}")
+            print(f"   URL: {article['url']}")
+            print(f"   Description: {article['description'][:100]}...")  # Show first 100 characters
+            print(f"   Authors: {', '.join(article['authors'])}")
+            print(f"   Date: {article['date']}")
+            print(f"   Image URL: {article['image_url']}")
+    except Exception as e:
+        print(f"Execution failed: {e}")
+
+    print("Done!")

octotools/tools/object_detector/test.log

@@ -0,0 +1,112 @@
+Could not load the custom kernel for multi-scale deformable attention: Command '['which', 'c++']' returned non-zero exit status 1.
+Could not load the custom kernel for multi-scale deformable attention: /root/.cache/torch_extensions/py310_cu121/MultiScaleDeformableAttention/MultiScaleDeformableAttention.so: cannot open shared object file: No such file or directory
+Could not load the custom kernel for multi-scale deformable attention: /root/.cache/torch_extensions/py310_cu121/MultiScaleDeformableAttention/MultiScaleDeformableAttention.so: cannot open shared object file: No such file or directory
+Could not load the custom kernel for multi-scale deformable attention: /root/.cache/torch_extensions/py310_cu121/MultiScaleDeformableAttention/MultiScaleDeformableAttention.so: cannot open shared object file: No such file or directory
+Could not load the custom kernel for multi-scale deformable attention: /root/.cache/torch_extensions/py310_cu121/MultiScaleDeformableAttention/MultiScaleDeformableAttention.so: cannot open shared object file: No such file or directory
+Could not load the custom kernel for multi-scale deformable attention: /root/.cache/torch_extensions/py310_cu121/MultiScaleDeformableAttention/MultiScaleDeformableAttention.so: cannot open shared object file: No such file or directory
+Could not load the custom kernel for multi-scale deformable attention: /root/.cache/torch_extensions/py310_cu121/MultiScaleDeformableAttention/MultiScaleDeformableAttention.so: cannot open shared object file: No such file or directory
+Could not load the custom kernel for multi-scale deformable attention: /root/.cache/torch_extensions/py310_cu121/MultiScaleDeformableAttention/MultiScaleDeformableAttention.so: cannot open shared object file: No such file or directory
+Could not load the custom kernel for multi-scale deformable attention: /root/.cache/torch_extensions/py310_cu121/MultiScaleDeformableAttention/MultiScaleDeformableAttention.so: cannot open shared object file: No such file or directory
+Could not load the custom kernel for multi-scale deformable attention: /root/.cache/torch_extensions/py310_cu121/MultiScaleDeformableAttention/MultiScaleDeformableAttention.so: cannot open shared object file: No such file or directory
+Could not load the custom kernel for multi-scale deformable attention: /root/.cache/torch_extensions/py310_cu121/MultiScaleDeformableAttention/MultiScaleDeformableAttention.so: cannot open shared object file: No such file or directory
+Could not load the custom kernel for multi-scale deformable attention: /root/.cache/torch_extensions/py310_cu121/MultiScaleDeformableAttention/MultiScaleDeformableAttention.so: cannot open shared object file: No such file or directory
+CUDA_HOME is not set
+{'tool_name': 'Object_Detector_Tool', 'tool_description': 'A tool that detects objects in an image using the Grounding DINO model and saves individual object images with empty padding.', 'tool_version': '1.0.0', 'input_types': {'image': 'str - The path to the image file.', 'labels': 'list - A list of object labels to detect.', 'threshold': 'float - The confidence threshold for detection (default: 0.35).', 'model_size': "str - The size of the model to use ('tiny' or 'base', default: 'tiny').", 'padding': 'int - The number of pixels to add as empty padding around detected objects (default: 20).'}, 'output_type': 'list - A list of detected objects with their scores, bounding boxes, and saved image paths.', 'demo_commands': [{'command': 'execution = tool.execute(image="path/to/image.png", labels=["baseball", "basket"])', 'description': 'Detect baseball and basket in an image, save the detected objects with default empty padding, and return their paths.'}, {'command': 'execution = tool.execute(image="path/to/image.png", labels=["car", "person"], threshold=0.5, model_size="base", padding=15)', 'description': 'Detect car and person in an image using the base model, save the detected objects with 15 pixels of empty padding, and return their paths.'}], 'require_llm_engine': False, 'user_metadata': {'limitation': 'The model may not always detect objects accurately, and its performance can vary depending on the input image and the associated labels. It typically struggles with detecting small objects, objects that are uncommon, or objects with limited or specific attributes. For improved accuracy or better detection in certain situations, consider using supplementary tools or image processing techniques to provide additional information for verification.'}}
+Detected Objects:
+Detected baseball with confidence 0.69
+Bounding box: (558, 48, 615, 107)
+Saved image (with padding): detected_objects/baseball_baseball_1.png
+
+Detected baseball with confidence 0.69
+Bounding box: (614, 137, 671, 191)
+Saved image (with padding): detected_objects/baseball_baseball_2.png
+
+Detected baseball with confidence 0.68
+Bounding box: (132, 67, 189, 126)
+Saved image (with padding): detected_objects/baseball_baseball_3.png
+
+Detected baseball with confidence 0.68
+Bounding box: (632, 67, 690, 126)
+Saved image (with padding): detected_objects/baseball_baseball_4.png
+
+Detected baseball with confidence 0.68
+Bounding box: (57, 289, 115, 346)
+Saved image (with padding): detected_objects/baseball_baseball_5.png
+
+Detected baseball with confidence 0.68
+Bounding box: (535, 111, 592, 170)
+Saved image (with padding): detected_objects/baseball_baseball_6.png
+
+Detected baseball with confidence 0.68
+Bounding box: (307, 48, 365, 107)
+Saved image (with padding): detected_objects/baseball_baseball_7.png
+
+Detected baseball with confidence 0.68
+Bounding box: (114, 137, 171, 191)
+Saved image (with padding): detected_objects/baseball_baseball_8.png
+
+Detected baseball with confidence 0.68
+Bounding box: (35, 351, 91, 410)
+Saved image (with padding): detected_objects/baseball_baseball_9.png
+
+Detected baseball with confidence 0.68
+Bounding box: (57, 48, 115, 107)
+Saved image (with padding): detected_objects/baseball_baseball_10.png
+
+Detected baseball with confidence 0.68
+Bounding box: (35, 111, 91, 170)
+Saved image (with padding): detected_objects/baseball_baseball_11.png
+
+Detected baseball with confidence 0.68
+Bounding box: (364, 137, 421, 191)
+Saved image (with padding): detected_objects/baseball_baseball_12.png
+
+Detected baseball with confidence 0.68
+Bounding box: (114, 377, 171, 430)
+Saved image (with padding): detected_objects/baseball_baseball_13.png
+
+Detected baseball with confidence 0.67
+Bounding box: (132, 307, 189, 366)
+Saved image (with padding): detected_objects/baseball_baseball_14.png
+
+Detected baseball with confidence 0.67
+Bounding box: (285, 111, 342, 170)
+Saved image (with padding): detected_objects/baseball_baseball_15.png
+
+Detected baseball with confidence 0.67
+Bounding box: (382, 67, 439, 126)
+Saved image (with padding): detected_objects/baseball_baseball_16.png
+
+Detected baseball with confidence 0.65
+Bounding box: (587, 94, 643, 153)
+Saved image (with padding): detected_objects/baseball_baseball_17.png
+
+Detected baseball with confidence 0.65
+Bounding box: (86, 94, 143, 153)
+Saved image (with padding): detected_objects/baseball_baseball_18.png
+
+Detected baseball with confidence 0.65
+Bounding box: (86, 335, 143, 393)
+Saved image (with padding): detected_objects/baseball_baseball_19.png
+
+Detected baseball with confidence 0.63
+Bounding box: (336, 95, 393, 153)
+Saved image (with padding): detected_objects/baseball_baseball_20.png
+
+Detected basket with confidence 0.59
+Bounding box: (252, 2, 468, 215)
+Saved image (with padding): detected_objects/baseball_basket_1.png
+
+Detected basket with confidence 0.55
+Bounding box: (503, 2, 717, 215)
+Saved image (with padding): detected_objects/baseball_basket_2.png
+
+Detected basket with confidence 0.54
+Bounding box: (2, 2, 217, 215)
+Saved image (with padding): detected_objects/baseball_basket_3.png
+
+Detected basket with confidence 0.5
+Bounding box: (2, 242, 217, 455)
+Saved image (with padding): detected_objects/baseball_basket_4.png
+
+Done!

octotools/tools/object_detector/tool.py

@@ -0,0 +1,179 @@
+# Grounding DINO Object Detection Tool
+# https://huggingface.co/IDEA-Research/grounding-dino
+
+import os
+import time
+import torch
+from transformers import pipeline
+
+from octotools.tools.base import BaseTool
+from PIL import Image, ImageOps
+
+import os
+# If CUDA_HOME is set, print the value
+print(os.environ.get('CUDA_HOME', 'CUDA_HOME is not set'))
+
+# Suppress stderr by redirecting it to /dev/null
+import sys
+sys.stderr = open(os.devnull, 'w')
+
+import warnings
+warnings.filterwarnings("ignore")
+
+
+class Object_Detector_Tool(BaseTool):
+    def __init__(self):
+        super().__init__(
+            tool_name="Object_Detector_Tool",
+            tool_description="A tool that detects objects in an image using the Grounding DINO model and saves individual object images with empty padding.",
+            tool_version="1.0.0",
+            input_types={
+                "image": "str - The path to the image file.",
+                "labels": "list - A list of object labels to detect.",
+                "threshold": "float - The confidence threshold for detection (default: 0.35).",
+                "model_size": "str - The size of the model to use ('tiny' or 'base', default: 'tiny').",
+                "padding": "int - The number of pixels to add as empty padding around detected objects (default: 20)."
+            },
+            output_type="list - A list of detected objects with their scores, bounding boxes, and saved image paths.",
+            demo_commands=[
+                {
+                    "command": 'execution = tool.execute(image="path/to/image.png", labels=["baseball", "basket"])',
+                    "description": "Detect baseball and basket in an image, save the detected objects with default empty padding, and return their paths."
+                },
+                {
+                    "command": 'execution = tool.execute(image="path/to/image.png", labels=["car", "person"], threshold=0.5, model_size="base", padding=15)',
+                    "description": "Detect car and person in an image using the base model, save the detected objects with 15 pixels of empty padding, and return their paths."
+                }
+            ],
+            user_metadata={
+                "limitation": "The model may not always detect objects accurately, and its performance can vary depending on the input image and the associated labels. It typically struggles with detecting small objects, objects that are uncommon, or objects with limited or specific attributes. For improved accuracy or better detection in certain situations, consider using supplementary tools or image processing techniques to provide additional information for verification."
+            }
+        )
+
+    def preprocess_caption(self, caption):
+        result = caption.lower().strip()
+        if result.endswith("."):
+            return result
+        return result + "."
+
+    def build_tool(self, model_size='tiny'):
+        model_name = f"IDEA-Research/grounding-dino-{model_size}"
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        try:
+            pipe = pipeline(model=model_name, task="zero-shot-object-detection", device=device)
+            return pipe
+        except Exception as e:
+            print(f"Error building the Object Detection tool: {e}")
+            return None
+
+    def save_detected_object(self, image, box, image_name, label, index, padding):
+        object_image = image.crop(box)
+        padded_image = ImageOps.expand(object_image, border=padding, fill='white')
+        
+        filename = f"{image_name}_{label}_{index}.png"
+        os.makedirs(self.output_dir, exist_ok=True)
+        save_path = os.path.join(self.output_dir, filename)
+        
+        padded_image.save(save_path)
+        return save_path
+
+    def execute(self, image, labels, threshold=0.35, model_size='tiny', padding=20, max_retries=10, retry_delay=5, clear_cuda_cache=False):
+        for attempt in range(max_retries):
+            try:
+                saved_files = []
+
+                pipe = self.build_tool(model_size)
+                if pipe is None:
+                    raise ValueError("Failed to build the Object Detection tool.")
+                
+                preprocessed_labels = [self.preprocess_caption(label) for label in labels]
+                results = pipe(image, candidate_labels=preprocessed_labels, threshold=threshold)
+                
+                formatted_results = []
+                original_image = Image.open(image)
+                image_name = os.path.splitext(os.path.basename(image))[0]
+                
+                object_counts = {}
+
+                for result in results:
+                    box = tuple(result["box"].values())
+                    label = result["label"]
+                    score = round(result["score"], 2)
+                    if label.endswith("."):
+                        label = label[:-1]
+                    
+                    object_counts[label] = object_counts.get(label, 0) + 1
+                    index = object_counts[label]
+                    
+                    save_path = self.save_detected_object(original_image, box, image_name, label, index, padding)
+            
+                    formatted_results.append({
+                        "label": label,
+                        "confidence score": score,
+                        "box": box,
+                        "saved_image_path": save_path
+                    })
+
+                return formatted_results
+            
+            except RuntimeError as e:
+                if "CUDA out of memory" in str(e):
+                    print(f"CUDA out of memory error on attempt {attempt + 1}.")
+                    if clear_cuda_cache:
+                        print("Clearing CUDA cache and retrying...")
+                        torch.cuda.empty_cache()
+                    else:
+                        print(f"Retrying in {retry_delay} seconds...")
+                    time.sleep(retry_delay)
+                    continue
+                else:
+                    print(f"Runtime error: {e}")
+                    break
+            except Exception as e:
+                print(f"Error detecting objects: {e}")
+                break
+        
+        print(f"Failed to detect objects after {max_retries} attempts.")
+        return []
+
+    def get_metadata(self):
+        metadata = super().get_metadata()
+        return metadata
+
+if __name__ == "__main__":
+    # Test command:
+    """
+    Run the following commands in the terminal to test the script:
+    
+    cd octotools/tools/object_detector
+    python tool.py
+    """
+
+    # Get the directory of the current script
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+
+    # Example usage of the Object_Detector_Tool
+    tool = Object_Detector_Tool()
+    tool.set_custom_output_dir("detected_objects")
+
+    # Get tool metadata
+    metadata = tool.get_metadata()
+    print(metadata)
+
+    # Construct the full path to the image using the script's directory
+    relative_image_path = "examples/baseball.png"
+    image_path = os.path.join(script_dir, relative_image_path)
+
+    # Execute the tool
+    try:
+        execution = tool.execute(image=image_path, labels=["baseball", "basket"], padding=20)
+        print("Detected Objects:")
+        for obj in execution:
+            print(f"Detected {obj['label']} with confidence {obj['confidence score']}")
+            print(f"Bounding box: {obj['box']}")
+            print(f"Saved image (with padding): {obj['saved_image_path']}")
+            print()
+    except ValueError as e: 
+        print(f"Execution failed: {e}")
+
+    print("Done!")

octotools/tools/pubmed_search/test.log

@@ -0,0 +1,3 @@
+2025-02-14 19:03:45 06a0c5b0e177 metapub.config[158535] WARNING NCBI_API_KEY was not set.
+[{'title': 'Safety of health workers during the COVID-19 pandemic and beyond: piloting WHO framework in Iran.', 'abstract': "BACKGROUND: Health Workers Safety (HWS) is a global health priority and essential at all times, in stable situations, in emergencies, in disease epidemics or pandemics. This study aimed to assess HWS during the COVID-19 Pandemic.\nMETHODS: This cross-sectional study was conducted in 2022 in east Azerbaijan province, Iran. HWS was assessed based on 22 indicators suggested by WHO EMRO. We selected 15 PHC facilities and six wards from two hospitals randomly. Data collected (qualitative and quantitative) using national digital health records, staff records, and indicator-specific tools. In addition to measuring the indicator's value, the indicators' feasibility was also assessed. Descriptive and inferential statistics with SPSS-16 were used for data analysis.\nRESULTS: Totally, 325 Health Workers (HWs) (218 from PHC facilities and 107 from hospitals) participated in the study. Most of the participants in PHC facilities and hospitals were Community Health Workers (CHWs) (Moragheb Salamat) (45.4%) and nurses (37.38%), respectively. Most of HWs had completed the full vaccination schedule for Hepatitis B and COVID-19. Personal Protective Equipment (PPE) safety protocols were adhered by most of HWs within a healthcare facility. None of managers had attended nationally certified training for mental health support for health and care workers. Less than 20% of HWs participated in the work burnout prevention courses and most of HWs complained about work overload, or burnout. The job satisfaction level of hospital HWs (60.20%) was significantly higher than that of HWs from PHC facilities (57.18%) (P\u2009<\u20090.001).\nCONCLUSION: Even though the mental health of HWs was not as expected, the indicators related to physical health and occupational health were at a suitable level. Also, there is not a system in PHC to audit the application of safety measures to mitigate the risk of contracting COVID-19. We recommend creating a specific system (precise and detailed) for HWs' safety and applying safety measures in the PHC routine programs.", 'keywords': ['Assessment', 'COVID-19 pandemic', 'Health worker', 'Iran', 'Safety'], 'url': 'https://ncbi.nlm.nih.gov/pubmed/39920792'}, {'title': 'Experiences of working as a clinical nurse while pregnant during the coronavirus disease-2019 pandemic: a qualitative study.', 'abstract': 'BACKGROUND: Working as a pregnant clinical nurse might experience a range of challenges, such as significant anatomical and physiological changes as well as emotional and cognitive changes. That might be particularly obvious under the historical background of coronavirus disease-2019 (COVID-19) pandemic. However, a dearth of studies has explored the experiences of working as a pregnant nurse during this special period. This study aimed to explore the experiences of working as a clinical nurse while pregnant during the COVID-19 pandemic.\nMETHODS: A descriptive qualitative design was selected. Purposive sampling, combined with maximum variation strategy and snowball sampling, were utilized to identify and select participants from tertiary-teaching hospitals, specialized hospitals, and community hospitals in Zhejiang Province, southeastern China. Online semi-structured individual interviews were used to collect data, and conventional content analysis was used to analyze the data.\nRESULTS: Eleven Chinese nurses with a mean age of 31.8 years, ranging from 26 to 40 years, participated in this study. Four themes and twelve subthemes emerged: (1) still adhering to work as a clinical nurse despite being pregnant during the pandemic; (2) working during pregnancy under pandemic is still an ordinary nurse; (3) still staying in the special life phase as a pregnant mother; and (4) growth and gains as pregnant mother.\nCONCLUSION: The pregnant clinical nurses suffered from various changes and difficulties during the pandemic. Managers, occupational health and other health system leaders, and policymakers should be aware of the importance of establishing a work environment that guarantees safe continued pregnancy. Future studies should focus on the establishment of specific guidelines and manuals regarding how pregnant nurses worked, as well as the development of self-protection interventions during pregnancy. Moreover, research on moral stigma and bullying in nursing during pregnancy deserves further exploration.\nCLINICAL TRIAL NUMBER: Not applicable.', 'keywords': ['COVID-19 pandemic', 'Experiences', 'Nurse', 'Pregnant', 'Qualitative research'], 'url': 'https://ncbi.nlm.nih.gov/pubmed/39901239'}, {'title': "Development and psychometric validation of the frontline health workers' occupational risk and characteristics in emergencies index (FORCE-index) - The covid Hospital cohort study.", 'abstract': "OBJECTIVES: A lack of tools for the systematic identification of frontline health workers' changing occupational risks, characteristics, and needs, poses a major barrier to supporting vital personnel to stay in practice through health emergencies and beyond. The current study reports on the development and psychometric evaluation of the Frontline health workers' Occupational Risk and Characteristics in Emergencies index (FORCE-index).\nSTUDY DESIGN: The Covid hospital study is a large, multisite, four-wave, open cohort study of frontline health workers responding to the first four waves of the COVID-19 pandemic (2020-2022).\nMETHODS: 2496 frontline health workers responded to questionnaires assessing various aspects of their work environment. Using exploratory factor analysis, we estimated the latent structure of the FORCE-index at the first and second waves. This structure was evaluated using confirmatory factor analysis at the third and fourth waves. The internal consistency of the instrument's subscales (e.g., factors) was evaluated using omega reliability, Cronbach's alpha coefficient, and mean inter-item correlation.\nRESULTS: A nine-factor solution provided best fit to the data. These factors mapped onto the following aspects of the work environment; competency, stress management, familiarity, workload manageability, work performance, infection safety, personal protective equipment, social safety, and social support. Internal consistency for the full FORCE-index and the nine factors was satisfactory.\nCONCLUSIONS: The initial psychometric validation indicates that the FORCE-index is a valid measure which can be used by health authorities, services, and institutions to adequately and systematically assess central aspects of frontline health workers' work environment that are commonly challenged in health emergencies.", 'keywords': ['Covid-19', 'Frontline', 'Health Personnel', 'Health care worker', 'Health emergency', 'Health response', 'Hospital', 'Index', 'Infectious outbreak', 'Job characteristics', 'Occupational Health', 'Occupational diseases', 'Occupational exposure', 'Occupational stress', 'Preparedness', 'Preparedness planning', 'Psychometric', 'Scale', 'Stress', 'Work environment'], 'url': 'https://ncbi.nlm.nih.gov/pubmed/39896339'}, {'title': "A descriptive analysis of nurses' self-reported mental health symptoms during the COVID-19 pandemic: An international study.", 'abstract': "AIM: To describe the self-reported mental health of nurses from 35 countries who worked during the COVID-19 pandemic.\nBACKGROUND: There is little occupationally specific data about nurses' mental health worldwide. Studies have documented the impact on nurses' mental health of the COVID-19 pandemic, but few have baseline referents.\nMETHODS: A descriptive, cross-sectional design structured the study. Data reflect a convenience sample of\xa09,387 participants who completed the opt-in survey between July 31, 2022, and October 31, 2023. Descriptive statistics were run to analyze the following variables associated with mental health: Self-reports of mental health symptoms, burnout, personal losses during the pandemic, access to mental health services, and self-care practices used to cope with pandemic-related stressors. Reporting of this study was steered by the STROBE guideline for quantitative studies.\nRESULTS: Anxiety or depression occurred at rates ranging from 23%-61%, with country-specific trends in reporting observed. Approximately 18% of the sample reported experiencing some symptoms of burnout. The majority of nurses' employers did not provide mental health support in the workplace. Most reported more frequently engaging with self-care practices compared with before the pandemic. Notably, 20% of nurses suffered the loss of a family member, 35% lost a friend, and 34% a coworker due to COVID-19. Nearly half (48%) reported experiencing public aggression due to their identity as a nurse.\nCONCLUSIONS: The data obtained establish a basis for understanding the specific mental health needs of the nursing workforce globally, highlighting key areas for service development.\nIMPLICATIONS FOR NURSING POLICY: Healthcare organizations and governmental bodies need to develop targeted mental health support programs that are readily accessible to nurses to foster a resilient nursing workforce.", 'keywords': ['COVID‐19', 'global health', 'health workforce', 'nursing', 'nursing shortage', 'occupational health', 'occupational health nursing', 'pandemics'], 'url': 'https://ncbi.nlm.nih.gov/pubmed/39871528'}, {'title': 'Work Psychology and Occupational Health: An Editorial.', 'abstract': "Globally, the COVID-19 pandemic has severely impacted workers' health, particularly their mental well-being [...].", 'keywords': [], 'url': 'https://ncbi.nlm.nih.gov/pubmed/39857553'}, {'title': 'Analysis of HFE impact of COVID-19 on OHS in construction enterprises.', 'abstract': "Human factors are critical to Occupational Health and Safety (OHS) in construction enterprises. However, comprehensive industry-wide recognition remains challenging, underscoring the need for Human Factors Engineering (HFE) research. This study develops an optimized HFE evaluation model based on fundamental HFE principles. Examining COVID-19's significant impact on construction enterprise OHS, this research employs an empirical investigation of 259 cases, utilizing a model that integrates NetLogo's System Dynamics (SD) and Multiple Linear Regression (MLR) to analyze the interactions between human factors and other variables. The findings reveal four key factors influencing human factors: management, material, environmental, and methodological. These factors demonstrate a quadratic parabolic relationship, with peak influence occurring at step 36 of the research period. Twelve of the 20 survey factors exhibit a linear regression relationship with human factors' four sub-factors, with pre-job training (Q<sub>9</sub>) demonstrating multiple influential interactions. The strongest correlation is between pre-job training (Q<sub>9</sub>) and living materials (Q<sub>14</sub>), with a weight coefficient of .325. Psychological counseling (Q<sub>8</sub>) and living materials (Q<sub>14</sub>) show a close relationship (weight coefficient .301). Notably, Q<sub>9</sub> and empirical prevention materials (Q<sub>11</sub>) display a negative correlation with a weight coefficient of -.156. This study's practical significance lies in enabling enterprises to identify key HFE control factors and understand critical sub-factors for mitigating COVID-19's adverse impacts.", 'keywords': ['COVID-19', 'Human factors engineering (HFE)', 'Multiple linear regression (MLR)', 'NetLogo', 'Occupational health and safety (OHS)', 'System dynamics (SD)'], 'url': 'https://ncbi.nlm.nih.gov/pubmed/39811363'}, {'title': 'COVID-19 workplace countermeasures that occupational physicians could not change in Japan: a qualitative study.', 'abstract': 'BACKGROUND: During the COVID-19 pandemic, information and circumstances changed from moment to moment, including the accumulation of scientific knowledge, the emergence of variants, social tolerance, and government policy. Therefore, it was important to adapt workplace countermeasures punctually and flexibly based on scientific evidence and according to circumstances. However, there has been no assessment of changes in workplace countermeasures. With a view toward preparedness for future pandemics, we surveyed COVID-19 workplace countermeasures that occupational physicians considered as needing to be changed but went unchanged.\nMETHODS: We invited 685 professional occupational physicians certified by Japan Society for Occupational Health to complete an online questionnaire by sending postcards with QR codes. The main questions concerned countermeasures that the participants wanted to change but could not. The survey period was from February 21 to April 28, 2022. The responses were analyzed using the KJ method.\nRESULTS: Of the 168 invitees (24.5%) who responded to the survey, 125 reported countermeasures that needed to be changed (total count: 254). The responses were categorized into basic systems, occupational health services, workplace countermeasures, vaccines, and incidents, with a code count of 7, 8,147, 10, and 82, respectively. The type of countermeasure was 115 for countermeasures to be strengthened (CBS), 110 for measures to be mitigated (CBM), and 29 for neither.\nCONCLUSIONS: Often-mentioned CBS were increased teleworking, strengthened ventilation, smoking cessation, and promotion of vaccines. Often-mentioned CBM were relaxation of protective equipment rules, discontinued environmental disinfection, and shorted isolation and reinstatement. In the early pandemic phases, CBSs were frequently mentioned, whereas CBMs were featured more prominently in the latter phases. The survey revealed countermeasures that occupational physicians thought needed to be changed but were not changed in practice. For future responses to emerging and reemerging infectious diseases, it will be necessary to establish rules compatible with flexible modification of workplace countermeasures in response to changing circumstances.', 'keywords': ['COVID-19', 'Japan', 'Occupational health', 'Occupational physician', 'Workers', 'Workplace', 'Workplace countermeasures'], 'url': 'https://ncbi.nlm.nih.gov/pubmed/39780108'}, {'title': 'Rapid COVID-19 Testing of Symptomatic Health Care Personnel: A Strategy for Safely Maintaining the Workforce.', 'abstract': 'Determine performance characteristics and safety outcomes of two rapid COVID-19 screening methods to inform immediate return to work (RTW) decisions while (health care personnel) HCP await results of pending confirmatory laboratory test. Retrospective, occupational health quality improvement study comparing screening with rapid SARS-CoV-2 nucleic acid amplification (NAAT) and antigen test. 531 mildly symptomatic HCP screened over 16 months. Until more accurate affordable NAAT tests become available, antigen test screening alone addresses simultaneous needs to minimize COVID-19 transmission from symptomatic HCP and maintain an adequate workforce.', 'keywords': [], 'url': 'https://ncbi.nlm.nih.gov/pubmed/39739739'}, {'title': 'Satisfaction and Workload as Predictors of Psychological Distress in Professionals of Psychosocial Care Centers During the COVID-19 Pandemic.', 'abstract': 'BACKGROUND AND AIMS: The COVID-19 pandemic significantly impacted the mental health of healthcare professionals, especially those working in Psychosocial Care Centers (CAPS), which are crucial services in the Brazilian mental health system. This study aimed to investigate the association between job satisfaction, workload, and psychological distress among CAPS professionals during the pandemic.\nMETHODS: A cross-sectional study was conducted with 53 professionals from seven CAPS. The Workload Impact Scale (IMPACTO-BR) and Job Satisfaction Scale (SATIS-BR), the General Health Questionnaire (GHQ-12), and a sociodemographic questionnaire were used. Descriptive and analytical statistical analyses were performed. Multiple linear regression analysis was conducted to examine the relationship between job satisfaction, workload, and psychological distress.\nRESULTS: Professionals reported moderate satisfaction (3.67 ± 0.45) and mild workload (1.82 ± 0.63). One-third of the sample showed scores indicative of psychological distress. Multiple linear regression analysis revealed that workload (p = 0.0025) and low job satisfaction (p = 0.0495) were significantly associated with psychological distress.\nCONCLUSIONS: Low job satisfaction and high professional workload were predictive variables of psychological distress. These findings highlight the need for investments in promoting the quality of life at work for mental health professionals, especially during crises. The implications for human resource management and public policy development emphasize the importance of an integrated approach that considers the well-being of professionals for the effectiveness and sustainability of the psychosocial care model.', 'keywords': ['COVID-19', 'health personnel', 'job satisfaction', 'mental health', 'mental health services', 'occupational health'], 'url': 'https://ncbi.nlm.nih.gov/pubmed/39728651'}, {'title': 'Occupational-related risk of testing SARS-CoV-2 positive for publicly employed medical doctors in Sweden: A nationwide cohort study.', 'abstract': 'AIMS: Doctors have an increased risk of SARS-CoV-2 infection caused by exposure to contagious patients. We aimed to identify which clinical specialities among medical doctors had the highest occupation-related risk of testing positive for SARS-CoV-2, utilizing data for all publicly employed medical doctors in Sweden.\nMETHODS: Data regarding positive SARS-CoV-2 test results and employment for publicly employed doctors in Sweden were divided into three observation periods: 1) 1 February to 31 December 2020, 2) 1 January to 30 June 2021 and 3) 1 July 2021 to 31 March 2022. Individuals were stratified according to occupation clinic and compared with clinical occupations with little to no patient contact. The risk of testing positive for SARS-CoV-2 was estimated using Cox proportional hazards regression, with sex, age and vaccination status as covariates.\nRESULTS: The study cohort included all publicly employed doctors in Sweden: 35,028 individuals. In the first period, Infectious Disease doctors had the highest incidence of SARS-CoV-2 positive tests, with an incidence of 20.2 %, compared with 8.7 % in the reference group, and an adjusted hazard ratio of 2.5 (95% confidence interval 2.02-3.04), which decreased during period 2-3. Doctors in Geriatric Medicine had an elevated risk throughout the whole study period.\nCONCLUSIONS: Our study shows an association between working in a speciality that involves caring for contagious COVID-19 patients, which raises concerns about infection control measures and routines being insufficient to prevent occupational infection in future pandemics.', 'keywords': ['COVID-19', 'Occupational health', 'SARS-CoV-2', 'healthcare workers', 'medical doctors', 'risk factors'], 'url': 'https://ncbi.nlm.nih.gov/pubmed/39726065'}]
+Done!

octotools/tools/pubmed_search/tool.py

@@ -0,0 +1,112 @@
+import os
+import json
+from pymed import PubMed
+from metapub import PubMedFetcher
+from octotools.tools.base import BaseTool
+from tenacity import (
+    retry,
+    stop_after_attempt,
+    wait_random_exponential,
+)
+
+# Suppress stderr by redirecting it to /dev/null
+import sys
+sys.stderr = open(os.devnull, 'w')
+
+import warnings
+warnings.filterwarnings("ignore")
+
+
+class Pubmed_Search_Tool(BaseTool):
+    def __init__(self):
+        super().__init__(
+            tool_name="Pubmed_Search_Tool",
+            tool_description="A tool that searches PubMed Central to retrieve relevant article abstracts based on a given list of text queries. Use this ONLY if you cannot use the other more specific ontology tools.",
+            tool_version="1.0.0",
+            input_types={
+                "queries": "list[str] - list of queries terms for searching PubMed."
+            },
+            output_type="list - List of items matching the search query. Each item consists of the title, abstract, keywords, and URL of the article. If no results found, a string message is returned.",
+            demo_commands=[
+                {
+                    "command": 'execution = tool.execute(queries=["scoliosis", "injury"])',
+                    "description": "Search for PubMed articles mentioning 'scoliosis' OR 'injury'."
+                },
+                {
+                    "command": 'execution = tool.execute(queries=["COVID", "vaccine", "occupational health"])',
+                    "description": "Search for PubMed articles mentioning 'COVID' OR 'vaccine' OR 'occupational health'."
+                }
+            ],
+            user_metadata={
+                'limitations': "Try to use shorter and more general search queries."
+            }
+        )
+        self.pubmed = PubMed(tool="MyTool", email="[email protected]")
+        self.fetch = PubMedFetcher()
+
+    @retry(wait=wait_random_exponential(min=1, max=10), stop=stop_after_attempt(3))
+    def search_query(self, query_str, max_results=10):
+        return self.pubmed.query(query_str, max_results=max_results)
+
+    def execute(self, queries, max_results=10):
+        try:
+            query_str = f"({'[Title/Abstract] OR '.join(queries) + '[Title/Abstract]'}) AND hasabstract[All Fields] AND fha[Filter]"
+            max_results = min(max_results, 50)
+
+            results = self.search_query(query_str, max_results=max_results) # API can only get most recent
+
+            items = []
+            for article in results:
+                try:
+                    article = json.loads(article.toJSON())
+                    pubmed_id = article['pubmed_id'] # get id using pymed then get content using metapub
+
+                    article = self.fetch.article_by_pmid(pubmed_id)
+                    items.append({
+                        'title': article.title,
+                        'abstract': article.abstract,
+                        'keywords': article.keywords,
+                        'url': article.url
+                    })
+                except:
+                    continue
+
+            if len(items) == 0:
+                return "No results found for search query. Try another query or tool."
+            
+            return items
+        
+        except Exception as e:
+            print(f"Error searching PubMed: {e}")
+            return []
+
+    def get_metadata(self):
+        metadata = super().get_metadata()
+        return metadata
+
+if __name__ == "__main__":
+    # Test command:
+    """
+    Run the following commands in the terminal to test the script:
+    
+    cd octotools/tools/pubmed_search
+    python tool.py
+    """
+
+    # Get the directory of the current script
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+
+    # Example usage
+    tool = Pubmed_Search_Tool()
+
+    # Queries
+    queries = ["COVID occupational health"]
+
+    # Execute the tool
+    try:
+        execution = tool.execute(queries=queries)
+        print(execution)
+    except ValueError as e: 
+        print(f"Execution failed: {e}")
+
+    print("Done!")

octotools/tools/python_code_generator/test.log

@@ -0,0 +1,13 @@
+
+Initializing Python_Code_Generator_Tool with model_string: gpt-4o-mini
+!! Cache enabled for model: gpt-4o-mini
+
+Initializing Python_Code_Generator_Tool with model_string: gpt-4o-mini
+!! Cache enabled for model: gpt-4o-mini
+{'tool_name': 'Python_Code_Generator_Tool', 'tool_description': 'A tool that generates and executes simple Python code snippets for basic arithmetical calculations and math-related problems. The generated code runs in a highly restricted environment with only basic mathematical operations available.', 'tool_version': '1.0.0', 'input_types': {'query': 'str - A clear, specific description of the arithmetic calculation or math problem to be solved, including any necessary numerical inputs.'}, 'output_type': 'dict - A dictionary containing the generated code, calculation result, and any error messages.', 'demo_commands': [{'command': 'execution = tool.execute(query="Calculate the factorial of 5")', 'description': 'Generate a Python code snippet to calculate the factorial of 5.'}, {'command': 'execution = tool.execute(query="Find the sum of prime numbers up to 50")', 'description': 'Generate a Python code snippet to find the sum of prime numbers up to 50.'}, {'command': 'query="Given the list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], calculate the sum of squares of odd numbers"\nexecution = tool.execute(query=query)', 'description': 'Generate a Python function for a specific mathematical operation on a given list of numbers.'}], 'require_llm_engine': True, 'user_metadata': {'limitations': ['Restricted to basic Python arithmetic operations and built-in mathematical functions.', 'Cannot use any external libraries or modules, including those in the Python standard library.', 'Limited to simple mathematical calculations and problems.', 'Cannot perform any string processing, data structure manipulation, or complex algorithms.', 'No access to any system resources, file operations, or network requests.', "Cannot use 'import' statements.", 'All calculations must be self-contained within a single function or script.', 'Input must be provided directly in the query string.', 'Output is limited to numerical results or simple lists/tuples of numbers.'], 'best_practices': ['Provide clear and specific queries that describe the desired mathematical calculation.', 'Include all necessary numerical inputs directly in the query string.', 'Keep tasks focused on basic arithmetic, algebraic calculations, or simple mathematical algorithms.', 'Ensure all required numerical data is included in the query.', 'Verify that the query only involves mathematical operations and does not require any data processing or complex algorithms.', 'Review generated code to ensure it only uses basic Python arithmetic operations and built-in math functions.']}}
+
+###Query: Given the number list: [1, 2, 3, 4, 5], calculate the sum of all the numbers in the list.
+The sum of all the numbers in the list [1, 2, 3, 4, 5] is: 15
+
+###Execution Result: {'printed_output': 'The sum of all the numbers in the list [1, 2, 3, 4, 5] is: 15', 'variables': {'numbers': [1, 2, 3, 4, 5], 'total_sum': 15}}
+Done!

octotools/tools/python_code_generator/tool.py

@@ -0,0 +1,243 @@
+# octotools/tools/python_code_generator/tool.py
+
+import os
+import re
+import sys
+from io import StringIO
+import contextlib
+
+
+from octotools.tools.base import BaseTool
+from octotools.engine.openai import ChatOpenAI
+
+import signal
+from contextlib import contextmanager
+
+# Custom exception for code execution timeout
+class TimeoutException(Exception):
+    pass
+
+# Custom context manager for code execution timeout
+@contextmanager
+def timeout(seconds):
+    def timeout_handler(signum, frame):
+        raise TimeoutException("Code execution timed out")
+
+    # Set the timeout handler
+    original_handler = signal.signal(signal.SIGALRM, timeout_handler)
+    signal.alarm(seconds)
+    
+    try:
+        yield
+    finally:
+        # Restore the original handler and disable the alarm
+        signal.alarm(0)
+        signal.signal(signal.SIGALRM, original_handler)
+
+
+class Python_Code_Generator_Tool(BaseTool):
+    require_llm_engine = True
+
+    def __init__(self, model_string="gpt-4o-mini"):
+        super().__init__(
+            tool_name="Python_Code_Generator_Tool",
+            tool_description="A tool that generates and executes simple Python code snippets for basic arithmetical calculations and math-related problems. The generated code runs in a highly restricted environment with only basic mathematical operations available.",
+            tool_version="1.0.0",
+            input_types={
+                "query": "str - A clear, specific description of the arithmetic calculation or math problem to be solved, including any necessary numerical inputs."},
+            output_type="dict - A dictionary containing the generated code, calculation result, and any error messages.",
+            demo_commands=[
+                {
+                    "command": 'execution = tool.execute(query="Calculate the factorial of 5")',
+                    "description": "Generate a Python code snippet to calculate the factorial of 5."
+                },
+                {
+                    "command": 'execution = tool.execute(query="Find the sum of prime numbers up to 50")',
+                    "description": "Generate a Python code snippet to find the sum of prime numbers up to 50."
+                },
+                {
+                    "command": 'query="Given the list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], calculate the sum of squares of odd numbers"\nexecution = tool.execute(query=query)',
+                    "description": "Generate a Python function for a specific mathematical operation on a given list of numbers."
+                },
+            ],
+            user_metadata = {
+                "limitations": [
+                    "Restricted to basic Python arithmetic operations and built-in mathematical functions.",
+                    "Cannot use any external libraries or modules, including those in the Python standard library.",
+                    "Limited to simple mathematical calculations and problems.",
+                    "Cannot perform any string processing, data structure manipulation, or complex algorithms.",
+                    "No access to any system resources, file operations, or network requests.",
+                    "Cannot use 'import' statements.",
+                    "All calculations must be self-contained within a single function or script.",
+                    "Input must be provided directly in the query string.",
+                    "Output is limited to numerical results or simple lists/tuples of numbers."
+                ],
+                "best_practices": [
+                    "Provide clear and specific queries that describe the desired mathematical calculation.",
+                    "Include all necessary numerical inputs directly in the query string.",
+                    "Keep tasks focused on basic arithmetic, algebraic calculations, or simple mathematical algorithms.",
+                    "Ensure all required numerical data is included in the query.",
+                    "Verify that the query only involves mathematical operations and does not require any data processing or complex algorithms.",
+                    "Review generated code to ensure it only uses basic Python arithmetic operations and built-in math functions."
+                ]
+            }
+        )
+        print(f"\nInitializing Python_Code_Generator_Tool with model_string: {model_string}")
+        self.llm_engine = ChatOpenAI(model_string=model_string, is_multimodal=False) if model_string else None
+
+    @staticmethod
+    def preprocess_code(code):
+        """
+        Preprocesses the generated code snippet by extracting it from the response.
+
+        Parameters:
+            code (str): The response containing the code snippet.
+
+        Returns:
+            str: The extracted code snippet.
+        """
+        code = re.search(r"```python(.*)```", code, re.DOTALL).group(1).strip()
+        return code
+
+    @contextlib.contextmanager
+    def capture_output(self):
+        """
+        Context manager to capture the standard output.
+
+        Yields:
+            StringIO: The captured output.
+        """
+        new_out = StringIO()
+        old_out = sys.stdout
+        sys.stdout = new_out
+        try:
+            yield sys.stdout
+        finally:
+            sys.stdout = old_out
+
+    def execute_code_snippet(self, code):
+        """
+        Executes the given Python code snippet.
+
+        Parameters:
+            code (str): The Python code snippet to be executed.
+
+        Returns:
+            dict: A dictionary containing the printed output and local variables.
+        """
+        # Check for dangerous functions and remove them
+        dangerous_functions = ['exit', 'quit', 'sys.exit']
+        for func in dangerous_functions:
+            if func in code:
+                print(f"Warning: Removing unsafe '{func}' call from code")
+                # Use regex to remove function calls with any arguments
+                code = re.sub(rf'{func}\s*\([^)]*\)', 'break', code)
+
+        try:
+            execution_code = self.preprocess_code(code)
+
+            # Execute with 10-second timeout
+            with timeout(10):
+                try:
+                    exec(execution_code)
+                except TimeoutException:
+                    print("Error: Code execution exceeded 60 seconds timeout")
+                    return {"error": "Execution timed out after 60 seconds"}
+                except Exception as e:
+                    print(f"Error executing code: {e}")
+                    return {"error": str(e)}
+                
+            # Capture the output and local variables
+            local_vars = {}
+            with self.capture_output() as output:
+                exec(execution_code, {}, local_vars)
+            printed_output = output.getvalue().strip()
+
+            # Filter out built-in variables and modules
+            """
+            only the variables used in the code are returned, 
+            excluding built-in variables (which start with '__') and imported modules.
+            """
+            used_vars = {k: v for k, v in local_vars.items() 
+                         if not k.startswith('__') and not isinstance(v, type(sys))}
+            
+            return {"printed_output": printed_output, "variables": used_vars}
+        
+        except Exception as e:
+            print(f"Error executing code: {e}")
+            return {"error": str(e)}
+
+    def execute(self, query):
+        """
+        Generates and executes Python code based on the provided query.
+
+        Parameters:
+            query (str): A query describing the desired operation.
+
+        Returns:
+            dict: A dictionary containing the executed output, local variables, or any error message.
+        """
+
+        if not self.llm_engine:
+            raise ValueError("LLM engine not initialized. Please provide a valid model_string when initializing the tool.")
+
+        task_description = """
+        Given a query, generate a Python code snippet that performs the specified operation on the provided data. Please think step by step. Ensure to break down the process into clear, logical steps. Make sure to print the final result in the generated code snippet with a descriptive message explaining what the output represents. The final output should be presented in the following format:
+
+        ```python
+        <code snippet>
+        ```
+        """
+        task_description = task_description.strip()
+        full_prompt = f"Task:\n{task_description}\n\nQuery:\n{query}"
+
+        response = self.llm_engine(full_prompt)
+        result_or_error = self.execute_code_snippet(response)
+        return result_or_error
+
+    def get_metadata(self):
+        """
+        Returns the metadata for the Python_Code_Generator_Tool.
+
+        Returns:
+            dict: A dictionary containing the tool's metadata.
+        """
+        metadata = super().get_metadata()
+        metadata["require_llm_engine"] = self.require_llm_engine # NOTE: can be removed if not needed
+        return metadata
+
+
+if __name__ == "__main__":
+    # Test command:
+    """
+    Run the following commands in the terminal to test the script:
+    
+    cd octotools/tools/python_code_generator
+    python tool.py
+    """
+
+    # Get the directory of the current script
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+
+    # Example usage of the Python_Code_Generator_Tool
+    tool = Python_Code_Generator_Tool()
+    tool = Python_Code_Generator_Tool(model_string="gpt-4o-mini")
+
+    # Get tool metadata
+    metadata = tool.get_metadata()
+    print(metadata)
+
+    # Sample query for generating and executing Python code
+    queries = [
+        "Given the number list: [1, 2, 3, 4, 5], calculate the sum of all the numbers in the list.",
+    ]
+    for query in queries:
+        print(f"\n###Query: {query}")
+        # Execute the tool with the sample query
+        try:
+            execution = tool.execute(query=query)
+            print("\n###Execution Result:", execution)
+        except ValueError as e:
+            print(f"Execution failed: {e}")
+
+    print("Done!")

octotools/tools/relevant_patch_zoomer/test.log

@@ -0,0 +1,10 @@
+
+Initializing Patch Zoomer Tool with model: gpt-4o
+!! Cache enabled for model: gpt-4o
+{'tool_name': 'Relevant_Patch_Zoomer_Tool', 'tool_description': 'A tool that analyzes an image, divides it into 5 regions (4 quarters + center), and identifies the most relevant patches based on a question. The returned patches are zoomed in by a factor of 2.', 'tool_version': '1.0.0', 'input_types': {'image': 'str - The path to the image file.', 'question': 'str - The question about the image content.'}, 'output_type': 'dict - Contains analysis text and list of saved zoomed patch paths.', 'demo_commands': [{'command': 'execution = tool.execute(image="path/to/image.jpg", question="What is the color of the car?")', 'description': "Analyze image and return relevant zoomed patches that show the car's color."}], 'require_llm_engine': True, 'user_metadata': {'best_practices': ['It might be helpful to zoom in on the image first to get a better look at the object(s).', 'It might be helpful if the question requires a close-up view of the object(s), symbols, texts, etc.', 'The tool should be used to provide a high-level analysis first, and then use other tools for fine-grained analysis. For example, you can use Relevant_Patch_Zoomer_Tool first to get a zoomed patch of specific objects, and then use Image_Captioner_Tool to describe the objects in detail.']}}
+
+Detected Patches:
+Path: /root/Projects/octotools/octotools/tools/relevant_patch_zoomer/zoomed_patches/car_bottom-right_zoomed_2x.png
+Description: The bottom-right region of the image: /root/Projects/octotools/octotools/tools/relevant_patch_zoomer/examples/car.png.
+
+Done!

octotools/tools/relevant_patch_zoomer/tool.py

@@ -0,0 +1,188 @@
+import os
+import cv2
+from pydantic import BaseModel
+from octotools.tools.base import BaseTool
+from octotools.engine.openai import ChatOpenAI
+
+class PatchZoomerResponse(BaseModel):
+    analysis: str
+    patch: list[str]
+
+class Relevant_Patch_Zoomer_Tool(BaseTool):
+    require_llm_engine = True
+
+    def __init__(self, model_string="gpt-4o"):
+        super().__init__(
+            tool_name="Relevant_Patch_Zoomer_Tool",
+            tool_description="A tool that analyzes an image, divides it into 5 regions (4 quarters + center), and identifies the most relevant patches based on a question. The returned patches are zoomed in by a factor of 2.",
+            tool_version="1.0.0",
+            input_types={
+                "image": "str - The path to the image file.",
+                "question": "str - The question about the image content.",
+            },
+            output_type="dict - Contains analysis text and list of saved zoomed patch paths.",
+            demo_commands=[
+                {
+                    "command": 'execution = tool.execute(image="path/to/image.jpg", question="What is the color of the car?")',
+                    "description": "Analyze image and return relevant zoomed patches that show the car's color."
+                }
+            ],
+            user_metadata = {
+                "best_practices": [
+                    "It might be helpful to zoom in on the image first to get a better look at the object(s).",
+                    "It might be helpful if the question requires a close-up view of the object(s), symbols, texts, etc.",
+                    "The tool should be used to provide a high-level analysis first, and then use other tools for fine-grained analysis. For example, you can use Relevant_Patch_Zoomer_Tool first to get a zoomed patch of specific objects, and then use Image_Captioner_Tool to describe the objects in detail."
+                ]
+            }
+        )
+        self.matching_dict = {
+            "A": "top-left",
+            "B": "top-right",
+            "C": "bottom-left",
+            "D": "bottom-right",
+            "E": "center"
+        }
+
+        print(f"\nInitializing Patch Zoomer Tool with model: {model_string}")
+        self.llm_engine = ChatOpenAI(model_string=model_string, is_multimodal=True) if model_string else None
+        
+    def _save_patch(self, image_path, patch, save_path, zoom_factor=2):
+        """Extract and save a specific patch from the image with 10% margins."""
+        img = cv2.imread(image_path)
+        height, width = img.shape[:2]
+        
+        quarter_h = height // 2
+        quarter_w = width // 2
+        
+        margin_h = int(quarter_h * 0.1)
+        margin_w = int(quarter_w * 0.1)
+        
+        patch_coords = {
+            'A': ((max(0, 0 - margin_w), max(0, 0 - margin_h)),
+                  (min(width, quarter_w + margin_w), min(height, quarter_h + margin_h))),
+            'B': ((max(0, quarter_w - margin_w), max(0, 0 - margin_h)),
+                  (min(width, width + margin_w), min(height, quarter_h + margin_h))),
+            'C': ((max(0, 0 - margin_w), max(0, quarter_h - margin_h)),
+                  (min(width, quarter_w + margin_w), min(height, height + margin_h))),
+            'D': ((max(0, quarter_w - margin_w), max(0, quarter_h - margin_h)),
+                  (min(width, width + margin_w), min(height, height + margin_h))),
+            'E': ((max(0, quarter_w//2 - margin_w), max(0, quarter_h//2 - margin_h)),
+                  (min(width, quarter_w//2 + quarter_w + margin_w), 
+                   min(height, quarter_h//2 + quarter_h + margin_h)))
+        }
+        
+        (x1, y1), (x2, y2) = patch_coords[patch]
+        patch_img = img[y1:y2, x1:x2]
+        
+        zoomed_patch = cv2.resize(patch_img, 
+                                (patch_img.shape[1] * zoom_factor, 
+                                 patch_img.shape[0] * zoom_factor), 
+                                interpolation=cv2.INTER_LINEAR)
+        
+        os.makedirs(os.path.dirname(save_path), exist_ok=True)
+        cv2.imwrite(save_path, zoomed_patch)
+        return save_path
+
+    def execute(self, image, question, zoom_factor=2):
+        try:
+            if not self.llm_engine:
+                return "Error: LLM engine not initialized. Please provide a valid model_string."
+            
+            # Prepare the prompt
+            prompt = f"""
+Analyze this image to identify the most relevant region(s) for answering the question:
+
+Question: {question}
+
+The image is divided into 5 regions:
+- (A) Top-left quarter
+- (B) Top-right quarter
+- (C) Bottom-left quarter
+- (D) Bottom-right quarter
+- (E) Center region (1/4 size, overlapping middle section)
+
+Instructions:
+1. First describe what you see in each of the five regions.
+2. Then select the most relevant region(s) to answer the question.
+3. Choose only the minimum necessary regions - avoid selecting redundant areas that show the same content. For example, if one patch contains the entire object(s), do not select another patch that only shows a part of the same object(s).
+
+
+Response format:
+<analysis>: Describe the image and five patches first. Then analyze the question and select the most relevant patch or list of patches.
+<patch>: List of letters (A-E)
+"""
+            # Read image and create input data
+            with open(image, 'rb') as file:
+                image_bytes = file.read()
+            input_data = [prompt, image_bytes]
+            
+            # Get response from LLM
+            response = self.llm_engine(input_data, response_format=PatchZoomerResponse)
+            
+            # Save patches
+            image_dir = os.path.dirname(image)
+            image_name = os.path.splitext(os.path.basename(image))[0]
+            
+            # Update the return structure
+            patch_info = []
+            for patch in response.patch:
+                patch_name = self.matching_dict[patch]
+                save_path = os.path.join(self.output_dir, 
+                                       f"{image_name}_{patch_name}_zoomed_{zoom_factor}x.png")
+                saved_path = self._save_patch(image, patch, save_path, zoom_factor)
+                save_path = os.path.abspath(saved_path)
+                patch_info.append({
+                    "path": save_path,
+                    "description": f"The {self.matching_dict[patch]} region of the image: {image}."
+                })
+            
+            return {
+                "analysis": response.analysis,
+                "patches": patch_info
+            }
+            
+        except Exception as e:
+            print(f"Error in patch zooming: {e}")
+            return None
+
+    def get_metadata(self):
+        return super().get_metadata()
+
+if __name__ == "__main__":
+    # Test command:
+    """
+    Run the following commands in the terminal to test the script:
+    
+    cd octotools/tools/relevant_patch_zoomer
+    python tool.py
+    """
+
+    # Get the directory of the current script
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+
+    # Example usage of the Relevant_Patch_Zoomer_Tool
+    tool = Relevant_Patch_Zoomer_Tool()
+    tool.set_custom_output_dir(f"{script_dir}/zoomed_patches")
+
+    # Get tool metadata
+    metadata = tool.get_metadata()
+    print(metadata)
+
+    # Construct the full path to the image using the script's directory
+    relative_image_path = "examples/car.png"
+    image_path = os.path.join(script_dir, relative_image_path)
+    question = "What is the color of the car?"
+
+    # Execute the tool
+    try:
+        result = tool.execute(image=image_path, question=question)
+        if result:
+            print("\nDetected Patches:")
+            for patch in result['patches']:
+                print(f"Path: {patch['path']}")
+                print(f"Description: {patch['description']}")
+                print()
+    except Exception as e:
+        print(f"Execution failed: {e}")
+
+    print("Done!")