@tencent-rtc/trtc-agent-skills 0.1.3 → 0.1.4

package/skills/trtc-ai-service/scripts/verify-credentials.py

@@ -0,0 +1,108 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Three-key credential-less validation script (Phase 3 Stage 5).
+
+Design Goals
+------------
+**The "atomic tool" for AI-driven key configuration flow**:
+1. The AI writes user-pasted keys into ``.env`` via ``write_to_file``
+2. The AI calls ``python scripts/verify-credentials.py [--type tencent|trtc|llm]``
+3. This script **only** reads from .env / environment variables; it does **not** accept any keys as CLI arguments
+4. Outputs **structured JSON** to stdout; the AI parses it to determine ok / failure and responds per SKILL.md §5.5
+
+Output format (always valid JSON)::
+
+    Single: {"ok": true,  "type": "tencent", "error": "",     "message": "...", "latency_ms": 320}
+    Single: {"ok": false, "type": "trtc",    "error": "E002", "message": "...", "latency_ms": 0}
+    Batch:  {"ok": true,  "type": "all", "items": [ ... ]}
+
+Exit code: ``0`` means all passed; non-zero means at least one failure (for shell scripting).
+
+Usage
+-----
+    python3 scripts/verify-credentials.py                  # validate all three
+    python3 scripts/verify-credentials.py --type tencent   # Tencent Cloud only
+    python3 scripts/verify-credentials.py --type trtc      # TRTC only
+    python3 scripts/verify-credentials.py --type llm       # LLM only
+    python3 scripts/verify-credentials.py --no-deep        # TRTC skip deep OpenAPI validation
+
+Security Constraints (Red Lines)
+--------------------------------
+- Never pass keys via CLI arguments (no --secret-id / --api-key parameters)
+- Never echo credential plaintext to stdout / stderr
+- ``.env`` permissions (600) are set by the caller at write time (this script does not re-process)
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+import warnings
+from pathlib import Path
+
+# Suppress warnings from third-party libraries (e.g., urllib3 / NotOpenSSLWarning) sent to stderr,
+# keeping stdout pure JSON and stderr silent — no noise for AI parsing
+warnings.filterwarnings("ignore")
+
+_HERE = Path(__file__).resolve().parent
+_ROOT = _HERE.parent
+if str(_ROOT) not in sys.path:
+    sys.path.insert(0, str(_ROOT))
+
+from scripts.lib import credential_validators as cv  # noqa: E402
+
+
+def _print_json(data: dict) -> None:
+    sys.stdout.write(json.dumps(data, ensure_ascii=False))
+    sys.stdout.write("\n")
+    sys.stdout.flush()
+
+
+def main(argv=None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="verify-credentials",
+        description="Credential-less validation of three keys (reads from .env only, outputs structured JSON)",
+    )
+    parser.add_argument(
+        "--type",
+        choices=["tencent", "trtc", "llm", "all"],
+        default="all",
+        help="Validate a single key; default is all",
+    )
+    parser.add_argument(
+        "--no-deep",
+        action="store_true",
+        help="Skip deep OpenAPI validation for TRTC; only local UserSig self-consistency check",
+    )
+    parser.add_argument(
+        "--env-file",
+        default="",
+        help="Optional: specify .env path (default: capabilities/conversation-core/.env)",
+    )
+    args = parser.parse_args(argv)
+
+    cv.load_dotenv(Path(args.env_file) if args.env_file else None)
+
+    if args.type == "tencent":
+        result = cv.validate_tencent()
+        _print_json(result.to_dict())
+        return 0 if result.ok else 1
+
+    if args.type == "trtc":
+        result = cv.validate_trtc(deep=not args.no_deep)
+        _print_json(result.to_dict())
+        return 0 if result.ok else 1
+
+    if args.type == "llm":
+        result = cv.validate_llm()
+        _print_json(result.to_dict())
+        return 0 if result.ok else 1
+
+    # all
+    batch = cv.validate_all()
+    _print_json(batch.to_dict())
+    return 0 if batch.ok else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/skills/trtc-ai-service/start.sh

