enya-agent 0.1.0

package/Cargo.toml

@@ -0,0 +1,97 @@
+[workspace]
+resolver = "2"
+members = [
+    "crates/enact-core",
+    "crates/enact-config",
+    "crates/enact-providers",
+    "crates/enact-runner",
+    "crates/enact-context",
+    "crates/enact-channels",
+    "crates/enact-memory",
+    "crates/enact-gateway",
+    "crates/enact-cli",
+    "crates/enact-skills",
+    "crates/enact-mcp",
+    "crates/enact-a2a",
+    "crates/enact-oauth",
+    "crates/enact-observability",
+    "crates/enact-cron",
+    "crates/enact-tools",
+    "crates/enact-security",
+    "crates/enact",
+]
+
+[workspace.package]
+version = "0.0.1"
+edition = "2021"
+license = "MIT"
+repository = "https://github.com/adl-tan-theta/enactai"
+homepage = "https://www.enactai.now"
+keywords = ["ai", "agent", "llm", "gpt", "claude", "anthropic", "openai", "graph-native"]
+categories = ["api-bindings", "asynchronous", "command-line-utilities"]
+
+[workspace.dependencies]
+# Async runtime
+tokio = { version = "1", features = ["full"] }
+tokio-util = "0.7"
+tokio-stream = "0.1"
+async-trait = "0.1"
+async-stream = "0.3"
+futures = "0.3"
+futures-util = "0.3"
+
+# Serialization
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+toml = "0.8"
+serde_yaml = "0.9.34"
+
+# HTTP
+reqwest = { version = "0.12", features = ["json", "stream"] }
+
+# Tracing
+tracing = "0.1"
+tracing-subscriber = "0.3"
+
+# Utilities
+uuid = { version = "1", features = ["v4", "serde"] }
+svix-ksuid = "0.7"
+chrono = { version = "0.4", features = ["serde"] }
+thiserror = "1"
+anyhow = "1"
+regex = "1.10"
+once_cell = "1.19"
+urlencoding = "2.1"
+html-escape = "0.2"
+
+dirs = "5.0"
+rand = "0.8"
+hex = "0.4"
+dotenv = "0.15.0"
+tiktoken-rs = "0.5"
+tempfile = "3"
+parking_lot = "0.12"
+
+# Compression & Hashing
+miniz_oxide = "0.8"
+sha2 = "0.10"
+aes-gcm = "0.10"
+
+# Internal crates
+enact-core = { path = "crates/enact-core" }
+enact-config = { path = "crates/enact-config" }
+enact-providers = { path = "crates/enact-providers" }
+enact-runner = { path = "crates/enact-runner" }
+enact-context = { path = "crates/enact-context" }
+enact-channels = { path = "crates/enact-channels" }
+enact-memory = { path = "crates/enact-memory" }
+enact-gateway = { path = "crates/enact-gateway" }
+enact-skills = { path = "crates/enact-skills" }
+enact-mcp = { path = "crates/enact-mcp" }
+enact-a2a = { path = "crates/enact-a2a" }
+enact-oauth = { path = "crates/enact-oauth" }
+enact-observability = { path = "crates/enact-observability" }
+enact-cron = { path = "crates/enact-cron" }
+enact-tools = { path = "crates/enact-tools" }
+enact-security = { path = "crates/enact-security" }
+enact = { path = "crates/enact" }

package/crates/enact/Cargo.toml

@@ -0,0 +1,27 @@
+[package]
+name = "enact"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+description = "Enact - Graph-Native AI agents (umbrella crate)"
+repository.workspace = true
+homepage.workspace = true
+keywords = ["ai", "agent", "llm", "graph-native", "gpt", "claude"]
+categories.workspace = true
+
+[dependencies]
+enact-core.workspace = true
+enact-config.workspace = true
+enact-providers.workspace = true
+enact-runner.workspace = true
+enact-context.workspace = true
+enact-channels.workspace = true
+enact-memory.workspace = true
+enact-gateway.workspace = true
+enact-skills.workspace = true
+enact-mcp.workspace = true
+enact-a2a.workspace = true
+enact-oauth.workspace = true
+enact-observability.workspace = true
+enact-cron.workspace = true
+enact-tools.workspace = true

