Merge pull request #42 from hunjixin/refrator/add_do_request_in_builder

feat: add do_request in requstbuilder

Author: hunjixin

README.md

@@ -41,7 +41,8 @@ The DeepSeek API SDK supports both asynchronous and synchronous usage patterns i
 ```rust
 use anyhow::Result;
 use clap::Parser;
-use deepseek_api::{Client, request::MessageRequest, response::ModelType};
+use deepseek_api::response::ModelType;
+use deepseek_api::{ClientBuilder, CompletionsRequestBuilder, RequestBuilder};
 use std::io::{stdin, stdout, Write};
 use std::vec;
 
@@ -55,7 +56,7 @@ struct Args {
 #[tokio::main]
 async fn main() -> Result<()> {
     let args = Args::parse();
-    let client = Client::new(&args.api_key);
+    let client = ClientBuilder::new(args.api_key.clone()).build()?;
     loop {
         let mut buffer = String::new();
 
@@ -82,13 +83,17 @@ async fn main() -> Result<()> {
                 println!("models {:?}", models);
             }
             word => {
-                let mut completions = client.chat();
-                let builder = completions.chat_builder(vec![]).append_user_message(word);
-                let resp = completions.create(builder).await?.must_response();
+                let completions = client.chat();
+                let resp = CompletionsRequestBuilder::new(vec![])
+                    .use_model(ModelType::DeepSeekChat)
+                    .append_user_message(word)
+                    .do_request(&completions)
+                    .await?
+                    .must_response();
 
                 let mut resp_words = vec![];
                 for msg in resp.choices.iter() {
-                    history.push(MessageRequest::Assistant(msg.message.as_ref().expect("message exit").clone()));
+                    history.push(msg.message.as_ref().expect("message exit").clone());
                     resp_words.push(msg.message.as_ref().expect("message").content.clone());
                 }
 
@@ -100,7 +105,6 @@ async fn main() -> Result<()> {
     }
     Ok(())
 }
-
 ```
 
 ### Synchronous Example  (Requires Feature Flag)
