Provider Traits

pub trait Provider: Send + Sync {
    fn id(&self) -> &'static str;
    fn display_name(&self) -> &str;
    fn is_available(&self) -> bool;
    fn chat(&self, system: &str, user_message: &str) -> Result<ProviderResponse>;
    fn chat_with_history(&self, system: &str, messages: &[ChatMessage]) -> Result<ProviderResponse>;
}

pub struct ChatMessage {
    pub role: MessageRole,
    pub content: String,
}

pub enum MessageRole {
    System,     // System-level instruction
    User,       // User message
    Assistant,  // Assistant response
}

pub struct ProviderResponse {
    pub content: String,              // Generated text
    pub provider_id: &'static str,    // Which provider served the response
    pub usage: Option<TokenUsage>,    // Token usage (if available)
}

pub struct TokenUsage {
    pub prompt_tokens: u32,      // Tokens in the prompt
    pub completion_tokens: u32,  // Tokens in the completion
    pub total_tokens: u32,       // Total tokens used
}

pub struct ProviderConfig {
    pub provider_id: String,          // "anthropic", "openai", etc.
    pub endpoint: Option<String>,     // Custom endpoint (None = default)
    pub api_key: Option<String>,      // API key (None for Ollama)
    pub model: String,                // Model name
    pub max_tokens: u32,              // Max tokens for response
    pub temperature: f32,             // Temperature (0.0 - 1.0)
}

pub trait EmbeddingProvider: Send + Sync {
    fn id(&self) -> &str;
    fn model_name(&self) -> &str;
    fn model_id(&self) -> String;
    fn embed(&self, text: &str) -> Result<Embedding>;
    fn embed_batch(&self, texts: &[&str]) -> Result<Vec<Embedding>>;
    fn dimensions(&self) -> usize;
    fn is_available(&self) -> bool;
}

use oneclaw_core::provider::{Provider, ChatMessage, MessageRole};

// Any provider can be used as Box<dyn Provider>
let provider: Box<dyn Provider> = Box::new(anthropic_provider);

// Simple chat
let response = provider.chat(
    "You are a helpful assistant.",
    "What is the capital of France?"
)?;

println!("Response: {}", response.content);
println!("Provider: {}", response.provider_id);

// Chat with history
let messages = vec![
    ChatMessage { role: MessageRole::User, content: "Hello".into() },
    ChatMessage { role: MessageRole::Assistant, content: "Hi there!".into() },
    ChatMessage { role: MessageRole::User, content: "How are you?".into() },
];

let response = provider.chat_with_history("Be friendly", &messages)?;

use oneclaw_core::provider::EmbeddingProvider;

let provider: Box<dyn EmbeddingProvider> = Box::new(ollama_embedding);

// Single embedding
let embedding = provider.embed("Hello, world!")?;
assert_eq!(embedding.dim(), 768);

// Batch embeddings
let texts = &["hello", "world", "test"];
let embeddings = provider.embed_batch(texts)?;
assert_eq!(embeddings.len(), 3);