chore(release): bump version to 0.6.0 and update changelog

- CHANGELOG 记录 LLM 层迁移至 rig-core 0.41 及四项行为变化
- README（中/英）项目结构树更新为新 llm 模块布局
- 仓库内 AI 服务集成文档同步为新实现（.qoder，不入库）

CHANGELOG.md

@@ -9,6 +9,24 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 暂无。
 
+## [0.6.0] - 2026-08-17
+
+### ✨ 新功能
+- LLM 层整体迁移至 rig-core 0.41：六家 provider（Ollama / OpenAI / Anthropic / Kimi / DeepSeek / OpenRouter）统一由 rig 原生客户端驱动，删除约 2100 行手写 HTTP/SSE/重试代码
+- 新 LLM 门面（`src/llm/rig/`）：provider 枚举 + 单一生成入口 + 凭据校验（rig VerifyClient）+ 错误映射层；提示词与提交解析拆分至独立模块
+- Anthropic 支持自定义 `base_url`（此前被静默忽略，本次修复）
+- 新增基于 rig mock 后端的 LLM 层离线测试（请求形状、流式事件、错误映射），并附 6 家 provider 的 `#[ignore]` 实网冒烟用例
+
+### 🐞 错误修复
+- 各 provider 超时统一由 `llm.timeout` 配置控制（此前默认超时 60/120/300 秒不一致）
+- 消除 Ollama 客户端构造时的 panic（`expect` 式构造）
+
+### 🔧 其他变更（行为变化）
+- Ollama 请求端点由 `/api/generate` 改为 `/api/chat`（功能等价；自定义 Ollama 代理需兼容 chat 端点）
+- 非流式请求不再做应用层重试（此前按错误文案字符串匹配重试 3 次）；流式请求由 rig 的 SSE 机制自动重连
+- 可用性校验端点变化：DeepSeek 改为 `/user/balance`、OpenRouter 改为 `/key`、Anthropic 改为 `/v1/models`（对外表现为 `LLM provider 'xxx' is not available` 语义不变）
+- 依赖瘦身：移除 `reqwest`(0.12) 与 `async-trait` 直接依赖，不引入 rig agent/fastembed/lancedb 等组件
+
 ## [0.5.0] - 2026-07-24
 
 ### ✨ 新功能

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "quicommit"
-version = "0.5.5"
+version = "0.6.0"
 edition = "2024"
 authors = ["Sidney Zhang <zly@lyzhang.me>"]
 description = "A powerful Git assistant tool with AI-powered commit/tag/changelog generation"
@@ -32,9 +32,7 @@ dirs = "5.0"
 git2 = "0.20.3"
 which = "6.0"
 
-# HTTP client for LLM APIs
+tokio = { version = "1.35", features = ["full", "macros", "rt-multi-thread"] }
-reqwest = { version = "0.12", features = ["json", "rustls-tls", "stream"], default-features = false }
-tokio = { version = "1.35", features = ["full"] }
 
 # Error handling
 thiserror = "1.0"
@@ -57,7 +55,6 @@ tempfile = "3.9"
 sha2 = "0.10"
 hex = "0.4"
 textwrap = "0.16"
-async-trait = "0.1"
 futures-util = "0.3"
 serde_json = "1.0"
 atty = "0.2"
@@ -76,6 +73,8 @@ edit = "0.1"
 
 # Shell completion generation
 shell-words = "1.1"
+# LLM integration (rig-core only: HTTP backend + rustls; no agent/derive)
+rig-core = { version = "0.41", default-features = false, features = ["reqwest", "rustls"] }
 
 [dev-dependencies]
 assert_cmd = "2.0"
@@ -83,6 +82,9 @@ predicates = "3.1"
 tempfile = "3.9"
 mockall = "0.12"
 wiremock = "0.6"
+# rig mock HTTP backends for LLM layer tests
+rig-core = { version = "0.41", default-features = false, features = ["test-utils"] }
+http = "1"
 
 [profile.release]
 opt-level = "s"

README.md

@@ -542,13 +542,12 @@ src/
 │   ├── commit.rs
 │   ├── tag.rs
 │   └── changelog.rs
-├── llm/         # LLM provider implementations
+├── llm/         # LLM integration (rig-core based)
-│   ├── ollama.rs
+│   ├── mod.rs
-│   ├── openai.rs
+│   ├── prompts.rs
-│   ├── anthropic.rs
+│   ├── parsing.rs
-│   ├── kimi.rs
+│   ├── thinking.rs
-│   ├── deepseek.rs
+│   └── rig/      # rig provider facade
-│   └── openrouter.rs
 ├── i18n/        # Internationalization support
 │   ├── messages.rs
 │   └── translator.rs

readme_zh.md

@@ -536,13 +536,12 @@ src/
 │   ├── commit.rs
 │   ├── tag.rs
 │   └── changelog.rs
-├── llm/         # LLM提供商实现
+├── llm/         # LLM 集成（基于 rig-core）
-│   ├── ollama.rs
+│   ├── mod.rs
-│   ├── openai.rs
+│   ├── prompts.rs
-│   ├── anthropic.rs
+│   ├── parsing.rs
-│   ├── kimi.rs
+│   ├── thinking.rs
-│   ├── deepseek.rs
+│   └── rig/      # rig provider 门面
-│   └── openrouter.rs
 ├── i18n/        # 国际化支持
 │   ├── messages.rs
 │   └── translator.rs

src/generator/mod.rs

@@ -1,7 +1,8 @@
 use crate::config::manager::ConfigManager;
 use crate::config::{CommitFormat, Language};
 use crate::git::{CommitInfo, GitRepo};
-use crate::llm::{GeneratedCommit, LlmClient};
+use crate::llm::parsing::GeneratedCommit;
+use crate::llm::rig::LlmClient;
 use anyhow::{Context, Result};
 
 /// Content generator using LLM

src/llm/anthropic.rs

