myagent-ai 1.23.81 → 1.23.82

package/myagent/package.json

@@ -1,6 +1,6 @@
 {
   "name": "myagent-ai",
-  "version": "1.23.81",
+  "version": "1.23.82",
   "description": "本地桌面端执行型AI助手 - Open Interpreter 风格 | Local Desktop Execution-Oriented AI Assistant",
   "main": "main.py",
   "bin": {

package/myagent/web/api_server.py

@@ -473,7 +473,11 @@ class ApiServer:
         # ── 群消息 ──
         r.add_get("/api/groups/{gid}/messages", self.handle_get_group_messages)
         r.add_post("/api/groups/{gid}/messages", self.handle_send_group_message)
+        r.add_post("/api/groups/{gid}/messages/stream", self.handle_send_group_message_stream)
         r.add_delete("/api/groups/{gid}/messages", self.handle_clear_group_messages)
+        # [v1.23.81] 群聊 session 管理（纯数字 ID，用于 URL 导航恢复）
+        r.add_get("/api/groups/{gid}/session", self.handle_get_group_session)
+        r.add_get("/api/group-session/{sid}", self.handle_resolve_group_session)
         # [v1.23.37] Agent间私聊记录查询
         r.add_get("/api/agent-chat/pairs", self.handle_get_agent_chat_pairs)
         r.add_get("/api/agent-chat/messages", self.handle_get_agent_chat_messages)
@@ -4169,9 +4173,7 @@ window.addEventListener('beforeunload', function() {{
             return web.json_response({"error": str(e)}, status=500)
 
     async def handle_list_sessions(self, request):
-        if not self.core.memory:
-            logger.warning("handle_list_sessions: self.core.memory is None, 无法查询会话")
-            return web.json_response([])
+        if not self.core.memory: return web.json_response([])
         agent = request.query.get("agent", "")
         # 只统计用户可见的消息数（排除 llm_output 和 conversation_insight）
         if agent:
@@ -4189,13 +4191,6 @@ window.addEventListener('beforeunload', function() {{
                 "AND key NOT IN ('llm_output', 'llm_input', 'tool_result_raw', 'conversation_insight') "
                 "GROUP BY session_id ORDER BY last DESC LIMIT 100").fetchall()
         sessions = [{"id": r["session_id"], "messages": r["cnt"], "last": r["last"]} for r in rows]
-        if not sessions:
-            try:
-                total = self.core.memory._get_conn().execute("SELECT COUNT(*) as cnt FROM memories WHERE category = 'session'").fetchone()
-                total_all = self.core.memory._get_conn().execute("SELECT COUNT(*) as cnt FROM memories").fetchone()
-                logger.debug(f"handle_list_sessions: 无会话. session记录: {total['cnt']}, 总: {total_all['cnt']}, agent: {agent or '(无)'}")
-            except Exception:
-                pass
         # 批量获取自定义会话名称
         sids = [s["id"] for s in sessions]
         name_map = self.core.memory.list_session_names(sids) if sids else {}
@@ -7981,6 +7976,313 @@ window.addEventListener('beforeunload', function() {{
             "task_id": task_id,
         })
 
+    async def handle_send_group_message_stream(self, request):
+        """POST /api/groups/{gid}/messages/stream - SSE 流式群聊
+
+        SSE 事件格式:
+          data: {"type":"agent_start","agent_path":"...","name":"...","avatar":"...","agent_color":"..."}
+          data: {"type":"text_delta","content":"...","agent_path":"..."}
+          data: {"type":"agent_done","agent_path":"..."}
+          data: {"type":"system_message","content":"..."}
+          data: {"type":"done","task_id":"..."}
+          data: {"type":"error","content":"..."}
+        """
+        import re as _re
+        import time as _time
+        import asyncio
+
+        try:
+            data = await request.json()
+        except Exception:
+            return web.Response(
+                text='data: ' + json.dumps({"type": "error", "content": "invalid JSON"}) + '\n\n',
+                content_type="text/event-stream",
+            )
+
+        gid = request.match_info["gid"]
+        content = data.get("message", "").strip()
+        if not content:
+            return web.Response(
+                text='data: ' + json.dumps({"type": "error", "content": "消息不能为空"}) + '\n\n',
+                content_type="text/event-stream",
+            )
+
+        mgr = self._get_group_manager()
+        group = mgr.get_group(gid)
+        if not group:
+            return web.Response(
+                text='data: ' + json.dumps({"type": "error", "content": "群不存在"}) + '\n\n',
+                content_type="text/event-stream",
+            )
+
+        # 创建 SSE 流式响应
+        response = web.StreamResponse(
+            status=200,
+            headers={
+                "Content-Type": "text/event-stream",
+                "Cache-Control": "no-cache",
+                "Connection": "keep-alive",
+                "X-Accel-Buffering": "no",
+            }
+        )
+        await response.prepare(request)
+
+        client_connected = {"value": True}
+        _write_lock = asyncio.Lock()
+
+        async def safe_write(obj):
+            if not client_connected["value"]:
+                return False
+            try:
+                async with _write_lock:
+                    await response.write(("data: " + json.dumps(obj, ensure_ascii=False) + "\n\n").encode())
+                return True
+            except Exception:
+                client_connected["value"] = False
+                return False
+
+        # 1. 保存用户消息
+        from groups.manager import GroupMessage
+        user_msg = GroupMessage(
+            group_id=gid, sender="user", sender_name="用户",
+            sender_avatar="👤", content=content,
+        )
+        mgr.add_message(user_msg)
+
+        # 2. 保存任务记录
+        tp = self._get_task_persistence()
+        from core.utils import generate_id
+        task_id = generate_id("task")
+        tp.save_task(
+            task_id=task_id, description=content[:500],
+            session_id=f"group_{gid}", group_id=gid,
+            agent_path=", ".join(m.agent_path for m in group.members if not m.muted),
+            status="running", metadata={"source": "group_chat", "group_name": group.name},
+        )
+
+        # 3. 解析 @提及
+        at_pattern = _re.compile(r'@(\S+)')
+        at_targets = at_pattern.findall(content)
+        mentioned_agents = set()
+        mentioned_all = False
+        for target in at_targets:
+            target_lower = target.lower()
+            if target_lower in ('all', '所有人', '大家'):
+                mentioned_all = True
+                break
+            for m in group.members:
+                agent_cfg = self._read_agent_config(m.agent_path)
+                agent_name = agent_cfg.get("name", "") if agent_cfg else ""
+                if (target_lower == m.agent_path.lower()
+                    or target_lower == agent_name.lower()
+                    or (m.nickname and target_lower == m.nickname.lower())):
+                    mentioned_agents.add(m.agent_path)
+
+        active_members = [m for m in group.members if not m.muted]
+        if mentioned_all:
+            target_members = active_members
+        elif mentioned_agents:
+            target_members = [m for m in active_members if m.agent_path in mentioned_agents]
+        else:
+            target_members = active_members
+
+        # 4. 串行处理每个 agent，流式输出
+        _chat_msg_pattern = _re.compile(r'__CHAT_AGENT__(.+?)\|(.+?)\|(.+?)__END__')
+        final_responses = []
+
+        for member in target_members:
+            agent_path = member.agent_path
+            agent_cfg = self._read_agent_config(agent_path)
+
+            # 获取显示信息
+            avatar = "🤖"
+            display_name = agent_path
+            agent_color = "var(--accent)"
+            if agent_cfg:
+                avatar = agent_cfg.get("avatar_emoji", "🤖") or "🤖"
+                display_name = agent_cfg.get("name", agent_path)
+                agent_color = agent_cfg.get("avatar_color", "var(--accent)")
+
+            # 通知前端：新 agent 开始回复
+            await safe_write({
+                "type": "agent_start",
+                "agent_path": agent_path,
+                "name": display_name,
+                "avatar": avatar,
+                "agent_color": agent_color,
+            })
+
+            try:
+                model_chain = self._build_model_chain(agent_cfg, agent_path)
+                session_id = f"group_{gid}_{agent_path}"
+
+                _, agent_system_prompt = self._build_agent_chat_context(agent_path, agent_cfg, content)
+
+                # 构建群聊上下文（与 handle_send_group_message 完全一致）
+                member_lines = []
+                for m in group.members:
+                    mc = self._read_agent_config(m.agent_path)
+                    m_name = mc.get("name", m.agent_path) if mc else m.agent_path
+                    m_id = mc.get("id", "") if mc else ""
+                    m_desc = mc.get("description", "") if mc else ""
+                    role_label = {"owner": "群主", "admin": "管理员"}.get(m.role, "成员")
+                    nick = f"（昵称: {m.nickname}）" if m.nickname else ""
+                    line = f"  - {m_name} [ID: {m_id}] ({role_label})"
+                    if m_desc: line += f" — {m_desc}"
+                    line += nick
+                    if m.muted: line += "（已禁言）"
+                    member_lines.append(line)
+
+                my_name = agent_cfg.get("name", agent_path) if agent_cfg else agent_path
+                my_role = {"owner": "群主", "admin": "管理员"}.get(member.role, "成员")
+
+                recent_msgs = mgr.get_messages(gid, limit=10)
+                history_lines = []
+                for rm in recent_msgs:
+                    rm_name = rm.sender_name or ("用户" if rm.sender == "user" else rm.agent_path)
+                    rm_time_str = _time.strftime("%H:%M", _time.localtime(rm.timestamp)) if rm.timestamp else ""
+                    history_lines.append(f"[{rm_time_str}] {rm_name}: {rm.content[:200]}")
+                chat_history = "\n".join(reversed(history_lines))
+
+                is_mentioned = mentioned_all or member.agent_path in mentioned_agents
+                at_info = ""
+                if mentioned_all:
+                    at_info = "- 本次消息使用了 @所有人，请务必回复。\n"
+                elif mentioned_agents:
+                    if is_mentioned:
+                        at_info = f"- 本次消息使用了 @{my_name}，请务必回复。\n"
+                    else:
+                        at_info = "- 本次消息使用了 @其他成员，与你无关，请不要回复。\n"
+                else:
+                    at_info = "- 本次消息没有 @任何人（广播消息），你可以根据内容决定是否回复。\n"
+
+                group_context = f"""## 群聊上下文
+
+你正在参与一个群聊，以下是群的详细信息：
+
+### 群信息
+- 群名称: {group.name}
+- 群描述: {group.description or '无'}
+- 当前发言者: 用户（群聊中的真人用户）
+
+### 你的身份
+- 名称: {my_name}
+- 路径: {agent_path}
+- 角色: {my_role}{"（已禁言，但仍可接收消息）" if member.muted else ""}
+
+### 群成员列表（共{len(group.members)}人）
+{chr(10).join(member_lines)}
+
+### 沟通规则（重要）
+1. **@提及机制**: 用户发送消息时可以使用 @名称 来指定回复者
+   - @某个Agent: 只有被@的Agent需要回复
+   - @所有人 / @all: 所有成员都需要回复
+   - 不@任何人（广播）: 你自行判断是否需要回复
+2. **跨Agent私下沟通**: 你可以使用 `myagent-ai chat --agent <ID> --message "消息"` 命令向群内其他Agent发送私下消息。
+   - **必须使用Agent的ID**，不是名字。从上方「群成员列表」中找到目标Agent的 `[ID: xxx]` 就是它的唯一ID
+   - 正确示例: `myagent-ai chat --agent a1b2c3d4e5f6 --message "你好"`
+   - 私下沟通的内容不会直接显示给用户，适合讨论细节、交换数据、协调方案
+   - 当任务需要多个Agent协作时，应该先在群里讨论分工，然后私下沟通具体细节
+3. **协作分工模式**（复杂任务）:
+   - 部长/管理员应主动分析任务，在群里提出分工方案（谁负责什么）
+   - 其他成员应积极响应，认领自己擅长的部分
+   - 分工确定后，各自私下沟通需要协调的细节
+   - 部长/管理员负责在群里汇总进展，向用户汇报阶段性成果和最终结果
+   - 私下沟通的详细过程不需要在群里展示，只汇报关键进展和最终结论
+{at_info}
+### 近期群聊记录（最近10条）
+{chat_history if chat_history else '（暂无历史消息）'}
+
+### 重要提醒
+- 你只代表你自己发言，使用第一人称
+- 不要假装是其他Agent或代替其他Agent回答
+- 如果问题超出你的能力范围，建议用户@相关专家Agent
+- 如果需要其他Agent的信息，使用 `myagent-ai chat --agent <ID>` 命令私下沟通（使用Agent的ID，从群成员列表的[ID: xxx]中获取）
+
+### 能力提醒（关键）
+- 你拥有完整的工具调用能力（搜索、文件操作、代码执行、图片生成等）
+- 在群聊中，你应该像在1对1对话中一样主动使用工具来完成用户的请求
+- 不要因为身处群聊就只做简单文字回复，该用工具时一定要用"""
+
+                if agent_system_prompt:
+                    agent_system_prompt += "\n\n" + group_context
+                else:
+                    agent_system_prompt = group_context
+
+                dept_context = self._build_dept_context(gid, agent_path)
+                if dept_context:
+                    agent_system_prompt += "\n\n" + dept_context
+
+                agent_content = content
+
+                # 调用 LLM 获取回复
+                if model_chain and self.core.llm:
+                    response_text = await self._try_model_chain_inner(
+                        model_chain, agent_content, session_id,
+                        agent_path=agent_path, agent_system_prompt=agent_system_prompt,
+                    )
+                else:
+                    response_text = await self.core.process_message(agent_content, session_id)
+
+                # 流式输出该 agent 的回复文本（逐块发送）
+                await self._stream_text_chunked(response_text, safe_write, chunk_size=6, delay=0.01)
+
+                # 处理跨 Agent 私聊标记
+                chat_matches = _chat_msg_pattern.findall(response_text)
+                if chat_matches:
+                    response_text = _chat_msg_pattern.sub('', response_text).strip()
+                    for c_path, c_name, c_msg in chat_matches:
+                        c_path_s, c_name_s, c_msg_s = c_path.strip(), c_name.strip(), c_msg.strip()
+                        chat_sys_msg = GroupMessage(
+                            group_id=gid, sender=agent_path,
+                            sender_name=display_name, sender_avatar=avatar,
+                            content=f"💬 私下与 {c_name_s} 沟通中...",
+                        )
+                        mgr.add_message(chat_sys_msg)
+                        try:
+                            mgr.add_agent_chat(
+                                group_id=gid, from_agent=agent_path,
+                                from_name=display_name, to_agent=c_path_s,
+                                to_name=c_name_s, content=c_msg_s,
+                            )
+                        except Exception as ce:
+                            logger.debug(f"保存私聊记录失败: {ce}")
+
+                # 保存到数据库
+                agent_msg = GroupMessage(
+                    group_id=gid, sender="agent",
+                    sender_name=display_name, sender_avatar=avatar,
+                    content=response_text, agent_path=agent_path,
+                )
+                mgr.add_message(agent_msg)
+
+                final_responses.append({
+                    "ok": True, "agent_path": agent_path,
+                    "name": display_name, "avatar": avatar,
+                    "agent_color": agent_color,
+                    "response": response_text,
+                })
+
+            except Exception as e:
+                logger.error(f"群消息处理失败 ({agent_path}): {e}")
+                await safe_write({"type": "text_delta", "content": f"处理失败: {str(e)}", "agent_path": agent_path})
+                final_responses.append({
+                    "ok": False, "agent_path": agent_path,
+                    "name": agent_path, "avatar": "❌",
+                    "response": f"处理失败: {str(e)}",
+                })
+
+            # 通知前端：该 agent 回复完成
+            await safe_write({"type": "agent_done", "agent_path": agent_path})
+
+        # 更新任务状态
+        has_failure = any(not r.get("ok") for r in final_responses)
+        tp.update_task_status(task_id, "failed" if has_failure else "completed", last_message=content[:500])
+
+        # 通知前端：全部完成
+        await safe_write({"type": "done", "task_id": task_id, "group_id": gid})
+        return response
+
     async def handle_clear_group_messages(self, request):
         """DELETE /api/groups/{gid}/messages - 清空群消息"""
         gid = request.match_info["gid"]
@@ -7988,6 +8290,30 @@ window.addEventListener('beforeunload', function() {{
         ok = mgr.clear_messages(gid)
         return web.json_response({"ok": ok})
 
+    # ── [v1.23.81] 群聊 Session API ──
+
+    async def handle_get_group_session(self, request):
+        """GET /api/groups/{gid}/session - 获取或创建群聊的 session ID（纯数字）"""
+        gid = request.match_info["gid"]
+        mgr = self._get_group_manager()
+        group = mgr.get_group(gid)
+        if not group:
+            return web.json_response({"error": "群不存在"}, status=404)
+        session_id = mgr.get_or_create_group_session(gid)
+        return web.json_response({"session_id": session_id, "group_id": gid})
+
+    async def handle_resolve_group_session(self, request):
+        """GET /api/group-session/{sid} - 通过 session ID 查找 group_id（用于 URL 恢复）"""
+        sid = request.match_info["sid"]
+        mgr = self._get_group_manager()
+        group_id = mgr.get_group_id_by_session(sid)
+        if not group_id:
+            return web.json_response({"error": "session 不存在"}, status=404)
+        group = mgr.get_group(group_id)
+        if not group:
+            return web.json_response({"error": "群已不存在"}, status=404)
+        return web.json_response({"session_id": sid, "group_id": group_id, "group": self._enrich_group_dict(group.to_dict())})
+
     # ── [v1.23.37] Agent间私聊记录 API ──
 
     async def handle_get_agent_chat_pairs(self, request):