Method execute

crates/opencode-tool/src/codesearch.rs:91–175

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

    }

    async fn execute(
        &self,
        args: serde_json::Value,
        ctx: ToolContext,
    ) -> Result<ToolResult, ToolError> {
        let params: CodeSearchParams = serde_json::from_value(args)
            .map_err(|e| ToolError::InvalidArguments(format!("Invalid parameters: {}", e)))?;

        ctx.ask_permission(
            PermissionRequest::new("codesearch")
                .with_pattern(&params.query)
                .always_allow(),
        )
        .await?;

        let tokens_num = params.tokens_num.clamp(1000, 50000);
        let query = params.query.clone();

        let client = Client::builder()
            .timeout(std::time::Duration::from_secs(30))
            .build()
            .map_err(|e| {
                ToolError::ExecutionError(format!("Failed to create HTTP client: {}", e))
            })?;

        let request = McpRequest {
            jsonrpc: "2.0".to_string(),
            id: 1,
            method: "tools/call".to_string(),
            params: McpParams {
                name: "get_code_context_exa".to_string(),
                arguments: McpArguments {
                    query: query.clone(),
                    tokens_num,
                },
            },
        };

        let abort_token = ctx.abort.clone();

        let request_future = async {
            client
                .post(EXA_MCP_URL)
                .header("Content-Type", "application/json")
                .header("Accept", "application/json, text/event-stream")
                .json(&request)
                .send()
                .await
                .map_err(|e| ToolError::ExecutionError(format!("HTTP request failed: {}", e)))
        };

        tokio::select! {
            result = request_future => {
                let response = result?;

                if !response.status().is_success() {
                    let status = response.status();
                    let error_text = response.text().await.unwrap_or_default();