@@ -1,655 +0,0 @@
-use super::thinking::ThinkingStateManager;
-use super::{LlmProvider, create_http_client};
-use anyhow::{Context, Result, bail};
-use async_trait::async_trait;
-use serde::{Deserialize, Serialize};
-use std::sync::Arc;
-use std::time::Duration;
-
-/// Anthropic Claude API client
-pub struct AnthropicClient {
-    api_key: String,
-    model: String,
-    client: reqwest::Client,
-    thinking_enabled: bool,
-    thinking_budget_tokens: u32,
-    max_tokens: u32,
-    temperature: f32,
-    top_p: Option<f32>,
-    thinking_state: Option<Arc<ThinkingStateManager>>,
-}
-
-#[derive(Debug, Serialize)]
-struct MessagesRequest {
-    model: String,
-    max_tokens: u32,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    temperature: Option<f32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    top_p: Option<f32>,
-    messages: Vec<AnthropicMessage>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    system: Option<Vec<SystemContent>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    thinking: Option<ThinkingConfig>,
-    stream: bool,
-}
-
-#[derive(Debug, Serialize, Clone)]
-struct SystemContent {
-    #[serde(rename = "type")]
-    content_type: String,
-    text: String,
-}
-
-#[derive(Debug, Serialize)]
-struct ThinkingConfig {
-    #[serde(rename = "type")]
-    thinking_type: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    budget_tokens: Option<u32>,
-}
-
-#[derive(Debug, Serialize, Deserialize, Clone)]
-struct AnthropicMessage {
-    role: String,
-    content: AnthropicContent,
-}
-
-#[derive(Debug, Serialize, Deserialize, Clone)]
-#[serde(untagged)]
-enum AnthropicContent {
-    Text(String),
-    Blocks(Vec<ContentBlock>),
-}
-
-#[derive(Debug, Serialize, Deserialize, Clone)]
-struct ContentBlock {
-    #[serde(rename = "type")]
-    content_type: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    text: Option<String>,
-}
-
-#[derive(Debug, Deserialize)]
-struct MessagesResponse {
-    content: Vec<ResponseContentBlock>,
-}
-
-#[derive(Debug, Deserialize)]
-struct ResponseContentBlock {
-    #[serde(rename = "type")]
-    content_type: String,
-    text: String,
-}
-
-#[derive(Debug, Deserialize)]
-struct ErrorResponse {
-    error: AnthropicError,
-}
-
-#[derive(Debug, Deserialize)]
-struct AnthropicError {
-    #[serde(rename = "type")]
-    error_type: String,
-    message: String,
-}
-
-// --- Streaming SSE event structures ---
-
-#[derive(Debug, Deserialize)]
-struct SseEvent {
-    #[serde(rename = "type")]
-    event_type: String,
-    #[serde(default)]
-    message: Option<SseMessage>,
-    #[serde(default)]
-    index: Option<u32>,
-    #[serde(default)]
-    content_block: Option<SseContentBlock>,
-    #[serde(default)]
-    delta: Option<SseDelta>,
-    #[serde(default)]
-    usage: Option<SseUsage>,
-}
-
-#[derive(Debug, Deserialize)]
-struct SseMessage {
-    #[serde(default)]
-    content: Option<Vec<SseContentBlock>>,
-}
-
-#[derive(Debug, Deserialize)]
-struct SseContentBlock {
-    #[serde(rename = "type")]
-    content_type: String,
-    #[serde(default)]
-    thinking: Option<String>,
-    #[serde(default)]
-    text: Option<String>,
-}
-
-#[derive(Debug, Deserialize)]
-struct SseDelta {
-    #[serde(rename = "type")]
-    delta_type: Option<String>,
-    #[serde(default)]
-    thinking: Option<String>,
-    #[serde(default)]
-    text: Option<String>,
-}
-
-#[derive(Debug, Deserialize)]
-struct SseUsage {
-    #[serde(default)]
-    output_tokens: Option<u32>,
-}
-
-impl AnthropicClient {
-    pub fn new(api_key: &str, model: &str) -> Result<Self> {
-        let client = create_http_client(Duration::from_secs(60))?;
-
-        Ok(Self {
-            api_key: api_key.to_string(),
-            model: model.to_string(),
-            client,
-            thinking_enabled: false,
-            thinking_budget_tokens: 1024,
-            max_tokens: 500,
-            temperature: 0.7,
-            top_p: None,
-            thinking_state: None,
-        })
-    }
-
-    pub fn with_timeout(mut self, timeout: Duration) -> Result<Self> {
-        self.client = create_http_client(timeout)?;
-        Ok(self)
-    }
-
-    pub fn with_thinking(mut self, enabled: bool) -> Self {
-        self.thinking_enabled = enabled;
-        self
-    }
-
-    pub fn with_thinking_budget_tokens(mut self, budget_tokens: u32) -> Self {
-        self.thinking_budget_tokens = budget_tokens;
-        self
-    }
-
-    pub fn with_max_tokens(mut self, max_tokens: u32) -> Self {
-        self.max_tokens = max_tokens;
-        self
-    }
-
-    pub fn with_temperature(mut self, temperature: f32) -> Self {
-        self.temperature = temperature;
-        self
-    }
-
-    pub fn with_top_p(mut self, top_p: f32) -> Self {
-        self.top_p = Some(top_p);
-        self
-    }
-
-    pub fn with_thinking_state(mut self, state: Arc<ThinkingStateManager>) -> Self {
-        self.thinking_state = Some(state);
-        self
-    }
-
-    pub async fn list_models(&self) -> Result<Vec<String>> {
-        Ok(ANTHROPIC_MODELS.iter().map(|&m| m.to_string()).collect())
-    }
-
-    pub async fn validate_key(&self) -> Result<bool> {
-        let url = "https://api.anthropic.com/v1/messages";
-
-        let request = MessagesRequest {
-            model: self.model.clone(),
-            max_tokens: 5,
-            temperature: Some(0.0),
-            top_p: None,
-            messages: vec![AnthropicMessage {
-                role: "user".to_string(),
-                content: AnthropicContent::Text("Hi".to_string()),
-            }],
-            system: None,
-            thinking: None,
-            stream: false,
-        };
-
-        let response = self
-            .client
-            .post(url)
-            .header("x-api-key", &self.api_key)
-            .header("anthropic-version", "2023-06-01")
-            .header("Content-Type", "application/json")
-            .json(&request)
-            .send()
-            .await;
-
-        match response {
-            Ok(resp) => {
-                if resp.status().is_success() {
-                    Ok(true)
-                } else {
-                    let status = resp.status();
-                    if status.as_u16() == 401 {
-                        Ok(false)
-                    } else {
-                        let text = resp.text().await.unwrap_or_default();
-                        bail!("Anthropic API error: {} - {}", status, text)
-                    }
-                }
-            }
-            Err(e) => Err(e.into()),
-        }
-    }
-}
-
-#[async_trait]
-impl LlmProvider for AnthropicClient {
-    async fn generate(&self, prompt: &str) -> Result<String> {
-        let messages = vec![AnthropicMessage {
-            role: "user".to_string(),
-            content: AnthropicContent::Text(prompt.to_string()),
-        }];
-
-        self.messages_request_with_retry(messages, None).await
-    }
-
-    async fn generate_with_system(&self, system: &str, user: &str) -> Result<String> {
-        let messages = vec![AnthropicMessage {
-            role: "user".to_string(),
-            content: AnthropicContent::Text(user.to_string()),
-        }];
-
-        let system = if system.is_empty() {
-            None
-        } else {
-            Some(vec![SystemContent {
-                content_type: "text".to_string(),
-                text: system.to_string(),
-            }])
-        };
-
-        self.messages_request_with_retry(messages, system).await
-    }
-
-    async fn is_available(&self) -> bool {
-        self.validate_key().await.unwrap_or(false)
-    }
-
-    fn name(&self) -> &str {
-        "anthropic"
-    }
-}
-
-impl AnthropicClient {
-    async fn messages_request_with_retry(
-        &self,
-        messages: Vec<AnthropicMessage>,
-        system: Option<Vec<SystemContent>>,
-    ) -> Result<String> {
-        let mut last_error = None;
-
-        for attempt in 1..=3 {
-            match self
-                .messages_request(messages.clone(), system.clone())
-                .await
-            {
-                Ok(result) => return Ok(result),
-                Err(e) => {
-                    let err_msg = e.to_string();
-                    let is_retryable = err_msg.contains("timeout")
-                        || err_msg.contains("connection")
-                        || err_msg.contains("temporary")
-                        || err_msg.contains("5")
-                            && (err_msg.contains("500")
-                                || err_msg.contains("502")
-                                || err_msg.contains("503")
-                                || err_msg.contains("504"));
-
-                    if !is_retryable || attempt == 3 {
-                        last_error = Some(e);
-                        break;
-                    }
-
-                    tokio::time::sleep(Duration::from_millis(500 * 2u64.pow(attempt - 1))).await;
-                }
-            }
-        }
-
-        Err(last_error.unwrap_or_else(|| anyhow::anyhow!("Request failed after retries")))
-    }
-
-    async fn messages_request(
-        &self,
-        messages: Vec<AnthropicMessage>,
-        system: Option<Vec<SystemContent>>,
-    ) -> Result<String> {
-        if self.thinking_enabled {
-            self.streaming_messages_request(messages, system).await
-        } else {
-            self.non_streaming_messages_request(messages, system).await
-        }
-    }
-
-    async fn non_streaming_messages_request(
-        &self,
-        messages: Vec<AnthropicMessage>,
-        system: Option<Vec<SystemContent>>,
-    ) -> Result<String> {
-        let url = "https://api.anthropic.com/v1/messages";
-
-        let temperature = if self.temperature == 0.0 {
-            None
-        } else {
-            Some(self.temperature)
-        };
-
-        let request = MessagesRequest {
-            model: self.model.clone(),
-            max_tokens: self.max_tokens,
-            temperature,
-            top_p: self.top_p,
-            messages,
-            system,
-            thinking: Some(ThinkingConfig {
-                thinking_type: "disabled".to_string(),
-                budget_tokens: None,
-            }),
-            stream: false,
-        };
-
-        let response = self
-            .client
-            .post(url)
-            .header("x-api-key", &self.api_key)
-            .header("anthropic-version", "2023-06-01")
-            .header("Content-Type", "application/json")
-            .json(&request)
-            .send()
-            .await
-            .context("Failed to send request to Anthropic")?;
-
-        let status = response.status();
-
-        if !status.is_success() {
-            let text = response.text().await.unwrap_or_default();
-
-            if let Ok(error) = serde_json::from_str::<ErrorResponse>(&text) {
-                bail!(
-                    "Anthropic API error: {} ({})",
-                    error.error.message,
-                    error.error.error_type
-                );
-            }
-
-            bail!("Anthropic API error: {} - {}", status, text);
-        }
-
-        let result: MessagesResponse = response
-            .json()
-            .await
-            .context("Failed to parse Anthropic response")?;
-
-        result
-            .content
-            .into_iter()
-            .find(|c| c.content_type == "text")
-            .map(|c| c.text.trim().to_string())
-            .filter(|s| !s.is_empty())
-            .ok_or_else(|| anyhow::anyhow!("No text response from Anthropic"))
-    }
-
-    /// Streaming request for thinking mode, filters thinking content blocks
-    async fn streaming_messages_request(
-        &self,
-        messages: Vec<AnthropicMessage>,
-        system: Option<Vec<SystemContent>>,
-    ) -> Result<String> {
-        let url = "https://api.anthropic.com/v1/messages";
-
-        let thinking = ThinkingConfig {
-            thinking_type: "enabled".to_string(),
-            budget_tokens: Some(self.thinking_budget_tokens),
-        };
-
-        // max_tokens must exceed budget_tokens
-        let max_tokens = (self.max_tokens).max(self.thinking_budget_tokens + 100);
-
-        let request = MessagesRequest {
-            model: self.model.clone(),
-            max_tokens,
-            temperature: None, // must be omitted for thinking mode
-            top_p: None,
-            messages,
-            system,
-            thinking: Some(thinking),
-            stream: true,
-        };
-
-        let response = self
-            .client
-            .post(url)
-            .header("x-api-key", &self.api_key)
-            .header("anthropic-version", "2023-06-01")
-            .header("Content-Type", "application/json")
-            .header("Accept", "text/event-stream")
-            .json(&request)
-            .send()
-            .await
-            .context("Failed to send streaming request to Anthropic")?;
-
-        let status = response.status();
-
-        if !status.is_success() {
-            let text = response.text().await.unwrap_or_default();
-
-            if let Ok(error) = serde_json::from_str::<ErrorResponse>(&text) {
-                bail!(
-                    "Anthropic API error: {} ({})",
-                    error.error.message,
-                    error.error.error_type
-                );
-            }
-
-            bail!("Anthropic API error: {} - {}", status, text);
-        }
-
-        let mut content_buffer = String::new();
-        let mut in_thinking = false;
-        let mut has_reasoning = false;
-        let mut has_content = false;
-
-        let thinking_state = self.thinking_state.as_ref();
-
-        let mut byte_stream = response.bytes_stream();
-        let mut line_buffer = String::new();
-
-        use futures_util::StreamExt;
-
-        while let Some(chunk) = byte_stream.next().await {
-            let chunk = chunk.context("Failed to read streaming response chunk")?;
-            let chunk_str =
-                String::from_utf8(chunk.to_vec()).context("Invalid UTF-8 in stream chunk")?;
-
-            line_buffer.push_str(&chunk_str);
-
-            while let Some(line_end) = line_buffer.find('\n') {
-                let line = line_buffer[..line_end].trim().to_string();
-                line_buffer = line_buffer[line_end + 1..].to_string();
-
-                if line.is_empty() {
-                    continue;
-                }
-
-                // Parse SSE event line
-                if let Some(data) = line.strip_prefix("data: ") {
-                    if let Ok(event) = serde_json::from_str::<SseEvent>(data) {
-                        match event.event_type.as_str() {
-                            "content_block_start" => {
-                                if let Some(ref block) = event.content_block {
-                                    if block.content_type == "thinking" {
-                                        in_thinking = true;
-                                        if !has_reasoning {
-                                            has_reasoning = true;
-                                            if let Some(state) = thinking_state {
-                                                state.start_thinking();
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                            "content_block_delta" => {
-                                if let Some(ref delta) = event.delta {
-                                    // Thinking delta - ignore content but track state
-                                    if delta.thinking.is_some() {
-                                        continue;
-                                    }
-
-                                    // Text delta - collect
-                                    if in_thinking && delta.text.is_some() {
-                                        // Transition from thinking to text
-                                        if let Some(state) = thinking_state {
-                                            state.end_thinking();
-                                        }
-                                        in_thinking = false;
-                                    }
-                                    if let Some(ref text) = delta.text
-                                        && !text.is_empty()
-                                    {
-                                        has_content = true;
-                                        content_buffer.push_str(text);
-                                    }
-                                }
-                            }
-                            "content_block_stop" => {
-                                if in_thinking {
-                                    if let Some(state) = thinking_state {
-                                        state.end_thinking();
-                                    }
-                                    in_thinking = false;
-                                }
-                            }
-                            _ => {}
-                        }
-                    }
-                }
-            }
-        }
-
-        // Ensure thinking state is ended
-        if let Some(state) = thinking_state {
-            state.end_thinking();
-        }
-
-        let result = content_buffer.trim().to_string();
-
-        if result.is_empty() {
-            if has_reasoning && !has_content {
-                bail!(
-                    "Anthropic returned thinking content but no final answer. \
-                     The model may have entered an incomplete thinking state. \
-                     Please try again or disable thinking mode."
-                );
-            }
-            bail!(
-                "No response from Anthropic. \
-                 If thinking mode is enabled, try disabling it or ensure the model supports it."
-            );
-        }
-
-        Ok(result)
-    }
-}
-
-/// Available Anthropic models (Claude 4 series with extended thinking)
-pub const ANTHROPIC_MODELS: &[&str] = &[
-    "claude-opus-4-7",
-    "claude-sonnet-4-6",
-    "claude-haiku-4-5",
-    // Legacy models
-    "claude-3-opus-20240229",
-    "claude-3-sonnet-20240229",
-    "claude-3-haiku-20240307",
-    "claude-2.1",
-    "claude-2.0",
-    "claude-instant-1.2",
-];
-
-pub fn is_valid_model(model: &str) -> bool {
-    ANTHROPIC_MODELS.contains(&model)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_model_validation_claude4() {
-        assert!(is_valid_model("claude-opus-4-7"));
-        assert!(is_valid_model("claude-sonnet-4-6"));
-        assert!(is_valid_model("claude-haiku-4-5"));
-        assert!(is_valid_model("claude-3-sonnet-20240229"));
-        assert!(!is_valid_model("invalid-model"));
-    }
-
-    #[test]
-    fn test_thinking_config_serialization() {
-        let config = ThinkingConfig {
-            thinking_type: "enabled".to_string(),
-            budget_tokens: Some(2048),
-        };
-        let json = serde_json::to_string(&config).unwrap();
-        assert!(json.contains(r#""type":"enabled""#));
-        assert!(json.contains(r#""budget_tokens":2048"#));
-    }
-
-    #[test]
-    fn test_thinking_config_disabled_serialization() {
-        let config = ThinkingConfig {
-            thinking_type: "disabled".to_string(),
-            budget_tokens: None,
-        };
-        let json = serde_json::to_string(&config).unwrap();
-        assert_eq!(json, r#"{"type":"disabled"}"#);
-    }
-
-    #[test]
-    fn test_system_content_serialization() {
-        let content = SystemContent {
-            content_type: "text".to_string(),
-            text: "You are helpful.".to_string(),
-        };
-        let json = serde_json::to_string(&content).unwrap();
-        assert!(json.contains(r#""type":"text""#));
-    }
-
-    #[test]
-    fn test_sse_event_parsing_content_block_start() {
-        let json = r#"{"type":"content_block_start","index":0,"content_block":{"type":"thinking","thinking":""}}"#;
-        let event: SseEvent = serde_json::from_str(json).unwrap();
-        assert_eq!(event.event_type, "content_block_start");
-        assert_eq!(event.content_block.unwrap().content_type, "thinking");
-    }
-
-    #[test]
-    fn test_sse_event_parsing_text_delta() {
-        let json = r#"{"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"Hello"}}"#;
-        let event: SseEvent = serde_json::from_str(json).unwrap();
-        assert_eq!(event.event_type, "content_block_delta");
-        assert_eq!(event.delta.unwrap().text, Some("Hello".to_string()));
-    }
-
-    #[test]
-    fn test_anthropic_content_text() {
-        let msg = AnthropicMessage {
-            role: "user".to_string(),
-            content: AnthropicContent::Text("Hello".to_string()),
-        };
-        let json = serde_json::to_string(&msg).unwrap();
-        assert!(json.contains(r#""content":"Hello""#));
-    }
-}

src/llm/deepseek.rs

@@ -1,622 +0,0 @@
-use super::thinking::ThinkingStateManager;
-use super::{LlmProvider, create_http_client};
-use anyhow::{Context, Result, bail};
-use async_trait::async_trait;
-use serde::{Deserialize, Serialize};
-use std::sync::Arc;
-use std::time::Duration;
-
-/// DeepSeek API client
-pub struct DeepSeekClient {
-    base_url: String,
-    api_key: String,
-    model: String,
-    client: reqwest::Client,
-    thinking_enabled: bool,
-    reasoning_effort: Option<String>,
-    max_tokens: u32,
-    temperature: f32,
-    thinking_state: Option<Arc<ThinkingStateManager>>,
-}
-
-#[derive(Debug, Serialize)]
-struct ChatCompletionRequest {
-    model: String,
-    messages: Vec<Message>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    max_tokens: Option<u32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    temperature: Option<f32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    top_p: Option<f32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    presence_penalty: Option<f32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    frequency_penalty: Option<f32>,
-    stream: bool,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    thinking: Option<ThinkingConfig>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    reasoning_effort: Option<String>,
-}
-
-#[derive(Debug, Serialize)]
-struct ThinkingConfig {
-    #[serde(rename = "type")]
-    thinking_type: String,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-struct Message {
-    role: String,
-    content: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    reasoning_content: Option<String>,
-}
-
-#[derive(Debug, Deserialize)]
-struct ChatCompletionResponse {
-    choices: Vec<Choice>,
-}
-
-#[derive(Debug, Deserialize)]
-struct Choice {
-    message: Message,
-    #[serde(default)]
-    reasoning_content: Option<String>,
-}
-
-// --- Streaming response structures ---
-
-#[derive(Debug, Deserialize)]
-struct StreamChunk {
-    choices: Vec<StreamChoice>,
-}
-
-#[derive(Debug, Deserialize)]
-struct StreamChoice {
-    delta: StreamDelta,
-    #[serde(default)]
-    finish_reason: Option<String>,
-    index: Option<u32>,
-}
-
-#[derive(Debug, Deserialize, Default)]
-struct StreamDelta {
-    #[serde(default)]
-    content: Option<String>,
-    #[serde(default)]
-    reasoning_content: Option<String>,
-}
-
-#[derive(Debug, Deserialize)]
-struct ErrorResponse {
-    error: ApiError,
-}
-
-#[derive(Debug, Deserialize)]
-struct ApiError {
-    message: String,
-    #[serde(rename = "type")]
-    error_type: String,
-}
-
-impl DeepSeekClient {
-    pub fn new(api_key: &str, model: &str) -> Result<Self> {
-        let client = create_http_client(Duration::from_secs(300))?;
-
-        Ok(Self {
-            base_url: "https://api.deepseek.com".to_string(),
-            api_key: api_key.to_string(),
-            model: model.to_string(),
-            client,
-            thinking_enabled: false,
-            reasoning_effort: None,
-            max_tokens: 500,
-            temperature: 0.7,
-            thinking_state: None,
-        })
-    }
-
-    pub fn with_base_url(api_key: &str, model: &str, base_url: &str) -> Result<Self> {
-        let client = create_http_client(Duration::from_secs(300))?;
-
-        Ok(Self {
-            base_url: base_url.trim_end_matches('/').to_string(),
-            api_key: api_key.to_string(),
-            model: model.to_string(),
-            client,
-            thinking_enabled: false,
-            reasoning_effort: None,
-            max_tokens: 500,
-            temperature: 0.7,
-            thinking_state: None,
-        })
-    }
-
-    pub fn with_timeout(mut self, timeout: Duration) -> Result<Self> {
-        self.client = create_http_client(timeout)?;
-        Ok(self)
-    }
-
-    pub fn with_thinking(mut self, enabled: bool) -> Self {
-        self.thinking_enabled = enabled;
-        self
-    }
-
-    pub fn with_reasoning_effort(mut self, effort: Option<String>) -> Self {
-        self.reasoning_effort = effort;
-        self
-    }
-
-    pub fn with_max_tokens(mut self, max_tokens: u32) -> Self {
-        self.max_tokens = max_tokens;
-        self
-    }
-
-    pub fn with_temperature(mut self, temperature: f32) -> Self {
-        self.temperature = temperature;
-        self
-    }
-
-    pub fn with_thinking_state(mut self, state: Arc<ThinkingStateManager>) -> Self {
-        self.thinking_state = Some(state);
-        self
-    }
-
-    pub async fn list_models(&self) -> Result<Vec<String>> {
-        let url = format!("{}/models", self.base_url);
-
-        let response = self
-            .client
-            .get(&url)
-            .header("Authorization", format!("Bearer {}", self.api_key))
-            .send()
-            .await
-            .context("Failed to list DeepSeek models")?;
-
-        if !response.status().is_success() {
-            let status = response.status();
-            let text = response.text().await.unwrap_or_default();
-            bail!("DeepSeek API error: {} - {}", status, text);
-        }
-
-        #[derive(Deserialize)]
-        struct ModelsResponse {
-            data: Vec<ModelId>,
-        }
-
-        #[derive(Deserialize)]
-        struct ModelId {
-            id: String,
-        }
-
-        let result: ModelsResponse = response
-            .json()
-            .await
-            .context("Failed to parse DeepSeek response")?;
-
-        Ok(result.data.into_iter().map(|m| m.id).collect())
-    }
-
-    pub async fn validate_key(&self) -> Result<bool> {
-        match self.list_models().await {
-            Ok(_) => Ok(true),
-            Err(e) => {
-                let err_str = e.to_string();
-                if err_str.contains("401") || err_str.contains("Unauthorized") {
-                    Ok(false)
-                } else {
-                    Err(e)
-                }
-            }
-        }
-    }
-}
-
-#[async_trait]
-impl LlmProvider for DeepSeekClient {
-    async fn generate(&self, prompt: &str) -> Result<String> {
-        let messages = vec![Message {
-            role: "user".to_string(),
-            content: prompt.to_string(),
-            reasoning_content: None,
-        }];
-
-        self.chat_completion_with_retry(messages).await
-    }
-
-    async fn generate_with_system(&self, system: &str, user: &str) -> Result<String> {
-        let mut messages = vec![];
-
-        if !system.is_empty() {
-            messages.push(Message {
-                role: "system".to_string(),
-                content: system.to_string(),
-                reasoning_content: None,
-            });
-        }
-
-        messages.push(Message {
-            role: "user".to_string(),
-            content: user.to_string(),
-            reasoning_content: None,
-        });
-
-        self.chat_completion_with_retry(messages).await
-    }
-
-    async fn is_available(&self) -> bool {
-        self.validate_key().await.unwrap_or(false)
-    }
-
-    fn name(&self) -> &str {
-        "deepseek"
-    }
-}
-
-impl DeepSeekClient {
-    async fn chat_completion_with_retry(&self, messages: Vec<Message>) -> Result<String> {
-        let mut last_error = None;
-
-        for attempt in 1..=3 {
-            match self.chat_completion(messages.clone()).await {
-                Ok(result) => return Ok(result),
-                Err(e) => {
-                    let err_msg = e.to_string();
-                    // 网络临时错误才重试
-                    let is_retryable = err_msg.contains("timeout")
-                        || err_msg.contains("connection")
-                        || err_msg.contains("temporary")
-                        || err_msg.contains("5")
-                            && (err_msg.contains("500")
-                                || err_msg.contains("502")
-                                || err_msg.contains("503")
-                                || err_msg.contains("504"));
-
-                    if !is_retryable || attempt == 3 {
-                        last_error = Some(e);
-                        break;
-                    }
-
-                    // 指数退避
-                    tokio::time::sleep(Duration::from_millis(500 * 2u64.pow(attempt - 1))).await;
-                }
-            }
-        }
-
-        Err(last_error.unwrap_or_else(|| anyhow::anyhow!("Request failed after retries")))
-    }
-
-    async fn chat_completion(&self, messages: Vec<Message>) -> Result<String> {
-        let url = format!("{}/chat/completions", self.base_url);
-
-        let thinking = Some(ThinkingConfig {
-            thinking_type: if self.thinking_enabled {
-                "enabled".to_string()
-            } else {
-                "disabled".to_string()
-            },
-        });
-
-        // 思考模式下，temperature/top_p 等参数不应传递
-        // 非思考模式下可以正常传递
-        let (temperature, max_tokens, top_p, presence_penalty, frequency_penalty) =
-            if self.thinking_enabled {
-                (None, Some(self.max_tokens), None, None, None)
-            } else {
-                (
-                    Some(self.temperature),
-                    Some(self.max_tokens),
-                    None,
-                    None,
-                    None,
-                )
-            };
-
-        let reasoning_effort = if self.thinking_enabled {
-            self.reasoning_effort.clone()
-        } else {
-            None
-        };
-
-        let request = ChatCompletionRequest {
-            model: self.model.clone(),
-            messages: messages.clone(),
-            max_tokens,
-            temperature,
-            top_p,
-            presence_penalty,
-            frequency_penalty,
-            stream: self.thinking_enabled,
-            thinking,
-            reasoning_effort,
-        };
-
-        if self.thinking_enabled {
-            self.streaming_chat_completion(&url, &request).await
-        } else {
-            self.non_streaming_chat_completion(&url, &request).await
-        }
-    }
-
-    /// 非流式请求（非思考模式）
-    async fn non_streaming_chat_completion(
-        &self,
-        url: &str,
-        request: &ChatCompletionRequest,
-    ) -> Result<String> {
-        let response = self
-            .client
-            .post(url)
-            .header("Authorization", format!("Bearer {}", self.api_key))
-            .header("Content-Type", "application/json")
-            .json(request)
-            .send()
-            .await
-            .context("Failed to send request to DeepSeek")?;
-
-        let status = response.status();
-
-        if !status.is_success() {
-            let text = response.text().await.unwrap_or_default();
-
-            if let Ok(error) = serde_json::from_str::<ErrorResponse>(&text) {
-                bail!(
-                    "DeepSeek API error: {} ({})",
-                    error.error.message,
-                    error.error.error_type
-                );
-            }
-
-            bail!("DeepSeek API error: {} - {}", status, text);
-        }
-
-        let result: ChatCompletionResponse = response
-            .json()
-            .await
-            .context("Failed to parse DeepSeek response")?;
-
-        result
-            .choices
-            .into_iter()
-            .next()
-            .map(|c| c.message.content.trim().to_string())
-            .filter(|s| !s.is_empty())
-            .ok_or_else(|| anyhow::anyhow!("No response from DeepSeek"))
-    }
-
-    /// 流式请求（思考模式），处理 reasoning_content 和 content
-    async fn streaming_chat_completion(
-        &self,
-        url: &str,
-        request: &ChatCompletionRequest,
-    ) -> Result<String> {
-        let response = self
-            .client
-            .post(url)
-            .header("Authorization", format!("Bearer {}", self.api_key))
-            .header("Content-Type", "application/json")
-            .header("Accept", "text/event-stream")
-            .json(request)
-            .send()
-            .await
-            .context("Failed to send streaming request to DeepSeek")?;
-
-        let status = response.status();
-
-        if !status.is_success() {
-            let text = response.text().await.unwrap_or_default();
-
-            if let Ok(error) = serde_json::from_str::<ErrorResponse>(&text) {
-                bail!(
-                    "DeepSeek API error: {} ({})",
-                    error.error.message,
-                    error.error.error_type
-                );
-            }
-
-            bail!("DeepSeek API error: {} - {}", status, text);
-        }
-
-        let mut content_buffer = String::new();
-        let mut has_reasoning = false;
-        let mut has_content = false;
-        let mut stream_ended = false;
-
-        let thinking_state = self.thinking_state.as_ref();
-
-        let mut byte_stream = response.bytes_stream();
-        let mut line_buffer = String::new();
-
-        use futures_util::StreamExt;
-
-        while let Some(chunk) = byte_stream.next().await {
-            let chunk = chunk.context("Failed to read streaming response chunk")?;
-            let chunk_str =
-                String::from_utf8(chunk.to_vec()).context("Invalid UTF-8 in stream chunk")?;
-
-            line_buffer.push_str(&chunk_str);
-
-            // 处理完整行
-            while let Some(line_end) = line_buffer.find('\n') {
-                let line = line_buffer[..line_end].trim().to_string();
-                line_buffer = line_buffer[line_end + 1..].to_string();
-
-                if line.is_empty() {
-                    continue;
-                }
-
-                // SSE 格式：data: {...} 或 data: [DONE]
-                if line == "data: [DONE]" {
-                    stream_ended = true;
-                    break;
-                }
-
-                if let Some(json_str) = line.strip_prefix("data: ") {
-                    match serde_json::from_str::<StreamChunk>(json_str) {
-                        Ok(chunk) => {
-                            for choice in &chunk.choices {
-                                // 处理 reasoning_content
-                                if let Some(ref reasoning) = choice.delta.reasoning_content
-                                    && !reasoning.is_empty()
-                                {
-                                    if !has_reasoning {
-                                        has_reasoning = true;
-                                        if let Some(state) = thinking_state {
-                                            state.start_thinking();
-                                        }
-                                    }
-                                    // reasoning_content 不对外输出，仅用于内部状态判断
-                                    continue;
-                                }
-
-                                // 处理 content
-                                if let Some(ref content) = choice.delta.content
-                                    && !content.is_empty()
-                                {
-                                    // reasoning 结束，content 开始出现时移除 thinking 标识
-                                    if has_reasoning
-                                        && !has_content
-                                        && let Some(state) = thinking_state
-                                    {
-                                        state.end_thinking();
-                                    }
-                                    has_content = true;
-                                    content_buffer.push_str(content);
-                                }
-
-                                // 检查 finish_reason
-                                if let Some(ref reason) = choice.finish_reason
-                                    && reason == "stop"
-                                {
-                                    stream_ended = true;
-                                }
-                            }
-                        }
-                        Err(_) => {
-                            // 忽略无法解析的行（可能是心跳或注释）
-                        }
-                    }
-                }
-            }
-
-            if stream_ended {
-                break;
-            }
-        }
-
-        // 确保思考状态已结束
-        if let Some(state) = thinking_state {
-            state.end_thinking();
-        }
-
-        let result = content_buffer.trim().to_string();
-
-        if result.is_empty() {
-            if has_reasoning && !has_content {
-                bail!(
-                    "DeepSeek returned reasoning content but no final answer. \
-                     The model may have entered an incomplete thinking state. \
-                     Please try again or disable thinking mode."
-                );
-            }
-            bail!(
-                "No response from DeepSeek. \
-                 If thinking mode is enabled, try disabling it or ensure the model supports it."
-            );
-        }
-
-        Ok(result)
-    }
-}
-
-/// 可用 DeepSeek 模型列表
-/// deepseek-chat / deepseek-reasoner 将于 2026-07-24 停用，推荐使用 V4 系列
-pub const DEEPSEEK_MODELS: &[&str] = &[
-    "deepseek-v4-flash",
-    "deepseek-v4-pro",
-    // 兼容旧版模型 ID（将于 2026-07-24 停用）
-    "deepseek-chat",
-    "deepseek-reasoner",
-];
-
-pub fn is_valid_model(model: &str) -> bool {
-    DEEPSEEK_MODELS.contains(&model)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_model_validation_v4() {
-        assert!(is_valid_model("deepseek-v4-flash"));
-        assert!(is_valid_model("deepseek-v4-pro"));
-        assert!(is_valid_model("deepseek-chat"));
-        assert!(is_valid_model("deepseek-reasoner"));
-        assert!(!is_valid_model("invalid-model"));
-        assert!(!is_valid_model("deepseek-v3"));
-    }
-
-    #[test]
-    fn test_client_builder_defaults() {
-        let client = DeepSeekClient::new("test-key", "deepseek-v4-flash").unwrap();
-        assert!(!client.thinking_enabled);
-        assert_eq!(client.max_tokens, 500);
-        assert_eq!(client.temperature, 0.7);
-        assert!(client.reasoning_effort.is_none());
-        assert!(client.thinking_state.is_none());
-    }
-
-    #[test]
-    fn test_client_builder_with_thinking() {
-        let client = DeepSeekClient::new("test-key", "deepseek-v4-flash")
-            .unwrap()
-            .with_thinking(true)
-            .with_reasoning_effort(Some("high".to_string()))
-            .with_max_tokens(1000)
-            .with_temperature(0.5);
-
-        assert!(client.thinking_enabled);
-        assert_eq!(client.reasoning_effort, Some("high".to_string()));
-        assert_eq!(client.max_tokens, 1000);
-        assert_eq!(client.temperature, 0.5);
-    }
-
-    #[test]
-    fn test_thinking_config_serialization() {
-        let config = ThinkingConfig {
-            thinking_type: "enabled".to_string(),
-        };
-        let json = serde_json::to_string(&config).unwrap();
-        assert_eq!(json, r#"{"type":"enabled"}"#);
-    }
-
-    #[test]
-    fn test_message_serialization_without_reasoning() {
-        let msg = Message {
-            role: "user".to_string(),
-            content: "Hello".to_string(),
-            reasoning_content: None,
-        };
-        let json = serde_json::to_string(&msg).unwrap();
-        assert!(!json.contains("reasoning_content"));
-    }
-
-    #[test]
-    fn test_stream_delta_parsing() {
-        let json = r#"{"content":"Hello","reasoning_content":null}"#;
-        let delta: StreamDelta = serde_json::from_str(json).unwrap();
-        assert_eq!(delta.content, Some("Hello".to_string()));
-        assert!(delta.reasoning_content.is_none());
-    }
-
-    #[test]
-    fn test_stream_delta_reasoning_only() {
-        let json = r#"{"content":null,"reasoning_content":"Let me think..."}"#;
-        let delta: StreamDelta = serde_json::from_str(json).unwrap();
-        assert!(delta.content.is_none());
-        assert_eq!(delta.reasoning_content, Some("Let me think...".to_string()));
-    }
-}

src/llm/kimi.rs

@@ -1,587 +0,0 @@
-use super::thinking::ThinkingStateManager;
-use super::{LlmProvider, create_http_client};
-use anyhow::{Context, Result, bail};
-use async_trait::async_trait;
-use serde::{Deserialize, Serialize};
-use std::sync::Arc;
-use std::time::Duration;
-
-/// Kimi API client (Moonshot AI)
-pub struct KimiClient {
-    base_url: String,
-    api_key: String,
-    model: String,
-    client: reqwest::Client,
-    thinking_enabled: bool,
-    max_tokens: u32,
-    temperature: f32,
-    thinking_state: Option<Arc<ThinkingStateManager>>,
-}
-
-#[derive(Debug, Serialize)]
-struct ChatCompletionRequest {
-    model: String,
-    messages: Vec<Message>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    max_tokens: Option<u32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    temperature: Option<f32>,
-    stream: bool,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    thinking: Option<ThinkingConfig>,
-}
-
-#[derive(Debug, Serialize)]
-struct ThinkingConfig {
-    #[serde(rename = "type")]
-    thinking_type: String,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-struct Message {
-    role: String,
-    content: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    reasoning_content: Option<String>,
-}
-
-#[derive(Debug, Deserialize)]
-struct ChatCompletionResponse {
-    choices: Vec<Choice>,
-}
-
-#[derive(Debug, Deserialize)]
-struct Choice {
-    message: Message,
-    #[serde(default)]
-    reasoning_content: Option<String>,
-}
-
-// --- Streaming response structures ---
-
-#[derive(Debug, Deserialize)]
-struct StreamChunk {
-    choices: Vec<StreamChoice>,
-}
-
-#[derive(Debug, Deserialize)]
-struct StreamChoice {
-    delta: StreamDelta,
-    #[serde(default)]
-    finish_reason: Option<String>,
-    index: Option<u32>,
-}
-
-#[derive(Debug, Deserialize, Default)]
-struct StreamDelta {
-    #[serde(default)]
-    content: Option<String>,
-    #[serde(default)]
-    reasoning_content: Option<String>,
-}
-
-#[derive(Debug, Deserialize)]
-struct ErrorResponse {
-    error: ApiError,
-}
-
-#[derive(Debug, Deserialize)]
-struct ApiError {
-    message: String,
-    #[serde(rename = "type")]
-    error_type: String,
-}
-
-impl KimiClient {
-    pub fn new(api_key: &str, model: &str) -> Result<Self> {
-        let client = create_http_client(Duration::from_secs(300))?;
-
-        Ok(Self {
-            base_url: "https://api.moonshot.cn/v1".to_string(),
-            api_key: api_key.to_string(),
-            model: model.to_string(),
-            client,
-            thinking_enabled: false,
-            max_tokens: 500,
-            temperature: 1.0,
-            thinking_state: None,
-        })
-    }
-
-    pub fn with_base_url(api_key: &str, model: &str, base_url: &str) -> Result<Self> {
-        let client = create_http_client(Duration::from_secs(300))?;
-
-        Ok(Self {
-            base_url: base_url.trim_end_matches('/').to_string(),
-            api_key: api_key.to_string(),
-            model: model.to_string(),
-            client,
-            thinking_enabled: false,
-            max_tokens: 500,
-            temperature: 1.0,
-            thinking_state: None,
-        })
-    }
-
-    pub fn with_timeout(mut self, timeout: Duration) -> Result<Self> {
-        self.client = create_http_client(timeout)?;
-        Ok(self)
-    }
-
-    pub fn with_thinking(mut self, enabled: bool) -> Self {
-        self.thinking_enabled = enabled;
-        self
-    }
-
-    pub fn with_max_tokens(mut self, max_tokens: u32) -> Self {
-        self.max_tokens = max_tokens;
-        self
-    }
-
-    pub fn with_temperature(mut self, temperature: f32) -> Self {
-        self.temperature = temperature;
-        self
-    }
-
-    pub fn with_thinking_state(mut self, state: Arc<ThinkingStateManager>) -> Self {
-        self.thinking_state = Some(state);
-        self
-    }
-
-    pub async fn list_models(&self) -> Result<Vec<String>> {
-        let url = format!("{}/models", self.base_url);
-
-        let response = self
-            .client
-            .get(&url)
-            .header("Authorization", format!("Bearer {}", self.api_key))
-            .send()
-            .await
-            .context("Failed to list Kimi models")?;
-
-        if !response.status().is_success() {
-            let status = response.status();
-            let text = response.text().await.unwrap_or_default();
-            bail!("Kimi API error: {} - {}", status, text);
-        }
-
-        #[derive(Deserialize)]
-        struct ModelsResponse {
-            data: Vec<ModelId>,
-        }
-
-        #[derive(Deserialize)]
-        struct ModelId {
-            id: String,
-        }
-
-        let result: ModelsResponse = response
-            .json()
-            .await
-            .context("Failed to parse Kimi response")?;
-
-        Ok(result.data.into_iter().map(|m| m.id).collect())
-    }
-
-    pub async fn validate_key(&self) -> Result<bool> {
-        match self.list_models().await {
-            Ok(_) => Ok(true),
-            Err(e) => {
-                let err_str = e.to_string();
-                if err_str.contains("401") || err_str.contains("Unauthorized") {
-                    Ok(false)
-                } else {
-                    Err(e)
-                }
-            }
-        }
-    }
-}
-
-#[async_trait]
-impl LlmProvider for KimiClient {
-    async fn generate(&self, prompt: &str) -> Result<String> {
-        let messages = vec![Message {
-            role: "user".to_string(),
-            content: prompt.to_string(),
-            reasoning_content: None,
-        }];
-
-        self.chat_completion_with_retry(messages).await
-    }
-
-    async fn generate_with_system(&self, system: &str, user: &str) -> Result<String> {
-        let mut messages = vec![];
-
-        if !system.is_empty() {
-            messages.push(Message {
-                role: "system".to_string(),
-                content: system.to_string(),
-                reasoning_content: None,
-            });
-        }
-
-        messages.push(Message {
-            role: "user".to_string(),
-            content: user.to_string(),
-            reasoning_content: None,
-        });
-
-        self.chat_completion_with_retry(messages).await
-    }
-
-    async fn is_available(&self) -> bool {
-        self.validate_key().await.unwrap_or(false)
-    }
-
-    fn name(&self) -> &str {
-        "kimi"
-    }
-}
-
-impl KimiClient {
-    async fn chat_completion_with_retry(&self, messages: Vec<Message>) -> Result<String> {
-        let mut last_error = None;
-
-        for attempt in 1..=3 {
-            match self.chat_completion(messages.clone()).await {
-                Ok(result) => return Ok(result),
-                Err(e) => {
-                    let err_msg = e.to_string();
-                    let is_retryable = err_msg.contains("timeout")
-                        || err_msg.contains("connection")
-                        || err_msg.contains("temporary")
-                        || err_msg.contains("5")
-                            && (err_msg.contains("500")
-                                || err_msg.contains("502")
-                                || err_msg.contains("503")
-                                || err_msg.contains("504"));
-
-                    if !is_retryable || attempt == 3 {
-                        last_error = Some(e);
-                        break;
-                    }
-
-                    tokio::time::sleep(Duration::from_millis(500 * 2u64.pow(attempt - 1))).await;
-                }
-            }
-        }
-
-        Err(last_error.unwrap_or_else(|| anyhow::anyhow!("Request failed after retries")))
-    }
-
-    async fn chat_completion(&self, messages: Vec<Message>) -> Result<String> {
-        let url = format!("{}/chat/completions", self.base_url);
-
-        let thinking = Some(ThinkingConfig {
-            thinking_type: if self.thinking_enabled {
-                "enabled".to_string()
-            } else {
-                "disabled".to_string()
-            },
-        });
-
-        // Kimi API temperature 要求:
-        // - 思考模式: temperature 必须为 1.0
-        // - 非思考模式: temperature 必须为 0.6
-        let temperature = if self.thinking_enabled {
-            Some(1.0)
-        } else {
-            Some(0.6)
-        };
-
-        let request = ChatCompletionRequest {
-            model: self.model.clone(),
-            messages: messages.clone(),
-            max_tokens: Some(self.max_tokens),
-            temperature,
-            stream: self.thinking_enabled,
-            thinking,
-        };
-
-        if self.thinking_enabled {
-            self.streaming_chat_completion(&url, &request).await
-        } else {
-            self.non_streaming_chat_completion(&url, &request).await
-        }
-    }
-
-    /// 非流式请求（非思考模式）
-    async fn non_streaming_chat_completion(
-        &self,
-        url: &str,
-        request: &ChatCompletionRequest,
-    ) -> Result<String> {
-        let response = self
-            .client
-            .post(url)
-            .header("Authorization", format!("Bearer {}", self.api_key))
-            .header("Content-Type", "application/json")
-            .json(request)
-            .send()
-            .await
-            .context("Failed to send request to Kimi")?;
-
-        let status = response.status();
-
-        if !status.is_success() {
-            let text = response.text().await.unwrap_or_default();
-
-            if let Ok(error) = serde_json::from_str::<ErrorResponse>(&text) {
-                bail!(
-                    "Kimi API error: {} ({})",
-                    error.error.message,
-                    error.error.error_type
-                );
-            }
-
-            bail!("Kimi API error: {} - {}", status, text);
-        }
-
-        let result: ChatCompletionResponse = response
-            .json()
-            .await
-            .context("Failed to parse Kimi response")?;
-
-        result
-            .choices
-            .into_iter()
-            .next()
-            .map(|c| {
-                let content = c.message.content.trim().to_string();
-                if content.is_empty() {
-                    c.reasoning_content
-                        .or(c.message.reasoning_content)
-                        .map(|r| r.trim().to_string())
-                        .unwrap_or_default()
-                } else {
-                    content
-                }
-            })
-            .filter(|s| !s.is_empty())
-            .ok_or_else(|| anyhow::anyhow!("No response from Kimi"))
-    }
-
-    /// 流式请求（思考模式），处理 reasoning_content 和 content
-    async fn streaming_chat_completion(
-        &self,
-        url: &str,
-        request: &ChatCompletionRequest,
-    ) -> Result<String> {
-        let response = self
-            .client
-            .post(url)
-            .header("Authorization", format!("Bearer {}", self.api_key))
-            .header("Content-Type", "application/json")
-            .header("Accept", "text/event-stream")
-            .json(request)
-            .send()
-            .await
-            .context("Failed to send streaming request to Kimi")?;
-
-        let status = response.status();
-
-        if !status.is_success() {
-            let text = response.text().await.unwrap_or_default();
-
-            if let Ok(error) = serde_json::from_str::<ErrorResponse>(&text) {
-                bail!(
-                    "Kimi API error: {} ({})",
-                    error.error.message,
-                    error.error.error_type
-                );
-            }
-
-            bail!("Kimi API error: {} - {}", status, text);
-        }
-
-        let mut content_buffer = String::new();
-        let mut has_reasoning = false;
-        let mut has_content = false;
-        let mut stream_ended = false;
-
-        let thinking_state = self.thinking_state.as_ref();
-
-        let mut byte_stream = response.bytes_stream();
-        let mut line_buffer = String::new();
-
-        use futures_util::StreamExt;
-
-        while let Some(chunk) = byte_stream.next().await {
-            let chunk = chunk.context("Failed to read streaming response chunk")?;
-            let chunk_str =
-                String::from_utf8(chunk.to_vec()).context("Invalid UTF-8 in stream chunk")?;
-
-            line_buffer.push_str(&chunk_str);
-
-            while let Some(line_end) = line_buffer.find('\n') {
-                let line = line_buffer[..line_end].trim().to_string();
-                line_buffer = line_buffer[line_end + 1..].to_string();
-
-                if line.is_empty() {
-                    continue;
-                }
-
-                if line == "data: [DONE]" {
-                    stream_ended = true;
-                    break;
-                }
-
-                if let Some(json_str) = line.strip_prefix("data: ") {
-                    match serde_json::from_str::<StreamChunk>(json_str) {
-                        Ok(chunk) => {
-                            for choice in &chunk.choices {
-                                if let Some(ref reasoning) = choice.delta.reasoning_content
-                                    && !reasoning.is_empty()
-                                {
-                                    if !has_reasoning {
-                                        has_reasoning = true;
-                                        if let Some(state) = thinking_state {
-                                            state.start_thinking();
-                                        }
-                                    }
-                                    continue;
-                                }
-
-                                if let Some(ref content) = choice.delta.content
-                                    && !content.is_empty()
-                                {
-                                    if has_reasoning
-                                        && !has_content
-                                        && let Some(state) = thinking_state
-                                    {
-                                        state.end_thinking();
-                                    }
-                                    has_content = true;
-                                    content_buffer.push_str(content);
-                                }
-
-                                if let Some(ref reason) = choice.finish_reason
-                                    && reason == "stop"
-                                {
-                                    stream_ended = true;
-                                }
-                            }
-                        }
-                        Err(_) => {
-                            // 忽略无法解析的行
-                        }
-                    }
-                }
-            }
-
-            if stream_ended {
-                break;
-            }
-        }
-
-        // 确保思考状态已结束
-        if let Some(state) = thinking_state {
-            state.end_thinking();
-        }
-
-        let result = content_buffer.trim().to_string();
-
-        if result.is_empty() {
-            if has_reasoning && !has_content {
-                bail!(
-                    "Kimi returned reasoning content but no final answer. \
-                     The model may have entered an incomplete thinking state. \
-                     Please try again or disable thinking mode."
-                );
-            }
-            bail!(
-                "No response from Kimi. \
-                 If thinking mode is enabled, try disabling it or ensure the model supports it."
-            );
-        }
-
-        Ok(result)
-    }
-}
-
-/// 可用 Kimi 模型列表
-pub const KIMI_MODELS: &[&str] = &[
-    // K2 系列（推荐）
-    "kimi-k2.6",
-    "kimi-k2.5",
-    "kimi-k2-thinking",
-    "kimi-k2-thinking-turbo",
-    "kimi-k2-instruct",
-    "kimi-k2-instruct-0905",
-    // 兼容旧版模型 ID
-    "moonshot-v1-8k",
-    "moonshot-v1-32k",
-    "moonshot-v1-128k",
-];
-
-pub fn is_valid_model(model: &str) -> bool {
-    KIMI_MODELS.contains(&model)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_model_validation_k2() {
-        assert!(is_valid_model("kimi-k2.6"));
-        assert!(is_valid_model("kimi-k2.5"));
-        assert!(is_valid_model("kimi-k2-thinking"));
-        assert!(is_valid_model("kimi-k2-thinking-turbo"));
-        assert!(is_valid_model("moonshot-v1-8k"));
-        assert!(is_valid_model("moonshot-v1-32k"));
-        assert!(is_valid_model("moonshot-v1-128k"));
-        assert!(!is_valid_model("invalid-model"));
-        assert!(!is_valid_model("kimi-k1.5"));
-    }
-
-    #[test]
-    fn test_client_builder_defaults() {
-        let client = KimiClient::new("test-key", "kimi-k2.6").unwrap();
-        assert!(!client.thinking_enabled);
-        assert_eq!(client.max_tokens, 500);
-        assert_eq!(client.temperature, 1.0);
-        assert!(client.thinking_state.is_none());
-    }
-
-    #[test]
-    fn test_client_builder_with_thinking() {
-        let client = KimiClient::new("test-key", "kimi-k2.6")
-            .unwrap()
-            .with_thinking(true)
-            .with_max_tokens(1000)
-            .with_temperature(0.5);
-
-        assert!(client.thinking_enabled);
-        assert_eq!(client.max_tokens, 1000);
-        assert_eq!(client.temperature, 0.5);
-    }
-
-    #[test]
-    fn test_thinking_config_serialization() {
-        let config = ThinkingConfig {
-            thinking_type: "enabled".to_string(),
-        };
-        let json = serde_json::to_string(&config).unwrap();
-        assert_eq!(json, r#"{"type":"enabled"}"#);
-    }
-
-    #[test]
-    fn test_client_new_defaults() {
-        let client = KimiClient::new("test-key", "kimi-k2.6").unwrap();
-        assert_eq!(client.name(), "kimi");
-        assert!(!client.thinking_enabled);
-    }
-
-    #[test]
-    fn test_message_serialization() {
-        let msg = Message {
-            role: "user".to_string(),
-            content: "Hello".to_string(),
-            reasoning_content: None,
-        };
-        let json = serde_json::to_string(&msg).unwrap();
-        assert!(!json.contains("reasoning_content"));
-    }
-}

src/llm/ollama.rs

@@ -1,229 +0,0 @@
-use super::{LlmProvider, create_http_client};
-use anyhow::{Context, Result};
-use async_trait::async_trait;
-use serde::{Deserialize, Serialize};
-use std::time::Duration;
-
-/// Ollama API client
-pub struct OllamaClient {
-    base_url: String,
-    model: String,
-    client: reqwest::Client,
-    max_tokens: u32,
-    temperature: f32,
-    top_p: Option<f32>,
-}
-
-#[derive(Debug, Serialize)]
-struct GenerateRequest {
-    model: String,
-    prompt: String,
-    system: Option<String>,
-    stream: bool,
-    options: GenerationOptions,
-}
-
-#[derive(Debug, Serialize, Default)]
-struct GenerationOptions {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    temperature: Option<f32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    num_predict: Option<u32>,
-}
-
-#[derive(Debug, Deserialize)]
-struct GenerateResponse {
-    response: String,
-    done: bool,
-}
-
-#[derive(Debug, Deserialize)]
-struct ListModelsResponse {
-    models: Vec<ModelInfo>,
-}
-
-#[derive(Debug, Deserialize)]
-struct ModelInfo {
-    name: String,
-}
-
-impl OllamaClient {
-    /// Create new Ollama client
-    pub fn new(base_url: &str, model: &str) -> Self {
-        let client =
-            create_http_client(Duration::from_secs(120)).expect("Failed to create HTTP client");
-
-        Self {
-            base_url: base_url.trim_end_matches('/').to_string(),
-            model: model.to_string(),
-            client,
-            max_tokens: 500,
-            temperature: 0.7,
-            top_p: None,
-        }
-    }
-
-    /// Set timeout
-    pub fn with_timeout(mut self, timeout: Duration) -> Self {
-        self.client = create_http_client(timeout).expect("Failed to create HTTP client");
-        self
-    }
-
-    pub fn with_max_tokens(mut self, max_tokens: u32) -> Self {
-        self.max_tokens = max_tokens;
-        self
-    }
-
-    pub fn with_temperature(mut self, temperature: f32) -> Self {
-        self.temperature = temperature;
-        self
-    }
-
-    pub fn with_top_p(mut self, top_p: f32) -> Self {
-        self.top_p = Some(top_p);
-        self
-    }
-
-    /// List available models
-    pub async fn list_models(&self) -> Result<Vec<String>> {
-        let url = format!("{}/api/tags", self.base_url);
-
-        let response = self
-            .client
-            .get(&url)
-            .send()
-            .await
-            .context("Failed to list Ollama models")?;
-
-        if !response.status().is_success() {
-            let status = response.status();
-            let text = response.text().await.unwrap_or_default();
-            anyhow::bail!("Ollama API error: {} - {}", status, text);
-        }
-
-        let result: ListModelsResponse = response
-            .json()
-            .await
-            .context("Failed to parse Ollama response")?;
-
-        Ok(result.models.into_iter().map(|m| m.name).collect())
-    }
-
-    /// Pull a model
-    pub async fn pull_model(&self, model: &str) -> Result<()> {
-        let url = format!("{}/api/pull", self.base_url);
-
-        let request = serde_json::json!({
-            "name": model,
-            "stream": false,
-        });
-
-        let response = self
-            .client
-            .post(&url)
-            .json(&request)
-            .send()
-            .await
-            .context("Failed to pull Ollama model")?;
-
-        if !response.status().is_success() {
-            let status = response.status();
-            let text = response.text().await.unwrap_or_default();
-            anyhow::bail!("Ollama pull error: {} - {}", status, text);
-        }
-
-        Ok(())
-    }
-
-    /// Check if model exists
-    pub async fn model_exists(&self, model: &str) -> bool {
-        match self.list_models().await {
-            Ok(models) => models.contains(&model.to_string()),
-            Err(_) => false,
-        }
-    }
-}
-
-#[async_trait]
-impl LlmProvider for OllamaClient {
-    async fn generate(&self, prompt: &str) -> Result<String> {
-        self.generate_with_system("", prompt).await
-    }
-
-    async fn generate_with_system(&self, system: &str, user: &str) -> Result<String> {
-        let url = format!("{}/api/generate", self.base_url);
-
-        let system = if system.is_empty() {
-            None
-        } else {
-            Some(system.to_string())
-        };
-
-        let request = GenerateRequest {
-            model: self.model.clone(),
-            prompt: user.to_string(),
-            system,
-            stream: false,
-            options: GenerationOptions {
-                temperature: Some(self.temperature),
-                num_predict: Some(self.max_tokens),
-            },
-        };
-
-        let response = self
-            .client
-            .post(&url)
-            .json(&request)
-            .send()
-            .await
-            .context("Failed to send request to Ollama")?;
-
-        if !response.status().is_success() {
-            let status = response.status();
-            let text = response.text().await.unwrap_or_default();
-            anyhow::bail!("Ollama API error: {} - {}", status, text);
-        }
-
-        let result: GenerateResponse = response
-            .json()
-            .await
-            .context("Failed to parse Ollama response")?;
-
-        Ok(result.response.trim().to_string())
-    }
-
-    async fn is_available(&self) -> bool {
-        let url = format!("{}/api/tags", self.base_url);
-
-        match self.client.get(&url).send().await {
-            Ok(response) => response.status().is_success(),
-            Err(_) => false,
-        }
-    }
-
-    fn name(&self) -> &str {
-        "ollama"
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    // These tests require a running Ollama server
-    #[tokio::test]
-    #[ignore]
-    async fn test_ollama_connection() {
-        let client = OllamaClient::new("http://localhost:11434", "llama2");
-        assert!(client.is_available().await);
-    }
-
-    #[tokio::test]
-    #[ignore]
-    async fn test_ollama_generate() {
-        let client = OllamaClient::new("http://localhost:11434", "llama2");
-        let response = client.generate("Hello, how are you?").await;
-        assert!(response.is_ok());
-        println!("Response: {}", response.unwrap());
-    }
-}

src/llm/openai.rs

@@ -1,659 +0,0 @@
-use super::thinking::ThinkingStateManager;
-use super::{LlmProvider, create_http_client};
-use anyhow::{Context, Result, bail};
-use async_trait::async_trait;
-use serde::{Deserialize, Serialize};
-use std::sync::Arc;
-use std::time::Duration;
-
-/// OpenAI API client with o-series reasoning support
-pub struct OpenAiClient {
-    base_url: String,
-    api_key: String,
-    model: String,
-    client: reqwest::Client,
-    thinking_enabled: bool,
-    reasoning_effort: Option<String>,
-    max_tokens: u32,
-    temperature: f32,
-    top_p: Option<f32>,
-    thinking_state: Option<Arc<ThinkingStateManager>>,
-}
-
-#[derive(Debug, Serialize)]
-struct ChatCompletionRequest {
-    model: String,
-    messages: Vec<Message>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    max_tokens: Option<u32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    temperature: Option<f32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    top_p: Option<f32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    reasoning_effort: Option<String>,
-    stream: bool,
-}
-
-#[derive(Debug, Serialize, Deserialize, Clone)]
-struct Message {
-    role: String,
-    content: String,
-}
-
-#[derive(Debug, Deserialize)]
-struct ChatCompletionResponse {
-    choices: Vec<Choice>,
-}
-
-#[derive(Debug, Deserialize)]
-struct Choice {
-    message: Message,
-}
-
-// --- Streaming response structures ---
-
-#[derive(Debug, Deserialize)]
-struct StreamChunk {
-    choices: Vec<StreamChoice>,
-}
-
-#[derive(Debug, Deserialize)]
-struct StreamChoice {
-    delta: StreamDelta,
-    #[serde(default)]
-    finish_reason: Option<String>,
-}
-
-#[derive(Debug, Deserialize, Default)]
-struct StreamDelta {
-    #[serde(default)]
-    content: Option<String>,
-    #[serde(default)]
-    reasoning_content: Option<String>,
-}
-
-#[derive(Debug, Deserialize)]
-struct ErrorResponse {
-    error: ApiError,
-}
-
-#[derive(Debug, Deserialize)]
-struct ApiError {
-    message: String,
-    #[serde(rename = "type")]
-    error_type: String,
-}
-
-impl OpenAiClient {
-    /// Create new OpenAI client
-    pub fn new(base_url: &str, api_key: &str, model: &str) -> Result<Self> {
-        let client = create_http_client(Duration::from_secs(60))?;
-
-        Ok(Self {
-            base_url: base_url.trim_end_matches('/').to_string(),
-            api_key: api_key.to_string(),
-            model: model.to_string(),
-            client,
-            thinking_enabled: false,
-            reasoning_effort: None,
-            max_tokens: 500,
-            temperature: 0.7,
-            top_p: None,
-            thinking_state: None,
-        })
-    }
-
-    pub fn with_timeout(mut self, timeout: Duration) -> Result<Self> {
-        self.client = create_http_client(timeout)?;
-        Ok(self)
-    }
-
-    pub fn with_thinking(mut self, enabled: bool) -> Self {
-        self.thinking_enabled = enabled;
-        self
-    }
-
-    pub fn with_reasoning_effort(mut self, effort: Option<String>) -> Self {
-        self.reasoning_effort = effort;
-        self
-    }
-
-    pub fn with_max_tokens(mut self, max_tokens: u32) -> Self {
-        self.max_tokens = max_tokens;
-        self
-    }
-
-    pub fn with_temperature(mut self, temperature: f32) -> Self {
-        self.temperature = temperature;
-        self
-    }
-
-    pub fn with_top_p(mut self, top_p: f32) -> Self {
-        self.top_p = Some(top_p);
-        self
-    }
-
-    pub fn with_thinking_state(mut self, state: Arc<ThinkingStateManager>) -> Self {
-        self.thinking_state = Some(state);
-        self
-    }
-
-    pub async fn list_models(&self) -> Result<Vec<String>> {
-        let url = format!("{}/models", self.base_url);
-
-        let response = self
-            .client
-            .get(&url)
-            .header("Authorization", format!("Bearer {}", self.api_key))
-            .send()
-            .await
-            .context("Failed to list OpenAI models")?;
-
-        if !response.status().is_success() {
-            let status = response.status();
-            let text = response.text().await.unwrap_or_default();
-            bail!("OpenAI API error: {} - {}", status, text);
-        }
-
-        #[derive(Deserialize)]
-        struct ModelsResponse {
-            data: Vec<Model>,
-        }
-
-        #[derive(Deserialize)]
-        struct Model {
-            id: String,
-        }
-
-        let result: ModelsResponse = response
-            .json()
-            .await
-            .context("Failed to parse OpenAI response")?;
-
-        Ok(result.data.into_iter().map(|m| m.id).collect())
-    }
-
-    pub async fn validate_key(&self) -> Result<bool> {
-        match self.list_models().await {
-            Ok(_) => Ok(true),
-            Err(e) => {
-                let err_str = e.to_string();
-                if err_str.contains("401") || err_str.contains("Unauthorized") {
-                    Ok(false)
-                } else {
-                    Err(e)
-                }
-            }
-        }
-    }
-}
-
-#[async_trait]
-impl LlmProvider for OpenAiClient {
-    async fn generate(&self, prompt: &str) -> Result<String> {
-        let messages = vec![Message {
-            role: "user".to_string(),
-            content: prompt.to_string(),
-        }];
-
-        self.chat_completion_with_retry(messages).await
-    }
-
-    async fn generate_with_system(&self, system: &str, user: &str) -> Result<String> {
-        let mut messages = vec![];
-
-        if !system.is_empty() {
-            messages.push(Message {
-                role: "system".to_string(),
-                content: system.to_string(),
-            });
-        }
-
-        messages.push(Message {
-            role: "user".to_string(),
-            content: user.to_string(),
-        });
-
-        self.chat_completion_with_retry(messages).await
-    }
-
-    async fn is_available(&self) -> bool {
-        self.validate_key().await.unwrap_or(false)
-    }
-
-    fn name(&self) -> &str {
-        "openai"
-    }
-}
-
-impl OpenAiClient {
-    async fn chat_completion_with_retry(&self, messages: Vec<Message>) -> Result<String> {
-        let mut last_error = None;
-
-        for attempt in 1..=3 {
-            match self.chat_completion(messages.clone()).await {
-                Ok(result) => return Ok(result),
-                Err(e) => {
-                    let err_msg = e.to_string();
-                    let is_retryable = err_msg.contains("timeout")
-                        || err_msg.contains("connection")
-                        || err_msg.contains("temporary")
-                        || err_msg.contains("5")
-                            && (err_msg.contains("500")
-                                || err_msg.contains("502")
-                                || err_msg.contains("503")
-                                || err_msg.contains("504"));
-
-                    if !is_retryable || attempt == 3 {
-                        last_error = Some(e);
-                        break;
-                    }
-
-                    tokio::time::sleep(Duration::from_millis(500 * 2u64.pow(attempt - 1))).await;
-                }
-            }
-        }
-
-        Err(last_error.unwrap_or_else(|| anyhow::anyhow!("Request failed after retries")))
-    }
-
-    async fn chat_completion(&self, messages: Vec<Message>) -> Result<String> {
-        if self.thinking_enabled {
-            self.streaming_chat_completion(messages).await
-        } else {
-            self.non_streaming_chat_completion(messages).await
-        }
-    }
-
-    async fn non_streaming_chat_completion(&self, messages: Vec<Message>) -> Result<String> {
-        let url = format!("{}/chat/completions", self.base_url);
-
-        let request = ChatCompletionRequest {
-            model: self.model.clone(),
-            messages,
-            max_tokens: Some(self.max_tokens),
-            temperature: Some(self.temperature),
-            top_p: self.top_p,
-            reasoning_effort: if is_reasoning_model(&self.model) {
-                Some("none".to_string())
-            } else {
-                None
-            },
-            stream: false,
-        };
-
-        let response = self
-            .client
-            .post(&url)
-            .header("Authorization", format!("Bearer {}", self.api_key))
-            .header("Content-Type", "application/json")
-            .json(&request)
-            .send()
-            .await
-            .context("Failed to send request to OpenAI")?;
-
-        let status = response.status();
-
-        if !status.is_success() {
-            let text = response.text().await.unwrap_or_default();
-
-            if let Ok(error) = serde_json::from_str::<ErrorResponse>(&text) {
-                bail!(
-                    "OpenAI API error: {} ({})",
-                    error.error.message,
-                    error.error.error_type
-                );
-            }
-
-            bail!("OpenAI API error: {} - {}", status, text);
-        }
-
-        let result: ChatCompletionResponse = response
-            .json()
-            .await
-            .context("Failed to parse OpenAI response")?;
-
-        result
-            .choices
-            .into_iter()
-            .next()
-            .map(|c| c.message.content.trim().to_string())
-            .filter(|s| !s.is_empty())
-            .ok_or_else(|| anyhow::anyhow!("No response from OpenAI"))
-    }
-
-    /// Streaming request for reasoning mode, filters reasoning_content from output
-    async fn streaming_chat_completion(&self, messages: Vec<Message>) -> Result<String> {
-        let url = format!("{}/chat/completions", self.base_url);
-
-        // For reasoning/thinking mode, omit temperature and top_p
-        let request = ChatCompletionRequest {
-            model: self.model.clone(),
-            messages,
-            max_tokens: Some(self.max_tokens),
-            temperature: None,
-            top_p: None,
-            reasoning_effort: self.reasoning_effort.clone(),
-            stream: true,
-        };
-
-        let response = self
-            .client
-            .post(&url)
-            .header("Authorization", format!("Bearer {}", self.api_key))
-            .header("Content-Type", "application/json")
-            .header("Accept", "text/event-stream")
-            .json(&request)
-            .send()
-            .await
-            .context("Failed to send streaming request to OpenAI")?;
-
-        let status = response.status();
-
-        if !status.is_success() {
-            let text = response.text().await.unwrap_or_default();
-
-            if let Ok(error) = serde_json::from_str::<ErrorResponse>(&text) {
-                bail!(
-                    "OpenAI API error: {} ({})",
-                    error.error.message,
-                    error.error.error_type
-                );
-            }
-
-            bail!("OpenAI API error: {} - {}", status, text);
-        }
-
-        let mut content_buffer = String::new();
-        let mut has_reasoning = false;
-        let mut has_content = false;
-
-        let thinking_state = self.thinking_state.as_ref();
-
-        let mut byte_stream = response.bytes_stream();
-        let mut line_buffer = String::new();
-
-        use futures_util::StreamExt;
-
-        while let Some(chunk) = byte_stream.next().await {
-            let chunk = chunk.context("Failed to read streaming response chunk")?;
-            let chunk_str =
-                String::from_utf8(chunk.to_vec()).context("Invalid UTF-8 in stream chunk")?;
-
-            line_buffer.push_str(&chunk_str);
-
-            while let Some(line_end) = line_buffer.find('\n') {
-                let line = line_buffer[..line_end].trim().to_string();
-                line_buffer = line_buffer[line_end + 1..].to_string();
-
-                if line.is_empty() {
-                    continue;
-                }
-
-                if line == "data: [DONE]" {
-                    break;
-                }
-
-                if let Some(json_str) = line.strip_prefix("data: ") {
-                    if let Ok(chunk) = serde_json::from_str::<StreamChunk>(json_str) {
-                        for choice in &chunk.choices {
-                            // Handle reasoning_content (o-series)
-                            if let Some(ref reasoning) = choice.delta.reasoning_content
-                                && !reasoning.is_empty()
-                            {
-                                if !has_reasoning {
-                                    has_reasoning = true;
-                                    if let Some(state) = thinking_state {
-                                        state.start_thinking();
-                                    }
-                                }
-                                continue;
-                            }
-
-                            // Handle content
-                            if let Some(ref content) = choice.delta.content
-                                && !content.is_empty()
-                            {
-                                if has_reasoning
-                                    && !has_content
-                                    && let Some(state) = thinking_state
-                                {
-                                    state.end_thinking();
-                                }
-                                has_content = true;
-                                content_buffer.push_str(content);
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        if let Some(state) = thinking_state {
-            state.end_thinking();
-        }
-
-        let result = content_buffer.trim().to_string();
-
-        if result.is_empty() {
-            if has_reasoning && !has_content {
-                bail!(
-                    "OpenAI returned reasoning content but no final answer. \
-                     The model may have entered an incomplete reasoning state. \
-                     Please try again or disable thinking mode."
-                );
-            }
-            bail!(
-                "No response from OpenAI. \
-                 If thinking mode is enabled, try disabling it or ensure the model supports reasoning."
-            );
-        }
-
-        Ok(result)
-    }
-}
-
-/// Azure OpenAI client (extends OpenAI with Azure-specific config)
-pub struct AzureOpenAiClient {
-    endpoint: String,
-    api_key: String,
-    deployment: String,
-    api_version: String,
-    client: reqwest::Client,
-    thinking_enabled: bool,
-    reasoning_effort: Option<String>,
-    max_tokens: u32,
-    temperature: f32,
-    top_p: Option<f32>,
-    thinking_state: Option<Arc<ThinkingStateManager>>,
-}
-
-impl AzureOpenAiClient {
-    pub fn new(endpoint: &str, api_key: &str, deployment: &str, api_version: &str) -> Result<Self> {
-        let client = create_http_client(Duration::from_secs(60))?;
-
-        Ok(Self {
-            endpoint: endpoint.trim_end_matches('/').to_string(),
-            api_key: api_key.to_string(),
-            deployment: deployment.to_string(),
-            api_version: api_version.to_string(),
-            client,
-            thinking_enabled: false,
-            reasoning_effort: None,
-            max_tokens: 500,
-            temperature: 0.7,
-            top_p: None,
-            thinking_state: None,
-        })
-    }
-
-    async fn chat_completion(&self, messages: Vec<Message>) -> Result<String> {
-        let url = format!(
-            "{}/openai/deployments/{}/chat/completions?api-version={}",
-            self.endpoint, self.deployment, self.api_version
-        );
-
-        let request = ChatCompletionRequest {
-            model: self.deployment.clone(),
-            messages,
-            max_tokens: Some(self.max_tokens),
-            temperature: Some(self.temperature),
-            top_p: self.top_p,
-            reasoning_effort: self.reasoning_effort.clone(),
-            stream: false,
-        };
-
-        let response = self
-            .client
-            .post(&url)
-            .header("api-key", &self.api_key)
-            .header("Content-Type", "application/json")
-            .json(&request)
-            .send()
-            .await
-            .context("Failed to send request to Azure OpenAI")?;
-
-        if !response.status().is_success() {
-            let status = response.status();
-            let text = response.text().await.unwrap_or_default();
-            bail!("Azure OpenAI API error: {} - {}", status, text);
-        }
-
-        let result: ChatCompletionResponse = response
-            .json()
-            .await
-            .context("Failed to parse Azure OpenAI response")?;
-
-        result
-            .choices
-            .into_iter()
-            .next()
-            .map(|c| c.message.content.trim().to_string())
-            .filter(|s| !s.is_empty())
-            .ok_or_else(|| anyhow::anyhow!("No response from Azure OpenAI"))
-    }
-}
-
-#[async_trait]
-impl LlmProvider for AzureOpenAiClient {
-    async fn generate(&self, prompt: &str) -> Result<String> {
-        let messages = vec![Message {
-            role: "user".to_string(),
-            content: prompt.to_string(),
-        }];
-
-        self.chat_completion(messages).await
-    }
-
-    async fn generate_with_system(&self, system: &str, user: &str) -> Result<String> {
-        let mut messages = vec![];
-
-        if !system.is_empty() {
-            messages.push(Message {
-                role: "system".to_string(),
-                content: system.to_string(),
-            });
-        }
-
-        messages.push(Message {
-            role: "user".to_string(),
-            content: user.to_string(),
-        });
-
-        self.chat_completion(messages).await
-    }
-
-    async fn is_available(&self) -> bool {
-        let url = format!(
-            "{}/openai/deployments/{}/chat/completions?api-version={}",
-            self.endpoint, self.deployment, self.api_version
-        );
-
-        let request = ChatCompletionRequest {
-            model: self.deployment.clone(),
-            messages: vec![Message {
-                role: "user".to_string(),
-                content: "Hi".to_string(),
-            }],
-            max_tokens: Some(5),
-            temperature: Some(0.0),
-            top_p: None,
-            reasoning_effort: None,
-            stream: false,
-        };
-
-        match self
-            .client
-            .post(&url)
-            .header("api-key", &self.api_key)
-            .json(&request)
-            .send()
-            .await
-        {
-            Ok(response) => response.status().is_success(),
-            Err(_) => false,
-        }
-    }
-
-    fn name(&self) -> &str {
-        "azure-openai"
-    }
-}
-
-/// Available OpenAI models (including o-series with reasoning)
-pub const OPENAI_MODELS: &[&str] = &[
-    "o4-mini",
-    "o3",
-    "o3-mini",
-    "o1",
-    "o1-mini",
-    "o1-pro",
-    "gpt-4.1",
-    "gpt-4.1-mini",
-    "gpt-4.1-nano",
-    "gpt-4o",
-    "gpt-4o-mini",
-    "gpt-4-turbo",
-    "gpt-4",
-    "gpt-3.5-turbo",
-];
-
-pub fn is_valid_model(model: &str) -> bool {
-    OPENAI_MODELS.contains(&model)
-}
-
-fn is_reasoning_model(model: &str) -> bool {
-    model.starts_with("o")
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_model_validation_o_series() {
-        assert!(is_valid_model("o4-mini"));
-        assert!(is_valid_model("o3"));
-        assert!(is_valid_model("o1"));
-        assert!(is_valid_model("gpt-4o"));
-        assert!(is_valid_model("gpt-3.5-turbo"));
-        assert!(!is_valid_model("invalid-model"));
-    }
-
-    #[test]
-    fn test_stream_delta_reasoning_parsing() {
-        let json = r#"{"content":null,"reasoning_content":"Let me think..."}"#;
-        let delta: StreamDelta = serde_json::from_str(json).unwrap();
-        assert!(delta.content.is_none());
-        assert_eq!(delta.reasoning_content, Some("Let me think...".to_string()));
-    }
-
-    #[test]
-    fn test_stream_delta_content_parsing() {
-        let json = r#"{"content":"Hello","reasoning_content":null}"#;
-        let delta: StreamDelta = serde_json::from_str(json).unwrap();
-        assert_eq!(delta.content, Some("Hello".to_string()));
-        assert!(delta.reasoning_content.is_none());
-    }
-}

src/llm/openrouter.rs

@@ -1,286 +0,0 @@
-use super::{LlmProvider, create_http_client};
-use anyhow::{Context, Result, bail};
-use async_trait::async_trait;
-use serde::{Deserialize, Serialize};
-use std::time::Duration;
-
-/// OpenRouter API client
-pub struct OpenRouterClient {
-    base_url: String,
-    api_key: String,
-    model: String,
-    client: reqwest::Client,
-    max_tokens: u32,
-    temperature: f32,
-    top_p: Option<f32>,
-}
-
-#[derive(Debug, Serialize)]
-struct ChatCompletionRequest {
-    model: String,
-    messages: Vec<Message>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    max_tokens: Option<u32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    temperature: Option<f32>,
-    stream: bool,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-struct Message {
-    role: String,
-    content: String,
-}
-
-#[derive(Debug, Deserialize)]
-struct ChatCompletionResponse {
-    choices: Vec<Choice>,
-}
-
-#[derive(Debug, Deserialize)]
-struct Choice {
-    message: Message,
-}
-
-#[derive(Debug, Deserialize)]
-struct ErrorResponse {
-    error: ApiError,
-}
-
-#[derive(Debug, Deserialize)]
-struct ApiError {
-    message: String,
-    #[serde(rename = "type")]
-    error_type: String,
-}
-
-impl OpenRouterClient {
-    /// Create new OpenRouter client
-    pub fn new(api_key: &str, model: &str) -> Result<Self> {
-        let client = create_http_client(Duration::from_secs(60))?;
-
-        Ok(Self {
-            base_url: "https://openrouter.ai/api/v1".to_string(),
-            api_key: api_key.to_string(),
-            model: model.to_string(),
-            client,
-            max_tokens: 500,
-            temperature: 0.7,
-            top_p: None,
-        })
-    }
-
-    /// Create with custom base URL
-    pub fn with_base_url(api_key: &str, model: &str, base_url: &str) -> Result<Self> {
-        let client = create_http_client(Duration::from_secs(60))?;
-
-        Ok(Self {
-            base_url: base_url.trim_end_matches('/').to_string(),
-            api_key: api_key.to_string(),
-            model: model.to_string(),
-            client,
-            max_tokens: 500,
-            temperature: 0.7,
-            top_p: None,
-        })
-    }
-
-    /// Set timeout
-    pub fn with_timeout(mut self, timeout: Duration) -> Result<Self> {
-        self.client = create_http_client(timeout)?;
-        Ok(self)
-    }
-
-    pub fn with_max_tokens(mut self, max_tokens: u32) -> Self {
-        self.max_tokens = max_tokens;
-        self
-    }
-
-    pub fn with_temperature(mut self, temperature: f32) -> Self {
-        self.temperature = temperature;
-        self
-    }
-
-    pub fn with_top_p(mut self, top_p: f32) -> Self {
-        self.top_p = Some(top_p);
-        self
-    }
-
-    /// List available models
-    pub async fn list_models(&self) -> Result<Vec<String>> {
-        let url = format!("{}/models", self.base_url);
-
-        let response = self
-            .client
-            .get(&url)
-            .header("Authorization", format!("Bearer {}", self.api_key))
-            .header("HTTP-Referer", "https://quicommit.dev")
-            .header("X-Title", "QuiCommit")
-            .send()
-            .await
-            .context("Failed to list OpenRouter models")?;
-
-        if !response.status().is_success() {
-            let status = response.status();
-            let text = response.text().await.unwrap_or_default();
-            bail!("OpenRouter API error: {} - {}", status, text);
-        }
-
-        #[derive(Deserialize)]
-        struct ModelsResponse {
-            data: Vec<Model>,
-        }
-
-        #[derive(Deserialize)]
-        struct Model {
-            id: String,
-        }
-
-        let result: ModelsResponse = response
-            .json()
-            .await
-            .context("Failed to parse OpenRouter response")?;
-
-        Ok(result.data.into_iter().map(|m| m.id).collect())
-    }
-
-    /// Validate API key
-    pub async fn validate_key(&self) -> Result<bool> {
-        match self.list_models().await {
-            Ok(_) => Ok(true),
-            Err(e) => {
-                let err_str = e.to_string();
-                if err_str.contains("401") || err_str.contains("Unauthorized") {
-                    Ok(false)
-                } else {
-                    Err(e)
-                }
-            }
-        }
-    }
-}
-
-#[async_trait]
-impl LlmProvider for OpenRouterClient {
-    async fn generate(&self, prompt: &str) -> Result<String> {
-        let messages = vec![Message {
-            role: "user".to_string(),
-            content: prompt.to_string(),
-        }];
-
-        self.chat_completion(messages).await
-    }
-
-    async fn generate_with_system(&self, system: &str, user: &str) -> Result<String> {
-        let mut messages = vec![];
-
-        if !system.is_empty() {
-            messages.push(Message {
-                role: "system".to_string(),
-                content: system.to_string(),
-            });
-        }
-
-        messages.push(Message {
-            role: "user".to_string(),
-            content: user.to_string(),
-        });
-
-        self.chat_completion(messages).await
-    }
-
-    async fn is_available(&self) -> bool {
-        self.validate_key().await.unwrap_or(false)
-    }
-
-    fn name(&self) -> &str {
-        "openrouter"
-    }
-}
-
-impl OpenRouterClient {
-    async fn chat_completion(&self, messages: Vec<Message>) -> Result<String> {
-        let url = format!("{}/chat/completions", self.base_url);
-
-        let request = ChatCompletionRequest {
-            model: self.model.clone(),
-            messages,
-            max_tokens: Some(self.max_tokens),
-            temperature: Some(self.temperature),
-            stream: false,
-        };
-
-        let response = self
-            .client
-            .post(&url)
-            .header("Authorization", format!("Bearer {}", self.api_key))
-            .header("Content-Type", "application/json")
-            .header("HTTP-Referer", "https://quicommit.dev")
-            .header("X-Title", "QuiCommit")
-            .json(&request)
-            .send()
-            .await
-            .context("Failed to send request to OpenRouter")?;
-
-        let status = response.status();
-
-        if !status.is_success() {
-            let text = response.text().await.unwrap_or_default();
-
-            // Try to parse error
-            if let Ok(error) = serde_json::from_str::<ErrorResponse>(&text) {
-                bail!(
-                    "OpenRouter API error: {} ({})",
-                    error.error.message,
-                    error.error.error_type
-                );
-            }
-
-            bail!("OpenRouter API error: {} - {}", status, text);
-        }
-
-        let result: ChatCompletionResponse = response
-            .json()
-            .await
-            .context("Failed to parse OpenRouter response")?;
-
-        result
-            .choices
-            .into_iter()
-            .next()
-            .map(|c| c.message.content.trim().to_string())
-            .ok_or_else(|| anyhow::anyhow!("No response from OpenRouter"))
-    }
-}
-
-/// Popular OpenRouter models
-pub const OPENROUTER_MODELS: &[&str] = &[
-    "openai/gpt-3.5-turbo",
-    "openai/gpt-4",
-    "openai/gpt-4-turbo",
-    "anthropic/claude-3-opus",
-    "anthropic/claude-3-sonnet",
-    "anthropic/claude-3-haiku",
-    "google/gemini-pro",
-    "meta-llama/llama-2-70b-chat",
-    "mistralai/mixtral-8x7b-instruct",
-    "01-ai/yi-34b-chat",
-];
-
-/// Check if a model name is valid
-pub fn is_valid_model(_model: &str) -> bool {
-    // Since OpenRouter supports many models, we'll allow any model name
-    // but provide some popular ones as suggestions
-    true
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_model_validation() {
-        assert!(is_valid_model("openai/gpt-4"));
-        assert!(is_valid_model("custom/model"));
-    }
-}

src/llm/parsing.rs

@@ -0,0 +1,281 @@
+use anyhow::{Result, bail};
+
+/// Parse commit response from LLM
+pub(crate) fn parse_commit_response(
+    response: &str,
+    format: crate::config::CommitFormat,
+) -> Result<GeneratedCommit> {
+    // Clean markdown code fences from the response
+    let cleaned = strip_code_fences(response);
+
+    let lines: Vec<&str> = cleaned
+        .lines()
+        .map(|l| l.trim())
+        .filter(|l| !l.is_empty())
+        .collect();
+
+    if lines.is_empty() {
+        let preview: String = response.chars().take(200).collect();
+        bail!(
+            "LLM returned empty or whitespace-only response. \
+             Raw response preview: '{}'. \
+             Hint: If using DeepSeek/Kimi with thinking enabled, \
+             the model may have returned reasoning_content only. \
+             Try disabling thinking mode or switching models.",
+            preview
+        );
+    }
+
+    // Find the line most likely to be the commit subject
+    let first_line = find_commit_subject_line(&lines, format);
+
+    // Parse based on format
+    match format {
+        crate::config::CommitFormat::Conventional => {
+            parse_conventional_commit(first_line, &lines, response)
+        }
+        crate::config::CommitFormat::Commitlint => {
+            parse_commitlint_commit(first_line, &lines, response)
+        }
+    }
+}
+
+/// Remove surrounding markdown code fences (```) from LLM output
+fn strip_code_fences(response: &str) -> String {
+    let mut lines: Vec<&str> = response.lines().collect();
+
+    // Strip leading fence lines (``` or ```lang)
+    while lines.first().map_or(false, |l| l.trim().starts_with("```")) {
+        lines.remove(0);
+    }
+
+    // Strip trailing fence lines
+    while lines.last().map_or(false, |l| l.trim() == "```") {
+        lines.pop();
+    }
+
+    lines.join("\n")
+}
+
+/// Find the line that is most likely the commit subject among extracted lines
+fn find_commit_subject_line<'a>(
+    lines: &[&'a str],
+    format: crate::config::CommitFormat,
+) -> &'a str {
+    let valid_types = crate::utils::validators::get_commit_types(matches!(
+        format,
+        crate::config::CommitFormat::Commitlint
+    ));
+
+    // First pass: line starting with a known type that also has proper syntax
+    // (e.g. "type:", "type(scope):", "type!:")
+    for &line in lines {
+        let trimmed = line.trim();
+        for &t in valid_types {
+            if let Some(rest) = trimmed.strip_prefix(t) {
+                if rest.starts_with(':') || rest.starts_with('(') || rest.starts_with("!:") {
+                    return trimmed;
+                }
+            }
+        }
+    }
+
+    // Second pass: any line containing a colon (generic "prefix: description")
+    for &line in lines {
+        if line.contains(':') {
+            return line.trim();
+        }
+    }
+
+    // Fallback: return the first line as-is
+    lines[0].trim()
+}
+
+fn parse_conventional_commit(
+    first_line: &str,
+    lines: &[&str],
+    raw_response: &str,
+) -> Result<GeneratedCommit> {
+    // Parse: type(scope)!: description
+    let parts: Vec<&str> = first_line.splitn(2, ':').collect();
+    if parts.len() != 2 {
+        let preview: String = raw_response.chars().take(300).collect();
+        bail!(
+            "Invalid conventional commit format: missing colon.\n\
+             Parsed subject line: '{}'\n\
+             Raw response preview: '{}'\n\
+             Expected: <type>[optional scope]: <description>",
+            first_line,
+            preview
+        );
+    }
+
+    let type_part = parts[0];
+    let description = parts[1].trim();
+
+    // Extract type, scope, and breaking indicator
+    let breaking = type_part.ends_with('!');
+    let type_part = type_part.trim_end_matches('!');
+
+    let (commit_type, scope) = if let Some(start) = type_part.find('(') {
+        if let Some(end) = type_part.find(')') {
+            let t = &type_part[..start];
+            let s = &type_part[start + 1..end];
+            (t.to_string(), Some(s.to_string()))
+        } else {
+            bail!("Invalid scope format: missing closing parenthesis");
+        }
+    } else {
+        (type_part.to_string(), None)
+    };
+
+    // Extract body and footer
+    let (body, footer) = extract_body_footer(lines);
+
+    Ok(GeneratedCommit {
+        commit_type,
+        scope,
+        description: description.to_string(),
+        body,
+        footer,
+        breaking,
+    })
+}
+
+fn parse_commitlint_commit(
+    first_line: &str,
+    lines: &[&str],
+    raw_response: &str,
+) -> Result<GeneratedCommit> {
+    // Similar parsing but with commitlint rules
+    let parts: Vec<&str> = first_line.splitn(2, ':').collect();
+    if parts.len() != 2 {
+        let preview: String = raw_response.chars().take(300).collect();
+        bail!(
+            "Invalid commit format: missing colon.\n\
+             Parsed subject line: '{}'\n\
+             Raw response preview: '{}'\n\
+             Expected: <type>[optional scope]: <subject>",
+            first_line,
+            preview
+        );
+    }
+
+    let type_part = parts[0];
+    let subject = parts[1].trim();
+
+    let (commit_type, scope) = if let Some(start) = type_part.find('(') {
+        if let Some(end) = type_part.find(')') {
+            let t = &type_part[..start];
+            let s = &type_part[start + 1..end];
+            (t.to_string(), Some(s.to_string()))
+        } else {
+            (type_part.to_string(), None)
+        }
+    } else {
+        (type_part.to_string(), None)
+    };
+
+    let (body, footer) = extract_body_footer(&lines);
+
+    Ok(GeneratedCommit {
+        commit_type,
+        scope,
+        description: subject.to_string(),
+        body,
+        footer,
+        breaking: false,
+    })
+}
+
+fn extract_body_footer(lines: &[&str]) -> (Option<String>, Option<String>) {
+    if lines.len() <= 1 {
+        return (None, None);
+    }
+
+    let rest: Vec<&str> = lines[1..]
+        .iter()
+        .skip_while(|l| l.trim().is_empty())
+        .copied()
+        .collect();
+
+    if rest.is_empty() {
+        return (None, None);
+    }
+
+    // Look for footer markers
+    let footer_markers = [
+        "BREAKING CHANGE:",
+        "Closes",
+        "Fixes",
+        "Refs",
+        "Co-authored-by:",
+    ];
+
+    let mut body_lines = vec![];
+    let mut footer_lines = vec![];
+    let mut in_footer = false;
+
+    for line in &rest {
+        if footer_markers.iter().any(|m| line.starts_with(m)) {
+            in_footer = true;
+        }
+
+        if in_footer {
+            footer_lines.push(*line);
+        } else {
+            body_lines.push(*line);
+        }
+    }
+
+    let body = if body_lines.is_empty() {
+        None
+    } else {
+        Some(body_lines.join("\n"))
+    };
+
+    let footer = if footer_lines.is_empty() {
+        None
+    } else {
+        Some(footer_lines.join("\n"))
+    };
+
+    (body, footer)
+}
+
+/// Generated commit structure
+#[derive(Debug, Clone)]
+pub struct GeneratedCommit {
+    pub commit_type: String,
+    pub scope: Option<String>,
+    pub description: String,
+    pub body: Option<String>,
+    pub footer: Option<String>,
+    pub breaking: bool,
+}
+
+impl GeneratedCommit {
+    /// Format as conventional commit
+    pub fn to_conventional(&self) -> String {
+        crate::utils::formatter::format_conventional_commit(
+            &self.commit_type,
+            self.scope.as_deref(),
+            &self.description,
+            self.body.as_deref(),
+            self.footer.as_deref(),
+            self.breaking,
+        )
+    }
+
+    /// Format as commitlint commit
+    pub fn to_commitlint(&self) -> String {
+        crate::utils::formatter::format_commitlint_commit(
+            &self.commit_type,
+            self.scope.as_deref(),
+            &self.description,
+            self.body.as_deref(),
+            self.footer.as_deref(),
+            None,
+        )
+    }
+}

src/llm/prompts.rs

@@ -0,0 +1,618 @@
+use crate::config::Language;
+
+/// Get commit system prompt based on format and language
+pub(crate) fn get_commit_system_prompt(
+    format: crate::config::CommitFormat,
+    language: Language,
+) -> &'static str {
+    match (format, language) {
+        (crate::config::CommitFormat::Conventional, Language::Chinese) => {
+            CONVENTIONAL_COMMIT_SYSTEM_PROMPT_ZH
+        }
+        (crate::config::CommitFormat::Conventional, Language::Japanese) => {
+            CONVENTIONAL_COMMIT_SYSTEM_PROMPT_JA
+        }
+        (crate::config::CommitFormat::Conventional, Language::Korean) => {
+            CONVENTIONAL_COMMIT_SYSTEM_PROMPT_KO
+        }
+        (crate::config::CommitFormat::Conventional, Language::Spanish) => {
+            CONVENTIONAL_COMMIT_SYSTEM_PROMPT_ES
+        }
+        (crate::config::CommitFormat::Conventional, Language::French) => {
+            CONVENTIONAL_COMMIT_SYSTEM_PROMPT_FR
+        }
+        (crate::config::CommitFormat::Conventional, Language::German) => {
+            CONVENTIONAL_COMMIT_SYSTEM_PROMPT_DE
+        }
+        (crate::config::CommitFormat::Conventional, _) => CONVENTIONAL_COMMIT_SYSTEM_PROMPT,
+        (crate::config::CommitFormat::Commitlint, Language::Chinese) => COMMITLINT_SYSTEM_PROMPT_ZH,
+        (crate::config::CommitFormat::Commitlint, Language::Japanese) => {
+            COMMITLINT_SYSTEM_PROMPT_JA
+        }
+        (crate::config::CommitFormat::Commitlint, Language::Korean) => COMMITLINT_SYSTEM_PROMPT_KO,
+        (crate::config::CommitFormat::Commitlint, Language::Spanish) => COMMITLINT_SYSTEM_PROMPT_ES,
+        (crate::config::CommitFormat::Commitlint, Language::French) => COMMITLINT_SYSTEM_PROMPT_FR,
+        (crate::config::CommitFormat::Commitlint, Language::German) => COMMITLINT_SYSTEM_PROMPT_DE,
+        (crate::config::CommitFormat::Commitlint, _) => COMMITLINT_SYSTEM_PROMPT,
+    }
+}
+
+pub(crate) fn get_tag_system_prompt(language: Language) -> &'static str {
+    match language {
+        Language::Chinese => TAG_MESSAGE_SYSTEM_PROMPT_ZH,
+        Language::Japanese => TAG_MESSAGE_SYSTEM_PROMPT_JA,
+        Language::Korean => TAG_MESSAGE_SYSTEM_PROMPT_KO,
+        Language::Spanish => TAG_MESSAGE_SYSTEM_PROMPT_ES,
+        Language::French => TAG_MESSAGE_SYSTEM_PROMPT_FR,
+        Language::German => TAG_MESSAGE_SYSTEM_PROMPT_DE,
+        _ => TAG_MESSAGE_SYSTEM_PROMPT,
+    }
+}
+
+pub(crate) fn get_changelog_system_prompt(language: Language) -> &'static str {
+    match language {
+        Language::Chinese => CHANGELOG_SYSTEM_PROMPT_ZH,
+        Language::Japanese => CHANGELOG_SYSTEM_PROMPT_JA,
+        Language::Korean => CHANGELOG_SYSTEM_PROMPT_KO,
+        Language::Spanish => CHANGELOG_SYSTEM_PROMPT_ES,
+        Language::French => CHANGELOG_SYSTEM_PROMPT_FR,
+        Language::German => CHANGELOG_SYSTEM_PROMPT_DE,
+        _ => CHANGELOG_SYSTEM_PROMPT,
+    }
+}
+
+// System prompts for LLM
+
+const CONVENTIONAL_COMMIT_SYSTEM_PROMPT: &str = r#"You are a helpful assistant that generates conventional commit messages.
+
+Analyze the git diff provided and generate a commit message following the Conventional Commits specification.
+
+Format: <type>[optional scope]: <description>
+
+Types:
+- feat: A new feature
+- fix: A bug fix
+- docs: Documentation only changes
+- style: Changes that don't affect code meaning (formatting, semicolons, etc.)
+- refactor: Code change that neither fixes a bug nor adds a feature
+- perf: Code change that improves performance
+- test: Adding or correcting tests
+- build: Changes to build system or dependencies
+- ci: Changes to CI configuration
+- chore: Other changes that don't modify src or test files
+- revert: Reverts a previous commit
+
+Rules:
+1. Use lowercase for type and scope
+2. Keep description under 100 characters
+3. Use imperative mood ("add" not "added")
+4. Don't capitalize first letter
+5. No period at the end
+6. Include scope if the change is specific to a module/component
+
+Output ONLY the commit message, nothing else.
+"#;
+
+const CONVENTIONAL_COMMIT_SYSTEM_PROMPT_ZH: &str = r#"你是一个生成符合 Conventional Commits 规范的提交消息的助手。
+
+分析提供的 git diff，并生成符合 Conventional Commits 规范的提交消息。
+
+格式: <type>[可选作用域]: <描述>
+
+类型:
+- feat: 新功能
+- fix: 修复错误
+- docs: 仅文档更改
+- style: 不影响代码含义的更改（格式化、分号等）
+- refactor: 既不修复错误也不添加功能的代码更改
+- perf: 提高性能的代码更改
+- test: 添加或更正测试
+- build: 更改构建系统或依赖项
+- ci: 更改 CI 配置
+- chore: 其他不修改 src 或测试文件的更改
+- revert: 撤销之前的提交
+
+规则:
+1. 类型和小写使用小写
+2. 描述保持在 100 个字符以内
+3. 使用祈使语气（"添加"而不是"已添加"）
+4. 不要大写首字母
+5. 结尾不要句号
+6. 如果更改特定于模块/组件，请包含作用域
+7. 仅输出提交消息，不要输出其他内容。
+"#;
+
+const CONVENTIONAL_COMMIT_SYSTEM_PROMPT_JA: &str = r#"あなたはConventional Commits仕様に従ったコミットメッセージを生成するアシスタントです。
+
+提供されたgit diffを分析し、Conventional Commits仕様に従ったコミットメッセージを生成してください。
+
+形式: <type>[オプションのスコープ]: <説明>
+
+タイプ:
+- feat: 新機能
+- fix: バグ修正
+- docs: ドキュメントのみの変更
+- style: コードの意味に影響しない変更（フォーマット、セミコロンなど）
+- refactor: バグ修正や機能追加を伴わないコード変更
+- perf: パフォーマンスを向上させるコード変更
+- test: テストの追加または修正
+- build: ビルドシステムまたは依存関係の変更
+- ci: CI設定の変更
+- chore: srcやテストファイルを変更しないその他の変更
+- revert: 以前のコミットを取り消す
+
+ルール:
+1. タイプとスコープは小文字を使用
+2. 説明は100文字以内にする
+3. 命令形を使用する（"追加"ではなく"追加する"）
+4. 先頭を大文字にしない
+5. 最後にピリオドを付けない
+6. 変更がモジュール/コンポーネントに固有の場合はスコープを含める
+7. コミットメッセージのみを出力し、それ以外は出力しないでください。
+"#;
+
+const CONVENTIONAL_COMMIT_SYSTEM_PROMPT_KO: &str = r#"당신은 Conventional Commits 사양에 따른 커밋 메시지를 생성하는 도우미입니다.
+
+제공된 git diff를 분석하고 Conventional Commits 사양에 따른 커밋 메시지를 생성하세요.
+
+형식: <type>[선택적 범위]: <설명>
+
+유형:
+- feat: 새 기능
+- fix: 버그 수정
+- docs: 문서 변경만
+- style: 코드 의미에 영향을 주지 않는 변경(서식, 세미콜론 등)
+- refactor: 버그를 수정하거나 기능을 추가하지 않는 코드 변경
+- perf: 성능을 향상시키는 코드 변경
+- test: 테스트 추가 또는 수정
+- build: 빌드 시스템 또는 종속성 변경
+- ci: CI 구성 변경
+- chore: src 또는 테스트 파일을 수정하지 않는 기타 변경
+- revert: 이전 커밋 되돌리기
+
+규칙:
+1. 유형과 범위는 소문자 사용
+2. 설명은 100자 이내로 유지
+3. 명령형 사용("추가"가 아닌 "추가하다")
+4. 첫 글자 대문자화하지 않음
+5. 끝에 마침표 사용하지 않음
+6. 변경 사항이 모듈/구성 요소에 특정한 경우 범위 포함
+7. 커밋 메시지만 출력하고 다른 내용은 출력하지 마세요.
+"#;
+
+const CONVENTIONAL_COMMIT_SYSTEM_PROMPT_ES: &str = r#"Eres un asistente que genera mensajes de commit siguiendo la especificación Conventional Commits.
+
+Analiza el diff de git proporcionado y genera un mensaje de commit siguiendo la especificación Conventional Commits.
+
+Formato: <tipo>[alcance opcional]: <descripción>
+
+Tipos:
+- feat: Una nueva característica
+- fix: Una corrección de error
+- docs: Solo cambios en documentación
+- style: Cambios que no afectan el significado del código (formato, punto y coma, etc.)
+- refactor: Cambio de código que no corrige un error ni agrega una característica
+- perf: Cambio de código que mejora el rendimiento
+- test: Agregar o corregir pruebas
+- build: Cambios en el sistema de construcción o dependencias
+- ci: Cambios en la configuración de CI
+- chore: Otros cambios que no modifican archivos src o de prueba
+- revert: Revierte un commit anterior
+
+Reglas:
+1. Usa minúsculas para tipo y alcance
+2. Mantén la descripción bajo 100 caracteres
+3. Usa modo imperativo ("agregar" no "agregado")
+4. No capitalices la primera letra
+5. Sin punto al final
+6. Incluye alcance si el cambio es específico de un módulo/componente
+7. Genera SOLO el mensaje de commit, nada más.
+"#;
+
+const CONVENTIONAL_COMMIT_SYSTEM_PROMPT_FR: &str = r#"Vous êtes un assistant qui génère des messages de commit suivant la spécification Conventional Commits.
+
+Analysez le diff git fourni et générez un message de commit suivant la spécification Conventional Commits.
+
+Format: <type>[portée optionnelle]: <description>
+
+Types:
+- feat: Une nouvelle fonctionnalité
+- fix: Une correction de bug
+- docs: Changements de documentation uniquement
+- style: Changements qui n'affectent pas la signification du code (formatage, points-virgules, etc.)
+- refactor: Changement de code qui ne corrige pas un bug ni n'ajoute une fonctionnalité
+- perf: Changement de code qui améliore les performances
+- test: Ajout ou correction de tests
+- build: Changements du système de build ou des dépendances
+- ci: Changements de la configuration CI
+- chore: Autres changements qui ne modifient pas les fichiers src ou de test
+- revert: Révertit un commit précédent
+
+Règles:
+1. Utilisez des minuscules pour le type et la portée
+2. Gardez la description sous 100 caractères
+3. Utilisez le mode impératif ("ajouter" non "ajouté")
+4. Ne capitalisez pas la première lettre
+5. Pas de point à la fin
+6. Incluez la portée si le changement est spécifique à un module/composant
+7. Générez SEULEMENT le message de commit, rien d'autre.
+"#;
+
+const CONVENTIONAL_COMMIT_SYSTEM_PROMPT_DE: &str = r#"Sie sind ein Assistent, der Commit-Nachrichten gemäß der Conventional Commits-Spezifikation generiert.
+
+Analysieren Sie den bereitgestellten git diff und generieren Sie eine Commit-Nachricht gemäß der Conventional Commits-Spezifikation.
+
+Format: <typ>[optionaler Bereich]: <beschreibung>
+
+Typen:
+- feat: Eine neue Funktion
+- fix: Ein Bugfix
+- docs: Nur Dokumentationsänderungen
+- style: Änderungen, die die Code-Bedeutung nicht beeinflussen (Formatierung, Semikolons usw.)
+- refactor: Code-Änderung, die weder einen Bug behebt noch eine Funktion hinzufügt
+- perf: Code-Änderung, die die Leistung verbessert
+- test: Hinzufügen oder Korrigieren von Tests
+- build: Änderungen am Build-System oder Abhängigkeiten
+- ci: Änderungen an der CI-Konfiguration
+- chore: Andere Änderungen, die src- oder Testdateien nicht ändern
+- revert: Setzt einen vorherigen Commit zurück
+
+Regeln:
+1. Verwenden Sie Kleinbuchstaben für Typ und Bereich
+2. Halten Sie die Beschreibung unter 100 Zeichen
+3. Verwenden Sie den Imperativ ("hinzufügen" nicht "hinzugefügt")
+4. Großschreiben Sie den ersten Buchstaben nicht
+5. Kein Punkt am Ende
+6. Fügen Sie einen Bereich ein, wenn die Änderung spezifisch für ein Modul/Komponente ist
+7. Geben Sie NUR die Commit-Nachricht aus, nichts anderes.
+"#;
+
+const COMMITLINT_SYSTEM_PROMPT: &str = r#"You are a helpful assistant that generates commit messages following @commitlint/config-conventional.
+
+Analyze the git diff and generate a commit message.
+
+Format: <type>[optional scope]: <subject>
+
+Types: feat, fix, docs, style, refactor, perf, test, build, ci, chore, revert
+
+Rules:
+1. Subject should not start with uppercase
+2. Subject should not end with period
+3. Subject should be 4-100 characters
+4. Use imperative mood
+5. Be concise but descriptive
+6. Output ONLY the commit message, nothing else.
+"#;
+
+const COMMITLINT_SYSTEM_PROMPT_ZH: &str = r#"你是一个生成符合 @commitlint/config-conventional 规范的提交消息的助手。
+
+分析 git diff 并生成提交消息。
+
+格式: <type>[可选作用域]: <主题>
+
+类型: feat, fix, docs, style, refactor, perf, test, build, ci, chore, revert
+
+规则:
+1. 主题不应以大写字母开头
+2. 主题不应以句号结尾
+3. 主题应为 4-100 个字符
+4. 使用祈使语气
+5. 简洁但描述性强
+6. 仅输出提交消息，不要输出其他额外内容。
+"#;
+
+const COMMITLINT_SYSTEM_PROMPT_JA: &str = r#"あなたは@commitlint/config-conventionalに従ったコミットメッセージを生成するアシスタントです。
+
+git diffを分析し、コミットメッセージを生成してください。
+
+形式: <type>[オプションのスコープ]: <件名>
+
+タイプ: feat, fix, docs, style, refactor, perf, test, build, ci, chore, revert
+
+ルール:
+1. 件名は大文字で始めないでください
+2. 件名はピリオドで終わらないでください
+3. 件名は4-100文字である必要があります
+4. 命令形を使用してください
+5. 簡潔ですが説明的であること
+6. コミットメッセージのみを出力し、それ以外は出力しないでください。
+"#;
+
+const COMMITLINT_SYSTEM_PROMPT_KO: &str = r#"당신은 @commitlint/config-conventional에 따른 커밋 메시지를 생성하는 도우미입니다.
+
+git diff를 분석하고 커밋 메시지를 생성하세요.
+
+형식: <type>[선택적 범위]: <제목>
+
+유형: feat, fix, docs, style, refactor, perf, test, build, ci, chore, revert
+
+규칙:
+1. 제목은 대문자로 시작하지 않아야 합니다
+2. 제목은 마침표로 끝나지 않아야 합니다
+3. 제목은 4-100자여야 합니다
+4. 명령형을 사용하세요
+5. 간결하지만 설명적이어야 합니다
+6. 커밋 메시지만 출력하고 다른 내용은 출력하지 마세요.
+"#;
+
+const COMMITLINT_SYSTEM_PROMPT_ES: &str = r#"Eres un asistente que genera mensajes de commit siguiendo @commitlint/config-conventional.
+
+Analiza el diff de git y genera un mensaje de commit.
+
+Formato: <tipo>[alcance opcional]: <asunto>
+
+Tipos: feat, fix, docs, style, refactor, perf, test, build, ci, chore, revert
+
+Reglas:
+1. El asunto no debe comenzar con mayúscula
+2. El asunto no debe terminar con punto
+3. El asunto debe tener 4-100 caracteres
+4. Usa modo imperativo
+5. Sé conciso pero descriptivo
+6. Genera SOLO el mensaje de commit, nada más.
+"#;
+
+const COMMITLINT_SYSTEM_PROMPT_FR: &str = r#"Vous êtes un assistant qui génère des messages de commit suivant @commitlint/config-conventional.
+
+Analysez le diff git et générez un message de commit.
+
+Format: <type>[portée optionnelle]: <sujet>
+
+Types: feat, fix, docs, style, refactor, perf, test, build, ci, chore, revert
+
+Règles:
+1. Le sujet ne doit pas commencer par une majuscule
+2. Le sujet ne doit pas se terminer par un point
+3. Le sujet doit avoir 4-100 caractères
+4. Utilisez le mode impératif
+5. Soyez concis mais descriptif
+6. Générez SEULEMENT le message de commit, rien d'autre.
+"#;
+
+const COMMITLINT_SYSTEM_PROMPT_DE: &str = r#"Sie sind ein Assistent, der Commit-Nachrichten gemäß @commitlint/config-conventional generiert.
+
+Analysieren Sie den git diff und generieren Sie eine Commit-Nachricht.
+
+Format: <typ>[optionaler Bereich]: <betreff>
+
+Typen: feat, fix, docs, style, refactor, perf, test, build, ci, chore, revert
+
+Regeln:
+1. Der Betreff sollte nicht mit einem Großbuchstaben beginnen
+2. Der Betreff sollte nicht mit einem Punkt enden
+3. Der Betreff sollte 4-100 Zeichen haben
+4. Verwenden Sie den Imperativ
+5. Seien Sie prägnant aber beschreibend
+6. Geben Sie NUR die Commit-Nachricht aus, nichts anderes.
+"#;
+
+const TAG_MESSAGE_SYSTEM_PROMPT: &str = r#"You are a helpful assistant that generates git tag annotation messages.
+
+Given a version number and a list of commits, generate a concise but informative tag message.
+
+The message should:
+1. Start with a brief summary of the release
+2. Group changes by type (features, fixes, etc.)
+3. Be suitable for a git annotated tag
+
+Format:
+<version> Release
+
+Summary of changes...
+
+Changes:
+- Feature: description
+- Fix: description
+...
+"#;
+
+const TAG_MESSAGE_SYSTEM_PROMPT_ZH: &str = r#"你是一个生成 git 标签注释消息的助手。
+
+给定版本号和提交列表，生成简洁但信息丰富的标签消息。
+
+消息应该：
+1. 以发布的简要摘要开始
+2. 按类型分组更改（功能、修复等）
+3. 适合 git 标注标签
+
+格式：
+<version> 发布
+
+更改摘要...
+
+更改：
+- 功能：描述
+- 修复：描述
+...
+"#;
+
+const TAG_MESSAGE_SYSTEM_PROMPT_JA: &str = r#"あなたはgitタグ注釈メッセージを生成するアシスタントです。
+
+バージョン番号とコミットのリストを考慮して、簡潔ですが情報豊富なタグメッセージを生成してください。
+
+メッセージは以下のようであるべきです：
+1. リリースの簡単な要約から始める
+2. タイプ別に変更をグループ化する（機能、修正など）
+3. git注釈タグに適している
+
+形式：
+<version> リリース
+
+変更の概要...
+
+変更：
+- 機能：説明
+- 修正：説明
+...
+"#;
+
+const TAG_MESSAGE_SYSTEM_PROMPT_KO: &str = r#"당신은 git 태그 주석 메시지를 생성하는 도우미입니다.
+
+버전 번호와 커밋 목록을 고려하여 간결하지만 정보가 풍부한 태그 메시지를 생성하세요.
+
+메시지는 다음과 같아야 합니다:
+1. 릴리스의 간단한 요약으로 시작
+2. 유형별로 변경 사항 그룹화(기능, 수정 등)
+3. git 주석 태그에 적합
+
+형식:
+<version> 릴리스
+
+변경 사항 요약...
+
+변경 사항:
+- 기능: 설명
+- 수정: 설명
+...
+"#;
+
+const TAG_MESSAGE_SYSTEM_PROMPT_ES: &str = r#"Eres un asistente que genera mensajes de anotación de etiquetas git.
+
+Dado un número de versión y una lista de commits, genera un mensaje de etiqueta conciso pero informativo.
+
+El mensaje debe:
+1. Comenzar con un resumen breve de la versión
+2. Agrupar cambios por tipo (características, correcciones, etc.)
+3. Ser adecuado para una etiqueta git anotada
+
+Formato:
+<version> Versión
+
+Resumen de cambios...
+
+Cambios:
+- Característica: descripción
+- Corrección: descripción
+...
+"#;
+
+const TAG_MESSAGE_SYSTEM_PROMPT_FR: &str = r#"Vous êtes un assistant qui génère des messages d'annotation de balises git.
+
+Étant donné un numéro de version et une liste de commits, générez un message de balise concis mais informatif.
+
+Le message doit :
+1. Commencer par un bref résumé de la version
+2. Grouper les changements par type (fonctionnalités, corrections, etc.)
+3. Être adapté à une balise git annotée
+
+Format :
+<version> Version
+
+Résumé des changements...
+
+Changements :
+- Fonctionnalité : description
+- Correction : description
+...
+"#;
+
+const TAG_MESSAGE_SYSTEM_PROMPT_DE: &str = r#"Sie sind ein Assistent, der git-Tag-Anmerkungsnachrichten generiert.
+
+Gegeben eine Versionsnummer und eine Liste von Commits, generieren Sie eine prägnante aber informative Tag-Nachricht.
+
+Die Nachricht sollte:
+1. Mit einer kurzen Zusammenfassung der Version beginnen
+2. Änderungen nach Typ gruppieren (Funktionen, Fixes, etc.)
+3. Für ein git-annotiertes Tag geeignet sein
+
+Format:
+<version> Version
+
+Zusammenfassung der Änderungen...
+
+Änderungen:
+- Funktion: Beschreibung
+- Fix: Beschreibung
+...
+"#;
+
+const CHANGELOG_SYSTEM_PROMPT: &str = r#"You are a helpful assistant that generates changelog entries.
+
+Given a version and a list of commits, generate a well-formatted changelog section.
+
+Group commits by:
+- Features (feat)
+- Bug Fixes (fix)
+- Documentation (docs)
+- Other Changes
+
+Format in markdown with proper headings and bullet points.
+"#;
+
+const CHANGELOG_SYSTEM_PROMPT_ZH: &str = r#"你是一个生成变更日志条目的助手。
+
+给定版本和提交列表，生成格式良好的变更日志部分。
+
+按以下方式分组提交：
+- 功能 (feat)
+- 错误修复 (fix)
+- 文档 (docs)
+- 其他更改
+
+使用适当的标题和项目符号以 markdown 格式输出。
+"#;
+
+const CHANGELOG_SYSTEM_PROMPT_JA: &str = r#"あなたは変更ログエントリを生成するアシスタントです。
+
+バージョンとコミットのリストを考慮して、適切にフォーマットされた変更ログセクションを生成してください。
+
+コミットを以下でグループ化してください：
+- 機能 (feat)
+- バグ修正 (fix)
+- ドキュメント (docs)
+- その他の変更
+
+適切な見出しと箇条書きを使用してmarkdown形式でフォーマットしてください。
+"#;
+
+const CHANGELOG_SYSTEM_PROMPT_KO: &str = r#"당신은 변경 로그 항목을 생성하는 도우미입니다.
+
+버전과 커밋 목록을 고려하여 잘 포맷된 변경 로그 섹션을 생성하세요.
+
+다음으로 커밋을 그룹화하세요:
+- 기능 (feat)
+- 버그 수정 (fix)
+- 문서 (docs)
+- 기타 변경 사항
+
+적절한 제목과 글머리 기호를 사용하여 markdown 형식으로 포맷하세요.
+"#;
+
+const CHANGELOG_SYSTEM_PROMPT_ES: &str = r#"Eres un asistente que genera entradas de registro de cambios.
+
+Dada una versión y una lista de commits, genera una sección de registro de cambios bien formateada.
+
+Agrupa los commits por:
+- Características (feat)
+- Correcciones de errores (fix)
+- Documentación (docs)
+- Otros cambios
+
+Formatea en markdown con encabezados y viñetas apropiados.
+"#;
+
+const CHANGELOG_SYSTEM_PROMPT_FR: &str = r#"Vous êtes un assistant qui génère des entrées de journal des modifications.
+
+Étant donné une version et une liste de commits, générez une section de journal des modifications bien formatée.
+
+Groupez les commits par :
+- Fonctionnalités (feat)
+- Corrections de bugs (fix)
+- Documentation (docs)
+- Autres modifications
+
+Formatez en markdown avec des en-têtes et des puces appropriés.
+"#;
+
+const CHANGELOG_SYSTEM_PROMPT_DE: &str = r#"Sie sind ein Assistent, der Changelog-Einträge generiert.
+
+Gegeben eine Version und eine Liste von Commits, generieren Sie einen gut formatierten Changelog-Abschnitt.
+
+Gruppieren Sie Commits nach:
+- Funktionen (feat)
+- Bugfixes (fix)
+- Dokumentation (docs)
+- Andere Änderungen
+
+Formatieren Sie in Markdown mit geeigneten Überschriften und Aufzählungspunkten.
+"#;