package/crates/enact/src/lib.rs

@@ -0,0 +1,60 @@
+//! Enact - Graph-Native AI Agents
+//!
+//! A modular, extensible AI agent framework with support for multiple LLM providers,
+//! messaging channels, skills, and multi-agent communication.
+//!
+//! # Quick Start
+//!
+//! ```ignore
+//! use enact::prelude::*;
+//!
+//! // Use any of the sub-crates
+//! // - enact_core: Core agent runtime
+//! // - enact_providers: LLM provider integrations
+//! // - enact_channels: Messaging integrations (WhatsApp, Telegram, Teams)
+//! // - enact_runner: Agent execution loop
+//! // - and more...
+//! ```
+//!
+//! # Crates
+//!
+//! | Crate | Description |
+//! |-------|-------------|
+//! | [`enact_core`] | Core agent runtime and graph execution |
+//! | [`enact_providers`] | LLM provider integrations (OpenAI, Anthropic, Azure, etc.) |
+//! | [`enact_runner`] | Robust agent loop with retries and compaction |
+//! | [`enact_context`] | Context window management and token counting |
+//! | [`enact_channels`] | Messaging channels (WhatsApp, Telegram, Teams) |
+//! | [`enact_memory`] | Local-first memory backends |
+//! | [`enact_gateway`] | HTTP gateway for webhooks |
+//! | [`enact_skills`] | Skills system with TOML manifests |
+//! | [`enact_mcp`] | Model Context Protocol client |
+//! | [`enact_a2a`] | Agent-to-Agent protocol support |
+//! | [`enact_oauth`] | OAuth authentication |
+//! | [`enact_observability`] | Observability and telemetry |
+//! | [`enact_cron`] | Cron scheduling for agents |
+//! | [`enact_tools`] | Built-in tools for agents |
+
+// Re-export all core crates
+pub use enact_a2a;
+pub use enact_channels;
+pub use enact_config;
+pub use enact_context;
+pub use enact_core;
+pub use enact_cron;
+pub use enact_gateway;
+pub use enact_mcp;
+pub use enact_memory;
+pub use enact_oauth;
+pub use enact_observability;
+pub use enact_providers;
+pub use enact_runner;
+pub use enact_skills;
+pub use enact_tools;
+
+/// Re-export commonly used types
+pub mod prelude {
+    pub use enact_core::prelude::*;
+    pub use enact_providers::ModelProvider;
+    pub use enact_runner::DefaultAgentRunner;
+}

package/crates/enact-a2a/Cargo.toml

@@ -0,0 +1,25 @@
+[package]
+name = "enact-a2a"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+description = "Multi-agent and A2A (Agent-to-Agent) protocol support for Enact"
+repository.workspace = true
+homepage.workspace = true
+keywords = ["a2a", "multi-agent", "agent-to-agent", "protocol"]
+categories.workspace = true
+
+[dependencies]
+enact-core.workspace = true
+enact-providers.workspace = true
+anyhow.workspace = true
+async-trait.workspace = true
+tokio.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+tracing.workspace = true
+uuid.workspace = true
+chrono = { workspace = true, features = ["serde"] }
+
+[dev-dependencies]
+tempfile.workspace = true

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