@@ -0,0 +1,111 @@
+#!/usr/bin/env bash
+# =====================================================================
+# conversation-core · Launch script (slim / Phase 3 Stage 5)
+#
+# Assumes: .env already exists (key collection & writing hosted by AI;
+#          or developer runs `python scripts/setup-credentials.py` as fallback).
+# Does only four things:
+#   1. Detect Python ≥ 3.9
+#   2. Create / reuse venv (does not pollute global environment)
+#   3. Install / verify dependencies (Tsinghua mirror first, fallback to official source)
+#   4. Launch FastAPI uvicorn (HTTP; --https uses self-signed cert)
+#
+# Usage:
+#   ./start.sh                  # HTTP launch (default port 3000)
+#   ./start.sh --https          # HTTPS launch (self-signed)
+#   ./start.sh --rebuild        # Force venv rebuild
+#   ./start.sh --port 8080      # Custom port
+# =====================================================================
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+cd "$SCRIPT_DIR"
+
+CORE_DIR="$SCRIPT_DIR/capabilities/conversation-core"
+ENV_FILE="$CORE_DIR/.env"
+REQUIREMENTS="$CORE_DIR/requirements.txt"
+VENV_DIR="$SCRIPT_DIR/.venv"
+MIN_PY_MAJOR=3; MIN_PY_MINOR=9
+PORT=3000; REBUILD=0; USE_HTTPS=0
+
+if [ -t 1 ]; then
+    GREEN='\033[0;32m'; YELLOW='\033[1;33m'; RED='\033[0;31m'; CYAN='\033[0;36m'; BOLD='\033[1m'; NC='\033[0m'
+else GREEN=''; YELLOW=''; RED=''; CYAN=''; BOLD=''; NC=''; fi
+log()  { printf "${CYAN}[%s]${NC} %s\n" "$(date +%H:%M:%S)" "$*"; }
+ok()   { printf "${GREEN}✓${NC} %s\n" "$*"; }
+warn() { printf "${YELLOW}⚠${NC}  %s\n" "$*"; }
+die()  { printf "${RED}✗${NC} %s\n" "$*" >&2; exit 1; }
+
+while [ $# -gt 0 ]; do
+    case "$1" in
+        --rebuild) REBUILD=1 ;;
+        --https)   USE_HTTPS=1 ;;
+        --port)    shift; PORT="$1" ;;
+        --help|-h) sed -n '2,18p' "${BASH_SOURCE[0]}" | sed 's/^# \{0,1\}//'; exit 0 ;;
+        *) warn "Ignoring unknown argument: $1" ;;
+    esac
+    shift
+done
+
+# ---------------- Step 1: Prerequisites ----------------
+[ -f "$ENV_FILE" ] || die ".env not found: $ENV_FILE\n  Please first complete the 3-key configuration in the Coding Agent per SKILL.md §7;\n  or developer fallback: python3 scripts/setup-credentials.py"
+
+PY_CMD=""
+for cand in python3.12 python3.11 python3.10 python3.9 python3 python; do
+    if command -v "$cand" >/dev/null 2>&1; then
+        VER=$("$cand" -c 'import sys; print(f"{sys.version_info.major}.{sys.version_info.minor}")' 2>/dev/null || echo "0.0")
+        MAJOR=$(echo "$VER" | cut -d. -f1); MINOR=$(echo "$VER" | cut -d. -f2)
+        if [ "$MAJOR" -gt "$MIN_PY_MAJOR" ] || { [ "$MAJOR" -eq "$MIN_PY_MAJOR" ] && [ "$MINOR" -ge "$MIN_PY_MINOR" ]; }; then
+            PY_CMD="$cand"; ok "Python $VER -> $(command -v "$cand")"; break
+        fi
+    fi
+done
+[ -z "$PY_CMD" ] && die "No Python ≥ ${MIN_PY_MAJOR}.${MIN_PY_MINOR} detected"
+
+# ---------------- Step 2: venv ----------------
+[ "$REBUILD" -eq 1 ] && [ -d "$VENV_DIR" ] && { warn "Rebuilding venv..."; rm -rf "$VENV_DIR"; }
+NEED_INSTALL=0
+if [ ! -d "$VENV_DIR" ]; then
+    log "Creating virtual environment..."
+    "$PY_CMD" -m venv "$VENV_DIR" || die "venv creation failed (Linux may need: apt install python3-venv)"
+    NEED_INSTALL=1
+fi
+# shellcheck disable=SC1091
+source "$VENV_DIR/bin/activate"
+VENV_PY="$VENV_DIR/bin/python"; VENV_PIP="$VENV_DIR/bin/pip"
+
+# ---------------- Step 3: Dependencies ----------------
+[ "$NEED_INSTALL" -eq 0 ] && ! "$VENV_PY" -c "import fastapi, uvicorn, requests, dotenv, pydantic" 2>/dev/null && NEED_INSTALL=1
+if [ "$NEED_INSTALL" -eq 1 ]; then
+    log "Installing dependencies..."
+    "$VENV_PIP" install --upgrade pip >/dev/null 2>&1 || true
+    if "$VENV_PIP" install -r "$REQUIREMENTS" -i "https://pypi.tuna.tsinghua.edu.cn/simple" --timeout 15 >/dev/null 2>&1; then
+        ok "Dependencies installed (Tsinghua mirror)"
+    else
+        warn "Mirror source failed, switching to official source..."
+        "$VENV_PIP" install -r "$REQUIREMENTS" >/dev/null || die "Dependency installation failed"
+        ok "Dependencies installed (official source)"
+    fi
+else ok "Dependencies ready"; fi
+
+# ---------------- Step 4: Launch ----------------
+SSL_ARGS=""
+if [ "$USE_HTTPS" -eq 1 ]; then
+    CERT_DIR="$SCRIPT_DIR/certs"; CERT_FILE="$CERT_DIR/cert.pem"; KEY_FILE="$CERT_DIR/key.pem"
+    if [ ! -f "$CERT_FILE" ] || [ ! -f "$KEY_FILE" ]; then
+        command -v openssl >/dev/null 2>&1 || die "openssl not installed"
+        mkdir -p "$CERT_DIR"
+        openssl req -x509 -newkey rsa:2048 -nodes -keyout "$KEY_FILE" -out "$CERT_FILE" \
+            -days 365 -subj "/CN=localhost" -addext "subjectAltName=DNS:localhost,IP:127.0.0.1" 2>/dev/null
+        ok "Self-signed certificate generated"
+    fi
+    SSL_ARGS="--ssl-keyfile $KEY_FILE --ssl-certfile $CERT_FILE"
+fi
+
+SCHEME="http"; [ "$USE_HTTPS" -eq 1 ] && SCHEME="https"
+printf "%b🚀 Launching conversation-core: %s://localhost:%s%b (Ctrl+C to stop)\n" "$GREEN" "$SCHEME" "$PORT" "$NC"
+
+cd "$CORE_DIR"
+export HOST="${HOST:-0.0.0.0}"; export PORT="$PORT"
+# shellcheck disable=SC2086
+exec "$VENV_PY" -m uvicorn src.server:app --host "$HOST" --port "$PORT" $SSL_ARGS

