enya-agent 0.1.0

package/crates/enact-core/tests/stream_event_id_validation.rs

@@ -0,0 +1,435 @@
+//! Unit tests for stream event ID signature validation
+//!
+//! CRITICAL: All stream events MUST carry full ID signatures (executionId, stepId, parentId, parentType, tenantId)
+//! to enable proper UI rendering and agent graph tracking, especially when multiple agents run simultaneously.
+//!
+//! This test ensures that:
+//! 1. All events have executionId
+//! 2. Step-related events have stepId
+//! 3. All events have parentId and parentType for proper hierarchy tracking
+//! 4. All events have tenantId for multi-tenancy support
+//! 5. Text deltas have stepId when part of a step
+//! 6. Artifacts have artifactId and stepId
+
+use enact_core::streaming::StreamEvent;
+
+/// Validate that a stream event has all required ID fields
+fn validate_event_ids(event: &StreamEvent) -> Result<(), Vec<String>> {
+    let mut missing = Vec::new();
+
+    match event {
+        StreamEvent::ExecutionStart { execution_id, .. } => {
+            if execution_id.is_empty() {
+                missing.push("executionId".to_string());
+            }
+            // parent_id and parent_type are optional for execution start
+        }
+
+        StreamEvent::ExecutionEnd { execution_id, .. }
+        | StreamEvent::ExecutionFailed { execution_id, .. }
+        | StreamEvent::ExecutionPaused { execution_id, .. }
+        | StreamEvent::ExecutionResumed { execution_id, .. }
+        | StreamEvent::ExecutionCancelled { execution_id, .. } => {
+            if execution_id.is_empty() {
+                missing.push("executionId".to_string());
+            }
+        }
+
+        StreamEvent::StepStart {
+            execution_id,
+            step_id,
+            ..
+        } => {
+            if execution_id.is_empty() {
+                missing.push("executionId".to_string());
+            }
+            if step_id.is_empty() {
+                missing.push("stepId".to_string());
+            }
+        }
+
+        StreamEvent::StepEnd {
+            execution_id,
+            step_id,
+            ..
+        }
+        | StreamEvent::StepFailed {
+            execution_id,
+            step_id,
+            ..
+        } => {
+            if execution_id.is_empty() {
+                missing.push("executionId".to_string());
+            }
+            if step_id.is_empty() {
+                missing.push("stepId".to_string());
+            }
+        }
+
+        StreamEvent::ArtifactCreated {
+            execution_id,
+            step_id,
+            artifact_id,
+            ..
+        } => {
+            if execution_id.is_empty() {
+                missing.push("executionId".to_string());
+            }
+            if step_id.is_empty() {
+                missing.push("stepId".to_string());
+            }
+            if artifact_id.is_empty() {
+                missing.push("artifactId".to_string());
+            }
+        }
+
+        StreamEvent::TextDelta { id, .. } => {
+            if id.is_empty() {
+                missing.push("id".to_string());
+            }
+            // NOTE: TextDelta currently doesn't have executionId, stepId, parentId, parentType, tenantId
+            // This is a known issue that needs to be fixed!
+            missing.push("executionId".to_string());
+            missing.push("stepId (when part of step)".to_string());
+            missing.push("parentId".to_string());
+            missing.push("parentType".to_string());
+            missing.push("tenantId".to_string());
+        }
+
+        StreamEvent::TextStart {
+            id, execution_id, ..
+        } => {
+            if id.is_empty() {
+                missing.push("id".to_string());
+            }
+            // execution_id is optional, but should be present for proper tracking
+            if execution_id.is_none() {
+                missing.push("executionId (recommended)".to_string());
+            }
+        }
+
+        StreamEvent::TextEnd { id, .. } => {
+            if id.is_empty() {
+                missing.push("id".to_string());
+            }
+        }
+
+        StreamEvent::StartStep { step_id, .. } => {
+            // step_id is optional, but should be present
+            if step_id.is_none() {
+                missing.push("stepId (recommended)".to_string());
+            }
+        }
+
+        StreamEvent::FinishStep { step_id, .. } => {
+            // step_id is optional, but should be present
+            if step_id.is_none() {
+                missing.push("stepId (recommended)".to_string());
+            }
+        }
+
+        StreamEvent::ToolInputStart { tool_call_id, .. }
+        | StreamEvent::ToolInputDelta { tool_call_id, .. }
+        | StreamEvent::ToolInputAvailable { tool_call_id, .. }
+        | StreamEvent::ToolOutputAvailable { tool_call_id, .. } => {
+            if tool_call_id.is_empty() {
+                missing.push("tool_call_id".to_string());
+            }
+            // NOTE: Tool events also need executionId, stepId, parentId, parentType, tenantId
+            missing.push("executionId".to_string());
+            missing.push("stepId (when part of step)".to_string());
+            missing.push("parentId".to_string());
+            missing.push("parentType".to_string());
+            missing.push("tenantId".to_string());
+        }
+
+        StreamEvent::Start {
+            message_id,
+            execution_id,
+            ..
+        } => {
+            if message_id.is_empty() {
+                missing.push("message_id".to_string());
+            }
+            // execution_id is optional, but should be present
+            if execution_id.is_none() {
+                missing.push("executionId (recommended)".to_string());
+            }
+        }
+
+        StreamEvent::Finish { message_id, .. } => {
+            if message_id.is_empty() {
+                missing.push("message_id".to_string());
+            }
+        }
+
+        StreamEvent::Error { .. } => {
+            // Error events may not have all IDs, but should have execution context
+            missing.push("executionId (recommended)".to_string());
+        }
+
+        StreamEvent::StateSnapshot { .. } => {
+            // State snapshots need full context
+            missing.push("executionId".to_string());
+            missing.push("stepId (when part of step)".to_string());
+            missing.push("parentId".to_string());
+            missing.push("parentType".to_string());
+            missing.push("tenantId".to_string());
+        }
+
+        StreamEvent::InboxMessage { .. } => {
+            // Inbox messages need full context
+            missing.push("executionId".to_string());
+            missing.push("stepId (when part of step)".to_string());
+            missing.push("parentId".to_string());
+            missing.push("parentType".to_string());
+            missing.push("tenantId".to_string());
+        }
+
+        StreamEvent::PolicyDecision { .. } => {
+            // Policy decisions need full context
+            missing.push("executionId".to_string());
+            missing.push("stepId (when part of step)".to_string());
+            missing.push("parentId".to_string());
+            missing.push("parentType".to_string());
+            missing.push("tenantId".to_string());
+        }
+
+        StreamEvent::StepDiscovered {
+            execution_id,
+            step_id,
+            ..
+        } => {
+            if execution_id.is_empty() {
+                missing.push("executionId".to_string());
+            }
+            if step_id.is_empty() {
+                missing.push("stepId".to_string());
+            }
+        }
+
+        StreamEvent::CheckpointSaved {
+            execution_id,
+            checkpoint_id,
+            ..
+        } => {
+            if execution_id.is_empty() {
+                missing.push("executionId".to_string());
+            }
+            if checkpoint_id.is_empty() {
+                missing.push("checkpointId".to_string());
+            }
+        }
+
+        StreamEvent::GoalEvaluated {
+            execution_id,
+            goal_id,
+            ..
+        } => {
+            if execution_id.is_empty() {
+                missing.push("executionId".to_string());
+            }
+            if goal_id.is_empty() {
+                missing.push("goalId".to_string());
+            }
+        }
+    }
+
+    if missing.is_empty() {
+        Ok(())
+    } else {
+        Err(missing)
+    }
+}
+
+#[test]
+fn test_execution_start_has_execution_id() {
+    let event = StreamEvent::ExecutionStart {
+        execution_id: "exec_123".to_string(),
+        parent_id: Some("msg_456".to_string()),
+        parent_type: Some("user_message".to_string()),
+        timestamp: 1234567890,
+    };
+
+    let result = validate_event_ids(&event);
+    // ExecutionStart should pass (parent_id and parent_type are optional)
+    assert!(result.is_ok() || result.unwrap_err().is_empty());
+}
+
+#[test]
+fn test_step_start_has_execution_id_and_step_id() {
+    let event = StreamEvent::StepStart {
+        execution_id: "exec_123".to_string(),
+        step_id: "step_456".to_string(),
+        step_type: "function".to_string(),
+        name: "Test Step".to_string(),
+        timestamp: 1234567890,
+    };
+
+    let result = validate_event_ids(&event);
+    assert!(
+        result.is_ok(),
+        "StepStart should have executionId and stepId"
+    );
+}
+
+#[test]
+fn test_step_end_has_execution_id_and_step_id() {
+    let event = StreamEvent::StepEnd {
+        execution_id: "exec_123".to_string(),
+        step_id: "step_456".to_string(),
+        output: None,
+        duration_ms: 100,
+        timestamp: 1234567890,
+    };
+
+    let result = validate_event_ids(&event);
+    assert!(result.is_ok(), "StepEnd should have executionId and stepId");
+}
+
+#[test]
+fn test_artifact_created_has_all_ids() {
+    let event = StreamEvent::ArtifactCreated {
+        execution_id: "exec_123".to_string(),
+        step_id: "step_456".to_string(),
+        artifact_id: "artifact_789".to_string(),
+        artifact_type: "evidence".to_string(),
+        timestamp: 1234567890,
+    };
+
+    let result = validate_event_ids(&event);
+    assert!(
+        result.is_ok(),
+        "ArtifactCreated should have executionId, stepId, and artifactId"
+    );
+}
+
+#[test]
+fn test_text_delta_missing_ids() {
+    let event = StreamEvent::TextDelta {
+        id: "text_123".to_string(),
+        delta: "Hello".to_string(),
+    };
+
+    let result = validate_event_ids(&event);
+    // TextDelta currently doesn't have executionId, stepId, etc. - this test documents the issue
+    assert!(
+        result.is_err(),
+        "TextDelta should fail validation until it includes executionId, stepId, parentId, parentType, tenantId"
+    );
+
+    let missing = result.unwrap_err();
+    assert!(
+        missing.contains(&"executionId".to_string()),
+        "TextDelta should report missing executionId"
+    );
+    assert!(
+        missing.contains(&"stepId (when part of step)".to_string()),
+        "TextDelta should report missing stepId when part of step"
+    );
+}
+
+#[test]
+fn test_tool_events_missing_ids() {
+    let event = StreamEvent::ToolInputStart {
+        tool_call_id: "tool_123".to_string(),
+        tool_name: "get_weather".to_string(),
+    };
+
+    let result = validate_event_ids(&event);
+    // Tool events currently don't have executionId, stepId, etc. - this test documents the issue
+    assert!(
+        result.is_err(),
+        "ToolInputStart should fail validation until it includes executionId, stepId, parentId, parentType, tenantId"
+    );
+
+    let missing = result.unwrap_err();
+    assert!(
+        missing.contains(&"executionId".to_string()),
+        "ToolInputStart should report missing executionId"
+    );
+}
+
+#[test]
+fn test_execution_end_has_execution_id() {
+    let event = StreamEvent::ExecutionEnd {
+        execution_id: "exec_123".to_string(),
+        final_output: None,
+        duration_ms: 1000,
+        timestamp: 1234567890,
+    };
+
+    let result = validate_event_ids(&event);
+    assert!(result.is_ok(), "ExecutionEnd should have executionId");
+}
+
+#[test]
+fn test_step_failed_has_execution_id_and_step_id() {
+    use enact_core::kernel::{ExecutionError, ExecutionErrorCategory};
+    let event = StreamEvent::StepFailed {
+        execution_id: "exec_123".to_string(),
+        step_id: "step_456".to_string(),
+        error: ExecutionError::new(ExecutionErrorCategory::KernelInternal, "Test error"),
+        timestamp: 1234567890,
+    };
+
+    let result = validate_event_ids(&event);
+    assert!(
+        result.is_ok(),
+        "StepFailed should have executionId and stepId"
+    );
+}
+
+/// Test that validates the requirement: ALL stream events must have complete ID signatures
+/// This test will fail until the StreamEvent enum is updated to include all required fields
+#[test]
+#[ignore] // Ignore until StreamEvent is fixed to include all required IDs
+fn test_all_events_have_complete_id_signatures() {
+    // This test documents the requirement that ALL events must have:
+    // - executionId (required for all events)
+    // - stepId (required for step-related events)
+    // - parentId (required for hierarchy tracking)
+    // - parentType (required for hierarchy tracking)
+    // - tenantId (required for multi-tenancy)
+    //
+    // Currently, many events are missing these fields. This test will pass once
+    // the StreamEvent enum is updated to include all required fields.
+
+    let test_events = vec![
+        StreamEvent::ExecutionStart {
+            execution_id: "exec_123".to_string(),
+            parent_id: Some("msg_456".to_string()),
+            parent_type: Some("user_message".to_string()),
+            timestamp: 1234567890,
+        },
+        StreamEvent::StepStart {
+            execution_id: "exec_123".to_string(),
+            step_id: "step_456".to_string(),
+            step_type: "function".to_string(),
+            name: "Test".to_string(),
+            timestamp: 1234567890,
+        },
+        StreamEvent::TextDelta {
+            id: "text_123".to_string(),
+            delta: "Hello".to_string(),
+        },
+        StreamEvent::ArtifactCreated {
+            execution_id: "exec_123".to_string(),
+            step_id: "step_456".to_string(),
+            artifact_id: "artifact_789".to_string(),
+            artifact_type: "evidence".to_string(),
+            timestamp: 1234567890,
+        },
+    ];
+
+    for (index, event) in test_events.iter().enumerate() {
+        let result = validate_event_ids(event);
+        assert!(
+            result.is_ok(),
+            "Event {} ({:?}) should have complete ID signatures. Missing: {:?}",
+            index,
+            event,
+            result.unwrap_err()
+        );
+    }
+}

