diff --git a/crates/ide-agent/src/acp/mod.rs b/crates/ide-agent/src/acp/mod.rs index 85b82a9a0..6f3689064 100644 --- a/crates/ide-agent/src/acp/mod.rs +++ b/crates/ide-agent/src/acp/mod.rs @@ -322,6 +322,13 @@ impl Handler for Dialect { } self.inner.on_request(method, params) } + + fn on_request_raw(&self, method: &str, params: Value, raw: &[u8]) -> Result)> { + if self.v2() && method == "session/request_permission" { + return self.on_request_with_data(method, params); + } + self.inner.on_request_raw(method, params, raw) + } } /// A v2 permission request with the v1 `toolCall` (its subject's, titled with the request's title). diff --git a/crates/ide-agent/src/elicitation.rs b/crates/ide-agent/src/elicitation.rs index cd809dc07..b2f1e0d43 100644 --- a/crates/ide-agent/src/elicitation.rs +++ b/crates/ide-agent/src/elicitation.rs @@ -2,6 +2,8 @@ //! user's answer as the `elicitation/create` response. use crate::model::{AgentForm, AgentFormField, AgentFormFieldKind, AgentFormOption, AgentPermissionOption}; +use serde::Deserialize; +use serde::de::{Deserializer, IgnoredAny, MapAccess, Visitor}; use serde_json::{Map, Value, json}; /// The reply that declines the form; a JSON object of field name to values accepts it, and @@ -27,6 +29,47 @@ pub(crate) fn form_of(params: &Value) -> Result { Ok(AgentForm { fields }) } +/// Orders the fields as the request's schema lists them: `Value` keeps object keys sorted, and +/// the agent's order is the one its form reads in. +pub(crate) fn in_schema_order(form: &mut AgentForm, raw: &[u8]) { + #[derive(Deserialize)] + struct Request { + params: Params, + } + #[derive(Deserialize)] + struct Params { + #[serde(rename = "requestedSchema")] + schema: Schema, + } + #[derive(Deserialize)] + struct Schema { + properties: Keys, + } + struct Keys(Vec); + impl<'de> Deserialize<'de> for Keys { + fn deserialize>(deserializer: D) -> Result { + struct Visit; + impl<'de> Visitor<'de> for Visit { + type Value = Keys; + fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + f.write_str("an object") + } + fn visit_map>(self, mut map: A) -> Result { + let mut keys = Vec::new(); + while let Some((key, IgnoredAny)) = map.next_entry::()? { + keys.push(key); + } + Ok(Keys(keys)) + } + } + deserializer.deserialize_map(Visit) + } + } + let Ok(request) = serde_json::from_slice::(raw) else { return }; + let order = request.params.schema.properties.0; + form.fields.sort_by_key(|field| order.iter().position(|name| *name == field.name).unwrap_or(usize::MAX)); +} + fn field(name: &str, property: &Value, required: bool) -> Result { let text = |key: &str| property.get(key).and_then(Value::as_str).unwrap_or_default().trim().to_owned(); let number = |key: &str| property.get(key).and_then(Value::as_f64); @@ -176,6 +219,18 @@ mod tests { }) } + #[test] + fn fields_follow_the_schema_order() { + let raw = br#"{ "jsonrpc": "2.0", "id": 3, "method": "elicitation/create", "params": { "mode": "form", + "requestedSchema": { "type": "object", "properties": { + "strategy": { "type": "string" }, "tests": { "type": "boolean" }, "note": { "type": "string" } + } } } }"#; + let params = serde_json::from_slice::(raw).unwrap()["params"].take(); + let mut form = form_of(¶ms).unwrap(); + in_schema_order(&mut form, raw); + assert_eq!(form.fields.iter().map(|f| f.name.as_str()).collect::>(), ["strategy", "tests", "note"]); + } + #[test] fn reads_choices_and_text_fields() { let form = form_of(&ask()).unwrap(); diff --git a/crates/ide-agent/src/lib.rs b/crates/ide-agent/src/lib.rs index bf22a2aa7..747566b03 100644 --- a/crates/ide-agent/src/lib.rs +++ b/crates/ide-agent/src/lib.rs @@ -2555,8 +2555,11 @@ impl Task { /// An agent's form (`elicitation/create`): asked in the conversation like a permission /// request, and answered with its values, declined or cancelled. Blocks like `ask_permission`. - fn elicit(self: &Arc, params: &Value) -> Result { - let form = elicitation::form_of(params)?; + fn elicit(self: &Arc, params: &Value, raw: Option<&[u8]>) -> Result { + let mut form = elicitation::form_of(params)?; + if let Some(raw) = raw { + elicitation::in_schema_order(&mut form, raw); + } let id = self.next_permission.fetch_add(1, Ordering::Relaxed); let message = params.get("message").and_then(Value::as_str).unwrap_or_default().trim().to_owned(); let (tx, rx) = std::sync::mpsc::channel(); @@ -2656,10 +2659,18 @@ impl Handler for Client { let task = self.task.upgrade().ok_or((codes::INTERNAL_ERROR, "task closed".to_owned()))?; match method { "session/request_permission" => Ok(task.ask_permission(¶ms)), - "elicitation/create" => task.elicit(¶ms).map_err(|e| (codes::INVALID_PARAMS, e)), + "elicitation/create" => task.elicit(¶ms, None).map_err(|e| (codes::INVALID_PARAMS, e)), _ => Err((codes::METHOD_NOT_FOUND, format!("unsupported method {method}"))), } } + + fn on_request_raw(&self, method: &str, params: Value, raw: &[u8]) -> Result)> { + if method != "elicitation/create" { + return self.on_request_with_data(method, params); + } + let task = self.task.upgrade().ok_or((codes::INTERNAL_ERROR, "task closed".to_owned(), None))?; + task.elicit(¶ms, Some(raw)).map_err(|e| (codes::INVALID_PARAMS, e, None)) + } } /// The prompt trimmed, or `None` when there is nothing to send. diff --git a/crates/ide-jsonrpc/src/lib.rs b/crates/ide-jsonrpc/src/lib.rs index 13b841103..eb539e1c8 100644 --- a/crates/ide-jsonrpc/src/lib.rs +++ b/crates/ide-jsonrpc/src/lib.rs @@ -215,12 +215,18 @@ pub trait Handler: Send + Sync + 'static { /// Respond to a server→client request (e.g. `workspace/configuration`). fn on_request(&self, method: &str, params: Value) -> Result; - /// [`on_request`](Self::on_request) for handlers whose errors carry `data`. This is the - /// one the connection calls. + /// [`on_request`](Self::on_request) for handlers whose errors carry `data`. fn on_request_with_data(&self, method: &str, params: Value) -> Result)> { self.on_request(method, params).map_err(|(code, message)| (code, message, None)) } + /// [`on_request_with_data`](Self::on_request_with_data) with the request as received, for + /// handlers that need what `Value` drops, such as the order of an object's keys. This is the + /// one the connection calls. + fn on_request_raw(&self, method: &str, params: Value, _raw: &[u8]) -> Result)> { + self.on_request_with_data(method, params) + } + /// Called once the response to a `method` request is queued: what it sends follows the response. fn after_response(&self, _method: &str) {} @@ -577,8 +583,8 @@ impl Peer { tracing::error!("jsonrpc notification handler panicked on {method}"); } } - Incoming::Request(id, method, params) => { - runtime.spawn(handle_request(inner.clone(), handler.clone(), id, method, params)); + Incoming::Request(id, method, params, raw) => { + runtime.spawn(handle_request(inner.clone(), handler.clone(), id, method, params, raw)); } Incoming::Response(tx, result) => { let _ = tx.send(result); @@ -761,14 +767,21 @@ fn parse_id(id: &Value) -> Option { enum Incoming { Notification(String, Value), - Request(Value, String, Value), + Request(Value, String, Value, Arc<[u8]>), Response(oneshot::Sender>, Result), } -async fn handle_request(inner: Arc, handler: Arc, id: Value, method: String, params: Value) { +async fn handle_request( + inner: Arc, + handler: Arc, + id: Value, + method: String, + params: Value, + raw: Arc<[u8]>, +) { let m = method.clone(); let h = handler.clone(); - let result = tokio::task::spawn_blocking(move || h.on_request_with_data(&m, params)).await; + let result = tokio::task::spawn_blocking(move || h.on_request_raw(&m, params, &raw)).await; let reply = match result { Ok(Ok(result)) => json!({ "jsonrpc": "2.0", "id": id, "result": result }), Ok(Err((code, message, data))) => { @@ -808,7 +821,7 @@ fn dispatch(inner: &Arc, handler: &dyn Handler, notif_tx: &std::sync::mps let params = obj.remove("params").unwrap_or(Value::Null); match id { Some(id) if !id.is_null() => { - let _ = notif_tx.send(Incoming::Request(id, method, params)); + let _ = notif_tx.send(Incoming::Request(id, method, params, Arc::from(body))); } _ => { let _ = notif_tx.send(Incoming::Notification(method, params));