@tikomni/skills 0.1.3 → 0.1.4

package/skills/{single-work-analysis → social-media-crawl}/scripts/core/config_loader.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-"""Lightweight config loader for Tikomni scripts (Phase 1 skeleton)."""
+"""Config loader for social-media-crawl."""
 
 from __future__ import annotations
 
@@ -11,7 +11,7 @@ from scripts.core.tikomni_common import bootstrap_runtime_env
 
 try:
     import yaml
-except Exception:  # pragma: no cover - defensive fallback
+except Exception:  # pragma: no cover
     yaml = None
 
 SKILL_ROOT = Path(__file__).resolve().parents[2]
@@ -23,12 +23,15 @@ 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,
     },
     "storage_routes": {
         "default": {
             "root_dir": "",
+            "card_root": "",
             "runs_dir": "_runs",
             "results_dir": "results",
             "errors_dir": "_errors",
@@ -37,25 +40,23 @@ BUILTIN_DEFAULT_CONFIG: Dict[str, Any] = {
             "single_video": "work",
             "note": "work",
             "work": "work",
+            "author_home": "work",
+            "work_collection": "work",
         },
         "card_type_routes": {
             "work": {
                 "prefix": "CBV",
-                "parts": ["内容系统", "对标研究", "作品卡"],
-            },
+                "parts": ["内容系统", "作品库", "{platform}-{author_slug}"],
+            }
         },
     },
     "naming_rules": {
-        "card_filename_pattern": "{prefix}-{platform}-{author_slug}-{title_slug}{ext}",
+        "card_filename_pattern": "{identifier}{ext}",
         "json_filename_pattern": "{timestamp}-{platform}-{identifier}{ext}",
     },
-    "analysis": {
-        "provider": "auto",
-        "timeout_sec": 90,
-    },
     "asr_strategy": {
         "poll_interval_sec": 3.0,
-        "max_polls": 10,
+        "max_polls": 30,
         "submit_retry": {
             "douyin_video": {"max_retries": 2, "backoff_ms": 1500},
             "xiaohongshu_note": {"max_retries": 0, "backoff_ms": 0},
@@ -71,29 +72,29 @@ LOCALE_ROUTE_PRESETS: Dict[str, Dict[str, Dict[str, Any]]] = {
     "zh": {
         "work": {
             "prefix": "CBV",
-            "parts": ["内容系统", "对标研究", "作品卡"],
-        },
+            "parts": ["内容系统", "作品库", "{platform}-{author_slug}"],
+        }
     },
     "en": {
         "work": {
             "prefix": "CBV",
-            "parts": ["content-system", "benchmark-research", "work-cards"],
-        },
+            "parts": ["content-system", "work-library", "{platform}-{author_slug}"],
+        }
     },
 }
 
