super-code-assistant 3.3.6__py3-none-any.whl

features/skills.py

@@ -0,0 +1,300 @@
+"""Skill system — load, register, and execute SKILL.md-based skills."""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Callable
+
+
+# ---------------------------------------------------------------------------
+# Skill definition
+# ---------------------------------------------------------------------------
+
+@dataclass
+class Skill:
+    name: str
+    description: str = ""
+    when_to_use: str = ""
+    user_invocable: bool = True
+    context: str = "inline"         # "inline" 注入当前对话 / "fork" 独立子会话
+    argument_hint: str = ""
+    source: str = "project"         # "bundled" / "project" / "user"
+    skill_root: str | None = None   # 用于 $SKILL_DIR 变量替换的基础目录
+
+    # ── 扩展字段 ───────────────────────────────────────────────────────────
+    # 解析后仅存储，目标 1（字段对齐）阶段不强制行为；目标 2（自动触发）启用后才生效。
+    # 这样外部 SKILL.md 可以直接复制进来不报错、字段不丢失。
+    allowed_tools: list[str] = field(default_factory=list)  # 限制 skill 可调用工具，空列表 = 不限制
+    model: str = ""                                          # 指定 skill 偏好的模型，空 = 沿用主对话
+    disable_model_invocation: bool = False                  # True = 仅允许用户 /<name> 手动触发
+
+    _prompt_text: str = ""
+    _prompt_fn: Callable[[str], str] | None = None
+
+    def get_prompt(self, args: str = "") -> str:
+        """返回最终提示词，替换变量。"""
+        if self._prompt_fn is not None:
+            return self._prompt_fn(args)
+        text = self._prompt_text
+        text = text.replace("$ARGUMENTS", args)
+        if self.skill_root:
+            text = text.replace("${CLAUDE_SKILL_DIR}", self.skill_root)
+        if args and self.argument_hint:
+            text = text.replace(f"${{{self.argument_hint}}}", args)
+        return text
+
+
+# ---------------------------------------------------------------------------
+# YAML frontmatter parser（最小实现，无 PyYAML 依赖）
+# ---------------------------------------------------------------------------
+
+_FRONTMATTER_RE = re.compile(r"^---\s*\n(.*?)\n---\s*\n?", re.DOTALL)
+
+#标识哪些字段被认为是列表类型，可以采用逗号分隔
+_LIST_FIELDS = {"allowed_tools"}
+
+
+def _parse_frontmatter(text: str) -> tuple[dict[str, Any], str]:
+    """将 SKILL.md 文本拆分为 (frontmatter_dict, body)。
+
+    支持 YAML 续行：以空格/制表符缩进开头的行视为前一字段的续行，
+    用单个空格连接拼到前一字段值上。典型场景：
+        description: Use this skill whenever the user wants to do anything with
+          PDF files. This includes reading or extracting text/tables ...
+    没有续行支持时 description 只保留第一行，模型读不到完整触发条件。
+    """
+    m = _FRONTMATTER_RE.match(text)
+    if not m:
+        return {}, text
+    raw = m.group(1)
+    body = text[m.end():]
+
+    # 第一遍：识别"key: value"行 + 续行（缩进开头），把多行 value 拼回单行
+    pairs: list[tuple[str, str]] = []
+    for line in raw.splitlines():
+        if not line.strip() or line.strip().startswith("#"):
+            continue
+        # 续行判定：行首是空白 + 已有累积字段 → 拼到前一字段
+        if line[:1] in (" ", "\t") and pairs:
+            cont = line.strip()
+            if cont:
+                key, prev = pairs[-1]
+                pairs[-1] = (key, (prev + " " + cont).strip() if prev else cont)
+            continue
+        if ":" not in line:
+            continue
+        key, _, val = line.partition(":")
+        pairs.append((key.strip().lower().replace("-", "_"), val.strip()))
+
+    # 第二遍：类型推断
+    meta: dict[str, Any] = {}
+    for key, val in pairs:
+        if val.lower() in ("true", "yes"):
+            meta[key] = True
+        elif val.lower() in ("false", "no"):
+            meta[key] = False
+        elif key in _LIST_FIELDS and "," in val:
+            # 仅已知列表字段才按逗号切分，避免 description/when_to_use 等被误切
+            meta[key] = [v.strip() for v in val.split(",") if v.strip()]
+        elif (val.startswith('"') and val.endswith('"')) or \
+             (val.startswith("'") and val.endswith("'")):
+            meta[key] = val[1:-1]
+        else:
+            meta[key] = val
+    return meta, body
+
+
+def _ensure_str(val: Any, default: str = "") -> str:
+    """将任意类型安全转为字符串（列表则 join）。"""
+    if val is None:
+        return default
+    if isinstance(val, list):
+        return ", ".join(str(v) for v in val)
+    return str(val)
+
+
+def _skill_from_frontmatter(meta: dict[str, Any], body: str,
+                             name: str, source: str,
+                             skill_root: str | None = None) -> Skill:
+    """根据解析的 frontmatter 和 body 构建 Skill 对象。"""
+    # argument-hint 是标准字段名（经 _parse_frontmatter 规范化后变成
+    # argument_hint）；早期版本写的是 arguments，两者都兼容，前者优先。
+    arg_hint = meta.get("argument_hint")
+    if not arg_hint:
+        arg_hint = meta.get("arguments")
+
+    # allowed-tools：标准 frontmatter 通常是 "Read, Write, Bash" 这样的逗号串。
+    # _parse_frontmatter 对已知列表字段会切成 list，但用户也可能写成单值字符串，
+    # 这里统一规整为 list[str]。
+    raw_allowed = meta.get("allowed_tools")
+    if isinstance(raw_allowed, list):
+        allowed_tools = [str(t).strip() for t in raw_allowed if str(t).strip()]
+    elif isinstance(raw_allowed, str) and raw_allowed.strip():
+        allowed_tools = [t.strip() for t in raw_allowed.split(",") if t.strip()]
+    else:
+        allowed_tools = []
+
+    return Skill(
+        name=_ensure_str(meta.get("name"), name),
+        description=_ensure_str(meta.get("description")),
+        when_to_use=_ensure_str(meta.get("when_to_use")),
+        user_invocable=meta.get("user_invocable", True),
+        context=_ensure_str(meta.get("context"), "inline"),
+        argument_hint=_ensure_str(arg_hint),
+        source=source,
+        skill_root=skill_root,
+        allowed_tools=allowed_tools,
+        model=_ensure_str(meta.get("model")),
+        disable_model_invocation=bool(meta.get("disable_model_invocation", False)),
+        _prompt_text=body.strip(),
+    )
+
+
+# ---------------------------------------------------------------------------
+# Skill registry（全局注册表）
+# ---------------------------------------------------------------------------
+
+_REGISTRY: dict[str, Skill] = {}
+
+# 本进程内"已被调用过的 skill 名称"集合。压缩流程会读取它做 Phase B 重注入，
+# 让模型在压缩之后仍知道之前调用过哪些 skill 的指令内容。
+# 进程级状态（不持久化、不跨会话）：/resume 一个老 session 时该集合为空，
+# 老对话里的 skill body 仍在 messages 中能进入 history 被总结，无需重注入。
+_INVOKED_SKILLS: set[str] = set()
+
+
+def mark_skill_invoked(name: str) -> None:
+    """记录一次 skill 调用。两条调用路径（用户 /<name> 与模型 SkillTool）都会调本函数。"""
+    if name:
+        _INVOKED_SKILLS.add(name)
+
+
+def get_invoked_skills() -> list[str]:
+    """返回本进程内调用过的 skill 名称（按字母序）。压缩重注入用。"""
+    return sorted(_INVOKED_SKILLS)
+
+
+def clear_invoked_skills() -> None:
+    """清空调用记录。测试或 /clear 命令调用。"""
+    _INVOKED_SKILLS.clear()
+
+
+def register_skill(skill: Skill) -> None:
+    """将 skill 注册到全局注册表。"""
+    _REGISTRY[skill.name] = skill
+
+
+def get_skill(name: str) -> Skill | None:
+    """按名称查找 skill。"""
+    return _REGISTRY.get(name)
+
+
+def list_skills(user_invocable_only: bool = True) -> list[Skill]:
+    """返回所有已注册的 skill，可选只返回用户可调用的。"""
+    skills = list(_REGISTRY.values())
+    if user_invocable_only:
+        skills = [s for s in skills if s.user_invocable]
+    return sorted(skills, key=lambda s: (s.source != "bundled", s.name))
+
+
+def clear_skills(source: str | None = None) -> None:
+    """清除注册表，可选只清除指定来源的 skill。"""
+    if source is None:
+        _REGISTRY.clear()
+    else:
+        for k in [k for k, v in _REGISTRY.items() if v.source == source]:
+            del _REGISTRY[k]
+
+
+# ---------------------------------------------------------------------------
+# Skill discovery from disk
+# ---------------------------------------------------------------------------
+
+def load_skills_from_dir(skills_dir: Path, source: str = "project") -> list[Skill]:
+    """扫描 skills_dir 下的 <name>/SKILL.md 并注册每个 skill。"""
+    loaded: list[Skill] = []
+    if not skills_dir.is_dir():
+        return loaded
+    for entry in sorted(skills_dir.iterdir()):
+        skill = None
+        if entry.is_dir():
+            skill_md = entry / "SKILL.md"
+            if not skill_md.exists():
+                md_files = list(entry.glob("*.md"))
+                skill_md = md_files[0] if md_files else None
+            if skill_md is None:
+                continue
+            try:
+                text = skill_md.read_text(encoding="utf-8")
+            except Exception:
+                continue
+            meta, body = _parse_frontmatter(text)
+            skill = _skill_from_frontmatter(meta, body, name=entry.name,
+                                            source=source, skill_root=str(entry))
+        elif entry.suffix == ".md" and entry.is_file():
+            try:
+                text = entry.read_text(encoding="utf-8")
+            except Exception:
+                continue
+            meta, body = _parse_frontmatter(text)
+            skill = _skill_from_frontmatter(meta, body, name=entry.stem,
+                                            source=source, skill_root=str(entry.parent))
+        if skill and skill._prompt_text:
+            register_skill(skill)
+            loaded.append(skill)
+    return loaded
+
+
+def discover_skills(cwd: str | None = None) -> list[Skill]:
+    """从标准位置发现并注册 skill。
+
+    搜索顺序（同名 skill 后扫描者覆盖前者）：
+      1. 用户级(HOME)：~/.config/super-code/skills/
+      2. 便携级(exe同级)：<exe目录>/skills/
+      3. 项目级(当前目录)：{cwd}/.super-code/skills/
+    """
+    loaded: list[Skill] = []
+    home = Path.home()
+    loaded.extend(load_skills_from_dir(home / ".config" / "super-code" / "skills", source="user"))
+    from core.config import get_portable_dir
+    loaded.extend(load_skills_from_dir(get_portable_dir() / "skills", source="portable"))
+    if cwd:
+        loaded.extend(load_skills_from_dir(Path(cwd) / ".super-code" / "skills", source="project"))
+    return loaded
+
+
+# ---------------------------------------------------------------------------
+# System prompt section
+# ---------------------------------------------------------------------------
+
+def build_skills_prompt_section() -> str:
+    """生成 skill 列表文本，拼接到系统提示词中，让模型知道可用的 skill。
+
+    输出含两段：
+      1) 用法说明：告诉模型如何用 Skill 工具自主调用，以及和用户手动 /<name> 的差异
+      2) skill 索引：每个 skill 的 name + description(+ when_to_use)，仅作触发判据
+
+    disable_model_invocation=true 的 skill 仍出现在索引里，便于模型识别用户意图
+    后建议用户手动 /<name>；SkillTool.execute 会真正拒绝模型对它们的调用。
+    """
+    skills = list_skills(user_invocable_only=False)
+    if not skills:
+        return ""
+    lines = [
+        "# Available Skills",
+        "",
+        "When the user's request matches one of these skills, prefer invoking it "
+        "via the Skill tool: `Skill(name=\"<skill-name>\", args=\"<user args>\")`. "
+        "The user can also trigger any skill manually by typing `/<skill-name> args`.",
+        "",
+    ]
+    for s in skills:
+        desc = s.description or "(no description)"
+        line = f"- {s.name}: {desc}"
+        if s.when_to_use:
+            line += f" — {s.when_to_use}"
+        if s.disable_model_invocation:
+            line += "  [user-only: suggest /<name> instead of calling Skill tool]"
+        lines.append(line)
+    return "\n".join(lines)

