enya-agent 0.1.0

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

@@ -0,0 +1,221 @@
+use async_trait::async_trait;
+use enact_core::providers::{
+    ChatChoice, ChatMessage, ChatRequest, ChatResponse, ModelCapabilities, ModelProvider,
+};
+use serde::{Deserialize, Serialize};
+
+/// ZeroClaw-style tool specification used by provider-side tool conversion.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ToolSpec {
+    pub name: String,
+    pub description: String,
+    pub parameters: serde_json::Value,
+}
+
+/// ZeroClaw-style tool call shape.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ToolCall {
+    pub id: String,
+    pub name: String,
+    pub arguments: String,
+}
+
+/// ZeroClaw-style chat response shape.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct BridgeChatResponse {
+    pub text: Option<String>,
+    pub tool_calls: Vec<ToolCall>,
+}
+
+/// Provider-native tool payloads, ported from ZeroClaw semantics.
+#[derive(Debug, Clone)]
+pub enum ToolsPayload {
+    Gemini {
+        function_declarations: Vec<serde_json::Value>,
+    },
+    Anthropic {
+        tools: Vec<serde_json::Value>,
+    },
+    OpenAI {
+        tools: Vec<serde_json::Value>,
+    },
+    PromptGuided {
+        instructions: String,
+    },
+}
+
+/// ZeroClaw-compatible provider contract.
+#[async_trait]
+pub trait ZeroClawProvider: Send + Sync {
+    fn provider_name(&self) -> &str;
+    fn model_name(&self) -> &str;
+
+    fn supports_native_tools(&self) -> bool {
+        false
+    }
+
+    fn convert_tools(&self, tools: &[ToolSpec]) -> ToolsPayload {
+        ToolsPayload::PromptGuided {
+            instructions: build_tool_instructions_text(tools),
+        }
+    }
+
+    async fn chat_with_history(
+        &self,
+        messages: &[ChatMessage],
+        temperature: f32,
+    ) -> anyhow::Result<BridgeChatResponse>;
+}
+
+/// Bridge adapter that exposes a ZeroClaw-style provider as Enact `ModelProvider`.
+pub struct BridgeProvider<P> {
+    inner: P,
+}
+
+impl<P> BridgeProvider<P> {
+    pub fn new(inner: P) -> Self {
+        Self { inner }
+    }
+}
+
+#[async_trait]
+impl<P> ModelProvider for BridgeProvider<P>
+where
+    P: ZeroClawProvider,
+{
+    fn name(&self) -> &str {
+        self.inner.provider_name()
+    }
+
+    fn model(&self) -> &str {
+        self.inner.model_name()
+    }
+
+    fn capabilities(&self) -> ModelCapabilities {
+        ModelCapabilities {
+            supports_tools: self.inner.supports_native_tools(),
+            ..ModelCapabilities::default()
+        }
+    }
+
+    async fn chat(&self, request: ChatRequest) -> anyhow::Result<ChatResponse> {
+        let bridged = self
+            .inner
+            .chat_with_history(&request.messages, request.temperature.unwrap_or(0.7))
+            .await?;
+
+        // Preserve tool-calling semantics by encoding tool calls into content.
+        // This keeps compatibility with existing parser-driven runner loops.
+        let content = if bridged.tool_calls.is_empty() {
+            bridged.text.unwrap_or_default()
+        } else {
+            serde_json::json!({
+                "content": bridged.text.unwrap_or_default(),
+                "tool_calls": bridged.tool_calls,
+            })
+            .to_string()
+        };
+
+        Ok(ChatResponse {
+            id: format!("bridge-{}", uuid::Uuid::new_v4()),
+            choices: vec![ChatChoice {
+                index: 0,
+                message: ChatMessage::assistant(content),
+                finish_reason: Some("stop".to_string()),
+            }],
+            usage: None,
+        })
+    }
+}
+
+/// Build prompt-guided fallback instructions for tool usage.
+pub fn build_tool_instructions_text(tools: &[ToolSpec]) -> String {
+    let mut instructions = String::new();
+    instructions.push_str("## Tool Use Protocol\n\n");
+    instructions.push_str("To use a tool, wrap JSON in <tool_call></tool_call> tags:\n\n");
+    instructions.push_str("<tool_call>\n");
+    instructions.push_str("{\"name\": \"tool_name\", \"arguments\": {\"param\": \"value\"}}\n");
+    instructions.push_str("</tool_call>\n\n");
+    instructions.push_str("### Available Tools\n\n");
+
+    for tool in tools {
+        instructions.push_str(&format!("**{}**: {}\n", tool.name, tool.description));
+        let parameters = serde_json::to_string(&tool.parameters).unwrap_or_else(|_| "{}".to_string());
+        instructions.push_str(&format!("Parameters: `{parameters}`\n\n"));
+    }
+
+    instructions
+}
+
+/// Convert tool schema to Gemini `functionDeclarations` shape.
+pub fn convert_tools_for_gemini(tools: &[ToolSpec]) -> Vec<serde_json::Value> {
+    tools
+        .iter()
+        .map(|tool| {
+            serde_json::json!({
+                "name": tool.name,
+                "description": tool.description,
+                "parameters": tool.parameters,
+            })
+        })
+        .collect()
+}
+
+/// Convert tool schema to Anthropic `input_schema` shape.
+pub fn convert_tools_for_anthropic(tools: &[ToolSpec]) -> Vec<serde_json::Value> {
+    tools
+        .iter()
+        .map(|tool| {
+            serde_json::json!({
+                "name": tool.name,
+                "description": tool.description,
+                "input_schema": tool.parameters,
+            })
+        })
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn gemini_tool_conversion_maps_fields() {
+        let tools = vec![ToolSpec {
+            name: "search".to_string(),
+            description: "Search docs".to_string(),
+            parameters: serde_json::json!({"type": "object"}),
+        }];
+
+        let payload = convert_tools_for_gemini(&tools);
+        assert_eq!(payload.len(), 1);
+        assert_eq!(payload[0]["name"], "search");
+        assert_eq!(payload[0]["description"], "Search docs");
+    }
+
+    #[test]
+    fn anthropic_tool_conversion_uses_input_schema() {
+        let tools = vec![ToolSpec {
+            name: "shell".to_string(),
+            description: "Run command".to_string(),
+            parameters: serde_json::json!({"type": "object"}),
+        }];
+
+        let payload = convert_tools_for_anthropic(&tools);
+        assert_eq!(payload.len(), 1);
+        assert!(payload[0].get("input_schema").is_some());
+    }
+
+    #[test]
+    fn prompt_tool_instructions_include_tool_names() {
+        let tools = vec![ToolSpec {
+            name: "read_file".to_string(),
+            description: "Read files".to_string(),
+            parameters: serde_json::json!({"type": "object"}),
+        }];
+
+        let text = build_tool_instructions_text(&tools);
+        assert!(text.contains("read_file"));
+        assert!(text.contains("Tool Use Protocol"));
+    }
+}

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

