@tikomni/skills 1.0.3 → 1.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tikomni/skills",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "TikOmni skill installer CLI for structured social media crawling in Codex, Claude Code, and OpenClaw",
   "license": "MIT",
   "homepage": "https://github.com/mark-ly-wang/TikOmni-Skills#readme",

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

@@ -1586,22 +1586,8 @@ def run_u2_asr_batch_with_timeout_retry(
         existing = mapped_results.get(file_url)
         if existing is None:
             mapped_results[file_url] = candidate
-            continue
-
-        old_score = (
-            1 if existing.get("ok") else 0,
-            len(str(existing.get("transcript_text") or "")),
-            1 if existing.get("transcription_url") else 0,
-            1 if not existing.get("error_reason") else 0,
-        )
-        new_score = (
-            1 if candidate.get("ok") else 0,
-            len(str(candidate.get("transcript_text") or "")),
-            1 if candidate.get("transcription_url") else 0,
-            1 if not candidate.get("error_reason") else 0,
-        )
-        if new_score > old_score:
-            mapped_results[file_url] = candidate
+        # When the provider returns file_url, treat it as the source of truth.
+        # item_index remains a fallback only for older payloads without file_url.
 
     mapped_results = hydrate_u2_batch_results_from_transcription_urls(
         mapped_results=mapped_results,

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

@@ -30,13 +30,105 @@ def build_api_trace(
     return payload
 
 
+def build_route_plan_entry(
+    *,
+    route_label: str,
+    endpoint: Optional[str],
+    method: str = "GET",
+    param_readiness: str = "ready",
+    param_reason: str = "",
+) -> Dict[str, Any]:
+    return {
+        "route_label": route_label,
+        "endpoint": endpoint,
+        "method": method.upper(),
+        "param_readiness": param_readiness,
+        "param_reason": param_reason,
+    }
+
+
+def build_attempted_route(
+    *,
+    route_label: str,
+    endpoint: Optional[str],
+    response: Optional[Dict[str, Any]] = None,
+    accepted: bool = False,
+    accept_reason: str = "",
+    fallback_reason: str = "",
+    param_readiness: str = "ready",
+    param_reason: str = "",
+    skipped: bool = False,
+    extra: Optional[Dict[str, Any]] = None,
+) -> Dict[str, Any]:
+    attempt: Dict[str, Any] = {
+        "route_label": route_label,
+        "endpoint": endpoint,
+        "accepted": bool(accepted),
+        "accept_reason": accept_reason,
+        "fallback_reason": fallback_reason,
+        "param_readiness": param_readiness,
+        "param_reason": param_reason,
+        "skipped": bool(skipped),
+    }
+    if isinstance(response, dict):
+        attempt.update(
+            {
+                "ok": response.get("ok"),
+                "status_code": response.get("status_code"),
+                "request_id": response.get("request_id"),
+                "error_reason": response.get("error_reason"),
+                "retry_attempt": response.get("retry_attempt", 0),
+                "rate_limit_wait_ms": response.get("rate_limit_wait_ms", 0),
+            }
+        )
+    else:
+        attempt.update(
+            {
+                "ok": None,
+                "status_code": None,
+                "request_id": None,
+                "error_reason": None,
+                "retry_attempt": 0,
+                "rate_limit_wait_ms": 0,
+            }
+        )
+    if extra:
+        attempt.update(extra)
+    return attempt
+
+
+def build_stage_status(
+    *,
+    stage: str,
+    status: str,
+    route_plan: Optional[List[Dict[str, Any]]] = None,
+    attempted_routes: Optional[List[Dict[str, Any]]] = None,
+    chosen_route: Optional[str] = None,
+    accept_reason: str = "",
+    fallback_reason: str = "",
+    error_reason: Optional[str] = None,
+    all_routes_failed: bool = False,
+) -> Dict[str, Any]:
+    return {
+        "stage": stage,
+        "status": status,
+        "route_plan": list(route_plan or []),
+        "attempted_routes": list(attempted_routes or []),
+        "chosen_route": chosen_route or "",
+        "accept_reason": accept_reason,
+        "fallback_reason": fallback_reason,
+        "error_reason": error_reason,
+        "all_routes_failed": bool(all_routes_failed),
+    }
+
+
 def build_fallback_trace_from_extract_trace(extract_trace: Optional[List[Dict[str, Any]]]) -> List[Dict[str, Any]]:
     """Build a compact fallback trace from runner extract trace."""
     if not extract_trace:
         return []
 
     trace: List[Dict[str, Any]] = []
-    include_tokens = ("primary", "effective", "fallback", "gate", "retry")
+    include_tokens = ("primary", "effective", "fallback", "gate", "retry", "attempt", "route_decision")
 
     for step in extract_trace:
         if not isinstance(step, dict):