1 files changed, 20 insertions, 20 deletions

diff --git a/src/client/qianwen.rs b/src/client/qianwen.rs
index 3f4b73a..0230e21 100644
--- a/src/client/qianwen.rs
+++ b/src/client/qianwen.rs
@@ -1,5 +1,5 @@
 use super::{
-    maybe_catch_error, message::*, sse_stream, Client, CompletionData, CompletionOutput,
+    maybe_catch_error, message::*, sse_stream, ChatCompletionsData, ChatCompletionsOutput, Client,
     ExtraConfig, Model, ModelData, ModelPatches, PromptAction, PromptKind, QianwenClient,
     SseHandler, SseMmessage,
 };
@@ -38,10 +38,10 @@ impl QianwenClient {
     pub const PROMPTS: [PromptAction<'static>; 1] =
         [("api_key", "API Key:", true, PromptKind::String)];
 
-    fn request_builder(
+    fn chat_completions_builder(
         &self,
         client: &ReqwestClient,
-        data: CompletionData,
+        data: ChatCompletionsData,
     ) -> Result<RequestBuilder> {
         let api_key = self.get_api_key()?;
 
@@ -51,7 +51,7 @@ impl QianwenClient {
             true => API_URL_VL,
             false => API_URL,
         };
-        let (mut body, has_upload) = build_body(data, &self.model)?;
+        let (mut body, has_upload) = build_chat_completions_body(data, &self.model)?;
         self.patch_request_body(&mut body);
 
         debug!("Qianwen Request: {url} {body}");
@@ -72,39 +72,39 @@ impl QianwenClient {
 impl Client for QianwenClient {
     client_common_fns!();
 
-    async fn send_message_inner(
+    async fn chat_completions_inner(
         &self,
         client: &ReqwestClient,
-        mut data: CompletionData,
-    ) -> Result<CompletionOutput> {
+        mut data: ChatCompletionsData,
+    ) -> Result<ChatCompletionsOutput> {
         let api_key = self.get_api_key()?;
         patch_messages(self.model.name(), &api_key, &mut data.messages).await?;
-        let builder = self.request_builder(client, data)?;
-        send_message(builder, &self.model).await
+        let builder = self.chat_completions_builder(client, data)?;
+        chat_completions(builder, &self.model).await
     }
 
-    async fn send_message_streaming_inner(
+    async fn chat_completions_streaming_inner(
         &self,
         client: &ReqwestClient,
         handler: &mut SseHandler,
-        mut data: CompletionData,
+        mut data: ChatCompletionsData,
     ) -> Result<()> {
         let api_key = self.get_api_key()?;
         patch_messages(self.model.name(), &api_key, &mut data.messages).await?;
-        let builder = self.request_builder(client, data)?;
-        send_message_streaming(builder, handler, &self.model).await
+        let builder = self.chat_completions_builder(client, data)?;
+        chat_completions_streaming(builder, handler, &self.model).await
     }
 }
 
-async fn send_message(builder: RequestBuilder, model: &Model) -> Result<CompletionOutput> {
+async fn chat_completions(builder: RequestBuilder, model: &Model) -> Result<ChatCompletionsOutput> {
     let data: Value = builder.send().await?.json().await?;
     maybe_catch_error(&data)?;
 
     debug!("non-stream-data: {data}");
-    extract_completion_text(&data, model)
+    extract_chat_completions_text(&data, model)
 }
 
-async fn send_message_streaming(
+async fn chat_completions_streaming(
     builder: RequestBuilder,
     handler: &mut SseHandler,
     model: &Model,
@@ -133,8 +133,8 @@ async fn send_message_streaming(
     sse_stream(builder, handle).await
 }
 
-fn build_body(data: CompletionData, model: &Model) -> Result<(Value, bool)> {
-    let CompletionData {
+fn build_chat_completions_body(data: ChatCompletionsData, model: &Model) -> Result<(Value, bool)> {
+    let ChatCompletionsData {
         messages,
         temperature,
         top_p,
@@ -210,7 +210,7 @@ fn build_body(data: CompletionData, model: &Model) -> Result<(Value, bool)> {
     Ok((body, has_upload))
 }
 
-fn extract_completion_text(data: &Value, model: &Model) -> Result<CompletionOutput> {
+fn extract_chat_completions_text(data: &Value, model: &Model) -> Result<ChatCompletionsOutput> {
     let err = || anyhow!("Invalid response data: {data}");
     let text = if model.name() == "qwen-long" {
         data["output"]["choices"][0]["message"]["content"]
@@ -223,7 +223,7 @@ fn extract_completion_text(data: &Value, model: &Model) -> Result<CompletionOutp
     } else {
         data["output"]["text"].as_str().ok_or_else(err)?
     };
-    let output = CompletionOutput {
+    let output = ChatCompletionsOutput {
         text: text.to_string(),
         tool_calls: vec![],
         id: data["request_id"].as_str().map(|v| v.to_string()),