package/crates/enact-cron/Cargo.toml

@@ -0,0 +1,28 @@
+[package]
+name = "enact-cron"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+description = "Cron scheduling system for Enact agents"
+repository.workspace = true
+homepage.workspace = true
+keywords = ["cron", "scheduler", "scheduling", "timer"]
+categories.workspace = true
+
+[dependencies]
+enact-core.workspace = true
+anyhow.workspace = true
+async-trait.workspace = true
+tokio.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+tracing.workspace = true
+chrono = { version = "0.4", features = ["serde"] }
+cron = "0.15"
+chrono-tz = "0.10"
+rusqlite = { version = "0.32", features = ["bundled"] }
+uuid = { version = "1.0", features = ["v4"] }
+futures-util = "0.3"
+
+[dev-dependencies]
+tempfile.workspace = true

package/crates/enact-cron/src/lib.rs

@@ -0,0 +1,44 @@
+//! Cron scheduling system for Enact agents
+//!
+//! This crate provides a complete cron scheduling system with:
+//! - Standard cron expressions (5, 6, or 7 fields)
+//! - Timezone support
+//! - One-shot and interval schedules
+//! - SQLite-based persistence
+//! - Job history tracking
+
+pub mod schedule;
+pub mod store;
+pub mod types;
+
+pub use schedule::{next_run_for_schedule, normalize_expression, parse_delay, validate_schedule};
+pub use store::CronStore;
+pub use types::{CronJob, CronJobPatch, CronRun, DeliveryConfig, JobType, Schedule, SessionTarget};
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::TempDir;
+
+    #[test]
+    fn cron_store_works() {
+        let tmp = TempDir::new().unwrap();
+        let store = CronStore::new(tmp.path(), 100, 10).unwrap();
+
+        // Add a job
+        let job = store.add_job("0 9 * * *", "echo good morning").unwrap();
+        assert_eq!(job.command, "echo good morning");
+
+        // List jobs
+        let jobs = store.list_jobs().unwrap();
+        assert_eq!(jobs.len(), 1);
+
+        // Get job
+        let fetched = store.get_job(&job.id).unwrap();
+        assert_eq!(fetched.id, job.id);
+
+        // Remove job
+        store.remove_job(&job.id).unwrap();
+        assert!(store.list_jobs().unwrap().is_empty());
+    }
+}