@@ -0,0 +1,227 @@
+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 GeminiRequest {
+    contents: Vec<GeminiContent>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    system_instruction: Option<GeminiSystemInstruction>,
+    #[serde(rename = "generationConfig")]
+    generation_config: GeminiGenerationConfig,
+}
+
+#[derive(Debug, Serialize)]
+struct GeminiContent {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    role: Option<String>,
+    parts: Vec<GeminiPart>,
+}
+
+#[derive(Debug, Serialize)]
+struct GeminiSystemInstruction {
+    parts: Vec<GeminiPart>,
+}
+
+#[derive(Debug, Serialize)]
+struct GeminiPart {
+    text: String,
+}
+
+#[derive(Debug, Serialize)]
+struct GeminiGenerationConfig {
+    temperature: f32,
+    #[serde(rename = "maxOutputTokens")]
+    max_output_tokens: u32,
+}
+
+#[derive(Debug, Deserialize)]
+struct GeminiResponse {
+    #[serde(default)]
+    candidates: Vec<GeminiCandidate>,
+    #[serde(default)]
+    usage_metadata: Option<GeminiUsageMetadata>,
+}
+
+#[derive(Debug, Deserialize)]
+struct GeminiCandidate {
+    content: GeminiCandidateContent,
+}
+
+#[derive(Debug, Deserialize)]
+struct GeminiCandidateContent {
+    #[serde(default)]
+    parts: Vec<GeminiPartIn>,
+}
+
+#[derive(Debug, Deserialize)]
+struct GeminiPartIn {
+    #[serde(default)]
+    text: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+struct GeminiUsageMetadata {
+    #[serde(default, rename = "promptTokenCount")]
+    prompt_token_count: u32,
+    #[serde(default, rename = "candidatesTokenCount")]
+    candidates_token_count: u32,
+    #[serde(default, rename = "totalTokenCount")]
+    total_token_count: u32,
+}
+
+pub struct Gemini {
+    client: Client,
+    api_key: String,
+    model: String,
+    base_url: String,
+}
+
+impl Gemini {
+    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://generativelanguage.googleapis.com/v1beta".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 format_model(model: &str) -> String {
+        if model.starts_with("models/") {
+            model.to_string()
+        } else {
+            format!("models/{model}")
+        }
+    }
+
+    fn build_url(&self) -> String {
+        format!(
+            "{}/{}:generateContent?key={}",
+            self.base_url,
+            Self::format_model(&self.model),
+            self.api_key
+        )
+    }
+
+    fn convert_messages(messages: &[ChatMessage]) -> (Option<GeminiSystemInstruction>, Vec<GeminiContent>) {
+        let mut system = None;
+        let mut contents = Vec::new();
+
+        for msg in messages {
+            if msg.role == "system" && system.is_none() {
+                system = Some(GeminiSystemInstruction {
+                    parts: vec![GeminiPart {
+                        text: msg.content.clone(),
+                    }],
+                });
+                continue;
+            }
+
+            let role = if msg.role == "assistant" { "model" } else { "user" };
+            contents.push(GeminiContent {
+                role: Some(role.to_string()),
+                parts: vec![GeminiPart {
+                    text: msg.content.clone(),
+                }],
+            });
+        }
+
+        (system, contents)
+    }
+}
+
+#[async_trait]
+impl ModelProvider for Gemini {
+    fn name(&self) -> &str {
+        "gemini"
+    }
+
+    fn model(&self) -> &str {
+        &self.model
+    }
+
+    fn capabilities(&self) -> ModelCapabilities {
+        ModelCapabilities {
+            max_tokens: 1_000_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_instruction, contents) = Self::convert_messages(&request.messages);
+        let body = GeminiRequest {
+            contents,
+            system_instruction,
+            generation_config: GeminiGenerationConfig {
+                temperature: request.temperature.unwrap_or(0.7),
+                max_output_tokens: request.max_tokens.unwrap_or(4096),
+            },
+        };
+
+        let spec = HttpRequestSpec {
+            url: self.build_url(),
+            headers: vec![("content-type".to_string(), "application/json".to_string())],
+            body: serde_json::to_value(body)?,
+            timeout: Duration::from_secs(60),
+        };
+
+        let response: GeminiResponse = serde_json::from_value(post_json(&self.client, spec).await?)?;
+        let text = response
+            .candidates
+            .into_iter()
+            .next()
+            .map(|candidate| {
+                candidate
+                    .content
+                    .parts
+                    .into_iter()
+                    .filter_map(|part| part.text)
+                    .collect::<Vec<_>>()
+                    .join("\n")
+            })
+            .unwrap_or_default();
+
+        let usage = response.usage_metadata.map(|u| ChatUsage {
+            prompt_tokens: u.prompt_token_count,
+            completion_tokens: u.candidates_token_count,
+            total_tokens: u.total_token_count,
+        });
+
+        Ok(ChatResponse {
+            id: format!("gemini-{}", uuid::Uuid::new_v4()),
+            choices: vec![ChatChoice {
+                index: 0,
+                message: ChatMessage::assistant(text),
+                finish_reason: Some("stop".to_string()),
+            }],
+            usage,
+        })
+    }
+}

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

