style: cargo fmt

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

Author: ZhiXiao-Lin

core/examples/sdk_chat.rs

@@ -118,9 +118,10 @@ async fn main() -> anyhow::Result<()> {
                     }
                 }
                 ContentBlock::ToolUse { name, .. } => Some(format!("[tool_use: {}]", name)),
-                ContentBlock::ToolResult { content, .. } => {
-                    Some(format!("[tool_result: {}]", &content[..content.len().min(40)]))
-                }
+                ContentBlock::ToolResult { content, .. } => Some(format!(
+                    "[tool_result: {}]",
+                    &content[..content.len().min(40)]
+                )),
             })
             .collect::<Vec<_>>()
             .join(" | ");
@@ -160,7 +161,10 @@ async fn main() -> anyhow::Result<()> {
         },
     ];
     let custom_prompt = "What is the secret number? Reply with just the number.";
-    println!("  Custom history: {} messages injected", custom_history.len());
+    println!(
+        "  Custom history: {} messages injected",
+        custom_history.len()
+    );
     println!("  Prompt: {}", custom_prompt);
     let result3 = session.send(custom_prompt, Some(&custom_history)).await?;
     println!("  Response: {}", result3.text.trim());

core/examples/sdk_skills.rs

@@ -76,8 +76,14 @@ fn main() {
     );
 
     // Content: built-in agents
-    assert!(delegate.content.contains("explore"), "should reference explore");
-    assert!(delegate.content.contains("general"), "should reference general");
+    assert!(
+        delegate.content.contains("explore"),
+        "should reference explore"
+    );
+    assert!(
+        delegate.content.contains("general"),
+        "should reference general"
+    );
     assert!(delegate.content.contains("plan"), "should reference plan");
     println!("  [ok] content references agents: explore, general, plan");
 

core/src/agent.rs

