enya-agent 0.1.0

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

@@ -0,0 +1,197 @@
+use std::collections::HashMap;
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::time::{Duration, Instant};
+use tracing::{info, span, Level};
+
+/// Execution metrics for a single run
+#[derive(Debug, Clone)]
+pub struct ExecutionMetrics {
+    pub execution_id: String,
+    pub start_time: Instant,
+    pub end_time: Option<Instant>,
+    pub provider: String,
+    pub model: String,
+    pub input_tokens: u64,
+    pub output_tokens: u64,
+    pub total_tokens: u64,
+    pub tool_calls: u64,
+    pub errors: u64,
+    pub retries: u64,
+}
+
+impl ExecutionMetrics {
+    pub fn new(execution_id: impl Into<String>) -> Self {
+        Self {
+            execution_id: execution_id.into(),
+            start_time: Instant::now(),
+            end_time: None,
+            provider: String::new(),
+            model: String::new(),
+            input_tokens: 0,
+            output_tokens: 0,
+            total_tokens: 0,
+            tool_calls: 0,
+            errors: 0,
+            retries: 0,
+        }
+    }
+
+    pub fn finish(&mut self) {
+        self.end_time = Some(Instant::now());
+        let duration = self.duration();
+        info!(
+            execution_id = %self.execution_id,
+            duration_ms = duration.as_millis() as u64,
+            input_tokens = self.input_tokens,
+            output_tokens = self.output_tokens,
+            total_tokens = self.total_tokens,
+            tool_calls = self.tool_calls,
+            errors = self.errors,
+            "Execution completed"
+        );
+    }
+
+    pub fn duration(&self) -> Duration {
+        self.end_time
+            .map(|end| end.duration_since(self.start_time))
+            .unwrap_or_else(|| self.start_time.elapsed())
+    }
+}
+
+/// Global metrics collector
+pub struct MetricsCollector {
+    total_executions: AtomicU64,
+    total_tokens: AtomicU64,
+    total_errors: AtomicU64,
+    total_tool_calls: AtomicU64,
+}
+
+impl MetricsCollector {
+    pub fn new() -> Self {
+        Self {
+            total_executions: AtomicU64::new(0),
+            total_tokens: AtomicU64::new(0),
+            total_errors: AtomicU64::new(0),
+            total_tool_calls: AtomicU64::new(0),
+        }
+    }
+
+    pub fn record_execution(&self) {
+        self.total_executions.fetch_add(1, Ordering::Relaxed);
+    }
+
+    pub fn record_tokens(&self, tokens: u64) {
+        self.total_tokens.fetch_add(tokens, Ordering::Relaxed);
+    }
+
+    pub fn record_error(&self) {
+        self.total_errors.fetch_add(1, Ordering::Relaxed);
+    }
+
+    pub fn record_tool_call(&self) {
+        self.total_tool_calls.fetch_add(1, Ordering::Relaxed);
+    }
+
+    pub fn get_metrics(&self) -> GlobalMetrics {
+        GlobalMetrics {
+            total_executions: self.total_executions.load(Ordering::Relaxed),
+            total_tokens: self.total_tokens.load(Ordering::Relaxed),
+            total_errors: self.total_errors.load(Ordering::Relaxed),
+            total_tool_calls: self.total_tool_calls.load(Ordering::Relaxed),
+        }
+    }
+}
+
+impl Default for MetricsCollector {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct GlobalMetrics {
+    pub total_executions: u64,
+    pub total_tokens: u64,
+    pub total_errors: u64,
+    pub total_tool_calls: u64,
+}
+
+/// Event types for structured logging
+#[derive(Debug, Clone)]
+pub enum ObservabilityEvent {
+    ExecutionStart {
+        execution_id: String,
+        provider: String,
+        model: String,
+    },
+    ExecutionEnd {
+        execution_id: String,
+        success: bool,
+        duration_ms: u64,
+    },
+    ToolCall {
+        execution_id: String,
+        tool_name: String,
+        success: bool,
+    },
+    Error {
+        execution_id: String,
+        error_type: String,
+        message: String,
+    },
+}
+
+/// Initialize tracing subscriber for observability
+pub fn init_observability() {
+    tracing_subscriber::fmt()
+        .with_env_filter(tracing_subscriber::EnvFilter::from_default_env())
+        .with_target(true)
+        .with_thread_ids(true)
+        .with_line_number(true)
+        .with_file(true)
+        .init();
+}
+
+/// Create a tracing span for execution tracking
+pub fn create_execution_span(execution_id: &str, provider: &str, model: &str) -> tracing::Span {
+    span!(
+        Level::INFO,
+        "execution",
+        execution_id = %execution_id,
+        provider = %provider,
+        model = %model
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_execution_metrics() {
+        let mut metrics = ExecutionMetrics::new("test-1");
+        metrics.input_tokens = 100;
+        metrics.output_tokens = 50;
+        metrics.total_tokens = 150;
+        metrics.finish();
+
+        assert_eq!(metrics.execution_id, "test-1");
+        assert!(metrics.duration().as_nanos() > 0);
+        assert_eq!(metrics.input_tokens, 100);
+    }
+
+    #[test]
+    fn test_metrics_collector() {
+        let collector = MetricsCollector::new();
+        collector.record_execution();
+        collector.record_tokens(100);
+        collector.record_error();
+        collector.record_tool_call();
+
+        let metrics = collector.get_metrics();
+        assert_eq!(metrics.total_executions, 1);
+        assert_eq!(metrics.total_tokens, 100);
+        assert_eq!(metrics.total_errors, 1);
+        assert_eq!(metrics.total_tool_calls, 1);
+    }
+}

package/crates/enact-providers/Cargo.toml

@@ -0,0 +1,33 @@
+[package]
+name = "enact-providers"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+description = "LLM provider implementations for Enact - thin HTTP adapters"
+repository.workspace = true
+homepage.workspace = true
+keywords = ["llm", "openai", "anthropic", "azure", "gemini", "ollama"]
+categories.workspace = true
+
+[dependencies]
+enact-core = { workspace = true }
+reqwest.workspace = true
+async-trait.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+anyhow.workspace = true
+tokio.workspace = true
+uuid.workspace = true
+
+[features]
+default = [
+    "provider-azure",
+    "provider-anthropic",
+    "provider-gemini",
+    "provider-openai-compatible",
+]
+provider-azure = []
+provider-anthropic = []
+provider-gemini = []
+provider-openrouter = []
+provider-openai-compatible = []

package/crates/enact-providers/examples/hello-agent.rs

@@ -0,0 +1,33 @@
+use enact_core::providers::{ChatMessage, ChatRequest, ModelProvider};
+use enact_providers::OpenAICompatible;
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    let api_key = std::env::var("OPENAI_API_KEY")
+        .map_err(|_| anyhow::anyhow!("OPENAI_API_KEY is required for this example"))?;
+    let model = std::env::var("OPENAI_MODEL").unwrap_or_else(|_| "gpt-4o-mini".to_string());
+    let base_url = std::env::var("OPENAI_BASE_URL")
+        .unwrap_or_else(|_| "https://api.openai.com".to_string());
+
+    let provider = OpenAICompatible::new(base_url, model.clone(), Some(api_key));
+    let request = ChatRequest {
+        messages: vec![
+            ChatMessage::system("You are a concise assistant."),
+            ChatMessage::user("Say hello and describe yourself in one sentence."),
+        ],
+        max_tokens: Some(128),
+        temperature: Some(0.2),
+    };
+
+    let response = provider.chat(request).await?;
+    let text = response
+        .choices
+        .first()
+        .map(|c| c.message.content.as_str())
+        .unwrap_or("");
+
+    println!("Model: {}", provider.model());
+    println!("Response: {text}");
+
+    Ok(())
+}

package/crates/enact-providers/src/anthropic.rs

@@ -0,0 +1,182 @@
+use crate::http::{HttpRequestSpec, post_json};
+use async_trait::async_trait;
+use enact_core::providers::{
+    ChatChoice, ChatMessage, ChatRequest, ChatResponse, ChatUsage, ModelCapabilities, ModelProvider,
+};
+use reqwest::Client;
+use serde::{Deserialize, Serialize};
+use std::time::Duration;
+
+#[derive(Debug, Serialize)]
+struct AnthropicRequest {
+    model: String,
+    max_tokens: u32,
+    temperature: f32,
+    messages: Vec<AnthropicMessage>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    system: Option<String>,
+}
+
+#[derive(Debug, Serialize)]
+struct AnthropicMessage {
+    role: String,
+    content: String,
+}
+
+#[derive(Debug, Deserialize)]
+struct AnthropicResponse {
+    id: String,
+    content: Vec<AnthropicContentBlock>,
+    #[serde(default)]
+    usage: Option<AnthropicUsage>,
+}
+
+#[derive(Debug, Deserialize)]
+struct AnthropicContentBlock {
+    #[serde(rename = "type")]
+    kind: String,
+    #[serde(default)]
+    text: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+struct AnthropicUsage {
+    #[serde(default)]
+    input_tokens: u32,
+    #[serde(default)]
+    output_tokens: u32,
+}
+
+pub struct Anthropic {
+    client: Client,
+    api_key: String,
+    model: String,
+    base_url: String,
+}
+
+impl Anthropic {
+    pub fn new(api_key: impl Into<String>, model: impl Into<String>) -> Self {
+        Self {
+            client: Client::new(),
+            api_key: api_key.into(),
+            model: model.into(),
+            base_url: "https://api.anthropic.com".to_string(),
+        }
+    }
+
+    pub fn with_base_url(
+        api_key: impl Into<String>,
+        model: impl Into<String>,
+        base_url: impl Into<String>,
+    ) -> Self {
+        Self {
+            client: Client::new(),
+            api_key: api_key.into(),
+            model: model.into(),
+            base_url: base_url.into().trim_end_matches('/').to_string(),
+        }
+    }
+
+    fn build_url(&self) -> String {
+        format!("{}/v1/messages", self.base_url)
+    }
+
+    fn convert_messages(messages: &[ChatMessage]) -> (Option<String>, Vec<AnthropicMessage>) {
+        let mut system = None;
+        let mut out = Vec::new();
+
+        for msg in messages {
+            if msg.role == "system" && system.is_none() {
+                system = Some(msg.content.clone());
+                continue;
+            }
+
+            let role = if msg.role == "assistant" {
+                "assistant"
+            } else {
+                "user"
+            };
+
+            out.push(AnthropicMessage {
+                role: role.to_string(),
+                content: msg.content.clone(),
+            });
+        }
+
+        (system, out)
+    }
+}
+
+#[async_trait]
+impl ModelProvider for Anthropic {
+    fn name(&self) -> &str {
+        "anthropic"
+    }
+
+    fn model(&self) -> &str {
+        &self.model
+    }
+
+    fn capabilities(&self) -> ModelCapabilities {
+        ModelCapabilities {
+            max_tokens: 200_000,
+            max_output_tokens: 8192,
+            supports_streaming: false,
+            supports_tools: true,
+            supports_vision: true,
+            supports_json_mode: true,
+            supports_embeddings: false,
+            pii_safe: false,
+            cost_per_1k_input: None,
+            cost_per_1k_output: None,
+        }
+    }
+
+    async fn chat(&self, request: ChatRequest) -> anyhow::Result<ChatResponse> {
+        let (system, messages) = Self::convert_messages(&request.messages);
+        let body = AnthropicRequest {
+            model: self.model.clone(),
+            max_tokens: request.max_tokens.unwrap_or(4096),
+            temperature: request.temperature.unwrap_or(0.7),
+            messages,
+            system,
+        };
+
+        let spec = HttpRequestSpec {
+            url: self.build_url(),
+            headers: vec![
+                ("x-api-key".to_string(), self.api_key.clone()),
+                ("anthropic-version".to_string(), "2023-06-01".to_string()),
+                ("content-type".to_string(), "application/json".to_string()),
+            ],
+            body: serde_json::to_value(body)?,
+            timeout: Duration::from_secs(60),
+        };
+
+        let response: AnthropicResponse = serde_json::from_value(post_json(&self.client, spec).await?)?;
+
+        let text = response
+            .content
+            .into_iter()
+            .filter(|block| block.kind == "text")
+            .filter_map(|block| block.text)
+            .collect::<Vec<_>>()
+            .join("\n");
+
+        let usage = response.usage.map(|u| ChatUsage {
+            prompt_tokens: u.input_tokens,
+            completion_tokens: u.output_tokens,
+            total_tokens: u.input_tokens.saturating_add(u.output_tokens),
+        });
+
+        Ok(ChatResponse {
+            id: response.id,
+            choices: vec![ChatChoice {
+                index: 0,
+                message: ChatMessage::assistant(text),
+                finish_reason: Some("stop".to_string()),
+            }],
+            usage,
+        })
+    }
+}

package/crates/enact-providers/src/azure.rs

@@ -0,0 +1,96 @@
+//! Azure OpenAI provider
+
+use crate::http::{HttpRequestSpec, post_json};
+use enact_core::providers::{ChatRequest, ChatResponse, ModelProvider};
+use async_trait::async_trait;
+use reqwest::Client;
+use std::time::Duration;
+
+/// Azure OpenAI provider
+pub struct AzureOpenAI {
+    client: Client,
+    endpoint: String,
+    api_key: String,
+    api_version: String,
+    deployment: String,
+}
+
+impl AzureOpenAI {
+    /// Create with explicit configuration
+    pub fn new(
+        endpoint: impl Into<String>,
+        api_key: impl Into<String>,
+        deployment: impl Into<String>,
+    ) -> Self {
+        Self {
+            client: Client::new(),
+            endpoint: endpoint.into().trim_end_matches('/').to_string(),
+            api_key: api_key.into(),
+            api_version: "2024-02-15-preview".to_string(),
+            deployment: deployment.into(),
+        }
+    }
+
+    fn build_url(&self) -> String {
+        // Check if endpoint already includes deployment path
+        // e.g., https://xxx.openai.azure.com/openai/deployments/
+        if self.endpoint.ends_with("/deployments") || self.endpoint.contains("/openai/deployments") {
+            // Endpoint already has deployments path, just append deployment name
+            let base = self.endpoint.trim_end_matches('/');
+            if base.ends_with("/deployments") {
+                format!(
+                    "{}/{}/chat/completions?api-version={}",
+                    base, self.deployment, self.api_version
+                )
+            } else {
+                // Has /openai/deployments/ in the middle somewhere
+                format!(
+                    "{}{}/chat/completions?api-version={}",
+                    self.endpoint, self.deployment, self.api_version
+                )
+            }
+        } else {
+            // Standard Azure OpenAI endpoint format
+            format!(
+                "{}/openai/deployments/{}/chat/completions?api-version={}",
+                self.endpoint, self.deployment, self.api_version
+            )
+        }
+    }
+}
+
+#[async_trait]
+impl ModelProvider for AzureOpenAI {
+    fn name(&self) -> &str {
+        "azure-openai"
+    }
+
+    async fn chat(&self, request: ChatRequest) -> anyhow::Result<ChatResponse> {
+        let url = self.build_url();
+        
+        // Debug: print URL
+        eprintln!("🔗 Azure URL: {}", url);
+
+        // Convert ChatRequest to JSON
+        let body = serde_json::to_value(&request)?;
+
+        // Build HTTP request spec
+        let http_req = HttpRequestSpec {
+            url,
+            headers: vec![
+                ("api-key".to_string(), self.api_key.clone()),
+                ("Content-Type".to_string(), "application/json".to_string()),
+            ],
+            body,
+            timeout: Duration::from_secs(30),
+        };
+
+        // Execute request using HTTP helper
+        let json_response = post_json(&self.client, http_req).await?;
+
+        // Parse response
+        let chat_response: ChatResponse = serde_json::from_value(json_response)?;
+        Ok(chat_response)
+    }
+}
+