Method send_request

crates/opencode-mcp/src/client.rs:357–402

(
        &self,
        method: &str,
        params: Option<serde_json::Value>,
    )

        self.request_id.fetch_add(1, Ordering::SeqCst) + 1
    }
    async fn send_request(
        &self,
        method: &str,
        params: Option<serde_json::Value>,
    ) -> Result<JsonRpcResponse, McpClientError> {
        let id = self.next_id().await;
        let request = JsonRpcRequest::new(id, method);
        let request = if let Some(p) = params {
            request.with_params(p)
        } else {
            request
        };

        // Send under the lock, then release it.
        {
            let guard = self.transport.lock().await;
            let transport = guard.as_ref().ok_or(McpClientError::NotInitialized)?;
            transport.send(&request).await?;
        }

        // Re-acquire for receive.
        let guard = self.transport.lock().await;
        let transport = guard.as_ref().ok_or(McpClientError::NotInitialized)?;

        let response = loop {
            match transport.receive().await? {
                Some(JsonRpcMessage::Response(resp)) if resp.id == id => break resp,
                Some(JsonRpcMessage::Notification(notif)) => {
                    self.handle_notification(notif).await;
                    continue;
                }
                Some(_) => continue,
                None => {
                    return Err(McpClientError::TransportError(
                        "Connection closed".to_string(),
                    ));
                }
            }
        };

        if let Some(error) = response.error {
            return Err(McpClientError::ServerError(error.message));
        }

        Ok(response)
    }

    async fn send_request_with_progress_timeout(
        &self,