@@ -1639,8 +1639,7 @@ impl AgentLoop {
 
         for tool_call in query_tools {
             // Pre-execution checks: malformed args
-            if let Some(parse_error) =
-                tool_call.args.get("__parse_error").and_then(|v| v.as_str())
+            if let Some(parse_error) = tool_call.args.get("__parse_error").and_then(|v| v.as_str())
             {
                 let error_msg = format!("Error: {}", parse_error);
                 if let Some(tx) = event_tx {
@@ -1981,7 +1980,12 @@ impl AgentLoop {
             if ready.len() == 1 {
                 // === Single step: sequential execution (preserves history chain) ===
                 let step_id = &ready[0];
-                let step = plan.steps.iter().find(|s| s.id == *step_id).unwrap().clone();
+                let step = plan
+                    .steps
+                    .iter()
+                    .find(|s| s.id == *step_id)
+                    .unwrap()
+                    .clone();
                 let step_number = plan.steps.iter().position(|s| s.id == *step_id).unwrap() + 1;
 
                 // Send step start event
@@ -4861,7 +4865,11 @@ mod extra_agent_tests {
         ];
 
         let (query, sequential) = partition_by_lane(&tool_calls);
-        assert_eq!(query.len(), 6, "all read-only tools should be in query lane");
+        assert_eq!(
+            query.len(),
+            6,
+            "all read-only tools should be in query lane"
+        );
         assert_eq!(sequential.len(), 0);
     }
 
@@ -5003,21 +5011,12 @@ mod extra_agent_tests {
         let config = AgentConfig::default();
 
         let (event_tx, _) = broadcast::channel(100);
-        let queue = SessionLaneQueue::new(
-            "test-session",
-            SessionQueueConfig::default(),
-            event_tx,
-        )
-        .await
-        .unwrap();
+        let queue = SessionLaneQueue::new("test-session", SessionQueueConfig::default(), event_tx)
+            .await
+            .unwrap();
 
-        let agent = AgentLoop::new(
-            mock_client,
-            tool_executor,
-            test_tool_context(),
-            config,
-        )
-        .with_queue(Arc::new(queue));
+        let agent = AgentLoop::new(mock_client, tool_executor, test_tool_context(), config)
+            .with_queue(Arc::new(queue));
 
         assert!(agent.command_queue.is_some());
     }
@@ -5078,7 +5077,9 @@ mod extra_agent_tests {
         while let Some(event) = rx.recv().await {
             match event {
                 AgentEvent::StepStart { step_id, .. } => step_starts.push(step_id),
-                AgentEvent::StepEnd { step_id, status, .. } => {
+                AgentEvent::StepEnd {
+                    step_id, status, ..
+                } => {
                     assert_eq!(status, TaskStatus::Completed);
                     step_ends.push(step_id);
                 }
@@ -5190,13 +5191,9 @@ mod extra_agent_tests {
 
         let mut plan = ExecutionPlan::new("Test failure", Complexity::Medium);
         plan.add_step(Task::new("s1", "Independent step"));
-        plan.add_step(
-            Task::new("s2", "Depends on s1").with_dependencies(vec!["s1".to_string()]),
-        );
+        plan.add_step(Task::new("s2", "Depends on s1").with_dependencies(vec!["s1".to_string()]));
         plan.add_step(Task::new("s3", "Another independent"));
-        plan.add_step(
-            Task::new("s4", "Depends on s2").with_dependencies(vec!["s2".to_string()]),
-        );
+        plan.add_step(Task::new("s4", "Depends on s2").with_dependencies(vec!["s2".to_string()]));
 
         let (tx, mut rx) = mpsc::channel(100);
         let _result = agent.execute_plan(&[], &plan, Some(tx)).await.unwrap();
@@ -5227,10 +5224,7 @@ mod extra_agent_tests {
             completed_steps.contains(&"s3".to_string()),
             "s3 should complete"
         );
-        assert!(
-            failed_steps.contains(&"s2".to_string()),
-            "s2 should fail"
-        );
+        assert!(failed_steps.contains(&"s2".to_string()), "s2 should fail");
         // s4 should NOT appear in either list — it was never started
         assert!(
             !completed_steps.contains(&"s4".to_string()),

core/src/agent_api.rs

@@ -326,11 +326,7 @@ impl AgentSession {
     /// When `history` is `None`, uses (and auto-updates) the session's
     /// internal conversation history. When `Some`, uses the provided
     /// history instead (the internal history is **not** modified).
-    pub async fn send(
-        &self,
-        prompt: &str,
-        history: Option<&[Message]>,
-    ) -> Result<AgentResult> {
+    pub async fn send(&self, prompt: &str, history: Option<&[Message]>) -> Result<AgentResult> {
         let agent_loop = self.build_agent_loop();
 
         let use_internal = history.is_none();
@@ -370,7 +366,9 @@ impl AgentSession {
         let prompt = prompt.to_string();
 
         let handle = tokio::spawn(async move {
-            let _ = agent_loop.execute(&effective_history, &prompt, Some(tx)).await;
+            let _ = agent_loop
+                .execute(&effective_history, &prompt, Some(tx))
+                .await;
         });
 
         Ok((rx, handle))
@@ -446,11 +444,7 @@ impl AgentSession {
     /// Complete an external task by ID.
     ///
     /// Returns `true` if the task was found and completed, `false` if not found.
-    pub async fn complete_external_task(
-        &self,
-        task_id: &str,
-        result: ExternalTaskResult,
-    ) -> bool {
+    pub async fn complete_external_task(&self, task_id: &str, result: ExternalTaskResult) -> bool {
         if let Some(ref queue) = self.command_queue {
             queue.complete_external_task(task_id, result).await
         } else {
@@ -809,7 +803,9 @@ mod tests {
         let agent = Agent::from_config(test_config()).await.unwrap();
         let qc = SessionQueueConfig::default();
         let opts = SessionOptions::new().with_queue_config(qc);
-        let session = agent.session("/tmp/test-workspace-qstats", Some(opts)).unwrap();
+        let session = agent
+            .session("/tmp/test-workspace-qstats", Some(opts))
+            .unwrap();
         let stats = session.queue_stats().await;
         // Fresh queue with no commands should have zero stats
         assert_eq!(stats.total_pending, 0);
@@ -821,7 +817,9 @@ mod tests {
         let agent = Agent::from_config(test_config()).await.unwrap();
         let qc = SessionQueueConfig::default();
         let opts = SessionOptions::new().with_queue_config(qc);
-        let session = agent.session("/tmp/test-workspace-ext", Some(opts)).unwrap();
+        let session = agent
+            .session("/tmp/test-workspace-ext", Some(opts))
+            .unwrap();
         let tasks = session.pending_external_tasks().await;
         assert!(tasks.is_empty());
     }
@@ -831,7 +829,9 @@ mod tests {
         let agent = Agent::from_config(test_config()).await.unwrap();
         let qc = SessionQueueConfig::default().with_dlq(Some(100));
         let opts = SessionOptions::new().with_queue_config(qc);
-        let session = agent.session("/tmp/test-workspace-dlq", Some(opts)).unwrap();
+        let session = agent
+            .session("/tmp/test-workspace-dlq", Some(opts))
+            .unwrap();
         let dead = session.dead_letters().await;
         assert!(dead.is_empty());
     }
@@ -842,7 +842,9 @@ mod tests {
         // Metrics not enabled
         let qc = SessionQueueConfig::default();
         let opts = SessionOptions::new().with_queue_config(qc);
-        let session = agent.session("/tmp/test-workspace-nomet", Some(opts)).unwrap();
+        let session = agent
+            .session("/tmp/test-workspace-nomet", Some(opts))
+            .unwrap();
         let metrics = session.queue_metrics().await;
         assert!(metrics.is_none());
     }
@@ -852,7 +854,9 @@ mod tests {
         let agent = Agent::from_config(test_config()).await.unwrap();
         let qc = SessionQueueConfig::default().with_metrics();
         let opts = SessionOptions::new().with_queue_config(qc);
-        let session = agent.session("/tmp/test-workspace-met", Some(opts)).unwrap();
+        let session = agent
+            .session("/tmp/test-workspace-met", Some(opts))
+            .unwrap();
         let metrics = session.queue_metrics().await;
         assert!(metrics.is_some());
     }
@@ -862,7 +866,9 @@ mod tests {
         let agent = Agent::from_config(test_config()).await.unwrap();
         let qc = SessionQueueConfig::default();
         let opts = SessionOptions::new().with_queue_config(qc);
-        let session = agent.session("/tmp/test-workspace-handler", Some(opts)).unwrap();
+        let session = agent
+            .session("/tmp/test-workspace-handler", Some(opts))
+            .unwrap();
 
         // Set Execute lane to External mode
         session

core/src/planning/mod.rs

@@ -635,8 +635,7 @@ mod tests {
         plan.add_step(Task::new("s1", "Step 1"));
         plan.add_step(Task::new("s2", "Step 2"));
         plan.add_step(
-            Task::new("s3", "Step 3")
-                .with_dependencies(vec!["s1".to_string(), "s2".to_string()]),
+            Task::new("s3", "Step 3").with_dependencies(vec!["s1".to_string(), "s2".to_string()]),
         );
 
         // Wave 1: s1 and s2

core/src/tools/skill.rs

@@ -753,10 +753,7 @@ allowed-tools: InvalidFormat, AlsoInvalid
     fn test_builtin_skills_includes_delegate_task() {
         let skills = builtin_skills();
         let delegate = skills.iter().find(|s| s.name == "delegate-task");
-        assert!(
-            delegate.is_some(),
-            "delegate-task skill should be present"
-        );
+        assert!(delegate.is_some(), "delegate-task skill should be present");
 
         let d = delegate.unwrap();
         assert_eq!(d.kind, SkillKind::Instruction);
@@ -770,10 +767,7 @@ allowed-tools: InvalidFormat, AlsoInvalid
     #[test]
     fn test_builtin_delegate_task_content() {
         let skills = builtin_skills();
-        let skill = skills
-            .iter()
-            .find(|s| s.name == "delegate-task")
-            .unwrap();
+        let skill = skills.iter().find(|s| s.name == "delegate-task").unwrap();
 
         // Verify key content sections exist
         assert!(