-CARD_ROUTE_ENV_KEYS: Dict[str, str] = {
-    "work": "TIKOMNI_CARD_ROUTE_WORK",
+CARD_ROUTE_ENV_KEYS: Dict[str, List[str]] = {
+    "work": ["TIKOMNI_CARD_ROUTE_WORK", "TIKOMNI_CARD_ROUTE_AUTHOR_SAMPLE_WORK"],
 }
 
-CARD_PREFIX_ENV_KEYS: Dict[str, str] = {
-    "work": "TIKOMNI_CARD_PREFIX_WORK",
+CARD_PREFIX_ENV_KEYS: Dict[str, List[str]] = {
+    "work": ["TIKOMNI_CARD_PREFIX_WORK", "TIKOMNI_CARD_PREFIX_AUTHOR_SAMPLE_WORK"],
 }
 
 
 def _deep_clone(value: Any) -> Any:
     if isinstance(value, dict):
-        return {k: _deep_clone(v) for k, v in value.items()}
+        return {key: _deep_clone(item) for key, item in value.items()}
     if isinstance(value, list):
         return [_deep_clone(item) for item in value]
     return value
@@ -109,6 +110,10 @@ def _deep_merge(defaults: Dict[str, Any], override: Dict[str, Any]) -> Dict[str,
     return merged
 
 
+def _builtin_defaults() -> Dict[str, Any]:
+    return _deep_clone(BUILTIN_DEFAULT_CONFIG)
+
+
 def _resolve_repo_anchored_path(path_value: str) -> str:
     candidate = Path(path_value).expanduser()
     if not candidate.is_absolute():
@@ -116,15 +121,17 @@ def _resolve_repo_anchored_path(path_value: str) -> str:
     return str(candidate.resolve())
 
 
-def resolve_config_path(cli_config_path: Optional[str] = None, env_values: Optional[Dict[str, str]] = None) -> str:
-    """Resolve config file path with priority:
-    1) --config
-    2) TIKOMNI_CONFIG_FILE
-    3) references/config-templates/defaults.yaml
+def _load_yaml(path: str) -> Dict[str, Any]:
+    if yaml is None:
+        raise RuntimeError("PyYAML unavailable")
+    with open(path, "r", encoding="utf-8") as handle:
+        payload = yaml.safe_load(handle) or {}
+    if not isinstance(payload, dict):
+        raise ValueError(f"config_root_must_be_mapping:{path}")
+    return payload
 
-    Relative paths are always anchored at repository root (not current CWD).
-    """
 
+def resolve_config_path(cli_config_path: Optional[str] = None, env_values: Optional[Dict[str, str]] = None) -> str:
     if cli_config_path and str(cli_config_path).strip():
         return _resolve_repo_anchored_path(str(cli_config_path).strip())
 
@@ -136,31 +143,20 @@ def resolve_config_path(cli_config_path: Optional[str] = None, env_values: Optio
 
     if raw_env_path:
         return _resolve_repo_anchored_path(raw_env_path)
-
     return str(DEFAULT_CONFIG_PATH)
 
 
-def _load_yaml(path: str) -> Dict[str, Any]:
-    if yaml is None:
-        raise RuntimeError("PyYAML unavailable")
-
-    with open(path, "r", encoding="utf-8") as handle:
-        payload = yaml.safe_load(handle) or {}
-    if not isinstance(payload, dict):
-        raise ValueError(f"config_root_must_be_mapping:{path}")
-    return payload
-
-
-def _builtin_defaults() -> Dict[str, Any]:
-    return _deep_clone(BUILTIN_DEFAULT_CONFIG)
-
-
 def _read_env(name: str, env_values: Optional[Dict[str, str]] = None) -> str:
     if isinstance(env_values, dict) and name in env_values:
         return str(env_values.get(name, "") or "").strip()
     return os.getenv(name, "").strip()
 
 
+def _env_text(name: str, env_values: Optional[Dict[str, str]] = None) -> Optional[str]:
+    value = _read_env(name, env_values=env_values)
+    return value or None
+
+
 def _env_int(name: str, env_values: Optional[Dict[str, str]] = None) -> Optional[int]:
     raw = _read_env(name, env_values=env_values)
     if not raw:
@@ -169,12 +165,14 @@ def _env_int(name: str, env_values: Optional[Dict[str, str]] = None) -> Optional
         value = int(raw)
     except Exception:
         return None
-    return value if value > 0 else None
+    return value
 
 
-def _env_text(name: str, env_values: Optional[Dict[str, str]] = None) -> Optional[str]:
-    value = _read_env(name, env_values=env_values)
-    return value or None
+def _require_absolute_path(path_value: str, env_key: str) -> str:
+    candidate = Path(path_value).expanduser()
+    if not candidate.is_absolute():
+        raise ValueError(f"{env_key} must be an absolute path")
+    return str(candidate.resolve())
 
 
 def _require_absolute_env(name: str, env_values: Optional[Dict[str, str]] = None) -> str:
@@ -186,8 +184,8 @@ def _require_absolute_env(name: str, env_values: Optional[Dict[str, str]] = None
 
 def _route_from_env(value: str) -> Optional[List[str]]:
     parts = [item.strip() for item in value.split("|")]
-    normalized = [item for item in parts if item]
-    return normalized if normalized else None
+    cleaned = [item for item in parts if item]
+    return cleaned if cleaned else None
 
 
 def _normalize_path_locale(raw_value: Optional[str]) -> str:
@@ -197,44 +195,30 @@ def _normalize_path_locale(raw_value: Optional[str]) -> str:
     return "zh"
 
 
-def _require_absolute_path(path_value: str, env_key: str) -> str:
-    candidate = Path(path_value).expanduser()
-    if not candidate.is_absolute():
-        raise ValueError(f"{env_key} must be an absolute path")
-    return str(candidate.resolve())
-
-
 def resolve_storage_paths(config: Dict[str, Any]) -> Dict[str, str]:
-    """Resolve storage directories from an explicit absolute root (never CWD)."""
-
     default_route = config_get(config, "storage_routes.default", {})
     default_route = default_route if isinstance(default_route, dict) else {}
 
-    root_dir = Path(
-        _require_absolute_path(str(default_route.get("root_dir") or ""), "TIKOMNI_OUTPUT_ROOT")
-    )
+    root_dir = Path(_require_absolute_path(str(default_route.get("root_dir") or ""), "TIKOMNI_OUTPUT_ROOT"))
+    card_root = Path(_require_absolute_path(str(default_route.get("card_root") or ""), "TIKOMNI_CARD_ROOT"))
 
     resolved: Dict[str, str] = {
         "root_dir": str(root_dir),
+        "card_root": str(card_root),
     }
-    for key in ("runs_dir", "results_dir", "errors_dir"):
-        raw_value = str(default_route.get(key) or "").strip()
-        if not raw_value:
-            raw_value = {
-                "runs_dir": "_runs",
-                "results_dir": "results",
-                "errors_dir": "_errors",
-            }[key]
 
+    for key in ("runs_dir", "results_dir", "errors_dir"):
+        raw_value = str(default_route.get(key) or "").strip() or {
+            "runs_dir": "_runs",
+            "results_dir": "results",
+            "errors_dir": "_errors",
+        }[key]
         part = Path(raw_value).expanduser()
-        if part.is_absolute():
-            resolved[key] = str(part.resolve())
-        else:
-            resolved[key] = str((root_dir / part).resolve())
+        resolved[key] = str(part.resolve()) if part.is_absolute() else str((root_dir / part).resolve())
 
-    resolved["runs_root"] = resolved.get("runs_dir", str((root_dir / "_runs").resolve()))
-    resolved["results_root"] = resolved.get("results_dir", str((root_dir / "results").resolve()))
-    resolved["errors_root"] = resolved.get("errors_dir", str((root_dir / "_errors").resolve()))
+    resolved["runs_root"] = resolved["runs_dir"]
+    resolved["results_root"] = resolved["results_dir"]
+    resolved["errors_root"] = resolved["errors_dir"]
     return resolved
 
 
@@ -244,10 +228,8 @@ def apply_env_overrides(config: Dict[str, Any], env_values: Optional[Dict[str, s
 
     storage_routes = config.setdefault("storage_routes", {}) if isinstance(config.get("storage_routes"), dict) else {}
     config["storage_routes"] = storage_routes
-
     default_route = storage_routes.setdefault("default", {}) if isinstance(storage_routes.get("default"), dict) else {}
     storage_routes["default"] = default_route
-
     card_type_routes = (
         storage_routes.setdefault("card_type_routes", {}) if isinstance(storage_routes.get("card_type_routes"), dict) else {}
     )
@@ -255,14 +237,31 @@ def apply_env_overrides(config: Dict[str, Any], env_values: Optional[Dict[str, s
 
     naming_rules = config.setdefault("naming_rules", {}) if isinstance(config.get("naming_rules"), dict) else {}
     config["naming_rules"] = naming_rules
-    analysis = config.setdefault("analysis", {}) if isinstance(config.get("analysis"), dict) else {}
-    config["analysis"] = analysis
+    asr_strategy = config.setdefault("asr_strategy", {}) if isinstance(config.get("asr_strategy"), dict) else {}
+    config["asr_strategy"] = asr_strategy
+
+    auth_env_key = _env_text("TIKOMNI_AUTH_ENV_KEY", env_values=env_values)
+    if auth_env_key is not None:
+        runtime["auth_env_key"] = auth_env_key
+
+    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:
+            runtime[config_key] = value.rstrip("/")
 
     timeout_ms = _env_int("TIKOMNI_TIMEOUT_MS", env_values=env_values)
     if timeout_ms is not None:
         runtime["timeout_ms"] = timeout_ms
 
+    pending_timeout_sec = _env_int("TIKOMNI_U2_PENDING_TIMEOUT_SEC", env_values=env_values)
+    if pending_timeout_sec is not None and pending_timeout_sec > 0:
+        runtime["u2_pending_timeout_sec"] = pending_timeout_sec
+
     default_route["root_dir"] = _require_absolute_env("TIKOMNI_OUTPUT_ROOT", env_values=env_values)
+    default_route["card_root"] = _require_absolute_env("TIKOMNI_CARD_ROOT", env_values=env_values)
 
     for env_key, config_key in {
         "TIKOMNI_OUTPUT_RUNS_DIR": "runs_dir",
@@ -275,80 +274,49 @@ def apply_env_overrides(config: Dict[str, Any], env_values: Optional[Dict[str, s
 
     card_filename_pattern = _env_text("TIKOMNI_FILENAME_PATTERN_CARD", env_values=env_values)
     json_filename_pattern = _env_text("TIKOMNI_FILENAME_PATTERN_JSON", env_values=env_values)
-    legacy_filename_pattern = _env_text("TIKOMNI_FILENAME_PATTERN", env_values=env_values)
     if card_filename_pattern is not None:
         naming_rules["card_filename_pattern"] = card_filename_pattern
-    elif legacy_filename_pattern is not None:
-        naming_rules["card_filename_pattern"] = legacy_filename_pattern
     if json_filename_pattern is not None:
         naming_rules["json_filename_pattern"] = json_filename_pattern
 
-    analysis_provider = _env_text("TIKOMNI_ANALYSIS_PROVIDER", env_values=env_values)
-    if analysis_provider is not None:
-        analysis["provider"] = analysis_provider
-
-    analysis_timeout_sec = _env_int("TIKOMNI_ANALYSIS_TIMEOUT_SEC", env_values=env_values)
-    if analysis_timeout_sec is not None:
-        analysis["timeout_sec"] = analysis_timeout_sec
+    poll_interval_sec = _env_int("TIKOMNI_POLL_INTERVAL_SEC", env_values=env_values)
+    if poll_interval_sec is not None and poll_interval_sec > 0:
+        asr_strategy["poll_interval_sec"] = float(poll_interval_sec)
 
     path_locale = _normalize_path_locale(_read_env("TIKOMNI_PATH_LOCALE", env_values=env_values) or "zh")
     locale_routes = LOCALE_ROUTE_PRESETS.get(path_locale, LOCALE_ROUTE_PRESETS["zh"])
-
     for route_key, route_value in locale_routes.items():
-        existing = card_type_routes.get(route_key)
-        existing_prefix = ""
-        existing_parts: List[str] = []
-        if isinstance(existing, dict):
-            if isinstance(existing.get("prefix"), str):
-                existing_prefix = existing.get("prefix", "").strip()
-            if isinstance(existing.get("parts"), list) and existing.get("parts"):
-                existing_parts = [str(item) for item in existing.get("parts", []) if str(item).strip()]
-
         card_type_routes[route_key] = {
-            "prefix": existing_prefix or str(route_value.get("prefix") or ""),
-            "parts": existing_parts or _deep_clone(route_value.get("parts", [])),
+            "prefix": str(route_value.get("prefix") or "CBV"),
+            "parts": list(route_value.get("parts") or []),
         }
 
-    for route_key, env_name in CARD_ROUTE_ENV_KEYS.items():
-        raw_value = _env_text(env_name, env_values=env_values)
-        if raw_value is None:
-            continue
-
-        env_parts = _route_from_env(raw_value)
-        if not env_parts:
-            continue
-
-        current = card_type_routes.get(route_key)
-        prefix = ""
-        if isinstance(current, dict) and isinstance(current.get("prefix"), str):
-            prefix = current.get("prefix") or ""
-        if not prefix:
-            prefix = LOCALE_ROUTE_PRESETS["zh"].get(route_key, {}).get("prefix", "")
-
-        card_type_routes[route_key] = {
-            "prefix": prefix,
-            "parts": env_parts,
-        }
-
-    for route_key, env_name in CARD_PREFIX_ENV_KEYS.items():
-        prefix_value = _env_text(env_name, env_values=env_values)
-        if prefix_value is None:
-            continue
-        current = card_type_routes.get(route_key)
-        current_parts: List[str] = []
-        if isinstance(current, dict) and isinstance(current.get("parts"), list):
-            current_parts = [str(item) for item in current.get("parts", []) if str(item).strip()]
-        if not current_parts:
-            current_parts = list(LOCALE_ROUTE_PRESETS["zh"].get(route_key, {}).get("parts", []))
-        card_type_routes[route_key] = {
-            "prefix": prefix_value,
-            "parts": current_parts,
-        }
+    for route_key, env_names in CARD_ROUTE_ENV_KEYS.items():
+        for env_name in env_names:
+            raw_value = _env_text(env_name, env_values=env_values)
+            if raw_value is None:
+                continue
+            env_parts = _route_from_env(raw_value)
+            if not env_parts:
+                continue
+            current = card_type_routes.get(route_key) if isinstance(card_type_routes.get(route_key), dict) else {}
+            prefix = str(current.get("prefix") or LOCALE_ROUTE_PRESETS["zh"][route_key]["prefix"])
+            card_type_routes[route_key] = {"prefix": prefix, "parts": env_parts}
+            break
+
+    for route_key, env_names in CARD_PREFIX_ENV_KEYS.items():
+        for env_name in env_names:
+            prefix_value = _env_text(env_name, env_values=env_values)
+            if prefix_value is None:
+                continue
+            current = card_type_routes.get(route_key) if isinstance(card_type_routes.get(route_key), dict) else {}
+            parts = current.get("parts") if isinstance(current.get("parts"), list) else list(LOCALE_ROUTE_PRESETS["zh"][route_key]["parts"])
+            card_type_routes[route_key] = {"prefix": prefix_value, "parts": parts}
+            break
 
     resolved_storage = resolve_storage_paths(config)
     for key, value in resolved_storage.items():
         default_route[key] = value
-
     return config
 
 
@@ -357,10 +325,7 @@ def load_tikomni_config(
     env_file: Optional[str] = None,
     allow_process_env: bool = False,
 ) -> Tuple[Dict[str, Any], str]:
-    bootstrap = bootstrap_runtime_env(
-        primary_env_file=env_file,
-        allow_process_env=allow_process_env,
-    )
+    bootstrap = bootstrap_runtime_env(primary_env_file=env_file, allow_process_env=allow_process_env)
     env_values = bootstrap.get("effective_env", {}) if isinstance(bootstrap, dict) else {}
 
     explicit_config_requested = bool(

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

@@ -0,0 +1,145 @@
+#!/usr/bin/env python3
+"""Minimal MCP HTTP client for social-media-crawl."""
+
+from __future__ import annotations
+
+import json
+import urllib.request
+from dataclasses import dataclass
+from typing import Any, Dict, Optional
+
+
+def _parse_response_body(body: bytes) -> Any:
+    text = body.decode("utf-8", errors="replace").strip()
+    if not text:
+        return {}
+    if text.startswith("data:"):
+        payloads = []
+        for line in text.splitlines():
+            if not line.startswith("data:"):
+                continue
+            payload = line.split("data:", 1)[1].strip()
+            if payload:
+                payloads.append(payload)
+        if payloads:
+            return json.loads(payloads[-1])
+    return json.loads(text)
+
+
+@dataclass
+class McpResponse:
+    ok: bool
+    status_code: int
+    data: Any
+    session_id: Optional[str]
+    error_reason: Optional[str] = None
+
+
+class McpHttpClient:
+    def __init__(self, *, url: str, api_key: str, timeout_ms: int = 60000) -> None:
+        self.url = url.rstrip("/")
+        self.api_key = api_key
+        self.timeout_ms = timeout_ms
+        self.session_id: Optional[str] = None
+        self._next_id = 1
+
+    def _headers(self) -> Dict[str, str]:
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+            "Accept": "application/json, text/event-stream",
+        }
+        if self.session_id:
+            headers["mcp-session-id"] = self.session_id
+        return headers
+
+    def _request(self, payload: Dict[str, Any]) -> McpResponse:
+        req = urllib.request.Request(
+            self.url,
+            data=json.dumps(payload).encode("utf-8"),
+            headers=self._headers(),
+            method="POST",
+        )
+        try:
+            with urllib.request.urlopen(req, timeout=max(self.timeout_ms / 1000.0, 1.0)) as response:
+                body = response.read()
+                data = _parse_response_body(body)
+                session_id = response.headers.get("mcp-session-id") or response.headers.get("Mcp-Session-Id")
+                if session_id:
+                    self.session_id = session_id
+                return McpResponse(ok=True, status_code=response.getcode(), data=data, session_id=self.session_id)
+        except urllib.error.HTTPError as error:
+            body = error.read()
+            try:
+                data = _parse_response_body(body)
+            except Exception:
+                data = {"raw": body.decode("utf-8", errors="replace")}
+            return McpResponse(
+                ok=False,
+                status_code=error.code,
+                data=data,
+                session_id=self.session_id,
+                error_reason=f"http_error:{error.code}",
+            )
+        except Exception as error:
+            return McpResponse(
+                ok=False,
+                status_code=0,
+                data={},
+                session_id=self.session_id,
+                error_reason=f"request_failed:{type(error).__name__}:{error}",
+            )
+
+    def _rpc(self, method: str, params: Optional[Dict[str, Any]] = None, notification: bool = False) -> McpResponse:
+        payload: Dict[str, Any] = {"jsonrpc": "2.0", "method": method}
+        if not notification:
+            payload["id"] = self._next_id
+            self._next_id += 1
+        if params is not None:
+            payload["params"] = params
+        return self._request(payload)
+
+    def initialize(self) -> McpResponse:
+        response = self._rpc(
+            "initialize",
+            {
+                "protocolVersion": "2025-03-26",
+                "capabilities": {},
+                "clientInfo": {"name": "social-media-crawl", "version": "0.1.0"},
+            },
+        )
+        if response.ok:
+            self._rpc("notifications/initialized", notification=True)
+        return response
+
+    def tools_list(self) -> McpResponse:
+        if not self.session_id:
+            init = self.initialize()
+            if not init.ok:
+                return init
+        return self._rpc("tools/list")
+
+    def tool_call(self, name: str, arguments: Optional[Dict[str, Any]] = None) -> McpResponse:
+        if not self.session_id:
+            init = self.initialize()
+            if not init.ok:
+                return init
+        return self._rpc("tools/call", {"name": name, "arguments": arguments or {}})
+
+    def catalog_search(self, query: str) -> McpResponse:
+        return self.tool_call("catalog.search", {"query": query})
+
+    def endpoint_describe(self, endpoint: str) -> McpResponse:
+        return self.tool_call("endpoint.describe", {"endpoint": endpoint})
+
+    def api_call(self, endpoint: str, params: Optional[Dict[str, Any]] = None, body: Optional[Dict[str, Any]] = None, method: str = "GET") -> McpResponse:
+        return self.tool_call(
+            "api.call",
+            {"endpoint": endpoint, "params": params or {}, "body": body or {}, "method": method},
+        )
+
+    def u2_submit(self, file_url: str) -> McpResponse:
+        return self.tool_call("u2.submit", {"file_url": file_url})
+
+    def u2_query(self, task_id: str) -> McpResponse:
+        return self.tool_call("u2.query", {"task_id": task_id})

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

@@ -0,0 +1,63 @@
+#!/usr/bin/env python3
+"""Platform and object detection helpers."""
+
+from __future__ import annotations
+
+import urllib.request
+from dataclasses import dataclass, asdict
+from typing import Dict
+from urllib.parse import urlparse
+
+
+@dataclass
+class DetectionResult:
+    input_value: str
+    resolved_url: str
+    platform: str
+    object_type: str
+
+    def to_dict(self) -> Dict[str, str]:
+        return asdict(self)
+
+
+def resolve_final_url(input_value: str, timeout_ms: int = 10000) -> str:
+    candidate = str(input_value or "").strip()
+    if not candidate.startswith(("http://", "https://")):
+        return candidate
+    try:
+        request = urllib.request.Request(candidate, method="GET")
+        with urllib.request.urlopen(request, timeout=max(timeout_ms / 1000.0, 1.0)) as response:
+            return response.geturl() or candidate
+    except Exception:
+        return candidate
+
+
+def detect_target(input_value: str, timeout_ms: int = 10000) -> DetectionResult:
+    raw = str(input_value or "").strip()
+    resolved = resolve_final_url(raw, timeout_ms=timeout_ms)
+    candidate = resolved or raw
+    lower = candidate.lower()
+    host = urlparse(lower).netloc
+
+    platform = "unknown"
+    object_type = "unknown"
+
+    if any(token in host for token in ["douyin.com", "iesdouyin.com"]):
+        platform = "douyin"
+        if "/video/" in lower:
+            object_type = "work"
+        elif "/user/" in lower or "sec_uid=" in lower or "sec_user_id=" in lower:
+            object_type = "creator"
+    elif any(token in host for token in ["xiaohongshu.com", "xhslink.com"]):
+        platform = "xiaohongshu"
+        if any(token in lower for token in ["/discovery/item/", "/explore/"]):
+            object_type = "work"
+        elif any(token in lower for token in ["/user/profile/", "/user/", "/profile/"]):
+            object_type = "creator"
+
+    return DetectionResult(
+        input_value=raw,
+        resolved_url=resolved or raw,
+        platform=platform,
+        object_type=object_type,
+    )

package/skills/{single-work-analysis/scripts/pipeline/asr → social-media-crawl/scripts/core}/poll_u2_task.py

@@ -19,7 +19,7 @@ bootstrap_for_direct_run(__file__, __package__)
 import argparse
 from typing import Any, Callable, Dict, Optional
 
-from scripts.pipeline.asr.asr_pipeline import poll_u2_task_core
+from scripts.core.asr_pipeline import poll_u2_task_core
 from scripts.core.tikomni_common import extract_error_reason, resolve_runtime, write_json_stdout
 
 
@@ -31,6 +31,7 @@ def poll_u2_task(
     task_id: str,
     poll_interval_sec: float,
     max_polls: int,
+    pending_timeout_sec: Optional[int] = None,
     progress_callback: Optional[Callable[[Dict[str, Any]], None]] = None,
 ) -> Dict[str, Any]:
     return poll_u2_task_core(
@@ -40,6 +41,7 @@ def poll_u2_task(
         task_id=task_id,
         poll_interval_sec=poll_interval_sec,
         max_polls=max_polls,
+        pending_timeout_sec=pending_timeout_sec,
         progress_callback=progress_callback,
     )