@team-agent/installer 0.5.42 → 0.5.44

package/crates/team-agent/src/lifecycle/tests/main_preserved.rs

@@ -1,9 +1,9 @@
-use super::*;
 use super::agent_ops::lanea_team_ws;
 use super::lane_ops::{LaneSpawns, LaneTransport};
 use super::launch_spawn::{
     restart_ws_two_resumable_workers, seed_healthy_coordinator, DELEG_ROLE_ALPHA, DELEG_ROLE_BRAVO,
 };
+use super::*;
 
 type RecordedSpawns = LaneSpawns;
 
@@ -46,56 +46,118 @@ impl crate::transport::Transport for SessionProbeRecordingTransport {
     fn kind(&self) -> crate::transport::BackendKind {
         crate::transport::BackendKind::Tmux
     }
-    fn spawn_first(&self, session: &crate::transport::SessionName, window: &crate::transport::WindowName, argv: &[String], _cwd: &std::path::Path, _env: &std::collections::BTreeMap<String, String>) -> Result<crate::transport::SpawnResult, crate::transport::TransportError> {
-        self.spawns.lock().unwrap().push(("spawn_first".to_string(), argv.to_vec()));
+    fn spawn_first(
+        &self,
+        session: &crate::transport::SessionName,
+        window: &crate::transport::WindowName,
+        argv: &[String],
+        _cwd: &std::path::Path,
+        _env: &std::collections::BTreeMap<String, String>,
+    ) -> Result<crate::transport::SpawnResult, crate::transport::TransportError> {
+        self.spawns
+            .lock()
+            .unwrap()
+            .push(("spawn_first".to_string(), argv.to_vec()));
         self.spawn_targets.lock().unwrap().push((
             session.as_str().to_string(),
             window.as_str().to_string(),
             "%0".to_string(),
         ));
-        Ok(crate::transport::SpawnResult { pane_id: crate::transport::PaneId::new("%0"), session: session.clone(), window: window.clone(), child_pid: Some(6856) })
+        Ok(crate::transport::SpawnResult {
+            pane_id: crate::transport::PaneId::new("%0"),
+            session: session.clone(),
+            window: window.clone(),
+            child_pid: Some(6856),
+        })
     }
-    fn spawn_into(&self, session: &crate::transport::SessionName, window: &crate::transport::WindowName, argv: &[String], _cwd: &std::path::Path, _env: &std::collections::BTreeMap<String, String>) -> Result<crate::transport::SpawnResult, crate::transport::TransportError> {
-        self.spawns.lock().unwrap().push(("spawn_into".to_string(), argv.to_vec()));
+    fn spawn_into(
+        &self,
+        session: &crate::transport::SessionName,
+        window: &crate::transport::WindowName,
+        argv: &[String],
+        _cwd: &std::path::Path,
+        _env: &std::collections::BTreeMap<String, String>,
+    ) -> Result<crate::transport::SpawnResult, crate::transport::TransportError> {
+        self.spawns
+            .lock()
+            .unwrap()
+            .push(("spawn_into".to_string(), argv.to_vec()));
         let pane = format!("%{}", window.as_str());
         self.spawn_targets.lock().unwrap().push((
             session.as_str().to_string(),
             window.as_str().to_string(),
             pane.clone(),
         ));
-        Ok(crate::transport::SpawnResult { pane_id: crate::transport::PaneId::new(pane), session: session.clone(), window: window.clone(), child_pid: Some(6856) })
+        Ok(crate::transport::SpawnResult {
+            pane_id: crate::transport::PaneId::new(pane),
+            session: session.clone(),
+            window: window.clone(),
+            child_pid: Some(6856),
+        })
     }
-    fn inject(&self, _t: &crate::transport::Target, _p: &crate::transport::InjectPayload, _s: crate::transport::Key, _b: bool) -> Result<crate::transport::InjectReport, crate::transport::TransportError> {
+    fn inject(
+        &self,
+        _t: &crate::transport::Target,
+        _p: &crate::transport::InjectPayload,
+        _s: crate::transport::Key,
+        _b: bool,
+    ) -> Result<crate::transport::InjectReport, crate::transport::TransportError> {
         unimplemented!("not reached by start_agent respawn")
     }
-    fn send_keys(&self, _t: &crate::transport::Target, _k: &[crate::transport::Key]) -> Result<(), crate::transport::TransportError> {
+    fn send_keys(
+        &self,
+        _t: &crate::transport::Target,
+        _k: &[crate::transport::Key],
+    ) -> Result<(), crate::transport::TransportError> {
         unimplemented!("not reached")
     }
-    fn capture(&self, _t: &crate::transport::Target, _r: crate::transport::CaptureRange) -> Result<crate::transport::CapturedText, crate::transport::TransportError> {
+    fn capture(
+        &self,
+        _t: &crate::transport::Target,
+        _r: crate::transport::CaptureRange,
+    ) -> Result<crate::transport::CapturedText, crate::transport::TransportError> {
         Ok(crate::transport::CapturedText {
             text: String::new(),
             range: crate::transport::CaptureRange::Full,
         })
     }
-    fn query(&self, _t: &crate::transport::Target, _f: crate::transport::PaneField) -> Result<Option<String>, crate::transport::TransportError> {
+    fn query(
+        &self,
+        _t: &crate::transport::Target,
+        _f: crate::transport::PaneField,
+    ) -> Result<Option<String>, crate::transport::TransportError> {
         unimplemented!("not reached")
     }
-    fn liveness(&self, p: &crate::transport::PaneId) -> Result<crate::model::enums::PaneLiveness, crate::transport::TransportError> {
+    fn liveness(
+        &self,
+        p: &crate::transport::PaneId,
+    ) -> Result<crate::model::enums::PaneLiveness, crate::transport::TransportError> {
         let killed = self.killed_panes.lock().unwrap();
         if killed.contains(p.as_str()) {
             return Ok(crate::model::enums::PaneLiveness::Dead);
         }
         Ok(crate::model::enums::PaneLiveness::Live)
     }
-    fn has_pane(&self, p: &crate::transport::PaneId) -> Result<Option<bool>, crate::transport::TransportError> {
+    fn has_pane(
+        &self,
+        p: &crate::transport::PaneId,
+    ) -> Result<Option<bool>, crate::transport::TransportError> {
         let killed = self.killed_panes.lock().unwrap();
         Ok(Some(!killed.contains(p.as_str())))
     }
-    fn kill_pane(&self, p: &crate::transport::PaneId) -> Result<(), crate::transport::TransportError> {
-        self.killed_panes.lock().unwrap().insert(p.as_str().to_string());
+    fn kill_pane(
+        &self,
+        p: &crate::transport::PaneId,
+    ) -> Result<(), crate::transport::TransportError> {
+        self.killed_panes
+            .lock()
+            .unwrap()
+            .insert(p.as_str().to_string());
         Ok(())
     }
-    fn list_targets(&self) -> Result<Vec<crate::transport::PaneInfo>, crate::transport::TransportError> {
+    fn list_targets(
+        &self,
+    ) -> Result<Vec<crate::transport::PaneInfo>, crate::transport::TransportError> {
         Ok(self
             .spawn_targets
             .lock()
@@ -116,23 +178,47 @@ impl crate::transport::Transport for SessionProbeRecordingTransport {
             })
             .collect())
     }
-    fn has_session(&self, _s: &crate::transport::SessionName) -> Result<bool, crate::transport::TransportError> {
+    fn has_session(
+        &self,
+        _s: &crate::transport::SessionName,
+    ) -> Result<bool, crate::transport::TransportError> {
         Ok(self.session_exists)
     }
-    fn list_windows(&self, _s: &crate::transport::SessionName) -> Result<Vec<crate::transport::WindowName>, crate::transport::TransportError> {
+    fn list_windows(
+        &self,
+        _s: &crate::transport::SessionName,
+    ) -> Result<Vec<crate::transport::WindowName>, crate::transport::TransportError> {
         // a dead server has no windows; a live one has the agent window.
-        Ok(if self.session_exists { vec![crate::transport::WindowName::new("alpha")] } else { Vec::new() })
+        Ok(if self.session_exists {
+            vec![crate::transport::WindowName::new("alpha")]
+        } else {
+            Vec::new()
+        })
     }
-    fn set_session_env(&self, _s: &crate::transport::SessionName, _k: &str, _v: &str) -> Result<crate::transport::SetEnvOutcome, crate::transport::TransportError> {
+    fn set_session_env(
+        &self,
+        _s: &crate::transport::SessionName,
+        _k: &str,
+        _v: &str,
+    ) -> Result<crate::transport::SetEnvOutcome, crate::transport::TransportError> {
         unimplemented!("not reached")
     }
-    fn kill_session(&self, _s: &crate::transport::SessionName) -> Result<(), crate::transport::TransportError> {
+    fn kill_session(
+        &self,
+        _s: &crate::transport::SessionName,
+    ) -> Result<(), crate::transport::TransportError> {
         unimplemented!("not reached")
     }
-    fn kill_window(&self, _t: &crate::transport::Target) -> Result<(), crate::transport::TransportError> {
+    fn kill_window(
+        &self,
+        _t: &crate::transport::Target,
+    ) -> Result<(), crate::transport::TransportError> {
         Ok(())
     }
-    fn attach_session(&self, _s: &crate::transport::SessionName) -> Result<crate::transport::AttachOutcome, crate::transport::TransportError> {
+    fn attach_session(
+        &self,
+        _s: &crate::transport::SessionName,
+    ) -> Result<crate::transport::AttachOutcome, crate::transport::TransportError> {
         unimplemented!("not reached")
     }
 }
@@ -163,10 +249,27 @@ fn start_agent_respawn_into_dead_session_uses_new_session_not_new_window() {
     let ws = respawn_ws_one_resumable_worker();
     let spawns = std::sync::Arc::new(std::sync::Mutex::new(Vec::new()));
     // session_exists=false models the dead CP-1 `-L` server after --discard-session.
-    let transport = SessionProbeRecordingTransport { spawns: std::sync::Arc::clone(&spawns), spawn_targets: std::sync::Mutex::new(Vec::new()), session_exists: false, killed_panes: std::sync::Mutex::new(std::collections::BTreeSet::new()) };
-    let _ = start_agent_with_transport(&ws, &AgentId::new("alpha"), false, false, false, None, &transport);
+    let transport = SessionProbeRecordingTransport {
+        spawns: std::sync::Arc::clone(&spawns),
+        spawn_targets: std::sync::Mutex::new(Vec::new()),
+        session_exists: false,
+        killed_panes: std::sync::Mutex::new(std::collections::BTreeSet::new()),
+    };
+    let _ = start_agent_with_transport(
+        &ws,
+        &AgentId::new("alpha"),
+        false,
+        false,
+        false,
+        None,
+        &transport,
+    );
     let recorded = spawns.lock().unwrap().clone();
-    assert_eq!(recorded.len(), 1, "exactly one respawn for alpha; got {recorded:?}");
+    assert_eq!(
+        recorded.len(),
+        1,
+        "exactly one respawn for alpha; got {recorded:?}"
+    );
     assert_eq!(
         recorded[0].0, "spawn_first",
         "golden runtime.py:1017: when `tmux has-session` is FALSE (dead -L server after \
@@ -195,7 +298,12 @@ fn reset_agent_discard_session_rebuilds_window_via_start_respawn() {
     let ws = restart_ws_two_resumable_workers(); // compiled spec + state(alpha,bravo running) + seeded coordinator
     let spawns = std::sync::Arc::new(std::sync::Mutex::new(Vec::new()));
     // live session present (other workers keep it alive) but alpha's window was discarded.
-    let transport = SessionProbeRecordingTransport { spawns: std::sync::Arc::clone(&spawns), spawn_targets: std::sync::Mutex::new(Vec::new()), session_exists: true, killed_panes: std::sync::Mutex::new(std::collections::BTreeSet::new()) };
+    let transport = SessionProbeRecordingTransport {
+        spawns: std::sync::Arc::clone(&spawns),
+        spawn_targets: std::sync::Mutex::new(Vec::new()),
+        session_exists: true,
+        killed_panes: std::sync::Mutex::new(std::collections::BTreeSet::new()),
+    };
     let _ = reset_agent_with_transport(&ws, &AgentId::new("alpha"), true, false, None, &transport);
     let recorded = spawns.lock().unwrap().clone();
     assert!(
@@ -233,9 +341,15 @@ fn reset_agent_discard_session_syncs_projection_epoch_inputs_for_restart_agent_c
 
     let before = chrono::Utc::now();
     let spawns = std::sync::Arc::new(std::sync::Mutex::new(Vec::new()));
-    let transport = SessionProbeRecordingTransport { spawns: std::sync::Arc::clone(&spawns), spawn_targets: std::sync::Mutex::new(Vec::new()), session_exists: true, killed_panes: std::sync::Mutex::new(std::collections::BTreeSet::new()) };
-    let outcome = reset_agent_with_transport(&ws, &AgentId::new("alpha"), true, false, None, &transport)
-        .expect("reset-agent alpha --discard-session --no-display");
+    let transport = SessionProbeRecordingTransport {
+        spawns: std::sync::Arc::clone(&spawns),
+        spawn_targets: std::sync::Mutex::new(Vec::new()),
+        session_exists: true,
+        killed_panes: std::sync::Mutex::new(std::collections::BTreeSet::new()),
+    };
+    let outcome =
+        reset_agent_with_transport(&ws, &AgentId::new("alpha"), true, false, None, &transport)
+            .expect("reset-agent alpha --discard-session --no-display");
     assert!(
         matches!(outcome, ResetAgentOutcome::Reset { .. }),
         "restart-agent alpha --discard-session --no-display must complete reset; got {outcome:?}"
@@ -323,7 +437,10 @@ fn bugb_routed_team_ws() -> PathBuf {
     let yaml = crate::model::yaml::dumps(&spec);
     // sanity: the UNMODIFIED compiled spec really routes bravo — that route-bravo rule is the dangling
     // ref the cascade-prune must drop (and which makes golden's validate_spec raise + rollback).
-    assert!(yaml.contains("assign_to: \"bravo\""), "fixture: compiled spec must carry route-bravo (assign_to bravo); got:\n{yaml}");
+    assert!(
+        yaml.contains("assign_to: \"bravo\""),
+        "fixture: compiled spec must carry route-bravo (assign_to bravo); got:\n{yaml}"
+    );
     std::fs::write(ws.join("team.spec.yaml"), yaml).unwrap();
     crate::state::persist::save_runtime_state(
         &ws,
@@ -383,7 +500,10 @@ fn remove_routed_worker_prunes_dangling_routing_rule_divergence() {
     );
     let state = crate::state::persist::load_runtime_state(&ws).expect("load state");
     assert!(
-        state.get("agents").and_then(serde_json::Value::as_object).is_some_and(|a| !a.contains_key("bravo")),
+        state
+            .get("agents")
+            .and_then(serde_json::Value::as_object)
+            .is_some_and(|a| !a.contains_key("bravo")),
         "bravo must also be removed from state.agents; got {state:?}"
     );
     let _ = std::fs::remove_dir_all(&ws);

package/crates/team-agent/src/lifecycle/tests/phase_b_contracts.rs

@@ -720,11 +720,7 @@ impl Transport for BRealTransport {
         })
     }
 
-    fn query(
-        &self,
-        _target: &Target,
-        _field: PaneField,
-    ) -> Result<Option<String>, TransportError> {
+    fn query(&self, _target: &Target, _field: PaneField) -> Result<Option<String>, TransportError> {
         Ok(Some("node".to_string()))
     }
 

package/crates/team-agent/src/lifecycle/tests/phase_golden.rs

@@ -545,6 +545,9 @@ fn normalize_value(value: Value, ctx: &mut NormalizeCtx, key: Option<&str>) -> V
     if matches!(key, Some("env_overlay_keys" | "env_unset_keys")) {
         return json!("<ENV_KEYS>");
     }
+    if matches!(key, Some("env_unset")) {
+        return json!([]);
+    }
     match value {
         Value::Object(map) => {
             let sorted = map.into_iter().collect::<BTreeMap<_, _>>();

package/crates/team-agent/src/lifecycle/tests.rs

@@ -20,11 +20,11 @@ fn sess(s: &str) -> SessionName {
     SessionName(s.to_string())
 }
 
+mod agent_ops;
 mod core;
+mod lane_ops;
 mod launch_spawn;
 mod lifecycle_lock;
-mod agent_ops;
-mod lane_ops;
 mod main_preserved;
 mod phase_b_contracts;
 mod phase_golden;

package/crates/team-agent/src/main.rs

@@ -13,10 +13,10 @@ fn main() -> anyhow::Result<()> {
                 other => return Err(anyhow::anyhow!("unknown fake-worker argument: {other}")),
             }
         }
-        let workspace = workspace
-            .ok_or_else(|| anyhow::anyhow!("fake-worker requires --workspace <path>"))?;
-        let agent_id = agent_id
-            .ok_or_else(|| anyhow::anyhow!("fake-worker requires --agent-id <id>"))?;
+        let workspace =
+            workspace.ok_or_else(|| anyhow::anyhow!("fake-worker requires --workspace <path>"))?;
+        let agent_id =
+            agent_id.ok_or_else(|| anyhow::anyhow!("fake-worker requires --agent-id <id>"))?;
         let stdin = std::io::stdin();
         let stdout = std::io::stdout();
         team_agent::fake_worker::run(&workspace, &agent_id, stdin.lock(), stdout.lock())

package/crates/team-agent/src/mcp_server/lifecycle_tools/agent_ops.rs

@@ -3,8 +3,8 @@ use std::path::{Path, PathBuf};
 use serde_json::Value;
 
 use crate::lifecycle::{ResetAgentOutcome, ResetRefusal};
-use crate::model::yaml::{self, Value as YamlValue};
 use crate::model::ids::{AgentId, TeamKey};
+use crate::model::yaml::{self, Value as YamlValue};
 
 use super::super::helpers::{enum_value, object_fields, tool_runtime_error};
 use super::super::{ToolOk, ToolResult};
@@ -126,7 +126,9 @@ pub(crate) fn fork_agent(
 
 fn reset_refusal_reason(reason: ResetRefusal) -> Value {
     match reason {
-        ResetRefusal::DiscardSessionRequired => Value::String("discard_session_required".to_string()),
+        ResetRefusal::DiscardSessionRequired => {
+            Value::String("discard_session_required".to_string())
+        }
     }
 }
 
@@ -211,7 +213,10 @@ fn state_spec_workspace(state: &Value, team: Option<&str>) -> Option<PathBuf> {
     state_spec_workspace_from_entry(state).or_else(|| {
         let teams = state.get("teams").and_then(Value::as_object)?;
         if teams.len() == 1 {
-            teams.values().next().and_then(state_spec_workspace_from_entry)
+            teams
+                .values()
+                .next()
+                .and_then(state_spec_workspace_from_entry)
         } else {
             None
         }
@@ -294,20 +299,35 @@ fn materialize_mcp_lifecycle_spec(
         ),
         (
             "leader".to_string(),
-            YamlValue::Map(vec![("provider".to_string(), YamlValue::Str("codex".to_string()))]),
+            YamlValue::Map(vec![(
+                "provider".to_string(),
+                YamlValue::Str("codex".to_string()),
+            )]),
         ),
         ("agents".to_string(), YamlValue::List(agent_items)),
     ]);
     let spec_workspace = workspace.join(".team").join(&team_name);
     std::fs::create_dir_all(&spec_workspace).map_err(|e| {
-        tool_runtime_error(format!("create MCP lifecycle spec dir {}: {e}", spec_workspace.display()))
+        tool_runtime_error(format!(
+            "create MCP lifecycle spec dir {}: {e}",
+            spec_workspace.display()
+        ))
     })?;
     let spec_path = spec_workspace.join("team.spec.yaml");
     std::fs::write(&spec_path, yaml::dumps(&spec)).map_err(|e| {
-        tool_runtime_error(format!("write MCP lifecycle spec {}: {e}", spec_path.display()))
+        tool_runtime_error(format!(
+            "write MCP lifecycle spec {}: {e}",
+            spec_path.display()
+        ))
     })?;
     if prepare_state {
-        prepare_selected_team_state(workspace, &mut state, &team_name, &spec_workspace, &spec_path)?;
+        prepare_selected_team_state(
+            workspace,
+            &mut state,
+            &team_name,
+            &spec_workspace,
+            &spec_path,
+        )?;
     }
     Ok(spec_workspace)
 }
@@ -316,16 +336,15 @@ fn selected_agents<'a>(
     state: &'a Value,
     team: Option<&str>,
 ) -> Option<&'a serde_json::Map<String, Value>> {
-    team
-        .and_then(|team| {
-            state
-                .get("teams")
-                .and_then(Value::as_object)
-                .and_then(|teams| teams.get(team))
-                .and_then(|entry| entry.get("agents"))
-                .and_then(Value::as_object)
-        })
-        .or_else(|| state.get("agents").and_then(Value::as_object))
+    team.and_then(|team| {
+        state
+            .get("teams")
+            .and_then(Value::as_object)
+            .and_then(|teams| teams.get(team))
+            .and_then(|entry| entry.get("agents"))
+            .and_then(Value::as_object)
+    })
+    .or_else(|| state.get("agents").and_then(Value::as_object))
 }
 
 fn prepare_selected_team_state(
@@ -370,19 +389,27 @@ fn prepare_selected_team_state(
     if let Some(top_agents) = top_agents {
         if let Some(team_agents) = entry.get_mut("agents").and_then(Value::as_object_mut) {
             for (agent_id, top_agent) in top_agents {
-                let Some(team_agent) = team_agents.get_mut(&agent_id).and_then(Value::as_object_mut) else {
+                let Some(team_agent) = team_agents
+                    .get_mut(&agent_id)
+                    .and_then(Value::as_object_mut)
+                else {
                     continue;
                 };
                 let Some(top_agent) = top_agent.as_object() else {
                     continue;
                 };
                 for (key, value) in top_agent {
-                    team_agent.entry(key.clone()).or_insert_with(|| value.clone());
+                    team_agent
+                        .entry(key.clone())
+                        .or_insert_with(|| value.clone());
                 }
             }
         }
     }
     crate::state::persist::save_runtime_state(workspace, state).map_err(|e| {
-        tool_runtime_error(format!("save MCP lifecycle scoped state {}: {e}", workspace.display()))
+        tool_runtime_error(format!(
+            "save MCP lifecycle scoped state {}: {e}",
+            workspace.display()
+        ))
     })
 }

package/crates/team-agent/src/mcp_server/mod.rs

@@ -56,7 +56,15 @@
 
 // ROUND-0 skeleton: fn bodies are all unimplemented!() so imports/fields/methods are
 // not yet exercised; P2 porter removes this when implementing.
-#![allow(dead_code, unused_imports, unused_variables, clippy::result_large_err, clippy::doc_overindented_list_items, clippy::doc_lazy_continuation, clippy::io_other_error)]
+#![allow(
+    dead_code,
+    unused_imports,
+    unused_variables,
+    clippy::result_large_err,
+    clippy::doc_overindented_list_items,
+    clippy::doc_lazy_continuation,
+    clippy::io_other_error
+)]
 // §10:MCP stdio handlers 实现层禁 unwrap/expect/panic(unimplemented!() stub 不被拦);tests 子模块各自 allow。
 #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
 
@@ -104,7 +112,8 @@ pub(crate) use helpers::{
     object_fields, text_field, text_of_value, tool_error_reason_wire, tool_runtime_error,
 };
 pub(crate) use normalize::{
-    normalize_artifacts, normalize_changes, normalize_next_actions, normalize_risks, normalize_tests,
+    normalize_artifacts, normalize_changes, normalize_next_actions, normalize_risks,
+    normalize_tests,
 };
 pub(crate) use wire::dispatch_tool;
 

package/crates/team-agent/src/mcp_server/types.rs

@@ -275,7 +275,11 @@ impl ToolError {
 
     /// `_tool_error_result(reason, message, exc_type)` (`server.py:98-106`) for the
     /// `unknown_tool` / `peer_not_in_scope` non-exception paths.
-    pub fn new(reason: ToolErrorReason, message: impl Into<String>, exc_type: impl Into<String>) -> Self {
+    pub fn new(
+        reason: ToolErrorReason,
+        message: impl Into<String>,
+        exc_type: impl Into<String>,
+    ) -> Self {
         Self {
             reason,
             exc_type: exc_type.into(),
@@ -289,7 +293,11 @@ impl ToolError {
     pub fn public_exception_message(raw: &str, exc_type: &str) -> String {
         let cleaned = raw.replace(['\n', '\r'], " ");
         let trimmed = cleaned.trim();
-        let base = if trimmed.is_empty() { exc_type } else { trimmed };
+        let base = if trimmed.is_empty() {
+            exc_type
+        } else {
+            trimmed
+        };
         base.chars().take(200).collect()
     }
 }
@@ -320,7 +328,10 @@ impl SendOutcome {
     /// the [`ToolResult`] `Ok` body.
     pub fn to_value(&self) -> Value {
         match self {
-            SendOutcome::WorkerAccepted { message_id, poll_via } => {
+            SendOutcome::WorkerAccepted {
+                message_id,
+                poll_via,
+            } => {
                 let mut obj = serde_json::Map::new();
                 obj.insert("status".to_string(), Value::String("accepted".to_string()));
                 obj.insert("delivery_pending".to_string(), Value::Bool(true));