@tikomni/skills 1.0.6 → 1.0.7

package/skills/social-media-crawl/scripts/core/call_tikomni_api.py

@@ -0,0 +1,269 @@
+#!/usr/bin/env python3
+"""Call TikOmni API by catalog endpoint_id."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from pathlib import Path
+import urllib.parse
+from typing import Any, Dict, List, Optional, Tuple
+
+SKILL_ROOT = Path(__file__).resolve().parents[2]
+if str(SKILL_ROOT) not in sys.path:
+    sys.path.insert(0, str(SKILL_ROOT))
+
+from scripts.core.api_catalog import load_operations, operation_by_endpoint_id
+from scripts.core.tikomni_common import call_json_api, resolve_runtime
+
+RESERVED_PARAM_KEYS = {"path", "method"}
+
+
+def _json_stdout(payload: Dict[str, Any]) -> None:
+    print(json.dumps(payload, ensure_ascii=False, indent=2, sort_keys=True))
+
+
+def _parse_params(raw_params: str) -> Dict[str, Any]:
+    if not raw_params:
+        return {}
+    payload = json.loads(raw_params)
+    if not isinstance(payload, dict):
+        raise ValueError("params_must_be_json_object")
+    return payload
+
+
+def _schema_type(schema: Dict[str, Any]) -> str:
+    raw_type = schema.get("type")
+    if isinstance(raw_type, list):
+        return "|".join(str(item) for item in raw_type)
+    return str(raw_type or "")
+
+
+def _validate_type(name: str, value: Any, schema: Dict[str, Any]) -> Optional[str]:
+    schema_type = _schema_type(schema)
+    if not schema_type:
+        return None
+    allowed = set(schema_type.split("|"))
+    if "null" in allowed and value is None:
+        return None
+    if "string" in allowed and isinstance(value, str):
+        return None
+    if "integer" in allowed and isinstance(value, int) and not isinstance(value, bool):
+        return None
+    if "number" in allowed and isinstance(value, (int, float)) and not isinstance(value, bool):
+        return None
+    if "boolean" in allowed and isinstance(value, bool):
+        return None
+    if "array" in allowed and isinstance(value, list):
+        return None
+    if "object" in allowed and isinstance(value, dict):
+        return None
+    return f"invalid_type:{name}:expected_{schema_type or 'declared'}"
+
+
+def _parameter_maps(operation: Dict[str, Any]) -> Tuple[Dict[str, Dict[str, Any]], Dict[str, Dict[str, Any]], Dict[str, Dict[str, Any]]]:
+    path_params: Dict[str, Dict[str, Any]] = {}
+    query_params: Dict[str, Dict[str, Any]] = {}
+    header_params: Dict[str, Dict[str, Any]] = {}
+    for param in operation.get("parameters") or []:
+        if not isinstance(param, dict):
+            continue
+        name = str(param.get("name") or "")
+        location = str(param.get("in") or "query")
+        if not name:
+            continue
+        if location == "path":
+            path_params[name] = param
+        elif location == "header":
+            header_params[name] = param
+        else:
+            query_params[name] = param
+    return path_params, query_params, header_params
+
+
+def _body_properties(operation: Dict[str, Any]) -> Tuple[Dict[str, Any], bool, bool]:
+    body = operation.get("request_body") if isinstance(operation.get("request_body"), dict) else None
+    if not body:
+        return {}, False, False
+    schema = body.get("schema") if isinstance(body.get("schema"), dict) else {}
+    props = schema.get("properties") if isinstance(schema.get("properties"), dict) else {}
+    return props, bool(body.get("required")), True
+
+
+def _render_path(path: str, params: Dict[str, Any], path_params: Dict[str, Dict[str, Any]]) -> Tuple[str, List[str]]:
+    missing: List[str] = []
+
+    def replace(match: re.Match[str]) -> str:
+        name = match.group(1)
+        if name not in params or params.get(name) in (None, ""):
+            missing.append(name)
+            return match.group(0)
+        return urllib.parse.quote(str(params[name]), safe="")
+
+    rendered = re.sub(r"\{([^}]+)\}", replace, path)
+    for name, param in path_params.items():
+        if param.get("required") and (name not in params or params.get(name) in (None, "")):
+            missing.append(name)
+    return rendered, sorted(set(missing))
+
+
+def build_request(operation: Dict[str, Any], params: Dict[str, Any]) -> Tuple[Optional[Dict[str, Any]], Optional[Dict[str, Any]]]:
+    input_schema = operation.get("input_schema") if isinstance(operation.get("input_schema"), dict) else {}
+    properties = input_schema.get("properties") if isinstance(input_schema.get("properties"), dict) else {}
+    reserved = sorted(key for key in params.keys() if key in RESERVED_PARAM_KEYS and key not in properties)
+    if reserved:
+        return None, {"code": "RESERVED_PARAM_KEY", "message": f"Reserved API routing keys are not allowed in params: {', '.join(reserved)}"}
+
+    required = set(str(item) for item in input_schema.get("required") or [])
+    missing_required = sorted(name for name in required if name not in params or params.get(name) in (None, ""))
+    if missing_required:
+        return None, {"code": "MISSING_REQUIRED_PARAMS", "message": f"Missing required params: {', '.join(missing_required)}"}
+
+    unknown = sorted(key for key in params.keys() if key not in properties)
+    if unknown:
+        return None, {"code": "UNKNOWN_PARAMS", "message": f"Unknown params for endpoint_id={operation.get('endpoint_id')}: {', '.join(unknown)}"}
+
+    for name, value in params.items():
+        schema = properties.get(name) if isinstance(properties.get(name), dict) else {}
+        error = _validate_type(name, value, schema)
+        if error:
+            return None, {"code": "INVALID_PARAM_TYPE", "message": error}
+
+    path_params, query_params, header_params = _parameter_maps(operation)
+    path, missing_path = _render_path(str(operation.get("path") or ""), params, path_params)
+    if missing_path:
+        return None, {"code": "MISSING_PATH_PARAMS", "message": f"Missing path params: {', '.join(missing_path)}"}
+
+    query = {name: params[name] for name in query_params.keys() if name in params}
+    headers = {name: str(params[name]) for name in header_params.keys() if name in params}
+    body_props, body_required, has_body = _body_properties(operation)
+    body: Optional[Dict[str, Any]] = None
+    if has_body:
+        if body_props:
+            body = {name: params[name] for name in body_props.keys() if name in params}
+        elif "body" in params:
+            raw_body = params["body"]
+            if not isinstance(raw_body, dict):
+                return None, {"code": "INVALID_PARAM_TYPE", "message": "invalid_type:body:expected_object"}
+            body = raw_body
+        elif body_required:
+            return None, {"code": "MISSING_REQUIRED_PARAMS", "message": "Missing required params: body"}
+        else:
+            body = {}
+
+    return {
+        "method": str(operation.get("method") or "GET"),
+        "path": path,
+        "query": query,
+        "headers": headers,
+        "body": body,
+    }, None
+
+
+def call_endpoint(
+    *,
+    endpoint_id: str,
+    params: Dict[str, Any],
+    env_file: Optional[str] = None,
+    base_url: Optional[str] = None,
+    timeout_ms: Optional[int] = None,
+    allow_process_env: bool = False,
+    dry_run: bool = False,
+) -> Dict[str, Any]:
+    operations = load_operations()
+    operation = operation_by_endpoint_id(operations, endpoint_id)
+    if not operation:
+        return {
+            "ok": False,
+            "code": "UNKNOWN_ENDPOINT_ID",
+            "endpoint_id": endpoint_id,
+            "error_reason": f"endpoint_id_not_found:{endpoint_id}",
+        }
+
+    request_plan, validation_error = build_request(operation, params)
+    if validation_error:
+        return {
+            "ok": False,
+            "code": validation_error["code"],
+            "endpoint_id": endpoint_id,
+            "platform": operation.get("platform"),
+            "capability": operation.get("capability"),
+            "variant": operation.get("variant"),
+            "error_reason": validation_error["message"],
+            "alternatives": operation.get("alternatives") or [],
+        }
+
+    if dry_run:
+        return {
+            "ok": True,
+            "dry_run": True,
+            "endpoint_id": endpoint_id,
+            "platform": operation.get("platform"),
+            "capability": operation.get("capability"),
+            "variant": operation.get("variant"),
+            "alternatives": operation.get("alternatives") or [],
+            "request": request_plan,
+        }
+
+    runtime = resolve_runtime(
+        env_file=env_file,
+        api_key_env="TIKOMNI_API_KEY",
+        base_url=base_url,
+        timeout_ms=timeout_ms,
+        allow_process_env=allow_process_env,
+    )
+    response = call_json_api(
+        base_url=str(runtime["base_url"]),
+        path=str(request_plan["path"]),
+        token=str(runtime["token"]),
+        method=str(request_plan["method"]),
+        timeout_ms=int(runtime["timeout_ms"]),
+        params=request_plan.get("query") if isinstance(request_plan.get("query"), dict) else None,
+        body=request_plan.get("body") if isinstance(request_plan.get("body"), dict) else None,
+        extra_headers=request_plan.get("headers") if isinstance(request_plan.get("headers"), dict) else None,
+    )
+    return {
+        "ok": bool(response.get("ok")),
+        "status_code": response.get("status_code"),
+        "request_id": response.get("request_id"),
+        "endpoint_id": endpoint_id,
+        "platform": operation.get("platform"),
+        "capability": operation.get("capability"),
+        "variant": operation.get("variant"),
+        "alternatives": operation.get("alternatives") or [],
+        "error_reason": response.get("error_reason"),
+        "data": response.get("data") if response.get("ok") else {},
+    }
+
+
+def main(argv: Optional[List[str]] = None) -> int:
+    parser = argparse.ArgumentParser(description="Call TikOmni API by endpoint_id.")
+    parser.add_argument("--endpoint-id", required=True)
+    parser.add_argument("--params", default="{}")
+    parser.add_argument("--env-file", default=None)
+    parser.add_argument("--base-url", default=None)
+    parser.add_argument("--timeout-ms", type=int, default=None)
+    parser.add_argument("--allow-process-env", action="store_true")
+    parser.add_argument("--dry-run", action="store_true")
+    args = parser.parse_args(argv)
+    try:
+        params = _parse_params(args.params)
+        payload = call_endpoint(
+            endpoint_id=args.endpoint_id,
+            params=params,
+            env_file=args.env_file,
+            base_url=args.base_url,
+            timeout_ms=args.timeout_ms,
+            allow_process_env=bool(args.allow_process_env),
+            dry_run=bool(args.dry_run),
+        )
+    except Exception as exc:
+        payload = {"ok": False, "code": "CALLER_EXCEPTION", "error_reason": str(exc)}
+    _json_stdout(payload)
+    return 0 if payload.get("ok") else 2
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/skills/social-media-crawl/scripts/core/config_loader.py

@@ -23,7 +23,6 @@ BUILTIN_DEFAULT_CONFIG: Dict[str, Any] = {
     "profile": "default",
     "runtime": {
         "base_url": "https://api.tikomni.com",
-        "mcp_url": "https://mcp.tikomni.com/mcp",
         "auth_env_key": "TIKOMNI_API_KEY",
         "timeout_ms": 60000,
         "u2_pending_timeout_sec": 60,
@@ -246,7 +245,6 @@ def apply_env_overrides(config: Dict[str, Any], env_values: Optional[Dict[str, s
 
     for env_key, config_key in {
         "TIKOMNI_BASE_URL": "base_url",
-        "TIKOMNI_MCP_URL": "mcp_url",
     }.items():
         value = _env_text(env_key, env_values=env_values)
         if value is not None:

package/skills/social-media-crawl/scripts/core/resolve_api_endpoint.py

@@ -0,0 +1,176 @@
+#!/usr/bin/env python3
+"""Resolve a TikOmni API endpoint_id from platform and capability."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+SKILL_ROOT = Path(__file__).resolve().parents[2]
+if str(SKILL_ROOT) not in sys.path:
+    sys.path.insert(0, str(SKILL_ROOT))
+
+from scripts.core.api_catalog import (
+    infer_alias_from_text,
+    load_aliases,
+    load_operations,
+    resolve_alias,
+    sorted_operations,
+)
+
+
+def _json_stdout(payload: Dict[str, Any]) -> None:
+    print(json.dumps(payload, ensure_ascii=False, indent=2, sort_keys=True))
+
+
+def _load_context(raw_json: Optional[str]) -> Dict[str, Any]:
+    if not raw_json:
+        return {}
+    try:
+        payload = json.loads(raw_json)
+    except Exception:
+        return {"_raw": raw_json}
+    return payload if isinstance(payload, dict) else {"value": payload}
+
+
+def _suggestions(platform: str, capability: str, operations: List[Dict[str, Any]]) -> List[Dict[str, str]]:
+    suggestions: List[Dict[str, str]] = []
+    if platform == "wechat" and capability.startswith("article"):
+        suggestions.append({"platform": "wechat_mp", "capability": capability})
+    if platform == "wechat" and capability in {"video_detail", "comments", "search", "hot_search"}:
+        suggestions.append({"platform": "wechat_channels", "capability": capability})
+
+    for operation in operations:
+        if capability and operation.get("capability") != capability:
+            continue
+        item = {
+            "platform": str(operation.get("platform") or ""),
+            "capability": str(operation.get("capability") or ""),
+        }
+        if item["platform"] and item not in suggestions:
+            suggestions.append(item)
+        if len(suggestions) >= 8:
+            break
+    return suggestions
+
+
+def resolve_endpoint(
+    *,
+    platform: str = "",
+    capability: str = "",
+    intent: str = "",
+    url: str = "",
+    context: Optional[Dict[str, Any]] = None,
+    include_demo: bool = False,
+) -> Dict[str, Any]:
+    aliases = load_aliases()
+    operations = load_operations()
+    context = context or {}
+
+    platform_aliases = aliases.get("platforms") if isinstance(aliases.get("platforms"), dict) else {}
+    capability_aliases = aliases.get("capabilities") if isinstance(aliases.get("capabilities"), dict) else {}
+    text = " ".join(
+        str(value)
+        for value in [
+            intent,
+            url,
+            context.get("intent"),
+            context.get("url"),
+            context.get("share_url"),
+            context.get("input"),
+        ]
+        if value
+    )
+
+    resolved_platform = resolve_alias(platform, platform_aliases)
+    if not resolved_platform:
+        resolved_platform = infer_alias_from_text(text, platform_aliases)
+
+    resolved_capability = resolve_alias(capability, capability_aliases)
+    if not resolved_capability:
+        resolved_capability = infer_alias_from_text(text, capability_aliases)
+
+    if not resolved_platform or not resolved_capability:
+        return {
+            "ok": False,
+            "code": "ENDPOINT_NOT_RESOLVED",
+            "message": "platform and capability are required for deterministic API endpoint resolution.",
+            "platform": resolved_platform,
+            "capability": resolved_capability,
+            "suggestions": _suggestions(resolved_platform, resolved_capability, operations),
+        }
+
+    candidates = [
+        operation
+        for operation in operations
+        if operation.get("platform") == resolved_platform
+        and operation.get("capability") == resolved_capability
+        and (include_demo or not operation.get("demo"))
+    ]
+    if not candidates:
+        return {
+            "ok": False,
+            "code": "ENDPOINT_NOT_RESOLVED",
+            "message": (
+                "No TikOmni public API endpoint matches "
+                f"platform={resolved_platform} capability={resolved_capability}."
+            ),
+            "platform": resolved_platform,
+            "capability": resolved_capability,
+            "suggestions": _suggestions(resolved_platform, resolved_capability, operations),
+        }
+
+    ordered = sorted_operations(candidates)
+    recommended = ordered[0]
+    alternatives = [
+        {
+            "endpoint_id": str(operation.get("endpoint_id") or ""),
+            "variant": str(operation.get("variant") or ""),
+            "method": str(operation.get("method") or ""),
+            "path": str(operation.get("path") or ""),
+            "summary": str(operation.get("summary") or ""),
+        }
+        for operation in ordered[1:]
+    ]
+    return {
+        "ok": True,
+        "platform": resolved_platform,
+        "capability": resolved_capability,
+        "recommended": {
+            "endpoint_id": str(recommended.get("endpoint_id") or ""),
+            "method": str(recommended.get("method") or ""),
+            "path": str(recommended.get("path") or ""),
+            "variant": str(recommended.get("variant") or ""),
+            "summary": str(recommended.get("summary") or ""),
+        },
+        "alternatives": alternatives,
+        "reason": "catalog_recommended_or_variant_priority",
+    }
+
+
+def main(argv: Optional[List[str]] = None) -> int:
+    parser = argparse.ArgumentParser(description="Resolve a TikOmni API endpoint_id.")
+    parser.add_argument("--platform", default="")
+    parser.add_argument("--capability", default="")
+    parser.add_argument("--intent", default="")
+    parser.add_argument("--url", default="")
+    parser.add_argument("--json", default="", help="Optional JSON context.")
+    parser.add_argument("--include-demo", action="store_true")
+    args = parser.parse_args(argv)
+    payload = resolve_endpoint(
+        platform=args.platform,
+        capability=args.capability,
+        intent=args.intent,
+        url=args.url,
+        context=_load_context(args.json),
+        include_demo=bool(args.include_demo),
+    )
+    _json_stdout(payload)
+    return 0 if payload.get("ok") else 2
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/skills/social-media-crawl/scripts/run_task.py

