. refactor - decouple AdapterDispatcher from Adapter trait

examples/c06-target-resolver.rs

@@ -1,10 +1,8 @@
-//! This example demonstrates how to use a custom ServiceTargetResolver which gives full control of the final
-//! mapping for Endpoint, Model/AdapterKind, and Auth
+//! This example demonstrates how to use a custom ServiceTargetResolver which gives full control over the final
+//! mapping for Endpoint, Model/AdapterKind, and Auth.
 //!
 //! IMPORTANT - Here we are using xAI as an example of a custom ServiceTarget.
-//!             It works with regular chat using the basic OpenAIAdapter,
-//!             but for streaming, xAI does not follow OpenAI's specifications.
-//!             Therefore, below we use regular chat, and this crate provides an XaiAdapter.
+//!             However, there is now an XaiAdapter, which gets activated on `starts_with("grok")`.
 
 use genai::adapter::AdapterKind;
 use genai::chat::{ChatMessage, ChatRequest};

src/adapter/adapter_types.rs

@@ -11,9 +11,9 @@ pub trait Adapter {
 	// #[deprecated(note = "use default_auth")]
 	// fn default_key_env_name(kind: AdapterKind) -> Option<&'static str>;
 
-	fn default_auth(kind: AdapterKind) -> AuthData;
+	fn default_auth() -> AuthData;
 
-	fn default_endpoint(kind: AdapterKind) -> Endpoint;
+	fn default_endpoint() -> Endpoint;
 
 	// NOTE: Adapter is a crate trait, so it is acceptable to use async fn here.
 	async fn all_model_names(kind: AdapterKind) -> Result<Vec<String>>;

src/adapter/adapters/anthropic/adapter_impl.rs

@@ -31,12 +31,12 @@ const MODELS: &[&str] = &[
 ];
 
 impl Adapter for AnthropicAdapter {
-	fn default_endpoint(_kind: AdapterKind) -> Endpoint {
+	fn default_endpoint() -> Endpoint {
 		const BASE_URL: &str = "https://api.anthropic.com/v1/";
 		Endpoint::from_static(BASE_URL)
 	}
 
-	fn default_auth(_kind: AdapterKind) -> AuthData {
+	fn default_auth() -> AuthData {
 		AuthData::from_env("ANTHROPIC_API_KEY")
 	}
 

src/adapter/adapters/cohere/adapter_impl.rs

@@ -24,12 +24,12 @@ const MODELS: &[&str] = &[
 ];
 
 impl Adapter for CohereAdapter {
-	fn default_endpoint(_kind: AdapterKind) -> Endpoint {
+	fn default_endpoint() -> Endpoint {
 		const BASE_URL: &str = "https://api.cohere.com/v1/";
 		Endpoint::from_static(BASE_URL)
 	}
 
-	fn default_auth(_kind: AdapterKind) -> AuthData {
+	fn default_auth() -> AuthData {
 		AuthData::from_env("COHERE_API_KEY")
 	}
 

src/adapter/adapters/gemini/adapter_impl.rs

@@ -29,12 +29,12 @@ const MODELS: &[&str] = &[
 //   -X POST 'https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash-latest:generateContent?key=YOUR_API_KEY'
 
 impl Adapter for GeminiAdapter {
-	fn default_endpoint(_kind: AdapterKind) -> Endpoint {
+	fn default_endpoint() -> Endpoint {
 		const BASE_URL: &str = "https://generativelanguage.googleapis.com/v1beta/";
 		Endpoint::from_static(BASE_URL)
 	}
 
-	fn default_auth(_kind: AdapterKind) -> AuthData {
+	fn default_auth() -> AuthData {
 		AuthData::from_env("GEMINI_API_KEY")
 	}
 

src/adapter/adapters/groq/adapter_impl.rs

@@ -29,12 +29,12 @@ pub(in crate::adapter) const MODELS: &[&str] = &[
 
 // The Groq API adapter is modeled after the OpenAI adapter, as the Groq API is compatible with the OpenAI API.
 impl Adapter for GroqAdapter {
-	fn default_endpoint(_kind: AdapterKind) -> Endpoint {
+	fn default_endpoint() -> Endpoint {
 		const BASE_URL: &str = "https://api.groq.com/openai/v1/";
 		Endpoint::from_static(BASE_URL)
 	}
 
-	fn default_auth(_kind: AdapterKind) -> AuthData {
+	fn default_auth() -> AuthData {
 		AuthData::from_env("GROQ_API_KEY")
 	}
 

src/adapter/adapters/ollama/adapter_impl.rs

@@ -17,12 +17,12 @@ pub struct OllamaAdapter;
 ///       (https://github.com/ollama/ollama/blob/main/docs/openai.md)
 ///       Since the base Ollama API supports `application/x-ndjson` for streaming, whereas others support `text/event-stream`
 impl Adapter for OllamaAdapter {
-	fn default_endpoint(_kind: AdapterKind) -> Endpoint {
+	fn default_endpoint() -> Endpoint {
 		const BASE_URL: &str = "http://localhost:11434/v1/";
 		Endpoint::from_static(BASE_URL)
 	}
 
-	fn default_auth(_kind: AdapterKind) -> AuthData {
+	fn default_auth() -> AuthData {
 		AuthData::from_single("ollama")
 	}
 
@@ -33,7 +33,7 @@ impl Adapter for OllamaAdapter {
 	///       Later, we might add another function with a endpoint, so the the user can give an custom endpoint.
 	async fn all_model_names(adapter_kind: AdapterKind) -> Result<Vec<String>> {
 		// FIXME: This is harcoded to the default endpoint, should take endpoint as Argument
-		let endpoint = Self::default_endpoint(adapter_kind);
+		let endpoint = Self::default_endpoint();
 		let base_url = endpoint.base_url();
 		let url = format!("{base_url}models");
 

src/adapter/adapters/openai/adapter_impl.rs

@@ -27,12 +27,12 @@ const MODELS: &[&str] = &[
 ];
 
 impl Adapter for OpenAIAdapter {
-	fn default_endpoint(_kind: AdapterKind) -> Endpoint {
+	fn default_endpoint() -> Endpoint {
 		const BASE_URL: &str = "https://api.openai.com/v1/";
 		Endpoint::from_static(BASE_URL)
 	}
 
-	fn default_auth(_kind: AdapterKind) -> AuthData {
+	fn default_auth() -> AuthData {
 		AuthData::from_env("OPENAI_API_KEY")
 	}
 

src/adapter/adapters/xai/adapter_impl.rs

@@ -13,12 +13,12 @@ pub(in crate::adapter) const MODELS: &[&str] = &["grok-beta"];
 
 // The Groq API adapter is modeled after the OpenAI adapter, as the Groq API is compatible with the OpenAI API.
 impl Adapter for XaiAdapter {
-	fn default_endpoint(_kind: AdapterKind) -> Endpoint {
+	fn default_endpoint() -> Endpoint {
 		const BASE_URL: &str = "https://api.x.ai/v1/";
 		Endpoint::from_static(BASE_URL)
 	}
 
-	fn default_auth(_kind: AdapterKind) -> AuthData {
+	fn default_auth() -> AuthData {
 		AuthData::from_env("XAI_API_KEY")
 	}
 

src/adapter/dispatcher.rs

@@ -14,34 +14,39 @@ use super::groq::GroqAdapter;
 use crate::adapter::xai::XaiAdapter;
 use crate::resolver::{AuthData, Endpoint};
 
+/// A construct that allows dispatching calls to the Adapters.
+///
+/// Note 1: This struct does not need to implement the Adapter trait, as some of its methods take the adapter_kind as a parameter.
+///
+/// Note 2: This struct might be renamed to avoid confusion with the traditional Rust dispatcher pattern.
 pub struct AdapterDispatcher;
 
-impl Adapter for AdapterDispatcher {
-	fn default_endpoint(kind: AdapterKind) -> Endpoint {
+impl AdapterDispatcher {
+	pub fn default_endpoint(kind: AdapterKind) -> Endpoint {
 		match kind {
-			AdapterKind::OpenAI => OpenAIAdapter::default_endpoint(kind),
-			AdapterKind::Anthropic => AnthropicAdapter::default_endpoint(kind),
-			AdapterKind::Cohere => CohereAdapter::default_endpoint(kind),
-			AdapterKind::Ollama => OllamaAdapter::default_endpoint(kind),
-			AdapterKind::Gemini => GeminiAdapter::default_endpoint(kind),
-			AdapterKind::Groq => GroqAdapter::default_endpoint(kind),
-			AdapterKind::Xai => XaiAdapter::default_endpoint(kind),
+			AdapterKind::OpenAI => OpenAIAdapter::default_endpoint(),
+			AdapterKind::Anthropic => AnthropicAdapter::default_endpoint(),
+			AdapterKind::Cohere => CohereAdapter::default_endpoint(),
+			AdapterKind::Ollama => OllamaAdapter::default_endpoint(),
+			AdapterKind::Gemini => GeminiAdapter::default_endpoint(),
+			AdapterKind::Groq => GroqAdapter::default_endpoint(),
+			AdapterKind::Xai => XaiAdapter::default_endpoint(),
 		}
 	}
 
-	fn default_auth(kind: AdapterKind) -> AuthData {
+	pub fn default_auth(kind: AdapterKind) -> AuthData {
 		match kind {
-			AdapterKind::OpenAI => OpenAIAdapter::default_auth(kind),
-			AdapterKind::Anthropic => AnthropicAdapter::default_auth(kind),
-			AdapterKind::Cohere => CohereAdapter::default_auth(kind),
-			AdapterKind::Ollama => OllamaAdapter::default_auth(kind),
-			AdapterKind::Gemini => GeminiAdapter::default_auth(kind),
-			AdapterKind::Groq => GroqAdapter::default_auth(kind),
-			AdapterKind::Xai => XaiAdapter::default_auth(kind),
+			AdapterKind::OpenAI => OpenAIAdapter::default_auth(),
+			AdapterKind::Anthropic => AnthropicAdapter::default_auth(),
+			AdapterKind::Cohere => CohereAdapter::default_auth(),
+			AdapterKind::Ollama => OllamaAdapter::default_auth(),
+			AdapterKind::Gemini => GeminiAdapter::default_auth(),
+			AdapterKind::Groq => GroqAdapter::default_auth(),
+			AdapterKind::Xai => XaiAdapter::default_auth(),
 		}
 	}
 
-	async fn all_model_names(kind: AdapterKind) -> Result<Vec<String>> {
+	pub async fn all_model_names(kind: AdapterKind) -> Result<Vec<String>> {
 		match kind {
 			AdapterKind::OpenAI => OpenAIAdapter::all_model_names(kind).await,
 			AdapterKind::Anthropic => AnthropicAdapter::all_model_names(kind).await,
@@ -53,7 +58,7 @@ impl Adapter for AdapterDispatcher {
 		}
 	}
 
-	fn get_service_url(model: &ModelIden, service_type: ServiceType, endpoint: Endpoint) -> String {
+	pub fn get_service_url(model: &ModelIden, service_type: ServiceType, endpoint: Endpoint) -> String {
 		match model.adapter_kind {
 			AdapterKind::OpenAI => OpenAIAdapter::get_service_url(model, service_type, endpoint),
 			AdapterKind::Anthropic => AnthropicAdapter::get_service_url(model, service_type, endpoint),
@@ -65,7 +70,7 @@ impl Adapter for AdapterDispatcher {
 		}
 	}
 
-	fn to_web_request_data(
+	pub fn to_web_request_data(
 		target: ServiceTarget,
 		service_type: ServiceType,
 		chat_req: ChatRequest,
@@ -85,7 +90,7 @@ impl Adapter for AdapterDispatcher {
 		}
 	}
 
-	fn to_chat_response(model_iden: ModelIden, web_response: WebResponse) -> Result<ChatResponse> {
+	pub fn to_chat_response(model_iden: ModelIden, web_response: WebResponse) -> Result<ChatResponse> {
 		match model_iden.adapter_kind {
 			AdapterKind::OpenAI => OpenAIAdapter::to_chat_response(model_iden, web_response),
 			AdapterKind::Anthropic => AnthropicAdapter::to_chat_response(model_iden, web_response),
@@ -97,7 +102,7 @@ impl Adapter for AdapterDispatcher {
 		}
 	}
 
-	fn to_chat_stream(
+	pub fn to_chat_stream(
 		model_iden: ModelIden,
 		reqwest_builder: RequestBuilder,
 		options_set: ChatOptionsSet<'_, '_>,

src/client/client_impl.rs

@@ -1,4 +1,4 @@
-use crate::adapter::{Adapter, AdapterDispatcher, AdapterKind, ServiceType, WebRequestData};
+use crate::adapter::{AdapterDispatcher, AdapterKind, ServiceType, WebRequestData};
 use crate::chat::{ChatOptions, ChatOptionsSet, ChatRequest, ChatResponse, ChatStreamResponse};
 use crate::{Client, Error, ModelIden, Result, ServiceTarget};
 

src/client/config.rs

@@ -1,4 +1,4 @@
-use crate::adapter::{Adapter, AdapterDispatcher};
+use crate::adapter::AdapterDispatcher;
 use crate::chat::ChatOptions;
 use crate::client::ServiceTarget;
 use crate::resolver::{AuthResolver, ModelMapper, ServiceTargetResolver};