594 lines
21 KiB
Rust
594 lines
21 KiB
Rust
//! OpenAI 兼容引擎。
|
||
//!
|
||
//! 一套代码覆盖 DeepSeek / OpenAI / 通义（DashScope 兼容模式）/ Kimi / 智谱 /
|
||
//! 本地 Ollama / LM Studio / one-api 等中转服务——它们都提供
|
||
//! `POST {baseUrl}/chat/completions` 且请求响应结构一致，因此差异只在配置项里。
|
||
//!
|
||
//! 翻译场景刻意**不开思考模式**：不写 `thinking` / `reasoning_effort`，换低延迟与低费用。
|
||
//! 若用户确实需要，可通过 `extra_body`（JSON 文本）自行透传。
|
||
|
||
use std::time::{Duration, Instant};
|
||
|
||
use serde::Deserialize;
|
||
use serde_json::json;
|
||
|
||
use super::{
|
||
apply_common_params, build_user_content, render_template, EngineRequest, ErrorKind, TokenUsage,
|
||
TranslateEngine, TranslateError, TranslateMode, TranslateResult,
|
||
};
|
||
use crate::translate::settings::{PromptTemplates, TranslateEngineConfig};
|
||
|
||
/// 自检与连通性测试使用的探测文本
|
||
const PROBE_TEXT: &str = "Hello, world.";
|
||
|
||
pub struct AiEngine {
|
||
cfg: TranslateEngineConfig,
|
||
templates: PromptTemplates,
|
||
client: reqwest::Client,
|
||
}
|
||
|
||
impl AiEngine {
|
||
pub fn new(
|
||
cfg: TranslateEngineConfig,
|
||
templates: PromptTemplates,
|
||
client: reqwest::Client,
|
||
) -> Self {
|
||
Self {
|
||
cfg,
|
||
templates,
|
||
client,
|
||
}
|
||
}
|
||
|
||
/// API 根地址。容错处理：用户常把完整端点（`.../chat/completions`）直接粘进来，
|
||
/// 若不在末尾剥掉，就会拼出 `.../chat/completions/chat/completions`，
|
||
/// 而这类错误在上游表现为 404，排查成本远高于此处一行判断。
|
||
fn api_root(&self) -> Result<String, TranslateError> {
|
||
let raw = self.cfg.base_url.trim();
|
||
if raw.is_empty() {
|
||
return Err(TranslateError::config(format!(
|
||
"引擎「{}」尚未配置 Base URL",
|
||
self.cfg.name
|
||
)));
|
||
}
|
||
if !(raw.starts_with("http://") || raw.starts_with("https://")) {
|
||
return Err(TranslateError::config(format!(
|
||
"Base URL 需以 http:// 或 https:// 开头，当前为「{raw}」"
|
||
)));
|
||
}
|
||
let mut root = raw.trim_end_matches('/').to_string();
|
||
for suffix in ["/chat/completions", "/completions", "/models"] {
|
||
if let Some(stripped) = root.strip_suffix(suffix) {
|
||
root = stripped.trim_end_matches('/').to_string();
|
||
break;
|
||
}
|
||
}
|
||
Ok(root)
|
||
}
|
||
|
||
fn chat_endpoint(&self) -> Result<String, TranslateError> {
|
||
Ok(format!("{}/chat/completions", self.api_root()?))
|
||
}
|
||
|
||
fn models_endpoint(&self) -> Result<String, TranslateError> {
|
||
Ok(format!("{}/models", self.api_root()?))
|
||
}
|
||
|
||
/// 密钥只从系统凭据管理器读，不进配置文件、不经前端。
|
||
fn api_key(&self) -> String {
|
||
crate::translate::engine_api_key(&self.cfg.id)
|
||
}
|
||
|
||
fn require_key(&self) -> Result<String, TranslateError> {
|
||
let key = self.api_key();
|
||
if key.trim().is_empty() {
|
||
return Err(TranslateError::auth(format!(
|
||
"引擎「{}」尚未配置 API Key，请在翻译设置中填写",
|
||
self.cfg.name
|
||
)));
|
||
}
|
||
Ok(key)
|
||
}
|
||
|
||
fn require_model(&self) -> Result<String, TranslateError> {
|
||
let model = self.cfg.model.trim();
|
||
if model.is_empty() {
|
||
return Err(TranslateError::config(format!(
|
||
"引擎「{}」尚未选择模型，可在设置中拉取模型列表后选择",
|
||
self.cfg.name
|
||
)));
|
||
}
|
||
Ok(model.to_string())
|
||
}
|
||
|
||
/// 有效 system prompt：实例级自定义提示词优先，否则用模式对应的全局模板。
|
||
fn system_prompt(&self, req: &EngineRequest) -> String {
|
||
if !self.cfg.system_prompt.trim().is_empty() {
|
||
return render_template(&self.cfg.system_prompt, req);
|
||
}
|
||
render_template(self.templates.for_mode(req.mode), req)
|
||
}
|
||
|
||
/// 流式收尾。空内容不直接判死：**自动改用同步接口重试一次**。
|
||
///
|
||
/// 上游偶发「流正常结束但 content 为空」（安全拦截、思维链吃满 max_tokens、
|
||
/// 中转服务抖动都会导致）。用户视角这与请求失败无异，但同步接口往往能正常
|
||
/// 返回——与其抛错让人手动重试，不如在这里自愈一次。重试失败才把错误交给上层。
|
||
async fn finish_stream_with_fallback(
|
||
&self,
|
||
tx: &tokio::sync::mpsc::Sender<super::StreamEvent>,
|
||
request_id: String,
|
||
content: String,
|
||
req: &EngineRequest,
|
||
started: Instant,
|
||
finish_reason: Option<String>,
|
||
) -> Result<(), TranslateError> {
|
||
if content.trim().is_empty() {
|
||
if tx.is_closed() {
|
||
// 调用方已放弃（停止 / 新请求顶替），不再花一次 API 调用
|
||
return Ok(());
|
||
}
|
||
crate::logger::log_warn(
|
||
"translate",
|
||
&format!(
|
||
"「{}」流式返回为空（finish_reason={:?}），自动改用同步接口重试",
|
||
self.cfg.name, finish_reason
|
||
),
|
||
);
|
||
// 同步路径的错误更具体（认证/额度/响应解析都能区分），直接透传
|
||
let result = self.translate(req).await?;
|
||
let _ = tx.send(super::StreamEvent::Done { request_id, result }).await;
|
||
return Ok(());
|
||
}
|
||
finish_stream(
|
||
tx,
|
||
request_id,
|
||
content,
|
||
req,
|
||
&self.cfg,
|
||
started.elapsed().as_millis() as u64,
|
||
)
|
||
.await
|
||
}
|
||
}
|
||
|
||
#[async_trait::async_trait]
|
||
impl TranslateEngine for AiEngine {
|
||
fn config(&self) -> &TranslateEngineConfig {
|
||
&self.cfg
|
||
}
|
||
|
||
async fn translate(&self, req: &EngineRequest) -> Result<TranslateResult, TranslateError> {
|
||
if req.text.trim().is_empty() {
|
||
return Err(TranslateError::empty());
|
||
}
|
||
let key = self.require_key()?;
|
||
let model = self.require_model()?;
|
||
let endpoint = self.chat_endpoint()?;
|
||
|
||
let mut body = serde_json::Map::new();
|
||
body.insert("model".to_string(), json!(model));
|
||
body.insert("stream".to_string(), json!(false));
|
||
body.insert(
|
||
"messages".to_string(),
|
||
json!([
|
||
{ "role": "system", "content": self.system_prompt(req) },
|
||
{ "role": "user", "content": build_user_content(req, self.cfg.supports_vision) },
|
||
]),
|
||
);
|
||
apply_common_params(&mut body, &self.cfg);
|
||
|
||
let started = Instant::now();
|
||
let resp = self
|
||
.client
|
||
.post(&endpoint)
|
||
.bearer_auth(&key)
|
||
.timeout(Duration::from_millis(self.cfg.timeout_ms.max(1000)))
|
||
.json(&serde_json::Value::Object(body))
|
||
.send()
|
||
.await
|
||
.map_err(|e| classify_reqwest(e, &self.cfg.name))?;
|
||
|
||
let status = resp.status();
|
||
let raw = resp
|
||
.text()
|
||
.await
|
||
.map_err(|e| TranslateError::network(format!("读取「{}」响应失败: {e}", self.cfg.name)))?;
|
||
|
||
if !status.is_success() {
|
||
return Err(classify_http(status.as_u16(), &raw, &self.cfg.name, &model));
|
||
}
|
||
|
||
let parsed: ChatResponse = serde_json::from_str(&raw).map_err(|e| {
|
||
TranslateError::parse(format!("「{}」响应不是预期的 JSON: {e}", self.cfg.name))
|
||
.with_detail(&raw)
|
||
})?;
|
||
|
||
if let Some(err) = parsed.error {
|
||
let msg = err
|
||
.message
|
||
.filter(|m| !m.trim().is_empty())
|
||
.unwrap_or_else(|| "上游返回了错误对象".to_string());
|
||
return Err(
|
||
TranslateError::new(ErrorKind::Unknown, format!("「{}」返回错误：{msg}", self.cfg.name))
|
||
.with_detail(&raw),
|
||
);
|
||
}
|
||
|
||
let text = parsed
|
||
.choices
|
||
.into_iter()
|
||
.next()
|
||
.and_then(|c| c.message.content)
|
||
.map(|s| s.trim().to_string())
|
||
.filter(|s| !s.is_empty())
|
||
.ok_or_else(TranslateError::empty)?;
|
||
|
||
let latency_ms = started.elapsed().as_millis() as u64;
|
||
let usage = parsed.usage.map(|u| {
|
||
let total = if u.total_tokens > 0 {
|
||
u.total_tokens
|
||
} else {
|
||
u.prompt_tokens + u.completion_tokens
|
||
};
|
||
TokenUsage {
|
||
prompt_tokens: u.prompt_tokens,
|
||
completion_tokens: u.completion_tokens,
|
||
total_tokens: total,
|
||
}
|
||
});
|
||
|
||
Ok(TranslateResult {
|
||
text,
|
||
// AI 引擎不做语言检测：显式指定了源语言时回显，auto 时留空由前端展示「自动」
|
||
detected: if req.from.trim().is_empty() || req.from == "auto" {
|
||
None
|
||
} else {
|
||
Some(req.from.clone())
|
||
},
|
||
engine_id: self.cfg.id.clone(),
|
||
engine_name: self.cfg.name.clone(),
|
||
latency_ms,
|
||
usage,
|
||
})
|
||
}
|
||
|
||
/// 流式翻译（SSE）。增量经通道下发，`data: [DONE]` 或流结束时发 Done。
|
||
///
|
||
/// 错误处理约定：**本方法不发送 `StreamEvent::Error`**——任何失败都通过 `Err` 返回，
|
||
/// 由命令层统一转成错误事件，避免前端收到两条错误。通道关闭（调用方已放弃，
|
||
/// 例如用户点了停止）时安静返回 `Ok(())`，不当作失败。
|
||
async fn translate_stream(
|
||
&self,
|
||
req: &EngineRequest,
|
||
request_id: String,
|
||
tx: tokio::sync::mpsc::Sender<super::StreamEvent>,
|
||
) -> Result<(), TranslateError> {
|
||
if req.text.trim().is_empty() && req.image_png.is_none() {
|
||
return Err(TranslateError::empty());
|
||
}
|
||
let key = self.require_key()?;
|
||
let model = self.require_model()?;
|
||
let endpoint = self.chat_endpoint()?;
|
||
|
||
let mut body = serde_json::Map::new();
|
||
body.insert("model".to_string(), json!(model));
|
||
body.insert("stream".to_string(), json!(true));
|
||
body.insert(
|
||
"messages".to_string(),
|
||
json!([
|
||
{ "role": "system", "content": self.system_prompt(req) },
|
||
{ "role": "user", "content": build_user_content(req, self.cfg.supports_vision) },
|
||
]),
|
||
);
|
||
apply_common_params(&mut body, &self.cfg);
|
||
|
||
let started = Instant::now();
|
||
let resp = self
|
||
.client
|
||
.post(&endpoint)
|
||
.bearer_auth(&key)
|
||
.timeout(Duration::from_millis(self.cfg.timeout_ms.max(1000)))
|
||
.json(&serde_json::Value::Object(body))
|
||
.send()
|
||
.await
|
||
.map_err(|e| classify_reqwest(e, &self.cfg.name))?;
|
||
|
||
let status = resp.status();
|
||
if !status.is_success() {
|
||
let raw = resp.text().await.unwrap_or_default();
|
||
return Err(classify_http(status.as_u16(), &raw, &self.cfg.name, &model));
|
||
}
|
||
|
||
// SSE 逐行解析：字节块可能把一行劈成两半，必须先攒缓冲再按 \n 切
|
||
use futures_util::StreamExt;
|
||
let mut stream = resp.bytes_stream();
|
||
let mut buffer: Vec<u8> = Vec::new();
|
||
let mut content = String::new();
|
||
let mut finish_reason: Option<String> = None;
|
||
|
||
while let Some(item) = stream.next().await {
|
||
let bytes =
|
||
item.map_err(|e| TranslateError::network(format!("读取流失败: {e}")))?;
|
||
buffer.extend_from_slice(&bytes);
|
||
while let Some(pos) = buffer.iter().position(|&b| b == b'\n') {
|
||
let line_bytes: Vec<u8> = buffer.drain(..=pos).collect();
|
||
let line = String::from_utf8_lossy(&line_bytes[..line_bytes.len() - 1]);
|
||
let Some(payload) = line.trim().strip_prefix("data:") else {
|
||
continue;
|
||
};
|
||
let payload = payload.trim();
|
||
if payload.is_empty() {
|
||
continue;
|
||
}
|
||
if payload == "[DONE]" {
|
||
return self
|
||
.finish_stream_with_fallback(
|
||
&tx,
|
||
request_id,
|
||
content,
|
||
req,
|
||
started,
|
||
finish_reason,
|
||
)
|
||
.await;
|
||
}
|
||
let Ok(value) = serde_json::from_str::<serde_json::Value>(payload) else {
|
||
continue;
|
||
};
|
||
// 上游在流中携带错误对象时终止
|
||
if let Some(message) = value
|
||
.pointer("/error/message")
|
||
.and_then(|m| m.as_str())
|
||
.filter(|m| !m.trim().is_empty())
|
||
{
|
||
return Err(TranslateError::new(
|
||
ErrorKind::Unknown,
|
||
format!("「{}」流中返回错误：{message}", self.cfg.name),
|
||
));
|
||
}
|
||
if let Some(fr) = value
|
||
.pointer("/choices/0/finish_reason")
|
||
.and_then(|v| v.as_str())
|
||
{
|
||
finish_reason = Some(fr.to_string());
|
||
}
|
||
let Some(delta) = value
|
||
.pointer("/choices/0/delta/content")
|
||
.and_then(|c| c.as_str())
|
||
.filter(|d| !d.is_empty())
|
||
else {
|
||
continue;
|
||
};
|
||
content.push_str(delta);
|
||
if tx
|
||
.send(super::StreamEvent::Chunk {
|
||
request_id: request_id.clone(),
|
||
delta: delta.to_string(),
|
||
})
|
||
.await
|
||
.is_err()
|
||
{
|
||
// 通道已关 = 调用方放弃（停止 / 新请求顶替），安静退出
|
||
return Ok(());
|
||
}
|
||
}
|
||
}
|
||
|
||
// 流结束但没收到 [DONE]：部分上游异常断流。已有内容仍视为成功，
|
||
// 否则用户会看着已译出一半的结果被告知失败。
|
||
self.finish_stream_with_fallback(
|
||
&tx,
|
||
request_id,
|
||
content,
|
||
req,
|
||
started,
|
||
finish_reason,
|
||
)
|
||
.await
|
||
}
|
||
|
||
async fn list_models(&self) -> Result<Vec<String>, TranslateError> {
|
||
let key = self.require_key()?;
|
||
let endpoint = self.models_endpoint()?;
|
||
let resp = self
|
||
.client
|
||
.get(&endpoint)
|
||
.bearer_auth(&key)
|
||
.timeout(Duration::from_millis(self.cfg.timeout_ms.clamp(3_000, 15_000)))
|
||
.send()
|
||
.await
|
||
.map_err(|e| classify_reqwest(e, &self.cfg.name))?;
|
||
|
||
let status = resp.status();
|
||
let raw = resp
|
||
.text()
|
||
.await
|
||
.map_err(|e| TranslateError::network(format!("读取「{}」模型列表失败: {e}", self.cfg.name)))?;
|
||
|
||
if !status.is_success() {
|
||
return Err(classify_http(
|
||
status.as_u16(),
|
||
&raw,
|
||
&self.cfg.name,
|
||
self.cfg.model.as_str(),
|
||
));
|
||
}
|
||
|
||
let parsed: ModelsResponse = serde_json::from_str(&raw).map_err(|e| {
|
||
TranslateError::parse(format!("「{}」的模型列表无法解析: {e}", self.cfg.name))
|
||
.with_detail(&raw)
|
||
})?;
|
||
|
||
let mut ids: Vec<String> = parsed
|
||
.data
|
||
.into_iter()
|
||
.map(|m| m.id)
|
||
.filter(|id| !id.trim().is_empty())
|
||
.collect();
|
||
ids.sort();
|
||
ids.dedup();
|
||
Ok(ids)
|
||
}
|
||
|
||
async fn test(&self) -> Result<String, TranslateError> {
|
||
let req = EngineRequest {
|
||
text: PROBE_TEXT.to_string(),
|
||
from: "en".to_string(),
|
||
to: "zh-Hans".to_string(),
|
||
to_label: "简体中文".to_string(),
|
||
from_label: "英语".to_string(),
|
||
mode: TranslateMode::Translate,
|
||
image_png: None,
|
||
via: "preview".to_string(),
|
||
};
|
||
let started = Instant::now();
|
||
let result = self.translate(&req).await?;
|
||
let total = started.elapsed().as_millis() as u64;
|
||
Ok(format!(
|
||
"连通正常 · 模型 {} · {}ms · 回显「{}」",
|
||
self.cfg.model, total, result.text
|
||
))
|
||
}
|
||
}
|
||
|
||
/// 收尾：把累积内容封装成结果下发。空内容按「上游没产出」处理。
|
||
async fn finish_stream(
|
||
tx: &tokio::sync::mpsc::Sender<super::StreamEvent>,
|
||
request_id: String,
|
||
content: String,
|
||
req: &EngineRequest,
|
||
cfg: &TranslateEngineConfig,
|
||
latency_ms: u64,
|
||
) -> Result<(), TranslateError> {
|
||
let text = content.trim().to_string();
|
||
if text.is_empty() {
|
||
return Err(TranslateError::new(
|
||
ErrorKind::Empty,
|
||
format!("「{}」未返回任何译文（流提前结束）", cfg.name),
|
||
));
|
||
}
|
||
let _ = tx
|
||
.send(super::StreamEvent::Done {
|
||
request_id,
|
||
result: TranslateResult {
|
||
text,
|
||
detected: if req.from.trim().is_empty() || req.from == "auto" {
|
||
None
|
||
} else {
|
||
Some(req.from.clone())
|
||
},
|
||
engine_id: cfg.id.clone(),
|
||
engine_name: cfg.name.clone(),
|
||
latency_ms,
|
||
// 流式路径不索取 usage：stream_options 是各家扩展，兼容性不一
|
||
usage: None,
|
||
},
|
||
})
|
||
.await;
|
||
Ok(())
|
||
}
|
||
|
||
/// 网络层错误分类。
|
||
fn classify_reqwest(e: reqwest::Error, engine: &str) -> TranslateError {
|
||
if e.is_timeout() {
|
||
return TranslateError::timeout(format!(
|
||
"请求「{engine}」超时，可在引擎设置中调大超时时间，或检查网络"
|
||
));
|
||
}
|
||
if e.is_connect() {
|
||
return TranslateError::network(format!(
|
||
"无法连接「{engine}」：{e}（若该服务在境外，请检查网络或开启代理）"
|
||
));
|
||
}
|
||
TranslateError::network(format!("请求「{engine}」失败：{e}"))
|
||
}
|
||
|
||
/// HTTP 状态码分类。把「Key 不对」「模型名不对」「被限流」分开，
|
||
/// 是因为这三者在前端的处置动作完全不同。
|
||
fn classify_http(status: u16, body: &str, engine: &str, model: &str) -> TranslateError {
|
||
let snippet = body.trim();
|
||
let lower = snippet.to_lowercase();
|
||
let err = match status {
|
||
401 | 403 => TranslateError::auth(format!(
|
||
"「{engine}」认证失败（HTTP {status}），请检查 API Key 是否正确、是否有该模型的权限"
|
||
)),
|
||
402 => TranslateError::auth(format!("「{engine}」余额不足或未开通计费（HTTP 402）")),
|
||
429 => TranslateError::rate_limit(format!(
|
||
"「{engine}」请求过于频繁（HTTP 429），请稍后重试或降低频率"
|
||
)),
|
||
400 | 404 | 422 => {
|
||
if lower.contains("model") {
|
||
TranslateError::config(format!(
|
||
"「{engine}」不识别模型「{model}」（HTTP {status}）：上游模型名可能已变更，\
|
||
请在设置中拉取模型列表后重新选择"
|
||
))
|
||
} else {
|
||
TranslateError::new(
|
||
ErrorKind::Config,
|
||
format!("「{engine}」拒绝了该请求（HTTP {status}）"),
|
||
)
|
||
}
|
||
}
|
||
408 | 504 => TranslateError::timeout(format!("「{engine}」上游超时（HTTP {status}）")),
|
||
s if (500..600).contains(&s) => {
|
||
TranslateError::network(format!("「{engine}」服务端错误（HTTP {status}），可稍后重试"))
|
||
}
|
||
s => TranslateError::new(ErrorKind::Unknown, format!("「{engine}」返回 HTTP {s}")),
|
||
};
|
||
err.with_detail(snippet)
|
||
}
|
||
|
||
// ===== 响应结构（宽松解析：缺字段不报错，由业务层判断内容是否可用） =====
|
||
|
||
#[derive(Debug, Deserialize)]
|
||
struct ChatResponse {
|
||
#[serde(default)]
|
||
choices: Vec<ChatChoice>,
|
||
#[serde(default)]
|
||
usage: Option<ChatUsage>,
|
||
#[serde(default)]
|
||
error: Option<ApiErrorBody>,
|
||
}
|
||
|
||
#[derive(Debug, Deserialize)]
|
||
struct ChatChoice {
|
||
#[serde(default)]
|
||
message: ChatMessage,
|
||
}
|
||
|
||
#[derive(Debug, Default, Deserialize)]
|
||
struct ChatMessage {
|
||
/// 部分实现会返回 null（例如只产出思维链时），故用 Option 而非 String
|
||
#[serde(default)]
|
||
content: Option<String>,
|
||
}
|
||
|
||
#[derive(Debug, Deserialize)]
|
||
struct ChatUsage {
|
||
#[serde(default)]
|
||
prompt_tokens: u32,
|
||
#[serde(default)]
|
||
completion_tokens: u32,
|
||
#[serde(default)]
|
||
total_tokens: u32,
|
||
}
|
||
|
||
#[derive(Debug, Deserialize)]
|
||
struct ApiErrorBody {
|
||
#[serde(default)]
|
||
message: Option<String>,
|
||
}
|
||
|
||
#[derive(Debug, Deserialize)]
|
||
struct ModelsResponse {
|
||
#[serde(default)]
|
||
data: Vec<ModelEntry>,
|
||
}
|
||
|
||
#[derive(Debug, Deserialize)]
|
||
struct ModelEntry {
|
||
#[serde(default)]
|
||
id: String,
|
||
}
|