@@ -0,0 +1,78 @@
+//! HTTP helper utilities for providers
+//!
+//! This module provides low-level, provider-agnostic HTTP utilities.
+//! It does NOT know about models, providers, or chat semantics.
+//!
+//! **Important**: This is a dumb HTTP helper. All provider-specific logic
+//! (URL building, authentication, request/response transformation) belongs
+//! in the individual provider implementations.
+
+use reqwest::Client;
+use serde_json::Value;
+use std::time::Duration;
+
+/// HTTP request specification
+///
+/// This struct encapsulates the parameters needed to make an HTTP POST request.
+/// It is provider-agnostic and does not contain any model or provider semantics.
+pub struct HttpRequestSpec {
+    /// Full URL to POST to
+    pub url: String,
+    /// HTTP headers as (name, value) pairs
+    pub headers: Vec<(String, String)>,
+    /// JSON body to send
+    pub body: Value,
+    /// Request timeout
+    pub timeout: Duration,
+}
+
+impl Default for HttpRequestSpec {
+    fn default() -> Self {
+        Self {
+            url: String::new(),
+            headers: Vec::new(),
+            body: Value::Null,
+            timeout: Duration::from_secs(30),
+        }
+    }
+}
+
+/// Execute a JSON POST request
+///
+/// This function performs a POST request with JSON body and returns the
+/// response as a JSON value. It is provider-agnostic and does not know
+/// about models or chat semantics.
+///
+/// # Arguments
+///
+/// * `client` - The reqwest Client to use for the request
+/// * `req` - The HTTP request specification
+///
+/// # Returns
+///
+/// Returns the response body as a JSON value, or an error if the request fails.
+pub async fn post_json(
+    client: &Client,
+    req: HttpRequestSpec,
+) -> anyhow::Result<Value> {
+    let mut request_builder = client
+        .post(&req.url)
+        .timeout(req.timeout)
+        .json(&req.body);
+
+    for (name, value) in req.headers {
+        request_builder = request_builder.header(&name, &value);
+    }
+
+    let response = request_builder.send().await?;
+
+    if !response.status().is_success() {
+        let status = response.status();
+        let error_text = response.text().await.unwrap_or_default();
+        anyhow::bail!("HTTP error ({}): {}", status, error_text);
+    }
+
+    let json: Value = response.json().await?;
+    Ok(json)
+}
+

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