package/skills/trtc-ai-service/tests/__init__.py

@@ -0,0 +1 @@
+"""Phase 2 integration test suite (stdlib only, run via python -m tests)."""

package/skills/trtc-ai-service/tests/test_arbitrator.py

@@ -0,0 +1,64 @@
+"""α/β dual-track arbitration tests."""
+import sys
+import unittest
+from pathlib import Path
+
+_ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(_ROOT))
+
+from scripts.lib.arbitrator import AlphaTool, BetaTool, ToolRegistry
+
+
+class ArbitratorTests(unittest.TestCase):
+
+    def test_alpha_first_when_both_available(self):
+        r = ToolRegistry(default_priority="alpha")
+        r.register_alpha(AlphaTool(name="echo", func=lambda **kw: {"track": "alpha", "kw": kw}))
+        r.register_beta(BetaTool(name="echo", endpoint="https://example.com"))
+        result = r.call("echo", {"x": 1})
+        self.assertEqual(result.track, "alpha")
+        self.assertTrue(result.ok)
+        self.assertEqual(result.fallback_chain, ["alpha"])
+
+    def test_alpha_failure_falls_back_to_beta(self):
+        r = ToolRegistry(default_priority="alpha")
+
+        def boom(**_kw):
+            raise RuntimeError("alpha down")
+
+        r.register_alpha(AlphaTool(name="echo", func=boom))
+        r.register_beta(BetaTool(name="echo", endpoint="https://example.com"))
+
+        def fake_beta(tool, params):
+            return {"track": "beta", "ep": tool.endpoint, "params": params}
+
+        result = r.call("echo", {"x": 1}, beta_invoker=fake_beta)
+        self.assertEqual(result.track, "beta")
+        self.assertTrue(result.ok)
+        self.assertEqual(result.fallback_chain, ["alpha", "beta"])
+
+    def test_beta_priority_explicit(self):
+        r = ToolRegistry(default_priority="beta")
+        r.register_alpha(AlphaTool(name="echo", func=lambda **kw: {"a": True}))
+        r.register_beta(BetaTool(name="echo", endpoint="https://example.com"))
+
+        result = r.call("echo", {}, beta_invoker=lambda t, p: {"b": True})
+        self.assertEqual(result.track, "beta")
+
+    def test_no_track_available_yields_failure(self):
+        r = ToolRegistry()
+        result = r.call("nonexistent", {})
+        self.assertFalse(result.ok)
+        self.assertIn("no track", result.error)
+
+    def test_alpha_only_when_beta_invoker_missing(self):
+        r = ToolRegistry()
+        r.register_beta(BetaTool(name="x", endpoint="https://example.com"))
+        # No beta_invoker provided
+        result = r.call("x", {})
+        self.assertFalse(result.ok)
+        self.assertIn("beta_invoker not provided", result.error)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/skills/trtc-ai-service/tests/test_capability_overlay.py

