feat(staged): forward tool call raw_input params through ACP driver to DB

The ACP protocol provides raw_input on ToolCall and ToolCallUpdate, but
it was never extracted or forwarded. This adds raw_input through the full
pipeline: LiveAction enum, MessageWriter trait, and DB writer. When
raw_input is present, tool calls are stored as JSON {"name", "input"}
which the frontend already knows how to parse.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: matt2e

apps/staged/src-tauri/examples/acp_stream_probe.rs

@@ -68,7 +68,12 @@ impl MessageWriter for ProbeWriter {
         println!("[probe] finalize");
     }
 
-    async fn record_tool_call(&self, tool_call_id: &str, title: &str) {
+    async fn record_tool_call(
+        &self,
+        tool_call_id: &str,
+        title: &str,
+        _raw_input: Option<&serde_json::Value>,
+    ) {
         let mut state = self.state.lock().expect("probe state lock poisoned");
         state.total_tool_calls += 1;
         let count_for_id = *state
@@ -85,7 +90,12 @@ impl MessageWriter for ProbeWriter {
         );
     }
 
-    async fn update_tool_call_title(&self, tool_call_id: &str, title: &str) {
+    async fn update_tool_call_title(
+        &self,
+        tool_call_id: &str,
+        title: &str,
+        _raw_input: Option<&serde_json::Value>,
+    ) {
         let mut state = self.state.lock().expect("probe state lock poisoned");
         state.total_tool_title_updates += 1;
         println!(

apps/staged/src-tauri/src/agent/writer.rs

@@ -53,6 +53,17 @@ fn sanitize_title(title: &str) -> String {
     title.replace('`', "")
 }
 
+/// Format a tool call for storage. When `raw_input` is present, produces a JSON
+/// object `{"name": title, "input": raw_input}` that the frontend can parse to
+/// display structured tool call info. Without raw_input, falls back to the plain
+/// title string.
+fn format_tool_call_content(title: &str, raw_input: Option<&serde_json::Value>) -> String {
+    match raw_input {
+        Some(input) => serde_json::json!({ "name": title, "input": input }).to_string(),
+        None => title.to_string(),
+    }
+}
+
 impl MessageWriter {
     pub fn new(session_id: String, store: Arc<Store>) -> Self {
         Self {
@@ -98,22 +109,28 @@ impl MessageWriter {
 
     /// Record a tool call. Finalizes any in-progress assistant text first
     /// to maintain correct message ordering.
-    pub async fn record_tool_call(&self, tool_call_id: &str, title: &str) {
+    pub async fn record_tool_call(
+        &self,
+        tool_call_id: &str,
+        title: &str,
+        raw_input: Option<&serde_json::Value>,
+    ) {
         self.finalize().await;
         *self.current_tool_result_msg_id.lock().await = None;
 
         let title = sanitize_title(title);
+        let content = format_tool_call_content(&title, raw_input);
 
         // Some providers may resend ToolCall for the same ID while streaming.
         // Treat those as updates to the existing row.
         if let Some(&row_id) = self.tool_call_rows.lock().await.get(tool_call_id) {
-            let _ = self.store.update_message_content(row_id, &title);
+            let _ = self.store.update_message_content(row_id, &content);
             return;
         }
 
         match self
             .store
-            .add_session_message(&self.session_id, MessageRole::ToolCall, &title)
+            .add_session_message(&self.session_id, MessageRole::ToolCall, &content)
         {
             Ok(id) => {
                 self.tool_call_rows
@@ -125,12 +142,18 @@ impl MessageWriter {
         }
     }
 
-    /// Update a previously recorded tool call's title.
-    pub async fn update_tool_call_title(&self, tool_call_id: &str, title: &str) {
+    /// Update a previously recorded tool call's title and/or raw input.
+    pub async fn update_tool_call_title(
+        &self,
+        tool_call_id: &str,
+        title: &str,
+        raw_input: Option<&serde_json::Value>,
+    ) {
         let title = sanitize_title(title);
+        let content = format_tool_call_content(&title, raw_input);
         let rows = self.tool_call_rows.lock().await;
         if let Some(&row_id) = rows.get(tool_call_id) {
-            let _ = self.store.update_message_content(row_id, &title);
+            let _ = self.store.update_message_content(row_id, &content);
         }
     }
 
@@ -208,12 +231,23 @@ impl acp_client::MessageWriter for MessageWriter {
         self.finalize().await
     }
 
-    async fn record_tool_call(&self, tool_call_id: &str, title: &str) {
-        self.record_tool_call(tool_call_id, title).await
+    async fn record_tool_call(
+        &self,
+        tool_call_id: &str,
+        title: &str,
+        raw_input: Option<&serde_json::Value>,
+    ) {
+        self.record_tool_call(tool_call_id, title, raw_input).await
     }
 
-    async fn update_tool_call_title(&self, tool_call_id: &str, title: &str) {
-        self.update_tool_call_title(tool_call_id, title).await
+    async fn update_tool_call_title(
+        &self,
+        tool_call_id: &str,
+        title: &str,
+        raw_input: Option<&serde_json::Value>,
+    ) {
+        self.update_tool_call_title(tool_call_id, title, raw_input)
+            .await
     }
 
     async fn record_tool_result(&self, content: &str) {
@@ -241,7 +275,9 @@ mod tests {
     async fn record_tool_result_updates_existing_row_for_streaming_updates() {
         let (store, session_id, writer) = setup_writer();
 
-        writer.record_tool_call("tc-1", "Run echo hello").await;
+        writer
+            .record_tool_call("tc-1", "Run echo hello", None)
+            .await;
         writer.record_tool_result("first chunk").await;
         writer.record_tool_result("second chunk").await;
 
@@ -258,8 +294,12 @@ mod tests {
     async fn record_tool_call_same_id_updates_instead_of_inserting() {
         let (store, session_id, writer) = setup_writer();
 
-        writer.record_tool_call("tc-dup", "Run first title").await;
-        writer.record_tool_call("tc-dup", "Run updated title").await;
+        writer
+            .record_tool_call("tc-dup", "Run first title", None)
+            .await;
+        writer
+            .record_tool_call("tc-dup", "Run updated title", None)
+            .await;
 
         let messages = store
             .get_session_messages(&session_id)

crates/acp-client/src/driver.rs

@@ -48,11 +48,21 @@ pub trait MessageWriter: Send + Sync {
     /// Flush all buffered text and close the current message block.
     async fn finalize(&self);
 
-    /// Record a tool call with its ID and title.
-    async fn record_tool_call(&self, tool_call_id: &str, title: &str);
+    /// Record a tool call with its ID, title, and optional raw input parameters.
+    async fn record_tool_call(
+        &self,
+        tool_call_id: &str,
+        title: &str,
+        raw_input: Option<&serde_json::Value>,
+    );
 
-    /// Update a previously recorded tool call's title.
-    async fn update_tool_call_title(&self, tool_call_id: &str, title: &str);
+    /// Update a previously recorded tool call's title and/or raw input.
+    async fn update_tool_call_title(
+        &self,
+        tool_call_id: &str,
+        title: &str,
+        raw_input: Option<&serde_json::Value>,
+    );
 
     /// Record the result/output of a tool call.
     async fn record_tool_result(&self, content: &str);
@@ -839,10 +849,12 @@ impl agent_client_protocol::Client for AcpNotificationHandler {
             RecordToolCall {
                 id: String,
                 title: String,
+                raw_input: Option<serde_json::Value>,
             },
             ToolCallUpdate {
                 id: String,
                 title: Option<String>,
+                raw_input: Option<serde_json::Value>,
                 result: Option<String>,
             },
             Ignore,
@@ -948,19 +960,22 @@ impl agent_client_protocol::Client for AcpNotificationHandler {
                         SessionUpdate::ToolCall(tool_call) => LiveAction::RecordToolCall {
                             id: tool_call.tool_call_id.0.to_string(),
                             title: tool_call.title.clone(),
+                            raw_input: tool_call.raw_input.clone(),
                         },
                         SessionUpdate::ToolCallUpdate(update) => {
                             let tc_id = update.tool_call_id.0.to_string();
                             let title = update.fields.title.clone();
+                            let raw_input = update.fields.raw_input.clone();
                             let result = update
                                 .fields
                                 .content
                                 .as_ref()
                                 .and_then(|c| extract_content_preview(c));
-                            if title.is_some() || result.is_some() {
+                            if title.is_some() || raw_input.is_some() || result.is_some() {
                                 LiveAction::ToolCallUpdate {
                                     id: tc_id,
                                     title,
+                                    raw_input,
                                     result,
                                 }
                             } else {
@@ -979,12 +994,25 @@ impl agent_client_protocol::Client for AcpNotificationHandler {
             LiveAction::AppendText(text) => {
                 self.writer.append_text(&text).await;
             }
-            LiveAction::RecordToolCall { id, title } => {
-                self.writer.record_tool_call(&id, &title).await;
+            LiveAction::RecordToolCall {
+                id,
+                title,
+                raw_input,
+            } => {
+                self.writer
+                    .record_tool_call(&id, &title, raw_input.as_ref())
+                    .await;
             }
-            LiveAction::ToolCallUpdate { id, title, result } => {
+            LiveAction::ToolCallUpdate {
+                id,
+                title,
+                raw_input,
+                result,
+            } => {
                 if let Some(title) = title {
-                    self.writer.update_tool_call_title(&id, &title).await;
+                    self.writer
+                        .update_tool_call_title(&id, &title, raw_input.as_ref())
+                        .await;
                 }
                 if let Some(preview) = result {
                     self.writer.record_tool_result(&preview).await;
@@ -1253,12 +1281,22 @@ impl MessageWriter for BasicMessageWriter {
         // Nothing to do for basic implementation
     }
 
-    async fn record_tool_call(&self, _tool_call_id: &str, title: &str) {
+    async fn record_tool_call(
+        &self,
+        _tool_call_id: &str,
+        title: &str,
+        _raw_input: Option<&serde_json::Value>,
+    ) {
         let mut current = self.text.lock().await;
         current.push_str(&format!("\n[Tool: {}]\n", title));
     }
 
-    async fn update_tool_call_title(&self, _tool_call_id: &str, _title: &str) {
+    async fn update_tool_call_title(
+        &self,
+        _tool_call_id: &str,
+        _title: &str,
+        _raw_input: Option<&serde_json::Value>,
+    ) {
         // Nothing to do for basic implementation
     }