features/worker_manager.py

@@ -0,0 +1,232 @@
+from __future__ import annotations
+
+import threading
+import time
+import uuid
+from dataclasses import dataclass, field
+from queue import Empty, Queue
+from typing import Callable
+from xml.sax.saxutils import escape
+
+from core.engine import AbortedError, Engine
+
+
+@dataclass
+class WorkerUsage:
+    total_tokens: int = 0
+    tool_uses: int = 0
+    duration_ms: int = 0
+
+
+@dataclass
+class WorkerTask:
+    """表示一个后台 worker 任务。"""
+    task_id: str
+    description: str
+    engine: Engine
+    status: str = "idle"
+    summary: str = ""
+    result: str = ""
+    usage: WorkerUsage = field(default_factory=WorkerUsage)
+    thread: threading.Thread | None = None
+    tool_use_count: int = 0       # 已调用工具次数，用于实时状态显示
+    current_activity: str = ""    # 当前活动描述，用于实时状态显示
+
+
+class WorkerManager:
+    """管理后台 worker 线程的生命周期：spawn / continue / stop / 通知队列。"""
+
+    def __init__(self, build_worker_engine: Callable[[], Engine]):
+        self._build_worker_engine = build_worker_engine
+        self._tasks: dict[str, WorkerTask] = {}
+        self._lock = threading.Lock()           # 多线程访问 _tasks 需要加锁
+        self._notifications: Queue[str] = Queue()  # 线程安全的通知队列
+
+    def spawn(self, *, description: str, prompt: str,
+              subagent_type: str = "worker") -> dict[str, str]:
+        """启动一个新的 worker 任务，返回 task_id。"""
+        if subagent_type != "worker":
+            raise ValueError("Only subagent_type='worker' is supported.")
+
+        task = WorkerTask(
+            task_id=f"agent-{uuid.uuid4().hex[:8]}",
+            description=description.strip() or "Worker task",
+            engine=self._build_worker_engine(),  # 每个 worker 独立的 engine 实例
+        )
+        with self._lock:
+            self._tasks[task.task_id] = task
+        self._start(task, prompt)
+        return {"task_id": task.task_id, "status": "started", "description": task.description}
+
+    def continue_task(self, *, task_id: str, message: str) -> dict[str, str]:
+        """继续一个已完成的 worker 任务（SendMessage）。"""
+        task = self._get_task(task_id)
+        if self._is_running(task):
+            raise ValueError("Task is still running. Wait for it to finish before continuing it.")
+        self._start(task, message)
+        return {"task_id": task.task_id, "status": "started", "description": task.description}
+
+    def stop_task(self, *, task_id: str) -> dict[str, str]:
+        """中止一个正在运行的 worker 任务。"""
+        task = self._get_task(task_id)
+        if not self._is_running(task):
+            return {"task_id": task.task_id, "status": task.status or "idle",
+                    "description": task.description}
+        try:
+            task.engine.abort()
+        except Exception:
+            pass
+        return {"task_id": task.task_id, "status": "stopping", "description": task.description}
+
+    def drain_notifications(self) -> list[str]:
+        """取出队列中所有已完成任务的通知（非阻塞）。"""
+        drained: list[str] = []
+        while True:
+            try:
+                drained.append(self._notifications.get_nowait())
+            except Empty:
+                return drained
+
+    def has_running_tasks(self) -> bool:
+        """是否有正在运行的 worker。"""
+        with self._lock:
+            return any(self._is_running(t) for t in self._tasks.values())
+
+    def get_running_status(self) -> list[dict]:
+        """返回所有正在运行 worker 的实时状态。"""
+        with self._lock:
+            return [
+                {"task_id": t.task_id, "description": t.description,
+                 "tool_uses": t.tool_use_count, "activity": t.current_activity}
+                for t in self._tasks.values()
+                if self._is_running(t)
+            ]
+
+    def get_panel_status(self) -> list[dict]:
+        """返回进度面板所需的全部 worker 状态（运行中 + 已完成，按 spawn 序）。
+
+        与 get_running_status 的区别：不筛选运行态，附带 status 字段
+        （running/completed/killed/failed），供面板显示完成态（✓/✗）。
+        线程安全（_lock 保护）；status 的最终写发生在 worker 线程结束处。
+        """
+        with self._lock:
+            return [
+                {"task_id": t.task_id, "description": t.description,
+                 "tool_uses": t.tool_use_count, "activity": t.current_activity,
+                 "status": "running" if self._is_running(t) else t.status}
+                for t in self._tasks.values()
+            ]
+
+    def clear_finished(self) -> None:
+        """清除所有已结束任务的记录（保留仍在运行的）。
+
+        供主循环在用户提交新一轮输入时调用：完成态面板只保留到下一轮输入，
+        之后不再占用输入框上方空间；运行中的任务不受影响（继续展示进度）。
+        """
+        with self._lock:
+            for task_id in [tid for tid, t in self._tasks.items()
+                            if not self._is_running(t)]:
+                del self._tasks[task_id]
+
+    def _get_task(self, task_id: str) -> WorkerTask:
+        with self._lock:
+            task = self._tasks.get(task_id)
+        if task is None:
+            raise ValueError(f"Unknown task id: {task_id}")
+        return task
+
+    @staticmethod
+    def _is_running(task: WorkerTask) -> bool:
+        return task.thread is not None and task.thread.is_alive()
+
+    def _start(self, task: WorkerTask, prompt: str) -> None:
+        """在后台线程中启动任务。"""
+        task.status = "running"
+        task.summary = ""
+        task.result = ""
+        task.usage = WorkerUsage()
+        task.thread = threading.Thread(
+            target=self._run_task,          # 线程执行方法
+            name=task.task_id,
+            args=(task, prompt),
+            daemon=True,
+        )
+        task.thread.start()
+
+    def _run_task(self, task: WorkerTask, prompt: str) -> None:
+        """worker 线程主体：消费 engine.submit() 事件流，完成后推送通知。"""
+        started = time.monotonic()
+        parts: list[str] = []
+        total_tokens = 0
+        tool_uses = 0
+        task.tool_use_count = 0
+        task.current_activity = "Initializing…"
+        try:
+            for event in task.engine.submit(prompt):
+                kind = event[0]
+                if kind == "text":
+                    parts.append(event[1])
+                    task.current_activity = "Thinking…"
+                elif kind == "tool_call":
+                    tool_uses += 1
+                    task.tool_use_count = tool_uses
+                    tool_name = event[1] if len(event) > 1 else ""
+                    task.current_activity = f"Running {tool_name}…"
+                elif kind == "tool_result":
+                    task.current_activity = "Thinking…"
+                elif kind == "error":
+                    parts.append(event[1])
+            status = "completed"
+            summary = f'Agent "{task.description}" completed'
+        except AbortedError:
+            status = "killed"
+            summary = f'Agent "{task.description}" was stopped'
+        except Exception as exc:
+            status = "failed"
+            summary = f'Agent "{task.description}" failed: {exc}'
+            parts.append(str(exc))
+
+        task.status = status
+        task.summary = summary
+        task.current_activity = ""
+        task.result = "".join(parts).strip()
+        task.usage = WorkerUsage(
+            total_tokens=total_tokens,
+            tool_uses=tool_uses,
+            duration_ms=int((time.monotonic() - started) * 1000),
+        )
+        self._notifications.put(self._render_notification(task))
+
+    def _render_notification(self, task: WorkerTask) -> str:
+        """将任务结果序列化为 XML 风格的 <task-notification> 字符串。
+
+            示例：
+                <task-notification>
+                    <task-id>agent-a1b2c3d4</task-id>
+                    <status>completed</status>
+                    <summary>Agent &quot;代码重构&quot; completed</summary>
+                    <result>已成功将 utils.py 中的函数提取到 helper.py</result>
+                    <usage>
+                      <total_tokens>1500</total_tokens>
+                      <tool_uses>3</tool_uses>
+                      <duration_ms>5200</duration_ms>
+                    </usage>
+                </task-notification>
+        """
+        parts = [
+            "<task-notification>",
+            f"<task-id>{escape(task.task_id)}</task-id>",
+            f"<status>{escape(task.status)}</status>",
+            f"<summary>{escape(task.summary)}</summary>",
+        ]
+        if task.result:
+            parts.append(f"<result>{escape(task.result)}</result>")
+        parts.extend([
+            "<usage>",
+            f"  <total_tokens>{task.usage.total_tokens}</total_tokens>",
+            f"  <tool_uses>{task.usage.tool_uses}</tool_uses>",
+            f"  <duration_ms>{task.usage.duration_ms}</duration_ms>",
+            "</usage>",
+            "</task-notification>",
+        ])
+        return "\n".join(parts)

