enya-agent 0.1.0

package/crates/enact-core/src/context/invocation.rs

@@ -0,0 +1,99 @@
+//! Invocation Context - Context for agent/tool invocation
+//!
+//! Extends RuntimeContext with invocation-specific fields like input
+//! and available services.
+
+use super::execution_context::RuntimeContext;
+use crate::kernel::{ExecutionId, StepId};
+use serde::{Deserialize, Serialize};
+
+/// Services available during invocation
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+pub struct InvocationServices {
+    /// Memory service available
+    pub memory: bool,
+    /// Artifact storage available
+    pub artifacts: bool,
+    /// Tool registry available
+    pub tools: bool,
+}
+
+impl InvocationServices {
+    /// Create with all services enabled
+    pub fn all() -> Self {
+        Self {
+            memory: true,
+            artifacts: true,
+            tools: true,
+        }
+    }
+
+    /// Create with no services
+    pub fn none() -> Self {
+        Self::default()
+    }
+}
+
+/// InvocationContext - Context for invoking an agent or tool
+///
+/// Extends RuntimeContext with invocation-specific fields like input
+/// and available services.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct InvocationContext {
+    /// Runtime context
+    pub runtime: RuntimeContext,
+
+    /// Invocation input
+    pub input: serde_json::Value,
+
+    /// Services available to the invocation
+    pub services: InvocationServices,
+}
+
+impl InvocationContext {
+    /// Create a new InvocationContext
+    pub fn new(runtime: RuntimeContext, input: serde_json::Value) -> Self {
+        Self {
+            runtime,
+            input,
+            services: InvocationServices::default(),
+        }
+    }
+
+    /// Enable all services
+    pub fn with_all_services(mut self) -> Self {
+        self.services = InvocationServices::all();
+        self
+    }
+
+    /// Enable specific services
+    pub fn with_services(mut self, services: InvocationServices) -> Self {
+        self.services = services;
+        self
+    }
+
+    /// Get the execution ID
+    pub fn execution_id(&self) -> &ExecutionId {
+        &self.runtime.execution_id
+    }
+
+    /// Get the step ID
+    pub fn step_id(&self) -> Option<&StepId> {
+        self.runtime.step_id.as_ref()
+    }
+
+    /// Get the runtime context
+    pub fn runtime(&self) -> &RuntimeContext {
+        &self.runtime
+    }
+
+    /// Get the input
+    pub fn input(&self) -> &serde_json::Value {
+        &self.input
+    }
+
+    /// Get input as string (convenience method)
+    pub fn input_str(&self) -> Option<&str> {
+        self.input.as_str()
+    }
+}

package/crates/enact-core/src/context/mod.rs

@@ -0,0 +1,50 @@
+//! Context module - Execution context types
+//!
+//! This module provides the context types passed through all execution:
+//!
+//! - **TenantContext**: Multi-tenant isolation boundary (REQUIRED)
+//! - **RuntimeContext**: The execution spine
+//! - **TraceContext**: W3C distributed tracing
+//! - **InvocationContext**: Agent/tool invocation context
+//!
+//! ## Key Invariant: TenantContext is Required
+//!
+//! Every execution MUST have a TenantContext. This ensures:
+//! - Multi-tenant isolation
+//! - Resource limit enforcement
+//! - Audit compliance
+//! - Billing attribution
+//!
+//! ## Usage
+//! ```ignore
+//! use enact_core::context::{TenantContext, RuntimeContext};
+//! use enact_core::kernel::{ExecutionId, ParentLink, TenantId, UserId};
+//!
+//! // Create tenant context (REQUIRED)
+//! let tenant = TenantContext::new(TenantId::from("tenant_acme"))
+//!     .with_user(UserId::from("usr_alice"));
+//!
+//! // Create runtime context with tenant
+//! let ctx = RuntimeContext::new(
+//!     ExecutionId::new(),
+//!     ParentLink::from_user_message("msg_123"),
+//!     tenant,
+//! );
+//! ```
+
+mod execution_context;
+mod invocation;
+mod tenant;
+mod trace;
+
+// Tenant context (REQUIRED for every execution)
+pub use tenant::{ResourceLimits, TenantContext};
+
+// Runtime context (the spine)
+pub use execution_context::{RuntimeContext, RuntimeContextBuilder, SessionContext};
+
+// Trace context (OpenTelemetry)
+pub use trace::TraceContext;
+
+// Invocation context
+pub use invocation::{InvocationContext, InvocationServices};

package/crates/enact-core/src/context/tenant.rs

