Compactの実装

crates/llm-worker/examples/worker_cancel_demo.rs

@@ -45,6 +45,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             WorkerResult::Finished => println!("✅ Task completed normally"),
             WorkerResult::Paused => println!("⏸️  Task paused"),
             WorkerResult::LimitReached => println!("🔒 Turn limit reached"),
+            WorkerResult::Yielded => println!("↩️  Task yielded"),
         },
         Err(e) => {
             println!("❌ Task error: {}", e);

crates/llm-worker/src/interceptor.rs

@@ -30,8 +30,13 @@ pub enum PromptAction {
 pub enum PreRequestAction {
     /// Proceed normally.
     Continue,
-    /// Cancel with a reason.
+    /// Cancel with a reason (treated as an error).
     Cancel(String),
+    /// Yield control to the caller for external processing.
+    ///
+    /// The Worker exits the turn loop cleanly with `WorkerResult::Yielded`.
+    /// The caller is expected to resume execution later.
+    Yield,
 }
 
 /// Action before a tool call.

crates/llm-worker/src/worker.rs

@@ -71,6 +71,12 @@ pub enum WorkerResult {
     Paused,
     /// Turn limit reached (max_turns exceeded)
     LimitReached,
+    /// Yielded to caller for external processing (e.g. context compaction).
+    ///
+    /// Distinct from `Paused`: internal machinery, not user-facing. The
+    /// caller is expected to perform some side work and then call `resume()`
+    /// to continue the turn loop.
+    Yielded,
 }
 
 /// Result of [`Worker<C, Mutable>::run()`] / [`Worker<C, Mutable>::resume()`].
@@ -702,6 +708,14 @@ impl<C: LlmClient, S: WorkerState> Worker<C, S> {
                     self.last_run_interrupted = true;
                     return Err(WorkerError::Aborted(reason));
                 }
+                PreRequestAction::Yield => {
+                    info!("Yielded by interceptor");
+                    for cb in &self.turn_end_cbs {
+                        cb(current_turn);
+                    }
+                    self.last_run_interrupted = true;
+                    return Ok(WorkerResult::Yielded);
+                }
                 PreRequestAction::Continue => {}
             }