src/gateway/session.rs

@@ -210,13 +210,12 @@ impl Session {
 
     pub fn ensure_chat_loaded(&mut self, chat_id: &str) -> Result<(), AgentError> {
         // 检查历史是否存在且对应正确的话题
-        // 先获取 topic 信息并转换为 owned String，避免借用冲突
+        let current_topic = self.history.chat_topic(chat_id);
-        let current_topic: Option<String> = self.history.chat_topic(chat_id).map(|s| s.to_string());
         let stored_topic = self.history.history_topic(chat_id);
 
         if self.chat_history_exists(chat_id) {
             // 如果历史已存在，但话题不匹配，需要重新加载
-            if current_topic.as_deref() != stored_topic {
+            if current_topic != stored_topic {
                 tracing::info!(
                     chat_id = %chat_id,
                     current_topic = ?current_topic,
@@ -228,8 +227,8 @@ impl Session {
             return Ok(());
         }
 
-        // 历史不存在，按 topic 加载（如果设置了 topic）
+        // 历史不存在，正常加载
-        self.history.ensure_chat_loaded(chat_id, current_topic.as_deref())
+        self.history.ensure_chat_loaded(chat_id)
     }
 
     fn chat_history_exists(&self, chat_id: &str) -> bool {

src/gateway/session_history.rs

@@ -65,11 +65,7 @@ impl SessionHistory {
             .map_err(|err| AgentError::Other(format!("session persistence error: {}", err)))
     }
 
-    pub(crate) fn ensure_chat_loaded(
+    pub(crate) fn ensure_chat_loaded(&mut self, chat_id: &str) -> Result<(), AgentError> {
-        &mut self,
-        chat_id: &str,
-        topic_id: Option<&str>,
-    ) -> Result<(), AgentError> {
         // 获取 session 记录（用于检查最后活跃时间）
         let session_record = self.ensure_persistent_session(chat_id)?;
 
@@ -97,16 +93,10 @@ impl SessionHistory {
             return Ok(());
         }
 
-        // 如果提供了 topic_id，按 topic 加载；否则按 session 加载
+        let history = self
-        let history = if let Some(tid) = topic_id {
+            .conversations
-            self.conversations
-                .load_messages_for_topic(tid)
-                .map_err(|err| AgentError::Other(format!("session history load error: {}", err)))?
-        } else {
-            self.conversations
             .load_messages(&self.persistent_session_id(chat_id))
-                .map_err(|err| AgentError::Other(format!("session history load error: {}", err)))?
+            .map_err(|err| AgentError::Other(format!("session history load error: {}", err)))?;
-        };
         self.chat_histories.insert(chat_id.to_string(), history);
         Ok(())
     }

src/storage/ports.rs

@@ -22,8 +22,6 @@ pub trait ConversationRepository: Send + Sync + 'static {
 
     fn load_messages(&self, session_id: &str) -> Result<Vec<ChatMessage>, StorageError>;
 
-    fn load_messages_for_topic(&self, topic_id: &str) -> Result<Vec<ChatMessage>, StorageError>;
-
     fn append_message(&self, session_id: &str, message: &ChatMessage) -> Result<(), StorageError>;
 
     fn append_message_with_topic(
@@ -164,10 +162,6 @@ impl ConversationRepository for super::SessionStore {
         super::SessionStore::load_messages(self, session_id)
     }
 
-    fn load_messages_for_topic(&self, topic_id: &str) -> Result<Vec<ChatMessage>, StorageError> {
-        super::SessionStore::load_messages_for_topic(self, topic_id)
-    }
-
     fn append_message(&self, session_id: &str, message: &ChatMessage) -> Result<(), StorageError> {
         super::SessionStore::append_message(self, session_id, message)
     }

vendor/wechatbot/src/bot.rs

@@ -602,26 +602,24 @@ fn chunk_text(text: &str, limit: usize) -> Vec<String> {
             chunks.push(remaining.to_string());
             break;
         }
-        // Find the nearest valid character boundary
+        let window = &remaining[..limit];
-        let end = remaining.floor_char_boundary(limit);
-        let window = &remaining[..end];
         let cut = window
             .rfind("\n\n")
-            .filter(|&i| i > end * 3 / 10)
+            .filter(|&i| i > limit * 3 / 10)
             .map(|i| i + 2)
             .or_else(|| {
                 window
                     .rfind('\n')
-                    .filter(|&i| i > end * 3 / 10)
+                    .filter(|&i| i > limit * 3 / 10)
                     .map(|i| i + 1)
             })
             .or_else(|| {
                 window
                     .rfind(' ')
-                    .filter(|&i| i > end * 3 / 10)
+                    .filter(|&i| i > limit * 3 / 10)
                     .map(|i| i + 1)
             })
-            .unwrap_or(end);
+            .unwrap_or(limit);
         chunks.push(remaining[..cut].to_string());
         remaining = &remaining[cut..];
     }