feat(agent): unify tool calling around MCP and add /api/mcp endpoint

domain/agent/service.py

@@ -8,27 +8,27 @@ from fastapi import HTTPException
 
 from domain.ai import AIProviderService, MissingModelError, chat_completion, chat_completion_stream
 from domain.auth import User
-from .tools import get_tool, openai_tools, tool_result_to_content
-from .types import AgentChatRequest, PendingToolCall
+
+from .mcp import mcp_client_session, mcp_content_to_text
+from .tools import tool_result_to_content
+from .types import AgentChatRequest, PendingMcpCall
 
 
-def _normalize_path(p: Optional[str]) -> Optional[str]:
-    if not p:
+def _normalize_path(path: Optional[str]) -> Optional[str]:
+    if not path:
         return None
-    s = str(p).strip()
-    if not s:
+    value = str(path).strip().replace("\\", "/")
+    if not value:
         return None
-    s = s.replace("\\", "/")
-    if not s.startswith("/"):
-        s = "/" + s
-    s = s.rstrip("/") or "/"
-    return s
+    if not value.startswith("/"):
+        value = "/" + value
+    return value.rstrip("/") or "/"
 
 
 def _build_system_prompt(current_path: Optional[str]) -> str:
     lines = [
         "你是 Foxel 的 AI 助手。",
-        "你可以通过工具对文件/目录进行查询、读写、移动、复制、删除，以及运行处理器（processor）。",
+        "你可以通过 MCP 工具对文件/目录进行查询、读写、移动、复制、删除，以及运行处理器（processor）。",
         "",
         "可用工具：",
         "- time：获取服务器当前时间（精确到秒，英文星期），支持 year/month/day/hour/minute/second 偏移。",
@@ -60,13 +60,13 @@ def _build_system_prompt(current_path: Optional[str]) -> str:
     return "\n".join(lines)
 
 
-def _ensure_tool_call_ids(message: Dict[str, Any]) -> Dict[str, Any]:
-    tool_calls = message.get("tool_calls")
-    if not isinstance(tool_calls, list):
+def _ensure_mcp_call_ids(message: Dict[str, Any]) -> Dict[str, Any]:
+    mcp_calls = message.get("mcp_calls")
+    if not isinstance(mcp_calls, list):
         return message
 
     changed = False
-    for idx, call in enumerate(tool_calls):
+    for idx, call in enumerate(mcp_calls):
         if not isinstance(call, dict):
             continue
         call_id = call.get("id")
@@ -76,57 +76,54 @@ def _ensure_tool_call_ids(message: Dict[str, Any]) -> Dict[str, Any]:
         changed = True
 
     if changed:
-        message["tool_calls"] = tool_calls
+        message["mcp_calls"] = mcp_calls
     return message
 
 
-def _extract_pending(tool_call: Dict[str, Any], requires_confirmation: bool) -> PendingToolCall:
-    call_id = str(tool_call.get("id") or "")
-    fn = tool_call.get("function") or {}
-    name = str((fn.get("name") if isinstance(fn, dict) else None) or "")
-    raw_args = fn.get("arguments") if isinstance(fn, dict) else None
-    arguments: Dict[str, Any] = {}
-    if isinstance(raw_args, str) and raw_args.strip():
-        try:
-            parsed = json.loads(raw_args)
-            if isinstance(parsed, dict):
-                arguments = parsed
-        except json.JSONDecodeError:
-            arguments = {}
-    return PendingToolCall(
-        id=call_id,
-        name=name,
+def _extract_pending(mcp_call: Dict[str, Any], requires_confirmation: bool) -> PendingMcpCall:
+    arguments = mcp_call.get("arguments") if isinstance(mcp_call.get("arguments"), dict) else {}
+    return PendingMcpCall(
+        id=str(mcp_call.get("id") or ""),
+        name=str(mcp_call.get("name") or ""),
         arguments=arguments,
         requires_confirmation=requires_confirmation,
     )
 
 
-def _find_last_assistant_tool_calls(messages: List[Dict[str, Any]]) -> Tuple[int, Dict[str, Any]]:
+def _find_last_assistant_mcp_calls(messages: List[Dict[str, Any]]) -> Tuple[int, Dict[str, Any]]:
     for idx in range(len(messages) - 1, -1, -1):
         msg = messages[idx]
         if not isinstance(msg, dict):
             continue
         if msg.get("role") != "assistant":
             continue
-        tool_calls = msg.get("tool_calls")
-        if isinstance(tool_calls, list) and tool_calls:
+        mcp_calls = msg.get("mcp_calls")
+        if isinstance(mcp_calls, list) and mcp_calls:
             return idx, msg
     raise HTTPException(status_code=400, detail="没有可确认的待执行操作")
 
 
-def _existing_tool_result_ids(messages: List[Dict[str, Any]]) -> set[str]:
+def _existing_mcp_result_ids(messages: List[Dict[str, Any]]) -> set[str]:
     ids: set[str] = set()
     for msg in messages:
         if not isinstance(msg, dict):
             continue
         if msg.get("role") != "tool":
             continue
-        tool_call_id = msg.get("tool_call_id")
-        if isinstance(tool_call_id, str) and tool_call_id.strip():
-            ids.add(tool_call_id)
+        call_id = msg.get("mcp_call_id")
+        if isinstance(call_id, str) and call_id.strip():
+            ids.add(call_id)
     return ids
 
 
+def _tool_requires_confirmation(tool_descriptor: Dict[str, Any]) -> bool:
+    meta = tool_descriptor.get("meta") if isinstance(tool_descriptor.get("meta"), dict) else {}
+    if "requires_confirmation" in meta:
+        return bool(meta.get("requires_confirmation"))
+    annotations = tool_descriptor.get("annotations") if isinstance(tool_descriptor.get("annotations"), dict) else {}
+    return not bool(annotations.get("readOnlyHint"))
+
+
 async def _choose_chat_ability() -> str:
     tools_model = await AIProviderService.get_default_model("tools")
     return "tools" if tools_model else "chat"
@@ -142,245 +139,91 @@ def _format_exc(exc: BaseException) -> str:
     return text if text else exc.__class__.__name__
 
 
+async def _list_mcp_tools(session) -> List[Dict[str, Any]]:
+    result = await session.list_tools()
+    tools: List[Dict[str, Any]] = []
+    for item in result.tools:
+        annotations = getattr(item, "annotations", None)
+        meta = getattr(item, "meta", None)
+        tools.append(
+            {
+                "name": str(getattr(item, "name", "") or ""),
+                "description": str(getattr(item, "description", "") or ""),
+                "input_schema": getattr(item, "inputSchema", None) or {},
+                "annotations": annotations.model_dump(exclude_none=True) if annotations is not None else {},
+                "meta": meta if isinstance(meta, dict) else {},
+            }
+        )
+    return tools
+
+
+async def _execute_mcp_call(session, name: str, arguments: Dict[str, Any]) -> str:
+    result = await session.call_tool(name, arguments)
+    return mcp_content_to_text(result.content, result.structuredContent)
+
+
 class AgentService:
     @classmethod
     async def chat(cls, req: AgentChatRequest, user: Optional[User]) -> Dict[str, Any]:
         history: List[Dict[str, Any]] = list(req.messages or [])
         current_path = _normalize_path(req.context.current_path if req.context else None)
-
         system_prompt = _build_system_prompt(current_path)
         internal_messages: List[Dict[str, Any]] = [{"role": "system", "content": system_prompt}] + history
-
         new_messages: List[Dict[str, Any]] = []
-        pending: List[PendingToolCall] = []
+        pending: List[PendingMcpCall] = []
 
-        approved_ids = {i for i in (req.approved_tool_call_ids or []) if isinstance(i, str) and i.strip()}
-        rejected_ids = {i for i in (req.rejected_tool_call_ids or []) if isinstance(i, str) and i.strip()}
+        approved_ids = {i for i in (req.approved_mcp_call_ids or []) if isinstance(i, str) and i.strip()}
+        rejected_ids = {i for i in (req.rejected_mcp_call_ids or []) if isinstance(i, str) and i.strip()}
 
-        if approved_ids or rejected_ids:
-            _, last_call_msg = _find_last_assistant_tool_calls(internal_messages)
-            last_call_msg = _ensure_tool_call_ids(last_call_msg)
-            tool_calls = last_call_msg.get("tool_calls") or []
-            call_map: Dict[str, Dict[str, Any]] = {
-                str(c.get("id")): c
-                for c in tool_calls
-                if isinstance(c, dict) and isinstance(c.get("id"), str)
-            }
+        async with mcp_client_session(user, current_path) as mcp_session:
+            tools_schema = await _list_mcp_tools(mcp_session)
+            tool_index = {tool["name"]: tool for tool in tools_schema if tool.get("name")}
 
-            existing_ids = _existing_tool_result_ids(internal_messages)
-            for call_id in approved_ids | rejected_ids:
-                if call_id in existing_ids:
-                    continue
-                tool_call = call_map.get(call_id)
-                if not tool_call:
-                    continue
-                fn = tool_call.get("function") or {}
-                name = fn.get("name") if isinstance(fn, dict) else None
-                args_raw = fn.get("arguments") if isinstance(fn, dict) else None
-                args: Dict[str, Any] = {}
-                if isinstance(args_raw, str) and args_raw.strip():
-                    try:
-                        parsed = json.loads(args_raw)
-                        if isinstance(parsed, dict):
-                            args = parsed
-                    except json.JSONDecodeError:
-                        args = {}
-
-                spec = get_tool(str(name or ""))
-                if call_id in rejected_ids:
-                    content = tool_result_to_content({"canceled": True, "reason": "user_rejected"})
-                    tool_msg = {"role": "tool", "tool_call_id": call_id, "content": content}
-                    internal_messages.append(tool_msg)
-                    new_messages.append(tool_msg)
-                    continue
-
-                if not spec:
-                    content = tool_result_to_content({"error": f"unknown_tool: {name}"})
-                    tool_msg = {"role": "tool", "tool_call_id": call_id, "content": content}
-                    internal_messages.append(tool_msg)
-                    new_messages.append(tool_msg)
-                    continue
-
-                try:
-                    result = await spec.handler(args)
-                    content = tool_result_to_content(result)
-                except Exception as exc:  # noqa: BLE001
-                    content = tool_result_to_content({"error": str(exc)})
-                tool_msg = {"role": "tool", "tool_call_id": call_id, "content": content}
-                internal_messages.append(tool_msg)
-                new_messages.append(tool_msg)
-
-        tools_schema = openai_tools()
-        ability = await _choose_chat_ability()
-        max_loops = 4
-
-        for _ in range(max_loops):
-            try:
-                assistant = await chat_completion(
-                    internal_messages,
-                    ability=ability,
-                    tools=tools_schema,
-                    tool_choice="auto",
-                    timeout=60.0,
-                )
-            except MissingModelError as exc:
-                raise HTTPException(status_code=400, detail=str(exc)) from exc
-            except httpx.HTTPStatusError as exc:
-                raise HTTPException(status_code=502, detail=f"对话请求失败: {exc}") from exc
-            except httpx.RequestError as exc:
-                raise HTTPException(status_code=502, detail=f"对话请求异常: {exc}") from exc
-
-            assistant = _ensure_tool_call_ids(assistant)
-            internal_messages.append(assistant)
-            new_messages.append(assistant)
-
-            tool_calls = assistant.get("tool_calls")
-            if not isinstance(tool_calls, list) or not tool_calls:
-                break
-
-            pending = []
-            for call in tool_calls:
-                if not isinstance(call, dict):
-                    continue
-                call_id = str(call.get("id") or "")
-                fn = call.get("function") or {}
-                name = fn.get("name") if isinstance(fn, dict) else None
-                args_raw = fn.get("arguments") if isinstance(fn, dict) else None
-                args: Dict[str, Any] = {}
-                if isinstance(args_raw, str) and args_raw.strip():
-                    try:
-                        parsed = json.loads(args_raw)
-                        if isinstance(parsed, dict):
-                            args = parsed
-                    except json.JSONDecodeError:
-                        args = {}
-
-                spec = get_tool(str(name or ""))
-                if not spec:
-                    content = tool_result_to_content({"error": f"unknown_tool: {name}"})
-                    tool_msg = {"role": "tool", "tool_call_id": call_id, "content": content}
-                    internal_messages.append(tool_msg)
-                    new_messages.append(tool_msg)
-                    continue
-
-                if spec.requires_confirmation and not req.auto_execute:
-                    pending.append(_extract_pending(call, True))
-                    continue
-
-                try:
-                    result = await spec.handler(args)
-                    content = tool_result_to_content(result)
-                except Exception as exc:  # noqa: BLE001
-                    content = tool_result_to_content({"error": str(exc)})
-                tool_msg = {"role": "tool", "tool_call_id": call_id, "content": content}
-                internal_messages.append(tool_msg)
-                new_messages.append(tool_msg)
-
-            if pending:
-                break
-
-        payload: Dict[str, Any] = {"messages": new_messages}
-        if pending:
-            payload["pending_tool_calls"] = [p.model_dump() for p in pending]
-        return payload
-
-    @classmethod
-    async def chat_stream(cls, req: AgentChatRequest, user: Optional[User]):
-        history: List[Dict[str, Any]] = list(req.messages or [])
-        current_path = _normalize_path(req.context.current_path if req.context else None)
-
-        system_prompt = _build_system_prompt(current_path)
-        internal_messages: List[Dict[str, Any]] = [{"role": "system", "content": system_prompt}] + history
-
-        new_messages: List[Dict[str, Any]] = []
-        pending: List[PendingToolCall] = []
-
-        approved_ids = {i for i in (req.approved_tool_call_ids or []) if isinstance(i, str) and i.strip()}
-        rejected_ids = {i for i in (req.rejected_tool_call_ids or []) if isinstance(i, str) and i.strip()}
-
-        try:
             if approved_ids or rejected_ids:
-                _, last_call_msg = _find_last_assistant_tool_calls(internal_messages)
-                last_call_msg = _ensure_tool_call_ids(last_call_msg)
-                tool_calls = last_call_msg.get("tool_calls") or []
+                _, last_call_msg = _find_last_assistant_mcp_calls(internal_messages)
+                last_call_msg = _ensure_mcp_call_ids(last_call_msg)
+                mcp_calls = last_call_msg.get("mcp_calls") or []
                 call_map: Dict[str, Dict[str, Any]] = {
-                    str(c.get("id")): c
-                    for c in tool_calls
-                    if isinstance(c, dict) and isinstance(c.get("id"), str)
+                    str(call.get("id")): call
+                    for call in mcp_calls
+                    if isinstance(call, dict) and isinstance(call.get("id"), str)
                 }
 
-                existing_ids = _existing_tool_result_ids(internal_messages)
+                existing_ids = _existing_mcp_result_ids(internal_messages)
                 for call_id in approved_ids | rejected_ids:
                     if call_id in existing_ids:
                         continue
-                    tool_call = call_map.get(call_id)
-                    if not tool_call:
+                    mcp_call = call_map.get(call_id)
+                    if not mcp_call:
                         continue
-                    fn = tool_call.get("function") or {}
-                    name = fn.get("name") if isinstance(fn, dict) else None
-                    args_raw = fn.get("arguments") if isinstance(fn, dict) else None
-                    args: Dict[str, Any] = {}
-                    if isinstance(args_raw, str) and args_raw.strip():
-                        try:
-                            parsed = json.loads(args_raw)
-                            if isinstance(parsed, dict):
-                                args = parsed
-                        except json.JSONDecodeError:
-                            args = {}
+                    name = str(mcp_call.get("name") or "")
+                    arguments = mcp_call.get("arguments") if isinstance(mcp_call.get("arguments"), dict) else {}
+                    tool_desc = tool_index.get(name)
 
-                    spec = get_tool(str(name or ""))
                     if call_id in rejected_ids:
                         content = tool_result_to_content({"canceled": True, "reason": "user_rejected"})
-                        tool_msg = {"role": "tool", "tool_call_id": call_id, "content": content}
-                        internal_messages.append(tool_msg)
-                        new_messages.append(tool_msg)
-                        yield _sse("tool_end", {"tool_call_id": call_id, "name": str(name or ""), "message": tool_msg})
-                        continue
-
-                    if not spec:
+                    elif not tool_desc:
                         content = tool_result_to_content({"error": f"unknown_tool: {name}"})
-                        tool_msg = {"role": "tool", "tool_call_id": call_id, "content": content}
-                        internal_messages.append(tool_msg)
-                        new_messages.append(tool_msg)
-                        yield _sse("tool_end", {"tool_call_id": call_id, "name": str(name or ""), "message": tool_msg})
-                        continue
-
-                    yield _sse("tool_start", {"tool_call_id": call_id, "name": spec.name})
-                    try:
-                        result = await spec.handler(args)
-                        content = tool_result_to_content(result)
-                    except Exception as exc:  # noqa: BLE001
-                        content = tool_result_to_content({"error": str(exc)})
-                    tool_msg = {"role": "tool", "tool_call_id": call_id, "content": content}
+                    else:
+                        try:
+                            content = await _execute_mcp_call(mcp_session, name, arguments)
+                        except Exception as exc:  # noqa: BLE001
+                            content = tool_result_to_content({"error": str(exc)})
+                    tool_msg = {"role": "tool", "mcp_call_id": call_id, "content": content}
                     internal_messages.append(tool_msg)
                     new_messages.append(tool_msg)
-                    yield _sse("tool_end", {"tool_call_id": call_id, "name": spec.name, "message": tool_msg})
 
-            tools_schema = openai_tools()
             ability = await _choose_chat_ability()
-            max_loops = 4
 
-            for _ in range(max_loops):
-                assistant_event_id = uuid.uuid4().hex
-                yield _sse("assistant_start", {"id": assistant_event_id})
-
-                assistant_message: Dict[str, Any] | None = None
+            for _ in range(8):
                 try:
-                    async for event in chat_completion_stream(
+                    assistant = await chat_completion(
                         internal_messages,
                         ability=ability,
                         tools=tools_schema,
                         tool_choice="auto",
                         timeout=60.0,
-                    ):
-                        if event.get("type") == "delta":
-                            delta = event.get("delta")
-                            if isinstance(delta, str) and delta:
-                                yield _sse("assistant_delta", {"id": assistant_event_id, "delta": delta})
-                        elif event.get("type") == "message":
-                            msg = event.get("message")
-                            if isinstance(msg, dict):
-                                assistant_message = msg
+                    )
                 except MissingModelError as exc:
                     raise HTTPException(status_code=400, detail=_format_exc(exc)) from exc
                 except httpx.HTTPStatusError as exc:
@@ -388,66 +231,196 @@ class AgentService:
                 except httpx.RequestError as exc:
                     raise HTTPException(status_code=502, detail=f"对话请求异常: {_format_exc(exc)}") from exc
 
-                if not assistant_message:
-                    assistant_message = {"role": "assistant", "content": ""}
+                assistant = _ensure_mcp_call_ids(assistant if isinstance(assistant, dict) else {"role": "assistant", "content": ""})
+                internal_messages.append(assistant)
+                new_messages.append(assistant)
 
-                assistant_message = _ensure_tool_call_ids(assistant_message)
-                internal_messages.append(assistant_message)
-                new_messages.append(assistant_message)
-                yield _sse("assistant_end", {"id": assistant_event_id, "message": assistant_message})
-
-                tool_calls = assistant_message.get("tool_calls")
-                if not isinstance(tool_calls, list) or not tool_calls:
+                mcp_calls = assistant.get("mcp_calls")
+                if not isinstance(mcp_calls, list) or not mcp_calls:
                     break
 
                 pending = []
-                for call in tool_calls:
+                for call in mcp_calls:
                     if not isinstance(call, dict):
                         continue
                     call_id = str(call.get("id") or "")
-                    fn = call.get("function") or {}
-                    name = fn.get("name") if isinstance(fn, dict) else None
-                    args_raw = fn.get("arguments") if isinstance(fn, dict) else None
-                    args: Dict[str, Any] = {}
-                    if isinstance(args_raw, str) and args_raw.strip():
-                        try:
-                            parsed = json.loads(args_raw)
-                            if isinstance(parsed, dict):
-                                args = parsed
-                        except json.JSONDecodeError:
-                            args = {}
+                    name = str(call.get("name") or "")
+                    arguments = call.get("arguments") if isinstance(call.get("arguments"), dict) else {}
+                    tool_desc = tool_index.get(name)
 
-                    spec = get_tool(str(name or ""))
-                    if not spec:
+                    if not tool_desc:
                         content = tool_result_to_content({"error": f"unknown_tool: {name}"})
-                        tool_msg = {"role": "tool", "tool_call_id": call_id, "content": content}
+                        tool_msg = {"role": "tool", "mcp_call_id": call_id, "content": content}
                         internal_messages.append(tool_msg)
                         new_messages.append(tool_msg)
-                        yield _sse("tool_end", {"tool_call_id": call_id, "name": str(name or ""), "message": tool_msg})
                         continue
 
-                    if spec.requires_confirmation and not req.auto_execute:
+                    if _tool_requires_confirmation(tool_desc) and not req.auto_execute:
                         pending.append(_extract_pending(call, True))
                         continue
 
-                    yield _sse("tool_start", {"tool_call_id": call_id, "name": spec.name})
                     try:
-                        result = await spec.handler(args)
-                        content = tool_result_to_content(result)
+                        content = await _execute_mcp_call(mcp_session, name, arguments)
                     except Exception as exc:  # noqa: BLE001
                         content = tool_result_to_content({"error": str(exc)})
-                    tool_msg = {"role": "tool", "tool_call_id": call_id, "content": content}
+                    tool_msg = {"role": "tool", "mcp_call_id": call_id, "content": content}
                     internal_messages.append(tool_msg)
                     new_messages.append(tool_msg)
-                    yield _sse("tool_end", {"tool_call_id": call_id, "name": spec.name, "message": tool_msg})
 
                 if pending:
-                    yield _sse("pending", {"pending_tool_calls": [p.model_dump() for p in pending]})
                     break
 
+        payload: Dict[str, Any] = {"messages": new_messages}
+        if pending:
+            payload["pending_mcp_calls"] = [item.model_dump() for item in pending]
+        return payload
+
+    @classmethod
+    async def chat_stream(cls, req: AgentChatRequest, user: Optional[User]):
+        history: List[Dict[str, Any]] = list(req.messages or [])
+        current_path = _normalize_path(req.context.current_path if req.context else None)
+        system_prompt = _build_system_prompt(current_path)
+        internal_messages: List[Dict[str, Any]] = [{"role": "system", "content": system_prompt}] + history
+        new_messages: List[Dict[str, Any]] = []
+        pending: List[PendingMcpCall] = []
+
+        approved_ids = {i for i in (req.approved_mcp_call_ids or []) if isinstance(i, str) and i.strip()}
+        rejected_ids = {i for i in (req.rejected_mcp_call_ids or []) if isinstance(i, str) and i.strip()}
+
+        try:
+            async with mcp_client_session(user, current_path) as mcp_session:
+                tools_schema = await _list_mcp_tools(mcp_session)
+                tool_index = {tool["name"]: tool for tool in tools_schema if tool.get("name")}
+
+                if approved_ids or rejected_ids:
+                    _, last_call_msg = _find_last_assistant_mcp_calls(internal_messages)
+                    last_call_msg = _ensure_mcp_call_ids(last_call_msg)
+                    mcp_calls = last_call_msg.get("mcp_calls") or []
+                    call_map: Dict[str, Dict[str, Any]] = {
+                        str(call.get("id")): call
+                        for call in mcp_calls
+                        if isinstance(call, dict) and isinstance(call.get("id"), str)
+                    }
+
+                    existing_ids = _existing_mcp_result_ids(internal_messages)
+                    for call_id in approved_ids | rejected_ids:
+                        if call_id in existing_ids:
+                            continue
+                        mcp_call = call_map.get(call_id)
+                        if not mcp_call:
+                            continue
+
+                        name = str(mcp_call.get("name") or "")
+                        arguments = mcp_call.get("arguments") if isinstance(mcp_call.get("arguments"), dict) else {}
+                        tool_desc = tool_index.get(name)
+
+                        if call_id in rejected_ids:
+                            content = tool_result_to_content({"canceled": True, "reason": "user_rejected"})
+                            tool_msg = {"role": "tool", "mcp_call_id": call_id, "content": content}
+                            internal_messages.append(tool_msg)
+                            new_messages.append(tool_msg)
+                            yield _sse("mcp_call_end", {"mcp_call_id": call_id, "name": name, "message": tool_msg})
+                            continue
+
+                        if not tool_desc:
+                            content = tool_result_to_content({"error": f"unknown_tool: {name}"})
+                            tool_msg = {"role": "tool", "mcp_call_id": call_id, "content": content}
+                            internal_messages.append(tool_msg)
+                            new_messages.append(tool_msg)
+                            yield _sse("mcp_call_end", {"mcp_call_id": call_id, "name": name, "message": tool_msg})
+                            continue
+
+                        yield _sse("mcp_call_start", {"mcp_call_id": call_id, "name": name})
+                        try:
+                            content = await _execute_mcp_call(mcp_session, name, arguments)
+                        except Exception as exc:  # noqa: BLE001
+                            content = tool_result_to_content({"error": str(exc)})
+                        tool_msg = {"role": "tool", "mcp_call_id": call_id, "content": content}
+                        internal_messages.append(tool_msg)
+                        new_messages.append(tool_msg)
+                        yield _sse("mcp_call_end", {"mcp_call_id": call_id, "name": name, "message": tool_msg})
+
+                ability = await _choose_chat_ability()
+
+                for _ in range(8):
+                    assistant_event_id = str(uuid.uuid4())
+                    yield _sse("assistant_start", {"id": assistant_event_id})
+
+                    assistant_message: Dict[str, Any] | None = None
+                    try:
+                        async for event in chat_completion_stream(
+                            internal_messages,
+                            ability=ability,
+                            tools=tools_schema,
+                            tool_choice="auto",
+                            timeout=60.0,
+                        ):
+                            event_type = event.get("type")
+                            if event_type == "delta":
+                                delta = event.get("delta")
+                                if isinstance(delta, str) and delta:
+                                    yield _sse("assistant_delta", {"id": assistant_event_id, "delta": delta})
+                            elif event_type == "message":
+                                msg = event.get("message")
+                                if isinstance(msg, dict):
+                                    assistant_message = msg
+                    except MissingModelError as exc:
+                        raise HTTPException(status_code=400, detail=_format_exc(exc)) from exc
+                    except httpx.HTTPStatusError as exc:
+                        raise HTTPException(status_code=502, detail=f"对话请求失败: {_format_exc(exc)}") from exc
+                    except httpx.RequestError as exc:
+                        raise HTTPException(status_code=502, detail=f"对话请求异常: {_format_exc(exc)}") from exc
+
+                    if not assistant_message:
+                        assistant_message = {"role": "assistant", "content": ""}
+
+                    assistant_message = _ensure_mcp_call_ids(assistant_message)
+                    internal_messages.append(assistant_message)
+                    new_messages.append(assistant_message)
+                    yield _sse("assistant_end", {"id": assistant_event_id, "message": assistant_message})
+
+                    mcp_calls = assistant_message.get("mcp_calls")
+                    if not isinstance(mcp_calls, list) or not mcp_calls:
+                        break
+
+                    pending = []
+                    for call in mcp_calls:
+                        if not isinstance(call, dict):
+                            continue
+                        call_id = str(call.get("id") or "")
+                        name = str(call.get("name") or "")
+                        arguments = call.get("arguments") if isinstance(call.get("arguments"), dict) else {}
+                        tool_desc = tool_index.get(name)
+
+                        if not tool_desc:
+                            content = tool_result_to_content({"error": f"unknown_tool: {name}"})
+                            tool_msg = {"role": "tool", "mcp_call_id": call_id, "content": content}
+                            internal_messages.append(tool_msg)
+                            new_messages.append(tool_msg)
+                            yield _sse("mcp_call_end", {"mcp_call_id": call_id, "name": name, "message": tool_msg})
+                            continue
+
+                        if _tool_requires_confirmation(tool_desc) and not req.auto_execute:
+                            pending.append(_extract_pending(call, True))
+                            continue
+
+                        yield _sse("mcp_call_start", {"mcp_call_id": call_id, "name": name})
+                        try:
+                            content = await _execute_mcp_call(mcp_session, name, arguments)
+                        except Exception as exc:  # noqa: BLE001
+                            content = tool_result_to_content({"error": str(exc)})
+                        tool_msg = {"role": "tool", "mcp_call_id": call_id, "content": content}
+                        internal_messages.append(tool_msg)
+                        new_messages.append(tool_msg)
+                        yield _sse("mcp_call_end", {"mcp_call_id": call_id, "name": name, "message": tool_msg})
+
+                    if pending:
+                        yield _sse("pending", {"pending_mcp_calls": [item.model_dump() for item in pending]})
+                        break
+
             payload: Dict[str, Any] = {"messages": new_messages}
             if pending:
-                payload["pending_tool_calls"] = [p.model_dump() for p in pending]
+                payload["pending_mcp_calls"] = [item.model_dump() for item in pending]
             yield _sse("done", payload)
 
         except asyncio.CancelledError:
@@ -460,13 +433,11 @@ class AgentService:
             new_messages.append({"role": "assistant", "content": content})
             payload: Dict[str, Any] = {"messages": new_messages}
             if pending:
-                payload["pending_tool_calls"] = [p.model_dump() for p in pending]
+                payload["pending_mcp_calls"] = [item.model_dump() for item in pending]
             yield _sse("done", payload)
-            return
         except Exception as exc:  # noqa: BLE001
             new_messages.append({"role": "assistant", "content": f"服务端异常: {_format_exc(exc)}"})
             payload: Dict[str, Any] = {"messages": new_messages}
             if pending:
-                payload["pending_tool_calls"] = [p.model_dump() for p in pending]
+                payload["pending_mcp_calls"] = [item.model_dump() for item in pending]
             yield _sse("done", payload)
-            return