feat(core): 基本只剩顶层Agent未开发，底层开发差不多了

src/core/client/mod.rs

@@ -1,5 +1,10 @@
 mod config;
 pub mod base_client;
+pub mod ai_client;
+
+pub use config::ClientConfig;
+pub use base_client::BaseClient;
+pub use ai_client::AiClient;
 
 use anyhow::{anyhow, Result};
 use bytes::Bytes;
@@ -244,10 +249,10 @@ impl RetryMiddleware {
             let (ctx, request) = factory().await?;
 
             info!(
-                method = %ctx.method,
-                url = %ctx.url,
-                attempt,
-                "sending request"
+                "sending request: method={}, url={}, attempt={}",
+                ctx.method,
+                ctx.url,
+                attempt
             );
 
             let result =
@@ -294,11 +299,11 @@ impl RetryMiddleware {
             };
 
             warn!(
-                method = %ctx.method,
-                url = %ctx.url,
+                "retrying request: method={}, url={}, attempt={}, wait_ms={}",
+                ctx.method,
+                ctx.url,
                 attempt,
-                wait_ms = wait.as_millis(),
-                "retrying request"
+                wait.as_millis()
             );
 
             tokio::time::sleep(wait).await;

src/core/providers/claude_messages/mod.rs

@@ -1,4 +1,7 @@
 mod request;
 mod response;
-mod adapter;
-mod provider;
+mod provider;
+
+pub use provider::ClaudeProvider;
+pub use request::ClaudeRequest;
+pub use response::ClaudeResponse;

src/core/providers/claude_messages/provider.rs

@@ -1,57 +1,52 @@
+use anyhow::Result;
 use async_trait::async_trait;
-use reqwest::Client;
+use std::collections::HashMap;
+use crate::core::client::{AiClient, ClientConfig};
+use crate::core::transport::retry::RetryPolicy;
 use crate::core::providers::claude_messages::request::ClaudeRequest;
 use crate::core::providers::claude_messages::response::ClaudeResponse;
 use crate::core::providers::provider::Provider;
 use crate::core::providers::types::{CompletionRequest, CompletionResponse};
 
 pub struct ClaudeProvider {
-    client: Client,
-
+    client: AiClient,
     api_key: String,
 }
 
 impl ClaudeProvider {
-    pub fn new(
-        api_key: String,
-    ) -> Self {
-        Self {
-            client: Client::new(),
+    pub fn new(api_key: String) -> Result<Self> {
+        let config = ClientConfig::default();
+        let retry = RetryPolicy::default();
+        let client = AiClient::new(config, retry)?;
+
+        Ok(Self {
+            client,
             api_key,
-        }
+        })
     }
 }
 
 #[async_trait]
 impl Provider for ClaudeProvider {
-    async fn complete(
-        &self,
-        request: CompletionRequest,
-    ) -> Result<CompletionResponse> {
-
-        let body =
-            ClaudeRequest::from(request);
-
-        let resp = self
-            .client
-            .post(
-                "https://api.anthropic.com/v1/messages"
-            )
-            .header(
-                "x-api-key",
-                &self.api_key,
-            )
-            .header(
-                "anthropic-version",
-                "2023-06-01",
-            )
-            .json(&body)
-            .send()
-            .await?;
-
-        let response: ClaudeResponse =
-            resp.json().await?;
-
-        Ok(response.into())
+    fn client(&self) -> &AiClient {
+        &self.client
+    }
+
+    async fn complete(&self, request: CompletionRequest) -> Result<CompletionResponse> {
+        let claude_request = ClaudeRequest::from_completion_request(request);
+
+        let mut headers = HashMap::new();
+        headers.insert("x-api-key".to_string(), self.api_key.clone());
+        headers.insert("anthropic-version".to_string(), "2023-06-01".to_string());
+        headers.insert("Content-Type".to_string(), "application/json".to_string());
+
+        let url = "https://api.anthropic.com/v1/messages";
+
+        let response: ClaudeResponse = self.client
+            .post_json(url, headers, &claude_request)
+            .await
+            .map_err(|e| anyhow::anyhow!("Claude API error: {}", e))?;
+
+        Ok(CompletionResponse::from(response))
     }
 }

src/core/providers/claude_messages/request.rs

@@ -1,22 +1,57 @@
 use serde::Serialize;
+use crate::core::providers::types::{CompletionRequest, Message, Role};
 
 #[derive(Serialize)]
 pub struct ClaudeRequest {
     pub model: String,
-
     pub max_tokens: u32,
-
     pub messages: Vec<ClaudeMessage>,
-
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub system: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub temperature: Option<f32>,
-
     pub stream: bool,
 }
 
 #[derive(Serialize)]
 pub struct ClaudeMessage {
     pub role: String,
-
     pub content: String,
+}
+
+impl ClaudeRequest {
+    pub fn from_completion_request(request: CompletionRequest) -> Self {
+        let mut system_prompt = None;
+        let mut messages = Vec::new();
+
+        for msg in request.messages {
+            if msg.role == Role::System {
+                system_prompt = Some(msg.content);
+            } else {
+                messages.push(ClaudeMessage::from(msg));
+            }
+        }
+
+        Self {
+            model: request.model,
+            max_tokens: request.max_tokens.unwrap_or(4096),
+            messages,
+            system: system_prompt,
+            temperature: request.temperature,
+            stream: request.stream,
+        }
+    }
+}
+
+impl From<Message> for ClaudeMessage {
+    fn from(value: Message) -> Self {
+        Self {
+            role: match value.role {
+                Role::User => "user".to_string(),
+                Role::Assistant => "assistant".to_string(),
+                Role::System => "user".to_string(),
+            },
+            content: value.content,
+        }
+    }
 }

src/core/providers/claude_messages/response.rs

@@ -1,11 +1,10 @@
 use serde::Deserialize;
+use crate::core::providers::types::{CompletionResponse, FinishReason, Usage};
 
 #[derive(Deserialize)]
 pub struct ClaudeResponse {
     pub content: Vec<ClaudeContent>,
-
     pub stop_reason: Option<String>,
-
     pub usage: Option<ClaudeUsage>,
 }
 
@@ -17,6 +16,33 @@ pub struct ClaudeContent {
 #[derive(Deserialize)]
 pub struct ClaudeUsage {
     pub input_tokens: Option<u32>,
-
     pub output_tokens: Option<u32>,
+}
+
+impl From<ClaudeResponse> for CompletionResponse {
+    fn from(value: ClaudeResponse) -> Self {
+        let content = value
+            .content
+            .first()
+            .map(|c| c.text.clone())
+            .unwrap_or_default();
+
+        let finish_reason = value.stop_reason.and_then(|r| match r.as_str() {
+            "end_turn" => Some(FinishReason::Stop),
+            "max_tokens" => Some(FinishReason::Length),
+            _ => Some(FinishReason::Error),
+        });
+
+        let usage = value.usage.map(|u| Usage {
+            prompt_tokens: u.input_tokens,
+            completion_tokens: u.output_tokens,
+            total_tokens: None,
+        });
+
+        CompletionResponse {
+            content,
+            finish_reason,
+            usage,
+        }
+    }
 }

src/core/providers/config.rs

@@ -2,18 +2,17 @@
 
 #[derive(Debug, Clone)]
 pub enum ProviderKind {
-    OpenAiCompatible,
+    Compatible,
     Claude,
     Gemini,
+    Deepseek,
+    Ollama,
 }
 
 #[derive(Debug, Clone)]
 pub struct ProviderConfig {
     pub kind: ProviderKind,
-
     pub api_key: String,
-
     pub base_url: String,
-
     pub model: String,
 }