初步完成channel->queueu->[tool]->[queue]->[assistant]->channel的流程

【待处理】上下文管理和错误处理。

service/src/core/queue.rs

@@ -1,62 +1,84 @@
-use crate::{
-    AppState,
-    core::context::{add_assistant_message, add_tool_message, add_user_message, snapshot_context},
+use crate::core::context::{
+    add_assistant_message, add_tool_message, add_user_message, snapshot_context,
 };
 use ai::core::send_message;
-use axum::Json;
-use axum::extract::State;
-use common::queue::{ChannelMessage, QueueMessage};
+use common::queue::QueueMessage;
 use serde_json::error;
-use std::sync::Arc;
-use tokio::sync::{mpsc, mpsc::Sender};
+use tokio::sync::{mpsc::Receiver, mpsc::Sender};
+use wechat::manager::WeChatMultiAccountManager;
 
-pub async fn create_queue() -> Result<Sender<QueueMessage>, error::Error> {
-    let (sender, mut receiver) = mpsc::channel::<QueueMessage>(100);
-    let result_sender = sender.clone();
+pub async fn create_queue(
+    sender: Sender<QueueMessage>,
+    mut receiver: Receiver<QueueMessage>,
+    manager: WeChatMultiAccountManager,
+) -> Result<(), error::Error> {
     tokio::spawn(async move {
         while let Some(msg) = receiver.recv().await {
             let queue_sender = sender.clone();
             match msg {
-                QueueMessage::Aissitant(reasoning, content) => {
+                QueueMessage::Aissitant(channel, assistant) => {
+                    let content = assistant.content.clone();
+                    let reasoning = assistant.reasoning.clone().unwrap_or_default();
                     println!("\n\n收到llm回复：\n{}\n-------\n{}", reasoning, content);
-                    add_assistant_message(content).await;
+                    if !content.trim().is_empty() || !reasoning.trim().is_empty() {
+                        let text = if !content.trim().is_empty() {
+                            content.trim()
+                        } else {
+                            reasoning.trim()
+                        };
+                        manager
+                            .send_text(
+                                &channel.account_id,
+                                &channel.from_user_id,
+                                &text,
+                                channel.context.as_deref(),
+                            )
+                            .await
+                            .unwrap();
+                    }
+                    add_assistant_message(assistant.content, assistant.tool_calls).await;
                 }
-                QueueMessage::Channel(name, text) => {
-                    println!("\n\n收到来自{}消息：\n{}", name, text);
-                    add_user_message(text).await;
-                    send_message(queue_sender, snapshot_context().await)
+                QueueMessage::Channel(bundle) => {
+                    println!(
+                        "\n\n收到来自{}消息：\n{}",
+                        bundle.from_user_id.clone(),
+                        bundle.content.clone()
+                    );
+                    // todo 目前按单用户处理
+                    add_user_message(bundle.content.clone()).await;
+                    send_message(queue_sender, snapshot_context().await, bundle)
                         .await
                         .unwrap();
                 }
-                QueueMessage::Tool(tool_call_id, name, result) => {
+                QueueMessage::Tool(channel, tool_call_id, name, result) => {
                     println!("\n\n调用{}工具的结果:\n{}", name, result);
                     add_tool_message(tool_call_id, result).await;
-                    send_message(queue_sender, snapshot_context().await)
+                    send_message(queue_sender, snapshot_context().await, channel)
                         .await
                         .unwrap();
                 }
             }
         }
     });
-    Ok(result_sender)
+    Ok(())
 }
 
-pub async fn send_to_queue(
-    State(state): State<Arc<AppState>>,
-    Json(body): Json<ChannelMessage>,
-) -> Json<serde_json::Value> {
-    match state
-        .sender
-        .send(QueueMessage::Channel(body.channel, body.content))
-        .await
-    {
-        Ok(_) => Json(serde_json::json!({
-            "success":true,
-            "message":"queued"
-        })),
-        Err(_) => Json(serde_json::json!({
-            "success":true,
-            "message":"queue closed"
-        })),
-    }
-}
+// pub async fn send_to_queue(
+//     State(state): State<Arc<AppState>>,
+//     Json(body): Json<ChannelMessageBundle>,
+// ) -> Json<serde_json::Value> {
+// match state
+//     .sender
+//     .send(QueueMessage::Channel(body.channel, body.content))
+//     .await
+// {
+//     Ok(_) => Json(serde_json::json!({
+//         "success":true,
+//         "message":"queued"
+//     })),
+//     Err(_) => Json(serde_json::json!({
+//         "success":true,
+//         "message":"queue closed"
+//     })),
+// }
+// }