From b2282831339e90bafcc1537e7161f8287d9415d8 Mon Sep 17 00:00:00 2001
From: hubian <908234780@qq.com>
Date: Sat, 11 Apr 2026 12:29:11 +0800
Subject: [PATCH] =?UTF-8?q?feat:=20=E7=BD=91=E9=A1=B5=E7=AB=AF=E5=9B=BA?=
 =?UTF-8?q?=E5=AE=9A=E4=B8=BB=E7=94=A8=E6=88=B7=EF=BC=8CMatrix=20/new?=
 =?UTF-8?q?=E5=88=9B=E5=BB=BA=E6=96=B0=E4=BC=9A=E8=AF=9D=EF=BC=8C=E5=AE=9E?=
 =?UTF-8?q?=E6=97=B6=E5=90=8C=E6=AD=A5?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ai_chat.db                 | Bin 61440 -> 61440 bytes
 logs/ai-chat.log           |  11 ++-
 main.py                    | 141 +++++++++++++++++++++++--------------
 services/matrix_service.py | 129 ++++++++++++++++-----------------
 templates/index.html       |  53 ++++++++++++--
 5 files changed, 206 insertions(+), 128 deletions(-)

diff --git a/ai_chat.db b/ai_chat.db
index 4aa5ce0578900f5ffbbff6f0fe2fe6c0bd8a4e15..0f1ae8a49db23bb2ecec93e61498600e81e32127 100644
GIT binary patch
delta 2037
zcmZ`)Uu;ul6u)g_*1!881c*^#yhs$;?!Wf7^T90oATd4((KIHrgNh4VSLhg!nDmxz
zqwPA|v9ivsvOf+O$X1rk*}u#OqcQqqLc)uL$o=lU1(We2Pd<3Qb}ik8FW+{~x##!&
z&hMP_ReY!uAL`<-Xbz3M`mW~C(r0sMpT%^PLUZW-#=jfmjlAW)<x5MG`6u%iX0z#z
z>FDx-9jwXkv>2#^2X|3zZH9C1j&_%)$8({(=d5q5!P2blFwGxkm?oNUWgV@wwHbUY
zPycVk<}`1@?mNkLcXyxY_7Ln1!(X<xKya;`t(g`C#=*QWVs~(y;52Ol=Q|mWXS<kF
z1iaqZj=(pwR#vc=iTmqnf@>jUBLSyz6S!Nj`)DuYI!(aqjV<78E9YqDYz!|5FN!#5
z-e#knhB|D2N4rDlyKt)0XSWgXdgDb9w3VZ|t&*3orEPYB<DB|B@Q!wGAJ=2G`g%_i
z?0Tb$?ceApK-imk&cQRbYG_l$%ClC7vtbi>=Q&qjx7Br~kAT-3+YlHAusK>_w?zyj
z1mFU@eE+q#wEHY*g+l+LXXq(<j3o2`-A8|*-_g(LN0dV=%Lke+qc>mDX*3oKIn8Er
znoQ(08p&xekW;TGXG6p2gO=9;axaD6Mp^VH`VF<Cy=WbMh=S-ex`N(7HvsaVM*mLT
zK@F**HvX2Xr#7_as;4$wrmCkl5yq;g)<#3sQxjib_0$w=*ttCRj)&H3(J>08(J`QO
z1UWy^8mJb{e%MRuc#o&A-D>AqTZh}lA7>m!sW>f<r`HQp+XRIHwA*=s+dhC+7UrI(
z9qee@e+({rRu+1Br}!A{A#!Q8I-S8_q$o;@?osFox(Bge(VpG97R@#W+R-OdFYC4D
zRSNxLUWKRRmf1hp2$VJZhuU_v?bf<{zD{4S%hL-~@wMW5As~lFfb)B9xA!Br`_y_N
zsw9@=AC_?Ly1aBzS((KHw{a|kLz5+OTAAo?JAxxO<?s+>KAjqm7>$*DDI-dmTS_i1
zk6n^ex8?a6d=<Wls$ctyO8=^q8I}`iIU2xo6A+WdfSMk}q3>{HN(};ws8k#zK&dd~
zOL_P{A{C}<Q5;K4`D-|{NLbJHEAc@*c^3y`kHkRl`Cd4^Cq5^qm;8UO=gbNC<34}f
z-K8vq{S`#G17}yI{8v(DK~3jzYz+K(At|lR$bq!FHmS};acEG!8n0aNNW2Jy@M07X
z%;SM!btNkm*ObIO;K)PQfGES-KL9-l)65WHm9DITW~Ah`@k*^~AfXgT{Bk@+WZbAU
zR7#2J^#Ca(HUF`@qovL31xlbOj?60;v$!Bu@+xU^G+at7t{1|<$4KU@B1K7@P}eTu
z#c_Eoi*pI!g|7_aToS0L#Uc<Vo$`8tP02qIlas5Zi5O1Z!Iz^DQv(q^cT>vE$=?Sm
zWlDt!fKY-9a&SP&52^!s$S2T+n3T!Et#T|b-JQhoe&xn6v;jtd=#ZRN7jrN?c=D>U
zkSHY=OS9vkJRXjb84<rx#o!~+4?QOx1Bv9BZ#VQAPs>T@XQo1hV1-6X!6LpJlCp8R
zKL*nUla&ffc~Q!SNF%Bf0LZ`x=;3%077glx>hMTJO^3;6qtJoCU#WR`H8yte)9P;{
z+ge^V8^;Kqvt3<+Mo(#W?<Y%f*5^J$iY%}0^UUXoJl{;)9PpBp#L6nxt!ep%tE}nl
Kbkppe9sdCvVnZYV

delta 172
zcmZp8z})bFd4e>f<U|=~M#+r{OZWxYcyBQ9FX8v#d&4(@&xH5JW<!M|yqj;x>M#kg
z@!w<M|HJ={{{#Ok{wMtRHVZbK;-7pkUTE?MeGxu3{;3T7JNfVOpXPthKXtQ$!FRri
z3wkzBwa+(TW8`1Yz`uU8V!%@V$?NMwf&4!}lQs(;c+W4$z`(%F%*n|Gq#5~NGw{C#
X8vBrc^6UAMn^_M0k)Kq+0;2T+ODjDn

diff --git a/logs/ai-chat.log b/logs/ai-chat.log
index 3d9e2e5..81c8ae6 100644
--- a/logs/ai-chat.log
+++ b/logs/ai-chat.log
@@ -25,8 +25,15 @@ WARNING:nio.clieWARNING:nio.client.async_client:Timed out, sleeping for 60s
 WARNING:nio.client.async_client:Timed out, sleeping for 60s
 WARNING:nio.client.async_client:Timed out, sleeping for 60s
 WARNING:nio.client.async_client:Timed out, sleeping for 60s
-async_client:Timed out, sleeping for 25s
-WARNING:nio.client.async_client:Timed out, sleeping for 51s
+WARNING:nio.client.async_client:Timed out, sleeping for 60s
+WARNING:nio.client.async_client:Timed out, sleeping for 60s
+WARNING:nio.client.async_client:Timed out, sleeping for 60s
+WARNING:nio.client.async_client:Timed out, sleeping for 60s
+WARNING:nio.client.async_client:Timed out, sleeping for 60s
+WARNING:nio.client.async_client:Timed out, sleeping for 60s
+WARNING:nio.client.async_client:Timed out, sleeping for 60s
+async_client:Timed out, sleeping for 60s
+WARNING:nio.client.async_client:Timed out, sleeping for 60s
 WARNING:nio.client.async_client:Timed out, sleeping for 60s
 WARNING:nio.client.async_client:Timed out, sleeping for 60s
 WARNING:nio.client.async_client:Timed out, sleeping for 60s
diff --git a/main.py b/main.py
index 8a1d4fc..accccdb 100644
--- a/main.py
+++ b/main.py
@@ -83,15 +83,14 @@ async def admin(request: Request):
 
 # ==================== API路由 ====================
 
+# 固定主用户ID（与Matrix AI用户关联）
+MAIN_USER_ID = "main_user"
+
 @app.get("/api/conversations")
-async def get_conversations(user_id: str = None, db: Session = Depends(get_db)):
-    """获取会话列表"""
-    if not user_id:
-        # 临时用户ID（实际应用中应该从session获取）
-        user_id = "web_anonymous"
-    
+async def get_conversations(db: Session = Depends(get_db)):
+    """获取会话列表（使用固定主用户）"""
     conv_service = ConversationService(db)
-    user = conv_service.get_or_create_user(user_id, user_type='web')
+    user = conv_service.get_or_create_user(MAIN_USER_ID, display_name="主用户", user_type='web')
     conversations = conv_service.get_user_conversations(user.id)
     
     return {
@@ -106,15 +105,30 @@ async def get_conversations(user_id: str = None, db: Session = Depends(get_db)):
         ]
     }
 
+@app.get("/api/conversations/latest")
+async def get_latest_conversation(db: Session = Depends(get_db)):
+    """获取最新会话（用于Matrix同步）"""
+    conv_service = ConversationService(db)
+    user = conv_service.get_or_create_user(MAIN_USER_ID, display_name="主用户", user_type='web')
+    conversations = conv_service.get_user_conversations(user.id)
+    
+    if conversations:
+        latest = conversations[0]  # 已按更新时间倒序
+        return {
+            "conversation": {
+                "id": latest.conversation_id,
+                "title": latest.title or "新对话",
+                "updated_at": latest.updated_at.isoformat()
+            }
+        }
+    return {"conversation": None}
+
 
 @app.post("/api/conversations")
-async def create_conversation(user_id: str = None, db: Session = Depends(get_db)):
-    """创建新会话"""
-    if not user_id:
-        user_id = "web_anonymous"
-    
+async def create_conversation(db: Session = Depends(get_db)):
+    """创建新会话（使用固定主用户）"""
     conv_service = ConversationService(db)
-    user = conv_service.get_or_create_user(user_id, user_type='web')
+    user = conv_service.get_or_create_user(MAIN_USER_ID, display_name="主用户", user_type='web')
     conversation = conv_service.create_conversation(user.id)
     
     return {
@@ -165,10 +179,12 @@ async def delete_conversation(conversation_id: str, db: Session = Depends(get_db
 
 @app.websocket("/ws/{user_id}")
 async def websocket_endpoint(websocket: WebSocket, user_id: str, db: Session = Depends(get_db)):
-    """WebSocket连接 - 实时对话"""
-    await manager.connect(websocket, user_id)
+    """WebSocket连接 - 实时对话（所有连接使用主用户）"""
+    # 统一使用主用户ID
+    actual_user_id = MAIN_USER_ID
+    await manager.connect(websocket, actual_user_id)
     conv_service = ConversationService(db)
-    user = conv_service.get_or_create_user(user_id, user_type='web')
+    user = conv_service.get_or_create_user(MAIN_USER_ID, display_name="主用户", user_type='web')
     
     current_conversation_id = None
     
@@ -227,8 +243,8 @@ async def websocket_endpoint(websocket: WebSocket, user_id: str, db: Session = D
                     source='web'
                 )
                 
-                # 通知用户消息已收到
-                await manager.send_to_user(user_id, {
+                # 广播用户消息（同步到所有客户端）
+                await manager.send_to_user(MAIN_USER_ID, {
                     "type": "user_message",
                     "conversation_id": conversation_id,
                     "message": {
@@ -255,14 +271,15 @@ async def websocket_endpoint(websocket: WebSocket, user_id: str, db: Session = D
                         source='web'
                     )
                     
-                    # 发送AI回复
-                    await manager.send_to_user(user_id, {
+                    # 广播AI回复（同步到所有客户端）
+                    await manager.send_to_user(MAIN_USER_ID, {
                         "type": "assistant_message",
                         "conversation_id": conversation_id,
                         "message": {
                             "id": assistant_msg.id,
                             "role": "assistant",
                             "content": ai_response,
+                            "source": "web",
                             "created_at": assistant_msg.created_at.isoformat()
                         }
                     })
@@ -397,42 +414,58 @@ async def update_config(data: dict, db: Session = Depends(get_db)):
 
 # ==================== Matrix消息处理回调 ====================
 
-async def handle_matrix_message(conversation_id: str, user_message: str, user_id: str, room_id: str):
+async def handle_matrix_message(action: str, conversation_id: str = None, user_message: str = None, room_id: str = None, message_id: int = None):
     """处理从Matrix收到的消息"""
-    db = SessionLocal()
-    try:
-        conv_service = ConversationService(db)
-        
-        # 获取会话历史
-        history = conv_service.get_conversation_history(conversation_id, limit=20)
-        
-        # 调用AI
-        ai_response = await ai_service.chat(history)
-        
-        # 保存AI回复
-        conversation = conv_service.get_conversation(conversation_id)
-        if conversation:
-            conv_service.add_message(
-                conversation_id=conversation.id,
-                role='assistant',
-                content=ai_response,
-                source='matrix'
-            )
-        
-        # 发送到Matrix
-        await matrix_bot.send_message(room_id, ai_response)
-        
-        # 同时推送到网页端
-        await manager.send_to_user(user_id, {
-            "type": "assistant_message",
-            "conversation_id": conversation_id,
-            "message": {
-                "role": "assistant",
-                "content": ai_response,
-                "source": "matrix",
-                "created_at": datetime.utcnow().isoformat()
-            }
+    
+    if action == "new_conversation":
+        # 创建新会话 - 通知WebSocket客户端
+        await manager.send_to_user(MAIN_USER_ID, {
+            "type": "new_conversation",
+            "conversation_id": conversation_id
         })
+        return
+    
+    if action == "chat":
+        db = SessionLocal()
+        try:
+            conv_service = ConversationService(db)
+            
+            # 获取会话历史
+            history = conv_service.get_conversation_history(conversation_id, limit=20)
+            
+            # 调用AI
+            ai_response = await ai_service.chat(history)
+            
+            # 保存AI回复
+            conversation = conv_service.get_conversation(conversation_id)
+            if conversation:
+                assistant_msg = conv_service.add_message(
+                    conversation_id=conversation.id,
+                    role='assistant',
+                    content=ai_response,
+                    source='matrix'
+                )
+                
+                # 发送到Matrix
+                await matrix_bot.send_message(room_id, ai_response)
+                
+                # 同步到网页端WebSocket
+                await manager.send_to_user(MAIN_USER_ID, {
+                    "type": "assistant_message",
+                    "conversation_id": conversation_id,
+                    "message": {
+                        "id": assistant_msg.id,
+                        "role": "assistant",
+                        "content": ai_response,
+                        "source": "matrix",
+                        "created_at": assistant_msg.created_at.isoformat()
+                    }
+                })
+        except Exception as e:
+            logger.error(f"处理Matrix消息失败: {e}")
+            await matrix_bot.send_message(room_id, f"处理消息时出错: {str(e)}")
+        finally:
+            db.close()
     
     except Exception as e:
         logger.error(f"处理Matrix消息失败: {e}")
diff --git a/services/matrix_service.py b/services/matrix_service.py
index 567474f..58efc29 100644
--- a/services/matrix_service.py
+++ b/services/matrix_service.py
@@ -1,17 +1,21 @@
 """
 Matrix Bot 服务 - 处理Matrix消息收发
+所有消息都同步到主用户的最新会话
 """
 import asyncio
 import json
 from typing import Optional, Callable
-from nio import AsyncClient, MatrixRoom, RoomMessageText, LoginResponse, SyncResponse
+from nio import AsyncClient, MatrixRoom, RoomMessageText, LoginResponse
 import logging
 
-from models import SessionLocal, User, Conversation, Message, MatrixRoomMapping, SystemConfig
+from models import SessionLocal, User, Conversation, Message, SystemConfig
 from services.conversation_service import ConversationService
 
 logger = logging.getLogger(__name__)
 
+# 主用户ID
+MAIN_USER_ID = "main_user"
+
 
 class MatrixBot:
     def __init__(self):
@@ -45,14 +49,12 @@ class MatrixBot:
             return False
         
         try:
-            # 创建客户端
             self.client = AsyncClient(
                 self.homeserver, 
                 self.username,
                 store_path="/tmp/matrix_store"
             )
             
-            # 如果有access_token，直接设置
             if self.access_token:
                 self.client.access_token = self.access_token
                 self.client.user_id = self.username
@@ -60,7 +62,6 @@ class MatrixBot:
                 self.is_running = True
                 return True
             
-            # 否则使用密码登录
             response = await self.client.login(self.password)
             
             if isinstance(response, LoginResponse):
@@ -85,14 +86,12 @@ class MatrixBot:
         # 注册消息处理器
         self.client.add_event_callback(self._handle_room_message, RoomMessageText)
         
-        # 首先执行一次同步获取房间信息
         try:
-            sync_response = await self.client.sync(timeout=10000)
-            logger.info(f"Matrix初始同步完成")
+            await self.client.sync(timeout=10000)
+            logger.info("Matrix初始同步完成")
         except Exception as e:
-            logger.warning(f"Matrix初始同步失败: {e}, 将尝试继续")
+            logger.warning(f"Matrix初始同步失败: {e}")
         
-        # 启动后台同步任务（不阻塞）
         asyncio.create_task(self._sync_loop())
         logger.info("Matrix同步任务已启动")
     
@@ -100,65 +99,77 @@ class MatrixBot:
         """后台同步循环"""
         while self.is_running:
             try:
-                # 使用较短的超时，避免长时间阻塞
                 await self.client.sync(timeout=5000)
-                await asyncio.sleep(1)  # 每秒同步一次
+                await asyncio.sleep(1)
             except Exception as e:
                 logger.warning(f"Matrix同步错误: {e}")
-                await asyncio.sleep(5)  # 出错后等待5秒再重试
+                await asyncio.sleep(5)
     
     async def _handle_room_message(self, room: MatrixRoom, event: RoomMessageText):
-        """处理收到的房间消息"""
+        """处理Matrix消息 - 所有消息同步到主用户最新会话"""
         # 忽略自己发送的消息
         if event.sender == self.username:
             return
         
+        message_text = event.body.strip()
+        
         db = SessionLocal()
         try:
             conv_service = ConversationService(db)
             
-            # 获取或创建Matrix用户
-            matrix_user_id = event.sender
-            user = conv_service.get_or_create_user(
-                user_id=matrix_user_id,
-                display_name=room.users.get(matrix_user_id, {}).get('display_name', matrix_user_id),
-                user_type='matrix',
-                matrix_user_id=matrix_user_id
+            # 使用固定主用户
+            main_user = conv_service.get_or_create_user(
+                MAIN_USER_ID, 
+                display_name="主用户", 
+                user_type='web'
             )
             
-            # 获取或创建房间映射
-            mapping = db.query(MatrixRoomMapping).filter(
-                MatrixRoomMapping.room_id == room.room_id
-            ).first()
+            # 处理 /new 命令 - 创建新会话，不回复
+            if message_text == "/new":
+                conversation = conv_service.create_conversation(main_user.id)
+                await self.send_message(room.room_id, "✅ 已创建新会话")
+                logger.info(f"Matrix创建新会话: {conversation.conversation_id}")
+                
+                # 通知WebSocket客户端
+                if self.on_message_callback:
+                    await self.on_message_callback(
+                        action="new_conversation",
+                        conversation_id=conversation.conversation_id,
+                        room_id=room.room_id
+                    )
+                return
             
-            if not mapping:
-                # 为这个房间创建新会话
-                conversation = conv_service.create_conversation(user.id, title=f"Matrix: {room.display_name}")
-                mapping = MatrixRoomMapping(
-                    room_id=room.room_id,
-                    user_id=user.id,
-                    conversation_id=conversation.id
-                )
-                db.add(mapping)
-                db.commit()
-                db.refresh(mapping)
+            # 获取最新会话
+            conversations = conv_service.get_user_conversations(main_user.id)
+            if not conversations:
+                # 如果没有会话，创建一个
+                conversation = conv_service.create_conversation(main_user.id)
+            else:
+                conversation = conversations[0]  # 最新会话
             
             # 保存用户消息
-            conv_service.add_message(
-                conversation_id=mapping.conversation_id,
+            user_msg = conv_service.add_message(
+                conversation_id=conversation.id,
                 role='user',
-                content=event.body,
+                content=message_text,
                 source='matrix',
-                extra_data={'event_id': event.event_id, 'room_id': room.room_id}
+                extra_data={
+                    'event_id': event.event_id, 
+                    'room_id': room.room_id,
+                    'sender': event.sender
+                }
             )
             
-            # 调用外部消息处理器
+            logger.info(f"Matrix消息保存到会话 {conversation.conversation_id}")
+            
+            # 调用消息处理器（获取AI回复并同步）
             if self.on_message_callback:
                 await self.on_message_callback(
-                    conversation_id=mapping.conversation.conversation_id,
-                    user_message=event.body,
-                    user_id=user.user_id,
-                    room_id=room.room_id
+                    action="chat",
+                    conversation_id=conversation.conversation_id,
+                    user_message=message_text,
+                    room_id=room.room_id,
+                    message_id=user_msg.id
                 )
         finally:
             db.close()
@@ -182,28 +193,12 @@ class MatrixBot:
             logger.error(f"发送Matrix消息失败: {e}")
             return False
     
-    async def get_room_id_for_user(self, user_matrix_id: str) -> Optional[str]:
-        """获取与用户的对话房间ID"""
-        db = SessionLocal()
-        try:
-            user = db.query(User).filter(User.matrix_user_id == user_matrix_id).first()
-            if user:
-                mapping = db.query(MatrixRoomMapping).filter(
-                    MatrixRoomMapping.user_id == user.id
-                ).first()
-                if mapping:
-                    return mapping.room_id
-            return None
-        finally:
-            db.close()
-    
     async def disconnect(self):
         """断开连接"""
         if self.client:
-            await self.client.logout()
-            await self.client.close()
-            self.is_running = False
-
-
-# 全局实例
-matrix_bot = MatrixBot()
\ No newline at end of file
+            try:
+                await self.client.logout()
+                await self.client.close()
+            except:
+                pass
+            self.is_running = False
\ No newline at end of file
diff --git a/templates/index.html b/templates/index.html
index 200d2c3..455c891 100644
--- a/templates/index.html
+++ b/templates/index.html
@@ -341,20 +341,39 @@
     </div>
 
     <script>
-        // 全局变量
+        // 全局变量 - 使用固定主用户（与Matrix AI用户相同）
         let ws = null;
-        let userId = 'web_' + Math.random().toString(36).substr(2, 9);
+        let userId = 'main_user';  // 固定主用户ID
         let currentConversationId = null;
         let conversations = [];
         
         // 初始化
         document.addEventListener('DOMContentLoaded', () => {
-            document.getElementById('userIdDisplay').textContent = `用户: ${userId}`;
+            document.getElementById('userIdDisplay').textContent = '主用户模式';
             connectWebSocket();
             loadConversations();
             setupTextarea();
+            
+            // 监听最新会话更新
+            setInterval(checkLatestConversation, 2000);
         });
         
+        // 检查最新会话（用于Matrix同步）
+        async function checkLatestConversation() {
+            try {
+                const response = await fetch('/api/conversations/latest');
+                if (response.ok) {
+                    const data = await response.json();
+                    if (data.conversation && data.conversation.id !== currentConversationId) {
+                        // 有新会话，自动切换
+                        selectConversation(data.conversation.id);
+                    }
+                }
+            } catch (error) {
+                // 忽略错误
+            }
+        }
+        
         // WebSocket连接
         function connectWebSocket() {
             const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
@@ -391,8 +410,27 @@
                     loadConversations();
                     break;
                     
+                case 'new_conversation':
+                    // Matrix创建了新会话，自动切换
+                    currentConversationId = data.conversation_id;
+                    loadConversations();
+                    // 清空消息区域
+                    const container = document.getElementById('messagesContainer');
+                    container.innerHTML = `
+                        <div class="welcome">
+                            <h2>👋 开始新对话</h2>
+                            <p>输入您的问题开始对话</p>
+                        </div>
+                    `;
+                    break;
+                    
                 case 'user_message':
                     appendMessage('user', data.message.content, data.message.source);
+                    // 如果消息来自Matrix，切换到对应会话
+                    if (data.message.source === 'matrix' && data.conversation_id) {
+                        currentConversationId = data.conversation_id;
+                        renderConversations();
+                    }
                     break;
                     
                 case 'assistant_message':
@@ -451,10 +489,15 @@
         // 加载会话列表
         async function loadConversations() {
             try {
-                const response = await fetch('/api/conversations?user_id=' + userId);
+                const response = await fetch('/api/conversations');
                 const data = await response.json();
                 conversations = data.conversations;
                 renderConversations();
+                
+                // 如果没有当前会话且有会话列表，自动选择最新的
+                if (!currentConversationId && conversations.length > 0) {
+                    selectConversation(conversations[0].id);
+                }
             } catch (error) {
                 console.error('加载会话失败:', error);
             }
@@ -496,7 +539,7 @@
         // 创建新会话
         async function createNewConversation() {
             try {
-                const response = await fetch('/api/conversations?user_id=' + userId, {
+                const response = await fetch('/api/conversations', {
                     method: 'POST'
                 });
                 const data = await response.json();