@@ -0,0 +1,53 @@
+//! LLM Provider Implementations
+//!
+//! This crate contains thin HTTP adapters that implement the `ModelProvider` trait
+//! from `enact-core`. Providers are replaceable and side-effect free outside HTTP calls.
+//!
+//! All retries, rate limiting, and quotas are enforced by the kernel, not by providers.
+//!
+//! ## CRITICAL: Provider Module Scope
+//!
+//! Providers MUST NOT import:
+//! - `enact_core::kernel::*`
+//! - `enact_core::execution_state`
+//! - `enact_core::flow`
+//! - `enact_core::policy`
+//!
+//! Providers should only see:
+//! - `ChatRequest` / `ChatResponse` (from `enact_core::providers`)
+//! - Tool schemas (read-only)
+//! - HTTP helper utilities
+
+mod http;
+pub mod bridge;
+
+#[cfg(feature = "provider-azure")]
+mod azure;
+#[cfg(feature = "provider-anthropic")]
+mod anthropic;
+#[cfg(feature = "provider-gemini")]
+mod gemini;
+#[cfg(feature = "provider-openrouter")]
+mod openrouter;
+#[cfg(feature = "provider-openai-compatible")]
+mod openai_compatible;
+
+// Re-export ModelProvider trait and types from enact-core
+pub use enact_core::providers::{
+    ChatChoice, ChatMessage, ChatRequest, ChatResponse, ChatUsage,
+    EmbeddingData, EmbeddingRequest, EmbeddingResponse, EmbeddingUsage,
+    ModelCapabilities, ModelProvider,
+};
+
+// Re-export HTTP helpers
+pub use http::{HttpRequestSpec, post_json};
+
+// Re-export provider implementations conditionally
+#[cfg(feature = "provider-azure")]
+pub use azure::AzureOpenAI;
+#[cfg(feature = "provider-anthropic")]
+pub use anthropic::Anthropic;
+#[cfg(feature = "provider-gemini")]
+pub use gemini::Gemini;
+#[cfg(feature = "provider-openai-compatible")]
+pub use openai_compatible::OpenAICompatible;