mcp/client.py

@@ -0,0 +1,112 @@
+"""MCP Client — 通过 stdio 与 MCP server 子进程通信。
+
+MCP 协议简介：
+  - 传输层：子进程的 stdin/stdout，每条消息是一行 JSON（JSON-RPC 2.0）
+  - 握手流程：client 发 initialize → server 回 result → client 发 initialized 通知
+  - 获取工具：发 tools/list → server 返回工具列表（name, description, inputSchema）
+  - 调用工具：发 tools/call → server 返回 content 列表
+"""
+from __future__ import annotations
+
+import json
+import subprocess
+import threading
+from typing import Any
+
+
+class MCPError(Exception):
+    pass
+
+
+class MCPClient:
+    """管理单个 MCP server 子进程的生命周期和 JSON-RPC 通信。"""
+
+    def __init__(self, name: str, command: str, args: list[str], env: dict[str, str] | None = None):
+        self.name = name
+        self._proc = subprocess.Popen(
+            [command, *args],
+            stdin=subprocess.PIPE,      # 向子进程发送数据
+            stdout=subprocess.PIPE,     # 从子进程接收数据
+            stderr=subprocess.DEVNULL,  # 忽略 server 的调试输出
+            env=env,                    # 子进程的环境变量，默认继承父进程环境
+            text=True,                  # 用文本模式，而不是bytes
+            encoding="utf-8",           # 
+        )
+        self._lock = threading.Lock()  # 保证多线程下请求串行，避免消息交错
+        self._next_id = 1
+        self._handshake()
+
+    # ------------------------------------------------------------------ #
+    # 公开接口
+    # ------------------------------------------------------------------ #
+
+    def list_tools(self) -> list[dict[str, Any]]:
+        """返回 server 暴露的工具列表，每项含 name / description / inputSchema。"""
+        result = self._call("tools/list", {})
+        return result.get("tools", [])
+
+    def call_tool(self, tool_name: str, arguments: dict[str, Any]) -> str:
+        """调用指定工具，返回纯文本结果。"""
+        result = self._call("tools/call", {"name": tool_name, "arguments": arguments})
+        # MCP 返回 content 列表，每项有 type 和 text
+        parts = [
+            item.get("text", "")
+            for item in result.get("content", [])
+            if item.get("type") == "text"
+        ]
+        return "\n".join(parts) or "(no output)"
+
+    def close(self):
+        try:
+            self._proc.terminate()
+        except Exception:
+            pass
+
+    # ------------------------------------------------------------------ #
+    # 内部实现
+    # ------------------------------------------------------------------ #
+
+    def _handshake(self):
+        """MCP 握手：initialize → initialized。必须在首次 tools/list 之前完成。"""
+        self._call("initialize", {
+            "protocolVersion": "2024-11-05",
+            "capabilities": {},
+            "clientInfo": {"name": "super-code", "version": "1.0"},
+        })
+        # initialized 是通知（notification），没有 id，不等待响应
+        self._send({"jsonrpc": "2.0", "method": "notifications/initialized"})
+
+    def _call(self, method: str, params: dict) -> dict[str, Any]:
+        """发送 JSON-RPC 请求并等待对应响应。"""
+        with self._lock:
+            req_id = self._next_id
+            self._next_id += 1
+            self._send({"jsonrpc": "2.0", "id": req_id, "method": method, "params": params})
+            return self._recv(req_id)
+
+    def _send(self, obj: dict):
+        line = json.dumps(obj, ensure_ascii=False) + "\n"
+        self._proc.stdin.write(line)
+        self._proc.stdin.flush()
+
+    def _recv(self, expected_id: int) -> dict[str, Any]:
+        """
+            读取行 直到收到匹配 id 的响应（跳过 server 主动推送的通知）。
+            发出去的id，要和响应的id对起来
+        """
+        while True:
+            line = self._proc.stdout.readline()
+            if not line:
+                raise MCPError(f"MCP server '{self.name}' closed unexpectedly")
+            try:
+                msg = json.loads(line)
+            except json.JSONDecodeError:
+                continue  # 忽略非 JSON 行（server 可能输出日志）
+            # 通知没有 id，跳过
+            if "id" not in msg:
+                continue
+            if msg["id"] != expected_id:    # 发出去的id，要和响应的id对起来
+                continue  # 不属于本次请求，继续等
+            if "error" in msg:
+                raise MCPError(f"MCP error: {msg['error']}")
+            return msg.get("result", {})