package/crates/enact-cron/src/schedule.rs

@@ -0,0 +1,156 @@
+//! Schedule parsing and next run calculation
+
+use crate::types::Schedule;
+use anyhow::{Context, Result};
+use chrono::{DateTime, Duration as ChronoDuration, Utc};
+use cron::Schedule as CronExprSchedule;
+use std::str::FromStr;
+
+/// Calculate the next run time for a schedule
+pub fn next_run_for_schedule(schedule: &Schedule, from: DateTime<Utc>) -> Result<DateTime<Utc>> {
+    match schedule {
+        Schedule::Cron { expr, tz } => {
+            let normalized = normalize_expression(expr)?;
+            let cron = CronExprSchedule::from_str(&normalized)
+                .with_context(|| format!("Invalid cron expression: {expr}"))?;
+
+            if let Some(tz_name) = tz {
+                let timezone = chrono_tz::Tz::from_str(tz_name)
+                    .with_context(|| format!("Invalid IANA timezone: {tz_name}"))?;
+                let localized_from = from.with_timezone(&timezone);
+                let next_local = cron.after(&localized_from).next().ok_or_else(|| {
+                    anyhow::anyhow!("No future occurrence for expression: {expr}")
+                })?;
+                Ok(next_local.with_timezone(&Utc))
+            } else {
+                cron.after(&from)
+                    .next()
+                    .ok_or_else(|| anyhow::anyhow!("No future occurrence for expression: {expr}"))
+            }
+        }
+        Schedule::At { at } => Ok(*at),
+        Schedule::Every { every_ms } => {
+            if *every_ms == 0 {
+                anyhow::bail!("Invalid schedule: every_ms must be > 0");
+            }
+            let ms = i64::try_from(*every_ms).context("every_ms is too large")?;
+            let delta = ChronoDuration::milliseconds(ms);
+            from.checked_add_signed(delta)
+                .ok_or_else(|| anyhow::anyhow!("every_ms overflowed DateTime"))
+        }
+    }
+}
+
+/// Validate a schedule
+pub fn validate_schedule(schedule: &Schedule, now: DateTime<Utc>) -> Result<()> {
+    match schedule {
+        Schedule::Cron { expr, .. } => {
+            let _ = normalize_expression(expr)?;
+            let _ = next_run_for_schedule(schedule, now)?;
+            Ok(())
+        }
+        Schedule::At { at } => {
+            if *at <= now {
+                anyhow::bail!("Invalid schedule: 'at' must be in the future");
+            }
+            Ok(())
+        }
+        Schedule::Every { every_ms } => {
+            if *every_ms == 0 {
+                anyhow::bail!("Invalid schedule: every_ms must be > 0");
+            }
+            Ok(())
+        }
+    }
+}
+
+/// Extract the cron expression from a schedule
+pub fn schedule_cron_expression(schedule: &Schedule) -> Option<String> {
+    match schedule {
+        Schedule::Cron { expr, .. } => Some(expr.clone()),
+        _ => None,
+    }
+}
+
+/// Normalize a cron expression to 6 or 7 fields
+pub fn normalize_expression(expression: &str) -> Result<String> {
+    let expression = expression.trim();
+    let field_count = expression.split_whitespace().count();
+
+    match field_count {
+        // standard crontab syntax: minute hour day month weekday
+        5 => Ok(format!("0 {expression}")),
+        // crate-native syntax includes seconds (+ optional year)
+        6 | 7 => Ok(expression.to_string()),
+        _ => anyhow::bail!(
+            "Invalid cron expression: {expression} (expected 5, 6, or 7 fields, got {field_count})"
+        ),
+    }
+}
+
+/// Parse a human-readable delay string (e.g., "5m", "1h", "30s")
+pub fn parse_delay(input: &str) -> Result<ChronoDuration> {
+    let input = input.trim();
+    if input.is_empty() {
+        anyhow::bail!("delay must not be empty");
+    }
+    let split = input
+        .find(|c: char| !c.is_ascii_digit())
+        .unwrap_or(input.len());
+    let (num, unit) = input.split_at(split);
+    let amount: i64 = num.parse()?;
+    let unit = if unit.is_empty() { "m" } else { unit };
+    let duration = match unit {
+        "s" => ChronoDuration::seconds(amount),
+        "m" => ChronoDuration::minutes(amount),
+        "h" => ChronoDuration::hours(amount),
+        "d" => ChronoDuration::days(amount),
+        _ => anyhow::bail!("unsupported delay unit '{unit}', use s/m/h/d"),
+    };
+    Ok(duration)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use chrono::TimeZone;
+
+    #[test]
+    fn next_run_for_schedule_supports_every_and_at() {
+        let now = Utc::now();
+        let every = Schedule::Every { every_ms: 60_000 };
+        let next = next_run_for_schedule(&every, now).unwrap();
+        assert!(next > now);
+
+        let at = now + ChronoDuration::minutes(10);
+        let at_schedule = Schedule::At { at };
+        let next_at = next_run_for_schedule(&at_schedule, now).unwrap();
+        assert_eq!(next_at, at);
+    }
+
+    #[test]
+    fn next_run_for_schedule_supports_timezone() {
+        let from = Utc.with_ymd_and_hms(2026, 2, 16, 0, 0, 0).unwrap();
+        let schedule = Schedule::Cron {
+            expr: "0 9 * * *".into(),
+            tz: Some("America/Los_Angeles".into()),
+        };
+
+        let next = next_run_for_schedule(&schedule, from).unwrap();
+        assert_eq!(next, Utc.with_ymd_and_hms(2026, 2, 16, 17, 0, 0).unwrap());
+    }
+
+    #[test]
+    fn normalize_expression_handles_5_fields() {
+        let expr = normalize_expression("*/5 * * * *").unwrap();
+        assert_eq!(expr, "0 */5 * * * *");
+    }
+
+    #[test]
+    fn parse_delay_handles_units() {
+        assert_eq!(parse_delay("30s").unwrap(), ChronoDuration::seconds(30));
+        assert_eq!(parse_delay("5m").unwrap(), ChronoDuration::minutes(5));
+        assert_eq!(parse_delay("2h").unwrap(), ChronoDuration::hours(2));
+        assert_eq!(parse_delay("1d").unwrap(), ChronoDuration::days(1));
+    }
+}