SYMBOL INDEX (530 symbols across 68 files)

FILE: app/agent/base.py
  class BaseAgent (line 13) | class BaseAgent(BaseModel, ABC):
    class Config (line 45) | class Config:
    method initialize_agent (line 50) | def initialize_agent(self) -> "BaseAgent":
    method state_context (line 59) | async def state_context(self, new_state: AgentState):
    method update_memory (line 84) | def update_memory(
    method run (line 116) | async def run(self, request: Optional[str] = None) -> str:
    method step (line 157) | async def step(self) -> str:
    method handle_stuck_state (line 163) | def handle_stuck_state(self):
    method is_stuck (line 170) | def is_stuck(self) -> bool:
    method messages (line 189) | def messages(self) -> List[Message]:
    method messages (line 194) | def messages(self, value: List[Message]):

FILE: app/agent/browser.py
  class BrowserContextHelper (line 19) | class BrowserContextHelper:
    method __init__ (line 20) | def __init__(self, agent: "BaseAgent"):
    method get_browser_state (line 24) | async def get_browser_state(self) -> Optional[dict]:
    method format_next_step_prompt (line 47) | async def format_next_step_prompt(self) -> str:
    method cleanup_browser (line 81) | async def cleanup_browser(self):
  class BrowserAgent (line 87) | class BrowserAgent(ToolCallAgent):
    method initialize_helper (line 116) | def initialize_helper(self) -> "BrowserAgent":
    method think (line 120) | async def think(self) -> bool:
    method cleanup (line 127) | async def cleanup(self):

FILE: app/agent/data_analysis.py
  class DataAnalysis (line 12) | class DataAnalysis(ToolCallAgent):

FILE: app/agent/manus.py
  class Manus (line 18) | class Manus(ToolCallAgent):
    method initialize_helper (line 54) | def initialize_helper(self) -> "Manus":
    method create (line 60) | async def create(cls, **kwargs) -> "Manus":
    method initialize_mcp_servers (line 67) | async def initialize_mcp_servers(self) -> None:
    method connect_mcp_server (line 91) | async def connect_mcp_server(
    method disconnect_mcp_server (line 114) | async def disconnect_mcp_server(self, server_id: str = "") -> None:
    method cleanup (line 131) | async def cleanup(self):
    method think (line 140) | async def think(self) -> bool:

FILE: app/agent/mcp.py
  class MCPAgent (line 13) | class MCPAgent(ToolCallAgent):
    method initialize (line 40) | async def initialize(
    method _refresh_tools (line 87) | async def _refresh_tools(self) -> Tuple[List[str], List[str]]:
    method think (line 134) | async def think(self) -> bool:
    method _handle_special_tool (line 154) | async def _handle_special_tool(self, name: str, result: Any, **kwargs)...
    method _should_finish_execution (line 167) | def _should_finish_execution(self, name: str, **kwargs) -> bool:
    method cleanup (line 172) | async def cleanup(self) -> None:
    method run (line 178) | async def run(self, request: Optional[str] = None) -> str:

FILE: app/agent/react.py
  class ReActAgent (line 11) | class ReActAgent(BaseAgent, ABC):
    method think (line 26) | async def think(self) -> bool:
    method act (line 30) | async def act(self) -> str:
    method step (line 33) | async def step(self) -> str:

FILE: app/agent/sandbox_agent.py
  class SandboxManus (line 21) | class SandboxManus(ToolCallAgent):
    method initialize_helper (line 58) | def initialize_helper(self) -> "SandboxManus":
    method create (line 64) | async def create(cls, **kwargs) -> "SandboxManus":
    method initialize_sandbox_tools (line 72) | async def initialize_sandbox_tools(
    method initialize_mcp_servers (line 113) | async def initialize_mcp_servers(self) -> None:
    method connect_mcp_server (line 137) | async def connect_mcp_server(
    method disconnect_mcp_server (line 160) | async def disconnect_mcp_server(self, server_id: str = "") -> None:
    method delete_sandbox (line 177) | async def delete_sandbox(self, sandbox_id: str) -> None:
    method cleanup (line 188) | async def cleanup(self):
    method think (line 198) | async def think(self) -> bool:

FILE: app/agent/swe.py
  class SWEAgent (line 10) | class SWEAgent(ToolCallAgent):

FILE: app/agent/toolcall.py
  class ToolCallAgent (line 18) | class ToolCallAgent(ReActAgent):
    method think (line 39) | async def think(self) -> bool:
    method act (line 131) | async def act(self) -> str:
    method execute_tool (line 166) | async def execute_tool(self, command: ToolCall) -> str:
    method _handle_special_tool (line 210) | async def _handle_special_tool(self, name: str, result: Any, **kwargs):
    method _should_finish_execution (line 221) | def _should_finish_execution(**kwargs) -> bool:
    method _is_special_tool (line 225) | def _is_special_tool(self, name: str) -> bool:
    method cleanup (line 229) | async def cleanup(self):
    method run (line 245) | async def run(self, request: Optional[str] = None) -> str:

FILE: app/bedrock.py
  class OpenAIResponse (line 17) | class OpenAIResponse:
    method __init__ (line 18) | def __init__(self, data):
    method model_dump (line 30) | def model_dump(self, *args, **kwargs):
  class BedrockClient (line 38) | class BedrockClient:
    method __init__ (line 39) | def __init__(self):
  class Chat (line 50) | class Chat:
    method __init__ (line 51) | def __init__(self, client):
  class ChatCompletions (line 56) | class ChatCompletions:
    method __init__ (line 57) | def __init__(self, client):
    method _convert_openai_tools_to_bedrock_format (line 60) | def _convert_openai_tools_to_bedrock_format(self, tools):
    method _convert_openai_messages_to_bedrock_format (line 86) | def _convert_openai_messages_to_bedrock_format(self, messages):
    method _convert_bedrock_response_to_openai_format (line 134) | def _convert_bedrock_response_to_openai_format(self, bedrock_response):
    method _invoke_bedrock (line 195) | async def _invoke_bedrock(
    method _invoke_bedrock_stream (line 220) | async def _invoke_bedrock_stream(
    method create (line 300) | def create(

FILE: app/config.py
  function get_project_root (line 10) | def get_project_root() -> Path:
  class LLMSettings (line 19) | class LLMSettings(BaseModel):
  class ProxySettings (line 33) | class ProxySettings(BaseModel):
  class SearchSettings (line 39) | class SearchSettings(BaseModel):
  class RunflowSettings (line 63) | class RunflowSettings(BaseModel):
  class BrowserSettings (line 69) | class BrowserSettings(BaseModel):
  class SandboxSettings (line 94) | class SandboxSettings(BaseModel):
  class DaytonaSettings (line 108) | class DaytonaSettings(BaseModel):
  class MCPServerConfig (line 127) | class MCPServerConfig(BaseModel):
  class MCPSettings (line 138) | class MCPSettings(BaseModel):
    method load_server_config (line 149) | def load_server_config(cls) -> Dict[str, MCPServerConfig]:
  class AppConfig (line 174) | class AppConfig(BaseModel):
    class Config (line 193) | class Config:
  class Config (line 197) | class Config:
    method __new__ (line 202) | def __new__(cls):
    method __init__ (line 209) | def __init__(self):
    method _get_config_path (line 218) | def _get_config_path() -> Path:
    method _load_config (line 228) | def _load_config(self) -> dict:
    method _load_initial_config (line 233) | def _load_initial_config(self):
    method llm (line 332) | def llm(self) -> Dict[str, LLMSettings]:
    method sandbox (line 336) | def sandbox(self) -> SandboxSettings:
    method daytona (line 340) | def daytona(self) -> DaytonaSettings:
    method browser_config (line 344) | def browser_config(self) -> Optional[BrowserSettings]:
    method search_config (line 348) | def search_config(self) -> Optional[SearchSettings]:
    method mcp_config (line 352) | def mcp_config(self) -> MCPSettings:
    method run_flow_config (line 357) | def run_flow_config(self) -> RunflowSettings:
    method workspace_root (line 362) | def workspace_root(self) -> Path:
    method root_path (line 367) | def root_path(self) -> Path:

FILE: app/daytona/sandbox.py
  function get_or_start_sandbox (line 45) | async def get_or_start_sandbox(sandbox_id: str):
  function start_supervisord_session (line 80) | def start_supervisord_session(sandbox: Sandbox):
  function create_sandbox (line 102) | def create_sandbox(password: str, project_id: str = None):
  function delete_sandbox (line 150) | async def delete_sandbox(sandbox_id: str):

FILE: app/daytona/tool_base.py
  class ThreadMessage (line 26) | class ThreadMessage:
    method to_dict (line 39) | def to_dict(self) -> Dict[str, Any]:
  class SandboxToolsBase (line 50) | class SandboxToolsBase(BaseTool):
    class Config (line 67) | class Config:
    method _ensure_sandbox (line 71) | async def _ensure_sandbox(self) -> Sandbox:
    method sandbox (line 119) | def sandbox(self) -> Sandbox:
    method sandbox_id (line 126) | def sandbox_id(self) -> str:
    method clean_path (line 134) | def clean_path(self, path: str) -> str:

FILE: app/exceptions.py
  class ToolError (line 1) | class ToolError(Exception):
    method __init__ (line 4) | def __init__(self, message):
  class OpenManusError (line 8) | class OpenManusError(Exception):
  class TokenLimitExceeded (line 12) | class TokenLimitExceeded(OpenManusError):

FILE: app/flow/base.py
  class BaseFlow (line 9) | class BaseFlow(BaseModel, ABC):
    class Config (line 16) | class Config:
    method __init__ (line 19) | def __init__(
    method primary_agent (line 43) | def primary_agent(self) -> Optional[BaseAgent]:
    method get_agent (line 47) | def get_agent(self, key: str) -> Optional[BaseAgent]:
    method add_agent (line 51) | def add_agent(self, key: str, agent: BaseAgent) -> None:
    method execute (line 56) | async def execute(self, input_text: str) -> str:

FILE: app/flow/flow_factory.py
  class FlowType (line 9) | class FlowType(str, Enum):
  class FlowFactory (line 13) | class FlowFactory:
    method create_flow (line 17) | def create_flow(

FILE: app/flow/planning.py
  class PlanStepStatus (line 16) | class PlanStepStatus(str, Enum):
    method get_all_statuses (line 25) | def get_all_statuses(cls) -> list[str]:
    method get_active_statuses (line 30) | def get_active_statuses(cls) -> list[str]:
    method get_status_marks (line 35) | def get_status_marks(cls) -> Dict[str, str]:
  class PlanningFlow (line 45) | class PlanningFlow(BaseFlow):
    method __init__ (line 54) | def __init__(
    method get_executor (line 77) | def get_executor(self, step_type: Optional[str] = None) -> BaseAgent:
    method execute (line 94) | async def execute(self, input_text: str) -> str:
    method _create_initial_plan (line 136) | async def _create_initial_plan(self, request: str) -> None:
    method _get_current_step_info (line 213) | async def _get_current_step_info(self) -> tuple[Optional[int], Optiona...
    method _execute_step (line 277) | async def _execute_step(self, executor: BaseAgent, step_info: dict) ->...
    method _mark_step_completed (line 306) | async def _mark_step_completed(self) -> None:
    method _get_plan_text (line 337) | async def _get_plan_text(self) -> str:
    method _generate_plan_text_from_storage (line 348) | def _generate_plan_text_from_storage(self) -> str:
    method _finalize_plan (line 406) | async def _finalize_plan(self) -> str:

FILE: app/llm.py
  class TokenCounter (line 45) | class TokenCounter:
    method __init__ (line 57) | def __init__(self, tokenizer):
    method count_text (line 60) | def count_text(self, text: str) -> int:
    method count_image (line 64) | def count_image(self, image_item: dict) -> int:
    method _calculate_high_detail_tokens (line 95) | def _calculate_high_detail_tokens(self, width: int, height: int) -> int:
    method count_content (line 118) | def count_content(self, content: Union[str, List[Union[str, dict]]]) -...
    method count_tool_calls (line 137) | def count_tool_calls(self, tool_calls: List[dict]) -> int:
    method count_message_tokens (line 147) | def count_message_tokens(self, messages: List[dict]) -> int:
  class LLM (line 174) | class LLM:
    method __new__ (line 177) | def __new__(
    method __init__ (line 186) | def __init__(
    method count_tokens (line 229) | def count_tokens(self, text: str) -> int:
    method count_message_tokens (line 235) | def count_message_tokens(self, messages: List[dict]) -> int:
    method update_token_count (line 238) | def update_token_count(self, input_tokens: int, completion_tokens: int...
    method check_token_limit (line 249) | def check_token_limit(self, input_tokens: int) -> bool:
    method get_limit_error_message (line 256) | def get_limit_error_message(self, input_tokens: int) -> str:
    method format_messages (line 267) | def format_messages(
    method ask (line 361) | async def ask(
    method ask_with_images (line 488) | async def ask_with_images(
    method ask_tool (line 644) | async def ask_tool(

FILE: app/logger.py
  function define_log_level (line 12) | def define_log_level(print_level="INFO", logfile_level="DEBUG", name: st...

FILE: app/mcp/server.py
  class MCPServer (line 24) | class MCPServer:
    method __init__ (line 27) | def __init__(self, name: str = "openmanus"):
    method register_tool (line 37) | def register_tool(self, tool: BaseTool, method_name: Optional[str] = N...
    method _build_docstring (line 78) | def _build_docstring(self, tool_function: dict) -> str:
    method _build_signature (line 100) | def _build_signature(self, tool_function: dict) -> Signature:
    method cleanup (line 138) | async def cleanup(self) -> None:
    method register_all_tools (line 145) | def register_all_tools(self) -> None:
    method run (line 150) | def run(self, transport: str = "stdio") -> None:
  function parse_args (line 163) | def parse_args() -> argparse.Namespace:

FILE: app/sandbox/client.py
  class SandboxFileOperations (line 8) | class SandboxFileOperations(Protocol):
    method copy_from (line 11) | async def copy_from(self, container_path: str, local_path: str) -> None:
    method copy_to (line 20) | async def copy_to(self, local_path: str, container_path: str) -> None:
    method read_file (line 29) | async def read_file(self, path: str) -> str:
    method write_file (line 40) | async def write_file(self, path: str, content: str) -> None:
  class BaseSandboxClient (line 50) | class BaseSandboxClient(ABC):
    method create (line 54) | async def create(
    method run_command (line 62) | async def run_command(self, command: str, timeout: Optional[int] = Non...
    method copy_from (line 66) | async def copy_from(self, container_path: str, local_path: str) -> None:
    method copy_to (line 70) | async def copy_to(self, local_path: str, container_path: str) -> None:
    method read_file (line 74) | async def read_file(self, path: str) -> str:
    method write_file (line 78) | async def write_file(self, path: str, content: str) -> None:
    method cleanup (line 82) | async def cleanup(self) -> None:
  class LocalSandboxClient (line 86) | class LocalSandboxClient(BaseSandboxClient):
    method __init__ (line 89) | def __init__(self):
    method create (line 93) | async def create(
    method run_command (line 110) | async def run_command(self, command: str, timeout: Optional[int] = Non...
    method copy_from (line 127) | async def copy_from(self, container_path: str, local_path: str) -> None:
    method copy_to (line 141) | async def copy_to(self, local_path: str, container_path: str) -> None:
    method read_file (line 155) | async def read_file(self, path: str) -> str:
    method write_file (line 171) | async def write_file(self, path: str, content: str) -> None:
    method cleanup (line 185) | async def cleanup(self) -> None:
  function create_sandbox_client (line 192) | def create_sandbox_client() -> LocalSandboxClient:

FILE: app/sandbox/core/exceptions.py
  class SandboxError (line 8) | class SandboxError(Exception):
  class SandboxTimeoutError (line 12) | class SandboxTimeoutError(SandboxError):
  class SandboxResourceError (line 16) | class SandboxResourceError(SandboxError):

FILE: app/sandbox/core/manager.py
  class SandboxManager (line 14) | class SandboxManager:
    method __init__ (line 29) | def __init__(
    method ensure_image (line 65) | async def ensure_image(self, image: str) -> bool:
    method sandbox_operation (line 89) | async def sandbox_operation(self, sandbox_id: str):
    method create_sandbox (line 114) | async def create_sandbox(
    method get_sandbox (line 159) | async def get_sandbox(self, sandbox_id: str) -> DockerSandbox:
    method start_cleanup_task (line 174) | def start_cleanup_task(self) -> None:
    method _cleanup_idle_sandboxes (line 187) | async def _cleanup_idle_sandboxes(self) -> None:
    method cleanup (line 206) | async def cleanup(self) -> None:
    method _safe_delete_sandbox (line 244) | async def _safe_delete_sandbox(self, sandbox_id: str) -> None:
    method delete_sandbox (line 278) | async def delete_sandbox(self, sandbox_id: str) -> None:
    method __aenter__ (line 292) | async def __aenter__(self) -> "SandboxManager":
    method __aexit__ (line 296) | async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
    method get_stats (line 300) | def get_stats(self) -> Dict:

FILE: app/sandbox/core/sandbox.py
  class DockerSandbox (line 18) | class DockerSandbox:
    method __init__ (line 32) | def __init__(
    method create (line 49) | async def create(self) -> "DockerSandbox":
    method _prepare_volume_bindings (line 105) | def _prepare_volume_bindings(self) -> Dict[str, Dict[str, str]]:
    method _ensure_host_dir (line 124) | def _ensure_host_dir(path: str) -> str:
    method run_command (line 140) | async def run_command(self, cmd: str, timeout: Optional[int] = None) -...
    method read_file (line 166) | async def read_file(self, path: str) -> str:
    method write_file (line 198) | async def write_file(self, path: str, content: str) -> None:
    method _safe_resolve_path (line 232) | def _safe_resolve_path(self, path: str) -> str:
    method copy_from (line 255) | async def copy_from(self, src_path: str, dst_path: str) -> None:
    method copy_to (line 315) | async def copy_to(self, src_path: str, dst_path: str) -> None:
    method _create_tar_stream (line 378) | async def _create_tar_stream(name: str, content: bytes) -> io.BytesIO:
    method _read_from_tar (line 397) | async def _read_from_tar(tar_stream) -> bytes:
    method cleanup (line 425) | async def cleanup(self) -> None:
    method __aenter__ (line 456) | async def __aenter__(self) -> "DockerSandbox":
    method __aexit__ (line 460) | async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:

FILE: app/sandbox/core/terminal.py
  class DockerSession (line 19) | class DockerSession:
    method __init__ (line 20) | def __init__(self, container_id: str) -> None:
    method create (line 31) | async def create(self, working_dir: str, env_vars: Dict[str, str]) -> ...
    method close (line 75) | async def close(self) -> None:
    method _read_until_prompt (line 117) | async def _read_until_prompt(self) -> str:
    method execute (line 139) | async def execute(self, command: str, timeout: Optional[int] = None) -...
    method _sanitize_command (line 218) | def _sanitize_command(self, command: str) -> str:
  class AsyncDockerizedTerminal (line 251) | class AsyncDockerizedTerminal:
    method __init__ (line 252) | def __init__(
    method init (line 278) | async def init(self) -> None:
    method _ensure_workdir (line 291) | async def _ensure_workdir(self) -> None:
    method _exec_simple (line 302) | async def _exec_simple(self, cmd: str) -> Tuple[int, str]:
    method run_command (line 316) | async def run_command(self, cmd: str, timeout: Optional[int] = None) -...
    method close (line 334) | async def close(self) -> None:
    method __aenter__ (line 339) | async def __aenter__(self) -> "AsyncDockerizedTerminal":
    method __aexit__ (line 344) | async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:

FILE: app/schema.py
  class Role (line 7) | class Role(str, Enum):
  class ToolChoice (line 20) | class ToolChoice(str, Enum):
  class AgentState (line 32) | class AgentState(str, Enum):
  class Function (line 41) | class Function(BaseModel):
  class ToolCall (line 46) | class ToolCall(BaseModel):
  class Message (line 54) | class Message(BaseModel):
    method __add__ (line 64) | def __add__(self, other) -> List["Message"]:
    method __radd__ (line 75) | def __radd__(self, other) -> List["Message"]:
    method to_dict (line 84) | def to_dict(self) -> dict:
    method user_message (line 100) | def user_message(
    method system_message (line 107) | def system_message(cls, content: str) -> "Message":
    method assistant_message (line 112) | def assistant_message(
    method tool_message (line 119) | def tool_message(
    method from_tool_calls (line 132) | def from_tool_calls(
  class Memory (line 159) | class Memory(BaseModel):
    method add_message (line 163) | def add_message(self, message: Message) -> None:
    method add_messages (line 170) | def add_messages(self, messages: List[Message]) -> None:
    method clear (line 177) | def clear(self) -> None:
    method get_recent_messages (line 181) | def get_recent_messages(self, n: int) -> List[Message]:
    method to_dict_list (line 185) | def to_dict_list(self) -> List[dict]:

FILE: app/tool/ask_human.py
  class AskHuman (line 4) | class AskHuman(BaseTool):
    method execute (line 20) | async def execute(self, inquire: str) -> str:

FILE: app/tool/base.py
  class ToolResult (line 38) | class ToolResult(BaseModel):
    class Config (line 46) | class Config:
    method __bool__ (line 49) | def __bool__(self):
    method __add__ (line 52) | def __add__(self, other: "ToolResult"):
    method __str__ (line 69) | def __str__(self):
    method replace (line 72) | def replace(self, **kwargs):
  class BaseTool (line 78) | class BaseTool(ABC, BaseModel):
    class Config (line 99) | class Config:
    method __call__ (line 116) | async def __call__(self, **kwargs) -> Any:
    method execute (line 121) | async def execute(self, **kwargs) -> Any:
    method to_param (line 124) | def to_param(self) -> Dict:
    method success_response (line 147) | def success_response(self, data: Union[Dict[str, Any], str]) -> ToolRe...
    method fail_response (line 163) | def fail_response(self, msg: str) -> ToolResult:
  class CLIResult (line 176) | class CLIResult(ToolResult):
  class ToolFailure (line 180) | class ToolFailure(ToolResult):

FILE: app/tool/bash.py
  class _BashSession (line 16) | class _BashSession:
    method __init__ (line 27) | def __init__(self):
    method start (line 31) | async def start(self):
    method stop (line 47) | def stop(self):
    method run (line 55) | async def run(self, command: str):
  class Bash (line 116) | class Bash(BaseTool):
    method execute (line 134) | async def execute(

FILE: app/tool/browser_use_tool.py
  class BrowserUseTool (line 39) | class BrowserUseTool(BaseTool, Generic[Context]):
    method validate_parameters (line 136) | def validate_parameters(cls, v: dict, info: ValidationInfo) -> dict:
    method _ensure_browser_initialized (line 141) | async def _ensure_browser_initialized(self) -> BrowserContext:
    method execute (line 190) | async def execute(
    method get_current_state (line 479) | async def get_current_state(
    method cleanup (line 541) | async def cleanup(self):
    method __del__ (line 552) | def __del__(self):
    method create_with_context (line 563) | def create_with_context(cls, context: Context) -> "BrowserUseTool[Cont...

FILE: app/tool/chart_visualization/chart_prepare.py
  class VisualizationPrepare (line 4) | class VisualizationPrepare(NormalPythonExecute):

FILE: app/tool/chart_visualization/data_visualization.py
  class DataVisualization (line 15) | class DataVisualization(BaseTool):
    method initialize_llm (line 54) | def initialize_llm(self):
    method get_file_path (line 60) | def get_file_path(
    method success_output_template (line 82) | def success_output_template(self, result: list[dict[str, str]]) -> str:
    method data_visualization (line 94) | async def data_visualization(
    method add_insighs (line 148) | async def add_insighs(
    method execute (line 196) | async def execute(
    method invoke_vmind (line 217) | async def invoke_vmind(

FILE: app/tool/chart_visualization/python_execute.py
  class NormalPythonExecute (line 5) | class NormalPythonExecute(PythonExecute):
    method execute (line 35) | async def execute(self, code: str, code_type: str | None = None, timeo...

FILE: app/tool/chart_visualization/src/chartVisualize.ts
  type AlgorithmType (line 7) | enum AlgorithmType {
  function getHtmlVChart (line 58) | function getHtmlVChart(spec: any, width?: number, height?: number) {
  function getSavedPathName (line 100) | function getSavedPathName(
  function saveChartRes (line 148) | async function saveChartRes(options: {
  function generateChart (line 172) | async function generateChart(
  function updateChartWithInsight (line 288) | async function updateChartWithInsight(
  function executeVMind (line 324) | async function executeVMind() {

FILE: app/tool/chart_visualization/test/chart_demo.py
  function main (line 180) | async def main():

FILE: app/tool/chart_visualization/test/report_demo.py
  function main (line 9) | async def main():

FILE: app/tool/computer_use_tool.py
  class ComputerUseTool (line 102) | class ComputerUseTool(SandboxToolsBase):
    method __init__ (line 184) | def __init__(self, sandbox: Optional[Sandbox] = None, **data):
    method create_with_sandbox (line 195) | def create_with_sandbox(cls, sandbox: Sandbox) -> "ComputerUseTool":
    method _get_session (line 199) | async def _get_session(self) -> aiohttp.ClientSession:
    method _api_request (line 205) | async def _api_request(
    method execute (line 225) | async def execute(
    method cleanup (line 473) | async def cleanup(self):
    method __del__ (line 479) | def __del__(self):

FILE: app/tool/crawl4ai.py
  class Crawl4aiTool (line 16) | class Crawl4aiTool(BaseTool):
    method execute (line 65) | async def execute(
    method _is_valid_url (line 260) | def _is_valid_url(self, url: str) -> bool:

FILE: app/tool/create_chat_completion.py
  class CreateChatCompletion (line 8) | class CreateChatCompletion(BaseTool):
    method __init__ (line 26) | def __init__(self, response_type: Optional[Type] = str):
    method _build_parameters (line 32) | def _build_parameters(self) -> dict:
    method _create_type_schema (line 58) | def _create_type_schema(self, type_hint: Type) -> dict:
    method _get_type_info (line 110) | def _get_type_info(self, type_hint: Type) -> dict:
    method _create_union_schema (line 120) | def _create_union_schema(self, types: tuple) -> dict:
    method execute (line 130) | async def execute(self, required: list | None = None, **kwargs) -> Any:

FILE: app/tool/file_operators.py
  class FileOperator (line 16) | class FileOperator(Protocol):
    method read_file (line 19) | async def read_file(self, path: PathLike) -> str:
    method write_file (line 23) | async def write_file(self, path: PathLike, content: str) -> None:
    method is_directory (line 27) | async def is_directory(self, path: PathLike) -> bool:
    method exists (line 31) | async def exists(self, path: PathLike) -> bool:
    method run_command (line 35) | async def run_command(
  class LocalFileOperator (line 42) | class LocalFileOperator(FileOperator):
    method read_file (line 47) | async def read_file(self, path: PathLike) -> str:
    method write_file (line 54) | async def write_file(self, path: PathLike, content: str) -> None:
    method is_directory (line 61) | async def is_directory(self, path: PathLike) -> bool:
    method exists (line 65) | async def exists(self, path: PathLike) -> bool:
    method run_command (line 69) | async def run_command(
  class SandboxFileOperator (line 96) | class SandboxFileOperator(FileOperator):
    method __init__ (line 99) | def __init__(self):
    method _ensure_sandbox_initialized (line 102) | async def _ensure_sandbox_initialized(self):
    method read_file (line 107) | async def read_file(self, path: PathLike) -> str:
    method write_file (line 115) | async def write_file(self, path: PathLike, content: str) -> None:
    method is_directory (line 123) | async def is_directory(self, path: PathLike) -> bool:
    method exists (line 131) | async def exists(self, path: PathLike) -> bool:
    method run_command (line 139) | async def run_command(

FILE: app/tool/mcp.py
  class MCPClientTool (line 14) | class MCPClientTool(BaseTool):
    method execute (line 21) | async def execute(self, **kwargs) -> ToolResult:
  class MCPClients (line 37) | class MCPClients(ToolCollection):
    method __init__ (line 46) | def __init__(self):
    method connect_sse (line 50) | async def connect_sse(self, server_url: str, server_id: str = "") -> N...
    method connect_stdio (line 71) | async def connect_stdio(
    method _initialize_and_list_tools (line 97) | async def _initialize_and_list_tools(self, server_id: str) -> None:
    method _sanitize_tool_name (line 128) | def _sanitize_tool_name(self, name: str) -> str:
    method list_tools (line 147) | async def list_tools(self) -> ListToolsResult:
    method disconnect (line 155) | async def disconnect(self, server_id: str = "") -> None:

FILE: app/tool/planning.py
  class PlanningTool (line 14) | class PlanningTool(BaseTool):
    method execute (line 72) | async def execute(
    method _create_plan (line 120) | def _create_plan(
    method _update_plan (line 160) | def _update_plan(
    method _list_plans (line 209) | def _list_plans(self) -> ToolResult:
    method _get_plan (line 228) | def _get_plan(self, plan_id: Optional[str]) -> ToolResult:
    method _set_active_plan (line 244) | def _set_active_plan(self, plan_id: Optional[str]) -> ToolResult:
    method _mark_step (line 257) | def _mark_step(
    method _delete_plan (line 306) | def _delete_plan(self, plan_id: Optional[str]) -> ToolResult:
    method _format_plan (line 322) | def _format_plan(self, plan: Dict) -> str:

FILE: app/tool/python_execute.py
  class PythonExecute (line 9) | class PythonExecute(BaseTool):
    method _run_code (line 25) | def _run_code(self, code: str, result_dict: dict, safe_globals: dict) ...
    method execute (line 39) | async def execute(

FILE: app/tool/sandbox/sb_browser_tool.py
  class SandboxBrowserTool (line 36) | class SandboxBrowserTool(SandboxToolsBase):
    method __init__ (line 130) | def __init__(
    method _validate_base64_image (line 138) | def _validate_base64_image(
    method _execute_browser_action (line 195) | async def _execute_browser_action(
    method execute (line 278) | async def execute(
    method get_current_state (line 416) | async def get_current_state(
    method create_with_sandbox (line 448) | def create_with_sandbox(cls, sandbox: Sandbox) -> "SandboxBrowserTool":

FILE: app/tool/sandbox/sb_files_tool.py
  class SandboxFilesTool (line 28) | class SandboxFilesTool(SandboxToolsBase):
    method __init__ (line 78) | def __init__(
    method clean_path (line 86) | def clean_path(self, path: str) -> str:
    method _should_exclude_file (line 90) | def _should_exclude_file(self, rel_path: str) -> bool:
    method _file_exists (line 94) | def _file_exists(self, path: str) -> bool:
    method get_workspace_state (line 102) | async def get_workspace_state(self) -> dict:
    method execute (line 137) | async def execute(
    method _create_file (line 204) | async def _create_file(
    method _str_replace (line 250) | async def _str_replace(
    method _full_file_rewrite (line 297) | async def _full_file_rewrite(
    method _delete_file (line 337) | async def _delete_file(self, file_path: str) -> ToolResult:
    method cleanup (line 353) | async def cleanup(self):
    method create_with_context (line 357) | def create_with_context(cls, context: Context) -> "SandboxFilesTool[Co...

FILE: app/tool/sandbox/sb_shell_tool.py
  class SandboxShellTool (line 21) | class SandboxShellTool(SandboxToolsBase):
    method __init__ (line 84) | def __init__(
    method _ensure_session (line 92) | async def _ensure_session(self, session_name: str = "default") -> str:
    method _cleanup_session (line 104) | async def _cleanup_session(self, session_name: str):
    method _execute_raw_command (line 114) | async def _execute_raw_command(self, command: str) -> Dict[str, Any]:
    method _execute_command (line 138) | async def _execute_command(
    method _check_command_output (line 258) | async def _check_command_output(
    method _terminate_command (line 298) | async def _terminate_command(self, session_name: str) -> ToolResult:
    method _list_commands (line 322) | async def _list_commands(self) -> ToolResult:
    method execute (line 357) | async def execute(
    method cleanup (line 409) | async def cleanup(self):

FILE: app/tool/sandbox/sb_vision_tool.py
  class SandboxVisionTool (line 32) | class SandboxVisionTool(SandboxToolsBase):
    method __init__ (line 59) | def __init__(
    method compress_image (line 67) | def compress_image(self, image_bytes: bytes, mime_type: str, file_path...
    method execute (line 107) | async def execute(

FILE: app/tool/search/baidu_search.py
  class BaiduSearchEngine (line 8) | class BaiduSearchEngine(WebSearchEngine):
    method perform_search (line 9) | def perform_search(

FILE: app/tool/search/base.py
  class SearchItem (line 6) | class SearchItem(BaseModel):
    method __str__ (line 15) | def __str__(self) -> str:
  class WebSearchEngine (line 20) | class WebSearchEngine(BaseModel):
    method perform_search (line 25) | def perform_search(

FILE: app/tool/search/bing_search.py
  class BingSearchEngine (line 38) | class BingSearchEngine(WebSearchEngine):
    method __init__ (line 41) | def __init__(self, **data):
    method _search_sync (line 47) | def _search_sync(self, query: str, num_results: int = 10) -> List[Sear...
    method _parse_html (line 77) | def _parse_html(
    method perform_search (line 136) | def perform_search(

FILE: app/tool/search/duckduckgo_search.py
  class DuckDuckGoSearchEngine (line 8) | class DuckDuckGoSearchEngine(WebSearchEngine):
    method perform_search (line 9) | def perform_search(

FILE: app/tool/search/google_search.py
  class GoogleSearchEngine (line 8) | class GoogleSearchEngine(WebSearchEngine):
    method perform_search (line 9) | def perform_search(

FILE: app/tool/str_replace_editor.py
  function maybe_truncate (line 51) | def maybe_truncate(
  class StrReplaceEditor (line 60) | class StrReplaceEditor(BaseTool):
    method _get_operator (line 106) | def _get_operator(self) -> FileOperator:
    method execute (line 114) | async def execute(
    method validate_path (line 166) | async def validate_path(
    method view (line 196) | async def view(
    method _view_directory (line 219) | async def _view_directory(path: PathLike, operator: FileOperator) -> C...
    method _view_file (line 234) | async def _view_file(
    method str_replace (line 284) | async def str_replace(
    method insert (line 340) | async def insert(
    method undo_edit (line 394) | async def undo_edit(
    method _make_output (line 408) | def _make_output(

FILE: app/tool/terminate.py
  class Terminate (line 8) | class Terminate(BaseTool):
    method execute (line 23) | async def execute(self, status: str) -> str:

FILE: app/tool/tool_collection.py
  class ToolCollection (line 9) | class ToolCollection:
    class Config (line 12) | class Config:
    method __init__ (line 15) | def __init__(self, *tools: BaseTool):
    method __iter__ (line 19) | def __iter__(self):
    method to_params (line 22) | def to_params(self) -> List[Dict[str, Any]]:
    method execute (line 25) | async def execute(
    method execute_all (line 37) | async def execute_all(self) -> List[ToolResult]:
    method get_tool (line 48) | def get_tool(self, name: str) -> BaseTool:
    method add_tool (line 51) | def add_tool(self, tool: BaseTool):
    method add_tools (line 64) | def add_tools(self, *tools: BaseTool):

FILE: app/tool/web_search.py
  class SearchResult (line 22) | class SearchResult(BaseModel):
    method __str__ (line 38) | def __str__(self) -> str:
  class SearchMetadata (line 43) | class SearchMetadata(BaseModel):
  class SearchResponse (line 53) | class SearchResponse(ToolResult):
    method populate_output (line 65) | def populate_output(self) -> "SearchResponse":
  class WebContentFetcher (line 106) | class WebContentFetcher:
    method fetch_content (line 110) | async def fetch_content(url: str, timeout: int = 10) -> Optional[str]:
  class WebSearch (line 156) | class WebSearch(BaseTool):
    method execute (line 201) | async def execute(
    method _try_all_engines (line 290) | async def _try_all_engines(
    method _fetch_content_for_results (line 329) | async def _fetch_content_for_results(
    method _fetch_single_result_content (line 352) | async def _fetch_single_result_content(self, result: SearchResult) -> ...
    method _get_engine_order (line 360) | def _get_engine_order(self) -> List[str]:
    method _perform_search_with_engine (line 390) | async def _perform_search_with_engine(

FILE: app/utils/files_utils.py
  function should_exclude_file (line 36) | def should_exclude_file(rel_path: str) -> bool:
  function clean_path (line 63) | def clean_path(path: str, workspace_path: str = "/workspace") -> str:

FILE: main.py
  function main (line 8) | async def main():

FILE: protocol/a2a/app/agent.py
  class ResponseFormat (line 8) | class ResponseFormat(BaseModel):
  class A2AManus (line 15) | class A2AManus(Manus):
    method invoke (line 16) | async def invoke(self, query, sessionId) -> str:
    method stream (line 21) | async def stream(self, query: str) -> AsyncIterable[Dict[str, Any]]:
    method get_agent_response (line 25) | def get_agent_response(self, config, agent_response):

FILE: protocol/a2a/app/agent_executor.py
  class ManusExecutor (line 23) | class ManusExecutor(AgentExecutor):
    method __init__ (line 26) | def __init__(self, agent_factory: Callable[[], Awaitable[A2AManus]]):
    method execute (line 29) | async def execute(
    method _validate_request (line 66) | def _validate_request(self, context: RequestContext) -> bool:
    method cancel (line 69) | async def cancel(

FILE: protocol/a2a/app/main.py
  function main (line 27) | async def main(host: str = "localhost", port: int = 10000):
  function run_server (line 103) | def run_server(host: Optional[str] = "localhost", port: Optional[int] = ...

FILE: run_flow.py
  function run_flow (line 11) | async def run_flow():

FILE: run_mcp.py
  class MCPRunner (line 11) | class MCPRunner:
    method __init__ (line 14) | def __init__(self):
    method initialize (line 19) | async def initialize(
    method run_interactive (line 38) | async def run_interactive(self) -> None:
    method run_single_prompt (line 48) | async def run_single_prompt(self, prompt: str) -> None:
    method run_default (line 52) | async def run_default(self) -> None:
    method cleanup (line 63) | async def cleanup(self) -> None:
  function parse_args (line 69) | def parse_args() -> argparse.Namespace:
  function run_mcp (line 91) | async def run_mcp() -> None:

FILE: sandbox_main.py
  function main (line 8) | async def main():

FILE: tests/sandbox/test_client.py
  function local_client (line 13) | async def local_client() -> AsyncGenerator[LocalSandboxClient, None]:
  function temp_dir (line 23) | def temp_dir() -> Path:
  function test_sandbox_creation (line 30) | async def test_sandbox_creation(local_client: LocalSandboxClient):
  function test_local_command_execution (line 45) | async def test_local_command_execution(local_client: LocalSandboxClient):
  function test_local_file_operations (line 57) | async def test_local_file_operations(local_client: LocalSandboxClient, t...
  function test_local_volume_binding (line 81) | async def test_local_volume_binding(local_client: LocalSandboxClient, te...
  function test_local_error_handling (line 96) | async def test_local_error_handling(local_client: LocalSandboxClient):

FILE: tests/sandbox/test_docker_terminal.py
  function docker_client (line 11) | def docker_client():
  function docker_container (line 17) | async def docker_container(docker_client):
  function terminal (line 31) | async def terminal(docker_container):
  class TestAsyncDockerizedTerminal (line 44) | class TestAsyncDockerizedTerminal:
    method test_basic_command_execution (line 48) | async def test_basic_command_execution(self, terminal):
    method test_environment_variables (line 54) | async def test_environment_variables(self, terminal):
    method test_working_directory (line 60) | async def test_working_directory(self, terminal):
    method test_command_timeout (line 66) | async def test_command_timeout(self, docker_container):
    method test_multiple_commands (line 77) | async def test_multiple_commands(self, terminal):
    method test_session_cleanup (line 85) | async def test_session_cleanup(self, docker_container):
  function pytest_configure (line 97) | def pytest_configure(config):

FILE: tests/sandbox/test_sandbox.py
  function sandbox_config (line 8) | def sandbox_config():
  function sandbox (line 20) | async def sandbox(sandbox_config):
  function test_sandbox_working_directory (line 31) | async def test_sandbox_working_directory(sandbox):
  function test_sandbox_file_operations (line 38) | async def test_sandbox_file_operations(sandbox):
  function test_sandbox_python_execution (line 50) | async def test_sandbox_python_execution(sandbox):
  function test_sandbox_file_persistence (line 70) | async def test_sandbox_file_persistence(sandbox):
  function test_sandbox_python_environment (line 90) | async def test_sandbox_python_environment(sandbox):
  function test_sandbox_network_access (line 109) | async def test_sandbox_network_access(sandbox):
  function test_sandbox_cleanup (line 121) | async def test_sandbox_cleanup(sandbox_config):
  function test_sandbox_error_handling (line 141) | async def test_sandbox_error_handling():

FILE: tests/sandbox/test_sandbox_manager.py
  function manager (line 13) | async def manager() -> AsyncGenerator[SandboxManager, None]:
  function temp_file (line 27) | def temp_file():
  function test_create_sandbox (line 40) | async def test_create_sandbox(manager):
  function test_max_sandboxes_limit (line 54) | async def test_max_sandboxes_limit(manager):
  function test_get_nonexistent_sandbox (line 86) | async def test_get_nonexistent_sandbox(manager):
  function test_sandbox_cleanup (line 93) | async def test_sandbox_cleanup(manager):
  function test_idle_sandbox_cleanup (line 104) | async def test_idle_sandbox_cleanup(manager):
  function test_manager_cleanup (line 121) | async def test_manager_cleanup(manager):