@@ -0,0 +1,85 @@
+"""Capability overlay end-to-end tests: add-capability dry-run + adapter rendering against the real repo."""
+import json
+import subprocess
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+_ROOT = Path(__file__).resolve().parent.parent
+
+
+def _run(*args: str) -> dict:
+    proc = subprocess.run(
+        [sys.executable, str(_ROOT / "scripts" / "add-capability.py"), *args, "--json"],
+        cwd=str(_ROOT),
+        capture_output=True,
+        text=True,
+        timeout=20,
+    )
+    if proc.returncode != 0:
+        raise RuntimeError(f"add-capability failed: {proc.stderr}")
+    return json.loads(proc.stdout)
+
+
+class CapabilityOverlayTests(unittest.TestCase):
+
+    def test_list_includes_all_capabilities(self):
+        out = _run("--list")
+        self.assertEqual(out["skeleton"], "conversation-core")
+        names = {c["name"] for c in out["capabilities"]}
+        for n in ("knowledge-base", "tool-calling", "human-handoff",
+                  "session-summary", "digital-human"):
+            self.assertIn(n, names)
+
+    def test_install_dry_run_topological_order(self):
+        out = _run("session-summary", "knowledge-base", "tool-calling")
+        order = out["install_order"]
+        self.assertTrue(set(order).issuperset({"knowledge-base", "tool-calling", "session-summary"}))
+        self.assertTrue(out["dry_run"])
+        for r in out["reports"]:
+            self.assertIn("skeleton_injection", r)
+            for inj in r["skeleton_injection"]:
+                # Injection plan must locate anchor (dry-run so applied may be True/False; key is no error)
+                if inj["error"]:
+                    self.fail(f"injection error for {r['capability']}: {inj}")
+
+    def test_adapter_l1_render_for_react_project(self):
+        with tempfile.TemporaryDirectory() as td:
+            user_proj = Path(td) / "react-app"
+            user_proj.mkdir()
+            (user_proj / "package.json").write_text(
+                json.dumps({"dependencies": {"react": "^18.2.0"}}), encoding="utf-8"
+            )
+            out = _run(
+                "knowledge-base",
+                "--target-project", str(user_proj),
+                "--apply",
+            )
+            kb_report = next(r for r in out["reports"] if r["capability"] == "knowledge-base")
+            self.assertEqual(kb_report["adapter"]["adapter"], "frontend-spa")
+            self.assertEqual(kb_report["degrade"]["level"], "L1")
+            # Expected generated file exists
+            target = user_proj / "src" / "components" / "VoiceAgent.tsx"
+            self.assertTrue(target.exists(), f"expected {target} to exist")
+            content = target.read_text(encoding="utf-8")
+            # Placeholder variables have been substituted
+            self.assertIn("http://localhost:3000", content)
+            self.assertNotIn("${SKELETON_BASE_URL}", content)
+
+    def test_adapter_l3_when_unknown_stack(self):
+        with tempfile.TemporaryDirectory() as td:
+            user_proj = Path(td) / "exotic"
+            user_proj.mkdir()
+            (user_proj / "manifest.toml").write_text("# nothing recognisable\n", encoding="utf-8")
+            out = _run(
+                "knowledge-base",
+                "--target-project", str(user_proj),
+            )
+            kb_report = next(r for r in out["reports"] if r["capability"] == "knowledge-base")
+            self.assertIsNone(kb_report["adapter"]["tech_stack_used"])
+            self.assertEqual(kb_report["degrade"]["level"], "L3")
+
+
+if __name__ == "__main__":
+    unittest.main()