@@ -112,8 +116,8 @@ deepseek-api = { version = "xx", default-features = false, features = ["is_sync"
 ```rs
 use anyhow::Result;
 use clap::Parser;
-use deepseek_api::Client;
 use deepseek_api::{request::MessageRequest, response::ModelType};
+use deepseek_api::{ClientBuilder, CompletionsRequestBuilder, RequestBuilder};
 use std::vec;
 
 #[derive(Parser, Debug)]
@@ -125,29 +129,32 @@ struct Args {
 
 fn main() -> Result<()> {
     let args = Args::parse();
-    let client = Client::new(&args.api_key);
+
+    let client = ClientBuilder::new(args.api_key.clone())
+        .timeout(300)
+        .build()?;
     let mut history = vec![];
 
-    let mut completions = client.chat();
-    let builder = completions
-        .chat_builder(vec![])
-        .use_model(ModelType::DeepSeekChat)
-        .append_user_message("hello");
-    let resp = completions.create(builder)?.must_response();
+    let completions = client.chat();
+    let resp = CompletionsRequestBuilder::new(vec![])
+        .use_model(ModelType::DeepSeekReasoner)
+        .append_user_message("hello world")
+        .do_request(&completions)?
+        .must_response();
 
     let mut resp_words = vec![];
     for msg in resp.choices.iter() {
-        history.push(MessageRequest::Assistant(msg.message.as_ref().expect("message exit").clone()));
+        history.push(MessageRequest::Assistant(
+            msg.message.as_ref().expect("message exit").clone(),
+        ));
         resp_words.push(msg.message.as_ref().expect("message").content.clone());
     }
-
     for msg in resp_words.iter() {
         msg.split("\n").for_each(|x| println!("{}", x));
     }
 
     Ok(())
 }
-
 ```
 
 ### Function Calling
@@ -157,12 +164,14 @@ Use the function calling interface to define and invoke tools via the API.
 ```rust
 use anyhow::Result;
 use clap::Parser;
-use deepseek_api::request::{Function, ToolMessageRequest, ToolObject, ToolType, UserMessageRequest};
-use deepseek_api::response::FinishReason;
-use deepseek_api::Client;
 use deepseek_api::request::MessageRequest;
-use std::vec;
+use deepseek_api::request::{
+    Function, ToolMessageRequest, ToolObject, ToolType, UserMessageRequest,
+};
+use deepseek_api::response::FinishReason;
+use deepseek_api::{ClientBuilder, CompletionsRequestBuilder, RequestBuilder};
 use schemars::schema::SchemaObject;
+use std::vec;
 
 #[derive(Parser, Debug)]
 #[command(version, about, long_about = None)]
@@ -179,8 +188,9 @@ struct Args {
 #[tokio::main]
 async fn main() -> Result<()> {
     let args = Args::parse();
-    let client = Client::new(&args.api_key);
-    let parameters: SchemaObject = serde_json::from_str(r#"{
+    let client = ClientBuilder::new(args.api_key.clone()).build()?;
+    let parameters: SchemaObject = serde_json::from_str(
+        r#"{
         "type": "object",
         "properties": {
             "location": {
@@ -194,29 +204,32 @@ async fn main() -> Result<()> {
             }
         },
         "required": ["location"]
-    }"#)?;
+    }"#,
+    )?;
 
-    let tool_object = ToolObject{
+    let tool_object = ToolObject {
         tool_type: ToolType::Function,
-        function: Function{
+        function: Function {
             name: "get_weather".to_string(),
-            description: "Get weather of an location, the user shoud supply a location first".to_string(),
-            parameters
+            description: "Get weather of an location, the user shoud supply a location first"
+                .to_string(),
+            parameters,
         },
     };
-   
-    let mut messages = vec![
-        MessageRequest::User(UserMessageRequest::new(
-            "How's the weather in Hangzhou?"
-        ))
-    ];
-    let mut completetion = client.chat();
-    let req = client.chat().chat_builder(messages.clone()).tools(vec![tool_object.clone()]);
-    let resp = completetion.create(req).await?.must_response();
+
+    let mut messages = vec![MessageRequest::User(UserMessageRequest::new(
+        "How's the weather in Hangzhou?",
+    ))];
+    let completetion = client.chat();
+    let resp = CompletionsRequestBuilder::new(messages.clone())
+        .tools(vec![tool_object.clone()])
+        .do_request(&completetion)
+        .await?
+        .must_response();
     let mut id = String::new();
     if resp.choices[0].finish_reason == FinishReason::ToolCalls {
         if let Some(msg) = &resp.choices[0].message {
-           if let Some(tool) = &msg.tool_calls {
+            if let Some(tool) = &msg.tool_calls {
                 id = tool[0].id.clone();
                 println!("Function id: {}", id);
                 println!("Function name: {}", tool[0].function.name);
@@ -226,10 +239,16 @@ async fn main() -> Result<()> {
         }
     }
 
-    messages.push( MessageRequest::Tool(ToolMessageRequest::new("24℃", &id )));
-    let req = client.chat().chat_builder(messages.clone()).tools(vec![tool_object.clone()]);
-    let resp = completetion.create(req).await?.must_response();
-    println!("Reply with my function: {:?}", resp.choices[0].message.as_ref().unwrap().content);
+    messages.push(MessageRequest::Tool(ToolMessageRequest::new("24℃", &id)));
+    let resp = CompletionsRequestBuilder::new(messages.clone())
+        .tools(vec![tool_object.clone()])
+        .do_request(&completetion)
+        .await?
+        .must_response();
+    println!(
+        "Reply with my function: {:?}",
+        resp.choices[0].message.as_ref().unwrap().content
+    );
     Ok(())
 }
 ```

deepseek-api/src/async_impl/completions.rs

@@ -1,10 +1,5 @@
 use super::json_stream::JsonStream;
-use crate::{
-    request::{
-        CompletionsRequestBuilder, FMICompletionsRequestBuilder, MessageRequest, RequestBuilder,
-    },
-    response::ChatResponse,
-};
+use crate::{response::ChatResponse, RequestBuilder};
 use anyhow::Result;
 use reqwest::Client as ReqwestClient;
 
@@ -15,20 +10,12 @@ pub struct ChatCompletions {
 }
 
 impl ChatCompletions {
-    pub fn chat_builder(&self, messages: Vec<MessageRequest>) -> CompletionsRequestBuilder {
-        CompletionsRequestBuilder::new(messages)
-    }
-
-    pub fn fim_builder(&self, prompt: &str, suffix: &str) -> FMICompletionsRequestBuilder {
-        FMICompletionsRequestBuilder::new(prompt, suffix)
-    }
-
     pub async fn create<Builder>(
-        &mut self,
+        &self,
         request_builder: Builder,
     ) -> Result<ChatResponse<Builder::Response, Builder::Item>>
     where
-        Builder: RequestBuilder + Send,
+        Builder: RequestBuilder + Send + Sized,
     {
         let host = if request_builder.is_beta() {
             self.host.to_owned() + "/beta/completions"

deepseek-api/src/builder.rs deepseek-api/src/client_builder.rsdeepseek-api/src/builder.rs renamed to deepseek-api/src/client_builder.rs

@@ -1,22 +1,22 @@
+mod client_builder;
 mod error;
 pub mod request;
+mod request_builder;
 pub mod response;
-
+pub use client_builder::*;
 pub use error::*;
+pub use request_builder::*;
+
 cfg_if::cfg_if! {
     if #[cfg(feature = "is_sync")] {
         mod sync_impl;
-        mod builder;
 
-        pub use builder::*;
         pub use sync_impl::json_stream;
         pub use sync_impl::client::*;
         pub use sync_impl::completions;
     } else {
         mod async_impl;
-        mod builder;
 
-        pub use builder::*;
         pub use async_impl::json_stream;
         pub use async_impl::client::*;
         pub use async_impl::completions;