@@ -0,0 +1,411 @@
+use anyhow::Result;
+use enact_core::callable::Callable;
+use enact_providers::{ModelProvider, OpenAICompatible};
+use serde_json::json;
+use std::collections::HashMap;
+use std::sync::Arc;
+use std::time::Duration;
+use tracing::{debug, info, warn};
+
+const DELEGATE_TIMEOUT_SECS: u64 = 120;
+
+/// Configuration for a delegate agent
+#[derive(Debug, Clone)]
+pub struct DelegateAgentConfig {
+    pub provider: String,
+    pub model: String,
+    pub system_prompt: Option<String>,
+    pub api_key: Option<String>,
+    pub temperature: Option<f32>,
+    pub max_depth: u32,
+}
+
+impl Default for DelegateAgentConfig {
+    fn default() -> Self {
+        Self {
+            provider: "openai".to_string(),
+            model: "gpt-4o-mini".to_string(),
+            system_prompt: None,
+            api_key: None,
+            temperature: Some(0.7),
+            max_depth: 3,
+        }
+    }
+}
+
+/// Multi-Agent system that can delegate tasks to specialized agents
+pub struct MultiAgentSystem {
+    agents: HashMap<String, DelegateAgentConfig>,
+    fallback_credential: Option<String>,
+}
+
+impl MultiAgentSystem {
+    pub fn new() -> Self {
+        Self {
+            agents: HashMap::new(),
+            fallback_credential: None,
+        }
+    }
+
+    pub fn with_agents(agents: HashMap<String, DelegateAgentConfig>) -> Self {
+        Self {
+            agents,
+            fallback_credential: None,
+        }
+    }
+
+    pub fn set_fallback_credential(&mut self, credential: String) {
+        self.fallback_credential = Some(credential);
+    }
+
+    pub fn register_agent(
+        &mut self,
+        name: impl Into<String>,
+        config: DelegateAgentConfig,
+    ) {
+        self.agents.insert(name.into(), config);
+    }
+
+    pub fn get_agent_names(&self) -> Vec<&str> {
+        self.agents.keys().map(|s| s.as_str()).collect()
+    }
+
+    /// Delegate a task to a specialized agent
+    pub async fn delegate(
+        &self,
+        agent_name: &str,
+        prompt: &str,
+        context: Option<&str>,
+        current_depth: u32,
+    ) -> Result<DelegateResult> {
+        let agent_name = agent_name.trim();
+        if agent_name.is_empty() {
+            anyhow::bail!("Agent name cannot be empty");
+        }
+
+        let prompt = prompt.trim();
+        if prompt.is_empty() {
+            anyhow::bail!("Prompt cannot be empty");
+        }
+
+        // Look up agent config
+        let config = self
+            .agents
+            .get(agent_name)
+            .ok_or_else(|| {
+                let available: Vec<&str> = self.agents.keys().map(|s| s.as_str()).collect();
+                anyhow::anyhow!(
+                    "Unknown agent '{agent_name}'. Available agents: {}",
+                    if available.is_empty() {
+                        "(none configured)".to_string()
+                    } else {
+                        available.join(", ")
+                    }
+                )
+            })?;
+
+        // Check recursion depth
+        if current_depth >= config.max_depth {
+            return Ok(DelegateResult {
+                success: false,
+                output: String::new(),
+                error: Some(format!(
+                    "Delegation depth limit reached ({current_depth}/{}). Cannot delegate further to prevent infinite loops.",
+                    config.max_depth
+                )),
+                agent: agent_name.to_string(),
+                provider: config.provider.clone(),
+                model: config.model.clone(),
+            });
+        }
+
+        info!(
+            "Delegating to agent '{}' ({}/{})",
+            agent_name, current_depth, config.max_depth
+        );
+
+        // Create provider for this agent
+        let api_key = config
+            .api_key
+            .clone()
+            .or_else(|| self.fallback_credential.clone());
+
+        let provider: Arc<dyn ModelProvider> = match config.provider.as_str() {
+            "openai" | "openai-compatible" => {
+                let base_url = std::env::var("OPENAI_BASE_URL")
+                    .unwrap_or_else(|_| "https://api.openai.com".to_string());
+                Arc::new(OpenAICompatible::new(base_url, config.model.clone(), api_key))
+            }
+            _ => {
+                return Ok(DelegateResult {
+                    success: false,
+                    output: String::new(),
+                    error: Some(format!(
+                        "Unsupported provider '{}' for agent '{}'",
+                        config.provider, agent_name
+                    )),
+                    agent: agent_name.to_string(),
+                    provider: config.provider.clone(),
+                    model: config.model.clone(),
+                });
+            }
+        };
+
+        // Build the full prompt
+        let full_prompt = if let Some(ctx) = context {
+            if ctx.trim().is_empty() {
+                prompt.to_string()
+            } else {
+                format!("[Context]\n{}\n\n[Task]\n{}", ctx, prompt)
+            }
+        } else {
+            prompt.to_string()
+        };
+
+        // Execute with timeout
+        let temperature = config.temperature.unwrap_or(0.7);
+        let result = tokio::time::timeout(
+            Duration::from_secs(DELEGATE_TIMEOUT_SECS),
+            execute_with_provider(provider, config.system_prompt.as_deref(), &full_prompt, temperature),
+        )
+        .await;
+
+        match result {
+            Ok(Ok(response)) => {
+                let output = if response.trim().is_empty() {
+                    "[Empty response]".to_string()
+                } else {
+                    response
+                };
+
+                Ok(DelegateResult {
+                    success: true,
+                    output: format!(
+                        "[Agent '{}' ({}/{})]\n{}",
+                        agent_name, config.provider, config.model, output
+                    ),
+                    error: None,
+                    agent: agent_name.to_string(),
+                    provider: config.provider.clone(),
+                    model: config.model.clone(),
+                })
+            }
+            Ok(Err(e)) => Ok(DelegateResult {
+                success: false,
+                output: String::new(),
+                error: Some(format!("Agent '{}' failed: {}", agent_name, e)),
+                agent: agent_name.to_string(),
+                provider: config.provider.clone(),
+                model: config.model.clone(),
+            }),
+            Err(_) => Ok(DelegateResult {
+                success: false,
+                output: String::new(),
+                error: Some(format!(
+                    "Agent '{}' timed out after {}s",
+                    agent_name, DELEGATE_TIMEOUT_SECS
+                )),
+                agent: agent_name.to_string(),
+                provider: config.provider.clone(),
+                model: config.model.clone(),
+            }),
+        }
+    }
+}
+
+impl Default for MultiAgentSystem {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+async fn execute_with_provider(
+    provider: Arc<dyn ModelProvider>,
+    system_prompt: Option<&str>,
+    prompt: &str,
+    temperature: f32,
+) -> Result<String> {
+    use enact_core::providers::{ChatMessage, ChatRequest};
+
+    let messages = if let Some(system) = system_prompt {
+        vec![
+            ChatMessage::system(system),
+            ChatMessage::user(prompt),
+        ]
+    } else {
+        vec![ChatMessage::user(prompt)]
+    };
+
+    let request = ChatRequest {
+        messages,
+        max_tokens: Some(4096),
+        temperature: Some(temperature),
+    };
+
+    let response = provider.chat(request).await?;
+    
+    Ok(response
+        .choices
+        .first()
+        .map(|c| c.message.content.clone())
+        .unwrap_or_default())
+}
+
+/// Result of a delegation operation
+#[derive(Debug, Clone)]
+pub struct DelegateResult {
+    pub success: bool,
+    pub output: String,
+    pub error: Option<String>,
+    pub agent: String,
+    pub provider: String,
+    pub model: String,
+}
+
+/// A2A Message for agent-to-agent communication
+#[derive(Debug, Clone)]
+pub struct A2aMessage {
+    pub from_agent: String,
+    pub to_agent: String,
+    pub message_type: A2aMessageType,
+    pub payload: String,
+    pub timestamp: chrono::DateTime<chrono::Utc>,
+}
+
+#[derive(Debug, Clone)]
+pub enum A2aMessageType {
+    Request,
+    Response,
+    Event,
+    Error,
+}
+
+/// Agent registry for discovering and managing agents
+pub struct AgentRegistry {
+    agents: HashMap<String, AgentInfo>,
+}
+
+#[derive(Debug, Clone)]
+pub struct AgentInfo {
+    pub name: String,
+    pub description: String,
+    pub capabilities: Vec<String>,
+    pub endpoint: Option<String>,
+}
+
+impl AgentRegistry {
+    pub fn new() -> Self {
+        Self {
+            agents: HashMap::new(),
+        }
+    }
+
+    pub fn register(&mut self,
+        name: impl Into<String>,
+        description: impl Into<String>,
+        capabilities: Vec<String>,
+        endpoint: Option<String>,
+    ) {
+        let name = name.into();
+        self.agents.insert(
+            name.clone(),
+            AgentInfo {
+                name,
+                description: description.into(),
+                capabilities,
+                endpoint,
+            },
+        );
+    }
+
+    pub fn find_by_capability(&self,
+        capability: &str) -> Vec<&AgentInfo> {
+        self.agents
+            .values()
+            .filter(|agent| agent.capabilities.contains(&capability.to_string()))
+            .collect()
+    }
+
+    pub fn get(&self, name: &str) -> Option<&AgentInfo> {
+        self.agents.get(name)
+    }
+
+    pub fn list(&self) -> Vec<&AgentInfo> {
+        self.agents.values().collect()
+    }
+}
+
+impl Default for AgentRegistry {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_multi_agent_system_empty() {
+        let system = MultiAgentSystem::new();
+        assert!(system.get_agent_names().is_empty());
+    }
+
+    #[test]
+    fn test_register_agent() {
+        let mut system = MultiAgentSystem::new();
+        system.register_agent(
+            "researcher",
+            DelegateAgentConfig {
+                provider: "openai".to_string(),
+                model: "gpt-4".to_string(),
+                system_prompt: Some("You are a research assistant.".to_string()),
+                api_key: None,
+                temperature: Some(0.3),
+                max_depth: 3,
+            },
+        );
+
+        let names = system.get_agent_names();
+        assert_eq!(names.len(), 1);
+        assert_eq!(names[0], "researcher");
+    }
+
+    #[test]
+    fn test_agent_registry() {
+        let mut registry = AgentRegistry::new();
+        registry.register(
+            "coder",
+            "Writes code",
+            vec!["coding".to_string(), "rust".to_string()],
+            None,
+        );
+
+        let coders = registry.find_by_capability("coding");
+        assert_eq!(coders.len(), 1);
+        assert_eq!(coders[0].name, "coder");
+    }
+
+    #[tokio::test]
+    async fn test_delegate_unknown_agent() {
+        let system = MultiAgentSystem::new();
+        let result = system.delegate("unknown", "test", None, 0).await;
+        assert!(result.is_err());
+    }
+
+    #[tokio::test]
+    async fn test_delegate_depth_limit() {
+        let mut system = MultiAgentSystem::new();
+        system.register_agent(
+            "test",
+            DelegateAgentConfig {
+                max_depth: 2,
+                ..Default::default()
+            },
+        );
+
+        let result = system.delegate("test", "prompt", None, 2).await.unwrap();
+        assert!(!result.success);
+        assert!(result.error.unwrap().contains("depth limit"));
+    }
+}

package/crates/enact-channels/Cargo.toml

@@ -0,0 +1,64 @@
+[package]
+name = "enact-channels"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+description = "Channel integrations for Enact — Telegram, Teams, and extensible messaging"
+repository.workspace = true
+homepage.workspace = true
+keywords = ["telegram", "teams", "whatsapp", "messaging", "webhook"]
+categories.workspace = true
+
+[dependencies]
+# Internal crates
+enact-core = { workspace = true }
+enact-runner = { workspace = true }
+enact-config = { workspace = true }
+
+# Async runtime
+tokio.workspace = true
+async-trait.workspace = true
+futures.workspace = true
+
+# Serialization
+serde.workspace = true
+serde_json.workspace = true
+toml.workspace = true
+
+# HTTP
+reqwest = { workspace = true, features = ["multipart"] }
+
+# Logging
+tracing.workspace = true
+
+# Error handling
+anyhow.workspace = true
+thiserror.workspace = true
+
+# Utilities
+chrono.workspace = true
+uuid.workspace = true
+regex.workspace = true
+dirs = "5.0"
+directories = "5.0"
+parking_lot = "0.12"
+
+# Crypto for webhook verification
+hmac = "0.12"
+sha2.workspace = true
+rand.workspace = true
+hex.workspace = true
+
+# Web server for webhooks (Teams)
+axum = "0.7"
+tower = "0.4"
+tower-http = { version = "0.5", features = ["cors", "trace"] }
+
+[dev-dependencies]
+tokio = { workspace = true, features = ["test-util", "macros"] }
+tempfile.workspace = true
+tracing-subscriber = { workspace = true, features = ["env-filter"] }
+
+[[example]]
+name = "channel_bot"
+path = "examples/channel_bot.rs"