@@ -0,0 +1,175 @@
+//! Tenant Context - Multi-tenant isolation boundary
+//!
+//! TenantContext is a **required** component for every execution.
+//! Every invocation must run within a tenant boundary for:
+//! - Resource isolation
+//! - Billing attribution
+//! - Audit compliance
+//! - Data segregation
+//!
+//! ## Usage
+//! ```ignore
+//! let tenant = TenantContext::new(TenantId::from("tenant_acme"))
+//!     .with_user(UserId::from("usr_alice"))
+//!     .with_limits(ResourceLimits::default());
+//! ```
+
+use crate::kernel::{TenantId, UserId};
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+/// Resource limits enforced by the runtime per tenant
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ResourceLimits {
+    /// Maximum number of steps in an execution
+    pub max_steps: u32,
+    /// Maximum total tokens for LLM calls
+    pub max_tokens: u32,
+    /// Maximum wall time in milliseconds
+    pub max_wall_time_ms: u64,
+    /// Maximum memory in megabytes (optional)
+    pub max_memory_mb: Option<u32>,
+    /// Maximum concurrent executions
+    pub max_concurrent_executions: Option<u32>,
+}
+
+impl Default for ResourceLimits {
+    fn default() -> Self {
+        Self {
+            max_steps: 100,
+            max_tokens: 100_000,
+            max_wall_time_ms: 300_000, // 5 minutes
+            max_memory_mb: None,
+            max_concurrent_executions: None,
+        }
+    }
+}
+
+/// TenantContext - Required context for every execution
+///
+/// This is the multi-tenant isolation boundary. Every execution MUST
+/// have a TenantContext with a valid TenantId.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TenantContext {
+    /// Tenant ID (REQUIRED)
+    pub tenant_id: TenantId,
+
+    /// User ID (optional - system executions may not have a user)
+    pub user_id: Option<UserId>,
+
+    /// Resource limits for this tenant
+    pub limits: ResourceLimits,
+
+    /// Tenant-specific feature flags
+    pub features: HashMap<String, bool>,
+
+    /// Tenant metadata
+    pub metadata: HashMap<String, serde_json::Value>,
+}
+
+impl TenantContext {
+    /// Create a new TenantContext (TenantId is required)
+    pub fn new(tenant_id: TenantId) -> Self {
+        Self {
+            tenant_id,
+            user_id: None,
+            limits: ResourceLimits::default(),
+            features: HashMap::new(),
+            metadata: HashMap::new(),
+        }
+    }
+
+    /// Add user context
+    pub fn with_user(mut self, user_id: UserId) -> Self {
+        self.user_id = Some(user_id);
+        self
+    }
+
+    /// Set resource limits
+    pub fn with_limits(mut self, limits: ResourceLimits) -> Self {
+        self.limits = limits;
+        self
+    }
+
+    /// Enable a feature flag
+    pub fn with_feature(mut self, feature: impl Into<String>, enabled: bool) -> Self {
+        self.features.insert(feature.into(), enabled);
+        self
+    }
+
+    /// Add metadata
+    pub fn with_metadata(mut self, key: impl Into<String>, value: serde_json::Value) -> Self {
+        self.metadata.insert(key.into(), value);
+        self
+    }
+
+    /// Check if a feature is enabled
+    pub fn is_feature_enabled(&self, feature: &str) -> bool {
+        self.features.get(feature).copied().unwrap_or(false)
+    }
+
+    /// Get the tenant ID
+    pub fn tenant_id(&self) -> &TenantId {
+        &self.tenant_id
+    }
+
+    /// Get the user ID
+    pub fn user_id(&self) -> Option<&UserId> {
+        self.user_id.as_ref()
+    }
+
+    /// Create a child TenantContext for sub-agent execution
+    /// (inherits tenant, limits, features but can override user)
+    pub fn child_context(&self, user_id: Option<UserId>) -> Self {
+        Self {
+            tenant_id: self.tenant_id.clone(),
+            user_id: user_id.or_else(|| self.user_id.clone()),
+            limits: self.limits.clone(),
+            features: self.features.clone(),
+            metadata: HashMap::new(), // Child starts fresh
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_tenant_context_required_id() {
+        let tenant = TenantContext::new(TenantId::from("tenant_123"));
+        assert_eq!(tenant.tenant_id().as_str(), "tenant_123");
+    }
+
+    #[test]
+    fn test_tenant_context_with_user() {
+        let tenant = TenantContext::new(TenantId::from("tenant_123"))
+            .with_user(UserId::from("usr_456"));
+
+        assert_eq!(tenant.user_id().unwrap().as_str(), "usr_456");
+    }
+
+    #[test]
+    fn test_feature_flags() {
+        let tenant = TenantContext::new(TenantId::from("tenant_123"))
+            .with_feature("beta_tools", true)
+            .with_feature("experimental", false);
+
+        assert!(tenant.is_feature_enabled("beta_tools"));
+        assert!(!tenant.is_feature_enabled("experimental"));
+        assert!(!tenant.is_feature_enabled("nonexistent"));
+    }
+
+    #[test]
+    fn test_child_context() {
+        let parent = TenantContext::new(TenantId::from("tenant_123"))
+            .with_user(UserId::from("usr_456"))
+            .with_feature("beta", true);
+
+        let child = parent.child_context(Some(UserId::from("usr_789")));
+
+        assert_eq!(child.tenant_id().as_str(), "tenant_123");
+        assert_eq!(child.user_id().unwrap().as_str(), "usr_789");
+        assert!(child.is_feature_enabled("beta"));
+    }
+}

package/crates/enact-core/src/context/trace.rs

@@ -0,0 +1,127 @@
+//! Trace Context - W3C Trace Context for distributed tracing
+//!
+//! Implements W3C Trace Context propagation for OpenTelemetry integration.
+//!
+//! @see https://www.w3.org/TR/trace-context/
+
+use serde::{Deserialize, Serialize};
+
+/// TraceContext - W3C Trace Context for distributed tracing
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TraceContext {
+    /// Trace ID (32 hex chars)
+    pub trace_id: String,
+    /// Span ID (16 hex chars)
+    pub span_id: String,
+    /// Sampling flags
+    pub trace_flags: Option<u8>,
+    /// Vendor-specific state
+    pub trace_state: Option<String>,
+}
+
+impl TraceContext {
+    /// Create a new TraceContext with generated IDs
+    pub fn new() -> Self {
+        Self {
+            trace_id: Self::generate_trace_id(),
+            span_id: Self::generate_span_id(),
+            trace_flags: Some(1), // sampled
+            trace_state: None,
+        }
+    }
+
+    /// Create a child span context (same trace, new span)
+    pub fn child_span(&self) -> Self {
+        Self {
+            trace_id: self.trace_id.clone(),
+            span_id: Self::generate_span_id(),
+            trace_flags: self.trace_flags,
+            trace_state: self.trace_state.clone(),
+        }
+    }
+
+    /// Parse from W3C traceparent header
+    pub fn from_traceparent(header: &str) -> Option<Self> {
+        let parts: Vec<&str> = header.split('-').collect();
+        if parts.len() >= 3 {
+            Some(Self {
+                trace_id: parts[1].to_string(),
+                span_id: parts[2].to_string(),
+                trace_flags: parts.get(3).and_then(|f| u8::from_str_radix(f, 16).ok()),
+                trace_state: None,
+            })
+        } else {
+            None
+        }
+    }
+
+    /// Format as W3C traceparent header
+    pub fn to_traceparent(&self) -> String {
+        format!(
+            "00-{}-{}-{:02x}",
+            self.trace_id,
+            self.span_id,
+            self.trace_flags.unwrap_or(0)
+        )
+    }
+
+    fn generate_trace_id() -> String {
+        use std::time::{SystemTime, UNIX_EPOCH};
+        let now = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_nanos();
+        format!("{:032x}", now)
+    }
+
+    fn generate_span_id() -> String {
+        use std::time::{SystemTime, UNIX_EPOCH};
+        use std::sync::atomic::{AtomicU64, Ordering};
+        static COUNTER: AtomicU64 = AtomicU64::new(0);
+
+        let now = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_nanos() as u64;
+        let counter = COUNTER.fetch_add(1, Ordering::Relaxed);
+        // Mix timestamp with counter to ensure uniqueness
+        format!("{:016x}", now ^ (counter << 48))
+    }
+}
+
+impl Default for TraceContext {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_trace_context_new() {
+        let ctx = TraceContext::new();
+        assert_eq!(ctx.trace_id.len(), 32);
+        assert_eq!(ctx.span_id.len(), 16);
+    }
+
+    #[test]
+    fn test_child_span() {
+        let parent = TraceContext::new();
+        let child = parent.child_span();
+
+        assert_eq!(child.trace_id, parent.trace_id);
+        assert_ne!(child.span_id, parent.span_id);
+    }
+
+    #[test]
+    fn test_traceparent_roundtrip() {
+        let ctx = TraceContext::new();
+        let header = ctx.to_traceparent();
+        let parsed = TraceContext::from_traceparent(&header).unwrap();
+
+        assert_eq!(parsed.trace_id, ctx.trace_id);
+        assert_eq!(parsed.span_id, ctx.span_id);
+    }
+}