use std::collections::HashMap;
use std::sync::Arc;
use async_trait::async_trait;
use futures::stream::BoxStream;
use serde::{Deserialize, Serialize};
use crate::ai::message::{Message, StopReason, Usage};
use crate::ai::model::{Api, Context};
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum Reasoning {
#[default]
Off,
Low,
Medium,
High,
}
impl std::str::FromStr for Reasoning {
type Err = String;
fn from_str(s: &str) -> Result<Self, Self::Err> {
match s {
"off" => Ok(Reasoning::Off),
"low" => Ok(Reasoning::Low),
"medium" => Ok(Reasoning::Medium),
"high" => Ok(Reasoning::High),
other => Err(format!("unknown reasoning '{other}' (off|low|medium|high)")),
}
}
}
impl std::fmt::Display for Reasoning {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(match self {
Reasoning::Off => "off",
Reasoning::Low => "low",
Reasoning::Medium => "medium",
Reasoning::High => "high",
})
}
}
#[derive(Clone, Debug, Default)]
pub struct CompleteOptions {
pub max_tokens: Option<u32>,
pub reasoning: Reasoning,
pub tool_choice: Option<String>,
pub constrained_decoding: bool,
pub api_key: Option<String>,
}
#[derive(Clone, Debug, PartialEq)]
pub struct Completion {
pub message: Message,
pub stop_reason: StopReason,
pub usage: Usage,
}
#[derive(Clone, Debug, PartialEq)]
pub enum StreamEvent {
TextDelta {
content_index: usize,
delta: String,
},
ThinkingDelta {
content_index: usize,
delta: String,
},
ToolCallDelta {
content_index: usize,
id: Option<String>,
name: Option<String>,
arguments_delta: String,
},
Done {
stop_reason: StopReason,
usage: Usage,
message: Message,
},
}
pub type EventStream = BoxStream<'static, Result<StreamEvent, Error>>;
#[async_trait]
pub trait Provider: Send + Sync {
async fn complete(
&self,
http: &reqwest::Client,
model: &Model,
ctx: &Context,
opts: &CompleteOptions,
) -> Result<Completion, Error>;
async fn stream(
&self,
http: &reqwest::Client,
model: &Model,
ctx: &Context,
opts: &CompleteOptions,
) -> Result<EventStream, Error>;
}
use crate::ai::model::Model;
#[derive(Clone, Default)]
pub struct ProviderRegistry {
providers: HashMap<Api, Arc<dyn Provider>>,
}
impl ProviderRegistry {
pub fn new() -> Self {
ProviderRegistry {
providers: HashMap::new(),
}
}
pub fn with_builtins() -> Self {
let mut registry = ProviderRegistry::new();
registry.register(
Api::AnthropicMessages,
Arc::new(crate::ai::providers::anthropic::Anthropic),
);
registry.register(
Api::OpenAiCompletions,
Arc::new(crate::ai::providers::openai::OpenAi),
);
registry
}
pub fn register(&mut self, api: Api, provider: Arc<dyn Provider>) {
self.providers.insert(api, provider);
}
pub fn get(&self, api: Api) -> Option<Arc<dyn Provider>> {
self.providers.get(&api).cloned()
}
}
#[derive(Debug)]
pub enum Error {
Http(reqwest::Error),
Api { status: u16, message: String },
Parse(String),
Config(String),
}
impl std::fmt::Display for Error {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Error::Http(e) => write!(f, "http error: {e}"),
Error::Api { status, message } => write!(f, "api error {status}: {message}"),
Error::Parse(m) => write!(f, "parse error: {m}"),
Error::Config(m) => write!(f, "config error: {m}"),
}
}
}
impl std::error::Error for Error {}
impl From<reqwest::Error> for Error {
fn from(e: reqwest::Error) -> Self {
Error::Http(e)
}
}
#[cfg(test)]
#[path = "provider_tests.rs"]
mod tests;