@@ -0,0 +1,96 @@
+#!/usr/bin/env python3
+"""Minimal one-shot TikOmni API task runner."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+if str(SKILL_ROOT) not in sys.path:
+    sys.path.insert(0, str(SKILL_ROOT))
+
+from scripts.core.call_tikomni_api import call_endpoint
+from scripts.core.resolve_api_endpoint import resolve_endpoint
+
+
+def _json_stdout(payload: Dict[str, Any]) -> None:
+    print(json.dumps(payload, ensure_ascii=False, indent=2, sort_keys=True))
+
+
+def _parse_params(raw_params: str) -> Dict[str, Any]:
+    if not raw_params:
+        return {}
+    payload = json.loads(raw_params)
+    if not isinstance(payload, dict):
+        raise ValueError("params_must_be_json_object")
+    return payload
+
+
+def run_task(
+    *,
+    intent: str,
+    params: Dict[str, Any],
+    platform: str = "",
+    capability: str = "",
+    dry_run: bool = False,
+    allow_process_env: bool = False,
+) -> Dict[str, Any]:
+    resolved = resolve_endpoint(
+        platform=platform,
+        capability=capability,
+        intent=intent,
+        context=params,
+    )
+    if not resolved.get("ok"):
+        return resolved
+
+    recommended = resolved.get("recommended") if isinstance(resolved.get("recommended"), dict) else {}
+    endpoint_id = str(recommended.get("endpoint_id") or "")
+    if not endpoint_id:
+        return {
+            "ok": False,
+            "code": "ENDPOINT_NOT_RESOLVED",
+            "error_reason": "resolver_returned_empty_endpoint_id",
+            "resolution": resolved,
+        }
+
+    response = call_endpoint(
+        endpoint_id=endpoint_id,
+        params=params,
+        allow_process_env=allow_process_env,
+        dry_run=dry_run,
+    )
+    response["resolution"] = resolved
+    return response
+
+
+def main(argv: Optional[List[str]] = None) -> int:
+    parser = argparse.ArgumentParser(description="Run a deterministic TikOmni API task.")
+    parser.add_argument("--intent", default="")
+    parser.add_argument("--platform", default="")
+    parser.add_argument("--capability", default="")
+    parser.add_argument("--params", default="{}")
+    parser.add_argument("--dry-run", action="store_true")
+    parser.add_argument("--allow-process-env", action="store_true")
+    args = parser.parse_args(argv)
+    try:
+        payload = run_task(
+            intent=args.intent,
+            params=_parse_params(args.params),
+            platform=args.platform,
+            capability=args.capability,
+            dry_run=bool(args.dry_run),
+            allow_process_env=bool(args.allow_process_env),
+        )
+    except Exception as exc:
+        payload = {"ok": False, "code": "RUNNER_EXCEPTION", "error_reason": str(exc)}
+    _json_stdout(payload)
+    return 0 if payload.get("ok") else 2
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/skills/social-media-crawl/tests/test_api_only_routing.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python3
+
+from __future__ import annotations
+
+import json
+import sys
+import unittest
+from pathlib import Path
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+if str(SKILL_ROOT) not in sys.path:
+    sys.path.insert(0, str(SKILL_ROOT))
+
+from scripts.core.call_tikomni_api import call_endpoint
+from scripts.core.resolve_api_endpoint import resolve_endpoint
+
+
+class ApiOnlyRoutingTest(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls) -> None:
+        cls.operations = json.loads(
+            (SKILL_ROOT / "references" / "api-catalog" / "operations.json").read_text(encoding="utf-8")
+        )
+
+    def test_error_report_paths_are_not_in_catalog(self) -> None:
+        paths = {str(operation["path"]) for operation in self.operations}
+        wrong_paths = {
+            "/api/u1/v1/health",
+            "/api/u1/v1/douyin/hot_search_list",
+            "/api/u1/v1/Douyin/douyin_hot_search_list",
+            "/api/u1/v1/wechat/article",
+            "/api/u1/v1/wechat/fetch_article",
+            "/api/u1/v1/account/info",
+            "/api/u1/v1/quote/list",
+            "/api/u1/v1/demo/wechat/article",
+        }
+        self.assertTrue(wrong_paths.isdisjoint(paths))
+        self.assertIn("/api/u1/v1/demo/douyin/web/fetch_one_video", paths)
+
+    def test_douyin_hot_search_resolves_real_endpoint(self) -> None:
+        resolved = resolve_endpoint(platform="douyin", capability="hot_search")
+        self.assertTrue(resolved["ok"])
+        self.assertEqual(
+            resolved["recommended"]["endpoint_id"],
+            "douyin.hot_search.app_v3.fetch_hot_search_list",
+        )
+        self.assertEqual(
+            resolved["recommended"]["path"],
+            "/api/u1/v1/douyin/app/v3/fetch_hot_search_list",
+        )
+        self.assertTrue(resolved["alternatives"])
+
+    def test_wechat_mp_and_channels_are_split(self) -> None:
+        mp = resolve_endpoint(platform="wechat_mp", capability="article_detail")
+        self.assertTrue(mp["ok"])
+        self.assertEqual(mp["platform"], "wechat_mp")
+        self.assertEqual(mp["recommended"]["path"], "/api/u1/v1/wechat_mp/web/fetch_mp_article_detail_json")
+
+        channels = resolve_endpoint(platform="wechat_channels", capability="video_detail")
+        self.assertTrue(channels["ok"])
+        self.assertEqual(channels["platform"], "wechat_channels")
+        self.assertEqual(channels["recommended"]["path"], "/api/u1/v1/wechat_channels/fetch_video_detail")
+
+    def test_ambiguous_wechat_returns_suggestions_not_guess(self) -> None:
+        resolved = resolve_endpoint(platform="wechat", capability="article_detail")
+        self.assertFalse(resolved["ok"])
+        self.assertEqual(resolved["code"], "ENDPOINT_NOT_RESOLVED")
+        self.assertIn({"platform": "wechat_mp", "capability": "article_detail"}, resolved["suggestions"])
+
+    def test_caller_rejects_arbitrary_routing_params(self) -> None:
+        result = call_endpoint(
+            endpoint_id="douyin.hot_search.app_v3.fetch_hot_search_list",
+            params={"path": "/api/u1/v1/douyin/hot_search_list"},
+            dry_run=True,
+        )
+        self.assertFalse(result["ok"])
+        self.assertEqual(result["code"], "RESERVED_PARAM_KEY")
+
+        result = call_endpoint(
+            endpoint_id="douyin.hot_search.app_v3.fetch_hot_search_list",
+            params={"method": "POST"},
+            dry_run=True,
+        )
+        self.assertFalse(result["ok"])
+        self.assertEqual(result["code"], "RESERVED_PARAM_KEY")
+
+    def test_caller_allows_declared_path_payload_field(self) -> None:
+        result = call_endpoint(
+            endpoint_id="xiaohongshu.search.web.sign",
+            params={
+                "path": "/api/sns/web/v1/search/notes",
+                "cookie": "web_session=test",
+                "data": {"keyword": "test"},
+            },
+            dry_run=True,
+        )
+        self.assertTrue(result["ok"])
+        self.assertEqual(result["request"]["path"], "/api/u1/v1/xiaohongshu/web/sign")
+        self.assertEqual(result["request"]["body"]["path"], "/api/sns/web/v1/search/notes")
+
+    def test_caller_rejects_unknown_endpoint_id(self) -> None:
+        result = call_endpoint(
+            endpoint_id="douyin.hot_search.app_v3.not_real",
+            params={},
+            dry_run=True,
+        )
+        self.assertFalse(result["ok"])
+        self.assertEqual(result["code"], "UNKNOWN_ENDPOINT_ID")
+
+    def test_u2_u3_stay_in_same_catalog(self) -> None:
+        endpoint_ids = {str(operation["endpoint_id"]) for operation in self.operations}
+        self.assertIn("u2.transcription.service.transcription", endpoint_ids)
+        self.assertIn("u3.media_upload.service.uploads", endpoint_ids)
+
+    def test_plain_english_intent_does_not_match_single_letter_x_alias(self) -> None:
+        resolved = resolve_endpoint(intent="extract comments from this post")
+        self.assertFalse(resolved["ok"])
+        self.assertEqual(resolved["capability"], "comments")
+        self.assertEqual(resolved["platform"], "")
+
+    def test_search_operations_are_not_classified_as_comments(self) -> None:
+        by_id = {str(operation["endpoint_id"]): operation for operation in self.operations}
+        for endpoint_id in {
+            "xiaohongshu.search.app_v2.search_notes",
+            "xiaohongshu.search.app.search_notes",
+            "xiaohongshu.search.web.search_notes",
+            "xiaohongshu.search.web.search_notes_v3",
+        }:
+            self.assertIn(endpoint_id, by_id)
+            self.assertEqual(by_id[endpoint_id]["capability"], "search")