genai 0.6.0-beta.5

Multi-AI Providers Library for Rust. (OpenAI, Gemini, Anthropic, xAI, Ollama, Groq, DeepSeek, Grok)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

// region:    --- AliyunAdapter

use crate::adapter::openai::OpenAIAdapter;
use crate::adapter::{Adapter, AdapterKind, ServiceType, WebRequestData};
use crate::chat::{ChatOptionsSet, ChatRequest, ChatResponse, ChatStreamResponse};
use crate::resolver::{AuthData, Endpoint};
use crate::webc::WebResponse;
use crate::{ModelIden, Result, ServiceTarget};
use reqwest::RequestBuilder;

/// Aliyun Adapter - Uses OpenAI-compatible API for Dashscope (Aliyun)
///
/// Aliyun Dashscope API provides OpenAI-compatible endpoints for chat, streaming, and embedding.
/// This adapter delegates most of the implementation to OpenAIAdapter utilities.
#[derive(Debug)]
pub struct AliyunAdapter;
// All Aliyun supported models
// NOTE: These are sourced from the official Aliyun Dashscope documentation
pub const MODELS: &[&str] = &[
	// Chat models
	"qwen-turbo",
	"qwen-plus",
	"qwen-max",
	"qwen-max-longcontext",
	"qwen-turbo-latest",
	"qwen-plus-latest",
	"qwen-max-latest",
	// Vision-language models
	"qwen-vl-plus",
	"qwen-vl-max",
	"qwen-vl-plus-latest",
	// Open source models
	"qwen-7b-chat",
	"qwen-14b-chat",
	"qwen-72b-chat",
	"qwen-72b-chat-int4",
	// Math models
	"qwen-math-plus",
	"qwen-math-turbo",
	"qwen-math-plus-latest",
	"qwen-math-turbo-latest",
	// Audio models
	"qwen-audio-turbo",
	"qwen-audio-plus",
	"qwen-audio-chat-v1",
	// Code models
	"qwen-coder-plus",
	"qwen-coder-turbo",
	"qwen-coder-latest",
];
impl AliyunAdapter {
	pub const API_KEY_DEFAULT_ENV_NAME: &str = "ALIYUN_API_KEY";
}

impl Adapter for AliyunAdapter {
	const DEFAULT_API_KEY_ENV_NAME: Option<&'static str> = Some(Self::API_KEY_DEFAULT_ENV_NAME);

	/// Returns the default endpoint for Aliyun Dashscope API
	fn default_endpoint() -> Endpoint {
		const BASE_URL: &str = "https://dashscope.aliyuncs.com/compatible-mode/v1/";
		Endpoint::from_static(BASE_URL)
	}

	/// Returns authentication data with API key prefix AILIYUN and environment variable ALIYUN_API_KEY
	fn default_auth() -> AuthData {
		match Self::DEFAULT_API_KEY_ENV_NAME {
			Some(env_name) => AuthData::from_env(env_name),
			None => AuthData::None,
		}
	}

	/// Returns all supported model names for Aliyun
	async fn all_model_names(_kind: AdapterKind, _endpoint: Endpoint, _auth: AuthData) -> Result<Vec<String>> {
		Ok(MODELS.iter().map(|s| s.to_string()).collect())
	}

	/// Returns the service URL for the given model
	///
	/// Since Aliyun Dashscope API is OpenAI-compatible, we use the OpenAI URL pattern.
	fn get_service_url(_model: &ModelIden, service_type: ServiceType, endpoint: Endpoint) -> Result<String> {
		let base_url = endpoint.base_url();

		let url = match service_type {
			ServiceType::Chat | ServiceType::ChatStream => format!("{base_url}chat/completions"),
			ServiceType::Embed => format!("{base_url}embeddings"),
		};
		Ok(url)
	}

	/// Converts chat request data to web request format
	///
	/// Delegates to OpenAIAdapter utilities due to API compatibility.
	fn to_web_request_data(
		target: ServiceTarget,
		service_type: ServiceType,
		chat_req: ChatRequest,
		chat_options: ChatOptionsSet<'_, '_>,
	) -> Result<WebRequestData> {
		// Parse model name and determine appropriate endpoint
		OpenAIAdapter::util_to_web_request_data(target, service_type, chat_req, chat_options, None)
	}

	/// Converts response bytes to ChatResponse
	///
	/// Delegates to OpenAIAdapter due to API compatibility.
	fn to_chat_response(
		model_iden: ModelIden,
		web_response: WebResponse,
		options_set: ChatOptionsSet<'_, '_>,
	) -> Result<ChatResponse> {
		OpenAIAdapter::to_chat_response(model_iden, web_response, options_set)
	}

	/// Converts response stream to ChatStream
	///
	/// Delegates to OpenAIAdapter due to API compatibility.
	fn to_chat_stream(
		model_iden: ModelIden,
		reqwest_builder: RequestBuilder,
		options_set: ChatOptionsSet<'_, '_>,
	) -> Result<ChatStreamResponse> {
		OpenAIAdapter::to_chat_stream(model_iden, reqwest_builder, options_set)
	}

	/// Converts embedding request data to web request format
	///
	/// Delegates to OpenAIAdapter utilities due to API compatibility.
	fn to_embed_request_data(
		service_target: crate::ServiceTarget,
		embed_req: crate::embed::EmbedRequest,
		options_set: crate::embed::EmbedOptionsSet<'_, '_>,
	) -> Result<crate::adapter::WebRequestData> {
		OpenAIAdapter::to_embed_request_data(service_target, embed_req, options_set)
	}

	/// Converts response bytes to EmbedResponse
	///
	/// Delegates to OpenAIAdapter due to API compatibility.
	fn to_embed_response(
		model_iden: crate::ModelIden,
		web_response: crate::webc::WebResponse,
		options_set: crate::embed::EmbedOptionsSet<'_, '_>,
	) -> Result<crate::embed::EmbedResponse> {
		OpenAIAdapter::to_embed_response(model_iden, web_response, options_set)
	}
}

// endregion: --- AliyunAdapter