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

package/skills/trtc-ai-service/scripts/post-install-patch.py

@@ -0,0 +1,225 @@
+#!/usr/bin/env python3
+"""post-install-patch.py — safety-net patch script after capability assembly.
+
+When to Call
+------------
+    SKILL.md §6 Path A Step 2.5 (after add-capability, before UI overlay)
+
+What It Does
+------------
+1. **Fix legacy extension point misplacement**
+   Early versions of `conversation-core/manifest.yaml` wrote `agent.before_push_text`
+   as `before:push_text`, which add-capability.py interpreted as "insert at same indent
+   before the `def push_text` line," resulting in class-scope placement that referenced
+   local variables `session_id`/`text`, causing NameError.
+   The new version uses sentinel anchor `_ext_before_push_text_` (inside push_text method body).
+   This patch scans the deployed agent.py and moves any "class-scope misplaced injection block"
+   into the correct method-body position. If already in the method body, it is skipped (idempotent).
+   The same logic also covers `_ext_after_start_`.
+
+2. **Auto-append .env default capability variables**
+   recipe.yaml ui_overlay / capability adapter defaults (KB_ADAPTER=mock /
+   HH_ADAPTER=local_queue, etc.) previously required manual .env editing. This patch
+   appends missing entries to an existing .env without overwriting existing values.
+
+3. **server.py StaticFiles html=True verification**
+   Ensures `/static/admin/`, `/static/dev/`, etc. subdirectory access can fallback to index.html.
+
+Output
+------
+    A JSON line (structured). Exit code 0 = all OK or idempotent skips; non-0 = anomalies
+    requiring manual intervention.
+
+Only modifies these whitelisted files:
+    capabilities/conversation-core/src/agent.py
+    capabilities/conversation-core/src/server.py
+    capabilities/conversation-core/.env
+"""
+from __future__ import annotations
+
+import json
+import os
+import re
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+AGENT_PY = ROOT / "capabilities" / "conversation-core" / "src" / "agent.py"
+SERVER_PY = ROOT / "capabilities" / "conversation-core" / "src" / "server.py"
+ENV_FILE = ROOT / "capabilities" / "conversation-core" / ".env"
+
+# .env 默认值（与 scenarios/customer-service/recipe.yaml 对齐）
+ENV_DEFAULTS = {
+    "KB_ADAPTER": "mock",
+    "KB_TOP_K": "3",
+    "KB_MIN_SCORE": "0.05",
+    "HH_ADAPTER": "local_queue",
+}
+
+# Known capability injection block markers (by capability name)
+CAP_MARKERS = ("human-handoff", "tool-calling", "session-summary", "knowledge-base")
+
+
+# --------------------------------------------------------------------------- #
+# 1. agent.py misplaced injection fix
+# --------------------------------------------------------------------------- #
+def _patch_agent_py(report: dict) -> None:
+    if not AGENT_PY.exists():
+        report["agent_py"] = {"ok": False, "skipped": True, "reason": "agent.py not found"}
+        return
+
+    src = AGENT_PY.read_text(encoding="utf-8")
+
+    # Check whether each capability's marker still appears at 4-space indent in class scope
+    # (correct position is 8+ spaces = inside method body)
+    misplaced: list[str] = []
+    for cap in CAP_MARKERS:
+        marker = f"# [{cap}]"
+        # Class scope 4 spaces + marker
+        if re.search(rf"^    {re.escape(marker)}", src, re.MULTILINE):
+            misplaced.append(cap)
+
+    if not misplaced:
+        report["agent_py"] = {"ok": True, "patched": [], "note": "no misplaced capability injections"}
+        return
+
+    # For each misplaced capability, strip it from class scope → move before the corresponding method body sentinel
+    new_src = src
+    moved: list[str] = []
+    failures: list[dict] = []
+    for cap in misplaced:
+        marker = f"# [{cap}]"
+        # Extract consecutive 4-space-indented block starting with the marker
+        block_re = re.compile(
+            rf"(?:^    {re.escape(marker)}[^\n]*\n(?:^    [^\n]*\n)+)",
+            re.MULTILINE,
+        )
+        m = block_re.search(new_src)
+        if not m:
+            failures.append({"capability": cap, "reason": "marker found but block extract failed"})
+            continue
+        block_text = m.group(0)
+        # Promote 4-space indent to 8-space (method body)
+        rebased = "\n".join(
+            ("    " + line) if line.startswith("    ") else line
+            for line in block_text.splitlines()
+        ) + "\n"
+        # Choose sentinel: human-handoff before_push_text uses _ext_before_push_text_;
+        # the same capability's after_start uses _ext_after_start_.
+        # Simple heuristic: pick whichever sentinel appears first; decide by whether the cap references `text`.
+        sentinel = (
+            "_ext_before_push_text_"
+            if "maybe_handoff(session_id, text" in block_text
+            or "maybe_dispatch(text" in block_text
+            or "record_user_turn(session_id, text" in block_text
+            else "_ext_after_start_"
+        )
+        # Insert rebased before the sentinel comment line
+        sentinel_re = re.compile(
+            rf"^([ \t]*)# {re.escape(sentinel)}\b[^\n]*$",
+            re.MULTILINE,
+        )
+        s_match = sentinel_re.search(new_src)
+        if not s_match:
+            failures.append({"capability": cap, "reason": f"sentinel {sentinel} not found in agent.py"})
+            continue
+        # Build insertion text (indent aligned to sentinel, i.e. 8 spaces)
+        # rebased is already 8-space indented
+        # First remove old misplaced block from new_src
+        without_old = new_src[: m.start()] + new_src[m.end():]
+        # Re-locate sentinel line (position may have shifted)
+        s_match2 = re.compile(
+            rf"^([ \t]*)# {re.escape(sentinel)}\b[^\n]*$",
+            re.MULTILINE,
+        ).search(without_old)
+        if not s_match2:
+            failures.append({"capability": cap, "reason": f"sentinel {sentinel} lost after stripping old block"})
+            continue
+        new_src = (
+            without_old[: s_match2.start()]
+            + rebased
+            + without_old[s_match2.start():]
+        )
+        moved.append(cap)
+
+    if new_src != src:
+        AGENT_PY.write_text(new_src, encoding="utf-8")
+
+    report["agent_py"] = {
+        "ok": not failures,
+        "patched": moved,
+        "failed": failures,
+    }
+
+
+# --------------------------------------------------------------------------- #
+# 2. server.py StaticFiles html=True verification
+# --------------------------------------------------------------------------- #
+def _patch_server_py(report: dict) -> None:
+    if not SERVER_PY.exists():
+        report["server_py"] = {"ok": False, "skipped": True, "reason": "server.py not found"}
+        return
+    src = SERVER_PY.read_text(encoding="utf-8")
+    if "StaticFiles(directory=str(_DEMO_DIR), html=False)" in src:
+        new_src = src.replace(
+            "StaticFiles(directory=str(_DEMO_DIR), html=False)",
+            "StaticFiles(directory=str(_DEMO_DIR), html=True)",
+        )
+        SERVER_PY.write_text(new_src, encoding="utf-8")
+        report["server_py"] = {"ok": True, "patched": ["StaticFiles html=True"]}
+    elif "StaticFiles(directory=str(_DEMO_DIR), html=True)" in src:
+        report["server_py"] = {"ok": True, "patched": [], "note": "already html=True"}
+    else:
+        report["server_py"] = {"ok": True, "patched": [], "note": "no matching StaticFiles mount"}
+
+
+# --------------------------------------------------------------------------- #
+# 3. Append .env defaults (do not overwrite existing)
+# --------------------------------------------------------------------------- #
+def _patch_env(report: dict) -> None:
+    if not ENV_FILE.exists():
+        report["env"] = {"ok": True, "skipped": True, "reason": ".env not present yet (run setup-credentials first)"}
+        return
+    text = ENV_FILE.read_text(encoding="utf-8")
+    existing_keys = {
+        line.split("=", 1)[0].strip()
+        for line in text.splitlines()
+        if "=" in line and not line.strip().startswith("#")
+    }
+    appended = []
+    additions = [
+        f"{k}={v}" for k, v in ENV_DEFAULTS.items() if k not in existing_keys
+    ]
+    if additions:
+        if not text.endswith("\n"):
+            text += "\n"
+        text += "\n# Added by post-install-patch.py (capability adapter defaults)\n"
+        text += "\n".join(additions) + "\n"
+        ENV_FILE.write_text(text, encoding="utf-8")
+        appended = [a.split("=", 1)[0] for a in additions]
+    report["env"] = {"ok": True, "appended": appended}
+
+
+# --------------------------------------------------------------------------- #
+# Main
+# --------------------------------------------------------------------------- #
+def main() -> int:
+    report: dict = {}
+    try:
+        _patch_agent_py(report)
+        _patch_server_py(report)
+        _patch_env(report)
+    except Exception as exc:  # noqa: BLE001
+        report["fatal"] = repr(exc)
+        print(json.dumps(report, ensure_ascii=False))
+        return 2
+    overall_ok = all(
+        v.get("ok", False) or v.get("skipped", False) for v in report.values()
+    )
+    report["ok"] = overall_ok
+    print(json.dumps(report, ensure_ascii=False))
+    return 0 if overall_ok else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

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

