diff --git a/openmanus_rl/agentgym/agentenv_gaia/agentenv_gaia/__init__.py b/openmanus_rl/agentgym/__init__.py similarity index 100% rename from openmanus_rl/agentgym/agentenv_gaia/agentenv_gaia/__init__.py rename to openmanus_rl/agentgym/__init__.py diff --git a/openmanus_rl/agentgym/agentenv-gaia/README.md b/openmanus_rl/agentgym/agentenv-gaia/README.md new file mode 100644 index 00000000..73f20838 --- /dev/null +++ b/openmanus_rl/agentgym/agentenv-gaia/README.md @@ -0,0 +1,101 @@ +# GAIA Environment Server + +A comprehensive environment server for GAIA (Generative AI Agent) tasks, designed to work with OpenManus-RL. This server provides a research environment with powerful tools and real-time observation tracking. + +## Features + +- Loads GAIA datasets from HuggingFace or local files +- Integrates real functional tools for web search, Python code execution, and bash commands +- Concurrency support with environment locking +- Realistic research workflow simulation +- Detailed memory of actions and results +- Answer evaluation with true answer comparison + +## Installation + +```bash +pip install -e . +``` + +## Usage + +### Starting the server + +```bash +# Start the server with default settings +gaia-server + +# Start with custom host and port +gaia-server --host 127.0.0.1 --port 8080 + +# Start with custom data directory +gaia-server --data-dir /path/to/data/ +``` + +### API Endpoints + +The GAIA environment server provides the following endpoints: + +- `GET /` - Test connection +- `GET /list_envs` - List all active environments +- `POST /create` - Create a new environment +- `GET /observation?env_idx={env_id}` - Get the current observation for an environment +- `POST /step` - Execute an action in an environment +- `POST /reset` - Reset an environment +- `GET /available_actions?env_idx={env_id}` - Get available actions for an environment + +### Available Tools + +The environment provides the following powerful tools: + +- **web_search** - Search the web for real-time information about any topic +- **bash** - Execute bash commands in the terminal +- **python_execute** - Execute Python code and get the results +- **terminate** - Submit your final answer and terminate the task + +### Alternative Action Formats + +The server supports multiple action formats: + +#### Standard Format +``` +Action: tool_name Action Input: your_input +``` + +#### Direct Format +``` +tool_name: your_input +``` + +#### JSON Format +``` +{"tool_name": "web_search", "query": "What is the capital of France?"} +``` + +#### Specific Parameter Formats + +**Web Search:** +``` +Action: web_search Action Input: your search query +``` + +**Python Execute:** +``` +Action: python_execute Action Input: print("Hello, World!") +``` + +**Bash:** +``` +Action: bash Action Input: ls -la +``` + +**Terminate:** +``` +Action: terminate Action Input: Your final answer text here +``` + +## Dataset Format + +Place GAIA datasets in the `data/gaia/` directory. The server will automatically load from this location or download the datasets from HuggingFace if not available locally. + +Dataset loading is handled automatically through the `load_gaia_data` utility function. diff --git a/openmanus_rl/agentgym/agentenv_gaia/tests/__init__.py b/openmanus_rl/agentgym/agentenv-gaia/__init__.py similarity index 100% rename from openmanus_rl/agentgym/agentenv_gaia/tests/__init__.py rename to openmanus_rl/agentgym/agentenv-gaia/__init__.py diff --git a/openmanus_rl/agentgym/agentenv-gaia/agentenv_gaia/__init__.py b/openmanus_rl/agentgym/agentenv-gaia/agentenv_gaia/__init__.py new file mode 100644 index 00000000..88fea067 --- /dev/null +++ b/openmanus_rl/agentgym/agentenv-gaia/agentenv_gaia/__init__.py @@ -0,0 +1,13 @@ +import os +import sys + +# Add necessary directories to Python path if needed +sys.path.append( + os.path.join(os.path.dirname(os.path.realpath(__file__)), "..", "..") +) + +# Import components from server.py +from .server import app, launch, GaiaEnvServer + +# Export for command-line tool +__all__ = ["app", "launch", "GaiaEnvServer"] diff --git a/openmanus_rl/agentgym/agentenv-gaia/agentenv_gaia/environment.py b/openmanus_rl/agentgym/agentenv-gaia/agentenv_gaia/environment.py new file mode 100644 index 00000000..6467a79d --- /dev/null +++ b/openmanus_rl/agentgym/agentenv-gaia/agentenv_gaia/environment.py @@ -0,0 +1,556 @@ +import asyncio +import json +import os +import re +import threading +import uuid +import uvicorn +# Import utilities from load_data +from agentenv_gaia.load_data import load_gaia_data, parse_tools +from agentenv_gaia.tool_manager import ToolManager +from gaia.base import ToolResult + +from fastapi import FastAPI, HTTPException +from pydantic import BaseModel +from typing import Dict, List, Optional, Any, Tuple, Union + + +# List of default tools to include in every environment +DEFAULT_TOOLS = ["web_search", "bash", "python_execute", "browser_use", "terminate"] + + + +# GaiaEnvServer class to manage environment instances +class GaiaEnvServer: + def __init__(self, max_envs=100): + """Initialize the GAIA environment server""" + self.env_instances = {} # Dictionary to store environment instances + self.env_locks = {} # Locks for thread safety + self.max_envs = max_envs + + # Default dataset path + self.data_dir = os.path.join("data", "gaia") + + # Initialize the tool manager + self.tool_manager = ToolManager() + + # Create event loop for async tools + self.loop = asyncio.new_event_loop() + asyncio.set_event_loop(self.loop) + + # Try to load any available datasets + self._preload_datasets() + + def _preload_datasets(self): + """Pre-load available GAIA datasets""" + try: + # Check if datasets can be loaded + self.validation_data = load_gaia_data(data_dir="data/", dataset="validation") + self.test_data = load_gaia_data(data_dir="data/", dataset="test") + print(f"Preloaded validation dataset with {len(self.validation_data)} items") + print(f"Preloaded test dataset with {len(self.test_data)} items") + except Exception as e: + print(f"Warning: Could not preload datasets: {e}") + self.validation_data = None + self.test_data = None + + def create(self, id: int = 0, dataset_type: str = "validation", tool_list: Optional[List[str]] = None): + """ + Create a new environment instance + + Args: + id: Task ID in the dataset + dataset_type: Dataset type (validation/test) + tool_list: List of specific tools to enable + + Returns: + str: New environment UUID + """ + if len(self.env_instances) >= self.max_envs: + raise ValueError(f"Maximum number of environments reached ({self.max_envs})") + + # Generate a unique environment ID + env_id = str(uuid.uuid4()) + + # Create a lock for this environment + self.env_locks[env_id] = threading.Lock() + + # Prepare the dataset item + dataset_item = self._prepare_dataset_item(id, dataset_type) + + # Determine available tools based on task and tool_list + available_tools = self._determine_tools(dataset_item, tool_list) + + # Create environment with the dataset and tools + with self.env_locks[env_id]: + self.env_instances[env_id] = { + "dataset": dataset_item, + "question": dataset_item.get("question", ""), + "state": { + "steps_taken": 0, + "done": False, + "reward": 0.0, + "goal": dataset_item.get("question", ""), + "context": dataset_item.get("Context", ""), + "files": dataset_item.get("file_name", ""), + "memory": [], # Store previous actions and results + "collected_info": [] # Store information collected during the session + }, + "available_tools": available_tools + } + + return env_id + + def _prepare_dataset_item(self, id: int, dataset_type: str = "validation"): + """ + Prepare dataset item for the given ID + + Args: + id: Task ID + dataset_type: Dataset type + + Returns: + dict: Dataset item + """ + try: + # Try to get data from preloaded dataset + if dataset_type == "validation" and self.validation_data is not None: + if 0 <= id < len(self.validation_data): + return self.validation_data.iloc[id].to_dict() + + if dataset_type == "test" and self.test_data is not None: + if 0 <= id < len(self.test_data): + return self.test_data.iloc[id].to_dict() + + # Fall back to direct loading if needed + data = load_gaia_data(data_dir="data/", dataset=dataset_type) + if 0 <= id < len(data): + return data.iloc[id].to_dict() + except Exception as e: + print(f"Error loading dataset: {e}") + + # Return a default dataset structure if all else fails + return { + "question": f"Task {id} from {dataset_type} dataset", + "Context": "No context available", + "file_name": "", + "task": "generic", + } + + def _determine_tools(self, dataset_item: Dict[str, Any], tool_list: Optional[List[str]] = None) -> List[str]: + """ + Determine tools available for this environment based on the task + + Args: + dataset_item: Dataset item + tool_list: Optional list of specific tools to enable + + Returns: + List[str]: List of available tool names + """ + # If tool_list is provided, use only those tools + if tool_list: + # Filter to only valid tools + available_tools = [ + tool for tool in tool_list + if tool in self.tool_manager.get_tool_names() + ] + + # Always include terminate + if "terminate" not in available_tools: + available_tools.append("terminate") + + return available_tools + + # Get default tools + available_tools = DEFAULT_TOOLS.copy() + + # Task-specific additions could go here + task_type = dataset_item.get("task", "").lower() + + # Add tools based on task requirements if needed + # This would typically come from dataset metadata + + return available_tools + + def reset(self, env_id: str, id: Optional[int] = None, dataset_type: str = "validation"): + """ + Reset environment + + Args: + env_id: Environment ID + id: Optional new task ID + dataset_type: Dataset type + + Returns: + None + """ + self._check_env_id(env_id) + + with self.env_locks[env_id]: + env = self.env_instances[env_id] + + if id is not None: + # Reset with a new task + dataset_item = self._prepare_dataset_item(id, dataset_type) + env["dataset"] = dataset_item + env["question"] = dataset_item.get("question", "") + + # Determine available tools based on the new task + env["available_tools"] = self._determine_tools(dataset_item) + + env["state"] = { + "steps_taken": 0, + "done": False, + "reward": 0.0, + "goal": dataset_item.get("question", ""), + "context": dataset_item.get("Context", ""), + "files": dataset_item.get("file_name", ""), + "memory": [], + "collected_info": [] + } + else: + # Reset with the same task + dataset_item = env["dataset"] + env["state"] = { + "steps_taken": 0, + "done": False, + "reward": 0.0, + "goal": dataset_item.get("question", ""), + "context": dataset_item.get("Context", ""), + "files": dataset_item.get("file_name", ""), + "memory": [], + "collected_info": [] + } + + def step(self, env_id: str, action: str): + """ + Execute environment step + + Args: + env_id: Environment ID + action: Action description + + Returns: + tuple: (observation, reward, done, info) + """ + self._check_env_id(env_id) + + with self.env_locks[env_id]: + env = self.env_instances[env_id] + + # Parse and process the action + action_type, action_input = self._parse_action(action) + + # Update state + env["state"]["steps_taken"] += 1 + + # Process the action using available tools + observation, reward, done = self._process_action(env_id, action_type, action_input) + + # Store action and result in memory + env["state"]["memory"].append({ + "action": action, + "result": observation, + "step": env["state"]["steps_taken"] + }) + + # Update state with results + env["state"]["reward"] += reward + env["state"]["done"] = done + + info = { + "steps_taken": env["state"]["steps_taken"], + "action_processed": action, + } + + return observation, reward, done, info + + def _parse_action(self, action: str) -> Tuple[str, Dict[str, Any]]: + """ + Parse the action string into type and input + + Args: + action: Action string + + Returns: + tuple: (action_type, action_parameters) + """ + try: + # Parse actions in format "Action: action_type with Action Input: action_input" + if "Action:" in action and "Action Input:" in action: + action_parts = action.split("Action Input:", 1) + action_type = action_parts[0].replace("Action:", "").strip() + action_input = action_parts[1].strip() + return action_type, {"query": action_input} if action_type == "web_search" else { + "command": action_input} if action_type == "bash" else { + "code": action_input} if action_type == "python_execute" else {"input": action_input} + + # Parse JSON format with tool_name and parameters + elif action.strip().startswith("{") and action.strip().endswith("}"): + try: + action_json = json.loads(action) + if "tool_name" in action_json: + tool_name = action_json.pop("tool_name") + return tool_name, action_json + except json.JSONDecodeError: + pass + + # Parse direct tool calls (e.g., "web_search: query") + elif ":" in action: + tool_name, input_text = action.split(":", 1) + tool_name = tool_name.strip() + input_text = input_text.strip() + + # Map to appropriate parameter name based on tool + if tool_name.lower() in ["web_search", "search_web"]: + return tool_name, {"query": input_text} + elif tool_name.lower() == "bash": + return tool_name, {"command": input_text} + elif tool_name.lower() == "python_execute": + return tool_name, {"code": input_text} + elif tool_name.lower() == "browser_use": + return tool_name, {"url": input_text} + elif tool_name.lower() == "terminate": + return "terminate", {"answer": input_text} + else: + return tool_name, {"input": input_text} + + # Handle plain text as a default case + return "unknown", {"input": action} + + except Exception as e: + print(f"Error parsing action: {e}") + return "unknown", {"input": action} + + def _process_action(self, env_id: str, action_type: str, action_input: Dict[str, Any]) -> Tuple[str, float, bool]: + """ + Process the action using available tools + + Args: + env_id: Environment ID + action_type: Type of action + action_input: Input parameters for the action + + Returns: + tuple: (observation, reward, done) + """ + env = self.env_instances[env_id] + available_tools = env["available_tools"] + + # Clean up action type + clean_action_type = action_type.lower().replace(" ", "_") + if clean_action_type == "search_web": + clean_action_type = "web_search" # Normalize to official name + + # Check if the tool is available for this environment + if clean_action_type in available_tools: + try: + # Handle terminate as a special case + if clean_action_type == "terminate": + answer = action_input.get("answer", "") or action_input.get("input", "") + return self._process_answer_submission(env_id, answer) + + # Execute the tool using the tool manager + tool_result = self.loop.run_until_complete( + self.tool_manager.execute_tool(clean_action_type, **action_input) + ) + + # Extract result + if isinstance(tool_result, dict): + result_text = tool_result.get("observation", str(tool_result)) + elif isinstance(tool_result, ToolResult): + result_text = str(tool_result) + else: + result_text = str(tool_result) + + # Add to collected info + if result_text and not env["state"]["done"]: + env["state"]["collected_info"].append(result_text) + + observation = f"Tool {clean_action_type} executed.\nResult: {result_text}" + reward = 0.1 # Small reward for successful tool use + done = False + + return observation, reward, done + + except Exception as e: + observation = f"Error executing tool {clean_action_type}: {str(e)}" + reward = -0.1 # Small penalty for error + done = False + return observation, reward, done + else: + observation = f"Tool '{action_type}' is not available for this task. Available tools: {', '.join(available_tools)}" + reward = -0.05 # Very small penalty for using unavailable tool + done = False + return observation, reward, done + + def _process_answer_submission(self, env_id: str, answer: str) -> Tuple[str, float, bool]: + """ + Process answer submission + + Args: + env_id: Environment ID + answer: Submitted answer + + Returns: + tuple: (observation, reward, done) + """ + env = self.env_instances[env_id] + + # Get the true answer if available + dataset_item = env["dataset"] + true_answer = dataset_item.get("true_answer", None) + + # Check if this is a plausible answer based on collected info + has_relevant_info = len(env["state"]["collected_info"]) > 0 + + # Default quality is medium + quality_reward = 0.5 + + # If we have a true answer, check if the answer matches + if true_answer and isinstance(true_answer, str): + # Very simple heuristic - check if key terms from true answer are in the submission + key_terms = set(re.findall(r'\b\w+\b', true_answer.lower())) + submission_terms = set(re.findall(r'\b\w+\b', answer.lower())) + + common_terms = key_terms.intersection(submission_terms) + + if len(common_terms) / max(1, len(key_terms)) > 0.7: # 70% overlap + quality_reward = 1.0 # Good match with true answer + elif len(common_terms) / max(1, len(key_terms)) > 0.3: # 30% overlap + quality_reward = 0.7 # Partial match + else: + quality_reward = 0.3 # Poor match + elif has_relevant_info: + quality_reward = 0.8 # Did research but no true answer to compare + + observation = f"Answer submitted: {answer}" + if true_answer: + observation += f"\nReference answer: {true_answer}" + if has_relevant_info: + observation += "\nAnswer based on collected information." + + observation += "\nTask completed." + + return observation, quality_reward, True + + def observation(self, env_id: str): + """ + Get environment observation + + Args: + env_id: Environment ID + + Returns: + str: Formatted observation + """ + self._check_env_id(env_id) + + with self.env_locks[env_id]: + env = self.env_instances[env_id] + + # Check if this is a new task + if env["state"]["steps_taken"] == 0: + return self._format_new_task(env_id) + + # Return current state observation + return self._format_observation(env_id) + + def _format_new_task(self, env_id: str): + """ + Format observation for a new task + + Args: + env_id: Environment ID + + Returns: + str: Formatted observation + """ + env = self.env_instances[env_id] + + observation = ( + "New task starts.\n\n" + f"Question: {env['question']}\n" + ) + + # Add context if available + if env["state"]["context"]: + observation += f"\nContext: {env['state']['context']}\n" + + # Add file information if available + if env["state"]["files"]: + observation += f"\nFiles available: {env['state']['files']}\n" + + # Add available tools information + tools_str = ", ".join(env["available_tools"]) + observation += f"\nAvailable tools: {tools_str}\n" + + # Add tool descriptions + observation += "\nTool descriptions:\n" + for tool_name in env["available_tools"]: + description = self.tool_manager.get_tool_description(tool_name) + observation += f"- {tool_name}: {description}\n" + + observation += "\nUse tools in the format: Action: tool_name with Action Input: your_input\n" + observation += "\nGive me one action." + + return observation + + def _format_observation(self, env_id: str): + """ + Format regular observation + + Args: + env_id: Environment ID + + Returns: + str: Formatted observation + """ + env = self.env_instances[env_id] + + observation = ( + f"Current task: {env['question']}\n" + f"Steps taken: {env['state']['steps_taken']}\n" + ) + + # Add recent memory items (last 3 steps) + if env["state"]["memory"]: + observation += "\nRecent actions:\n" + for memory_item in env["state"]["memory"][-3:]: + observation += f"- Step {memory_item['step']}: {memory_item['action']}\n" + observation += f" Result: {memory_item['result']}\n" + + # Add tools reminder + observation += f"\nAvailable tools: {', '.join(env['available_tools'])}\n" + observation += "\nGive me one action." + + return observation + + def get_available_actions(self, env_id: str): + """ + Get available actions for the environment + + Args: + env_id: Environment ID + + Returns: + list: Available actions + """ + self._check_env_id(env_id) + + with self.env_locks[env_id]: + return self.env_instances[env_id]["available_tools"] + + def _check_env_id(self, env_id: str): + """ + Check if environment ID exists + + Args: + env_id: Environment ID + + Raises: + ValueError: If environment doesn't exist + """ + if env_id not in self.env_instances: + raise ValueError(f"Environment with ID {env_id} does not exist") diff --git a/openmanus_rl/agentgym/agentenv_gaia/agentenv_gaia/launch.py b/openmanus_rl/agentgym/agentenv-gaia/agentenv_gaia/launch.py similarity index 100% rename from openmanus_rl/agentgym/agentenv_gaia/agentenv_gaia/launch.py rename to openmanus_rl/agentgym/agentenv-gaia/agentenv_gaia/launch.py diff --git a/openmanus_rl/agentgym/agentenv_gaia/agentenv_gaia/utils/load_data.py b/openmanus_rl/agentgym/agentenv-gaia/agentenv_gaia/load_data.py similarity index 100% rename from openmanus_rl/agentgym/agentenv_gaia/agentenv_gaia/utils/load_data.py rename to openmanus_rl/agentgym/agentenv-gaia/agentenv_gaia/load_data.py diff --git a/openmanus_rl/agentgym/agentenv-gaia/agentenv_gaia/model.py b/openmanus_rl/agentgym/agentenv-gaia/agentenv_gaia/model.py new file mode 100644 index 00000000..4e42d42a --- /dev/null +++ b/openmanus_rl/agentgym/agentenv-gaia/agentenv_gaia/model.py @@ -0,0 +1,36 @@ +from fastapi import FastAPI, HTTPException +from pydantic import BaseModel +from typing import Dict, List, Optional, Any, Tuple, Union + + +# API Models +class CreateQuery(BaseModel): + """Create environment request""" + + id: int = 0 + dataset_type: str = "validation" + tool_list: Optional[List[str]] = None + + +class StepQuery(BaseModel): + """Execute action request""" + + env_idx: str # Changed to string for UUID + action: str + + +class StepResponse(BaseModel): + """Execute action response""" + + observation: str + reward: float + done: bool + info: dict + + +class ResetQuery(BaseModel): + """Reset environment request""" + + env_idx: str # Changed to string for UUID + id: Optional[int] = None + dataset_type: Optional[str] = "validation" diff --git a/openmanus_rl/agentgym/agentenv-gaia/agentenv_gaia/server.py b/openmanus_rl/agentgym/agentenv-gaia/agentenv_gaia/server.py new file mode 100644 index 00000000..f978c43f --- /dev/null +++ b/openmanus_rl/agentgym/agentenv-gaia/agentenv_gaia/server.py @@ -0,0 +1,108 @@ +import asyncio +import json +import os +import re +import threading +import uuid +import uvicorn + +from agentenv_gaia.environment import GaiaEnvServer +from agentenv_gaia.model import CreateQuery, StepQuery, StepResponse, ResetQuery + + +from fastapi import FastAPI, HTTPException + +# Create FastAPI application +app = FastAPI(title="GAIA Environment Server") + + +# Create environment server instance +gaia_env_server = GaiaEnvServer() + + +# API Endpoints +@app.get("/") +def generate_ok(): + """Test connection""" + return "ok" + + +@app.get("/list_envs") +def list_envs(): + """List all environments""" + return list(gaia_env_server.env_instances.keys()) + + +@app.post("/create") +def create(create_query: CreateQuery): + """Create new environment""" + try: + env_id = gaia_env_server.create( + create_query.id, create_query.dataset_type, create_query.tool_list + ) + return env_id + except Exception as e: + raise HTTPException(status_code=500, detail=str(e)) + + +@app.post("/step") +def step(step_query: StepQuery): + """Execute environment step""" + try: + observation, reward, done, info = gaia_env_server.step( + step_query.env_idx, step_query.action + ) + return StepResponse( + observation=observation, reward=reward, done=done, info=info + ) + except ValueError as e: + raise HTTPException(status_code=404, detail=str(e)) + except Exception as e: + raise HTTPException(status_code=500, detail=str(e)) + + +@app.get("/observation") +def observation(env_idx: str): + """Get environment observation""" + try: + return gaia_env_server.observation(env_idx) + except ValueError as e: + raise HTTPException(status_code=404, detail=str(e)) + except Exception as e: + raise HTTPException(status_code=500, detail=str(e)) + + +@app.post("/reset") +def reset(reset_query: ResetQuery): + """Reset environment""" + try: + gaia_env_server.reset( + reset_query.env_idx, reset_query.id, reset_query.dataset_type + ) + return gaia_env_server.observation(reset_query.env_idx) + except ValueError as e: + raise HTTPException(status_code=404, detail=str(e)) + except Exception as e: + raise HTTPException(status_code=500, detail=str(e)) + + +@app.get("/available_actions") +def available_actions(env_idx: str): + """Get available actions for an environment""" + try: + return gaia_env_server.get_available_actions(env_idx) + except ValueError as e: + raise HTTPException(status_code=404, detail=str(e)) + except Exception as e: + raise HTTPException(status_code=500, detail=str(e)) + + +# Server launch function +def launch(host: str = "0.0.0.0", port: int = 8000): + """Launch the GAIA environment server""" + uvicorn.run( + "agentenv_gaia.server:app", + host=host, + port=port, + reload=False, + ) diff --git a/openmanus_rl/agentgym/agentenv-gaia/agentenv_gaia/tool_manager.py b/openmanus_rl/agentgym/agentenv-gaia/agentenv_gaia/tool_manager.py new file mode 100644 index 00000000..72aa0323 --- /dev/null +++ b/openmanus_rl/agentgym/agentenv-gaia/agentenv_gaia/tool_manager.py @@ -0,0 +1,69 @@ +# Import real tools from gaia directory +from typing import Dict, List +from gaia.base import ToolResult +from gaia.bash import Bash +from gaia.browser_use_tool import BrowserUseTool +from gaia.python_execute import PythonExecute +from gaia.web_search import WebSearch + + +# Tool Initialization +class ToolManager: + """Manager for GAIA tools""" + + def __init__(self): + # Initialize tool instances + self.web_search = WebSearch() + self.bash = Bash() + self.python_execute = PythonExecute() + self.browser_use = BrowserUseTool() + + # Define terminate as a special handler (not a real tool class) + self.terminate = self._terminate_handler + + async def _terminate_handler(self, **kwargs) -> Dict: + """Handle terminate action""" + return {"observation": "Task terminated.", "success": True} + + async def execute_tool(self, tool_name: str, **kwargs) -> Dict: + """Execute a tool by name with given parameters""" + tool_name = tool_name.lower().replace(" ", "_") + + if tool_name == "web_search" or tool_name == "search_web": + return await self.web_search.execute(**kwargs) + elif tool_name == "bash": + return await self.bash.execute(**kwargs) + elif tool_name == "python_execute": + return await self.python_execute.execute(**kwargs) + elif tool_name == "browser_use": + return await self.browser_use.execute(**kwargs) + elif tool_name == "terminate": + return await self.terminate(**kwargs) + else: + return {"observation": f"Unknown tool: {tool_name}", "success": False} + + def get_tool_names(self) -> List[str]: + """Get list of available tool names""" + return ["web_search", "bash", "python_execute", "browser_use", "terminate"] + + def get_tool_by_name(self, name: str): + """Get tool instance by name""" + name = name.lower().replace(" ", "_") + if name == "web_search" or name == "search_web": + return self.web_search + elif name == "bash": + return self.bash + elif name == "python_execute": + return self.python_execute + elif name == "browser_use": + return self.browser_use + return None + + def get_tool_description(self, name: str) -> str: + """Get tool description by name""" + tool = self.get_tool_by_name(name) + if tool: + return tool.description + elif name == "terminate": + return "Terminate the current task and submit a final answer." + return "Unknown tool" diff --git a/openmanus_rl/agentgym/agentenv-gaia/config/.gitignore b/openmanus_rl/agentgym/agentenv-gaia/config/.gitignore new file mode 100644 index 00000000..eaff1825 --- /dev/null +++ b/openmanus_rl/agentgym/agentenv-gaia/config/.gitignore @@ -0,0 +1,2 @@ +# prevent the local config file from being uploaded to the remote repository +config.toml diff --git a/openmanus_rl/agentgym/agentenv-gaia/config/config.example.toml b/openmanus_rl/agentgym/agentenv-gaia/config/config.example.toml new file mode 100644 index 00000000..0ab590ef --- /dev/null +++ b/openmanus_rl/agentgym/agentenv-gaia/config/config.example.toml @@ -0,0 +1,41 @@ +# Example configuration for Gaia + +# LLM Configuration +[llm] +model = "gpt-4o" +base_url = "https://api.openai.com/v1" +api_key = "your-api-key-here" +max_tokens = 4096 +temperature = 0.7 +api_type = "openai" + +# Optional configuration for specific browser configuration +# [browser] +# Whether to run browser in headless mode (default: false) +#headless = false +# Disable browser security features (default: true) +#disable_security = true +# Extra arguments to pass to the browser +#extra_chromium_args = [] +# Path to a Chrome instance to use to connect to your normal browser +# e.g. '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome' +#chrome_instance_path = "" +# Connect to a browser instance via WebSocket +#wss_url = "" +# Connect to a browser instance via CDP +#cdp_url = "" + +# Optional configuration, Search settings. +# [search] +# Search engine for agent to use. Default is "Google", can be set to "Baidu" or "DuckDuckGo" or "Bing". +#engine = "Google" +# Fallback engine order. Default is ["DuckDuckGo", "Baidu", "Bing"] - will try in this order after primary engine fails. +#fallback_engines = ["DuckDuckGo", "Baidu", "Bing"] +# Seconds to wait before retrying all engines again when they all fail due to rate limits. Default is 60. +#retry_delay = 60 +# Maximum number of times to retry all engines when all fail. Default is 3. +#max_retries = 3 +# Language code for search results. Options: "en" (English), "zh" (Chinese), etc. +#lang = "en" +# Country code for search results. Options: "us" (United States), "cn" (China), etc. +#country = "us" diff --git a/openmanus_rl/agentgym/agentenv-gaia/gaia/__init__.py b/openmanus_rl/agentgym/agentenv-gaia/gaia/__init__.py new file mode 100644 index 00000000..8294308c --- /dev/null +++ b/openmanus_rl/agentgym/agentenv-gaia/gaia/__init__.py @@ -0,0 +1,5 @@ +""" +Gaia - Agent Toolkit +""" + +__version__ = "0.1.0" \ No newline at end of file diff --git a/openmanus_rl/agentgym/agentenv-gaia/gaia/base.py b/openmanus_rl/agentgym/agentenv-gaia/gaia/base.py new file mode 100644 index 00000000..f0ac8681 --- /dev/null +++ b/openmanus_rl/agentgym/agentenv-gaia/gaia/base.py @@ -0,0 +1,101 @@ +from abc import ABC, abstractmethod +from typing import Any, Dict, Optional + +from pydantic import BaseModel, Field + + +class BaseTool(ABC, BaseModel): + name: str + description: str + parameters: Optional[dict] = None + + class Config: + arbitrary_types_allowed = True + + async def __call__(self, **kwargs) -> Any: + """Execute the tool with given parameters.""" + return await self.execute(**kwargs) + + @abstractmethod + async def execute(self, **kwargs) -> Any: + """Execute the tool with given parameters.""" + + def to_param(self) -> Dict: + """Convert tool to function call format.""" + return { + "type": "function", + "function": { + "name": self.name, + "description": self.description, + "parameters": self.parameters, + }, + } + + +class ToolResult(BaseModel): + """Represents the result of a tool execution.""" + + output: Any = Field(default=None) + error: Optional[str] = Field(default=None) + base64_image: Optional[str] = Field(default=None) + system: Optional[str] = Field(default=None) + + class Config: + arbitrary_types_allowed = True + + def __bool__(self): + return any(getattr(self, field) for field in self.__fields__) + + def __add__(self, other: "ToolResult"): + def combine_fields( + field: Optional[str], other_field: Optional[str], concatenate: bool = True + ): + if field and other_field: + if concatenate: + return field + other_field + raise ValueError("Cannot combine tool results") + return field or other_field + + return ToolResult( + output=combine_fields(self.output, other.output), + error=combine_fields(self.error, other.error), + base64_image=combine_fields(self.base64_image, other.base64_image, False), + system=combine_fields(self.system, other.system), + ) + + def __str__(self): + return f"Error: {self.error}" if self.error else self.output + + def replace(self, **kwargs): + """Returns a new ToolResult with the given fields replaced.""" + # return self.copy(update=kwargs) + return type(self)(**{**self.dict(), **kwargs}) + + +class CLIResult(ToolResult): + """A ToolResult that can be rendered as a CLI output.""" + + +class ToolFailure(ToolResult): + """A ToolResult that represents a failure.""" + + +class ToolError(Exception): + """Raised when a tool encounters an error.""" + + def __init__(self, message): + self.message = message + super().__init__(self.message) + + def __str__(self): + return self.message + + +class TokenLimitExceeded(Exception): + """Exception raised when the token limit is exceeded""" + def __init__(self, message="Token limit exceeded"): + self.message = message + super().__init__(self.message) + + def __str__(self): + return self.message diff --git a/openmanus_rl/agentgym/agentenv-gaia/gaia/bash.py b/openmanus_rl/agentgym/agentenv-gaia/gaia/bash.py new file mode 100644 index 00000000..998df712 --- /dev/null +++ b/openmanus_rl/agentgym/agentenv-gaia/gaia/bash.py @@ -0,0 +1,158 @@ +import asyncio +import os +from typing import Optional + +from gaia.base import ToolError +from gaia.base import BaseTool, CLIResult + + +_BASH_DESCRIPTION = """Execute a bash command in the terminal. +* Long running commands: For commands that may run indefinitely, it should be run in the background and the output should be redirected to a file, e.g. command = `python3 app.py > server.log 2>&1 &`. +* Interactive: If a bash command returns exit code `-1`, this means the process is not yet finished. The assistant must then send a second call to terminal with an empty `command` (which will retrieve any additional logs), or it can send additional text (set `command` to the text) to STDIN of the running process, or it can send command=`ctrl+c` to interrupt the process. +* Timeout: If a command execution result says "Command timed out. Sending SIGINT to the process", the assistant should retry running the command in the background. +""" + + +class _BashSession: + """A session of a bash shell.""" + + _started: bool + _process: asyncio.subprocess.Process + + command: str = "/bin/bash" + _output_delay: float = 0.2 # seconds + _timeout: float = 120.0 # seconds + _sentinel: str = "<>" + + def __init__(self): + self._started = False + self._timed_out = False + + async def start(self): + if self._started: + return + + self._process = await asyncio.create_subprocess_shell( + self.command, + preexec_fn=os.setsid, + shell=True, + bufsize=0, + stdin=asyncio.subprocess.PIPE, + stdout=asyncio.subprocess.PIPE, + stderr=asyncio.subprocess.PIPE, + ) + + self._started = True + + def stop(self): + """Terminate the bash shell.""" + if not self._started: + raise ToolError("Session has not started.") + if self._process.returncode is not None: + return + self._process.terminate() + + async def run(self, command: str): + """Execute a command in the bash shell.""" + if not self._started: + raise ToolError("Session has not started.") + if self._process.returncode is not None: + return CLIResult( + system="tool must be restarted", + error=f"bash has exited with returncode {self._process.returncode}", + ) + if self._timed_out: + raise ToolError( + f"timed out: bash has not returned in {self._timeout} seconds and must be restarted", + ) + + # we know these are not None because we created the process with PIPEs + assert self._process.stdin + assert self._process.stdout + assert self._process.stderr + + # send command to the process + self._process.stdin.write( + command.encode() + f"; echo '{self._sentinel}'\n".encode() + ) + await self._process.stdin.drain() + + # read output from the process, until the sentinel is found + try: + async with asyncio.timeout(self._timeout): + while True: + await asyncio.sleep(self._output_delay) + # if we read directly from stdout/stderr, it will wait forever for + # EOF. use the StreamReader buffer directly instead. + output = ( + self._process.stdout._buffer.decode() + ) # pyright: ignore[reportAttributeAccessIssue] + if self._sentinel in output: + # strip the sentinel and break + output = output[: output.index(self._sentinel)] + break + except asyncio.TimeoutError: + self._timed_out = True + raise ToolError( + f"timed out: bash has not returned in {self._timeout} seconds and must be restarted", + ) from None + + if output.endswith("\n"): + output = output[:-1] + + error = ( + self._process.stderr._buffer.decode() + ) # pyright: ignore[reportAttributeAccessIssue] + if error.endswith("\n"): + error = error[:-1] + + # clear the buffers so that the next output can be read correctly + self._process.stdout._buffer.clear() # pyright: ignore[reportAttributeAccessIssue] + self._process.stderr._buffer.clear() # pyright: ignore[reportAttributeAccessIssue] + + return CLIResult(output=output, error=error) + + +class Bash(BaseTool): + """A tool for executing bash commands""" + + name: str = "bash" + description: str = _BASH_DESCRIPTION + parameters: dict = { + "type": "object", + "properties": { + "command": { + "type": "string", + "description": "The bash command to execute. Can be empty to view additional logs when previous exit code is `-1`. Can be `ctrl+c` to interrupt the currently running process.", + }, + }, + "required": ["command"], + } + + _session: Optional[_BashSession] = None + + async def execute( + self, command: str | None = None, restart: bool = False, **kwargs + ) -> CLIResult: + if restart: + if self._session: + self._session.stop() + self._session = _BashSession() + await self._session.start() + + return CLIResult(system="tool has been restarted.") + + if self._session is None: + self._session = _BashSession() + await self._session.start() + + if command is not None: + return await self._session.run(command) + + raise ToolError("no command provided.") + + +if __name__ == "__main__": + bash = Bash() + rst = asyncio.run(bash.execute("ls -l")) + print(rst) diff --git a/openmanus_rl/agentgym/agentenv-gaia/gaia/browser_use_tool.py b/openmanus_rl/agentgym/agentenv-gaia/gaia/browser_use_tool.py new file mode 100644 index 00000000..e9aedf8c --- /dev/null +++ b/openmanus_rl/agentgym/agentenv-gaia/gaia/browser_use_tool.py @@ -0,0 +1,567 @@ +import asyncio +import base64 +import json +from typing import Generic, Optional, TypeVar + +from browser_use import Browser as BrowserUseBrowser +from browser_use import BrowserConfig +from browser_use.browser.context import BrowserContext, BrowserContextConfig +from browser_use.dom.service import DomService +from pydantic import Field, field_validator +from pydantic_core.core_schema import ValidationInfo + +from gaia.config import config +from gaia.llm import LLM +from gaia.base import BaseTool, ToolResult +from gaia.web_search import WebSearch + + +_BROWSER_DESCRIPTION = """\ +A powerful browser automation tool that allows interaction with web pages through various actions. +* This tool provides commands for controlling a browser session, navigating web pages, and extracting information +* It maintains state across calls, keeping the browser session alive until explicitly closed +* Use this when you need to browse websites, fill forms, click buttons, extract content, or perform web searches +* Each action requires specific parameters as defined in the tool's dependencies + +Key capabilities include: +* Navigation: Go to specific URLs, go back, search the web, or refresh pages +* Interaction: Click elements, input text, select from dropdowns, send keyboard commands +* Scrolling: Scroll up/down by pixel amount or scroll to specific text +* Content extraction: Extract and analyze content from web pages based on specific goals +* Tab management: Switch between tabs, open new tabs, or close tabs + +Note: When using element indices, refer to the numbered elements shown in the current browser state. +""" + +Context = TypeVar("Context") + + +class BrowserUseTool(BaseTool, Generic[Context]): + name: str = "browser_use" + description: str = _BROWSER_DESCRIPTION + parameters: dict = { + "type": "object", + "properties": { + "action": { + "type": "string", + "enum": [ + "go_to_url", + "click_element", + "input_text", + "scroll_down", + "scroll_up", + "scroll_to_text", + "send_keys", + "get_dropdown_options", + "select_dropdown_option", + "go_back", + "web_search", + "wait", + "extract_content", + "switch_tab", + "open_tab", + "close_tab", + ], + "description": "The browser action to perform", + }, + "url": { + "type": "string", + "description": "URL for 'go_to_url' or 'open_tab' actions", + }, + "index": { + "type": "integer", + "description": "Element index for 'click_element', 'input_text', 'get_dropdown_options', or 'select_dropdown_option' actions", + }, + "text": { + "type": "string", + "description": "Text for 'input_text', 'scroll_to_text', or 'select_dropdown_option' actions", + }, + "scroll_amount": { + "type": "integer", + "description": "Pixels to scroll (positive for down, negative for up) for 'scroll_down' or 'scroll_up' actions", + }, + "tab_id": { + "type": "integer", + "description": "Tab ID for 'switch_tab' action", + }, + "query": { + "type": "string", + "description": "Search query for 'web_search' action", + }, + "goal": { + "type": "string", + "description": "Extraction goal for 'extract_content' action", + }, + "keys": { + "type": "string", + "description": "Keys to send for 'send_keys' action", + }, + "seconds": { + "type": "integer", + "description": "Seconds to wait for 'wait' action", + }, + }, + "required": ["action"], + "dependencies": { + "go_to_url": ["url"], + "click_element": ["index"], + "input_text": ["index", "text"], + "switch_tab": ["tab_id"], + "open_tab": ["url"], + "scroll_down": ["scroll_amount"], + "scroll_up": ["scroll_amount"], + "scroll_to_text": ["text"], + "send_keys": ["keys"], + "get_dropdown_options": ["index"], + "select_dropdown_option": ["index", "text"], + "go_back": [], + "web_search": ["query"], + "wait": ["seconds"], + "extract_content": ["goal"], + }, + } + + lock: asyncio.Lock = Field(default_factory=asyncio.Lock) + browser: Optional[BrowserUseBrowser] = Field(default=None, exclude=True) + context: Optional[BrowserContext] = Field(default=None, exclude=True) + dom_service: Optional[DomService] = Field(default=None, exclude=True) + web_search_tool: WebSearch = Field(default_factory=WebSearch, exclude=True) + + # Context for generic functionality + tool_context: Optional[Context] = Field(default=None, exclude=True) + + llm: Optional[LLM] = Field(default_factory=LLM) + + @field_validator("parameters", mode="before") + def validate_parameters(cls, v: dict, info: ValidationInfo) -> dict: + if not v: + raise ValueError("Parameters cannot be empty") + return v + + async def _ensure_browser_initialized(self) -> BrowserContext: + """Ensure browser and context are initialized.""" + if self.browser is None: + browser_config_kwargs = {"headless": False, "disable_security": True} + + if config.browser_config: + from browser_use.browser.browser import ProxySettings + + # handle proxy settings. + if config.browser_config.proxy and config.browser_config.proxy.server: + browser_config_kwargs["proxy"] = ProxySettings( + server=config.browser_config.proxy.server, + username=config.browser_config.proxy.username, + password=config.browser_config.proxy.password, + ) + + browser_attrs = [ + "headless", + "disable_security", + "extra_chromium_args", + "chrome_instance_path", + "wss_url", + "cdp_url", + ] + + for attr in browser_attrs: + value = getattr(config.browser_config, attr, None) + if value is not None: + if not isinstance(value, list) or value: + browser_config_kwargs[attr] = value + + self.browser = BrowserUseBrowser(BrowserConfig(**browser_config_kwargs)) + + if self.context is None: + context_config = BrowserContextConfig() + + # if there is context config in the config, use it. + if ( + config.browser_config + and hasattr(config.browser_config, "new_context_config") + and config.browser_config.new_context_config + ): + context_config = config.browser_config.new_context_config + + self.context = await self.browser.new_context(context_config) + self.dom_service = DomService(await self.context.get_current_page()) + + return self.context + + async def execute( + self, + action: str, + url: Optional[str] = None, + index: Optional[int] = None, + text: Optional[str] = None, + scroll_amount: Optional[int] = None, + tab_id: Optional[int] = None, + query: Optional[str] = None, + goal: Optional[str] = None, + keys: Optional[str] = None, + seconds: Optional[int] = None, + **kwargs, + ) -> ToolResult: + """ + Execute a specified browser action. + + Args: + action: The browser action to perform + url: URL for navigation or new tab + index: Element index for click or input actions + text: Text for input action or search query + scroll_amount: Pixels to scroll for scroll action + tab_id: Tab ID for switch_tab action + query: Search query for Google search + goal: Extraction goal for content extraction + keys: Keys to send for keyboard actions + seconds: Seconds to wait + **kwargs: Additional arguments + + Returns: + ToolResult with the action's output or error + """ + async with self.lock: + try: + context = await self._ensure_browser_initialized() + + # Get max content length from config + max_content_length = getattr( + config.browser_config, "max_content_length", 2000 + ) + + # Navigation actions + if action == "go_to_url": + if not url: + return ToolResult( + error="URL is required for 'go_to_url' action" + ) + page = await context.get_current_page() + await page.goto(url) + await page.wait_for_load_state() + return ToolResult(output=f"Navigated to {url}") + + elif action == "go_back": + await context.go_back() + return ToolResult(output="Navigated back") + + elif action == "refresh": + await context.refresh_page() + return ToolResult(output="Refreshed current page") + + elif action == "web_search": + if not query: + return ToolResult( + error="Query is required for 'web_search' action" + ) + # Execute the web search and return results directly without browser navigation + search_response = await self.web_search_tool.execute( + query=query, fetch_content=True, num_results=1 + ) + # Navigate to the first search result + first_search_result = search_response.results[0] + url_to_navigate = first_search_result.url + + page = await context.get_current_page() + await page.goto(url_to_navigate) + await page.wait_for_load_state() + + return search_response + + # Element interaction actions + elif action == "click_element": + if index is None: + return ToolResult( + error="Index is required for 'click_element' action" + ) + element = await context.get_dom_element_by_index(index) + if not element: + return ToolResult(error=f"Element with index {index} not found") + download_path = await context._click_element_node(element) + output = f"Clicked element at index {index}" + if download_path: + output += f" - Downloaded file to {download_path}" + return ToolResult(output=output) + + elif action == "input_text": + if index is None or not text: + return ToolResult( + error="Index and text are required for 'input_text' action" + ) + element = await context.get_dom_element_by_index(index) + if not element: + return ToolResult(error=f"Element with index {index} not found") + await context._input_text_element_node(element, text) + return ToolResult( + output=f"Input '{text}' into element at index {index}" + ) + + elif action == "scroll_down" or action == "scroll_up": + direction = 1 if action == "scroll_down" else -1 + amount = ( + scroll_amount + if scroll_amount is not None + else context.config.browser_window_size["height"] + ) + await context.execute_javascript( + f"window.scrollBy(0, {direction * amount});" + ) + return ToolResult( + output=f"Scrolled {'down' if direction > 0 else 'up'} by {amount} pixels" + ) + + elif action == "scroll_to_text": + if not text: + return ToolResult( + error="Text is required for 'scroll_to_text' action" + ) + page = await context.get_current_page() + try: + locator = page.get_by_text(text, exact=False) + await locator.scroll_into_view_if_needed() + return ToolResult(output=f"Scrolled to text: '{text}'") + except Exception as e: + return ToolResult(error=f"Failed to scroll to text: {str(e)}") + + elif action == "send_keys": + if not keys: + return ToolResult( + error="Keys are required for 'send_keys' action" + ) + page = await context.get_current_page() + await page.keyboard.press(keys) + return ToolResult(output=f"Sent keys: {keys}") + + elif action == "get_dropdown_options": + if index is None: + return ToolResult( + error="Index is required for 'get_dropdown_options' action" + ) + element = await context.get_dom_element_by_index(index) + if not element: + return ToolResult(error=f"Element with index {index} not found") + page = await context.get_current_page() + options = await page.evaluate( + """ + (xpath) => { + const select = document.evaluate(xpath, document, null, + XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue; + if (!select) return null; + return Array.from(select.options).map(opt => ({ + text: opt.text, + value: opt.value, + index: opt.index + })); + } + """, + element.xpath, + ) + return ToolResult(output=f"Dropdown options: {options}") + + elif action == "select_dropdown_option": + if index is None or not text: + return ToolResult( + error="Index and text are required for 'select_dropdown_option' action" + ) + element = await context.get_dom_element_by_index(index) + if not element: + return ToolResult(error=f"Element with index {index} not found") + page = await context.get_current_page() + await page.select_option(element.xpath, label=text) + return ToolResult( + output=f"Selected option '{text}' from dropdown at index {index}" + ) + + # Content extraction actions + elif action == "extract_content": + if not goal: + return ToolResult( + error="Goal is required for 'extract_content' action" + ) + + page = await context.get_current_page() + import markdownify + + content = markdownify.markdownify(await page.content()) + + prompt = f"""\ +Your task is to extract the content of the page. You will be given a page and a goal, and you should extract all relevant information around this goal from the page. If the goal is vague, summarize the page. Respond in json format. +Extraction goal: {goal} + +Page content: +{content[:max_content_length]} +""" + messages = [{"role": "system", "content": prompt}] + + # Define extraction function schema + extraction_function = { + "type": "function", + "function": { + "name": "extract_content", + "description": "Extract specific information from a webpage based on a goal", + "parameters": { + "type": "object", + "properties": { + "extracted_content": { + "type": "object", + "description": "The content extracted from the page according to the goal", + "properties": { + "text": { + "type": "string", + "description": "Text content extracted from the page", + }, + "metadata": { + "type": "object", + "description": "Additional metadata about the extracted content", + "properties": { + "source": { + "type": "string", + "description": "Source of the extracted content", + } + }, + }, + }, + } + }, + "required": ["extracted_content"], + }, + }, + } + + # Use LLM to extract content with required function calling + response = await self.llm.ask_tool( + messages, + tools=[extraction_function], + tool_choice="required", + ) + + if response and response.tool_calls: + args = json.loads(response.tool_calls[0].function.arguments) + extracted_content = args.get("extracted_content", {}) + return ToolResult( + output=f"Extracted from page:\n{extracted_content}\n" + ) + + return ToolResult(output="No content was extracted from the page.") + + # Tab management actions + elif action == "switch_tab": + if tab_id is None: + return ToolResult( + error="Tab ID is required for 'switch_tab' action" + ) + await context.switch_to_tab(tab_id) + page = await context.get_current_page() + await page.wait_for_load_state() + return ToolResult(output=f"Switched to tab {tab_id}") + + elif action == "open_tab": + if not url: + return ToolResult(error="URL is required for 'open_tab' action") + await context.create_new_tab(url) + return ToolResult(output=f"Opened new tab with {url}") + + elif action == "close_tab": + await context.close_current_tab() + return ToolResult(output="Closed current tab") + + # Utility actions + elif action == "wait": + seconds_to_wait = seconds if seconds is not None else 3 + await asyncio.sleep(seconds_to_wait) + return ToolResult(output=f"Waited for {seconds_to_wait} seconds") + + else: + return ToolResult(error=f"Unknown action: {action}") + + except Exception as e: + return ToolResult(error=f"Browser action '{action}' failed: {str(e)}") + + async def get_current_state( + self, context: Optional[BrowserContext] = None + ) -> ToolResult: + """ + Get the current browser state as a ToolResult. + If context is not provided, uses self.context. + """ + try: + # Use provided context or fall back to self.context + ctx = context or self.context + if not ctx: + return ToolResult(error="Browser context not initialized") + + state = await ctx.get_state() + + # Create a viewport_info dictionary if it doesn't exist + viewport_height = 0 + if hasattr(state, "viewport_info") and state.viewport_info: + viewport_height = state.viewport_info.height + elif hasattr(ctx, "config") and hasattr(ctx.config, "browser_window_size"): + viewport_height = ctx.config.browser_window_size.get("height", 0) + + # Take a screenshot for the state + page = await ctx.get_current_page() + + await page.bring_to_front() + await page.wait_for_load_state() + + screenshot = await page.screenshot( + full_page=True, animations="disabled", type="jpeg", quality=100 + ) + + screenshot = base64.b64encode(screenshot).decode("utf-8") + + # Build the state info with all required fields + state_info = { + "url": state.url, + "title": state.title, + "tabs": [tab.model_dump() for tab in state.tabs], + "help": "[0], [1], [2], etc., represent clickable indices corresponding to the elements listed. Clicking on these indices will navigate to or interact with the respective content behind them.", + "interactive_elements": ( + state.element_tree.clickable_elements_to_string() + if state.element_tree + else "" + ), + "scroll_info": { + "pixels_above": getattr(state, "pixels_above", 0), + "pixels_below": getattr(state, "pixels_below", 0), + "total_height": getattr(state, "pixels_above", 0) + + getattr(state, "pixels_below", 0) + + viewport_height, + }, + "viewport_height": viewport_height, + } + + return ToolResult( + output=json.dumps(state_info, indent=4, ensure_ascii=False), + base64_image=screenshot, + ) + except Exception as e: + return ToolResult(error=f"Failed to get browser state: {str(e)}") + + async def cleanup(self): + """Clean up browser resources.""" + async with self.lock: + if self.context is not None: + await self.context.close() + self.context = None + self.dom_service = None + if self.browser is not None: + await self.browser.close() + self.browser = None + + def __del__(self): + """Ensure cleanup when object is destroyed.""" + if self.browser is not None or self.context is not None: + try: + asyncio.run(self.cleanup()) + except RuntimeError: + loop = asyncio.new_event_loop() + loop.run_until_complete(self.cleanup()) + loop.close() + + @classmethod + def create_with_context(cls, context: Context) -> "BrowserUseTool[Context]": + """Factory method to create a BrowserUseTool with a specific context.""" + tool = cls() + tool.tool_context = context + return tool diff --git a/openmanus_rl/agentgym/agentenv-gaia/gaia/config.py b/openmanus_rl/agentgym/agentenv-gaia/gaia/config.py new file mode 100644 index 00000000..87780b4f --- /dev/null +++ b/openmanus_rl/agentgym/agentenv-gaia/gaia/config.py @@ -0,0 +1,320 @@ +import json +import threading +import tomllib +from pathlib import Path +from typing import Dict, List, Optional + +from pydantic import BaseModel, Field + + +def get_project_root() -> Path: + """Get the project root directory""" + return Path(__file__).resolve().parent.parent + + +PROJECT_ROOT = get_project_root() +WORKSPACE_ROOT = PROJECT_ROOT / "workspace" + + +class LLMSettings(BaseModel): + model: str = Field(..., description="Model name") + base_url: str = Field(..., description="API base URL") + api_key: str = Field(..., description="API key") + max_tokens: int = Field(4096, description="Maximum number of tokens per request") + max_input_tokens: Optional[int] = Field( + None, + description="Maximum input tokens to use across all requests (None for unlimited)", + ) + temperature: float = Field(1.0, description="Sampling temperature") + api_type: str = Field(..., description="Azure, Openai, or Ollama") + api_version: str = Field(..., description="Azure Openai version if AzureOpenai") + + +class ProxySettings(BaseModel): + server: str = Field(None, description="Proxy server address") + username: Optional[str] = Field(None, description="Proxy username") + password: Optional[str] = Field(None, description="Proxy password") + + +class SearchSettings(BaseModel): + engine: str = Field(default="Google", description="Search engine the llm to use") + fallback_engines: List[str] = Field( + default_factory=lambda: ["DuckDuckGo", "Baidu", "Bing"], + description="Fallback search engines to try if the primary engine fails", + ) + retry_delay: int = Field( + default=60, + description="Seconds to wait before retrying all engines again after they all fail", + ) + max_retries: int = Field( + default=3, + description="Maximum number of times to retry all engines when all fail", + ) + lang: str = Field( + default="en", + description="Language code for search results (e.g., en, zh, fr)", + ) + country: str = Field( + default="us", + description="Country code for search results (e.g., us, cn, uk)", + ) + + +class BrowserSettings(BaseModel): + headless: bool = Field(False, description="Whether to run browser in headless mode") + disable_security: bool = Field( + True, description="Disable browser security features" + ) + extra_chromium_args: List[str] = Field( + default_factory=list, description="Extra arguments to pass to the browser" + ) + chrome_instance_path: Optional[str] = Field( + None, description="Path to a Chrome instance to use" + ) + wss_url: Optional[str] = Field( + None, description="Connect to a browser instance via WebSocket" + ) + cdp_url: Optional[str] = Field( + None, description="Connect to a browser instance via CDP" + ) + proxy: Optional[ProxySettings] = Field( + None, description="Proxy settings for the browser" + ) + max_content_length: int = Field( + 2000, description="Maximum length for content retrieval operations" + ) + + +class SandboxSettings(BaseModel): + """Configuration for the execution sandbox""" + + use_sandbox: bool = Field(False, description="Whether to use the sandbox") + image: str = Field("python:3.12-slim", description="Base image") + work_dir: str = Field("/workspace", description="Container working directory") + memory_limit: str = Field("512m", description="Memory limit") + cpu_limit: float = Field(1.0, description="CPU limit") + timeout: int = Field(300, description="Default command timeout (seconds)") + network_enabled: bool = Field( + False, description="Whether network access is allowed" + ) + + +class MCPServerConfig(BaseModel): + """Configuration for a single MCP server""" + + type: str = Field(..., description="Server connection type (sse or stdio)") + url: Optional[str] = Field(None, description="Server URL for SSE connections") + command: Optional[str] = Field(None, description="Command for stdio connections") + args: List[str] = Field( + default_factory=list, description="Arguments for stdio command" + ) + + +class MCPSettings(BaseModel): + """Configuration for MCP (Model Context Protocol)""" + + server_reference: str = Field( + "app.mcp.server", description="Module reference for the MCP server" + ) + servers: Dict[str, MCPServerConfig] = Field( + default_factory=dict, description="MCP server configurations" + ) + + @classmethod + def load_server_config(cls) -> Dict[str, MCPServerConfig]: + """Load MCP server configuration from JSON file""" + config_path = PROJECT_ROOT / "config" / "mcp.json" + + try: + config_file = config_path if config_path.exists() else None + if not config_file: + return {} + + with config_file.open() as f: + data = json.load(f) + servers = {} + + for server_id, server_config in data.get("mcpServers", {}).items(): + servers[server_id] = MCPServerConfig( + type=server_config["type"], + url=server_config.get("url"), + command=server_config.get("command"), + args=server_config.get("args", []), + ) + return servers + except Exception as e: + raise ValueError(f"Failed to load MCP server config: {e}") + + +class AppConfig(BaseModel): + llm: Dict[str, LLMSettings] + sandbox: Optional[SandboxSettings] = Field( + None, description="Sandbox configuration" + ) + browser_config: Optional[BrowserSettings] = Field( + None, description="Browser configuration" + ) + search_config: Optional[SearchSettings] = Field( + None, description="Search configuration" + ) + mcp_config: Optional[MCPSettings] = Field(None, description="MCP configuration") + + class Config: + arbitrary_types_allowed = True + + +class Config: + _instance = None + _lock = threading.Lock() + _initialized = False + + def __new__(cls): + if cls._instance is None: + with cls._lock: + if cls._instance is None: + cls._instance = super().__new__(cls) + return cls._instance + + def __init__(self): + if not self._initialized: + with self._lock: + if not self._initialized: + self._config = None + self._load_initial_config() + self._initialized = True + + @staticmethod + def _get_config_path() -> Path: + root = PROJECT_ROOT + config_path = root / "config" / "config.toml" + if config_path.exists(): + return config_path + example_path = root / "config" / "config.example.toml" + if example_path.exists(): + return example_path + raise FileNotFoundError("No configuration file found in config directory") + + def _load_config(self) -> dict: + config_path = self._get_config_path() + with config_path.open("rb") as f: + return tomllib.load(f) + + def _load_initial_config(self): + raw_config = self._load_config() + base_llm = raw_config.get("llm", {}) + llm_overrides = { + k: v for k, v in raw_config.get("llm", {}).items() if isinstance(v, dict) + } + + default_settings = { + "model": base_llm.get("model"), + "base_url": base_llm.get("base_url"), + "api_key": base_llm.get("api_key"), + "max_tokens": base_llm.get("max_tokens", 4096), + "max_input_tokens": base_llm.get("max_input_tokens"), + "temperature": base_llm.get("temperature", 1.0), + "api_type": base_llm.get("api_type", ""), + "api_version": base_llm.get("api_version", ""), + } + + # handle browser config. + browser_config = raw_config.get("browser", {}) + browser_settings = None + + if browser_config: + # handle proxy settings. + proxy_config = browser_config.get("proxy", {}) + proxy_settings = None + + if proxy_config and proxy_config.get("server"): + proxy_settings = ProxySettings( + **{ + k: v + for k, v in proxy_config.items() + if k in ["server", "username", "password"] and v + } + ) + + # filter valid browser config parameters. + valid_browser_params = { + k: v + for k, v in browser_config.items() + if k in BrowserSettings.__annotations__ and v is not None + } + + # if there is proxy settings, add it to the parameters. + if proxy_settings: + valid_browser_params["proxy"] = proxy_settings + + # only create BrowserSettings when there are valid parameters. + if valid_browser_params: + browser_settings = BrowserSettings(**valid_browser_params) + + search_config = raw_config.get("search", {}) + search_settings = None + if search_config: + search_settings = SearchSettings(**search_config) + sandbox_config = raw_config.get("sandbox", {}) + if sandbox_config: + sandbox_settings = SandboxSettings(**sandbox_config) + else: + sandbox_settings = SandboxSettings() + + mcp_config = raw_config.get("mcp", {}) + mcp_settings = None + if mcp_config: + # Load server configurations from JSON + mcp_config["servers"] = MCPSettings.load_server_config() + mcp_settings = MCPSettings(**mcp_config) + else: + mcp_settings = MCPSettings(servers=MCPSettings.load_server_config()) + + config_dict = { + "llm": { + "default": default_settings, + **{ + name: {**default_settings, **override_config} + for name, override_config in llm_overrides.items() + }, + }, + "sandbox": sandbox_settings, + "browser_config": browser_settings, + "search_config": search_settings, + "mcp_config": mcp_settings, + } + + self._config = AppConfig(**config_dict) + + @property + def llm(self) -> Dict[str, LLMSettings]: + return self._config.llm + + @property + def sandbox(self) -> SandboxSettings: + return self._config.sandbox + + @property + def browser_config(self) -> Optional[BrowserSettings]: + return self._config.browser_config + + @property + def search_config(self) -> Optional[SearchSettings]: + return self._config.search_config + + @property + def mcp_config(self) -> MCPSettings: + """Get the MCP configuration""" + return self._config.mcp_config + + @property + def workspace_root(self) -> Path: + """Get the workspace root directory""" + return WORKSPACE_ROOT + + @property + def root_path(self) -> Path: + """Get the root path of the application""" + return PROJECT_ROOT + + +config = Config() diff --git a/openmanus_rl/agentgym/agentenv-gaia/gaia/llm.py b/openmanus_rl/agentgym/agentenv-gaia/gaia/llm.py new file mode 100644 index 00000000..d9f023e9 --- /dev/null +++ b/openmanus_rl/agentgym/agentenv-gaia/gaia/llm.py @@ -0,0 +1,766 @@ +import math +from typing import Dict, List, Optional, Union + +import tiktoken +from openai import ( + APIError, + AsyncAzureOpenAI, + AsyncOpenAI, + AuthenticationError, + OpenAIError, + RateLimitError, +) +from openai.types.chat import ChatCompletion, ChatCompletionMessage +from tenacity import ( + retry, + retry_if_exception_type, + stop_after_attempt, + wait_random_exponential, +) + +from gaia.config import LLMSettings, config +from gaia.base import TokenLimitExceeded +# from gaia.logger import logger # Assuming a logger is set up in your app +from gaia.schema import ( + ROLE_VALUES, + TOOL_CHOICE_TYPE, + TOOL_CHOICE_VALUES, + Message, + ToolChoice, +) + +import logging + +logger = logging.getLogger(__name__) + +REASONING_MODELS = ["o1", "o3-mini"] +MULTIMODAL_MODELS = [ + "gpt-4-vision-preview", + "gpt-4o", + "gpt-4o-mini", + "claude-3-opus-20240229", + "claude-3-sonnet-20240229", + "claude-3-haiku-20240307", +] + + +class TokenCounter: + # Token constants + BASE_MESSAGE_TOKENS = 4 + FORMAT_TOKENS = 2 + LOW_DETAIL_IMAGE_TOKENS = 85 + HIGH_DETAIL_TILE_TOKENS = 170 + + # Image processing constants + MAX_SIZE = 2048 + HIGH_DETAIL_TARGET_SHORT_SIDE = 768 + TILE_SIZE = 512 + + def __init__(self, tokenizer): + self.tokenizer = tokenizer + + def count_text(self, text: str) -> int: + """Calculate tokens for a text string""" + return 0 if not text else len(self.tokenizer.encode(text)) + + def count_image(self, image_item: dict) -> int: + """ + Calculate tokens for an image based on detail level and dimensions + + For "low" detail: fixed 85 tokens + For "high" detail: + 1. Scale to fit in 2048x2048 square + 2. Scale shortest side to 768px + 3. Count 512px tiles (170 tokens each) + 4. Add 85 tokens + """ + detail = image_item.get("detail", "medium") + + # For low detail, always return fixed token count + if detail == "low": + return self.LOW_DETAIL_IMAGE_TOKENS + + # For medium detail (default in OpenAI), use high detail calculation + # OpenAI doesn't specify a separate calculation for medium + + # For high detail, calculate based on dimensions if available + if detail == "high" or detail == "medium": + # If dimensions are provided in the image_item + if "dimensions" in image_item: + width, height = image_item["dimensions"] + return self._calculate_high_detail_tokens(width, height) + + return ( + self._calculate_high_detail_tokens(1024, 1024) if detail == "high" else 1024 + ) + + def _calculate_high_detail_tokens(self, width: int, height: int) -> int: + """Calculate tokens for high detail images based on dimensions""" + # Step 1: Scale to fit in MAX_SIZE x MAX_SIZE square + if width > self.MAX_SIZE or height > self.MAX_SIZE: + scale = self.MAX_SIZE / max(width, height) + width = int(width * scale) + height = int(height * scale) + + # Step 2: Scale so shortest side is HIGH_DETAIL_TARGET_SHORT_SIDE + scale = self.HIGH_DETAIL_TARGET_SHORT_SIDE / min(width, height) + scaled_width = int(width * scale) + scaled_height = int(height * scale) + + # Step 3: Count number of 512px tiles + tiles_x = math.ceil(scaled_width / self.TILE_SIZE) + tiles_y = math.ceil(scaled_height / self.TILE_SIZE) + total_tiles = tiles_x * tiles_y + + # Step 4: Calculate final token count + return ( + total_tiles * self.HIGH_DETAIL_TILE_TOKENS + ) + self.LOW_DETAIL_IMAGE_TOKENS + + def count_content(self, content: Union[str, List[Union[str, dict]]]) -> int: + """Calculate tokens for message content""" + if not content: + return 0 + + if isinstance(content, str): + return self.count_text(content) + + token_count = 0 + for item in content: + if isinstance(item, str): + token_count += self.count_text(item) + elif isinstance(item, dict): + if "text" in item: + token_count += self.count_text(item["text"]) + elif "image_url" in item: + token_count += self.count_image(item) + return token_count + + def count_tool_calls(self, tool_calls: List[dict]) -> int: + """Calculate tokens for tool calls""" + token_count = 0 + for tool_call in tool_calls: + if "function" in tool_call: + function = tool_call["function"] + token_count += self.count_text(function.get("name", "")) + token_count += self.count_text(function.get("arguments", "")) + return token_count + + def count_message_tokens(self, messages: List[dict]) -> int: + """Calculate the total number of tokens in a message list""" + total_tokens = self.FORMAT_TOKENS # Base format tokens + + for message in messages: + tokens = self.BASE_MESSAGE_TOKENS # Base tokens per message + + # Add role tokens + tokens += self.count_text(message.get("role", "")) + + # Add content tokens + if "content" in message: + tokens += self.count_content(message["content"]) + + # Add tool calls tokens + if "tool_calls" in message: + tokens += self.count_tool_calls(message["tool_calls"]) + + # Add name and tool_call_id tokens + tokens += self.count_text(message.get("name", "")) + tokens += self.count_text(message.get("tool_call_id", "")) + + total_tokens += tokens + + return total_tokens + + +class LLM: + _instances: Dict[str, "LLM"] = {} + + def __new__( + cls, config_name: str = "default", llm_config: Optional[LLMSettings] = None + ): + if config_name not in cls._instances: + instance = super().__new__(cls) + instance.__init__(config_name, llm_config) + cls._instances[config_name] = instance + return cls._instances[config_name] + + def __init__( + self, config_name: str = "default", llm_config: Optional[LLMSettings] = None + ): + if not hasattr(self, "client"): # Only initialize if not already initialized + llm_config = llm_config or config.llm + llm_config = llm_config.get(config_name, llm_config["default"]) + self.model = llm_config.model + self.max_tokens = llm_config.max_tokens + self.temperature = llm_config.temperature + self.api_type = llm_config.api_type + self.api_key = llm_config.api_key + self.api_version = llm_config.api_version + self.base_url = llm_config.base_url + + # Add token counting related attributes + self.total_input_tokens = 0 + self.total_completion_tokens = 0 + self.max_input_tokens = ( + llm_config.max_input_tokens + if hasattr(llm_config, "max_input_tokens") + else None + ) + + # Initialize tokenizer + try: + self.tokenizer = tiktoken.encoding_for_model(self.model) + except KeyError: + # If the model is not in tiktoken's presets, use cl100k_base as default + self.tokenizer = tiktoken.get_encoding("cl100k_base") + + if self.api_type == "azure": + self.client = AsyncAzureOpenAI( + base_url=self.base_url, + api_key=self.api_key, + api_version=self.api_version, + ) + else: + self.client = AsyncOpenAI(api_key=self.api_key, base_url=self.base_url) + + self.token_counter = TokenCounter(self.tokenizer) + + def count_tokens(self, text: str) -> int: + """Calculate the number of tokens in a text""" + if not text: + return 0 + return len(self.tokenizer.encode(text)) + + def count_message_tokens(self, messages: List[dict]) -> int: + return self.token_counter.count_message_tokens(messages) + + def update_token_count(self, input_tokens: int, completion_tokens: int = 0) -> None: + """Update token counts""" + # Only track tokens if max_input_tokens is set + self.total_input_tokens += input_tokens + self.total_completion_tokens += completion_tokens + logger.info( + f"Token usage: Input={input_tokens}, Completion={completion_tokens}, " + f"Cumulative Input={self.total_input_tokens}, Cumulative Completion={self.total_completion_tokens}, " + f"Total={input_tokens + completion_tokens}, Cumulative Total={self.total_input_tokens + self.total_completion_tokens}" + ) + + def check_token_limit(self, input_tokens: int) -> bool: + """Check if token limits are exceeded""" + if self.max_input_tokens is not None: + return (self.total_input_tokens + input_tokens) <= self.max_input_tokens + # If max_input_tokens is not set, always return True + return True + + def get_limit_error_message(self, input_tokens: int) -> str: + """Generate error message for token limit exceeded""" + if ( + self.max_input_tokens is not None + and (self.total_input_tokens + input_tokens) > self.max_input_tokens + ): + return f"Request may exceed input token limit (Current: {self.total_input_tokens}, Needed: {input_tokens}, Max: {self.max_input_tokens})" + + return "Token limit exceeded" + + @staticmethod + def format_messages( + messages: List[Union[dict, Message]], supports_images: bool = False + ) -> List[dict]: + """ + Format messages for LLM by converting them to OpenAI message format. + + Args: + messages: List of messages that can be either dict or Message objects + supports_images: Flag indicating if the target model supports image inputs + + Returns: + List[dict]: List of formatted messages in OpenAI format + + Raises: + ValueError: If messages are invalid or missing required fields + TypeError: If unsupported message types are provided + + Examples: + >>> msgs = [ + ... Message.system_message("You are a helpful assistant"), + ... {"role": "user", "content": "Hello"}, + ... Message.user_message("How are you?") + ... ] + >>> formatted = LLM.format_messages(msgs) + """ + formatted_messages = [] + + for message in messages: + # Convert Message objects to dictionaries + if isinstance(message, Message): + message = message.to_dict() + + if isinstance(message, dict): + # If message is a dict, ensure it has required fields + if "role" not in message: + raise ValueError("Message dict must contain 'role' field") + + # Process base64 images if present and model supports images + if supports_images and message.get("base64_image"): + # Initialize or convert content to appropriate format + if not message.get("content"): + message["content"] = [] + elif isinstance(message["content"], str): + message["content"] = [ + {"type": "text", "text": message["content"]} + ] + elif isinstance(message["content"], list): + # Convert string items to proper text objects + message["content"] = [ + ( + {"type": "text", "text": item} + if isinstance(item, str) + else item + ) + for item in message["content"] + ] + + # Add the image to content + message["content"].append( + { + "type": "image_url", + "image_url": { + "url": f"data:image/jpeg;base64,{message['base64_image']}" + }, + } + ) + + # Remove the base64_image field + del message["base64_image"] + # If model doesn't support images but message has base64_image, handle gracefully + elif not supports_images and message.get("base64_image"): + # Just remove the base64_image field and keep the text content + del message["base64_image"] + + if "content" in message or "tool_calls" in message: + formatted_messages.append(message) + # else: do not include the message + else: + raise TypeError(f"Unsupported message type: {type(message)}") + + # Validate all messages have required fields + for msg in formatted_messages: + if msg["role"] not in ROLE_VALUES: + raise ValueError(f"Invalid role: {msg['role']}") + + return formatted_messages + + @retry( + wait=wait_random_exponential(min=1, max=60), + stop=stop_after_attempt(6), + retry=retry_if_exception_type( + (OpenAIError, Exception, ValueError) + ), # Don't retry TokenLimitExceeded + ) + async def ask( + self, + messages: List[Union[dict, Message]], + system_msgs: Optional[List[Union[dict, Message]]] = None, + stream: bool = True, + temperature: Optional[float] = None, + ) -> str: + """ + Send a prompt to the LLM and get the response. + + Args: + messages: List of conversation messages + system_msgs: Optional system messages to prepend + stream (bool): Whether to stream the response + temperature (float): Sampling temperature for the response + + Returns: + str: The generated response + + Raises: + TokenLimitExceeded: If token limits are exceeded + ValueError: If messages are invalid or response is empty + OpenAIError: If API call fails after retries + Exception: For unexpected errors + """ + try: + # Check if the model supports images + supports_images = self.model in MULTIMODAL_MODELS + + # Format system and user messages with image support check + if system_msgs: + system_msgs = self.format_messages(system_msgs, supports_images) + messages = system_msgs + self.format_messages(messages, supports_images) + else: + messages = self.format_messages(messages, supports_images) + + # Calculate input token count + input_tokens = self.count_message_tokens(messages) + + # Check if token limits are exceeded + if not self.check_token_limit(input_tokens): + error_message = self.get_limit_error_message(input_tokens) + # Raise a special exception that won't be retried + raise TokenLimitExceeded(error_message) + + params = { + "model": self.model, + "messages": messages, + } + + if self.model in REASONING_MODELS: + params["max_completion_tokens"] = self.max_tokens + else: + params["max_tokens"] = self.max_tokens + params["temperature"] = ( + temperature if temperature is not None else self.temperature + ) + + if not stream: + # Non-streaming request + response = await self.client.chat.completions.create( + **params, stream=False + ) + + if not response.choices or not response.choices[0].message.content: + raise ValueError("Empty or invalid response from LLM") + + # Update token counts + self.update_token_count( + response.usage.prompt_tokens, response.usage.completion_tokens + ) + + return response.choices[0].message.content + + # Streaming request, For streaming, update estimated token count before making the request + self.update_token_count(input_tokens) + + response = await self.client.chat.completions.create(**params, stream=True) + + collected_messages = [] + completion_text = "" + async for chunk in response: + chunk_message = chunk.choices[0].delta.content or "" + collected_messages.append(chunk_message) + completion_text += chunk_message + print(chunk_message, end="", flush=True) + + print() # Newline after streaming + full_response = "".join(collected_messages).strip() + if not full_response: + raise ValueError("Empty response from streaming LLM") + + # estimate completion tokens for streaming response + completion_tokens = self.count_tokens(completion_text) + logger.info( + f"Estimated completion tokens for streaming response: {completion_tokens}" + ) + self.total_completion_tokens += completion_tokens + + return full_response + + except TokenLimitExceeded: + # Re-raise token limit errors without logging + raise + except ValueError: + logger.exception(f"Validation error") + raise + except OpenAIError as oe: + logger.exception(f"OpenAI API error") + if isinstance(oe, AuthenticationError): + logger.error("Authentication failed. Check API key.") + elif isinstance(oe, RateLimitError): + logger.error("Rate limit exceeded. Consider increasing retry attempts.") + elif isinstance(oe, APIError): + logger.error(f"API error: {oe}") + raise + except Exception: + logger.exception(f"Unexpected error in ask") + raise + + @retry( + wait=wait_random_exponential(min=1, max=60), + stop=stop_after_attempt(6), + retry=retry_if_exception_type( + (OpenAIError, Exception, ValueError) + ), # Don't retry TokenLimitExceeded + ) + async def ask_with_images( + self, + messages: List[Union[dict, Message]], + images: List[Union[str, dict]], + system_msgs: Optional[List[Union[dict, Message]]] = None, + stream: bool = False, + temperature: Optional[float] = None, + ) -> str: + """ + Send a prompt with images to the LLM and get the response. + + Args: + messages: List of conversation messages + images: List of image URLs or image data dictionaries + system_msgs: Optional system messages to prepend + stream (bool): Whether to stream the response + temperature (float): Sampling temperature for the response + + Returns: + str: The generated response + + Raises: + TokenLimitExceeded: If token limits are exceeded + ValueError: If messages are invalid or response is empty + OpenAIError: If API call fails after retries + Exception: For unexpected errors + """ + try: + # For ask_with_images, we always set supports_images to True because + # this method should only be called with models that support images + if self.model not in MULTIMODAL_MODELS: + raise ValueError( + f"Model {self.model} does not support images. Use a model from {MULTIMODAL_MODELS}" + ) + + # Format messages with image support + formatted_messages = self.format_messages(messages, supports_images=True) + + # Ensure the last message is from the user to attach images + if not formatted_messages or formatted_messages[-1]["role"] != "user": + raise ValueError( + "The last message must be from the user to attach images" + ) + + # Process the last user message to include images + last_message = formatted_messages[-1] + + # Convert content to multimodal format if needed + content = last_message["content"] + multimodal_content = ( + [{"type": "text", "text": content}] + if isinstance(content, str) + else content + if isinstance(content, list) + else [] + ) + + # Add images to content + for image in images: + if isinstance(image, str): + multimodal_content.append( + {"type": "image_url", "image_url": {"url": image}} + ) + elif isinstance(image, dict) and "url" in image: + multimodal_content.append({"type": "image_url", "image_url": image}) + elif isinstance(image, dict) and "image_url" in image: + multimodal_content.append(image) + else: + raise ValueError(f"Unsupported image format: {image}") + + # Update the message with multimodal content + last_message["content"] = multimodal_content + + # Add system messages if provided + if system_msgs: + all_messages = ( + self.format_messages(system_msgs, supports_images=True) + + formatted_messages + ) + else: + all_messages = formatted_messages + + # Calculate tokens and check limits + input_tokens = self.count_message_tokens(all_messages) + if not self.check_token_limit(input_tokens): + raise TokenLimitExceeded(self.get_limit_error_message(input_tokens)) + + # Set up API parameters + params = { + "model": self.model, + "messages": all_messages, + "stream": stream, + } + + # Add model-specific parameters + if self.model in REASONING_MODELS: + params["max_completion_tokens"] = self.max_tokens + else: + params["max_tokens"] = self.max_tokens + params["temperature"] = ( + temperature if temperature is not None else self.temperature + ) + + # Handle non-streaming request + if not stream: + response = await self.client.chat.completions.create(**params) + + if not response.choices or not response.choices[0].message.content: + raise ValueError("Empty or invalid response from LLM") + + self.update_token_count(response.usage.prompt_tokens) + return response.choices[0].message.content + + # Handle streaming request + self.update_token_count(input_tokens) + response = await self.client.chat.completions.create(**params) + + collected_messages = [] + async for chunk in response: + chunk_message = chunk.choices[0].delta.content or "" + collected_messages.append(chunk_message) + print(chunk_message, end="", flush=True) + + print() # Newline after streaming + full_response = "".join(collected_messages).strip() + + if not full_response: + raise ValueError("Empty response from streaming LLM") + + return full_response + + except TokenLimitExceeded: + raise + except ValueError as ve: + logger.error(f"Validation error in ask_with_images: {ve}") + raise + except OpenAIError as oe: + logger.error(f"OpenAI API error: {oe}") + if isinstance(oe, AuthenticationError): + logger.error("Authentication failed. Check API key.") + elif isinstance(oe, RateLimitError): + logger.error("Rate limit exceeded. Consider increasing retry attempts.") + elif isinstance(oe, APIError): + logger.error(f"API error: {oe}") + raise + except Exception as e: + logger.error(f"Unexpected error in ask_with_images: {e}") + raise + + @retry( + wait=wait_random_exponential(min=1, max=60), + stop=stop_after_attempt(6), + retry=retry_if_exception_type( + (OpenAIError, Exception, ValueError) + ), # Don't retry TokenLimitExceeded + ) + async def ask_tool( + self, + messages: List[Union[dict, Message]], + system_msgs: Optional[List[Union[dict, Message]]] = None, + timeout: int = 300, + tools: Optional[List[dict]] = None, + tool_choice: TOOL_CHOICE_TYPE = ToolChoice.AUTO, # type: ignore + temperature: Optional[float] = None, + **kwargs, + ) -> ChatCompletionMessage | None: + """ + Ask LLM using functions/tools and return the response. + + Args: + messages: List of conversation messages + system_msgs: Optional system messages to prepend + timeout: Request timeout in seconds + tools: List of tools to use + tool_choice: Tool choice strategy + temperature: Sampling temperature for the response + **kwargs: Additional completion arguments + + Returns: + ChatCompletionMessage: The model's response + + Raises: + TokenLimitExceeded: If token limits are exceeded + ValueError: If tools, tool_choice, or messages are invalid + OpenAIError: If API call fails after retries + Exception: For unexpected errors + """ + try: + # Validate tool_choice + if tool_choice not in TOOL_CHOICE_VALUES: + raise ValueError(f"Invalid tool_choice: {tool_choice}") + + # Check if the model supports images + supports_images = self.model in MULTIMODAL_MODELS + + # Format messages + if system_msgs: + system_msgs = self.format_messages(system_msgs, supports_images) + messages = system_msgs + self.format_messages(messages, supports_images) + else: + messages = self.format_messages(messages, supports_images) + + # Calculate input token count + input_tokens = self.count_message_tokens(messages) + + # If there are tools, calculate token count for tool descriptions + tools_tokens = 0 + if tools: + for tool in tools: + tools_tokens += self.count_tokens(str(tool)) + + input_tokens += tools_tokens + + # Check if token limits are exceeded + if not self.check_token_limit(input_tokens): + error_message = self.get_limit_error_message(input_tokens) + # Raise a special exception that won't be retried + raise TokenLimitExceeded(error_message) + + # Validate tools if provided + if tools: + for tool in tools: + if not isinstance(tool, dict) or "type" not in tool: + raise ValueError("Each tool must be a dict with 'type' field") + + # Set up the completion request + params = { + "model": self.model, + "messages": messages, + "tools": tools, + "tool_choice": tool_choice, + "timeout": timeout, + **kwargs, + } + + if self.model in REASONING_MODELS: + params["max_completion_tokens"] = self.max_tokens + else: + params["max_tokens"] = self.max_tokens + params["temperature"] = ( + temperature if temperature is not None else self.temperature + ) + + params["stream"] = False # Always use non-streaming for tool requests + response: ChatCompletion = await self.client.chat.completions.create( + **params + ) + + # Check if response is valid + if not response.choices or not response.choices[0].message: + print(response) + # raise ValueError("Invalid or empty response from LLM") + return None + + # Update token counts + self.update_token_count( + response.usage.prompt_tokens, response.usage.completion_tokens + ) + + return response.choices[0].message + + except TokenLimitExceeded: + # Re-raise token limit errors without logging + raise + except ValueError as ve: + logger.error(f"Validation error in ask_tool: {ve}") + raise + except OpenAIError as oe: + logger.error(f"OpenAI API error: {oe}") + if isinstance(oe, AuthenticationError): + logger.error("Authentication failed. Check API key.") + elif isinstance(oe, RateLimitError): + logger.error("Rate limit exceeded. Consider increasing retry attempts.") + elif isinstance(oe, APIError): + logger.error(f"API error: {oe}") + raise + except Exception as e: + logger.error(f"Unexpected error in ask_tool: {e}") + raise diff --git a/openmanus_rl/agentgym/agentenv-gaia/gaia/python_execute.py b/openmanus_rl/agentgym/agentenv-gaia/gaia/python_execute.py new file mode 100644 index 00000000..5c1f9cef --- /dev/null +++ b/openmanus_rl/agentgym/agentenv-gaia/gaia/python_execute.py @@ -0,0 +1,75 @@ +import multiprocessing +import sys +from io import StringIO +from typing import Dict + +from gaia.base import BaseTool + + +class PythonExecute(BaseTool): + """A tool for executing Python code with timeout and safety restrictions.""" + + name: str = "python_execute" + description: str = "Executes Python code string. Note: Only print outputs are visible, function return values are not captured. Use print statements to see results." + parameters: dict = { + "type": "object", + "properties": { + "code": { + "type": "string", + "description": "The Python code to execute.", + }, + }, + "required": ["code"], + } + + def _run_code(self, code: str, result_dict: dict, safe_globals: dict) -> None: + original_stdout = sys.stdout + try: + output_buffer = StringIO() + sys.stdout = output_buffer + exec(code, safe_globals, safe_globals) + result_dict["observation"] = output_buffer.getvalue() + result_dict["success"] = True + except Exception as e: + result_dict["observation"] = str(e) + result_dict["success"] = False + finally: + sys.stdout = original_stdout + + async def execute( + self, + code: str, + timeout: int = 5, + ) -> Dict: + """ + Executes the provided Python code with a timeout. + + Args: + code (str): The Python code to execute. + timeout (int): Execution timeout in seconds. + + Returns: + Dict: Contains 'output' with execution output or error message and 'success' status. + """ + + with multiprocessing.Manager() as manager: + result = manager.dict({"observation": "", "success": False}) + if isinstance(__builtins__, dict): + safe_globals = {"__builtins__": __builtins__} + else: + safe_globals = {"__builtins__": __builtins__.__dict__.copy()} + proc = multiprocessing.Process( + target=self._run_code, args=(code, result, safe_globals) + ) + proc.start() + proc.join(timeout) + + # timeout process + if proc.is_alive(): + proc.terminate() + proc.join(1) + return { + "observation": f"Execution timeout after {timeout} seconds", + "success": False, + } + return dict(result) diff --git a/openmanus_rl/agentgym/agentenv-gaia/gaia/schema.py b/openmanus_rl/agentgym/agentenv-gaia/gaia/schema.py new file mode 100644 index 00000000..5f743f92 --- /dev/null +++ b/openmanus_rl/agentgym/agentenv-gaia/gaia/schema.py @@ -0,0 +1,187 @@ +from enum import Enum +from typing import Any, List, Literal, Optional, Union + +from pydantic import BaseModel, Field + + +class Role(str, Enum): + """Message role options""" + + SYSTEM = "system" + USER = "user" + ASSISTANT = "assistant" + TOOL = "tool" + + +ROLE_VALUES = tuple(role.value for role in Role) +ROLE_TYPE = Literal[ROLE_VALUES] # type: ignore + + +class ToolChoice(str, Enum): + """Tool choice options""" + + NONE = "none" + AUTO = "auto" + REQUIRED = "required" + + +TOOL_CHOICE_VALUES = tuple(choice.value for choice in ToolChoice) +TOOL_CHOICE_TYPE = Literal[TOOL_CHOICE_VALUES] # type: ignore + + +class AgentState(str, Enum): + """Agent execution states""" + + IDLE = "IDLE" + RUNNING = "RUNNING" + FINISHED = "FINISHED" + ERROR = "ERROR" + + +class Function(BaseModel): + name: str + arguments: str + + +class ToolCall(BaseModel): + """Represents a tool/function call in a message""" + + id: str + type: str = "function" + function: Function + + +class Message(BaseModel): + """Represents a chat message in the conversation""" + + role: ROLE_TYPE = Field(...) # type: ignore + content: Optional[str] = Field(default=None) + tool_calls: Optional[List[ToolCall]] = Field(default=None) + name: Optional[str] = Field(default=None) + tool_call_id: Optional[str] = Field(default=None) + base64_image: Optional[str] = Field(default=None) + + def __add__(self, other) -> List["Message"]: + """支持 Message + list 或 Message + Message 的操作""" + if isinstance(other, list): + return [self] + other + elif isinstance(other, Message): + return [self, other] + else: + raise TypeError( + f"unsupported operand type(s) for +: '{type(self).__name__}' and '{type(other).__name__}'" + ) + + def __radd__(self, other) -> List["Message"]: + """支持 list + Message 的操作""" + if isinstance(other, list): + return other + [self] + else: + raise TypeError( + f"unsupported operand type(s) for +: '{type(other).__name__}' and '{type(self).__name__}'" + ) + + def to_dict(self) -> dict: + """Convert message to dictionary format""" + message = {"role": self.role} + if self.content is not None: + message["content"] = self.content + if self.tool_calls is not None: + message["tool_calls"] = [tool_call.dict() for tool_call in self.tool_calls] + if self.name is not None: + message["name"] = self.name + if self.tool_call_id is not None: + message["tool_call_id"] = self.tool_call_id + if self.base64_image is not None: + message["base64_image"] = self.base64_image + return message + + @classmethod + def user_message( + cls, content: str, base64_image: Optional[str] = None + ) -> "Message": + """Create a user message""" + return cls(role=Role.USER, content=content, base64_image=base64_image) + + @classmethod + def system_message(cls, content: str) -> "Message": + """Create a system message""" + return cls(role=Role.SYSTEM, content=content) + + @classmethod + def assistant_message( + cls, content: Optional[str] = None, base64_image: Optional[str] = None + ) -> "Message": + """Create an assistant message""" + return cls(role=Role.ASSISTANT, content=content, base64_image=base64_image) + + @classmethod + def tool_message( + cls, content: str, name, tool_call_id: str, base64_image: Optional[str] = None + ) -> "Message": + """Create a tool message""" + return cls( + role=Role.TOOL, + content=content, + name=name, + tool_call_id=tool_call_id, + base64_image=base64_image, + ) + + @classmethod + def from_tool_calls( + cls, + tool_calls: List[Any], + content: Union[str, List[str]] = "", + base64_image: Optional[str] = None, + **kwargs, + ): + """Create ToolCallsMessage from raw tool calls. + + Args: + tool_calls: Raw tool calls from LLM + content: Optional message content + base64_image: Optional base64 encoded image + """ + formatted_calls = [ + {"id": call.id, "function": call.function.model_dump(), "type": "function"} + for call in tool_calls + ] + return cls( + role=Role.ASSISTANT, + content=content, + tool_calls=formatted_calls, + base64_image=base64_image, + **kwargs, + ) + + +class Memory(BaseModel): + messages: List[Message] = Field(default_factory=list) + max_messages: int = Field(default=100) + + def add_message(self, message: Message) -> None: + """Add a message to memory""" + self.messages.append(message) + # Optional: Implement message limit + if len(self.messages) > self.max_messages: + self.messages = self.messages[-self.max_messages :] + + def add_messages(self, messages: List[Message]) -> None: + """Add multiple messages to memory""" + self.messages.extend(messages) + # Optional: Implement message limit + if len(self.messages) > self.max_messages: + self.messages = self.messages[-self.max_messages :] + + def clear(self) -> None: + """Clear all messages""" + self.messages.clear() + + def get_recent_messages(self, n: int) -> List[Message]: + """Get n most recent messages""" + return self.messages[-n:] + + def to_dict_list(self) -> List[dict]: + """Convert messages to list of dicts""" + return [msg.to_dict() for msg in self.messages] diff --git a/openmanus_rl/agentgym/agentenv-gaia/gaia/search/__init__.py b/openmanus_rl/agentgym/agentenv-gaia/gaia/search/__init__.py new file mode 100644 index 00000000..3cd2b3dc --- /dev/null +++ b/openmanus_rl/agentgym/agentenv-gaia/gaia/search/__init__.py @@ -0,0 +1,14 @@ +from gaia.search.baidu_search import BaiduSearchEngine +from gaia.search.base import WebSearchEngine +from gaia.search.bing_search import BingSearchEngine +from gaia.search.duckduckgo_search import DuckDuckGoSearchEngine +from gaia.search.google_search import GoogleSearchEngine + + +__all__ = [ + "WebSearchEngine", + "BaiduSearchEngine", + "DuckDuckGoSearchEngine", + "GoogleSearchEngine", + "BingSearchEngine", +] diff --git a/openmanus_rl/agentgym/agentenv-gaia/gaia/search/baidu_search.py b/openmanus_rl/agentgym/agentenv-gaia/gaia/search/baidu_search.py new file mode 100644 index 00000000..7faf6007 --- /dev/null +++ b/openmanus_rl/agentgym/agentenv-gaia/gaia/search/baidu_search.py @@ -0,0 +1,54 @@ +from typing import List + +from baidusearch.baidusearch import search + +from gaia.search.base import SearchItem, WebSearchEngine + + +class BaiduSearchEngine(WebSearchEngine): + def perform_search( + self, query: str, num_results: int = 10, *args, **kwargs + ) -> List[SearchItem]: + """ + Baidu search engine. + + Returns results formatted according to SearchItem model. + """ + raw_results = search(query, num_results=num_results) + + # Convert raw results to SearchItem format + results = [] + for i, item in enumerate(raw_results): + if isinstance(item, str): + # If it's just a URL + results.append( + SearchItem(title=f"Baidu Result {i+1}", url=item, description=None) + ) + elif isinstance(item, dict): + # If it's a dictionary with details + results.append( + SearchItem( + title=item.get("title", f"Baidu Result {i+1}"), + url=item.get("url", ""), + description=item.get("abstract", None), + ) + ) + else: + # Try to get attributes directly + try: + results.append( + SearchItem( + title=getattr(item, "title", f"Baidu Result {i+1}"), + url=getattr(item, "url", ""), + description=getattr(item, "abstract", None), + ) + ) + except Exception: + # Fallback to a basic result + results.append( + SearchItem( + title=f"Baidu Result {i+1}", url=str(item), description=None + ) + ) + + return results diff --git a/openmanus_rl/agentgym/agentenv-gaia/gaia/search/base.py b/openmanus_rl/agentgym/agentenv-gaia/gaia/search/base.py new file mode 100644 index 00000000..31d78b9f --- /dev/null +++ b/openmanus_rl/agentgym/agentenv-gaia/gaia/search/base.py @@ -0,0 +1,40 @@ +from typing import List, Optional + +from pydantic import BaseModel, Field + + +class SearchItem(BaseModel): + """Represents a single search result item""" + + title: str = Field(description="The title of the search result") + url: str = Field(description="The URL of the search result") + description: Optional[str] = Field( + default=None, description="A description or snippet of the search result" + ) + + def __str__(self) -> str: + """String representation of a search result item.""" + return f"{self.title} - {self.url}" + + +class WebSearchEngine(BaseModel): + """Base class for web search engines.""" + + model_config = {"arbitrary_types_allowed": True} + + def perform_search( + self, query: str, num_results: int = 10, *args, **kwargs + ) -> List[SearchItem]: + """ + Perform a web search and return a list of search items. + + Args: + query (str): The search query to submit to the search engine. + num_results (int, optional): The number of search results to return. Default is 10. + args: Additional arguments. + kwargs: Additional keyword arguments. + + Returns: + List[SearchItem]: A list of SearchItem objects matching the search query. + """ + raise NotImplementedError diff --git a/openmanus_rl/agentgym/agentenv-gaia/gaia/search/bing_search.py b/openmanus_rl/agentgym/agentenv-gaia/gaia/search/bing_search.py new file mode 100644 index 00000000..60cf2fbf --- /dev/null +++ b/openmanus_rl/agentgym/agentenv-gaia/gaia/search/bing_search.py @@ -0,0 +1,143 @@ +from typing import List, Optional, Tuple + +import requests +from bs4 import BeautifulSoup + +from gaia.search.base import SearchItem, WebSearchEngine + + +ABSTRACT_MAX_LENGTH = 300 + +USER_AGENTS = [ + "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.106 Safari/537.36", + "Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)", + "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Ubuntu Chromium/49.0.2623.108 Chrome/49.0.2623.108 Safari/537.36", + "Mozilla/5.0 (Windows; U; Windows NT 5.1; pt-BR) AppleWebKit/533.3 (KHTML, like Gecko) QtWeb Internet Browser/3.7 http://www.QtWeb.net", + "Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2228.0 Safari/537.36", + "Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US) AppleWebKit/532.2 (KHTML, like Gecko) ChromePlus/4.0.222.3 Chrome/4.0.222.3 Safari/532.2", + "Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.8.1.4pre) Gecko/20070404 K-Ninja/2.1.3", + "Mozilla/5.0 (Future Star Technologies Corp.; Star-Blade OS; x86_64; U; en-US) iNet Browser 4.7", + "Mozilla/5.0 (Windows; U; Windows NT 6.1; rv:2.2) Gecko/20110201", + "Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.8.1.13) Gecko/20080414 Firefox/2.0.0.13 Pogo/2.0.0.13.6866", +] + +HEADERS = { + "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8", + "Content-Type": "application/x-www-form-urlencoded", + "User-Agent": USER_AGENTS[0], + "Referer": "https://www.bing.com/", + "Accept-Encoding": "gzip, deflate", + "Accept-Language": "zh-CN,zh;q=0.9", +} + +BING_HOST_URL = "https://www.bing.com" +BING_SEARCH_URL = "https://www.bing.com/search?q=" + + +class BingSearchEngine(WebSearchEngine): + session: Optional[requests.Session] = None + + def __init__(self, **data): + """Initialize the BingSearch tool with a requests session.""" + super().__init__(**data) + self.session = requests.Session() + self.session.headers.update(HEADERS) + + def _search_sync(self, query: str, num_results: int = 10) -> List[SearchItem]: + """ + Synchronous Bing search implementation to retrieve search results. + + Args: + query (str): The search query to submit to Bing. + num_results (int, optional): Maximum number of results to return. Defaults to 10. + + Returns: + List[SearchItem]: A list of search items with title, URL, and description. + """ + if not query: + return [] + + list_result = [] + first = 1 + next_url = BING_SEARCH_URL + query + + while len(list_result) < num_results: + data, next_url = self._parse_html( + next_url, rank_start=len(list_result), first=first + ) + if data: + list_result.extend(data) + if not next_url: + break + first += 10 + + return list_result[:num_results] + + def _parse_html( + self, url: str, rank_start: int = 0, first: int = 1 + ) -> Tuple[List[SearchItem], str]: + """ + Parse Bing search result HTML to extract search results and the next page URL. + + Returns: + tuple: (List of SearchItem objects, next page URL or None) + """ + try: + res = self.session.get(url=url) + res.encoding = "utf-8" + root = BeautifulSoup(res.text, "lxml") + + list_data = [] + ol_results = root.find("ol", id="b_results") + if not ol_results: + return [], None + + for li in ol_results.find_all("li", class_="b_algo"): + title = "" + url = "" + abstract = "" + try: + h2 = li.find("h2") + if h2: + title = h2.text.strip() + url = h2.a["href"].strip() + + p = li.find("p") + if p: + abstract = p.text.strip() + + if ABSTRACT_MAX_LENGTH and len(abstract) > ABSTRACT_MAX_LENGTH: + abstract = abstract[:ABSTRACT_MAX_LENGTH] + + rank_start += 1 + + # Create a SearchItem object + list_data.append( + SearchItem( + title=title or f"Bing Result {rank_start}", + url=url, + description=abstract, + ) + ) + except Exception: + continue + + next_btn = root.find("a", title="Next page") + if not next_btn: + return list_data, None + + next_url = BING_HOST_URL + next_btn["href"] + return list_data, next_url + except Exception as e: + print(f"Error parsing HTML: {e}") + return [], None + + def perform_search( + self, query: str, num_results: int = 10, *args, **kwargs + ) -> List[SearchItem]: + """ + Bing search engine. + + Returns results formatted according to SearchItem model. + """ + return self._search_sync(query, num_results=num_results) diff --git a/openmanus_rl/agentgym/agentenv-gaia/gaia/search/duckduckgo_search.py b/openmanus_rl/agentgym/agentenv-gaia/gaia/search/duckduckgo_search.py new file mode 100644 index 00000000..17384258 --- /dev/null +++ b/openmanus_rl/agentgym/agentenv-gaia/gaia/search/duckduckgo_search.py @@ -0,0 +1,57 @@ +from typing import List + +from duckduckgo_search import DDGS + +from gaia.search.base import SearchItem, WebSearchEngine + + +class DuckDuckGoSearchEngine(WebSearchEngine): + def perform_search( + self, query: str, num_results: int = 10, *args, **kwargs + ) -> List[SearchItem]: + """ + DuckDuckGo search engine. + + Returns results formatted according to SearchItem model. + """ + raw_results = DDGS().text(query, max_results=num_results) + + results = [] + for i, item in enumerate(raw_results): + if isinstance(item, str): + # If it's just a URL + results.append( + SearchItem( + title=f"DuckDuckGo Result {i + 1}", url=item, description=None + ) + ) + elif isinstance(item, dict): + # Extract data from the dictionary + results.append( + SearchItem( + title=item.get("title", f"DuckDuckGo Result {i + 1}"), + url=item.get("href", ""), + description=item.get("body", None), + ) + ) + else: + # Try to extract attributes directly + try: + results.append( + SearchItem( + title=getattr(item, "title", f"DuckDuckGo Result {i + 1}"), + url=getattr(item, "href", ""), + description=getattr(item, "body", None), + ) + ) + except Exception: + # Fallback + results.append( + SearchItem( + title=f"DuckDuckGo Result {i + 1}", + url=str(item), + description=None, + ) + ) + + return results diff --git a/openmanus_rl/agentgym/agentenv-gaia/gaia/search/google_search.py b/openmanus_rl/agentgym/agentenv-gaia/gaia/search/google_search.py new file mode 100644 index 00000000..bd3a1f2a --- /dev/null +++ b/openmanus_rl/agentgym/agentenv-gaia/gaia/search/google_search.py @@ -0,0 +1,33 @@ +from typing import List + +from googlesearch import search + +from gaia.search.base import SearchItem, WebSearchEngine + + +class GoogleSearchEngine(WebSearchEngine): + def perform_search( + self, query: str, num_results: int = 10, *args, **kwargs + ) -> List[SearchItem]: + """ + Google search engine. + + Returns results formatted according to SearchItem model. + """ + raw_results = search(query, num_results=num_results, advanced=True) + + results = [] + for i, item in enumerate(raw_results): + if isinstance(item, str): + # If it's just a URL + results.append( + {"title": f"Google Result {i+1}", "url": item, "description": ""} + ) + else: + results.append( + SearchItem( + title=item.title, url=item.url, description=item.description + ) + ) + + return results diff --git a/openmanus_rl/agentgym/agentenv-gaia/gaia/terminate.py b/openmanus_rl/agentgym/agentenv-gaia/gaia/terminate.py new file mode 100644 index 00000000..3db4fab9 --- /dev/null +++ b/openmanus_rl/agentgym/agentenv-gaia/gaia/terminate.py @@ -0,0 +1,25 @@ +from gaia.base import BaseTool + + +_TERMINATE_DESCRIPTION = """Terminate the interaction when the request is met OR if the assistant cannot proceed further with the task. +When you have finished all the tasks, call this tool to end the work.""" + + +class Terminate(BaseTool): + name: str = "terminate" + description: str = _TERMINATE_DESCRIPTION + parameters: dict = { + "type": "object", + "properties": { + "status": { + "type": "string", + "description": "The finish status of the interaction.", + "enum": ["success", "failure"], + } + }, + "required": ["status"], + } + + async def execute(self, status: str) -> str: + """Finish the current execution""" + return f"The interaction has been completed with status: {status}" diff --git a/openmanus_rl/agentgym/agentenv-gaia/gaia/tool_collection.py b/openmanus_rl/agentgym/agentenv-gaia/gaia/tool_collection.py new file mode 100644 index 00000000..10fa960f --- /dev/null +++ b/openmanus_rl/agentgym/agentenv-gaia/gaia/tool_collection.py @@ -0,0 +1,70 @@ +"""Collection classes for managing multiple tools.""" +from typing import Any, Dict, List + +from gaia.base import ToolError +from gaia.base import BaseTool, ToolFailure, ToolResult + + +class ToolCollection: + """A collection of defined tools.""" + + class Config: + arbitrary_types_allowed = True + + def __init__(self, *tools: BaseTool): + self.tools = tools + self.tool_map = {tool.name: tool for tool in tools} + + def __iter__(self): + return iter(self.tools) + + def to_params(self) -> List[Dict[str, Any]]: + return [tool.to_param() for tool in self.tools] + + async def execute( + self, *, name: str, tool_input: Dict[str, Any] = None + ) -> ToolResult: + tool = self.tool_map.get(name) + if not tool: + return ToolFailure(error=f"Tool {name} is invalid") + try: + result = await tool(**tool_input) + return result + except ToolError as e: + return ToolFailure(error=e.message) + + async def execute_all(self) -> List[ToolResult]: + """Execute all tools in the collection sequentially.""" + results = [] + for tool in self.tools: + try: + result = await tool() + results.append(result) + except ToolError as e: + results.append(ToolFailure(error=e.message)) + return results + + def get_tool(self, name: str) -> BaseTool: + return self.tool_map.get(name) + + def add_tool(self, tool: BaseTool): + """Add a single tool to the collection. + + If a tool with the same name already exists, it will be skipped and a warning will be logged. + """ + if tool.name in self.tool_map: + print(f"Tool {tool.name} already exists in collection, skipping") + return self + + self.tools += (tool,) + self.tool_map[tool.name] = tool + return self + + def add_tools(self, *tools: BaseTool): + """Add multiple tools to the collection. + + If any tool has a name conflict with an existing tool, it will be skipped and a warning will be logged. + """ + for tool in tools: + self.add_tool(tool) + return self diff --git a/openmanus_rl/agentgym/agentenv-gaia/gaia/web_search.py b/openmanus_rl/agentgym/agentenv-gaia/gaia/web_search.py new file mode 100644 index 00000000..562b461c --- /dev/null +++ b/openmanus_rl/agentgym/agentenv-gaia/gaia/web_search.py @@ -0,0 +1,417 @@ +import asyncio +from typing import Any, Dict, List, Optional + +import requests +from bs4 import BeautifulSoup +from pydantic import BaseModel, ConfigDict, Field, model_validator +from tenacity import retry, stop_after_attempt, wait_exponential + +from gaia.config import config +from gaia.base import BaseTool, ToolResult +from gaia.search import ( + BaiduSearchEngine, + BingSearchEngine, + DuckDuckGoSearchEngine, + GoogleSearchEngine, + WebSearchEngine, +) +from gaia.search.base import SearchItem + + +class SearchResult(BaseModel): + """Represents a single search result returned by a search engine.""" + + model_config = ConfigDict(arbitrary_types_allowed=True) + + position: int = Field(description="Position in search results") + url: str = Field(description="URL of the search result") + title: str = Field(default="", description="Title of the search result") + description: str = Field( + default="", description="Description or snippet of the search result" + ) + source: str = Field(description="The search engine that provided this result") + raw_content: Optional[str] = Field( + default=None, description="Raw content from the search result page if available" + ) + + def __str__(self) -> str: + """String representation of a search result.""" + return f"{self.title} ({self.url})" + + +class SearchMetadata(BaseModel): + """Metadata about the search operation.""" + + model_config = ConfigDict(arbitrary_types_allowed=True) + + total_results: int = Field(description="Total number of results found") + language: str = Field(description="Language code used for the search") + country: str = Field(description="Country code used for the search") + + +class SearchResponse(ToolResult): + """Structured response from the web search tool, inheriting ToolResult.""" + + query: str = Field(description="The search query that was executed") + results: List[SearchResult] = Field( + default_factory=list, description="List of search results" + ) + metadata: Optional[SearchMetadata] = Field( + default=None, description="Metadata about the search" + ) + + @model_validator(mode="after") + def populate_output(self) -> "SearchResponse": + """Populate output or error fields based on search results.""" + if self.error: + return self + + result_text = [f"Search results for '{self.query}':"] + + for i, result in enumerate(self.results, 1): + # Add title with position number + title = result.title.strip() or "No title" + result_text.append(f"\n{i}. {title}") + + # Add URL with proper indentation + result_text.append(f" URL: {result.url}") + + # Add description if available + if result.description.strip(): + result_text.append(f" Description: {result.description}") + + # Add content preview if available + if result.raw_content: + content_preview = result.raw_content[:1000].replace("\n", " ").strip() + if len(result.raw_content) > 1000: + content_preview += "..." + result_text.append(f" Content: {content_preview}") + + # Add metadata at the bottom if available + if self.metadata: + result_text.extend( + [ + f"\nMetadata:", + f"- Total results: {self.metadata.total_results}", + f"- Language: {self.metadata.language}", + f"- Country: {self.metadata.country}", + ] + ) + + self.output = "\n".join(result_text) + return self + + +class WebContentFetcher: + """Utility class for fetching web content.""" + + @staticmethod + async def fetch_content(url: str, timeout: int = 10) -> Optional[str]: + """ + Fetch and extract the main content from a webpage. + + Args: + url: The URL to fetch content from + timeout: Request timeout in seconds + + Returns: + Extracted text content or None if fetching fails + """ + headers = { + "WebSearch": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36" + } + + try: + # Use asyncio to run requests in a thread pool + response = await asyncio.get_event_loop().run_in_executor( + None, lambda: requests.get(url, headers=headers, timeout=timeout) + ) + + if response.status_code != 200: + print( + f"Failed to fetch content from {url}: HTTP {response.status_code}" + ) + return None + + # Parse HTML with BeautifulSoup + soup = BeautifulSoup(response.text, "html.parser") + + # Remove script and style elements + for script in soup(["script", "style", "header", "footer", "nav"]): + script.extract() + + # Get text content + text = soup.get_text(separator="\n", strip=True) + + # Clean up whitespace and limit size (100KB max) + text = " ".join(text.split()) + return text[:10000] if text else None + + except Exception as e: + print(f"Error fetching content from {url}: {e}") + return None + + +class WebSearch(BaseTool): + """Search the web for information using various search engines.""" + + name: str = "web_search" + description: str = """Search the web for real-time information about any topic. + This tool returns comprehensive search results with relevant information, URLs, titles, and descriptions. + If the primary search engine fails, it automatically falls back to alternative engines.""" + parameters: dict = { + "type": "object", + "properties": { + "query": { + "type": "string", + "description": "(required) The search query to submit to the search engine.", + }, + "num_results": { + "type": "integer", + "description": "(optional) The number of search results to return. Default is 5.", + "default": 5, + }, + "lang": { + "type": "string", + "description": "(optional) Language code for search results (default: en).", + "default": "en", + }, + "country": { + "type": "string", + "description": "(optional) Country code for search results (default: us).", + "default": "us", + }, + "fetch_content": { + "type": "boolean", + "description": "(optional) Whether to fetch full content from result pages. Default is false.", + "default": False, + }, + }, + "required": ["query"], + } + _search_engine: dict[str, WebSearchEngine] = { + "google": GoogleSearchEngine(), + "baidu": BaiduSearchEngine(), + "duckduckgo": DuckDuckGoSearchEngine(), + "bing": BingSearchEngine(), + } + content_fetcher: WebContentFetcher = WebContentFetcher() + + async def execute( + self, + query: str, + num_results: int = 5, + lang: Optional[str] = None, + country: Optional[str] = None, + fetch_content: bool = False, + ) -> SearchResponse: + """ + Execute a Web search and return detailed search results. + + Args: + query: The search query to submit to the search engine + num_results: The number of search results to return (default: 5) + lang: Language code for search results (default from config) + country: Country code for search results (default from config) + fetch_content: Whether to fetch content from result pages (default: False) + + Returns: + A structured response containing search results and metadata + """ + # Get settings from config + retry_delay = ( + getattr(config.search_config, "retry_delay", 60) + if config.search_config + else 60 + ) + max_retries = ( + getattr(config.search_config, "max_retries", 3) + if config.search_config + else 3 + ) + + # Use config values for lang and country if not specified + if lang is None: + lang = ( + getattr(config.search_config, "lang", "en") + if config.search_config + else "en" + ) + + if country is None: + country = ( + getattr(config.search_config, "country", "us") + if config.search_config + else "us" + ) + + search_params = {"lang": lang, "country": country} + + # Try searching with retries when all engines fail + for retry_count in range(max_retries + 1): + results = await self._try_all_engines(query, num_results, search_params) + + if results: + # Fetch content if requested + if fetch_content: + results = await self._fetch_content_for_results(results) + + # Return a successful structured response + return SearchResponse( + status="success", + query=query, + results=results, + metadata=SearchMetadata( + total_results=len(results), + language=lang, + country=country, + ), + ) + + if retry_count < max_retries: + # All engines failed, wait and retry + print( + f"All search engines failed. Waiting {retry_delay} seconds before retry {retry_count + 1}/{max_retries}..." + ) + await asyncio.sleep(retry_delay) + else: + print( + f"All search engines failed after {max_retries} retries. Giving up." + ) + + # Return an error response + return SearchResponse( + query=query, + error="All search engines failed to return results after multiple retries.", + results=[], + ) + + async def _try_all_engines( + self, query: str, num_results: int, search_params: Dict[str, Any] + ) -> List[SearchResult]: + """Try all search engines in the configured order.""" + engine_order = self._get_engine_order() + failed_engines = [] + + for engine_name in engine_order: + engine = self._search_engine[engine_name] + print(f"🔎 Attempting search with {engine_name.capitalize()}...") + search_items = await self._perform_search_with_engine( + engine, query, num_results, search_params + ) + + if not search_items: + continue + + if failed_engines: + print( + f"Search successful with {engine_name.capitalize()} after trying: {', '.join(failed_engines)}" + ) + + # Transform search items into structured results + return [ + SearchResult( + position=i + 1, + url=item.url, + title=item.title + or f"Result {i+1}", # Ensure we always have a title + description=item.description or "", + source=engine_name, + ) + for i, item in enumerate(search_items) + ] + + if failed_engines: + print(f"All search engines failed: {', '.join(failed_engines)}") + return [] + + async def _fetch_content_for_results( + self, results: List[SearchResult] + ) -> List[SearchResult]: + """Fetch and add web content to search results.""" + if not results: + return [] + + # Create tasks for each result + tasks = [self._fetch_single_result_content(result) for result in results] + + # Type annotation to help type checker + fetched_results = await asyncio.gather(*tasks) + + # Explicit validation of return type + return [ + ( + result + if isinstance(result, SearchResult) + else SearchResult(**result.dict()) + ) + for result in fetched_results + ] + + async def _fetch_single_result_content(self, result: SearchResult) -> SearchResult: + """Fetch content for a single search result.""" + if result.url: + content = await self.content_fetcher.fetch_content(result.url) + if content: + result.raw_content = content + return result + + def _get_engine_order(self) -> List[str]: + """Determines the order in which to try search engines.""" + preferred = ( + getattr(config.search_config, "engine", "google").lower() + if config.search_config + else "google" + ) + fallbacks = ( + [engine.lower() for engine in config.search_config.fallback_engines] + if config.search_config + and hasattr(config.search_config, "fallback_engines") + else [] + ) + + # Start with preferred engine, then fallbacks, then remaining engines + engine_order = [preferred] if preferred in self._search_engine else [] + engine_order.extend( + [ + fb + for fb in fallbacks + if fb in self._search_engine and fb not in engine_order + ] + ) + engine_order.extend([e for e in self._search_engine if e not in engine_order]) + + return engine_order + + @retry( + stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=1, max=10) + ) + async def _perform_search_with_engine( + self, + engine: WebSearchEngine, + query: str, + num_results: int, + search_params: Dict[str, Any], + ) -> List[SearchItem]: + """Execute search with the given engine and parameters.""" + return await asyncio.get_event_loop().run_in_executor( + None, + lambda: list( + engine.perform_search( + query, + num_results=num_results, + lang=search_params.get("lang"), + country=search_params.get("country"), + ) + ), + ) + + +if __name__ == "__main__": + web_search = WebSearch() + search_response = asyncio.run( + web_search.execute( + query="Python programming", fetch_content=True, num_results=1 + ) + ) + print(search_response.to_tool_result()) diff --git a/openmanus_rl/agentgym/agentenv-gaia/pyproject.toml b/openmanus_rl/agentgym/agentenv-gaia/pyproject.toml new file mode 100644 index 00000000..440e3aba --- /dev/null +++ b/openmanus_rl/agentgym/agentenv-gaia/pyproject.toml @@ -0,0 +1,36 @@ +[project] +name = "agentenv_gaia" +version = "0.1.0" +description = "GAIA Environment Server for OpenManus-RL" +authors = [ + {name = "rxdaozhang",email = "896836861@qq.com"} +] +readme = "README.md" +requires-python = ">=3.11" +dependencies = [ + "fastapi>=0.95.0", + "uvicorn>=0.22.0", + "pydantic>=1.10.7", + "requests>=2.28.0", + "datasets>=2.10.0", + "pandas>=2.0.0", + "beautifulsoup4>=4.12.0", + "tenacity>=8.2.0", + "multiprocessing-logging>=0.3.1", + "baidusearch>=0.1.0", + "googlesearch-python>=1.0.0", + "duckduckgo-search>=3.0.0", + "browser-use~=0.1.40", + "loguru>=0.6.0", +] + +[project.scripts] +gaia-server = "agentenv_gaia.launch:main" + +[tool.poetry] +packages = [{include = "agentenv_gaia"}] + + +[build-system] +requires = ["poetry-core>=2.0.0,<3.0.0"] +build-backend = "poetry.core.masonry.api" diff --git a/openmanus_rl/agentgym/agentenv-gaia/tests/README.md b/openmanus_rl/agentgym/agentenv-gaia/tests/README.md new file mode 100644 index 00000000..fd9d6dcb --- /dev/null +++ b/openmanus_rl/agentgym/agentenv-gaia/tests/README.md @@ -0,0 +1,137 @@ +# GAIA Environment Server Tests + +This directory contains comprehensive test suites for the GAIA Environment Server implementation. + +## Test Files + +- `test_server.py`: Main test file containing unit tests for: + - `ToolManager` class + - `GaiaEnvServer` class + - API endpoints + - Trajectory examples + +- `test_api.py`: Comprehensive API testing script with detailed logging + +- `test_trajectories.py`: Tests server behavior with example trajectory files + +- Example trajectory files: + - `bash_traj.json`: Example of bash tool usage to print "hello world" + - `python_execute_traj.json`: Example of Python execution (bubble sort implementation) + - `web_search_traj.json`: Example of web search functionality + - `browser_use_traj.json`: Example of browser automation and interaction + +- Test runners: + - `run_tests.py`: Script to run all unit tests automatically + +## Running Tests + +### Automated Unit Tests + +```bash +# Run all tests +python tests/run_tests.py + +# Or run with executable permission +./tests/run_tests.py +``` + +### Using pytest + +```bash +# From the agentenv-gaia directory +pytest tests/test_server.py -v +pytest tests/test_trajectories.py -v +``` + +### Using unittest + +```bash +# From the agentenv-gaia directory +python -m unittest tests/test_server.py +``` + +## Manual API Testing + +The `test_api.py` script provides comprehensive interactive testing of the GAIA server API: + +1. First, start the server: +```bash +python -m agentenv_gaia.server +``` + +2. Then run the test script in a different terminal: +```bash +python tests/test_api.py + +# Or run with executable permission +./tests/test_api.py +``` + +### Command Line Options + +The `test_api.py` script accepts several command-line arguments: + +```bash +# For more verbose output including request/response details +./tests/test_api.py --verbose + +# For minimal output (only errors and results) +./tests/test_api.py --quiet + +# Without color coding (useful for CI environments) +./tests/test_api.py --no-color +``` + +### Features of the API Test Script + +The `test_api.py` script tests: + +- Server connection +- Environment creation with default and custom tools +- All available tools (web_search, bash, python_execute, browser_use, terminate) +- Different action formats (standard, JSON, direct) +- Error handling with invalid tools/actions +- Environment reset functionality +- List environments endpoint + +The script includes: + +- Time-stamped logging for all operations +- Color-coded output for different types of messages +- Detailed request and response information +- Test duration tracking +- Comprehensive result summary +- HTTP error handling with detailed diagnostics + +## Test Coverage + +The tests cover the following functionality: + +1. Tool management: + - Tool initialization + - Tool execution + - Parameter mapping + +2. Environment operations: + - Environment creation + - State management + - Action parsing and execution + - Observation formatting + +3. API endpoints: + - Environment creation + - Observation retrieval + - Action execution + - Environment reset + +4. Trajectory examples: + - Testing with real-world examples from provided JSON files + +5. Browser automation (BrowserUseTool): + - Web navigation (go_to_url) + - Content extraction (extract_content) + - Element interaction (click_element, input_text) + - Scrolling operations (scroll_down, scroll_up, scroll_to_text) + - Tab management (open_tab, close_tab, switch_tab) + - Keyboard input (send_keys) + - Dropdown handling (get_dropdown_options, select_dropdown_option) \ No newline at end of file diff --git a/openmanus_rl/agentgym/agentenv-gaia/tests/__init__.py b/openmanus_rl/agentgym/agentenv-gaia/tests/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/openmanus_rl/agentgym/agentenv-gaia/tests/bash_traj.json b/openmanus_rl/agentgym/agentenv-gaia/tests/bash_traj.json new file mode 100644 index 00000000..69658488 --- /dev/null +++ b/openmanus_rl/agentgym/agentenv-gaia/tests/bash_traj.json @@ -0,0 +1,57 @@ +{ + "messages": [ + { + "role": "user", + "content": "Please using bash tool to print 'hello world'" + }, + { + "role": "user", + "content": "If you want to stop interaction, use `terminate` tool/function call." + }, + { + "role": "assistant", + "content": "I'll help you print 'hello world' using the bash tool and then terminate the interaction.\n\nFirst, let's use the bash command `echo` to print 'hello world':", + "tool_calls": [ + { + "id": "tooluse_l3A6KggVTUmzBZ7irXGuGg", + "type": "function", + "function": { + "name": "bash", + "arguments": "{\"command\": \"echo \\\"hello world\\\"\"}" + } + } + ] + }, + { + "role": "tool", + "content": "Observed output of cmd `bash` executed:\nhello world", + "name": "bash", + "tool_call_id": "tooluse_l3A6KggVTUmzBZ7irXGuGg" + }, + { + "role": "user", + "content": "If you want to stop interaction, use `terminate` tool/function call." + }, + { + "role": "assistant", + "content": "\n\nNow that we've successfully printed 'hello world', I'll terminate the interaction:", + "tool_calls": [ + { + "id": "tooluse_MoFP_S7nT5ufMbSLChmESw", + "type": "function", + "function": { + "name": "terminate", + "arguments": "{\"status\": \"success\"}" + } + } + ] + }, + { + "role": "tool", + "content": "Observed output of cmd `terminate` executed:\nThe interaction has been completed with status: success", + "name": "terminate", + "tool_call_id": "tooluse_MoFP_S7nT5ufMbSLChmESw" + } + ], + "max_messages": 100 +} \ No newline at end of file diff --git a/openmanus_rl/agentgym/agentenv-gaia/tests/browser_use_traj.json b/openmanus_rl/agentgym/agentenv-gaia/tests/browser_use_traj.json new file mode 100644 index 00000000..70683e10 --- /dev/null +++ b/openmanus_rl/agentgym/agentenv-gaia/tests/browser_use_traj.json @@ -0,0 +1,76 @@ +{ + "messages": [ + { + "role": "user", + "content": "搜索北京然后结束对话" + }, + { + "role": "user", + "content": "\nBased on user needs, proactively select the most appropriate tool or combination of tools. For complex tasks, you can break down the problem and use different tools step by step to solve it. After using each tool, clearly explain the execution results and suggest the next steps.\n\nIf you want to stop the interaction at any point, use the `terminate` tool/function call.\n" + }, + { + "role": "assistant", + "content": "", + "tool_calls": [ + { + "id": "tool_0_browser_use", + "type": "function", + "function": { + "name": "browser_use", + "arguments": "{\"query\":\"北京\",\"action\":\"web_search\"}" + } + } + ] + }, + { + "role": "tool", + "content": "Observed output of cmd `browser_use` executed:\nSearch results for '北京':\n\n1. Result 1\n URL: https://www.google.com/search?num=3\n Content: Google Search Images Maps Play YouTube News Gmail Drive More » Web History | Settings | Sign in Advanced search Google offered in: 简体中文 Bahasa Melayu தமிழ் Advertising Business Solutions About Google Google.com.sg © 2025 - Privacy - Terms\n\nMetadata:\n- Total results: 1\n- Language: en\n- Country: us", + "tool_calls": null, + "name": "browser_use", + "tool_call_id": "tool_0_browser_use", + "base64_image": null + }, + { + "role": "user", + "content": "Current browser screenshot:", + "tool_calls": null, + "name": null, + "tool_call_id": null, + "base64_image": "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" + }, + { + "role": "user", + "content": "\nWhat should I do next to achieve my goal?\n\nWhen you see [Current state starts here], focus on the following:\n- Current URL and page title\n URL: https://www.google.com/sorry/index?continue=https://www.google.com/search%3Fnum%3D3&q=EhAkBHrAYPa4Gvm-uUnhRtMjGKKZgcEGIjDI5IgfnqSv4Q_g3o6fuCRXc-hWml-03nyVpG6f3XB2vSffOZfYNKEHYUU96WsP928yAnJSWgFD\n Title: https://www.google.com/search?num=3\n- Available tabs\n 1 tab(s) available\n- Interactive elements and their indices\n- Content above or below the viewport (if indicated)\n- Any action results or errors\n\nFor browser interactions:\n- To navigate: browser_use with action=\"go_to_url\", url=\"...\"\n- To click: browser_use with action=\"click_element\", index=N\n- To type: browser_use with action=\"input_text\", index=N, text=\"...\"\n- To extract: browser_use with action=\"extract_content\", goal=\"...\"\n- To scroll: browser_use with action=\"scroll_down\" or \"scroll_up\"\n\nConsider both what's visible and what might be beyond the current viewport.\nBe methodical - remember your progress and what you've learned so far.\n\nIf you want to stop the interaction at any point, use the `terminate` tool/function call.\n", + "tool_calls": null, + "name": null, + "tool_call_id": null, + "base64_image": null + }, + { + "role": "assistant", + "content": "I have searched for 北京 and the results are displayed. Now I will terminate the interaction.\n", + "tool_calls": [ + { + "id": "tool_0_terminate", + "type": "function", + "function": { + "name": "terminate", + "arguments": "{\"status\":\"success\"}" + } + } + ], + "name": null, + "tool_call_id": null, + "base64_image": null + }, + { + "role": "tool", + "content": "Observed output of cmd `terminate` executed:\nThe interaction has been completed with status: success", + "tool_calls": null, + "name": "terminate", + "tool_call_id": "tool_0_terminate", + "base64_image": null + } + ], + "max_messages": 100 +} \ No newline at end of file diff --git a/openmanus_rl/agentgym/agentenv-gaia/tests/python_execute_traj.json b/openmanus_rl/agentgym/agentenv-gaia/tests/python_execute_traj.json new file mode 100644 index 00000000..5a6f77bd --- /dev/null +++ b/openmanus_rl/agentgym/agentenv-gaia/tests/python_execute_traj.json @@ -0,0 +1,57 @@ +{ + "messages": [ + { + "role": "user", + "content": "Please write a bubble sort algorithm in Python." + }, + { + "role": "user", + "content": "If you want to stop interaction, use `terminate` tool/function call." + }, + { + "role": "assistant", + "content": "I'll help you write a bubble sort algorithm in Python. I'll use the `python_execute` tool to demonstrate the implementation and then terminate the interaction.", + "tool_calls": [ + { + "id": "tooluse_wQbRFUo2TpGx6AH6CLErCw", + "type": "function", + "function": { + "name": "python_execute", + "arguments": "{\"code\": \"def bubble_sort(arr):\\n n = len(arr)\\n \\n # Traverse through all array elements\\n for i in range(n):\\n # Last i elements are already in place\\n for j in range(0, n-i-1):\\n # Traverse the array from 0 to n-i-1\\n # Swap if the element found is greater than the next element\\n if arr[j] > arr[j+1]:\\n arr[j], arr[j+1] = arr[j+1], arr[j]\\n \\n return arr\\n\\n# Test the bubble sort implementation\\ntest_array = [64, 34, 25, 12, 22, 11, 90]\\nprint(\\\"Original array:\\\", test_array)\\nsorted_array = bubble_sort(test_array)\\nprint(\\\"Sorted array:\\\", sorted_array)\"}" + } + } + ] + }, + { + "role": "tool", + "content": "Observed output of cmd `python_execute` executed:\n{'observation': 'Original array: [64, 34, 25, 12, 22, 11, 90]\\nSorted array: [11, 12, 22, 25, 34, 64, 90]\\n', 'success': True}", + "name": "python_execute", + "tool_call_id": "tooluse_wQbRFUo2TpGx6AH6CLErCw" + }, + { + "role": "user", + "content": "If you want to stop interaction, use `terminate` tool/function call." + }, + { + "role": "assistant", + "content": "Since I have completed the task of writing and demonstrating the bubble sort algorithm, I will now terminate the interaction.", + "tool_calls": [ + { + "id": "toolu_01WxzJUN8HYuV7PSKUU41RjP", + "type": "function", + "function": { + "name": "terminate", + "arguments": "{\"status\": \"success\"}" + } + } + ] + }, + { + "role": "tool", + "content": "Observed output of cmd `terminate` executed:\nThe interaction has been completed with status: success", + "name": "terminate", + "tool_call_id": "toolu_01WxzJUN8HYuV7PSKUU41RjP" + } + ], + "max_messages": 100 +} diff --git a/openmanus_rl/agentgym/agentenv-gaia/tests/run_tests.py b/openmanus_rl/agentgym/agentenv-gaia/tests/run_tests.py new file mode 100644 index 00000000..8d7dad3d --- /dev/null +++ b/openmanus_rl/agentgym/agentenv-gaia/tests/run_tests.py @@ -0,0 +1,33 @@ +#!/usr/bin/env python +import os +import sys +import subprocess + +if __name__ == "__main__": + # Add parent directory to path for imports + sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + + # Get current directory + test_dir = os.path.dirname(os.path.abspath(__file__)) + + # Run tests using pytest + try: + # Run server tests first + print("Running server tests...") + subprocess.run(["pytest", os.path.join(test_dir, "test_server.py"), "-v"], check=True) + + # Run trajectory tests + print("\nRunning trajectory tests...") + subprocess.run(["pytest", os.path.join(test_dir, "test_trajectories.py"), "-v"], check=True) + + # Optionally run all other tests + print("\nRunning any remaining tests...") + subprocess.run(["pytest", test_dir, "-v", + "--ignore=test_server.py", + "--ignore=test_trajectories.py"], check=True) + + print("\nAll tests completed successfully!") + sys.exit(0) + except subprocess.CalledProcessError as e: + print(f"\nTest execution failed with error code: {e.returncode}") + sys.exit(e.returncode) \ No newline at end of file diff --git a/openmanus_rl/agentgym/agentenv-gaia/tests/test_api.py b/openmanus_rl/agentgym/agentenv-gaia/tests/test_api.py new file mode 100755 index 00000000..6b7c6107 --- /dev/null +++ b/openmanus_rl/agentgym/agentenv-gaia/tests/test_api.py @@ -0,0 +1,519 @@ +#!/usr/bin/env python +""" +Comprehensive manual test script for GAIA Environment Server + +This script tests all functionality of the GAIA Environment Server including: +- Environment creation, reset, and observation +- All available tools (web_search, bash, python_execute, terminate) +- Different action formats (standard, JSON, direct format) +- Error handling +""" + +import requests +import json +import sys +import time +import datetime +from pprint import pformat + +# Server URL +BASE_URL = "http://localhost:8000" + +# Define colors for output +class Colors: + HEADER = '\033[95m' + BLUE = '\033[94m' + CYAN = '\033[96m' + GREEN = '\033[92m' + YELLOW = '\033[93m' + RED = '\033[91m' + ENDC = '\033[0m' + BOLD = '\033[1m' + UNDERLINE = '\033[4m' + GRAY = '\033[90m' + +# Configure logging details +VERBOSE_LOGGING = True # Set to True for full request/response logging +LOG_REQUEST_BODY = True +LOG_RESPONSE_BODY = True +LOG_TIMESTAMPS = True + +def get_timestamp(): + """Get formatted timestamp""" + if LOG_TIMESTAMPS: + return f"{Colors.GRAY}[{datetime.datetime.now().strftime('%H:%M:%S.%f')[:-3]}]{Colors.ENDC} " + return "" + +def print_section(title): + """Print a section header""" + print(f"\n{get_timestamp()}{Colors.HEADER}{Colors.BOLD}{'='*80}{Colors.ENDC}") + print(f"{get_timestamp()}{Colors.HEADER}{Colors.BOLD} {title} {Colors.ENDC}") + print(f"{get_timestamp()}{Colors.HEADER}{Colors.BOLD}{'='*80}{Colors.ENDC}\n") + +def print_step(step): + """Print a test step""" + print(f"{get_timestamp()}{Colors.BLUE}{Colors.BOLD}>>> {step}{Colors.ENDC}") + +def print_success(message): + """Print a success message""" + print(f"{get_timestamp()}{Colors.GREEN}✓ {message}{Colors.ENDC}") + +def print_warning(message): + """Print a warning message""" + print(f"{get_timestamp()}{Colors.YELLOW}⚠ {message}{Colors.ENDC}") + +def print_error(message): + """Print an error message""" + print(f"{get_timestamp()}{Colors.RED}✖ {message}{Colors.ENDC}") + +def print_debug(message): + """Print a debug message""" + if VERBOSE_LOGGING: + print(f"{get_timestamp()}{Colors.GRAY}DEBUG: {message}{Colors.ENDC}") + +def format_json(obj): + """Format JSON for pretty printing""" + if isinstance(obj, (dict, list)): + return pformat(obj, indent=2) + return str(obj) + +def make_request(method, endpoint, data=None, params=None): + """Make a request to the server with error handling""" + url = f"{BASE_URL}/{endpoint}" + + # Print request details + print_debug(f"Request: {method} {url}") + if params and VERBOSE_LOGGING: + print_debug(f"Query params: {format_json(params)}") + if data and LOG_REQUEST_BODY: + print_debug(f"Request body: {format_json(data)}") + + start_time = time.time() + try: + if method == "GET": + response = requests.get(url, params=params) + elif method == "POST": + response = requests.post(url, json=data) + else: + print_error(f"Unknown method: {method}") + return None + + # Calculate response time + response_time = (time.time() - start_time) * 1000 # Convert to ms + print_debug(f"Response status: {response.status_code} (in {response_time:.2f}ms)") + + response.raise_for_status() + + # Print response body if enabled + if LOG_RESPONSE_BODY: + try: + response_json = response.json() + print_debug(f"Response body: {format_json(response_json)}") + return response_json + except json.JSONDecodeError: + print_debug(f"Response (not JSON): {response.text}") + return response.text + else: + return response.json() + except requests.exceptions.ConnectionError: + print_error(f"Connection refused. Is the server running at {BASE_URL}?") + return None + except requests.exceptions.HTTPError as e: + print_error(f"HTTP Error: {e}") + print_debug(f"Response body: {response.text}") + return None + except json.JSONDecodeError: + print_error(f"Invalid JSON response: {response.text}") + return None + except Exception as e: + print_error(f"Unexpected error: {str(e)}") + return None + +def test_server_connection(): + """Test basic server connection""" + print_step("Testing server connection...") + response = make_request("GET", "") + + if response == "ok": + print_success("Server connection successful!") + return True + else: + print_error("Server connection failed!") + return False + +def create_environment(task_id=0, dataset_type="validation", tool_list=None): + """Create a test environment""" + print_step(f"Creating environment (task_id={task_id}, dataset={dataset_type}, tools={tool_list if tool_list else 'default'})...") + + data = {"id": task_id, "dataset_type": dataset_type} + if tool_list: + data["tool_list"] = tool_list + + env_id = make_request("POST", "create", data=data) + + if env_id: + print_success(f"Environment created with ID: {env_id}") + return env_id + else: + print_error("Failed to create environment") + return None + +def get_observation(env_id): + """Get observation for environment""" + print_step(f"Getting observation for environment {env_id}...") + + observation = make_request("GET", "observation", params={"env_idx": env_id}) + + if observation: + print_success("Observation received") + print(f"\n{Colors.CYAN}{'='*40} OBSERVATION {'='*40}{Colors.ENDC}") + print(f"{Colors.CYAN}{observation}{Colors.ENDC}") + print(f"{Colors.CYAN}{'='*90}{Colors.ENDC}\n") + return observation + else: + print_error("Failed to get observation") + return None + +def get_available_actions(env_id): + """Get available actions for environment""" + print_step(f"Getting available actions for environment {env_id}...") + + actions = make_request("GET", "available_actions", params={"env_idx": env_id}) + + if actions: + print_success(f"Available actions: {', '.join(actions)}") + return actions + else: + print_error("Failed to get available actions") + return None + +def execute_action(env_id, action, format_type="standard", description=None): + """Execute an action in the environment with different formats""" + if description: + print_step(f"Executing {description} ({format_type} format)...") + else: + print_step(f"Executing action ({format_type} format)...") + + if format_type == "standard": + # Standard format: "Action: tool_name with Action Input: input" + formatted_action = action + elif format_type == "json": + # JSON format with tool_name and parameters + formatted_action = json.dumps(action) + elif format_type == "direct": + # Direct format: "tool_name: input" + tool_name = action.get("tool_name", "") + if tool_name == "web_search": + formatted_action = f"web_search: {action.get('query', '')}" + elif tool_name == "bash": + formatted_action = f"bash: {action.get('command', '')}" + elif tool_name == "python_execute": + formatted_action = f"python_execute: {action.get('code', '')}" + elif tool_name == "terminate": + formatted_action = f"terminate: {action.get('answer', '')}" + + print(f"{get_timestamp()}{Colors.CYAN}Action: {formatted_action}{Colors.ENDC}") + + data = {"env_idx": env_id, "action": formatted_action} + result = make_request("POST", "step", data=data) + + if result: + print_success("Action executed successfully") + + print(f"\n{Colors.CYAN}{'='*40} RESULT {'='*40}{Colors.ENDC}") + print(f"{Colors.CYAN}Observation: {result['observation']}{Colors.ENDC}") + print(f"{Colors.CYAN}{'='*90}{Colors.ENDC}\n") + + # Print detailed result information + print(f"Reward: {result['reward']}", end="") + if result['reward'] > 0: + print(f" {Colors.GREEN}(positive){Colors.ENDC}") + elif result['reward'] < 0: + print(f" {Colors.RED}(negative){Colors.ENDC}") + else: + print(f" {Colors.YELLOW}(neutral){Colors.ENDC}") + + print(f"Done: {result['done']}") + + # Print step information if available + if 'info' in result and 'steps_taken' in result['info']: + print(f"Steps taken: {result['info']['steps_taken']}") + + return result + else: + print_error("Failed to execute action") + return None + +def reset_environment(env_id, task_id=None, dataset_type="validation"): + """Reset environment to a new or same task""" + if task_id is not None: + print_step(f"Resetting environment {env_id} to new task (id={task_id}, dataset={dataset_type})...") + else: + print_step(f"Resetting environment {env_id} to same task...") + + data = {"env_idx": env_id} + if task_id is not None: + data["id"] = task_id + data["dataset_type"] = dataset_type + + observation = make_request("POST", "reset", data=data) + + if observation: + print_success("Environment reset successfully") + print(f"\n{Colors.CYAN}{'='*40} NEW OBSERVATION {'='*40}{Colors.ENDC}") + print(f"{Colors.CYAN}{observation}{Colors.ENDC}") + print(f"{Colors.CYAN}{'='*90}{Colors.ENDC}\n") + return observation + else: + print_error("Failed to reset environment") + return None + +def run_tests(): + """Run all tests""" + # Store test results + test_results = {} + start_time = time.time() + + # Print test header + print_section("GAIA Environment Server API Tests") + print(f"{get_timestamp()}Starting tests at: {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}") + print(f"{get_timestamp()}Server URL: {BASE_URL}") + + # Test server connection + print_section("Server Connection Test") + if not test_server_connection(): + print_error("Aborting tests due to connection failure") + return + test_results["server_connection"] = True + + # Test environment creation + print_section("Environment Creation Test") + env_id = create_environment() + if not env_id: + print_error("Aborting tests due to environment creation failure") + return + test_results["env_creation"] = True + + # Test custom tools creation + print_section("Custom Tools Environment Test") + custom_tools = ["web_search", "python_execute", "terminate"] + custom_tools_env_id = create_environment( + task_id=1, + tool_list=custom_tools + ) + if custom_tools_env_id: + print_success(f"Successfully created environment with custom tools: {', '.join(custom_tools)}") + test_results["custom_tools_creation"] = True + else: + print_error("Failed to create environment with custom tools") + test_results["custom_tools_creation"] = False + + # Get initial observation and available actions + print_section("Initial Observation Test") + observation = get_observation(env_id) + test_results["get_observation"] = observation is not None + + actions = get_available_actions(env_id) + test_results["get_available_actions"] = actions is not None + + # Test all tools with different formats + + # 1. Test web_search with standard format + # 1.1 Tool argument is fault + print_section("Web Search Tool Test (standard format, faulty tool argument)") + web_search_action = "Action: web_search with Action Input: What is the capital of France?" + web_search_result = execute_action( + env_id, + web_search_action, + format_type="standard", + description="web search for 'What is the capital of France?'" + ) + test_results["web_search_tool"] = web_search_result is not None + + # 1.2 Tool argument is correct + print_section("Web Search Tool Test (standard format, correct tool argument)") + web_search_action = "Action: web_search Action Input: What is the capital of France?" + web_search_result = execute_action( + env_id, + web_search_action, + format_type="standard", + description="web search for 'What is the capital of France?'" + ) + test_results["web_search_tool"] = web_search_result is not None + + # 2. Test bash with JSON format + print_section("Bash Tool Test (JSON Format)") + bash_action = { + "tool_name": "bash", + "command": "echo 'Hello from bash test' && ls -la | head -n 5" + } + bash_result = execute_action( + env_id, + bash_action, + format_type="json", + description="bash command to echo text and list files" + ) + test_results["bash_tool"] = bash_result is not None + + # 3. Test python_execute with direct format + print_section("Python Execute Tool Test (Direct Format)") + python_action = { + "tool_name": "python_execute", + "code": "import random\nprint('Random number:', random.randint(1, 100))\nprint('Test successful!')" + } + python_result = execute_action( + env_id, + python_action, + format_type="direct", + description="Python code to generate a random number" + ) + test_results["python_execute_tool"] = python_result is not None + + # 3.1 Test browser_use with JSON format, go to url + print_section("Browser Use Tool Test (JSON Format, go to url)") + browser_action = { + "tool_name": "browser_use", + "action": "go_to_url", + "url": "https://www.example.com" + } + browser_result = execute_action( + env_id, + browser_action, + format_type="json", + description="browser action to navigate to example.com" + ) + test_results["browser_use_tool_go_to_url"] = browser_result is not None + + # 3.2 Test browser_use with JSON format, web search + print_section("Browser Use Tool Test (JSON Format, Web Search)") + browser_json_action = { + "tool_name": "browser_use", + "action": "web_search", + "query": "How to test browser automation" + } + browser_json_result = execute_action( + env_id, + browser_json_action, + format_type="json", + description="browser action to search the web" + ) + test_results["browser_use_tool_web_search"] = browser_json_result is not None + + # 3.3 Test browser_use with JSON format, extract content + print_section("Browser Use Tool Test (JSON Format, Extract Content)") + browser_json_action = { + "tool_name": "browser_use", + "action": "extract_content", + "goal": "extract the content of the page" + } + browser_json_result = execute_action( + env_id, + browser_json_action, + format_type="json", + description="browser action to extract content from example.com" + ) + test_results["browser_use_tool_extract_content"] = browser_json_result is not None + + # 4. Test environment reset + print_section("Environment Reset Test") + reset_result = reset_environment(env_id, task_id=1) + test_results["env_reset"] = reset_result is not None + + # 5. Test terminate tool + print_section("Terminate Tool Test (json format, correct tool argument)") + terminate_action = { + "tool_name": "terminate", + "status": "success" + } + terminate_result = execute_action( + env_id, + terminate_action, + format_type="json", + description="terminate action with final answer" + ) + test_results["terminate_tool"] = terminate_result is not None + test_results["terminate_done_state"] = terminate_result is not None and terminate_result.get("done", False) + + # 6. Test error handling for invalid tool + print_section("Invalid Tool Test") + invalid_action = "Action: invalid_tool Action Input: This should fail gracefully" + invalid_result = execute_action( + env_id, + invalid_action, + description="invalid tool that should be handled gracefully" + ) + # This should return a result with an error message but not crash + test_results["invalid_tool_handled"] = invalid_result is not None + + # 7. Test listing environments + print_section("List Environments Test") + print_step("Listing all active environments...") + envs = make_request("GET", "list_envs") + if envs: + print_success(f"Environment listing successful: {envs}") + # Verify both environments are in the list + env_ids_found = [env_id in envs, custom_tools_env_id in envs] + if all(env_ids_found): + print_success("All created environments found in list") + else: + print_warning("Not all created environments were found in the list") + test_results["list_envs"] = True + else: + print_error("Failed to list environments") + test_results["list_envs"] = False + + # Calculate test duration + end_time = time.time() + test_duration = end_time - start_time + + # Summary + print_section("Test Summary") + print(f"{get_timestamp()}Tests completed at: {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}") + print(f"{get_timestamp()}Total test duration: {test_duration:.2f} seconds") + print(f"{get_timestamp()}Created environments: {env_id}, {custom_tools_env_id}") + + # Count successes and failures + success_count = sum(1 for result in test_results.values() if result is True) + failure_count = sum(1 for result in test_results.values() if result is False) + + print(f"\n{Colors.BOLD}Test Results:{Colors.ENDC}") + print(f" {Colors.GREEN}Passed: {success_count}/{len(test_results)}{Colors.ENDC}") + print(f" {Colors.RED if failure_count > 0 else ''}Failed: {failure_count}/{len(test_results)}{Colors.ENDC}") + + # Print detailed test results + print(f"\n{Colors.BOLD}Detailed Test Results:{Colors.ENDC}") + for test_name, result in test_results.items(): + status = f"{Colors.GREEN}✓ PASS{Colors.ENDC}" if result else f"{Colors.RED}✗ FAIL{Colors.ENDC}" + print(f" {test_name}: {status}") + + if test_results.get("terminate_done_state", False): + print_success("\nEnvironment successfully completed task with terminate action") + else: + print_warning("\nEnvironment did not reach completion state with terminate action") + +if __name__ == "__main__": + try: + # Check if running in CI mode (without colors) + if "--no-color" in sys.argv: + # Disable colors + for attr in dir(Colors): + if not attr.startswith('__'): + setattr(Colors, attr, '') + + # Check for verbose mode + if "--verbose" in sys.argv: + VERBOSE_LOGGING = True + LOG_REQUEST_BODY = True + LOG_RESPONSE_BODY = True + elif "--quiet" in sys.argv: + VERBOSE_LOGGING = False + LOG_REQUEST_BODY = False + LOG_RESPONSE_BODY = False + + run_tests() + except KeyboardInterrupt: + print_warning("\nTests interrupted by user") + sys.exit(1) + except Exception as e: + print_error(f"Unexpected error during tests: {str(e)}") + sys.exit(1) diff --git a/openmanus_rl/agentgym/agentenv-gaia/tests/test_server.py b/openmanus_rl/agentgym/agentenv-gaia/tests/test_server.py new file mode 100644 index 00000000..980dd62d --- /dev/null +++ b/openmanus_rl/agentgym/agentenv-gaia/tests/test_server.py @@ -0,0 +1,161 @@ +#!/usr/bin/env python +""" +Test module for testing GAIA Environment Server functionality +with a focus on BrowserUseTool integration +""" + +import json +import pytest +import asyncio +from unittest import mock + +# Import server components to test +from agentenv_gaia.server import GaiaEnvServer, ToolManager +from gaia.browser_use_tool import BrowserUseTool +from gaia.base import ToolResult + +class TestToolManager: + """Tests for the ToolManager class""" + + def test_init(self): + """Test ToolManager initialization""" + manager = ToolManager() + assert hasattr(manager, 'browser_use') + assert isinstance(manager.browser_use, BrowserUseTool) + + def test_get_tool_names(self): + """Test tool name listing""" + manager = ToolManager() + names = manager.get_tool_names() + assert "browser_use" in names + + def test_get_tool_by_name(self): + """Test getting tool by name""" + manager = ToolManager() + tool = manager.get_tool_by_name("browser_use") + assert tool is not None + assert isinstance(tool, BrowserUseTool) + + def test_get_tool_description(self): + """Test getting tool description""" + manager = ToolManager() + description = manager.get_tool_description("browser_use") + assert description is not None + assert len(description) > 0 + + @pytest.mark.asyncio + async def test_execute_browser_use_tool(self): + """Test executing browser_use tool""" + manager = ToolManager() + + # Mock the BrowserUseTool.execute method + original_execute = manager.browser_use.execute + + # Create our mock execute function + async def mock_execute(**kwargs): + return ToolResult(output=f"Mocked browser action executed with: {json.dumps(kwargs)}") + + # Replace with mock + manager.browser_use.execute = mock_execute + + try: + # Test execution + result = await manager.execute_tool("browser_use", action="go_to_url", url="https://example.com") + assert result is not None + assert isinstance(result, ToolResult) or isinstance(result, dict) + + # Check if our mocked function was called with the right parameters + if isinstance(result, ToolResult): + assert "go_to_url" in result.output + assert "https://example.com" in result.output + else: # dict + assert "go_to_url" in str(result) + assert "https://example.com" in str(result) + finally: + # Restore original method + manager.browser_use.execute = original_execute + +class TestGaiaEnvServer: + """Tests for the GaiaEnvServer class with BrowserUseTool""" + + def setup_method(self): + """Set up the test environment""" + self.server = GaiaEnvServer(max_envs=5) + + def test_browser_use_in_default_tools(self): + """Test browser_use is in default tools""" + from agentenv_gaia.server import DEFAULT_TOOLS + assert "browser_use" in DEFAULT_TOOLS + + def test_create_environment_with_browser_use(self): + """Test creating environment with browser_use tool""" + env_id = self.server.create(tool_list=["browser_use"]) + assert env_id is not None + assert "browser_use" in self.server.env_instances[env_id]["available_tools"] + + def test_parse_browser_use_action(self): + """Test parsing browser_use action""" + # Test standard format + action = "Action: browser_use Action Input: {\"action\": \"go_to_url\", \"url\": \"https://example.com\"}" + action_type, action_input = self.server._parse_action(action) + assert action_type == "browser_use" + + # Test JSON format + action = json.dumps({ + "tool_name": "browser_use", + "action": "click_element", + "index": 1 + }) + action_type, action_input = self.server._parse_action(action) + assert action_type == "browser_use" + assert "action" in action_input + assert action_input["action"] == "click_element" + assert action_input["index"] == 1 + + # Test direct format + action = "browser_use: {\"action\": \"scroll_down\", \"scroll_amount\": 100}" + action_type, action_input = self.server._parse_action(action) + assert action_type == "browser_use" + + @pytest.mark.asyncio + async def test_process_browser_use_action(self): + """Test processing browser_use action with mocked tool""" + # Create environment + env_id = self.server.create(tool_list=["browser_use"]) + + # Mock the execute_tool method to avoid actual browser operations + original_execute = self.server.tool_manager.execute_tool + + async def mock_execute_tool(tool_name, **kwargs): + if tool_name == "browser_use": + return ToolResult(output=f"Mocked browser action: {json.dumps(kwargs)}") + return await original_execute(tool_name, **kwargs) + + # Replace with mock + self.server.tool_manager.execute_tool = mock_execute_tool + + try: + # Test processing a browser action + observation, reward, done = self.server._process_action( + env_id, + "browser_use", + {"action": "go_to_url", "url": "https://example.com"} + ) + + assert observation is not None + assert "Mocked browser action" in observation + assert reward > 0 # Should get positive reward for successful tool use + assert not done # Should not be done + + # Verify the action was added to memory + memory = self.server.env_instances[env_id]["state"]["memory"] + assert len(memory) > 0 + last_action = memory[-1] + assert "browser_use" in str(last_action["action"]) + + finally: + # Restore original method + self.server.tool_manager.execute_tool = original_execute + +if __name__ == "__main__": + pytest.main(["-xvs", "test_server.py"]) \ No newline at end of file diff --git a/openmanus_rl/agentgym/agentenv-gaia/tests/test_trajectories.py b/openmanus_rl/agentgym/agentenv-gaia/tests/test_trajectories.py new file mode 100644 index 00000000..2a3112f2 --- /dev/null +++ b/openmanus_rl/agentgym/agentenv-gaia/tests/test_trajectories.py @@ -0,0 +1,435 @@ +#!/usr/bin/env python +""" +Test script for executing example trajectory files against the GAIA Environment Server + +This script tests the GAIA Environment Server by replaying trajectory examples from: +- bash_traj.json +- python_execute_traj.json +- web_search_traj.json +- browser_use_traj.json + +It makes HTTP requests to a running server instance and checks if the responses +match the expected behavior for each tool. +""" + +import os +import json +import sys +import time +import datetime +import argparse +from pprint import pformat +import requests + +# Server URL +BASE_URL = "http://localhost:8000" + +# Define colors for output +class Colors: + HEADER = '\033[95m' + BLUE = '\033[94m' + CYAN = '\033[96m' + GREEN = '\033[92m' + YELLOW = '\033[93m' + RED = '\033[91m' + ENDC = '\033[0m' + BOLD = '\033[1m' + UNDERLINE = '\033[4m' + GRAY = '\033[90m' + +# Configure logging details +VERBOSE_LOGGING = True +LOG_REQUEST_BODY = True +LOG_RESPONSE_BODY = True +LOG_TIMESTAMPS = True + +def get_timestamp(): + """Get formatted timestamp""" + if LOG_TIMESTAMPS: + return f"{Colors.GRAY}[{datetime.datetime.now().strftime('%H:%M:%S.%f')[:-3]}]{Colors.ENDC} " + return "" + +def print_section(title): + """Print a section header""" + print(f"\n{get_timestamp()}{Colors.HEADER}{Colors.BOLD}{'='*80}{Colors.ENDC}") + print(f"{get_timestamp()}{Colors.HEADER}{Colors.BOLD} {title} {Colors.ENDC}") + print(f"{get_timestamp()}{Colors.HEADER}{Colors.BOLD}{'='*80}{Colors.ENDC}\n") + +def print_step(step): + """Print a test step""" + print(f"{get_timestamp()}{Colors.BLUE}{Colors.BOLD}>>> {step}{Colors.ENDC}") + +def print_success(message): + """Print a success message""" + print(f"{get_timestamp()}{Colors.GREEN}✓ {message}{Colors.ENDC}") + +def print_warning(message): + """Print a warning message""" + print(f"{get_timestamp()}{Colors.YELLOW}⚠ {message}{Colors.ENDC}") + +def print_error(message): + """Print an error message""" + print(f"{get_timestamp()}{Colors.RED}✖ {message}{Colors.ENDC}") + +def print_debug(message): + """Print a debug message""" + if VERBOSE_LOGGING: + print(f"{get_timestamp()}{Colors.GRAY}DEBUG: {message}{Colors.ENDC}") + +def format_json(obj): + """Format JSON for pretty printing""" + if isinstance(obj, (dict, list)): + return pformat(obj, indent=2) + return str(obj) + +def make_request(method, endpoint, data=None, params=None): + """Make a request to the server with error handling""" + url = f"{BASE_URL}/{endpoint}" + + # Print request details + print_debug(f"Request: {method} {url}") + if params and VERBOSE_LOGGING: + print_debug(f"Query params: {format_json(params)}") + if data and LOG_REQUEST_BODY: + print_debug(f"Request body: {format_json(data)}") + + start_time = time.time() + try: + if method == "GET": + response = requests.get(url, params=params) + elif method == "POST": + response = requests.post(url, json=data) + else: + print_error(f"Unknown method: {method}") + return None + + # Calculate response time + response_time = (time.time() - start_time) * 1000 # Convert to ms + print_debug(f"Response status: {response.status_code} (in {response_time:.2f}ms)") + + response.raise_for_status() + + # Print response body if enabled + if LOG_RESPONSE_BODY: + try: + response_json = response.json() + print_debug(f"Response body: {format_json(response_json)}") + return response_json + except json.JSONDecodeError: + print_debug(f"Response (not JSON): {response.text}") + return response.text + else: + return response.json() + except requests.exceptions.ConnectionError: + print_error(f"Connection refused. Is the server running at {BASE_URL}?") + return None + except requests.exceptions.HTTPError as e: + print_error(f"HTTP Error: {e}") + print_debug(f"Response body: {response.text}") + return None + except json.JSONDecodeError: + print_error(f"Invalid JSON response: {response.text}") + return None + except Exception as e: + print_error(f"Unexpected error: {str(e)}") + return None + +def test_server_connection(): + """Test basic server connection""" + print_step("Testing server connection...") + response = make_request("GET", "") + + if response == "ok": + print_success("Server connection successful!") + return True + else: + print_error("Server connection failed!") + return False + +def create_environment(task_id=0, dataset_type="validation", tool_list=None): + """Create a test environment""" + print_step(f"Creating environment (task_id={task_id}, dataset={dataset_type}, tools={tool_list if tool_list else 'default'})...") + + data = {"id": task_id, "dataset_type": dataset_type} + if tool_list: + data["tool_list"] = tool_list + + env_id = make_request("POST", "create", data=data) + + if env_id: + print_success(f"Environment created with ID: {env_id}") + return env_id + else: + print_error("Failed to create environment") + return None + +def execute_action(env_id, action, format_type="standard", description=None): + """Execute an action in the environment with different formats""" + if description: + print_step(f"Executing {description} ({format_type} format)...") + else: + print_step(f"Executing action ({format_type} format)...") + + if format_type == "standard": + # Standard format: "Action: tool_name with Action Input: input" + formatted_action = action + elif format_type == "json": + # JSON format with tool_name and parameters + formatted_action = json.dumps(action) + elif format_type == "direct": + # Direct format: "tool_name: input" + tool_name = action.get("tool_name", "") + if tool_name == "web_search": + formatted_action = f"web_search: {action.get('query', '')}" + elif tool_name == "bash": + formatted_action = f"bash: {action.get('command', '')}" + elif tool_name == "python_execute": + formatted_action = f"python_execute: {action.get('code', '')}" + elif tool_name == "browser_use": + # For browser_use, convert args to JSON string + args = {k: v for k, v in action.items() if k != "tool_name"} + formatted_action = f"browser_use: {json.dumps(args)}" + elif tool_name == "terminate": + formatted_action = f"terminate: {action.get('answer', '')}" + + print(f"{get_timestamp()}{Colors.CYAN}Action: {formatted_action}{Colors.ENDC}") + + data = {"env_idx": env_id, "action": formatted_action} + result = make_request("POST", "step", data=data) + + if result: + print_success("Action executed successfully") + + print(f"\n{Colors.CYAN}{'='*40} RESULT {'='*40}{Colors.ENDC}") + print(f"{Colors.CYAN}Observation: {result['observation']}{Colors.ENDC}") + print(f"{Colors.CYAN}{'='*90}{Colors.ENDC}\n") + + # Print detailed result information + print(f"Reward: {result['reward']}", end="") + if result['reward'] > 0: + print(f" {Colors.GREEN}(positive){Colors.ENDC}") + elif result['reward'] < 0: + print(f" {Colors.RED}(negative){Colors.ENDC}") + else: + print(f" {Colors.YELLOW}(neutral){Colors.ENDC}") + + print(f"Done: {result['done']}") + + # Print step information if available + if 'info' in result and 'steps_taken' in result['info']: + print(f"Steps taken: {result['info']['steps_taken']}") + + return result + else: + print_error("Failed to execute action") + return None + +class TrajectoryTester: + """Class for executing and validating example trajectories""" + + def __init__(self): + """Initialize the trajectory tester""" + self.trajectories = { + "bash": self._load_trajectory("bash_traj.json"), + "python_execute": self._load_trajectory("python_execute_traj.json"), + "web_search": self._load_trajectory("web_search_traj.json"), + "browser_use": self._load_trajectory("browser_use_traj.json") + } + self.results = {} + + def _load_trajectory(self, filename: str) -> dict: + """Load trajectory from JSON file""" + test_dir = os.path.dirname(os.path.abspath(__file__)) + traj_path = os.path.join(test_dir, filename) + + try: + with open(traj_path, 'r') as f: + return json.load(f) + except (FileNotFoundError, json.JSONDecodeError) as e: + print_warning(f"Failed to load trajectory file {filename}: {str(e)}") + return {"messages": []} + + def _extract_tool_calls(self, trajectory: dict) -> list: + """Extract tool calls from a trajectory""" + tool_calls = [] + for message in trajectory.get("messages", []): + if message.get("role") == "assistant" and message.get("tool_calls"): + for tool_call in message.get("tool_calls", []): + if tool_call.get("function", {}).get("name") and tool_call.get("function", {}).get("arguments"): + tool_calls.append({ + "name": tool_call["function"]["name"], + "arguments": json.loads(tool_call["function"]["arguments"]) + }) + return tool_calls + + def _format_action(self, tool_call: dict) -> dict: + """Format a tool call into an action dictionary for execute_action""" + tool_name = tool_call["name"] + args = tool_call["arguments"] + + # Format all tool calls as JSON + action = {"tool_name": tool_name} + + if tool_name == "bash": + action["command"] = args.get("command", "") + elif tool_name == "python_execute": + action["code"] = args.get("code", "") + elif tool_name == "web_search": + action["query"] = args.get("query", "") + elif tool_name == "browser_use": + # For browser_use, include all arguments + action.update(args) + elif tool_name == "terminate": + action["status"] = args.get("status", "success") + + return action + + def test_trajectory(self, traj_name: str, env_id: str = None) -> bool: + """Test a specific trajectory""" + print_section(f"Testing {traj_name.upper()} Trajectory") + + # Get the trajectory + trajectory = self.trajectories.get(traj_name) + if not trajectory or not trajectory.get("messages"): + print_error(f"No valid trajectory found for {traj_name}") + self.results[traj_name] = False + return False + + # Extract tool calls + tool_calls = self._extract_tool_calls(trajectory) + if not tool_calls: + print_error(f"No tool calls found in {traj_name} trajectory") + self.results[traj_name] = False + return False + + print_success(f"Found {len(tool_calls)} tool calls in trajectory") + + # Get required tool list for this trajectory + tool_names = set(tc["name"] for tc in tool_calls) + tool_list = list(tool_names) + print_debug(f"Required tools for trajectory: {', '.join(tool_list)}") + + # Create environment if not provided + if env_id is None: + env_id = create_environment(tool_list=tool_list) + if not env_id: + print_error(f"Failed to create environment for {traj_name} trajectory") + self.results[traj_name] = False + return False + + # Process each tool call + success = True + for i, tool_call in enumerate(tool_calls): + action = self._format_action(tool_call) + + # Create a description for the action + tool_type = tool_call["name"] + description = f"{tool_type} action (step {i+1}/{len(tool_calls)})" + + # Execute the action + result = execute_action(env_id, action, format_type="json", description=description) + + if not result: + print_error(f"Failed to execute {tool_type} action") + success = False + break + + # Check for trajectory completion + if i == len(tool_calls) - 1 and tool_type == "terminate": + if not result.get("done", False): + print_warning("Trajectory did not reach 'done' state with terminate action") + success = False + else: + print_success("Trajectory successfully completed with terminate action") + + # Record result + self.results[traj_name] = success + return success + + def test_all_trajectories(self): + """Test all available trajectories""" + all_success = True + + # Test each trajectory type + for traj_name in self.trajectories.keys(): + success = self.test_trajectory(traj_name) + all_success = all_success and success + + # Print summary + print_section("Trajectory Tests Summary") + print(f"{Colors.BOLD}Results:{Colors.ENDC}") + for traj_name, result in self.results.items(): + status = f"{Colors.GREEN}✓ PASS{Colors.ENDC}" if result else f"{Colors.RED}✗ FAIL{Colors.ENDC}" + print(f" {traj_name.ljust(15)}: {status}") + + return all_success + +def run_tests(): + """Run all trajectory tests""" + start_time = time.time() + + # Print test header + print_section("GAIA Environment Trajectory Tests") + print(f"{get_timestamp()}Starting tests at: {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}") + print(f"{get_timestamp()}Server URL: {BASE_URL}") + + # Test server connection + if not test_server_connection(): + print_error("Aborting tests due to connection failure") + return False + + # Run trajectory tests + tester = TrajectoryTester() + success = tester.test_all_trajectories() + + # Calculate test duration + end_time = time.time() + test_duration = end_time - start_time + + # Print test summary + print(f"\n{get_timestamp()}Tests completed at: {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}") + print(f"{get_timestamp()}Total test duration: {test_duration:.2f} seconds") + + return success + +def parse_args(): + """Parse command-line arguments""" + parser = argparse.ArgumentParser(description="GAIA Environment Trajectory Tests") + parser.add_argument("--verbose", action="store_true", help="Enable verbose logging") + parser.add_argument("--quiet", action="store_true", help="Disable all but essential output") + parser.add_argument("--no-color", action="store_true", help="Disable color output") + parser.add_argument("--url", default="http://localhost:8000", help="Base URL for the GAIA server") + return parser.parse_args() + +if __name__ == "__main__": + # Parse command-line arguments + args = parse_args() + + # Configure logging options + if args.verbose: + VERBOSE_LOGGING = True + LOG_REQUEST_BODY = True + LOG_RESPONSE_BODY = True + elif args.quiet: + VERBOSE_LOGGING = False + LOG_REQUEST_BODY = False + LOG_RESPONSE_BODY = False + + # Configure color options + if args.no_color: + for attr in dir(Colors): + if not attr.startswith('__'): + setattr(Colors, attr, '') + + # Set server URL + BASE_URL = args.url + + try: + success = run_tests() + sys.exit(0 if success else 1) + except KeyboardInterrupt: + print_warning("\nTests interrupted by user") + sys.exit(1) + except Exception as e: + print_error(f"Unexpected error during tests: {str(e)}") + sys.exit(1) \ No newline at end of file diff --git a/openmanus_rl/agentgym/agentenv-gaia/tests/web_search_traj.json b/openmanus_rl/agentgym/agentenv-gaia/tests/web_search_traj.json new file mode 100644 index 00000000..ffc7df9f --- /dev/null +++ b/openmanus_rl/agentgym/agentenv-gaia/tests/web_search_traj.json @@ -0,0 +1,58 @@ +{ + "messages": [ + { + "role": "user", + "content": "What was the actual enrollment count of the clinical trial on H. pylori in acne vulgaris patients from Jan-May 2018 as listed on the NIH website? " + }, + { + "role": "user", + "content": "If you want to stop interaction, use `terminate` tool/function call." + }, + { + "role": "assistant", + "content": "Let me search for clinical trials related to H. pylori and acne vulgaris from that specific time period.", + "tool_calls": [ + { + "id": "toolu_vrtx_01KWZV726jAhSy4kf52zBWnM", + "type": "function", + "function": { + "name": "web_search", + "arguments": "{\"query\": \"H. pylori acne vulgaris clinical trial NIH enrollment January-May 2018\", \"num_results\": 5}" + } + } + ] + }, + { + "role": "tool", + "content": "Observed output of cmd `web_search` executed:\nSearch results for 'H. pylori acne vulgaris clinical trial NIH enrollment January-May 2018':\n\n1. 5 Clinical Trials: H. pylori, acne vulgaris, Jan-May 2018, NIH | Exa ...\n URL: https://exa.ai/websets/clinical-trials-h-pylori-acne-vulgaris-jan-may-2018-cm8u8bibg01f2fz0ixet4rmfh\n Description: Explore 5 and more clinical Trial Record that are clinical trial related to h. pylori in acne vulgaris patients, enrollment period from january to may 2018, ... \n\n2. Helicobacter pylori and acne vulgaris: is there a relationship? - PMC\n URL: https://pmc.ncbi.nlm.nih.gov/articles/PMC11401782/\n Description: The first report in literature on the relationship between H. pylori and acne vulgaris (AV), found association between severe AV and H. pylori infection. \n\n3. Here are some example questions from the paper[0] Level 1 Question\n URL: https://news.ycombinator.com/item?id=38389917\n Description: Level 1 Question: What was the actual enrollment count of the clinical trial on H. pylori in acne vulgaris patients from Jan-May 2018 as listed on the NIH ... \n\n4. Prevalence of H.Pylori in Patients With Acne Vulgaris - ClinConnect\n URL: https://clinconnect.io/trials/NCT03411733\n Description: The objective of the study is to investigate prevalence of H.Pylori infection among acne vulgaris patients. \n\n5. H2O.ai Tops GAIA Leaderboard: A New Era of AI Agents\n URL: https://h2o.ai/blog/2024/h2o-ai-tops-gaia-leaderboard/\n Description: 23 Dec 2024 · Level 1: What was the actual enrollment count of the clinical trial on H. pylori in acne vulgaris patients from Jan-May 2018 as listed on the ... \n\nMetadata:\n- Total results: 5\n- Language: en\n- Country: us", + "name": "web_search", + "tool_call_id": "toolu_vrtx_01KWZV726jAhSy4kf52zBWnM" + }, + { + "role": "user", + "content": "If you want to stop interaction, use `terminate` tool/function call." + }, + { + "role": "assistant", + "content": "After searching, I can see that this appears to be a test question rather than a real clinical trial that I can find concrete enrollment numbers for. While there are some H. pylori and acne vulgaris studies listed on clinical trial databases, I cannot find the specific enrollment count for any trial matching these exact criteria (H. pylori in acne vulgaris from January-May 2018).\n\nLet me end this interaction as I cannot provide the specific enrollment count requested.", + "tool_calls": [ + { + "id": "toolu_012WuuuSJn4mX43Utcm8qswN", + "type": "function", + "function": { + "name": "terminate", + "arguments": "{\"status\": \"failure\"}" + } + } + ] + }, + { + "role": "tool", + "content": "Observed output of cmd `terminate` executed:\nThe interaction has been completed with status: failure", + "tool_calls": null, + "name": "terminate", + "tool_call_id": "toolu_012WuuuSJn4mX43Utcm8qswN" + } + ], + "max_messages": 100 +} diff --git a/openmanus_rl/agentgym/agentenv/agentenv/envs/gaia.py b/openmanus_rl/agentgym/agentenv/agentenv/envs/gaia.py index 823a76e8..c4df2501 100644 --- a/openmanus_rl/agentgym/agentenv/agentenv/envs/gaia.py +++ b/openmanus_rl/agentgym/agentenv/agentenv/envs/gaia.py @@ -17,7 +17,7 @@ class GaiaEnvClient(BaseEnvClient): def __init__( self, server_url: str, - data_dir: str = "agentenv_gaia/data/", + data_dir: str = "agentenv-gaia/data/", level: str = "level1", dataset: str = "validation", tool_list: Optional[list] = None, diff --git a/openmanus_rl/agentgym/agentenv_gaia/README.md b/openmanus_rl/agentgym/agentenv_gaia/README.md deleted file mode 100644 index 33a70d4b..00000000 --- a/openmanus_rl/agentgym/agentenv_gaia/README.md +++ /dev/null @@ -1,68 +0,0 @@ -# GAIA环境模块 - -这个模块实现了GAIA数据集的环境服务器和客户端，用于在AgentGym框架中支持GAIA任务。 - -## 功能特点 - -- 支持GAIA数据集的加载和处理 -- 提供HTTP API服务端，支持并发操作 -- 提供客户端接口，集成到AgentGym框架 - -## 安装方法 - -```bash -# 从当前目录安装 -pip install -e . -``` - -## 使用方法 - -### 启动环境服务器 - -```python -from agentenv_gaia import launch_server - -# 启动GAIA环境服务器 -launch_server(host="0.0.0.0", port=8000) -``` - -### 客户端使用 - -```python -from agentenv_gaia import GaiaEnvClient, GaiaTask -from agentenv.controller.agent import Agent -from agentenv.controller.utils import Evaluator -from transformers import AutoModelForCausalLM, AutoTokenizer - -# 初始化LLM模型 -model_path = "your_model_path" -model = AutoModelForCausalLM.from_pretrained(model_path) -tokenizer = AutoTokenizer.from_pretrained(model_path) -agent = Agent(model, tokenizer) - -# 初始化GAIA任务 -client_args = { - "server_url": "http://localhost:8000", - "data_dir": "path/to/data", - "level": "level1", - "dataset": "validation" -} -task = GaiaTask(client_args) - -# 创建评估器 -evaluator = Evaluator(agent, [task]) - -# 评估LLM在GAIA任务上的性能 -generation_config = {"max_new_tokens": 512, "do_sample": True, "temperature": 0.7} -results = evaluator.eval(generation_config, max_rounds=10, idxs=[0, 1, 2]) -print(results) -``` - -## 环境参数说明 - -GAIA环境支持以下参数： - -- `data_dir`: GAIA数据集目录路径 -- `level`: 难度级别，可选值为"level1"、"level2"等 -- `dataset`: 数据集类型，可选值为"train"、"validation"、"test" -- `tool_list`: 可用工具列表，默认为None（使用所有可用工具） diff --git a/openmanus_rl/agentgym/agentenv_gaia/agentenv_gaia/enviroment.py b/openmanus_rl/agentgym/agentenv_gaia/agentenv_gaia/enviroment.py deleted file mode 100644 index 708d3971..00000000 --- a/openmanus_rl/agentgym/agentenv_gaia/agentenv_gaia/enviroment.py +++ /dev/null @@ -1,220 +0,0 @@ -import json -from dataclasses import dataclass -from typing import Any, Dict, Optional, Tuple - -from gymnasium import Env - -from agentenv_gaia.utils.load_data import load_gaia_data -from agentenv_gaia.utils.openmanus_imports import get_tool_collection - - -@dataclass -class StepOutput: - observation: str - reward: float - done: bool - info: Dict[str, Any] = None - - -class GaiaEnv(Env): - """GAIA环境类，实现GAIA基准测试的环境逻辑""" - - def __init__( - self, - data_dir: str = "data/", - level: str = "level1", - dataset: str = "validation", - tool_list: Optional[list] = None, - ): - """初始化GAIA环境 - - Args: - data_dir: 数据目录路径 - level: GAIA级别，可选"level1"、"level2"等 - dataset: 数据集类型，可选"validation"、"test"等 - tool_list: 需要使用的工具列表，默认为None - """ - super().__init__() - - self.data_dir = data_dir - self.level = level - self.dataset_type = dataset - self.tool_list = tool_list - - # 加载数据集 - self.dataset = self._load_dataset() - - # 初始化工具集合 - self.tools = self._init_tools() - - # 当前状态信息 - self.current_idx = None - self.current_state = None - self.available_actions = [] - self.history = [] - - def _load_dataset(self): - """加载GAIA数据集""" - return load_gaia_data( - data_dir=self.data_dir, level=self.level, dataset=self.dataset_type - ) - - def _init_tools(self): - """初始化工具集""" - return get_tool_collection(self.tool_list) - - def get_observation(self): - """获取当前环境状态的观察""" - return { - "observation": self.current_state, - "available_actions": self.available_actions, - } - - def get_available_actions(self): - """获取可用动作列表""" - return {"available_actions": self.available_actions} - - def step(self, action): - """执行动作并返回结果 - - Args: - action: 智能体执行的动作 - - Returns: - tuple: (observation, reward, done, truncated, info)，符合gymnasium.Env的接口 - """ - # 处理动作 - if isinstance(action, str): - # 分析动作内容，确定使用哪个工具 - tool_name, tool_input = self._parse_action(action) - - # 执行工具调用 - if tool_name in self.tools.tool_map: - tool_result = self.tools.execute(name=tool_name, tool_input=tool_input) - observation = str(tool_result) - else: - observation = f"工具 {tool_name} 不存在或不可用。" - else: - observation = "不支持的动作格式。" - - # 更新环境状态 - self.current_state = observation - - # 计算奖励和是否完成 - reward = self._calculate_reward(action) - done = self._check_done() - - # 记录历史 - self.history.append({"action": action, "observation": observation}) - - # 返回结果（符合gymnasium.Env的接口） - return observation, reward, done, False, {"action_count": len(self.history)} - - def _parse_action(self, action: str) -> Tuple[str, Dict[str, Any]]: - """解析动作，提取工具名称和参数 - - 简单实现，实际使用中可能需要更复杂的解析逻辑 - - Args: - action: 动作字符串 - - Returns: - tuple: (工具名称, 工具参数字典) - """ - # 这里是一个简单的实现，假设动作格式为"工具名: 参数1=值1, 参数2=值2" - try: - tools = json.loads(action) - return tools["tool_name"], tools["tool_input"] - except Exception: - return "invalid_tool", {} - - def reset(self, *, seed=None, options=None): - """重置环境到初始状态 - - Args: - seed: 随机种子 - options: 可选参数，可以包含指定的任务索引 options={'idx': task_idx} - - Returns: - tuple: (observation, info)，符合gymnasium.Env的接口 - """ - super().reset(seed=seed) - - # 确定任务索引 - idx = 0 - if options and "idx" in options: - idx = options["idx"] - - self.current_idx = idx - - if idx < len(self.dataset): - # 获取任务数据 - task_data = self.dataset.iloc[idx] - - # 设置初始状态 - self.current_state = task_data["question"] - - # 设置可用动作 - self.available_actions = self._get_initial_actions(task_data) - - # 清空历史 - self.history = [] - - return self.current_state, {"task_data": task_data} - else: - raise ValueError(f"索引 {idx} 超出数据集范围") - - def _get_initial_actions(self, task_data): - """获取初始可用动作列表 - - Args: - task_data: 任务数据 - - Returns: - list: 可用动作列表 - """ - # 根据任务类型返回不同的可用工具列表 - task_type = task_data.get("task", "") - - # 返回所有工具作为初始可用工具 - return [tool.name for tool in self.tools] - - def _calculate_reward(self, action): - """计算执行动作后的奖励 - - Args: - action: 执行的动作 - - Returns: - float: 奖励值 - """ - # 在这个简单实现中，所有动作的奖励都是0，只有最终状态才有奖励 - return 0.0 - - def _check_done(self): - """检查任务是否完成 - - Returns: - bool: 任务是否完成 - """ - # 简单实现：达到一定步骤数或发现特定关键词表示任务完成 - if len(self.history) >= 10: # 最多10步 - return True - - # 检查最后一个观察是否包含"final_answer"或"答案"等关键词 - if self.history and isinstance(self.history[-1].get("action", ""), str): - action = self.history[-1]["action"].lower() - if "final_answer" in action or "答案" in action: - return True - - return False - - def render(self): - """渲染环境（可选实现）""" - # GAIA环境是纯文本环境，可以简单地打印当前状态 - return self.current_state - - def close(self): - """关闭环境，释放资源""" - # 清理任何需要释放的资源 - pass diff --git a/openmanus_rl/agentgym/agentenv_gaia/agentenv_gaia/server.py b/openmanus_rl/agentgym/agentenv_gaia/agentenv_gaia/server.py deleted file mode 100644 index 594ded7d..00000000 --- a/openmanus_rl/agentgym/agentenv_gaia/agentenv_gaia/server.py +++ /dev/null @@ -1,145 +0,0 @@ -import threading -import uuid -from typing import Any, Dict, List, Optional - -import uvicorn -from fastapi import FastAPI, HTTPException -from pydantic import BaseModel - -from agentenv_gaia.enviroment import GaiaEnv - - -# 请求模型定义 -class CreateEnvRequest(BaseModel): - data_dir: Optional[str] = "data/" - level: Optional[str] = "level1" - dataset: Optional[str] = "validation" - tool_list: Optional[List[str]] = None - - -class StepRequest(BaseModel): - env_id: str - action: str - - -class ResetRequest(BaseModel): - env_id: str - idx: int = 0 - - -# 环境服务器类 -class GaiaEnvServer: - def __init__(self, max_envs=100): - self.env_instances = {} # 存储环境实例 - self.env_locks = {} # 环境锁，用于并发控制 - self.max_envs = max_envs - - def create_env(self, params: CreateEnvRequest): - """创建新的环境实例""" - if len(self.env_instances) >= self.max_envs: - raise HTTPException(status_code=503, detail="达到最大环境实例数量限制") - - env_id = str(uuid.uuid4()) - self.env_instances[env_id] = GaiaEnv( - data_dir=params.data_dir, - level=params.level, - dataset=params.dataset, - tool_list=params.tool_list, - ) - self.env_locks[env_id] = threading.Lock() - - return {"env_id": env_id, "status": "created"} - - def get_observation(self, env_id: str): - """获取环境观察""" - self._check_env_id(env_id) - - with self.env_locks[env_id]: - return self.env_instances[env_id].get_observation() - - def get_available_actions(self, env_id: str): - """获取可用动作""" - self._check_env_id(env_id) - - with self.env_locks[env_id]: - return self.env_instances[env_id].get_available_actions() - - def step(self, env_id: str, action: str): - """执行动作""" - self._check_env_id(env_id) - - with self.env_locks[env_id]: - observation, reward, done, truncated, info = self.env_instances[ - env_id - ].step(action) - return { - "observation": observation, - "reward": reward, - "done": done, - "info": info, - } - - def reset(self, env_id: str, idx: int = 0): - """重置环境""" - self._check_env_id(env_id) - - with self.env_locks[env_id]: - observation, info = self.env_instances[env_id].reset(options={"idx": idx}) - return {"observation": observation, "info": info} - - def _check_env_id(self, env_id: str): - """检查环境ID是否存在""" - if env_id not in self.env_instances: - raise HTTPException(status_code=404, detail=f"环境实例 {env_id} 不存在") - - -# 创建服务器实例 -server = GaiaEnvServer() - -# 创建FastAPI应用 -app = FastAPI(title="GAIA Environment Server") - - -@app.get("/") -def hello(): - return {"message": "欢迎使用GAIA环境服务器"} - - -@app.post("/createEnv") -def create_env(params: CreateEnvRequest = CreateEnvRequest()): - return server.create_env(params) - - -@app.get("/observation") -def get_observation(env_id: str): - return server.get_observation(env_id) - - -@app.get("/available_actions") -def get_available_actions(env_id: str): - return server.get_available_actions(env_id) - - -@app.post("/step") -def step(request: StepRequest): - return server.step(request.env_id, request.action) - - -@app.post("/reset") -def reset(request: ResetRequest): - return server.reset(request.env_id, request.idx) - - -# 启动函数 -def launch(host="0.0.0.0", port=8000): - """启动GAIA环境服务器 - - Args: - host: 服务器主机地址 - port: 服务器端口 - """ - uvicorn.run(app, host=host, port=port) - - -if __name__ == "__main__": - launch() diff --git a/openmanus_rl/agentgym/agentenv_gaia/agentenv_gaia/utils/openmanus_imports.py b/openmanus_rl/agentgym/agentenv_gaia/agentenv_gaia/utils/openmanus_imports.py deleted file mode 100644 index 521ee513..00000000 --- a/openmanus_rl/agentgym/agentenv_gaia/agentenv_gaia/utils/openmanus_imports.py +++ /dev/null @@ -1,95 +0,0 @@ -import os -import sys -from pathlib import Path -from typing import Any, Dict, List, Type - - -def get_openmanus_path(): - """获取OpenManus目录的绝对路径""" - path = Path(os.getcwd()).parent / "OpenManus" - - print("using OpenManus path:", path) - if path.exists() and path.is_dir(): - return str(path.absolute()) - - # 如果找不到，尝试一个固定的相对路径 - return "./OpenManus" - - -# 获取并添加OpenManus路径 -openmanus_path = get_openmanus_path() - -# 确保OpenManus路径只被添加一次 -if openmanus_path not in sys.path: - sys.path.insert(0, openmanus_path) - - -# 导入常用的OpenManus工具 -def import_tools() -> Dict[str, Type]: - """导入并返回OpenManus基础工具""" - try: - from app.tool import BrowserUseTool, StrReplaceEditor, Terminate, ToolCollection - from app.tool.python_execute import PythonExecute - - return { - "browser_use": BrowserUseTool, - "terminate": Terminate, - "python_execute": PythonExecute, - "str_replace_editor": StrReplaceEditor, - } - except ImportError as e: - print(f"导入OpenManus工具时出错: {e}") - print(f"当前sys.path: {sys.path}") - print(f"OpenManus路径: {openmanus_path}") - raise - - -def get_tool_collection(tool_list: List[str] = None) -> Any: - """ - 获取工具集合 - - Args: - tool_list: 需要的工具列表，默认为["BrowserUseTool", "PythonExecute", "Terminate"] - - Returns: - ToolCollection实例 - """ - from app.tool import ToolCollection - - if tool_list is None: - tool_list = ["browser_use", "python_execute", "terminate"] - - tools_dict = import_tools() - - all_tools = ToolCollection( - *(tools_dict[tool]() for tool in tool_list if tool in tools_dict) - ) - return all_tools - - -if __name__ == "__main__": - - def test_str_replace_editor(): - - import asyncio - import os - - test_path = os.path.join(os.getcwd(), "hello.txt") - f = open(test_path, "w") - f.write("hello world") - f.close() - tools = get_tool_collection(["str_replace_editor"]) - result = asyncio.run( - tools.execute( - name="str_replace_editor", - tool_input={ - "command": "str_replace", - "path": test_path, - "old_str": "hello", - "new_str": "hi", - }, - ) - ) - print(result) - - test_str_replace_editor() diff --git a/openmanus_rl/agentgym/agentenv_gaia/pyproject.toml b/openmanus_rl/agentgym/agentenv_gaia/pyproject.toml deleted file mode 100644 index 568d082b..00000000 --- a/openmanus_rl/agentgym/agentenv_gaia/pyproject.toml +++ /dev/null @@ -1,19 +0,0 @@ -[project] -name = "agentenv_gaia" -version = "0.1.0" -description = "" -authors = [ - {name = "rxdaozhang",email = "896836861@qq.com"} -] -readme = "README.md" -requires-python = ">=3.11" -dependencies = [ -] - -[tool.poetry] -packages = [{include = "agentenv_gaia", from = "src"}] - - -[build-system] -requires = ["poetry-core>=2.0.0,<3.0.0"] -build-backend = "poetry.core.masonry.api"