feat: use refrence to avoid always clone request messages

README.md

@@ -41,6 +41,7 @@ The DeepSeek API SDK supports both asynchronous and synchronous usage patterns i
 ```rust
 use anyhow::Result;
 use clap::Parser;
+use deepseek_api::request::MessageRequest;
 use deepseek_api::response::ModelType;
 use deepseek_api::{CompletionsRequestBuilder, DeepSeekClientBuilder, RequestBuilder};
 use std::io::{stdin, stdout, Write};
@@ -83,9 +84,8 @@ async fn main() -> Result<()> {
                 println!("models {:?}", models);
             }
             word => {
-                let resp = CompletionsRequestBuilder::new(vec![])
+                let resp = CompletionsRequestBuilder::new(&[MessageRequest::user(word)])
                     .use_model(ModelType::DeepSeekChat)
-                    .append_user_message(word)
                     .do_request(&client)
                     .await?
                     .must_response();
@@ -134,9 +134,8 @@ fn main() -> Result<()> {
         .build()?;
 
     let mut history = vec![];
-    let resp = CompletionsRequestBuilder::new(vec![])
+    let resp = CompletionsRequestBuilder::new(&[MessageRequest::user("hello world")])
         .use_model(ModelType::DeepSeekReasoner)
-        .append_user_message("hello world")
         .do_request(&client)?
         .must_response();
 
@@ -163,9 +162,7 @@ Use the function calling interface to define and invoke tools via the API.
 use anyhow::Result;
 use clap::Parser;
 use deepseek_api::request::MessageRequest;
-use deepseek_api::request::{
-    Function, ToolMessageRequest, ToolObject, ToolType, UserMessageRequest,
-};
+use deepseek_api::request::{Function, ToolMessageRequest, ToolObject, ToolType};
 use deepseek_api::response::FinishReason;
 use deepseek_api::{CompletionsRequestBuilder, DeepSeekClientBuilder, RequestBuilder};
 use schemars::schema::SchemaObject;
@@ -215,11 +212,10 @@ async fn main() -> Result<()> {
         },
     };
 
-    let mut messages = vec![MessageRequest::User(UserMessageRequest::new(
-        "How's the weather in Hangzhou?",
-    ))];
-    let resp = CompletionsRequestBuilder::new(messages.clone())
-        .tools(vec![tool_object.clone()])
+    let tool_objects: Vec<ToolObject> = vec![tool_object];
+    let mut messages = vec![MessageRequest::user("How's the weather in Hangzhou?")];
+    let resp = CompletionsRequestBuilder::new(&messages)
+        .tools(&tool_objects)
         .do_request(&client)
         .await?
         .must_response();
@@ -237,8 +233,8 @@ async fn main() -> Result<()> {
     }
 
     messages.push(MessageRequest::Tool(ToolMessageRequest::new("24℃", &id)));
-    let resp = CompletionsRequestBuilder::new(messages.clone())
-        .tools(vec![tool_object.clone()])
+    let resp = CompletionsRequestBuilder::new(&messages)
+        .tools(&tool_objects)
         .do_request(&client)
         .await?
         .must_response();

deepseek-api/src/async_impl/client.rs

@@ -143,15 +143,14 @@ impl DeepSeekClient {
     /// ```no_run
     /// #[tokio::main]
     /// async fn main() {
-    ///     use deepseek_api::{request::{MessageRequest, UserMessageRequest}, DeepSeekClientBuilder, CompletionsRequestBuilder};
+    ///     use deepseek_api::{request::MessageRequest, DeepSeekClientBuilder, CompletionsRequestBuilder};
     ///     use deepseek_api::response::ChatResponse;
     ///     use futures_util::StreamExt;
     ///
     ///     let api_key = "your_api_key".to_string();
     ///     let client = DeepSeekClientBuilder::new(api_key).build().unwrap();
-    ///     let request_builder = CompletionsRequestBuilder::new(vec![MessageRequest::User(
-    ///                 UserMessageRequest::new("Hello, DeepSeek!")
-    ///     )]);
+    ///     let msgs = &[MessageRequest::user("Hello, DeepSeek!")];
+    ///     let request_builder = CompletionsRequestBuilder::new(msgs);
     ///
     ///     let response = client.send_completion_request(request_builder).await.unwrap();
     ///     match response {

deepseek-api/src/request.rs

@@ -147,7 +147,7 @@ impl StreamOptions {
 
 /// Represents the temperature with a value between 0 and 2.
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct Temperature(pub u32);
+pub struct Temperature(pub f32);
 
 impl Temperature {
     /// Creates a new `Temperature` instance.
@@ -159,8 +159,8 @@ impl Temperature {
     /// # Errors
     ///
     /// Returns an error if the value is not between 0 and 2.
-    pub fn new(v: u32) -> Result<Self> {
-        if v > 2 {
+    pub fn new(v: f32) -> Result<Self> {
+        if !(0.0..=2.0).contains(&v) {
             return Err(anyhow!("Temperature must be between 0 and 2.".to_string()));
         }
         Ok(Temperature(v))
@@ -170,7 +170,7 @@ impl Temperature {
 impl Default for Temperature {
     /// Returns the default value for `Temperature`, which is 1.
     fn default() -> Self {
-        Temperature(1)
+        Temperature(1.0)
     }
 }
 
@@ -304,6 +304,30 @@ pub enum MessageRequest {
 }
 
 impl MessageRequest {
+    /// Creates a new `MessageRequest` instance for a user message.
+    ///
+    /// # Arguments
+    ///
+    /// * `content` - The content of the user message.
+    /// * `name` - An optional name for the user message.
+    pub fn user(content: &str) -> Self {
+        MessageRequest::User(UserMessageRequest {
+            content: content.to_string(),
+            name: None,
+        })
+    }
+
+    /// Creates a new `MessageRequest` instance for a system message.
+    ///
+    /// # Arguments
+    ///
+    /// * `content` - The content of the system message.
+    pub fn sys(content: &str) -> Self {
+        MessageRequest::System(SystemMessageRequest {
+            content: content.to_string(),
+            name: None,
+        })
+    }
     pub fn get_content(&self) -> &str {
         match self {
             MessageRequest::System(req) => req.content.as_str(),