@@ -0,0 +1,393 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""3-Key interactive configuration script.
+
+Features:
+  1. Each key is validated for connectivity immediately after input; failure prevents proceeding to the next key.
+  2. Successfully verified keys are written to .credentials_cache (permissions 600);
+     re-running the script auto-skips already-passed keys, supporting checkpoint resume (idempotent).
+  3. Final artifacts: root-level `.env` file (permissions 600) + config-report.json.
+
+Usage:
+    python scripts/setup-credentials.py
+    python scripts/setup-credentials.py --reset    # Clear cache and reconfigure
+    python scripts/setup-credentials.py validate-tencent-cloud --secret-id ... --secret-key ...
+    python scripts/setup-credentials.py validate-trtc --app-id ... --app-key ...
+    python scripts/setup-credentials.py validate-llm --api-key ... --endpoint ...
+"""
+from __future__ import annotations
+
+import argparse
+import getpass
+import hashlib
+import json
+import os
+import sys
+import time
+from pathlib import Path
+from typing import Dict
+
+# Add capabilities/conversation-core to sys.path to reuse skeleton self-check logic
+_HERE = Path(__file__).resolve().parent
+_PROJECT_ROOT = _HERE.parent
+_CORE_DIR = _PROJECT_ROOT / "capabilities" / "conversation-core"
+sys.path.insert(0, str(_CORE_DIR))
+
+from src.credentials import (  # noqa: E402  pylint: disable=wrong-import-position
+    LlmCredential,
+    TencentCloudCredential,
+    TrtcCredential,
+)
+from src.health import (  # noqa: E402  pylint: disable=wrong-import-position
+    check_llm,
+    check_tencent_cloud,
+    check_trtc,
+)
+
+# Credential files go into the conversation-core directory, matching src/server.py's load_dotenv path
+# (server.py: _BASE_DIR = capabilities/conversation-core, reads _BASE_DIR/.env)
+CACHE_FILE = _CORE_DIR / ".credentials_cache"
+ENV_FILE = _CORE_DIR / ".env"
+REPORT_FILE = _PROJECT_ROOT / "config-report.json"
+
+
+# ---------------------------------------------------------------------------
+# Internationalization
+# ---------------------------------------------------------------------------
+def _is_zh() -> bool:
+    return os.getenv("LANG", "").lower().startswith("zh")
+
+
+_T = {
+    "header": ("=== TRTC Voice Agent 配置引导 ===", "=== TRTC Voice Agent Setup ==="),
+    "step_tc": ("[1/3] 腾讯云 API 密钥", "[1/3] Tencent Cloud API Credentials"),
+    "step_trtc": ("[2/3] TRTC 应用凭据", "[2/3] TRTC Application Credentials"),
+    "step_llm": ("[3/3] 外部 LLM 接入密钥", "[3/3] External LLM API Key"),
+    "input_secret_id": ("SecretId: ", "SecretId: "),
+    "input_secret_key": ("SecretKey (隐藏输入): ", "SecretKey (hidden): "),
+    "input_region": ("Region [ap-guangzhou]: ", "Region [ap-guangzhou]: "),
+    "input_app_id": ("SDKAppID (整数): ", "SDKAppID (integer): "),
+    "input_app_key": ("SDKSecretKey (隐藏输入): ", "SDKSecretKey (hidden): "),
+    "input_llm_key": ("LLM API Key: ", "LLM API Key: "),
+    "input_llm_url": (
+        "LLM API URL [https://api.openai.com/v1/chat/completions]: ",
+        "LLM API URL [https://api.openai.com/v1/chat/completions]: ",
+    ),
+    "input_llm_model": ("LLM Model [gpt-4o-mini]: ", "LLM Model [gpt-4o-mini]: "),
+    "skip_cached": ("✓ 检测到已通过验证的缓存，跳过本步骤。", "✓ Cached credential found, skipping."),
+    "validating": ("  正在校验...", "  Validating..."),
+    "ok": ("✅ 校验通过", "✅ OK"),
+    "fail": ("❌ 校验失败", "❌ Failed"),
+    "retry": ("是否重新输入？[Y/n] ", "Retry? [Y/n] "),
+    "done": ("=== 三把 Key 配置完成 ===", "=== All 3 keys configured ==="),
+    "next_step": (
+        "执行 `bash start.sh` 或 `python -m src.server` 启动 Web Demo。",
+        "Run `bash start.sh` or `python -m src.server` to launch the Web Demo.",
+    ),
+}
+
+
+def t(key: str) -> str:
+    pair = _T[key]
+    return pair[0] if _is_zh() else pair[1]
+
+
+# ---------------------------------------------------------------------------
+# Cache
+# ---------------------------------------------------------------------------
+def _hash(value: str) -> str:
+    return hashlib.sha256(value.encode("utf-8")).hexdigest()
+
+
+def _load_cache() -> Dict[str, str]:
+    if not CACHE_FILE.exists():
+        return {}
+    try:
+        return json.loads(CACHE_FILE.read_text(encoding="utf-8"))
+    except Exception:
+        return {}
+
+
+def _save_cache(cache: Dict[str, str]) -> None:
+    CACHE_FILE.write_text(json.dumps(cache, indent=2), encoding="utf-8")
+    try:
+        os.chmod(CACHE_FILE, 0o600)
+    except OSError:
+        pass
+
+
+def _persist_env(values: Dict[str, str]) -> None:
+    """Write / merge .env file and enforce permissions 600."""
+    existing: Dict[str, str] = {}
+    if ENV_FILE.exists():
+        for line in ENV_FILE.read_text(encoding="utf-8").splitlines():
+            if "=" in line and not line.strip().startswith("#"):
+                k, _, v = line.partition("=")
+                existing[k.strip()] = v.strip()
+    existing.update(values)
+    rendered = "\n".join(f"{k}={v}" for k, v in existing.items()) + "\n"
+    ENV_FILE.write_text(rendered, encoding="utf-8")
+    try:
+        os.chmod(ENV_FILE, 0o600)
+    except OSError:
+        pass
+
+
+def _read_env_value(key: str) -> str:
+    """Read a single variable value from the generated .env file (for sharing across multi-step config)."""
+    if not ENV_FILE.exists():
+        return ""
+    for line in ENV_FILE.read_text(encoding="utf-8").splitlines():
+        if "=" in line and not line.strip().startswith("#"):
+            k, _, v = line.partition("=")
+            if k.strip() == key:
+                return v.strip()
+    return ""
+
+
+# ---------------------------------------------------------------------------
+# Interactive flow
+# ---------------------------------------------------------------------------
+def _step_tencent_cloud(cache: Dict[str, str], report: Dict[str, dict]) -> None:
+    print()
+    print(t("step_tc"))
+    while True:
+        secret_id = input(t("input_secret_id")).strip()
+        secret_key = getpass.getpass(t("input_secret_key")).strip()
+        region = input(t("input_region")).strip() or "ap-guangzhou"
+        if not secret_id or not secret_key:
+            print(t("fail") + ": empty input")
+            continue
+        sig = _hash(secret_id + ":" + secret_key)
+        if cache.get("tencent_cloud") == sig:
+            print(t("skip_cached"))
+            return
+        print(t("validating"))
+        result = check_tencent_cloud(
+            TencentCloudCredential(secret_id=secret_id, secret_key=secret_key, region=region)
+        )
+        report["tencent_cloud"] = result.to_dict() | {"checked_at": int(time.time())}
+        if result.ok:
+            print(f"{t('ok')} (latency {result.latency_ms}ms)")
+            _persist_env(
+                {
+                    "TENCENT_CLOUD_SECRET_ID": secret_id,
+                    "TENCENT_CLOUD_SECRET_KEY": secret_key,
+                    "TENCENT_CLOUD_REGION": region,
+                }
+            )
+            cache["tencent_cloud"] = sig
+            _save_cache(cache)
+            return
+        print(f"{t('fail')} [{result.error_code}]: {result.detail}")
+        if input(t("retry")).strip().lower() in ("n", "no"):
+            sys.exit(1)
+
+
+def _step_trtc(cache: Dict[str, str], report: Dict[str, dict]) -> None:
+    print()
+    print(t("step_trtc"))
+    # Read previously configured Tencent Cloud credentials for real OpenAPI validation
+    tc_cred = TencentCloudCredential(
+        secret_id=os.getenv("TENCENT_CLOUD_SECRET_ID", "")
+        or _read_env_value("TENCENT_CLOUD_SECRET_ID"),
+        secret_key=os.getenv("TENCENT_CLOUD_SECRET_KEY", "")
+        or _read_env_value("TENCENT_CLOUD_SECRET_KEY"),
+        region=_read_env_value("TENCENT_CLOUD_REGION") or "ap-guangzhou",
+    )
+    while True:
+        app_id_raw = input(t("input_app_id")).strip()
+        app_key = getpass.getpass(t("input_app_key")).strip()
+        if not app_id_raw or not app_key:
+            print(t("fail") + ": empty input")
+            continue
+        try:
+            app_id = int(app_id_raw)
+        except ValueError:
+            print(t("fail") + ": SDKAppID must be integer")
+            continue
+
+        # —— SDKSecretKey defensive validation ——
+        # TRTC SDKSecretKey is a 64-char hex string (format copied directly from trtc.io console).
+        # Common error: user pastes twice → 128 chars; or pastes extra whitespace.
+        if not all(c in "0123456789abcdefABCDEF" for c in app_key):
+            print(
+                t("fail")
+                + ": SDKSecretKey only allows 0-9 / a-f characters, please re-copy from TRTC console"
+            )
+            continue
+        if len(app_key) == 128 and app_key[:64] == app_key[64:]:
+            print(
+                "  ⚠ Detected SDKSecretKey pasted twice (128 chars = same string copied twice), "
+                "auto-truncated to first 64 characters"
+            )
+            app_key = app_key[:64]
+        if len(app_key) != 64:
+            print(
+                f"{t('fail')}: SDKSecretKey must be 64 characters (you entered {len(app_key)}), "
+                "please re-copy"
+            )
+            continue
+
+        sig = _hash(f"{app_id}:{app_key}")
+        if cache.get("trtc") == sig:
+            print(t("skip_cached"))
+            return
+        print(t("validating"))
+        # Default to intl (trtc.io international); overseas devs don't need to select region
+        result = check_trtc(
+            TrtcCredential(sdk_app_id=app_id, sdk_secret_key=app_key, region="intl"),
+            tencent=tc_cred if tc_cred.configured else None,
+        )
+        report["trtc"] = result.to_dict() | {"checked_at": int(time.time())}
+        if result.ok:
+            print(f"{t('ok')} (latency {result.latency_ms}ms; {result.detail or ''})")
+            _persist_env(
+                {
+                    "TRTC_SDK_APP_ID": str(app_id),
+                    "TRTC_SDK_SECRET_KEY": app_key,
+                }
+            )
+            cache["trtc"] = sig
+            _save_cache(cache)
+            return
+        print(f"{t('fail')} [{result.error_code}]: {result.detail}")
+        if input(t("retry")).strip().lower() in ("n", "no"):
+            sys.exit(1)
+
+
+def _step_llm(cache: Dict[str, str], report: Dict[str, dict]) -> None:
+    print()
+    print(t("step_llm"))
+    retries = 0
+    while True:
+        api_key = input(t("input_llm_key")).strip()
+        api_url = input(t("input_llm_url")).strip() or "https://api.openai.com/v1/chat/completions"
+        model = input(t("input_llm_model")).strip() or "gpt-4o-mini"
+        if not api_key:
+            print(t("fail") + ": empty input")
+            continue
+        sig = _hash(f"{api_key}:{api_url}:{model}")
+        if cache.get("llm") == sig:
+            print(t("skip_cached"))
+            return
+        print(t("validating"))
+        result = check_llm(
+            LlmCredential(api_key=api_key, api_url=api_url, model=model)
+        )
+        report["llm"] = result.to_dict() | {"checked_at": int(time.time())}
+        if result.ok:
+            print(f"{t('ok')} (latency {result.latency_ms}ms)")
+            _persist_env(
+                {"LLM_API_KEY": api_key, "LLM_API_URL": api_url, "LLM_MODEL": model}
+            )
+            cache["llm"] = sig
+            _save_cache(cache)
+            return
+        retries += 1
+        print(f"{t('fail')} [{result.error_code}]: {result.detail}")
+        if retries >= 3:
+            print("Reached 3 failure limit. Please check your LLM Endpoint / Key and retry.")
+            sys.exit(1)
+        if input(t("retry")).strip().lower() in ("n", "no"):
+            sys.exit(1)
+
+
+# ---------------------------------------------------------------------------
+# Single-step validation subcommands (for start.sh reuse)
+# ---------------------------------------------------------------------------
+def _validate_tencent_cloud(args: argparse.Namespace) -> int:
+    r = check_tencent_cloud(
+        TencentCloudCredential(args.secret_id, args.secret_key, args.region or "ap-guangzhou")
+    )
+    print(json.dumps(r.to_dict()))
+    return 0 if r.ok else 1
+
+
+def _validate_trtc(args: argparse.Namespace) -> int:
+    try:
+        app_id = int(args.app_id)
+    except ValueError:
+        print(json.dumps({"status": "failed", "error_code": "E002", "detail": "invalid app_id"}))
+        return 1
+    tc = None
+    if getattr(args, "secret_id", None) and getattr(args, "secret_key", None):
+        tc = TencentCloudCredential(args.secret_id, args.secret_key, args.region or "ap-guangzhou")
+    r = check_trtc(
+        TrtcCredential(sdk_app_id=app_id, sdk_secret_key=args.app_key),
+        tencent=tc,
+    )
+    print(json.dumps(r.to_dict()))
+    return 0 if r.ok else 1
+
+
+def _validate_llm(args: argparse.Namespace) -> int:
+    r = check_llm(
+        LlmCredential(
+            api_key=args.api_key,
+            api_url=args.endpoint or "https://api.openai.com/v1/chat/completions",
+            model=args.model or "gpt-4o-mini",
+        )
+    )
+    print(json.dumps(r.to_dict()))
+    return 0 if r.ok else 1
+
+
+# ---------------------------------------------------------------------------
+# main
+# ---------------------------------------------------------------------------
+def main() -> int:
+    parser = argparse.ArgumentParser(description="TRTC Voice Agent credentials setup")
+    parser.add_argument("--reset", action="store_true", help="Clear cache and reconfigure")
+    sub = parser.add_subparsers(dest="cmd")
+
+    p_tc = sub.add_parser("validate-tencent-cloud")
+    p_tc.add_argument("--secret-id", required=True)
+    p_tc.add_argument("--secret-key", required=True)
+    p_tc.add_argument("--region", default="ap-guangzhou")
+
+    p_trtc = sub.add_parser("validate-trtc")
+    p_trtc.add_argument("--app-id", required=True)
+    p_trtc.add_argument("--app-key", required=True)
+    p_trtc.add_argument("--secret-id", default="", help="Tencent Cloud SecretId (optional, enables deep validation)")
+    p_trtc.add_argument("--secret-key", default="", help="Tencent Cloud SecretKey (optional, enables deep validation)")
+    p_trtc.add_argument("--region", default="ap-guangzhou")
+
+    p_llm = sub.add_parser("validate-llm")
+    p_llm.add_argument("--api-key", required=True)
+    p_llm.add_argument("--endpoint", default="")
+    p_llm.add_argument("--model", default="")
+
+    args = parser.parse_args()
+
+    if args.cmd == "validate-tencent-cloud":
+        return _validate_tencent_cloud(args)
+    if args.cmd == "validate-trtc":
+        return _validate_trtc(args)
+    if args.cmd == "validate-llm":
+        return _validate_llm(args)
+
+    if args.reset and CACHE_FILE.exists():
+        CACHE_FILE.unlink()
+
+    print(t("header"))
+    cache = _load_cache()
+    report: Dict[str, dict] = {}
+    _step_tencent_cloud(cache, report)
+    _step_trtc(cache, report)
+    _step_llm(cache, report)
+
+    REPORT_FILE.write_text(json.dumps(report, indent=2, ensure_ascii=False), encoding="utf-8")
+    try:
+        os.chmod(REPORT_FILE, 0o644)
+    except OSError:
+        pass
+
+    print()
+    print(t("done"))
+    print(t("next_step"))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())