enya-agent 0.1.0

package/crates/enact-core/src/kernel/interrupt.rs

@@ -0,0 +1,125 @@
+//! Interruptable execution for plan approval flows
+//!
+//! Kernel-owned interrupt handling logic.
+
+use super::ids::ExecutionId;
+use crate::streaming::{EventEmitter, StreamEvent};
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use tokio::sync::mpsc;
+
+/// Interrupt reason
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum InterruptReason {
+    /// Waiting for plan approval
+    PlanApproval { plan: Value },
+    /// Waiting for user input
+    UserInput { prompt: String },
+    /// Custom interrupt
+    Custom { reason: String, data: Value },
+}
+
+/// User decision for an interrupt
+#[derive(Debug, Clone)]
+pub enum InterruptDecision {
+    /// Approve and continue
+    Approve,
+    /// Reject and abort/replan
+    Reject { reason: Option<String> },
+    /// Provide input and continue
+    Input { value: Value },
+}
+
+/// Interruptable execution handler
+pub struct InterruptableRunner {
+    execution_id: ExecutionId,
+    emitter: EventEmitter,
+    interrupt_tx: mpsc::Sender<InterruptDecision>,
+    interrupt_rx: Option<mpsc::Receiver<InterruptDecision>>,
+}
+
+impl InterruptableRunner {
+    pub fn new() -> Self {
+        let (tx, rx) = mpsc::channel(1);
+        Self {
+            execution_id: ExecutionId::new(),
+            emitter: EventEmitter::new(),
+            interrupt_tx: tx,
+            interrupt_rx: Some(rx),
+        }
+    }
+
+    /// Get the execution ID
+    pub fn execution_id(&self) -> &ExecutionId {
+        &self.execution_id
+    }
+
+    /// Backward compatibility alias
+    #[deprecated(note = "Use execution_id() instead")]
+    pub fn run_id(&self) -> &ExecutionId {
+        &self.execution_id
+    }
+
+    pub fn emitter(&self) -> &EventEmitter {
+        &self.emitter
+    }
+
+    /// Get the decision sender (for external use to send decisions)
+    pub fn decision_sender(&self) -> mpsc::Sender<InterruptDecision> {
+        self.interrupt_tx.clone()
+    }
+
+    /// Send approval decision
+    pub async fn approve(&self) {
+        let _ = self.interrupt_tx.send(InterruptDecision::Approve).await;
+    }
+
+    /// Send rejection decision
+    pub async fn reject(&self, reason: Option<String>) {
+        let _ = self.interrupt_tx.send(InterruptDecision::Reject { reason }).await;
+    }
+
+    /// Request approval and wait for decision
+    pub async fn request_approval(&mut self, plan: Value) -> anyhow::Result<bool> {
+        // Emit waiting event
+        self.emitter.emit(StreamEvent::text_delta(
+            self.execution_id.as_str(),
+            format!("Waiting for approval: {}", serde_json::to_string_pretty(&plan)?),
+        ));
+
+        // Wait for decision
+        if let Some(ref mut rx) = self.interrupt_rx {
+            if let Some(decision) = rx.recv().await {
+                match decision {
+                    InterruptDecision::Approve => {
+                        self.emitter.emit(StreamEvent::text_delta(
+                            self.execution_id.as_str(),
+                            "Plan approved, continuing execution",
+                        ));
+                        Ok(true)
+                    }
+                    InterruptDecision::Reject { reason } => {
+                        self.emitter.emit(StreamEvent::text_delta(
+                            self.execution_id.as_str(),
+                            format!("Plan rejected: {:?}", reason),
+                        ));
+                        Ok(false)
+                    }
+                    InterruptDecision::Input { .. } => {
+                        Ok(true)
+                    }
+                }
+            } else {
+                anyhow::bail!("Interrupt channel closed")
+            }
+        } else {
+            anyhow::bail!("Interrupt receiver not available")
+        }
+    }
+}
+
+impl Default for InterruptableRunner {
+    fn default() -> Self {
+        Self::new()
+    }
+}