Method execute

crates/opencode-tool/src/websearch.rs:154–230

(
        &self,
        args: serde_json::Value,
        ctx: ToolContext,
    )

    }

    async fn execute(
        &self,
        args: serde_json::Value,
        ctx: ToolContext,
    ) -> Result<ToolResult, ToolError> {
        let input: WebSearchInput =
            serde_json::from_value(args).map_err(|e| ToolError::InvalidArguments(e.to_string()))?;

        ctx.ask_permission(
            crate::PermissionRequest::new("websearch")
                .with_pattern(&input.query)
                .with_metadata("query", serde_json::Value::String(input.query.clone()))
                .with_metadata(
                    "numResults",
                    serde_json::Value::Number(input.num_results.into()),
                )
                .always_allow(),
        )
        .await?;

        let search_request = McpSearchRequest {
            jsonrpc: "2.0".to_string(),
            id: 1,
            method: "tools/call".to_string(),
            params: McpSearchParams {
                name: "web_search_exa".to_string(),
                arguments: McpSearchArguments {
                    query: input.query.clone(),
                    search_type: input.search_type.or(Some("auto".to_string())),
                    num_results: Some(input.num_results),
                    livecrawl: input.livecrawl.or(Some("fallback".to_string())),
                    context_max_characters: input.context_max_characters,
                },
            },
        };

        let response = self
            .client
            .post(format!("{}/mcp", API_BASE_URL))
            .header("Accept", "application/json, text/event-stream")
            .header("Content-Type", "application/json")
            .json(&search_request)
            .timeout(std::time::Duration::from_secs(25))
            .send()
            .await
            .map_err(|e| {
                if e.is_timeout() {
                    ToolError::ExecutionError("Search request timed out".to_string())
                } else {
                    ToolError::ExecutionError(format!("Search request failed: {}", e))
                }
            })?;

        let status = response.status();
        let response_text = response
            .text()
            .await
            .map_err(|e| ToolError::ExecutionError(format!("Failed to read response: {}", e)))?;