enya-agent 0.1.0

package/crates/enact-core/src/callable/graph.rs

@@ -0,0 +1,104 @@
+//! GraphCallable - Wraps CompiledGraph to implement Callable trait
+//!
+//! This allows graphs to be registered in the CallableRegistry and executed
+//! through the unified agent/stream endpoint alongside other callable types.
+
+use super::Callable;
+use crate::graph::CompiledGraph;
+use async_trait::async_trait;
+use std::sync::Arc;
+
+/// A callable backed by a compiled graph
+///
+/// This wrapper allows `CompiledGraph` to be used as a `Callable`, enabling
+/// graphs to be registered in the `CallableRegistry` and executed through
+/// the unified agent/stream endpoint.
+pub struct GraphCallable {
+    name: String,
+    graph: Arc<CompiledGraph>,
+}
+
+impl GraphCallable {
+    /// Create a new GraphCallable
+    ///
+    /// # Arguments
+    /// * `name` - The name of this callable
+    /// * `graph` - The compiled graph to wrap
+    pub fn new(name: impl Into<String>, graph: Arc<CompiledGraph>) -> Self {
+        Self {
+            name: name.into(),
+            graph,
+        }
+    }
+
+    /// Get a reference to the underlying graph
+    pub fn graph(&self) -> &CompiledGraph {
+        &self.graph
+    }
+}
+
+#[async_trait]
+impl Callable for GraphCallable {
+    fn name(&self) -> &str {
+        &self.name
+    }
+
+    fn description(&self) -> Option<&str> {
+        None // Could be extended to store description
+    }
+
+    async fn run(&self, input: &str) -> anyhow::Result<String> {
+        // Run the graph with the input
+        let state = self.graph.run(input).await?;
+        
+        // Convert NodeState to String
+        // NodeState contains a serde_json::Value, so we serialize it
+        if let Some(s) = state.as_str() {
+            Ok(s.to_string())
+        } else {
+            // If not a string, serialize the JSON value
+            Ok(serde_json::to_string(&state.data)?)
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::graph::CompiledGraph;
+    use std::collections::HashMap;
+
+    #[tokio::test]
+    async fn test_graph_callable_name() {
+        // Create a minimal graph for testing
+        let graph = Arc::new(CompiledGraph {
+            nodes: HashMap::new(),
+            edges: vec![],
+            conditional_edges: vec![],
+            entry_point: "start".to_string(),
+        });
+
+        let callable = GraphCallable::new("test-graph", graph);
+        assert_eq!(callable.name(), "test-graph");
+    }
+
+    #[tokio::test]
+    async fn test_graph_callable_run() {
+        // Create a minimal graph that just returns the input
+        // Note: This is a simplified test - a real graph would have nodes
+        let graph = Arc::new(CompiledGraph {
+            nodes: HashMap::new(),
+            edges: vec![],
+            conditional_edges: vec![],
+            entry_point: "start".to_string(),
+        });
+
+        let callable = GraphCallable::new("test-graph", graph);
+        
+        // The graph will fail because it has no nodes, but we can test the structure
+        let result = callable.run("test input").await;
+        // This will fail because the graph has no nodes, but that's expected
+        assert!(result.is_err());
+    }
+}
+

package/crates/enact-core/src/callable/llm.rs

@@ -0,0 +1,211 @@
+//! LLM Callable - LLM-powered execution with tool loop
+//!
+//! This is an "agentic" callable - it runs an LLM with tools in a loop
+//! until the LLM produces a final response.
+
+use super::Callable;
+use crate::providers::{ChatMessage, ChatRequest, ModelProvider};
+use crate::tool::{DynTool, Tool};
+use async_trait::async_trait;
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use std::sync::Arc;
+
+/// Tool call from the LLM
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ToolCall {
+    pub id: String,
+    pub name: String,
+    pub arguments: Value,
+}
+
+/// Tool schema for LLM
+#[derive(Debug, Clone, Serialize)]
+pub struct ToolSchema {
+    #[serde(rename = "type")]
+    pub tool_type: String,
+    pub function: FunctionSchema,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct FunctionSchema {
+    pub name: String,
+    pub description: String,
+    pub parameters: Value,
+}
+
+impl ToolSchema {
+    pub fn from_tool(tool: &dyn Tool) -> Self {
+        Self {
+            tool_type: "function".to_string(),
+            function: FunctionSchema {
+                name: tool.name().to_string(),
+                description: tool.description().to_string(),
+                parameters: tool.parameters_schema(),
+            },
+        }
+    }
+}
+
+/// LLM-powered callable with tool execution
+///
+/// This is the "agentic" callable - it runs the LLM in a loop,
+/// executing tools as requested until a final response is produced.
+///
+/// Note: The loop is controlled by `max_iterations` to prevent runaway.
+pub struct LlmCallable {
+    name: String,
+    description: Option<String>,
+    system_prompt: String,
+    provider: Arc<dyn ModelProvider>,
+    tools: Vec<DynTool>,
+    max_iterations: usize,
+}
+
+
+impl LlmCallable {
+    /// Create with a custom provider
+    pub fn with_provider(
+        name: impl Into<String>,
+        system_prompt: impl Into<String>,
+        provider: Arc<dyn ModelProvider>,
+    ) -> Self {
+        Self {
+            name: name.into(),
+            description: None,
+            system_prompt: system_prompt.into(),
+            provider,
+            tools: Vec::new(),
+            max_iterations: 10,
+        }
+    }
+
+    pub fn with_description(mut self, description: impl Into<String>) -> Self {
+        self.description = Some(description.into());
+        self
+    }
+
+    /// Add a tool to the callable
+    pub fn add_tool(mut self, tool: impl Tool + 'static) -> Self {
+        self.tools.push(Arc::new(tool));
+        self
+    }
+
+    /// Add multiple tools
+    pub fn add_tools(mut self, tools: Vec<DynTool>) -> Self {
+        self.tools.extend(tools);
+        self
+    }
+
+    /// Set max iterations for tool loop
+    pub fn max_iterations(mut self, max: usize) -> Self {
+        self.max_iterations = max;
+        self
+    }
+
+    /// Execute a tool by name
+    async fn execute_tool(&self, name: &str, args: Value) -> anyhow::Result<Value> {
+        let tool = self
+            .tools
+            .iter()
+            .find(|t| t.name() == name)
+            .ok_or_else(|| anyhow::anyhow!("Tool '{}' not found", name))?;
+
+        tool.execute(args).await
+    }
+
+    /// Get tool schemas for LLM
+    #[allow(dead_code)]
+    fn get_tool_schemas(&self) -> Vec<ToolSchema> {
+        self.tools
+            .iter()
+            .map(|t| ToolSchema::from_tool(t.as_ref()))
+            .collect()
+    }
+
+    /// Check if response contains tool calls (simple heuristic)
+    fn extract_tool_calls(&self, content: &str) -> Option<Vec<ToolCall>> {
+        // Look for JSON tool call format in response
+        // Format: {"tool_call": {"name": "...", "arguments": {...}}}
+        if let Ok(parsed) = serde_json::from_str::<Value>(content) {
+            if let Some(tool_call) = parsed.get("tool_call") {
+                let name = tool_call.get("name")?.as_str()?.to_string();
+                let arguments = tool_call.get("arguments").cloned().unwrap_or(Value::Null);
+                return Some(vec![ToolCall {
+                    id: format!("call_{}", uuid::Uuid::new_v4()),
+                    name,
+                    arguments,
+                }]);
+            }
+        }
+        None
+    }
+}
+
+#[async_trait]
+impl Callable for LlmCallable {
+    fn name(&self) -> &str {
+        &self.name
+    }
+
+    fn description(&self) -> Option<&str> {
+        self.description.as_deref()
+    }
+
+    async fn run(&self, input: &str) -> anyhow::Result<String> {
+        let mut messages = vec![
+            ChatMessage::system(&self.system_prompt),
+            ChatMessage::user(input),
+        ];
+
+        // If we have tools, add instructions
+        if !self.tools.is_empty() {
+            let tool_names: Vec<&str> = self.tools.iter().map(|t| t.name()).collect();
+            let tool_instruction = format!(
+                "\n\nYou have access to these tools: {:?}. To use a tool, respond with ONLY a JSON object: {{\"tool_call\": {{\"name\": \"tool_name\", \"arguments\": {{...}}}}}}",
+                tool_names
+            );
+            messages[0] =
+                ChatMessage::system(format!("{}{}", self.system_prompt, tool_instruction));
+        }
+
+        // Agentic loop
+        for iteration in 0..self.max_iterations {
+            tracing::debug!(iteration, "Callable iteration");
+
+            let request = ChatRequest {
+                messages: messages.clone(),
+                max_tokens: Some(4096),
+                temperature: Some(0.7),
+            };
+
+            let response = self.provider.chat(request).await?;
+            let content = response
+                .choices
+                .first()
+                .map(|c| c.message.content.clone())
+                .unwrap_or_default();
+
+            // Check for tool calls
+            if let Some(tool_calls) = self.extract_tool_calls(&content) {
+                for call in tool_calls {
+                    tracing::debug!(tool = %call.name, "Executing tool");
+
+                    let result = self.execute_tool(&call.name, call.arguments.clone()).await?;
+
+                    // Add assistant message (tool call) and tool result to history
+                    messages.push(ChatMessage::assistant(&content));
+                    messages.push(ChatMessage {
+                        role: "user".to_string(),
+                        content: format!("Tool result: {}", serde_json::to_string(&result)?),
+                    });
+                }
+            } else {
+                // No tool calls - this is the final response
+                return Ok(content);
+            }
+        }
+
+        anyhow::bail!("Max iterations ({}) reached", self.max_iterations)
+    }
+}

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

@@ -0,0 +1,64 @@
+//! Callable - The execution unit abstraction
+//!
+//! A Callable is anything that can be invoked with an input and produces an output.
+//! This is the fundamental building block of execution.
+//!
+//! ## Key Distinction
+//!
+//! - **Callable**: The interface (trait) - defines HOW to invoke
+//! - **Agent**: A marketing/user-facing term - we keep it as a type alias
+//! - **LlmCallable**: A Callable backed by an LLM with tool loop
+//! - **GraphCallable**: A Callable backed by a compiled graph
+//!
+//! ## Naming Convention
+//!
+//! Internally we use "Callable" to be precise about what this abstraction is.
+//! Externally we re-export "Agent" as a type alias for user familiarity.
+//!
+//! ```text
+//! ┌─────────────────────────────────────────────┐
+//! │              trait Callable                 │
+//! │  ┌─────────────────────────────────────┐    │
+//! │  │  fn name() -> &str                  │    │
+//! │  │  fn description() -> Option<&str>   │    │
+//! │  │  async fn run(&str) -> Result<String>│   │
+//! │  └─────────────────────────────────────┘    │
+//! └─────────────────────────────────────────────┘
+//!            ▲              ▲              ▲
+//!            │              │              │
+//!     ┌──────┴───┐   ┌──────┴───┐   ┌──────┴───┐
+//!     │LlmCallable│   │GraphCallable│  │FnCallable│
+//!     └──────────┘   └──────────┘   └──────────┘
+//! ```
+
+mod callable;
+mod composite;
+mod graph;
+mod llm;
+mod registry;
+
+pub use callable::{Callable, DynCallable};
+pub use composite::{
+    // Descriptor
+    CallableDescriptor,
+    CostTier,
+    // Invocation
+    CallableInvocation,
+    CallableInvocationResult,
+    // Resource allocation
+    ResourceAllocation,
+    ResourceAllocationStrategy,
+    ResourceBudget,
+    // Discovery
+    CallableInvoker,
+    DiscoveryQuery,
+    DiscoveryResult,
+};
+pub use graph::GraphCallable;
+pub use llm::{LlmCallable, ToolCall, ToolSchema};
+pub use registry::CallableRegistry;
+
+// Re-export Agent as a user-friendly alias
+// "Agent" is what users expect, "Callable" is what it really is
+pub type Agent = dyn Callable;
+pub type DynAgent = DynCallable;

package/crates/enact-core/src/callable/registry.rs

@@ -0,0 +1,206 @@
+//! Callable Registry - Central registry for all callable types
+//!
+//! The registry allows registering and looking up any callable type (graphs, agents, workflows, LLM functions, etc.)
+//! by name. This enables the unified agent/stream endpoint to execute any callable type through a single interface.
+
+use super::DynCallable;
+use std::collections::HashMap;
+use std::sync::{Arc, RwLock};
+
+/// Thread-safe registry for callables
+///
+/// Allows registering any callable type (LlmCallable, GraphCallable, FnCallable, etc.)
+/// and looking them up by name. Used by the unified agent/stream endpoint.
+pub struct CallableRegistry {
+    callables: Arc<RwLock<HashMap<String, DynCallable>>>,
+}
+
+impl CallableRegistry {
+    /// Create a new empty registry
+    pub fn new() -> Self {
+        Self {
+            callables: Arc::new(RwLock::new(HashMap::new())),
+        }
+    }
+
+    /// Register a callable with a given name
+    ///
+    /// # Arguments
+    /// * `name` - The name to register the callable under
+    /// * `callable` - The callable to register
+    ///
+    /// # Panics
+    /// This will overwrite any existing callable with the same name.
+    pub fn register(&self, name: String, callable: DynCallable) {
+        let mut callables = self.callables.write().unwrap();
+        callables.insert(name, callable);
+    }
+
+    /// Get a callable by name
+    ///
+    /// # Arguments
+    /// * `name` - The name of the callable to retrieve
+    ///
+    /// # Returns
+    /// * `Some(DynCallable)` if found
+    /// * `None` if not found
+    pub fn get(&self, name: &str) -> Option<DynCallable> {
+        let callables = self.callables.read().unwrap();
+        callables.get(name).cloned()
+    }
+
+    /// List all registered callable names
+    ///
+    /// # Returns
+    /// A vector of all registered callable names, sorted alphabetically
+    pub fn list(&self) -> Vec<String> {
+        let callables = self.callables.read().unwrap();
+        let mut names: Vec<String> = callables.keys().cloned().collect();
+        names.sort();
+        names
+    }
+
+    /// Check if a callable is registered
+    ///
+    /// # Arguments
+    /// * `name` - The name to check
+    ///
+    /// # Returns
+    /// `true` if registered, `false` otherwise
+    pub fn contains(&self, name: &str) -> bool {
+        let callables = self.callables.read().unwrap();
+        callables.contains_key(name)
+    }
+
+    /// Remove a callable from the registry
+    ///
+    /// # Arguments
+    /// * `name` - The name of the callable to remove
+    ///
+    /// # Returns
+    /// `true` if the callable was removed, `false` if it wasn't found
+    pub fn remove(&self, name: &str) -> bool {
+        let mut callables = self.callables.write().unwrap();
+        callables.remove(name).is_some()
+    }
+
+    /// Get the number of registered callables
+    pub fn len(&self) -> usize {
+        let callables = self.callables.read().unwrap();
+        callables.len()
+    }
+
+    /// Check if the registry is empty
+    pub fn is_empty(&self) -> bool {
+        let callables = self.callables.read().unwrap();
+        callables.is_empty()
+    }
+}
+
+impl Default for CallableRegistry {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Clone for CallableRegistry {
+    fn clone(&self) -> Self {
+        Self {
+            callables: Arc::clone(&self.callables),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::callable::Callable;
+    use async_trait::async_trait;
+    use std::sync::Arc;
+
+    struct MockCallable {
+        name: String,
+        output: String,
+    }
+
+    #[async_trait]
+    impl Callable for MockCallable {
+        fn name(&self) -> &str {
+            &self.name
+        }
+
+        async fn run(&self, _input: &str) -> anyhow::Result<String> {
+            Ok(self.output.clone())
+        }
+    }
+
+    #[tokio::test]
+    async fn test_register_and_get() {
+        let registry = CallableRegistry::new();
+        let callable = Arc::new(MockCallable {
+            name: "test".to_string(),
+            output: "test output".to_string(),
+        });
+
+        registry.register("test".to_string(), callable.clone());
+        let retrieved = registry.get("test").unwrap();
+        assert_eq!(retrieved.name(), "test");
+    }
+
+    #[tokio::test]
+    async fn test_get_nonexistent() {
+        let registry = CallableRegistry::new();
+        assert!(registry.get("nonexistent").is_none());
+    }
+
+    #[tokio::test]
+    async fn test_list() {
+        let registry = CallableRegistry::new();
+        let callable1 = Arc::new(MockCallable {
+            name: "callable1".to_string(),
+            output: "output1".to_string(),
+        });
+        let callable2 = Arc::new(MockCallable {
+            name: "callable2".to_string(),
+            output: "output2".to_string(),
+        });
+
+        registry.register("callable1".to_string(), callable1);
+        registry.register("callable2".to_string(), callable2);
+
+        let names = registry.list();
+        assert_eq!(names.len(), 2);
+        assert!(names.contains(&"callable1".to_string()));
+        assert!(names.contains(&"callable2".to_string()));
+    }
+
+    #[tokio::test]
+    async fn test_contains() {
+        let registry = CallableRegistry::new();
+        let callable = Arc::new(MockCallable {
+            name: "test".to_string(),
+            output: "output".to_string(),
+        });
+
+        registry.register("test".to_string(), callable);
+        assert!(registry.contains("test"));
+        assert!(!registry.contains("nonexistent"));
+    }
+
+    #[tokio::test]
+    async fn test_remove() {
+        let registry = CallableRegistry::new();
+        let callable = Arc::new(MockCallable {
+            name: "test".to_string(),
+            output: "output".to_string(),
+        });
+
+        registry.register("test".to_string(), callable);
+        assert!(registry.contains("test"));
+        
+        assert!(registry.remove("test"));
+        assert!(!registry.contains("test"));
+        assert!(!registry.remove("test"));
+    }
+}
+