coze_lab 0.1.16 → 0.1.18

package/index.js

@@ -4572,8 +4572,14 @@ function writeCodexHook(token, workspaceId, pythonCmd, codexHome, cloud) {
   if (!cloud) {
     envLines.push(`COZELOOP_API_TOKEN=${token}`);
   }
+  envLines.push(`CODEX_HOME=${home}`);
   envLines.push(`COZELOOP_HOOK_LOG=${logFile}`);
   envLines.push('TRACE_TO_COZELOOP=true');
+  if (process.env.COZELOOP_API_BASE_URL) {
+    envLines.push(`COZELOOP_API_BASE_URL=${process.env.COZELOOP_API_BASE_URL}`);
+  } else if (process.env.OTEL_ENDPOINT) {
+    envLines.push(`OTEL_ENDPOINT=${process.env.OTEL_ENDPOINT}`);
+  }
   // PPE 泳道：cozeloop SDK 读这两个环境变量，自动注入 x-tt-env / x-use-ppe header
   envLines.push(`x_tt_env=${PPE_TT_ENV}`);
   envLines.push(`x_use_ppe=${PPE_USE_PPE}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coze_lab",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "description": "Configure local AI agents (Claude Code, Codex, OpenClaw) to report traces to CozeLoop",
   "keywords": [
     "cozeloop",

package/scripts/codex/cozeloop_hook.py

@@ -46,6 +46,7 @@ _COZELOOP_CLIENT_ID = "46371084383473718052118955183420.app.coze"
 _COZE_API = "https://api.coze.cn"
 _REFRESH_THRESHOLD = 10 * 60
 _DEFAULT_WORKSPACE_ID = "7644910356078837760"  # hardcoded spaceID fallback
+_OTEL_SUFFIX = "/v1/loop/opentelemetry"
 
 
 # --- coze-context parsing -------------------------------------------------
@@ -98,6 +99,22 @@ def coze_context_tags(text: str) -> Dict[str, str]:
     return {f"coze_{k}": v for k, v in parse_coze_context(text).items()}
 
 
+def turn_coze_context(turn: Dict[str, Any]) -> Dict[str, str]:
+    """Extract coze-context from a grouped turn with fallbacks for Codex rollout shapes."""
+    texts = [turn.get("user_message_text", "")]
+    for msg in turn.get("input_messages", []):
+        if isinstance(msg, dict):
+            texts.append(str(msg.get("content", "")))
+    user_payload = turn.get("user_message")
+    if isinstance(user_payload, dict):
+        texts.append(extract_message_content_text(user_payload))
+    for text in texts:
+        ctx = parse_coze_context(text)
+        if ctx:
+            return ctx
+    return {}
+
+
 # --- trace upload failure / logid capture ---------------------------------
 def _extract_logid(msg: str) -> str:
     """Pull the server logid out of an SDK error message, if present.
@@ -190,6 +207,20 @@ def _refresh_token(refresh_tok: str):
         pass
     return None
 
+
+def _normalize_api_base_url(url: str) -> str:
+    base = (url or "").strip().rstrip("/")
+    if base.endswith(_OTEL_SUFFIX):
+        return base[:-len(_OTEL_SUFFIX)].rstrip("/")
+    return base
+
+
+def get_api_base_url() -> str:
+    return _normalize_api_base_url(
+        os.environ.get("COZELOOP_API_BASE_URL", "") or os.environ.get("OTEL_ENDPOINT", "")
+    )
+
+
 def get_fresh_token():
     creds = _load_credentials()
     if creds:
@@ -200,8 +231,14 @@ def get_fresh_token():
             new_token = _refresh_token(creds["refresh_token"])
             if new_token:
                 return new_token
-    # Cloud sandbox: token lives in COZE_API_TOKEN (no credentials.json / refresh).
-    return os.environ.get("COZELOOP_API_TOKEN") or os.environ.get("COZE_API_TOKEN")
+    token = os.environ.get("COZELOOP_API_TOKEN")
+    if token:
+        return token
+    if get_api_base_url():
+        return os.environ.get("COZE_API_TOKEN")
+    if os.environ.get("COZE_API_TOKEN"):
+        hook_log("COZE_API_TOKEN present but ignored without COZELOOP_API_BASE_URL or OTEL_ENDPOINT")
+    return None
 # -------------------------------------------------------------------------
 
 # --- SDK Import ---
@@ -366,6 +403,101 @@ def read_rollout_messages(transcript_path: str, start_line: int = 0) -> List[Dic
     return entries
 
 
+def _add_unique_path(paths: List[Path], p: Optional[Path]):
+    if not p:
+        return
+    try:
+        resolved = p.expanduser().resolve()
+    except Exception:
+        return
+    if resolved not in paths:
+        paths.append(resolved)
+
+
+def _candidate_codex_homes() -> List[Path]:
+    homes: List[Path] = []
+    _add_unique_path(homes, Path(os.environ["CODEX_HOME"]) if os.environ.get("CODEX_HOME") else None)
+
+    log_path = _log_file_path()
+    if log_path:
+        try:
+            log_parent = Path(log_path).expanduser().resolve().parent
+            if log_parent.name == "hooks":
+                _add_unique_path(homes, log_parent.parent)
+        except Exception:
+            pass
+
+    _add_unique_path(homes, Path.home() / ".codex")
+
+    agents_root = Path.home() / ".coze" / "agents"
+    try:
+        if agents_root.exists():
+            for child in agents_root.iterdir():
+                _add_unique_path(homes, child / "codex-home")
+    except Exception:
+        pass
+
+    return homes
+
+
+def _latest_file(paths: List[Path]) -> Optional[Path]:
+    existing = []
+    for p in paths:
+        try:
+            if p.is_file():
+                existing.append(p)
+        except Exception:
+            pass
+    if not existing:
+        return None
+    return max(existing, key=lambda p: p.stat().st_mtime)
+
+
+def find_latest_transcript() -> Optional[str]:
+    """Best-effort fallback when Codex does not pass hook stdin."""
+    candidates: List[Path] = []
+    for codex_home in _candidate_codex_homes():
+        sessions_dir = codex_home / "sessions"
+        if not sessions_dir.exists():
+            continue
+        try:
+            candidates.extend(sessions_dir.rglob("rollout-*.jsonl"))
+        except Exception as e:
+            hook_log(f"fallback scan failed dir={sessions_dir} error={repr(e)}")
+
+    latest = _latest_file(candidates)
+    if latest:
+        return str(latest)
+
+    for codex_home in _candidate_codex_homes():
+        sessions_dir = codex_home / "sessions"
+        if not sessions_dir.exists():
+            continue
+        try:
+            candidates.extend(sessions_dir.rglob("*.jsonl"))
+        except Exception:
+            pass
+
+    latest = _latest_file(candidates)
+    return str(latest) if latest else None
+
+
+def recover_hook_input(reason: str) -> Optional[Dict[str, Any]]:
+    transcript_path = find_latest_transcript()
+    if not transcript_path:
+        hook_log(f"fallback failed reason={reason} no transcript found")
+        print(f"[CozeLoop] Hook input missing ({reason}); no Codex transcript found.", file=sys.stderr)
+        return None
+    hook_log(f"fallback transcript reason={reason} path={transcript_path}")
+    print(f"[CozeLoop] Hook input missing ({reason}); fallback transcript: {transcript_path}", file=sys.stderr)
+    return {
+        "hook_event_name": "Stop",
+        "session_id": "",
+        "transcript_path": transcript_path,
+        "input_fallback": reason,
+    }
+
+
 def parse_session_meta(entries: List[Dict[str, Any]]) -> Dict[str, Any]:
     """Extract session identity from session_meta entry."""
     result = {
@@ -421,6 +553,8 @@ def is_real_user_message(payload: Dict[str, Any]) -> bool:
         if item.get("type") != "input_text":
             continue
         text = item.get("text", "")
+        if parse_coze_context(text):
+            return True
         if text.startswith("<environment_context>"):
             continue
         if text.startswith("<permissions instructions>"):
@@ -439,9 +573,10 @@ def extract_user_text(payload: Dict[str, Any]) -> str:
     for item in payload.get("content", []):
         if isinstance(item, dict) and item.get("type") == "input_text":
             text = item.get("text", "")
-            if (not text.startswith("<environment_context>") and
+            if (parse_coze_context(text) or
+                    (not text.startswith("<environment_context>") and
                     not text.startswith("<permissions instructions>") and
-                    not text.startswith("<turn_aborted>")):
+                    not text.startswith("<turn_aborted>"))):
                 parts.append(text)
     return "\n".join(parts)
 
@@ -726,6 +861,10 @@ def send_turns_to_cozeloop(turns: List[Dict[str, Any]], session_id: str, model_n
         "upload_timeout": 120,
         "trace_finish_event_processor": _make_finish_event_processor(),
     }
+    api_base_url = get_api_base_url()
+    if api_base_url:
+        client_kwargs["api_base_url"] = api_base_url
+        hook_log(f"api_base_url={api_base_url}")
     if workspace_id:
         client_kwargs["workspace_id"] = workspace_id
     if token:
@@ -764,7 +903,7 @@ def send_turns_to_cozeloop(turns: List[Dict[str, Any]], session_id: str, model_n
             # Inject coze-context kv (last occurrence across turns wins).
             coze_tags = {}
             for turn in turns:
-                t = coze_context_tags(turn.get("user_message_text", ""))
+                t = {f"coze_{k}": v for k, v in turn_coze_context(turn).items()}
                 if t:
                     coze_tags = t
             if coze_tags:
@@ -1076,28 +1215,41 @@ def main():
     try:
         raw_input = sys.stdin.read().strip()
         if not raw_input:
-            hook_log("skip no stdin")
+            hook_log("stdin empty, trying fallback")
             debug_log("No input received from stdin")
-            return
-        hook_input = json.loads(raw_input)
+            hook_input = recover_hook_input("empty_stdin")
+            if not hook_input:
+                return
+        else:
+            hook_input = json.loads(raw_input)
     except Exception as e:
-        hook_log(f"skip stdin parse error={repr(e)}")
+        hook_log(f"stdin parse error={repr(e)}, trying fallback")
         debug_log(f"Error reading hook input from stdin: {e}")
-        return
+        hook_input = recover_hook_input("stdin_parse_error")
+        if not hook_input:
+            return
 
     debug_log(f"Hook input: {json.dumps(hook_input, ensure_ascii=False)}")
 
     # Get transcript path
     transcript_path = hook_input.get("transcript_path")
     if not transcript_path:
-        hook_log("skip missing transcript_path")
+        hook_log("missing transcript_path, trying fallback")
         debug_log("No transcript_path in hook input")
-        return
+        recovered = recover_hook_input("missing_transcript_path")
+        if not recovered:
+            return
+        hook_input = recovered
+        transcript_path = hook_input.get("transcript_path")
 
     if not os.path.exists(transcript_path):
-        hook_log(f"skip transcript not found path={transcript_path}")
+        hook_log(f"transcript not found path={transcript_path}, trying fallback")
         debug_log(f"Transcript file not found: {transcript_path}")
-        return
+        recovered = recover_hook_input("transcript_not_found")
+        if not recovered:
+            return
+        hook_input = recovered
+        transcript_path = hook_input.get("transcript_path")
 
     # Load state
     state_file = get_state_file_path(transcript_path)
@@ -1168,7 +1320,7 @@ def main():
     # Send turns to CozeLoop — only if at least one turn carries coze-context.
     if turns:
         has_coze_ctx = any(
-            parse_coze_context(t.get("user_message_text", ""))
+            turn_coze_context(t)
             for t in turns
         )
         if not has_coze_ctx:

package/scripts/openclaw/dist/index.js

@@ -22,7 +22,11 @@ function safeClone(value) {
 // --- coze-context parsing ---------------------------------------------------
 // User input may embed a <coze-context>...</coze-context> block with key:value
 // lines (agent_id, session_id, message_id, account_id, ...). Parse the LAST
-// block and inject the pairs (prefixed "coze.") into the root span attributes.
+// block and inject the pairs (prefixed "coze_") into the root span attributes.
+// NOTE: prefix MUST be "coze_" (underscore) to match the cozelab backend trace
+// query field names (coze_message_id / coze_agent_id) and stay consistent with
+// the claude-code / codex hooks. Do NOT use "coze." (dot) — backend Eq filter
+// matches tag keys exactly and would never hit dotted keys.
 const COZE_CTX_OPEN = "<coze-context>";
 const COZE_CTX_CLOSE = "</coze-context>";
 function cozeInputToText(input) {
@@ -67,7 +71,7 @@ function parseCozeContext(input) {
         const key = line.slice(0, sep).trim();
         const value = line.slice(sep + 1).trim();
         if (key)
-            out["coze." + key] = value;
+            out["coze_" + key] = value;
     }
     return out;
 }