package/skills/trtc-ai-service/tests/test_contract_resolver.py

@@ -0,0 +1,190 @@
+"""Phase 3 阶段 6：scripts/lib/contract_resolver.py 单元测试。
+
+覆盖目标：
+- load_business_contract：能加载 human-handoff / knowledge-base 两个能力包并通过 BC001~BC006 校验
+- diff_contracts：同名同类型 → 无 diff（L1）；rename 候选命中同义词字典；类型不兼容 → L2
+- decide_level：protocol 级别 method/body 不一致 → L3；out-of-slot rename → L2；slot 内 rename → L1
+- validate_manifest：能产出（或不产出）warning 列表
+"""
+from __future__ import annotations
+
+import sys
+import unittest
+from pathlib import Path
+
+_ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(_ROOT))
+
+from scripts.lib.contract_resolver import (  # noqa: E402
+    BusinessContract,
+    ContractError,
+    DegradeLevel,
+    decide_level,
+    diff_contracts,
+    load_business_contract,
+    validate_manifest,
+)
+from scripts.lib.curl_parser import AuthSpec, ParsedApi  # noqa: E402
+
+
+_HH_DIR = _ROOT / "capabilities" / "human-handoff"
+_KB_DIR = _ROOT / "capabilities" / "knowledge-base"
+
+
+class LoadBusinessContractTests(unittest.TestCase):
+    """Read real manifests and verify correct field parsing."""
+
+    def test_load_human_handoff_outbound_apis(self):
+        bc = load_business_contract(_HH_DIR)
+        self.assertEqual(bc.capability, "human-handoff")
+        self.assertTrue(bc.port_class.endswith("HandoffClient"))
+        outs = bc.outbound_apis()
+        names = {a.name for a in outs}
+        # At least three outbound ticket APIs
+        self.assertIn("ticket.create", names)
+        self.assertIn("ticket.status_query", names)
+        self.assertIn("ticket.cancel", names)
+        # Inbound APIs should not mix into outbound
+        for a in outs:
+            self.assertEqual(a.direction, "outbound")
+
+    def test_load_knowledge_base_outbound_apis(self):
+        bc = load_business_contract(_KB_DIR)
+        self.assertEqual(bc.capability, "knowledge-base")
+        names = {a.name for a in bc.outbound_apis()}
+        # At least faq.search
+        self.assertIn("faq.search", names)
+
+    def test_get_api_lookup(self):
+        bc = load_business_contract(_HH_DIR)
+        api = bc.get_api("ticket.create")
+        self.assertIsNotNone(api)
+        self.assertEqual(api.method, "POST")
+        self.assertIn("user_id", api.request_schema)
+        self.assertIn("response.ticket_id", api.adapter_slots)
+
+    def test_load_missing_manifest_raises(self):
+        with self.assertRaises(ContractError) as ctx:
+            load_business_contract(_ROOT / "no_such_capability_dir")
+        self.assertEqual(ctx.exception.code, "BC000")
+
+    def test_validate_manifest_runs(self):
+        # validate_manifest must not raise fatal; BC004 warnings are allowed (array-type slot paths may hit hits[])
+        warnings_hh = validate_manifest(_HH_DIR)
+        self.assertIsInstance(warnings_hh, list)
+        warnings_kb = validate_manifest(_KB_DIR)
+        self.assertIsInstance(warnings_kb, list)
+        # Warning strings should start with BC prefix
+        for w in warnings_hh + warnings_kb:
+            self.assertTrue(w.startswith("BC"), w)
+
+
+class DiffContractsTests(unittest.TestCase):
+    """构造默认契约 + 用户 ParsedApi，验证 diff / level 决策。"""
+
+    def setUp(self):
+        bc = load_business_contract(_HH_DIR)
+        self.api = bc.get_api("ticket.create")
+        self.assertIsNotNone(self.api)
+
+    def _make_user(
+        self,
+        *,
+        method="POST",
+        path="/tickets",
+        request_schema=None,
+        body_format="json",
+    ):
+        return ParsedApi(
+            method=method,
+            base_url="https://crm.example.com",
+            path=path,
+            headers={},
+            auth=AuthSpec(type="bearer", location="header", name="Authorization"),
+            request_schema=request_schema or {},
+            response_schema={},
+            body_format=body_format,
+            source="curl",
+        )
+
+    def test_l1_when_same_field_names(self):
+        """Same field names + same types + method/path match → L1."""
+        user = self._make_user(
+            request_schema={
+                "user_id": "string",
+                "subject": "string",
+                "description": "string",
+                "priority": "string",
+                "transcript": "string[]",
+            }
+        )
+        diff = diff_contracts(self.api, user)
+        self.assertFalse(diff.protocol_mismatch)
+        self.assertEqual(decide_level(diff), DegradeLevel.L1)
+
+    def test_l1_when_slot_rename(self):
+        """subject → title (synonym, inside adapter_slots) → still L1."""
+        user = self._make_user(
+            request_schema={
+                "user_id": "string",
+                "title": "string",         # subject → title（slot 内）
+                "description": "string",
+                "priority": "string",      # priority 仍同名
+                "transcript": "string[]",
+            }
+        )
+        diff = diff_contracts(self.api, user)
+        self.assertEqual(decide_level(diff), DegradeLevel.L1)
+        # Must have a rename record (subject → title) that is in-slot
+        renames = [f for f in diff.fields if f.kind == "rename"]
+        self.assertTrue(any(f.in_slot and "subject" in f.path for f in renames))
+
+    def test_l2_when_out_of_slot_rename(self):
+        """user_id → customer_id (synonym, but user_id not in adapter_slots) → L2."""
+        user = self._make_user(
+            request_schema={
+                "customer_id": "string",   # user_id 重命名（不在 slot）
+                "subject": "string",
+                "description": "string",
+                "priority": "string",
+                "transcript": "string[]",
+            }
+        )
+        diff = diff_contracts(self.api, user)
+        self.assertEqual(decide_level(diff), DegradeLevel.L2)
+
+    def test_l3_when_method_mismatch(self):
+        """方法不一致（POST → PUT）→ protocol_mismatch → L3。"""
+        user = self._make_user(method="PUT")
+        diff = diff_contracts(self.api, user)
+        self.assertTrue(diff.protocol_mismatch)
+        self.assertEqual(decide_level(diff), DegradeLevel.L3)
+
+    def test_l3_when_raw_body_format(self):
+        """body_format=raw (non-JSON) → protocol_mismatch → L3."""
+        user = self._make_user(body_format="raw")
+        diff = diff_contracts(self.api, user)
+        self.assertTrue(diff.protocol_mismatch)
+        self.assertEqual(decide_level(diff), DegradeLevel.L3)
+
+    def test_response_missing_does_not_block_l1(self):
+        """User did not provide response → not counted as a protocol/L2/L3 obstacle."""
+        user = self._make_user(
+            request_schema={
+                "user_id": "string",
+                "subject": "string",
+                "description": "string",
+                "priority": "string",
+                "transcript": "string[]",
+            }
+        )
+        # response 留空
+        diff = diff_contracts(self.api, user)
+        self.assertEqual(decide_level(diff), DegradeLevel.L1)
+        # 但应有 user_response_missing 记录
+        kinds = {f.kind for f in diff.fields}
+        self.assertIn("user_response_missing", kinds)
+
+
+if __name__ == "__main__":
+    unittest.main()