Workerの自動キャッシュロック

crates/llm-worker/examples/worker_cancel_demo.rs

@@ -4,9 +4,7 @@
 
 use llm_worker::llm_client::providers::anthropic::AnthropicClient;
 use llm_worker::{Worker, WorkerResult};
-use std::sync::Arc;
 use std::time::Duration;
-use tokio::sync::Mutex;
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
@@ -25,48 +23,38 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         std::env::var("ANTHROPIC_API_KEY").expect("ANTHROPIC_API_KEY environment variable not set");
 
     let client = AnthropicClient::new(&api_key, "claude-sonnet-4-20250514");
-    let worker = Arc::new(Mutex::new(Worker::new(client)));
+    let worker = Worker::new(client);
 
     println!("🚀 Starting Worker...");
     println!("💡 Will cancel after 2 seconds\n");
 
-    // Get cancel sender first (without holding lock)
-    let cancel_tx = {
-        let w = worker.lock().await;
-        w.cancel_sender()
-    };
+    // Get cancel sender before run (Mutable state)
+    let cancel_tx = worker.cancel_sender();
 
-    // Task 1: Run Worker
-    let worker_clone = worker.clone();
-    let task = tokio::spawn(async move {
-        let mut w = worker_clone.lock().await;
-        println!("📡 Sending request to LLM...");
-
-        match w.run("Tell me a very long story about a brave knight. Make it as detailed as possible with many paragraphs.").await {
-            Ok(WorkerResult::Finished) => {
-                println!("✅ Task completed normally");
-            }
-            Ok(WorkerResult::Paused) => {
-                println!("⏸️  Task paused");
-            }
-            Ok(WorkerResult::LimitReached) => {
-                println!("🔒 Turn limit reached");
-            }
-            Err(e) => {
-                println!("❌ Task error: {}", e);
-            }
-        }
-    });
-
-    // Task 2: Cancel after 2 seconds
+    // Task: Cancel after 2 seconds
     tokio::spawn(async move {
         tokio::time::sleep(Duration::from_secs(2)).await;
         println!("\n🛑 Cancelling worker...");
         let _ = cancel_tx.send(()).await;
     });
 
-    // Wait for task completion
-    task.await?;
+    println!("📡 Sending request to LLM...");
+
+    // Mutable::run consumes self → (Locked, WorkerResult)
+    match worker.run("Tell me a very long story about a brave knight. Make it as detailed as possible with many paragraphs.").await {
+        Ok((_locked, WorkerResult::Finished)) => {
+            println!("✅ Task completed normally");
+        }
+        Ok((_locked, WorkerResult::Paused)) => {
+            println!("⏸️  Task paused");
+        }
+        Ok((_locked, WorkerResult::LimitReached)) => {
+            println!("🔒 Turn limit reached");
+        }
+        Err(e) => {
+            println!("❌ Task error: {}", e);
+        }
+    }
 
     println!("\n✨ Demo complete!");
 

crates/llm-worker/examples/worker_cli.rs

@@ -438,10 +438,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Register tools (unless --no-tools)
     if !args.no_tools {
         let app = AppContext;
-        worker
-            .register_tool(app.get_current_time_definition())
-            .unwrap();
-        worker.register_tool(app.calculate_definition()).unwrap();
+        worker.register_tool(app.get_current_time_definition());
+        worker.register_tool(app.calculate_definition());
     }
 
     // Register streaming display handlers
@@ -465,7 +463,27 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         return Ok(());
     }
 
-    // Interactive loop
+    // Interactive loop — first input transitions Mutable → Locked
+    print!("\n👤 You: ");
+    io::stdout().flush()?;
+
+    let mut first_input = String::new();
+    io::stdin().read_line(&mut first_input)?;
+    let first_input = first_input.trim();
+
+    if first_input == "quit" || first_input == "exit" || first_input.is_empty() {
+        println!("\n👋 Goodbye!");
+        return Ok(());
+    }
+
+    let (mut locked, _) = match worker.run(first_input).await {
+        Ok(pair) => pair,
+        Err(e) => {
+            eprintln!("\n❌ Error: {}", e);
+            return Ok(());
+        }
+    };
+
     loop {
         print!("\n👤 You: ");
         io::stdout().flush()?;
@@ -483,8 +501,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             break;
         }
 
-        // Run Worker (Worker manages history)
-        match worker.run(input).await {
+        match locked.run(input).await {
             Ok(_) => {}
             Err(e) => {
                 eprintln!("\n❌ Error: {}", e);