coze_lab 0.1.35 → 0.1.36

package/index.js

@@ -2,11 +2,8 @@
 'use strict';
 
 // ─── 0. Constants ─────────────────────────────────────────────────────────────
-const CLIENT_ID   = '46371084383473718052118955183420.app.coze';
-const WORKSPACE_ID = '7644910356078837760';
-// PPE 泳道：所有 cozeloop 上报 / OAuth 请求都带这两个 header（SDK 读 x_tt_env/x_use_ppe 环境变量自动注入）。
-const PPE_TT_ENV  = 'ppe_cozelab';
-const PPE_USE_PPE = '1';
+const CLIENT_ID   = '08972682140163281554629748278108.app.coze';
+const WORKSPACE_ID = '7649231955045072915';
 const COZE_API    = 'https://api.coze.cn';
 const CREDS_PATH  = require('path').join(require('os').homedir(), '.cozeloop', 'credentials.json');
 const PACKAGE_VERSION = require('./package.json').version;
@@ -139,4687 +136,6 @@ function loadOpenclawFiles() {
 }
 
 
-// ─── 2b. Embedded OpenClaw plugin files ─────────────────────────────────────
-
-// ─── 2c. Embedded refresh script ──────────────────────────────────────────────
-// ─── 2. Embedded Python hook scripts ─────────────────────────────────────────
-const CLAUDE_CODE_HOOK_PY = `\
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-CozeLoop Hook for Claude Code
-
-This hook integrates Claude Code with CozeLoop for tracing and observability.
-It captures conversation interactions from the local .jsonl file and sends them
-as traces to the CozeLoop platform.
-
-Usage:
-    1. Place this script in \`~/.claude/hooks/cozeloop_hook.py\`.
-    2. Configure the hook in \`~/.claude/settings.json\`.
-    3. Set environment variables \`COZELOOP_WORKSPACE_ID\` and \`COZELOOP_API_TOKEN\`
-       in your project's \`.claude/settings.local.json\`.
-    4. Run Claude Code as normal - traces will be sent automatically.
-"""
-
-import json
-import os
-import sys
-import glob
-import hashlib
-import time
-import urllib.request
-import urllib.error
-from datetime import datetime
-from pathlib import Path
-from typing import Optional, List, Dict, Any
-
-# --- SDK Import ---
-try:
-    import cozeloop
-    from cozeloop.spec.tracespec import (
-        Runtime, ModelInput, ModelMessage, ModelToolChoice,
-        ModelOutput, ModelChoice, ModelToolCall, ModelToolCallFunction,
-        ModelMessagePart, ModelMessagePartType
-    )
-except ImportError:
-    print("Error: cozeloop SDK not found. Please install it with: pip install cozeloop", file=sys.stderr)
-    sys.exit(1)
-
-# --- Configuration ---
-DEBUG = os.environ.get("CC_COZELOOP_DEBUG", "").lower() == "true"
-_COZELOOP_CLIENT_ID = "46371084383473718052118955183420.app.coze"
-_COZE_API = "https://api.coze.cn"
-_REFRESH_THRESHOLD = 10 * 60  # refresh when < 10 minutes remain
-
-def debug_log(message: str):
-    """Print debug message if debug mode is enabled."""
-    if DEBUG:
-        print(f"[COZELOOP_HOOK_DEBUG] {datetime.now().isoformat()} - {message}", file=sys.stderr)
-
-# --- Token refresh --------------------------------------------------------
-
-def _get_credentials_path() -> Path:
-    return Path.home() / ".cozeloop" / "credentials.json"
-
-def _load_credentials() -> Optional[Dict]:
-    path = _get_credentials_path()
-    if not path.exists():
-        return None
-    try:
-        return json.loads(path.read_text())
-    except Exception:
-        return None
-
-def _save_credentials(creds: Dict):
-    path = _get_credentials_path()
-    path.parent.mkdir(parents=True, exist_ok=True)
-    path.write_text(json.dumps(creds, indent=2))
-    os.chmod(path, 0o600)
-
-def _refresh_token(refresh_token: str) -> Optional[str]:
-    """Call Coze refresh token API. Returns new access_token or None on failure."""
-    try:
-        payload = json.dumps({
-            "grant_type": "refresh_token",
-            "client_id": _COZELOOP_CLIENT_ID,
-            "refresh_token": refresh_token,
-        }).encode()
-        req = urllib.request.Request(
-            f"{_COZE_API}/api/permission/oauth2/token",
-            data=payload,
-            headers={
-                "Content-Type": "application/json",
-                "x-tt-env": "ppe_cozelab",
-                "x-use-ppe": "1",
-            },
-        )
-        with urllib.request.urlopen(req, timeout=10) as resp:
-            data = json.loads(resp.read())
-        if data.get("access_token"):
-            existing = _load_credentials() or {}
-            creds = {
-                "access_token": data["access_token"],
-                "refresh_token": data.get("refresh_token", refresh_token),
-                "expires_at": data.get("expires_in", 0) * 1000,  # unix timestamp in seconds
-                "workspace_id": existing.get("workspace_id", ""),
-            }
-            _save_credentials(creds)
-            debug_log("Token refreshed successfully.")
-            return creds["access_token"]
-    except Exception as e:
-        debug_log(f"Token refresh failed: {e}")
-    return None
-
-def _token_from_credentials() -> Optional[str]:
-    creds = _load_credentials()
-    if not creds:
-        return None
-    expires_at_sec = creds.get("expires_at", 0) / 1000
-    remaining = expires_at_sec - time.time()
-    if remaining > _REFRESH_THRESHOLD:
-        debug_log(f"Cached token valid, expires in {int(remaining)}s.")
-        return creds.get("access_token")
-    if creds.get("refresh_token"):
-        debug_log(f"Token expiring in {int(remaining)}s, refreshing...")
-        new_token = _refresh_token(creds["refresh_token"])
-        if new_token:
-            return new_token
-        debug_log("Refresh failed.")
-    return None
-
-def get_fresh_token() -> Optional[str]:
-    """Return a valid access token, refreshing if needed."""
-    env_token = os.environ.get("COZELOOP_API_TOKEN")
-    env_coze_token = os.environ.get("COZE_API_TOKEN")
-    is_cloud = os.environ.get("COZELAB_ONBOARD_CLOUD", "").lower() in ("1", "true", "yes")
-    if is_cloud:
-        return env_token or env_coze_token or _token_from_credentials()
-    creds = _load_credentials()
-    if creds:
-        return _token_from_credentials()
-    return env_token or env_coze_token
-
-# -------------------------------------------------------------------------
-
-# --- State Management ---
-
-def get_state_file_path(conversation_file: str) -> str:
-    """Get the state file path for tracking processed messages."""
-    state_dir = Path.home() / ".claude" / "cozeloop_state"
-    state_dir.mkdir(parents=True, exist_ok=True)
-    file_hash = hashlib.md5(conversation_file.encode()).hexdigest()[:12]
-    return str(state_dir / f"state_{file_hash}.json")
-
-def load_state(state_file: str) -> Dict[str, Any]:
-    """Load the processing state from file."""
-    if os.path.exists(state_file):
-        try:
-            with open(state_file, 'r') as f:
-                return json.load(f)
-        except (json.JSONDecodeError, IOError) as e:
-            debug_log(f"Error loading state: {e}")
-    return {"last_processed_line": 0, "session_id": None}
-
-def save_state(state_file: str, state: Dict[str, Any]):
-    """Save the processing state to file."""
-    try:
-        with open(state_file, 'w') as f:
-            json.dump(state, f, indent=2)
-    except IOError as e:
-        debug_log(f"Error saving state: {e}")
-
-# --- Conversation File Handling ---
-
-def find_latest_conversation_file() -> Optional[str]:
-    """Find the most recently modified conversation file in ~/.claude/projects/."""
-    claude_dir = Path.home() / ".claude" / "projects"
-    if not claude_dir.exists():
-        debug_log(f"Claude projects directory not found: {claude_dir}")
-        return None
-
-    jsonl_files = list(claude_dir.rglob("*.jsonl"))
-    if not jsonl_files:
-        debug_log("No conversation files (*.jsonl) found.")
-        return None
-
-    latest_file = max(jsonl_files, key=lambda p: p.stat().st_mtime)
-    debug_log(f"Found latest conversation file: {latest_file}")
-    return str(latest_file)
-
-def read_new_messages(file_path: str, start_line: int = 0) -> List[Dict[str, Any]]:
-    """Read new messages from a conversation file since the last processed line."""
-    messages = []
-    try:
-        with open(file_path, 'r', encoding='utf-8') as f:
-            for i, line in enumerate(f):
-                if i < start_line:
-                    continue
-                line = line.strip()
-                if line:
-                    try:
-                        msg = json.loads(line)
-                        msg['_line_number'] = i
-                        messages.append(msg)
-                    except json.JSONDecodeError:
-                        debug_log(f"Skipping malformed JSON on line {i+1}")
-    except (IOError, FileNotFoundError) as e:
-        debug_log(f"Error reading conversation file: {e}")
-    return messages
-
-# --- Content Helpers ---
-
-def is_empty_content(content: Any) -> bool:
-    """Return True if content carries no meaningful data."""
-    if content is None:
-        return True
-    if isinstance(content, str):
-        return content.strip() == ""
-    if isinstance(content, list):
-        if len(content) == 0:
-            return True
-        if len(content) == 1 and isinstance(content[0], dict) and content[0].get("type") == "text" and content[0].get("text", "").strip() == "":
-            return True
-    return False
-
-def format_content(content: Any, truncate: int = 4096) -> str:
-    """Format message content for trace display."""
-    if isinstance(content, str):
-        return content[:truncate]
-    if isinstance(content, dict):
-        return json.dumps(content, ensure_ascii=False)[:truncate]
-    if isinstance(content, list):
-        return json.dumps(content, ensure_ascii=False)[:truncate]
-    return str(content)[:truncate]
-
-
-# --- Message Parsing and Grouping ---
-
-def is_tool_result_message(msg: Dict[str, Any]) -> bool:
-    """Check if a message is a tool_result (not a real user input)."""
-    content = msg.get("message", {}).get("content", [])
-    return isinstance(content, list) and any(
-        isinstance(item, dict) and item.get("type") == "tool_result"
-        for item in content
-    )
-
-def extract_tool_result_from_message(msg: Dict[str, Any]) -> List[Dict[str, Any]]:
-    """Extract tool_result items from a user message."""
-    content = msg.get("message", {}).get("content", [])
-    if isinstance(content, list):
-        return [item for item in content if isinstance(item, dict) and item.get("type") == "tool_result"]
-    return []
-
-
-def _extract_progress_inner_message(msg: Dict[str, Any]) -> Optional[Dict[str, Any]]:
-    """Extract the inner conversation message from a progress (sub-agent) message.
-
-    Progress messages have the inner message nested at data.message.message.
-    Returns a dict with keys: role, content, id, parentToolUseID, or None if not valid.
-    """
-    data = msg.get("data", {})
-    outer_msg = data.get("message", {})
-    inner_msg = outer_msg.get("message", {})
-    if not inner_msg:
-        return None
-
-    role = inner_msg.get("role")
-    content = inner_msg.get("content")
-    if not role or content is None:
-        return None
-
-    return {
-        "role": role,
-        "content": content,
-        "id": inner_msg.get("id"),
-        "usage": inner_msg.get("usage", {}),
-        "model": inner_msg.get("model"),
-        "parentToolUseID": msg.get("parentToolUseID"),
-        "agentId": data.get("agentId", ""),
-    }
-
-
-def _group_subagent_steps(progress_msgs: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
-    """Group sub-agent progress messages into steps (same logic as top-level).
-
-    Each step is an assistant message (model call) + its tool_calls + tool_results.
-    Returns list of steps in the same format as turn["steps"], but with simplified
-    assistant_message structure.
-    """
-    steps = []
-
-    for pmsg in progress_msgs:
-        role = pmsg.get("role")
-        content = pmsg.get("content", [])
-
-        if role == "user":
-            # Could be tool_result or user input for the sub-agent
-            if isinstance(content, list):
-                has_tool_result = any(
-                    isinstance(item, dict) and item.get("type") == "tool_result"
-                    for item in content
-                )
-                if has_tool_result and steps:
-                    for item in content:
-                        if isinstance(item, dict) and item.get("type") == "tool_result":
-                            steps[-1]["tool_results"].append(item)
-            # Skip non-tool-result user messages (sub-agent prompt)
-            continue
-
-        if role == "assistant":
-            tool_calls = []
-            if isinstance(content, list):
-                for item in content:
-                    if isinstance(item, dict) and item.get("type") == "tool_use":
-                        tool_calls.append(item)
-
-            msg_id = pmsg.get("id")
-            last_step = steps[-1] if steps else None
-            last_msg_id = last_step.get("_msg_id") if last_step else None
-
-            if last_step and msg_id and msg_id == last_msg_id:
-                # Same API response — merge
-                existing = last_step["assistant_message"].get("message", {}).get("content", [])
-                if isinstance(existing, list) and isinstance(content, list):
-                    existing.extend(content)
-                last_step["tool_calls"].extend(tool_calls)
-                usage = pmsg.get("usage", {})
-                if usage.get("input_tokens", 0) > 0 or usage.get("output_tokens", 0) > 0:
-                    last_step["assistant_message"]["message"]["usage"] = usage
-            else:
-                steps.append({
-                    "assistant_message": {
-                        "message": {
-                            "role": "assistant",
-                            "content": content,
-                            "id": msg_id,
-                            "model": pmsg.get("model", ""),
-                            "usage": pmsg.get("usage", {}),
-                        }
-                    },
-                    "tool_calls": tool_calls,
-                    "tool_results": [],
-                    "_msg_id": msg_id,
-                })
-
-    return steps
-
-
-def group_messages_into_turns(messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
-    """Group messages into conversation turns (user -> assistant -> tool_results).
-
-    A turn represents a complete interaction cycle starting from a real user input.
-    Within each turn, we track individual "steps" -- each step is a single model
-    invocation (assistant message) paired with the tool_results it triggered.
-
-    This captures the full chain:
-      user_input -> model_call_1 (tool_use) -> tool_result -> model_call_2 (tool_use)
-      -> tool_result -> ... -> model_call_N (final text)
-
-    Each step has:
-      - assistant_message: the assistant's response (one API call)
-      - tool_calls: tool_use items from this assistant message
-      - tool_results: matching tool_result items from the following user message(s)
-
-    Sub-agent (Task tool) progress messages are parsed and stored as
-    sub_steps on the step containing the parent tool call.
-    """
-    turns = []
-    current_turn = None
-
-    # First pass: collect progress messages grouped by parentToolUseID,
-    # and collect toolUseResult usage keyed by tool_use_id.
-    subagent_progress: Dict[str, List[Dict[str, Any]]] = {}
-    tool_use_result_usage: Dict[str, Dict[str, Any]] = {}
-    for msg in messages:
-        if msg.get("type") == "progress":
-            inner = _extract_progress_inner_message(msg)
-            if inner and inner.get("parentToolUseID"):
-                parent_id = inner["parentToolUseID"]
-                if parent_id not in subagent_progress:
-                    subagent_progress[parent_id] = []
-                subagent_progress[parent_id].append(inner)
-        # Collect toolUseResult usage from tool_result messages
-        tur = msg.get("toolUseResult")
-        if isinstance(tur, dict) and tur.get("usage"):
-            message = msg.get("message", {})
-            content = message.get("content", [])
-            if isinstance(content, list):
-                for item in content:
-                    if isinstance(item, dict) and item.get("type") == "tool_result":
-                        tid = item.get("tool_use_id", "")
-                        if tid:
-                            tool_use_result_usage[tid] = tur["usage"]
-
-    # Second pass: build turns from user/assistant messages
-    for msg in messages:
-        msg_type = msg.get("type")
-        role = msg.get("role")
-        message = msg.get("message", {})
-        message_role = message.get("role", "")
-
-        # Skip non-conversation messages
-        if msg_type in ("progress", "system", "file-history-snapshot"):
-            continue
-
-        # Check if this is a user message
-        is_user_msg = msg_type == "user" or role == "user" or message_role == "user"
-
-        if is_user_msg:
-            # Check if this is a tool_result message (should not start a new turn)
-            if is_tool_result_message(msg):
-                # Attach tool results to the last step of the current turn
-                if current_turn and current_turn["steps"]:
-                    tool_results = extract_tool_result_from_message(msg)
-                    current_turn["steps"][-1]["tool_results"].extend(tool_results)
-            else:
-                # This is a real user input, start a new turn
-                if current_turn:
-                    turns.append(current_turn)
-                current_turn = {
-                    "user_message": msg,
-                    "steps": [],
-                    "start_line": msg.get("_line_number", 0)
-                }
-        elif msg_type == "assistant" or role == "assistant" or message_role == "assistant":
-            if current_turn:
-                # Extract tool_use items from this line's content
-                tool_calls = []
-                content = message.get("content", [])
-                if isinstance(content, list):
-                    for item in content:
-                        if isinstance(item, dict) and item.get("type") == "tool_use":
-                            tool_calls.append(item)
-
-                # Claude Code writes text and tool_use from the same API response
-                # as separate JSONL lines sharing the same message.id.
-                # Merge them into a single step.
-                msg_id = message.get("id")
-                last_step = current_turn["steps"][-1] if current_turn["steps"] else None
-                last_msg_id = (last_step["assistant_message"].get("message", {}).get("id")
-                               if last_step else None)
-
-                if last_step and msg_id and msg_id == last_msg_id:
-                    # Same API response — merge content into the existing step
-                    existing_content = last_step["assistant_message"].get("message", {}).get("content", [])
-                    if isinstance(existing_content, list) and isinstance(content, list):
-                        existing_content.extend(content)
-                    last_step["tool_calls"].extend(tool_calls)
-                    # Carry over usage from the later line (earlier line typically has zeros)
-                    usage = message.get("usage", {})
-                    if usage.get("input_tokens", 0) > 0 or usage.get("output_tokens", 0) > 0:
-                        last_step["assistant_message"]["message"]["usage"] = usage
-                else:
-                    # New API response — create a new step
-                    current_turn["steps"].append({
-                        "assistant_message": msg,
-                        "tool_calls": tool_calls,
-                        "tool_results": [],
-                    })
-
-    # Don't forget the last turn
-    if current_turn:
-        turns.append(current_turn)
-
-    # Third pass: attach sub-agent steps, agentId, and total usage to their parent tool calls
-    for turn in turns:
-        for step in turn["steps"]:
-            for tc in step["tool_calls"]:
-                tool_id = tc.get("id", "")
-                if tool_id in subagent_progress:
-                    progress_msgs = subagent_progress[tool_id]
-                    tc["_sub_steps"] = _group_subagent_steps(progress_msgs)
-                    # Extract agentId (same for all messages under this parent)
-                    for pm in progress_msgs:
-                        if pm.get("agentId"):
-                            tc["_agent_id"] = pm["agentId"]
-                            break
-                    # Attach total usage from toolUseResult for token distribution
-                    if tool_id in tool_use_result_usage:
-                        tc["_total_usage"] = tool_use_result_usage[tool_id]
-
-    return turns
-
-
-# --- CozeLoop Message Helpers ---
-
-def _make_message(role: str, content: str = "", tool_calls: list = None,
-                   tool_call_id: str = "", parts: list = None) -> ModelMessage:
-    """Helper to create a CozeLoop ModelMessage with default fields."""
-    return ModelMessage(
-        role=role,
-        content=content,
-        reasoning_content="",
-        parts=parts or [],
-        name="",
-        tool_calls=tool_calls or [],
-        tool_call_id=tool_call_id or "",
-        metadata={}
-    )
-
-
-def _format_tool_output(result_content: Any, max_len: int = 2000) -> str:
-    """Format tool result content for span output.
-
-    When content is a list (e.g. Task tool results with multiple text blocks),
-    extract and join text parts instead of dumping raw JSON.
-    """
-    if isinstance(result_content, str):
-        if len(result_content) > max_len:
-            return result_content[:max_len] + "..."
-        return result_content
-
-    if isinstance(result_content, list):
-        text_parts = []
-        for item in result_content:
-            if isinstance(item, dict):
-                if item.get("type") == "text":
-                    text_parts.append(item.get("text", ""))
-                else:
-                    # Non-text items: serialize compactly
-                    text_parts.append(json.dumps(item, ensure_ascii=False))
-            elif isinstance(item, str):
-                text_parts.append(item)
-        joined = "\\n".join(text_parts)
-        if len(joined) > max_len:
-            return joined[:max_len] + "..."
-        return joined
-
-    s = str(result_content)
-    if len(s) > max_len:
-        return s[:max_len] + "..."
-    return s
-
-
-def _make_tool_result_message(result_content: Any, tool_call_id: str = "") -> ModelMessage:
-    """Create a role='tool' ModelMessage for model input.
-
-    When result_content is a list, items go into parts (not content) to avoid
-    dumping raw JSON into the content field.
-    """
-    if isinstance(result_content, list):
-        parts_list = []
-        for item in result_content:
-            if isinstance(item, dict):
-                item_type = item.get("type", "text")
-                if item_type == "text":
-                    parts_list.append(ModelMessagePart(type=ModelMessagePartType.TEXT, text=item.get("text", "")))
-                else:
-                    parts_list.append(ModelMessagePart(
-                        type=ModelMessagePartType.TEXT,
-                        text=json.dumps(item, ensure_ascii=False)[:4096]
-                    ))
-            elif isinstance(item, str):
-                parts_list.append(ModelMessagePart(type=ModelMessagePartType.TEXT, text=item))
-        return _make_message(
-            role="tool",
-            content="",
-            tool_call_id=tool_call_id,
-            parts=parts_list
-        )
-
-    # String or other scalar
-    return _make_message(
-        role="tool",
-        content=format_content(result_content),
-        tool_call_id=tool_call_id
-    )
-
-
-def _raw_content_to_input_message(raw_content: Any, role: str) -> List[ModelMessage]:
-    """Convert raw Claude content to CozeLoop ModelMessage(s) suitable for model input.
-
-    When content is a list:
-    - tool_use items -> ModelMessage.tool_calls (as ModelToolCall objects)
-    - tool_result items -> separate ModelMessage(role="tool") per result
-    - all other items (text, etc.) -> ModelMessage.parts (as ModelMessagePart objects)
-    - ModelMessage.content = empty when parts are used (avoid duplication)
-
-    When content is a string:
-    - Simple ModelMessage with content
-    """
-    if isinstance(raw_content, str):
-        return [_make_message(role, format_content(raw_content))]
-
-    if not isinstance(raw_content, list):
-        return [_make_message(role, format_content(raw_content))]
-
-    # Check if content is all tool_result items
-    all_tool_results = all(
-        isinstance(item, dict) and item.get("type") == "tool_result"
-        for item in raw_content if isinstance(item, dict)
-    ) and any(
-        isinstance(item, dict) and item.get("type") == "tool_result"
-        for item in raw_content
-    )
-
-    if all_tool_results:
-        messages = []
-        for item in raw_content:
-            if isinstance(item, dict) and item.get("type") == "tool_result":
-                result_content = item.get("content", "")
-                messages.append(_make_tool_result_message(
-                    result_content,
-                    tool_call_id=item.get("tool_use_id", "")
-                ))
-        return messages
-
-    # Mixed content: split into tool_calls, parts, and text
-    tc_list = []
-    parts_list = []
-    text_parts = []
-
-    for item in raw_content:
-        if not isinstance(item, dict):
-            continue
-        item_type = item.get("type", "")
-
-        if item_type == "tool_use":
-            tc_list.append(ModelToolCall(
-                id=item.get("id", ""),
-                type="function",
-                function=ModelToolCallFunction(
-                    name=item.get("name", ""),
-                    arguments=json.dumps(item.get("input", {}), ensure_ascii=False) if isinstance(item.get("input"), dict) else str(item.get("input", ""))
-                )
-            ))
-        elif item_type == "text":
-            t = item.get("text", "")
-            if t:
-                text_parts.append(t)
-                parts_list.append(ModelMessagePart(type=ModelMessagePartType.TEXT, text=t))
-        elif item_type in ("thinking", "redacted_thinking"):
-            pass  # skip internal thinking from input history
-        else:
-            parts_list.append(ModelMessagePart(
-                type=ModelMessagePartType.TEXT,
-                text=json.dumps(item, ensure_ascii=False)[:4096]
-            ))
-
-    content_text = "\\n".join(text_parts) if text_parts else ""
-    return [_make_message(
-        role=role,
-        content=content_text,
-        tool_calls=tc_list if tc_list else None,
-        parts=parts_list if parts_list else None
-    )]
-
-
-def _build_history_messages(history_turns: List[Dict[str, Any]]) -> list:
-    """Build cumulative history messages from previously processed turns."""
-    history_messages = []
-    for ht in (history_turns or []):
-        ht_user = ht.get("user_message", {}).get("message", {})
-        ht_user_content = ht_user.get("content") if ht_user else None
-        if ht_user and not is_empty_content(ht_user_content):
-            history_messages.append(_make_message("user", format_content(ht_user_content)))
-        for step in ht.get("steps", []):
-            msg = step.get("assistant_message", {})
-            asst_content = msg.get("message", {}).get("content")
-            if not is_empty_content(asst_content):
-                history_messages.extend(_raw_content_to_input_message(asst_content, "assistant"))
-            for tr in step.get("tool_results", []):
-                tr_content = tr.get("content", "")
-                history_messages.append(_make_tool_result_message(
-                    tr_content,
-                    tool_call_id=tr.get("tool_use_id", "")
-                ))
-    return history_messages
-
-
-# --- CozeLoop Trace Reporting ---
-
-def send_turns_to_cozeloop(turns: List[Dict[str, Any]], session_id: str, history_turns: Optional[List[Dict[str, Any]]] = None):
-    """Send conversation turns to CozeLoop.
-
-    Span hierarchy:
-      root_span (claude_code_request) [input=user_input, output=final_response]
-        +-- turn_span
-              |-- model_span (1st model call)
-              |-- tool_span / agent_span (tool call from 1st model response)
-              |-- model_span (2nd model call, after receiving tool result)
-              |-- tool_span / agent_span (tool call from 2nd model response)
-              |-- ...
-              +-- model_span (Nth model call, final text response)
-    """
-    if not turns:
-        return
-
-    debug_log(f"Initializing CozeLoop client for session: {session_id}")
-    token = get_fresh_token()
-    if token:
-        os.environ["COZELOOP_API_TOKEN"] = token
-    client = cozeloop.new_client()
-
-    try:
-        with client.start_span(name="claude_code_request", span_type="main") as root_span:
-            root_span.set_runtime(Runtime(library="claude-code"))
-            root_span.set_tags({
-                "thread_id": session_id,
-                "total_turns": len(turns),
-                "source": "claude_code"
-            })
-            root_span.set_baggage({
-                "thread_id": session_id,
-            })
-
-            # Set root span input: first user message across all turns
-            first_user_content = None
-            for turn in turns:
-                um = turn.get("user_message", {}).get("message", {})
-                uc = um.get("content") if um else None
-                if not is_empty_content(uc):
-                    first_user_content = uc
-                    break
-            if first_user_content is not None:
-                root_span.set_input(format_content(first_user_content))
-
-            # Build cumulative history from previously processed turns
-            history_messages = _build_history_messages(history_turns)
-
-            # Process each turn as a child span under the root
-            for i, turn in enumerate(turns):
-                try:
-                    steps = turn.get("steps", [])
-                    total_steps = len(steps)
-
-                    with client.start_span(name=f"turn_{i}", span_type="main") as turn_span:
-                        turn_span.set_runtime(Runtime(library="claude-code"))
-                        turn_span.set_tags({
-                            "thread_id": session_id,
-                            "turn_index": i,
-                            "total_steps": total_steps,
-                            "source": "claude_code",
-                        })
-
-                        # Extract user input for this turn
-                        user_message = turn.get("user_message", {}).get("message", {})
-                        user_raw_content = user_message.get("content") if user_message else None
-
-                        # Build input context for the first model call in this turn
-                        input_messages = list(history_messages)
-                        if not is_empty_content(user_raw_content):
-                            input_messages.append(_make_message("user", format_content(user_raw_content)))
-
-                        # Process each step: model_span + tool_spans
-                        for j, step in enumerate(steps):
-                            assistant_msg = step.get("assistant_message", {})
-                            assistant_message_obj = assistant_msg.get("message", {})
-                            raw_content = assistant_message_obj.get("content", [])
-                            model_name = assistant_message_obj.get("model", "claude-code")
-
-                            # --- Create model span for this step ---
-                            with client.start_span(name=f"model_call_{j}", span_type="model") as model_span:
-                                model_span.set_runtime(Runtime(library="claude-code"))
-                                model_span.set_model_name(model_name)
-
-                                # Set input: accumulated context up to this point
-                                model_span.set_input(ModelInput(
-                                    messages=list(input_messages),
-                                    tools=[],
-                                    tool_choice=ModelToolChoice(type="", function=None)
-                                ))
-
-                                # Build output: text -> parts, tool_use -> tool_calls, thinking -> reasoning_content
-                                text_parts = []
-                                tool_call_list = []
-                                parts_list = []
-                                thinking_parts = []
-                                if isinstance(raw_content, list):
-                                    for item in raw_content:
-                                        if not isinstance(item, dict):
-                                            continue
-                                        item_type = item.get("type", "")
-                                        if item_type == "text":
-                                            text = item.get("text", "")
-                                            if text:
-                                                text_parts.append(text)
-                                                parts_list.append(ModelMessagePart(type=ModelMessagePartType.TEXT, text=text))
-                                        elif item_type == "thinking":
-                                            thinking = item.get("thinking", "")
-                                            if thinking:
-                                                thinking_parts.append(thinking)
-                                        elif item_type == "redacted_thinking":
-                                            pass  # encrypted, cannot extract
-                                        elif item_type == "tool_use":
-                                            tool_call_list.append(ModelToolCall(
-                                                id=item.get("id", ""),
-                                                type="function",
-                                                function=ModelToolCallFunction(
-                                                    name=item.get("name", ""),
-                                                    arguments=json.dumps(item.get("input", {}), ensure_ascii=False) if isinstance(item.get("input"), dict) else str(item.get("input", ""))
-                                                )
-                                            ))
-                                        else:
-                                            parts_list.append(ModelMessagePart(
-                                                type=ModelMessagePartType.TEXT,
-                                                text=json.dumps(item, ensure_ascii=False)[:4096]
-                                            ))
-                                elif isinstance(raw_content, str) and raw_content:
-                                    text_parts.append(raw_content)
-
-                                content_text = "\\n".join(text_parts) if text_parts else ""
-                                reasoning_text = "\\n".join(thinking_parts) if thinking_parts else ""
-                                finish_reason = "tool_calls" if tool_call_list else "stop"
-
-                                output_choice = ModelChoice(
-                                    finish_reason=finish_reason,
-                                    index=0,
-                                    message=ModelMessage(
-                                        role="assistant",
-                                        content=content_text,
-                                        reasoning_content=reasoning_text,
-                                        parts=parts_list,
-                                        name="",
-                                        tool_calls=tool_call_list if tool_call_list else [],
-                                        tool_call_id="",
-                                        metadata={}
-                                    )
-                                )
-
-                                model_span.set_output(ModelOutput(choices=[output_choice]))
-
-                                # Set token usage for this specific model call
-                                usage = assistant_message_obj.get("usage", {})
-                                input_tokens = usage.get("input_tokens", 0)
-                                output_tokens = usage.get("output_tokens", 0)
-                                cache_creation = usage.get("cache_creation_input_tokens", 0)
-                                cache_read = usage.get("cache_read_input_tokens", 0)
-                                if input_tokens > 0 or cache_creation > 0 or cache_read > 0:
-                                    model_span.set_input_tokens(input_tokens + cache_creation + cache_read)
-                                if output_tokens > 0:
-                                    model_span.set_output_tokens(output_tokens)
-
-                            # Add this assistant message to context for subsequent steps
-                            if not is_empty_content(raw_content):
-                                input_messages.extend(_raw_content_to_input_message(raw_content, "assistant"))
-
-                            # --- Create tool spans for each tool call in this step ---
-                            for tool_call in step.get("tool_calls", []):
-                                tool_name = tool_call.get('name', 'unknown')
-                                sub_steps = tool_call.get("_sub_steps", [])
-                                agent_id = tool_call.get("_agent_id", "")
-                                is_agent = bool(sub_steps)
-
-                                # Task tool with sub-agent steps uses "agent" span type
-                                span_type = "agent" if is_agent else "tool"
-                                span_name = f"agent_{tool_name}" if is_agent else f"tool_{tool_name}"
-
-                                with client.start_span(name=span_name, span_type=span_type) as tool_span:
-                                    tool_span.set_runtime(Runtime(library="claude-code"))
-                                    tags = {
-                                        "tool_name": tool_name,
-                                        "tool_call_id": tool_call.get("id"),
-                                        "step_index": j,
-                                    }
-                                    if is_agent:
-                                        tags["agent_name"] = agent_id
-                                    tool_span.set_tags(tags)
-                                    tool_span.set_input(
-                                        json.dumps(tool_call.get("input", {}), ensure_ascii=False)[:2000]
-                                    )
-
-                                    # Find matching tool result
-                                    tool_id = tool_call.get("id")
-                                    for result in step.get("tool_results", []):
-                                        if result.get("tool_use_id") == tool_id:
-                                            result_content = result.get("content", "")
-                                            tool_span.set_output(_format_tool_output(result_content))
-                                            break
-
-                                    # If this tool call has sub-agent steps (e.g. Task tool),
-                                    # create child spans for each sub-agent model call and tool call.
-                                    if sub_steps:
-                                        # Initialize sub-agent input with the prompt (first user message)
-                                        sub_input_messages = []
-                                        task_prompt = tool_call.get("input", {}).get("prompt", "")
-                                        if task_prompt:
-                                            sub_input_messages.append(_make_message("user", format_content(task_prompt)))
-
-                                        # Distribute total usage evenly across sub-agent model steps.
-                                        total_usage = tool_call.get("_total_usage", {})
-                                        total_in = (total_usage.get("input_tokens", 0)
-                                                    + total_usage.get("cache_creation_input_tokens", 0)
-                                                    + total_usage.get("cache_read_input_tokens", 0))
-                                        total_out = total_usage.get("output_tokens", 0)
-                                        n_model_steps = len(sub_steps)
-                                        per_step_in = total_in // n_model_steps if n_model_steps > 0 else 0
-                                        per_step_out = total_out // n_model_steps if n_model_steps > 0 else 0
-                                        # Give remainder to the last step
-                                        remainder_in = total_in - per_step_in * n_model_steps if n_model_steps > 0 else 0
-                                        remainder_out = total_out - per_step_out * n_model_steps if n_model_steps > 0 else 0
-
-                                        for sk, sub_step in enumerate(sub_steps):
-                                            sub_asst = sub_step.get("assistant_message", {}).get("message", {})
-                                            sub_content = sub_asst.get("content", [])
-                                            sub_model = sub_asst.get("model") or "claude-code"
-
-                                            # Sub-agent model span
-                                            with client.start_span(name=f"subagent_model_{sk}", span_type="model") as sub_model_span:
-                                                sub_model_span.set_runtime(Runtime(library="claude-code"))
-                                                sub_model_span.set_model_name(sub_model)
-                                                sub_model_span.set_tags({"agent_name": agent_id})
-
-                                                # Set input: accumulated sub-agent context
-                                                sub_model_span.set_input(ModelInput(
-                                                    messages=list(sub_input_messages),
-                                                    tools=[],
-                                                    tool_choice=ModelToolChoice(type="", function=None)
-                                                ))
-
-                                                # Build output for sub-agent model call
-                                                sub_text_parts = []
-                                                sub_tc_list = []
-                                                sub_parts_list = []
-                                                sub_thinking_parts = []
-                                                if isinstance(sub_content, list):
-                                                    for item in sub_content:
-                                                        if not isinstance(item, dict):
-                                                            continue
-                                                        item_type = item.get("type", "")
-                                                        if item_type == "text":
-                                                            t = item.get("text", "")
-                                                            if t:
-                                                                sub_text_parts.append(t)
-                                                                sub_parts_list.append(ModelMessagePart(type=ModelMessagePartType.TEXT, text=t))
-                                                        elif item_type == "thinking":
-                                                            t = item.get("thinking", "")
-                                                            if t:
-                                                                sub_thinking_parts.append(t)
-                                                        elif item_type == "redacted_thinking":
-                                                            pass
-                                                        elif item_type == "tool_use":
-                                                            sub_tc_list.append(ModelToolCall(
-                                                                id=item.get("id", ""),
-                                                                type="function",
-                                                                function=ModelToolCallFunction(
-                                                                    name=item.get("name", ""),
-                                                                    arguments=json.dumps(item.get("input", {}), ensure_ascii=False) if isinstance(item.get("input"), dict) else str(item.get("input", ""))
-                                                                )
-                                                            ))
-                                                        else:
-                                                            sub_parts_list.append(ModelMessagePart(
-                                                                type=ModelMessagePartType.TEXT,
-                                                                text=json.dumps(item, ensure_ascii=False)[:4096]
-                                                            ))
-
-                                                sub_content_text = "\\n".join(sub_text_parts) if sub_text_parts else ""
-                                                sub_reasoning_text = "\\n".join(sub_thinking_parts) if sub_thinking_parts else ""
-                                                sub_finish = "tool_calls" if sub_tc_list else "stop"
-                                                sub_model_span.set_output(ModelOutput(choices=[ModelChoice(
-                                                    finish_reason=sub_finish,
-                                                    index=0,
-                                                    message=ModelMessage(
-                                                        role="assistant",
-                                                        content=sub_content_text,
-                                                        reasoning_content=sub_reasoning_text,
-                                                        parts=sub_parts_list,
-                                                        name="",
-                                                        tool_calls=sub_tc_list if sub_tc_list else [],
-                                                        tool_call_id="",
-                                                        metadata={}
-                                                    )
-                                                )]))
-
-                                                # Distribute tokens evenly; remainder goes to last step
-                                                step_in = per_step_in + (remainder_in if sk == n_model_steps - 1 else 0)
-                                                step_out = per_step_out + (remainder_out if sk == n_model_steps - 1 else 0)
-                                                if step_in > 0:
-                                                    sub_model_span.set_input_tokens(step_in)
-                                                if step_out > 0:
-                                                    sub_model_span.set_output_tokens(step_out)
-
-                                            # Add assistant output to sub-agent context
-                                            if not is_empty_content(sub_content):
-                                                sub_input_messages.extend(
-                                                    _raw_content_to_input_message(sub_content, "assistant")
-                                                )
-
-                                            # Sub-agent tool spans
-                                            for sub_tc in sub_step.get("tool_calls", []):
-                                                with client.start_span(name=f"tool_{sub_tc.get('name', 'unknown')}", span_type="tool") as sub_tool_span:
-                                                    sub_tool_span.set_tags({
-                                                        "tool_name": sub_tc.get("name"),
-                                                        "tool_call_id": sub_tc.get("id"),
-                                                        "agent_name": agent_id,
-                                                    })
-                                                    sub_tool_span.set_runtime(Runtime(library="claude-code"))
-                                                    sub_tool_span.set_input(
-                                                        json.dumps(sub_tc.get("input", {}), ensure_ascii=False)[:2000]
-                                                    )
-
-                                                    sub_tool_id = sub_tc.get("id")
-                                                    for sub_result in sub_step.get("tool_results", []):
-                                                        if sub_result.get("tool_use_id") == sub_tool_id:
-                                                            sr_content = sub_result.get("content", "")
-                                                            sub_tool_span.set_output(_format_tool_output(sr_content))
-                                                            break
-
-                                            # Add tool results to sub-agent context
-                                            for sub_result in sub_step.get("tool_results", []):
-                                                sr_content = sub_result.get("content", "")
-                                                sub_input_messages.append(_make_tool_result_message(
-                                                    sr_content,
-                                                    tool_call_id=sub_result.get("tool_use_id", "")
-                                                ))
-
-                            # Add tool results to context for subsequent model calls
-                            for result in step.get("tool_results", []):
-                                result_content = result.get("content", "")
-                                input_messages.append(_make_tool_result_message(
-                                    result_content,
-                                    tool_call_id=result.get("tool_use_id", "")
-                                ))
-
-                        # Append this turn's messages to history for subsequent turns
-                        if user_message and not is_empty_content(user_message.get("content")):
-                            history_messages.append(_make_message(
-                                "user", format_content(user_message.get("content"))
-                            ))
-                        for step in steps:
-                            msg = step.get("assistant_message", {})
-                            asst_content = msg.get("message", {}).get("content")
-                            if not is_empty_content(asst_content):
-                                history_messages.extend(_raw_content_to_input_message(asst_content, "assistant"))
-                            for tr in step.get("tool_results", []):
-                                tr_content = tr.get("content", "")
-                                history_messages.append(_make_tool_result_message(
-                                    tr_content,
-                                    tool_call_id=tr.get("tool_use_id", "")
-                                ))
-
-                except Exception as e:
-                    debug_log(f"Error processing turn {i}: {e}")
-                    continue
-
-            # Set root span output: last assistant text from the last step of the last turn
-            last_output = None
-            for turn in reversed(turns):
-                for step in reversed(turn.get("steps", [])):
-                    asst = step.get("assistant_message", {}).get("message", {})
-                    content = asst.get("content", [])
-                    if isinstance(content, list):
-                        text_parts = [
-                            item.get("text", "")
-                            for item in content
-                            if isinstance(item, dict) and item.get("type") == "text" and item.get("text")
-                        ]
-                        if text_parts:
-                            last_output = "\\n".join(text_parts)
-                            break
-                    elif isinstance(content, str) and content.strip():
-                        last_output = content
-                        break
-                if last_output:
-                    break
-            if last_output:
-                root_span.set_output(format_content(last_output))
-
-        debug_log(f"Successfully processed {len(turns)} turn(s) for session {session_id}")
-
-    except Exception as e:
-        debug_log(f"An error occurred while sending traces to CozeLoop: {e}")
-    finally:
-        # Crucial: close the client to ensure all buffered traces are sent.
-        client.close()
-        debug_log("CozeLoop client closed.")
-
-
-# --- Hook Input ---
-
-def read_hook_stdin() -> Dict[str, Any]:
-    """Read hook input from stdin (non-blocking).
-
-    Claude Code passes a JSON payload via stdin to hooks, containing fields like
-    transcript_path, session_id, hook_event_name, etc.
-    Returns empty dict if stdin is empty or not valid JSON.
-    """
-    try:
-        if not sys.stdin.isatty():
-            data = sys.stdin.read().strip()
-            if data:
-                result = json.loads(data)
-                debug_log(f"Read hook stdin: keys={list(result.keys())}")
-                return result
-    except Exception as e:
-        debug_log(f"Error reading hook stdin: {e}")
-    return {}
-
-
-# --- Main Execution ---
-
-def main():
-    """Main entry point for the hook script."""
-    debug_log("Hook started.")
-
-    # Check if tracing is enabled
-    if os.environ.get("TRACE_TO_COZELOOP", "").lower() == "false":
-        debug_log("TRACE_TO_COZELOOP is set to 'false', skipping")
-        return
-
-    # Read hook input from stdin (Claude Code provides transcript_path, session_id, etc.)
-    hook_input = read_hook_stdin()
-
-    # Determine conversation file: prefer stdin, fallback to file scan
-    conversation_file = hook_input.get("transcript_path")
-    if conversation_file:
-        conversation_file = os.path.expanduser(conversation_file)
-        if not os.path.exists(conversation_file):
-            debug_log(f"transcript_path from stdin does not exist: {conversation_file}")
-            conversation_file = None
-
-    if not conversation_file:
-        conversation_file = find_latest_conversation_file()
-
-    if not conversation_file:
-        debug_log("Execution skipped: No conversation file found.")
-        return
-
-    debug_log(f"Using conversation file: {conversation_file}")
-
-    # Load state to know where to start reading
-    state_file = get_state_file_path(conversation_file)
-    state = load_state(state_file)
-    last_processed_line = state.get("last_processed_line", 0)
-
-    # Read new messages from the file
-    new_messages = read_new_messages(conversation_file, last_processed_line)
-
-    # Determine session ID: prefer stdin, then messages, then state, then generate
-    session_id = hook_input.get("session_id")
-    if not session_id:
-        for msg in new_messages:
-            if msg.get("sessionId"):
-                session_id = msg.get("sessionId")
-                break
-    if not session_id:
-        if state.get("session_id"):
-            session_id = state["session_id"]
-        else:
-            session_id = f"claude-code-{datetime.now().strftime('%Y%m%d-%H%M%S')}-{os.getpid()}"
-            debug_log(f"Generated new session ID: {session_id}")
-
-    state["session_id"] = session_id
-    debug_log(f"Session ID: {session_id}")
-
-    if not new_messages:
-        debug_log("No new messages to process.")
-        return
-
-    debug_log(f"Found {len(new_messages)} new messages.")
-
-    # Read historical messages to build context for model input
-    history_turns = []
-    if last_processed_line > 0:
-        historical_messages = read_new_messages(conversation_file, 0)
-        historical_messages = [m for m in historical_messages if m.get("_line_number", 0) < last_processed_line]
-        history_turns = group_messages_into_turns(historical_messages)
-        debug_log(f"Loaded {len(history_turns)} historical turn(s) for context.")
-
-    # Group messages into turns and send to CozeLoop
-    turns = group_messages_into_turns(new_messages)
-    if turns:
-        send_turns_to_cozeloop(turns, session_id, history_turns)
-
-        # Update state with the new last processed line number
-        last_line_in_batch = max(msg.get("_line_number", 0) for msg in new_messages)
-        state["last_processed_line"] = last_line_in_batch + 1
-        save_state(state_file, state)
-        debug_log(f"State updated. Last processed line: {state['last_processed_line']}")
-
-    debug_log("Hook finished.")
-
-if __name__ == "__main__":
-    main()
-
-
-
-`;
-
-const CODEX_HOOK_PY = `\
-#!/usr/bin/env python3
-"""
-CozeLoop Hook for Codex CLI
-
-This hook integrates OpenAI Codex CLI with CozeLoop for tracing and observability.
-It captures conversation interactions from the rollout JSONL file and sends them
-to the CozeLoop platform for analysis.
-
-Usage:
-    1. Copy this script to ~/.codex/hooks/cozeloop_hook.py
-    2. Register the hook in ~/.codex/hooks.json
-    3. Set environment variables: COZELOOP_WORKSPACE_ID, COZELOOP_API_TOKEN
-    4. Run Codex CLI as normal - traces will be sent automatically on each turn end
-
-Hook input (via stdin):
-    {
-        "hook_event_name": "Stop",
-        "session_id": "...",
-        "turn_id": "...",
-        "transcript_path": "/Users/.../.codex/sessions/YYYY/MM/DD/rollout-xxx.jsonl"
-    }
-
-Subagent support:
-    When Codex spawns subagents, each subagent gets its own rollout file with:
-      session_meta.source = {"subagent": {"thread_spawn": {"parent_thread_id": "..."}}}
-    Subagent hooks do NOT report traces directly. Instead they save their
-    processed turn data to a per-agent file under ~/.codex/cozeloop_state/.
-    When the parent session's hook runs, it reads those saved files and includes
-    the subagent spans inside the same trace, producing a single trace per
-    conversation that contains both the main agent and all of its subagents.
-"""
-
-import json
-import os
-import sys
-import hashlib
-import time
-import urllib.request
-import urllib.error
-from datetime import datetime
-from pathlib import Path
-from typing import Optional, List, Dict, Any
-
-# --- Token refresh --------------------------------------------------------
-_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 -------------------------------------------------
-# User messages may embed a block like:
-#   <coze-context>
-#   account_id: 0
-#   agent_id: 7644920552473395499
-#   session_id: 7644919579054997796
-#   message_id: 04dd5246-...
-#   </coze-context>
-# We parse its key:value pairs and inject them into the trace.
-
-_COZE_CTX_OPEN = "<coze-context>"
-_COZE_CTX_CLOSE = "</coze-context>"
-
-
-def parse_coze_context(text: str) -> Dict[str, str]:
-    """Extract the LAST <coze-context> block's key:value pairs from text.
-
-    Returns {} if no block is present. Tag keys are prefixed with
-    'coze_' by the caller; here we return raw keys as written.
-    """
-    if not text or _COZE_CTX_OPEN not in text:
-        return {}
-    # Take the last occurrence (latest context wins).
-    open_idx = text.rfind(_COZE_CTX_OPEN)
-    close_idx = text.find(_COZE_CTX_CLOSE, open_idx)
-    if close_idx == -1:
-        return {}
-    body = text[open_idx + len(_COZE_CTX_OPEN):close_idx]
-    # The block may arrive with real newlines, OR with literal backslash-n
-    # (e.g. when the whole message is an embedded JSON string that was never
-    # un-escaped). Normalize both forms before splitting into lines.
-    body = body.replace("\\r\\n", "\n").replace("\\n", "\n").replace("\\r", "\n")
-    result: Dict[str, str] = {}
-    for line in body.splitlines():
-        line = line.strip()
-        if not line or ":" not in line:
-            continue
-        key, _, value = line.partition(":")
-        key = key.strip()
-        value = value.strip()
-        if key:
-            result[key] = value
-    return result
-
-
-def coze_context_tags(text: str) -> Dict[str, str]:
-    """Return coze-context kv as trace tags, prefixed with 'coze_'."""
-    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.
-
-    SDK failure messages embed it as 'logid=XXXX' (sometimes within brackets).
-    """
-    if not msg:
-        return ""
-    marker = "logid="
-    idx = msg.find(marker)
-    if idx == -1:
-        return ""
-    rest = msg[idx + len(marker):]
-    logid = []
-    for ch in rest:
-        if ch.isalnum():
-            logid.append(ch)
-        else:
-            break
-    return "".join(logid)
-
-
-def _make_finish_event_processor(upload_events: Optional[List[str]] = None):
-    """Return a trace_finish_event_processor that surfaces failures + logid.
-
-    The CozeLoop SDK calls this for each flush event; on failure we print the
-    server logid to stderr so it can be handed to platform support for tracing
-    the root cause (e.g. via \`bytedcli log get-logid-log <logid>\`).
-    """
-    def _processor(info):
-        try:
-            if not getattr(info, "is_event_fail", False):
-                hook_log("upload success")
-                return
-            detail = getattr(info, "detail_msg", "") or ""
-            if upload_events is not None:
-                upload_events.append(detail or "trace export failed")
-            logid = _extract_logid(detail)
-            if logid:
-                hook_log(f"upload failed logid={logid} detail={detail[:500]}")
-                print(f"[CozeLoop] 上报失败 logid={logid} (可用 bytedcli log get-logid-log {logid} 排查)", file=sys.stderr)
-            else:
-                hook_log(f"upload failed detail={detail[:500]}")
-                print(f"[CozeLoop] 上报失败: {detail[:300]}", file=sys.stderr)
-        except Exception:
-            pass
-    return _processor
-
-
-
-def _get_credentials_path() -> Path:
-    return Path.home() / ".cozeloop" / "credentials.json"
-
-def _load_credentials():
-    path = _get_credentials_path()
-    if not path.exists():
-        return None
-    try:
-        return json.loads(path.read_text())
-    except Exception:
-        return None
-
-def _save_credentials(creds):
-    path = _get_credentials_path()
-    path.parent.mkdir(parents=True, exist_ok=True)
-    path.write_text(json.dumps(creds, indent=2))
-    os.chmod(path, 0o600)
-
-def _refresh_token(refresh_tok: str):
-    try:
-        payload = json.dumps({
-            "grant_type": "refresh_token",
-            "client_id": _COZELOOP_CLIENT_ID,
-            "refresh_token": refresh_tok,
-        }).encode()
-        req = urllib.request.Request(
-            f"{_COZE_API}/api/permission/oauth2/token",
-            data=payload,
-            headers={
-                "Content-Type": "application/json",
-                "x-tt-env": "ppe_cozelab",
-                "x-use-ppe": "1",
-            },
-        )
-        with urllib.request.urlopen(req, timeout=10) as resp:
-            data = json.loads(resp.read())
-        if data.get("access_token"):
-            existing = _load_credentials() or {}
-            creds = {
-                "access_token": data["access_token"],
-                "refresh_token": data.get("refresh_token", refresh_tok),
-                "expires_at": data.get("expires_in", 0) * 1000,  # unix timestamp in seconds
-                "workspace_id": existing.get("workspace_id", ""),
-            }
-            _save_credentials(creds)
-            return creds["access_token"]
-    except Exception:
-        pass
-    return None
-
-
-def _normalize_api_base_url(url: str) -> str:
-    base = (url or "").strip().rstrip("/")
-    if base.endswith(_OTEL_SUFFIX + "/v1/traces"):
-        return base[:-len(_OTEL_SUFFIX + "/v1/traces")].rstrip("/")
-    if base.endswith("/api/v1/loop/opentelemetry/v1/traces"):
-        return base[:-len("/v1/loop/opentelemetry/v1/traces")].rstrip("/")
-    if base.endswith(_OTEL_SUFFIX):
-        return base[:-len(_OTEL_SUFFIX)].rstrip("/")
-    if base.endswith("/api/v1/loop/opentelemetry"):
-        return base[:-len("/v1/loop/opentelemetry")].rstrip("/")
-    if base.endswith("/api/v1"):
-        return base[:-len("/v1")].rstrip("/")
-    return base
-
-
-def get_api_base_url() -> str:
-    return _normalize_api_base_url(
-        os.environ.get("COZELOOP_API_BASE_URL", "")
-    )
-
-
-def _token_from_credentials():
-    creds = _load_credentials()
-    if not creds:
-        return None
-    remaining = creds.get("expires_at", 0) / 1000 - time.time()
-    if remaining > _REFRESH_THRESHOLD:
-        return creds.get("access_token")
-    if creds.get("refresh_token"):
-        new_token = _refresh_token(creds["refresh_token"])
-        if new_token:
-            return new_token
-    return None
-
-
-def get_fresh_token():
-    env_token = os.environ.get("COZELOOP_API_TOKEN")
-    env_coze_token = os.environ.get("COZE_API_TOKEN")
-    is_cloud = os.environ.get("COZELAB_ONBOARD_CLOUD", "").lower() in ("1", "true", "yes")
-    if is_cloud:
-        return env_token or env_coze_token or _token_from_credentials()
-
-    # Local onboard used to write a short-lived access token into cozeloop.env.
-    # If credentials exist but cannot be refreshed, do not fall back to that stale
-    # env token; failing closed keeps state from advancing on a known-bad token.
-    creds = _load_credentials()
-    if creds:
-        return _token_from_credentials()
-    if env_token and not env_coze_token:
-        token = _token_from_credentials()
-        if token:
-            return token
-        return env_token
-    if env_token:
-        return env_token
-    if env_coze_token:
-        return env_coze_token
-    return _token_from_credentials()
-# -------------------------------------------------------------------------
-
-# --- SDK Import ---
-# 最低版本：set_finish_time 是 cozeloop SDK 0.1.25 才引入的方法，云端预装旧版（<=0.1.24）
-# 调用会抛 AttributeError 并使整条 trace 上报失败。统一用能力探测（hasattr）判定，与
-# _set_finish_time_safe 兜底口径一致，避免版本号字符串比较的边界问题。
-_MIN_COZELOOP_SPEC = "cozeloop>=0.1.28"
-
-
-def _cozeloop_capable():
-    """已装 cozeloop 是否具备 set_finish_time 能力。未装/异常返回 None（无法判定）。"""
-    try:
-        import cozeloop  # noqa: F401
-    except ImportError:
-        return None
-    try:
-        return hasattr(cozeloop.Span, "set_finish_time")
-    except Exception:
-        return False
-
-
-def _ensure_cozeloop_sdk():
-    """确保 cozeloop 可 import 且尽量满足 set_finish_time 能力。
-
-    返回 True 表示 cozeloop 可 import（不保证版本达标——能力不足时由
-    _set_finish_time_safe 兜底，不阻断上报）；返回 False 表示完全无法 import。
-    """
-    capable = _cozeloop_capable()
-    if capable is True:
-        return True
-    # 已装但能力不足（capable is False）→ 需升级；未装（None）→ 需安装。
-    import subprocess
-    import importlib
-    import site
-    # 能力不足时强制升级到带下限的版本；未装时直接装下限版本。
-    pkg = _MIN_COZELOOP_SPEC
-    base_flags = ["--quiet", "--disable-pip-version-check", "--upgrade"]
-    attempts = (
-        [*base_flags, pkg],
-        [*base_flags, "--break-system-packages", pkg],
-        [*base_flags, "--break-system-packages", "--user", pkg],
-    )
-    for extra in attempts:
-        try:
-            subprocess.run(
-                [sys.executable, "-m", "pip", "install", *extra],
-                timeout=180, check=True,
-                stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
-            )
-        except Exception:
-            continue
-        try:
-            importlib.reload(site)
-            user_site = site.getusersitepackages()
-            for p in ([user_site] if isinstance(user_site, str) else list(user_site)):
-                if p and p not in sys.path:
-                    sys.path.insert(0, p)
-            importlib.invalidate_caches()
-            import cozeloop  # noqa: F401
-            print("[CozeLoop] cozeloop SDK installed/upgraded at runtime.", file=sys.stderr)
-            return True
-        except ImportError:
-            continue
-    # 升级没成功，但只要原本能 import（capable is False）就继续——兜底会处理能力缺失。
-    return capable is False
-
-
-if _ensure_cozeloop_sdk():
-    import cozeloop
-    from cozeloop.spec.tracespec import (
-        Runtime, ModelInput, ModelMessage, ModelToolChoice,
-        ModelOutput, ModelChoice, ModelToolCall, ModelToolCallFunction,
-        ModelMessagePart, ModelMessagePartType
-    )
-else:
-    print("Error: cozeloop SDK not found and auto-install failed. Try: pip install cozeloop", file=sys.stderr)
-    sys.exit(1)
-
-# --- Configuration ---
-DEBUG = os.environ.get("CC_COZELOOP_DEBUG", "").lower() == "true"
-
-
-def _log_file_path() -> str:
-    return os.environ.get("COZELOOP_HOOK_LOG", "").strip()
-
-
-def hook_log(message: str):
-    """Append one diagnostic line to the hook log, if configured."""
-    log_path = _log_file_path()
-    if not log_path:
-        return
-    try:
-        p = Path(log_path).expanduser()
-        p.parent.mkdir(parents=True, exist_ok=True)
-        with p.open("a", encoding="utf-8") as f:
-            f.write(f"{datetime.now().isoformat()} {message}\n")
-    except Exception:
-        pass
-
-
-def debug_log(message: str):
-    """Print debug message if debug mode is enabled."""
-    hook_log(f"DEBUG {message}")
-    if DEBUG:
-        print(f"[COZELOOP_HOOK_DEBUG] {datetime.now().isoformat()} - {message}", file=sys.stderr)
-
-
-# --- State Management ---
-
-def get_state_file_path(transcript_path: str) -> str:
-    """Get the state file path for tracking processed lines."""
-    state_dir = Path.home() / ".codex" / "cozeloop_state"
-    state_dir.mkdir(parents=True, exist_ok=True)
-    file_hash = hashlib.md5(transcript_path.encode()).hexdigest()[:12]
-    return str(state_dir / f"state_{file_hash}.json")
-
-
-def get_subagent_data_file(agent_session_id: str) -> str:
-    """Get the file path for storing subagent turn data."""
-    state_dir = Path.home() / ".codex" / "cozeloop_state"
-    state_dir.mkdir(parents=True, exist_ok=True)
-    return str(state_dir / f"subagent_{agent_session_id}.json")
-
-
-def save_subagent_data(agent_session_id: str, data: Dict[str, Any]):
-    """Save subagent turn data for later inclusion by parent hook."""
-    path = get_subagent_data_file(agent_session_id)
-    try:
-        with open(path, "w") as f:
-            json.dump(data, f, ensure_ascii=False)
-        debug_log(f"Saved subagent data for {agent_session_id}")
-    except Exception as e:
-        debug_log(f"Error saving subagent data for {agent_session_id}: {e}")
-
-
-def load_subagent_data(agent_session_id: str) -> Optional[Dict[str, Any]]:
-    """Load previously saved subagent turn data."""
-    path = get_subagent_data_file(agent_session_id)
-    if os.path.exists(path):
-        try:
-            with open(path, "r") as f:
-                return json.load(f)
-        except Exception as e:
-            debug_log(f"Error loading subagent data for {agent_session_id}: {e}")
-    return None
-
-
-def load_state(state_file: str) -> Dict[str, Any]:
-    """Load the processing state from file."""
-    if os.path.exists(state_file):
-        try:
-            with open(state_file, 'r') as f:
-                return json.load(f)
-        except Exception as e:
-            debug_log(f"Error loading state: {e}")
-    return {"last_processed_line": 0, "session_id": None, "conversation_history": []}
-
-
-def save_state(state_file: str, state: Dict[str, Any]):
-    """Save the processing state to file."""
-    try:
-        with open(state_file, 'w') as f:
-            json.dump(state, f)
-    except Exception as e:
-        debug_log(f"Error saving state: {e}")
-
-
-# --- Rollout File Parsing ---
-
-def read_rollout_messages(transcript_path: str, start_line: int = 0) -> List[Dict[str, Any]]:
-    """Read raw JSONL entries from the rollout file starting from a given line."""
-    entries = []
-    try:
-        with open(transcript_path, 'r') as f:
-            for i, line in enumerate(f):
-                if i < start_line:
-                    continue
-                line = line.strip()
-                if line:
-                    try:
-                        entry = json.loads(line)
-                        entry['_line_number'] = i
-                        entries.append(entry)
-                    except json.JSONDecodeError as e:
-                        debug_log(f"Error parsing line {i}: {e}")
-    except Exception as e:
-        debug_log(f"Error reading rollout file: {e}")
-    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 = {
-        "session_id": None,
-        "parent_session_id": None,
-        "agent_nickname": None,
-        "agent_role": None,
-        "is_subagent": False,
-        "subagent_content_start_line": None,
-    }
-    for entry in entries:
-        if entry.get("type") != "session_meta":
-            continue
-        p = entry.get("payload", {})
-        result["session_id"] = p.get("id")
-        result["agent_nickname"] = p.get("agent_nickname")
-        result["agent_role"] = p.get("agent_role")
-
-        source = p.get("source", "")
-        if isinstance(source, dict):
-            thread_spawn = source.get("subagent", {}).get("thread_spawn", {})
-            parent_id = thread_spawn.get("parent_thread_id")
-            if parent_id:
-                result["parent_session_id"] = parent_id
-                result["is_subagent"] = True
-        break
-
-    if result["is_subagent"]:
-        meta_count = 0
-        for entry in entries:
-            if entry.get("type") == "session_meta":
-                meta_count += 1
-                if meta_count == 2:
-                    result["subagent_content_start_line"] = entry.get("_line_number", 0) + 1
-                    break
-
-    return result
-
-
-# --- Message Content Helpers ---
-
-def is_real_user_message(payload: Dict[str, Any]) -> bool:
-    """Check whether a response_item/message(user) entry is a real user input."""
-    if payload.get("role") != "user":
-        return False
-    content = payload.get("content", [])
-    if not isinstance(content, list):
-        return False
-
-    for item in content:
-        if not isinstance(item, dict):
-            continue
-        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>"):
-            continue
-        if text.startswith("<turn_aborted>"):
-            continue
-        if text.strip():
-            return True
-
-    return False
-
-
-def extract_user_text(payload: Dict[str, Any]) -> str:
-    """Extract the visible text from a user message payload."""
-    parts = []
-    for item in payload.get("content", []):
-        if isinstance(item, dict) and item.get("type") == "input_text":
-            text = item.get("text", "")
-            if (parse_coze_context(text) or
-                    (not text.startswith("<environment_context>") and
-                    not text.startswith("<permissions instructions>") and
-                    not text.startswith("<turn_aborted>"))):
-                parts.append(text)
-    return "\n".join(parts)
-
-
-def extract_assistant_text(payload: Dict[str, Any]) -> str:
-    """Extract visible text from an assistant message payload."""
-    parts = []
-    for item in payload.get("content", []):
-        if isinstance(item, dict) and item.get("type") in ("output_text", "text"):
-            parts.append(item.get("text", ""))
-    return "\n".join(parts)
-
-
-def extract_message_content_text(payload: Dict[str, Any]) -> str:
-    """Extract all text content from a message payload regardless of role."""
-    parts = []
-    for item in payload.get("content", []):
-        if not isinstance(item, dict):
-            continue
-        text = item.get("text", "")
-        if text:
-            parts.append(text)
-    return "\n".join(parts)
-
-
-def truncate_text(text: str, limit: int = 12000) -> str:
-    """Truncate text to a maximum length."""
-    if len(text) <= limit:
-        return text
-    return text[:limit] + "..."
-
-
-# --- Message Grouping ---
-
-def _parse_ts(obj):
-    """从 codex entry/payload 的 timestamp 解析 datetime（带时区）。失败返回 None。
-
-    Codex rollout JSONL 每条 entry 顶层带 ISO8601 timestamp。建 span 时用它做
-    start_time，避免回放时所有 span 挤在几毫秒内。
-    """
-    if not isinstance(obj, dict):
-        return None
-    ts = obj.get("timestamp") or obj.get("_ts")
-    if not ts or not isinstance(ts, str):
-        return None
-    try:
-        return datetime.fromisoformat(ts.replace("Z", "+00:00"))
-    except Exception:
-        return None
-
-
-def _ts_ms(dt):
-    """datetime → 毫秒时间戳（int）；None → None。"""
-    return int(dt.timestamp() * 1000) if dt is not None else None
-
-
-def _set_finish_time_safe(span, dt):
-    """安全设置 span 结束时间。
-
-    set_finish_time 是 cozeloop SDK 0.1.25+ 的方法，云端旧版没有；缺失或异常都不能
-    让整条 trace 上报失败（real_*_ms tag 仍保留耗时信息）。
-    """
-    if dt is None:
-        return
-    fn = getattr(span, "set_finish_time", None)
-    if fn is None:
-        return
-    try:
-        fn(dt)
-    except Exception:
-        pass
-
-
-def _max_dt(*values):
-    result = None
-    for value in values:
-        if value is not None and (result is None or value > result):
-            result = value
-    return result
-
-
-def _parse_ts_value(value):
-    return _parse_ts({"_ts": value}) if value else None
-
-
-def _turn_timestamps(turn):
-    values = []
-    for item in [turn.get("user_message"), *turn.get("assistant_messages", [])]:
-        dt = _parse_ts(item)
-        if dt:
-            values.append(dt)
-    for item in [*turn.get("tool_calls", []), *turn.get("tool_results", [])]:
-        dt = _parse_ts(item)
-        if dt:
-            values.append(dt)
-    for sc in turn.get("subagent_calls", []):
-        for key in ("_start_ts", "_end_ts"):
-            dt = _parse_ts_value(sc.get(key))
-            if dt:
-                values.append(dt)
-    return values
-
-
-def _turn_bounds(turn):
-    values = _turn_timestamps(turn)
-    if not values:
-        return None, None
-    return min(values), max(values)
-
-
-def _assistant_bounds(turn):
-    values = []
-    for item in turn.get("assistant_messages", []):
-        dt = _parse_ts(item)
-        if dt:
-            values.append(dt)
-    if not values:
-        return None, None
-    return min(values), max(values)
-
-
-def group_messages_into_turns(entries: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
-    """Group raw JSONL entries into conversation turns.
-
-    Turn lifecycle:
-      - Opened by: event_msg / task_started
-      - Closed by: event_msg / task_complete (or next task_started)
-
-    Within a turn we collect:
-      - user_message       : first real user input
-      - assistant_messages : response_item/message role=assistant items
-      - tool_calls         : response_item/function_call items (excl. spawn/wait_agent)
-      - tool_results       : response_item/function_call_output items (excl. spawn/wait)
-      - input_messages     : messages sent as model input up to the user message
-      - subagent_calls     : spawn_agent calls with their agent_id and final result
-    """
-    turns = []
-    current_turn: Optional[Dict[str, Any]] = None
-    pending_calls: Dict[str, Dict[str, Any]] = {}
-
-    for entry in entries:
-        entry_type = entry.get("type")
-        payload = entry.get("payload", {})
-        # 把 entry 顶层 timestamp 注入 payload，供后续建 span 取真实时间
-        if isinstance(payload, dict) and entry.get("timestamp") and "_ts" not in payload:
-            payload["_ts"] = entry.get("timestamp")
-
-        # --- Turn lifecycle events ---
-        if entry_type == "event_msg":
-            msg_type = payload.get("type")
-            if msg_type == "task_started":
-                if current_turn is not None:
-                    turns.append(current_turn)
-                current_turn = {
-                    "turn_id": payload.get("turn_id"),
-                    "user_message": None,
-                    "user_message_text": "",
-                    "assistant_messages": [],
-                    "tool_calls": [],
-                    "tool_results": [],
-                    "input_messages": [],
-                    "subagent_calls": [],
-                    "token_usage": {},
-                    "start_line": entry.get("_line_number", 0),
-                }
-                pending_calls = {}
-            elif msg_type == "task_complete":
-                if current_turn is not None:
-                    turns.append(current_turn)
-                    current_turn = None
-                pending_calls = {}
-            elif msg_type == "token_count":
-                if current_turn is not None:
-                    info = payload.get("info") or {}
-                    current_turn["token_usage"] = info.get("last_token_usage", {})
-            continue
-
-        # --- Content items ---
-        if entry_type == "response_item":
-            item_type = payload.get("type")
-
-            if item_type == "message":
-                role = payload.get("role")
-                if role == "user" and is_real_user_message(payload):
-                    if current_turn is not None and current_turn["user_message"] is None:
-                        current_turn["user_message"] = payload
-                        current_turn["user_message_text"] = extract_user_text(payload)
-                    if current_turn is not None:
-                        current_turn["input_messages"].append({
-                            "role": "user",
-                            "content": extract_user_text(payload),
-                        })
-                elif role == "assistant":
-                    if current_turn is not None:
-                        current_turn["assistant_messages"].append(payload)
-                elif role in ("developer", "system"):
-                    if current_turn is not None:
-                        current_turn["input_messages"].append({
-                            "role": role,
-                            "content": extract_message_content_text(payload),
-                        })
-                else:
-                    if current_turn is not None:
-                        text = extract_message_content_text(payload)
-                        if text:
-                            current_turn["input_messages"].append({
-                                "role": role or "user",
-                                "content": text,
-                            })
-
-            elif item_type == "function_call":
-                if current_turn is None:
-                    continue
-                call_id = payload.get("call_id")
-                name = payload.get("name", "")
-                args_raw = payload.get("arguments", "{}")
-                try:
-                    args = json.loads(args_raw)
-                except (json.JSONDecodeError, TypeError):
-                    args = {"_raw": args_raw}
-
-                if name == "spawn_agent":
-                    subagent_call = {
-                        "call_id": call_id,
-                        "agent_id": None,
-                        "nickname": None,
-                        "role": args.get("agent_type"),
-                        "message": args.get("message", ""),
-                        "model": args.get("model"),
-                        "result": None,
-                        "_start_ts": payload.get("_ts"),
-                        "_end_ts": None,
-                    }
-                    current_turn["subagent_calls"].append(subagent_call)
-                    pending_calls[call_id] = {"kind": "spawn", "subagent_call": subagent_call}
-                elif name == "wait_agent":
-                    pending_calls[call_id] = {
-                        "kind": "wait",
-                        "ids": args.get("ids", []),
-                        "_start_ts": payload.get("_ts"),
-                    }
-                else:
-                    current_turn["tool_calls"].append({
-                        "call_id": call_id,
-                        "name": name,
-                        "input": args,
-                        "_ts": payload.get("_ts"),
-                    })
-                    pending_calls[call_id] = {"kind": "tool", "_start_ts": payload.get("_ts")}
-
-            elif item_type == "function_call_output":
-                if current_turn is None:
-                    continue
-                call_id = payload.get("call_id")
-                raw_output = payload.get("output", "")
-
-                pending = pending_calls.get(call_id, {})
-                kind = pending.get("kind", "tool")
-
-                if kind == "spawn":
-                    subagent_call = pending.get("subagent_call")
-                    if subagent_call is not None:
-                        try:
-                            out = json.loads(raw_output) if isinstance(raw_output, str) else raw_output
-                            subagent_call["agent_id"] = out.get("agent_id")
-                            subagent_call["nickname"] = out.get("nickname")
-                        except (json.JSONDecodeError, TypeError, AttributeError):
-                            pass
-                        subagent_call["_end_ts"] = payload.get("_ts")
-
-                elif kind == "wait":
-                    try:
-                        out = json.loads(raw_output) if isinstance(raw_output, str) else raw_output
-                        status = out.get("status", {}) if isinstance(out, dict) else {}
-                        for agent_id, agent_status in status.items():
-                            result_text = None
-                            if isinstance(agent_status, dict):
-                                result_text = agent_status.get("completed")
-                            for sc in current_turn["subagent_calls"]:
-                                if sc.get("agent_id") == agent_id and sc.get("result") is None:
-                                    sc["result"] = result_text
-                                    sc["_end_ts"] = payload.get("_ts")
-                                    break
-                    except (json.JSONDecodeError, TypeError, AttributeError):
-                        pass
-
-                else:
-                    current_turn["tool_results"].append({
-                        "call_id": call_id,
-                        "output": raw_output,
-                        "_ts": payload.get("_ts"),
-                    })
-
-    if current_turn is not None:
-        turns.append(current_turn)
-
-    # Drop turns with no user input and no assistant response
-    turns = [
-        t for t in turns
-        if t["user_message"] is not None or t["assistant_messages"]
-    ]
-
-    return turns
-
-
-# --- CozeLoop Trace Reporting ---
-
-def _make_model_message(role: str, content: str = "", tool_calls: list = None,
-                        tool_call_id: str = "") -> ModelMessage:
-    """Helper to create a CozeLoop ModelMessage."""
-    return ModelMessage(
-        role=role,
-        content=content,
-        reasoning_content="",
-        parts=[],
-        name="",
-        tool_calls=tool_calls or [],
-        tool_call_id=tool_call_id or "",
-        metadata={}
-    )
-
-
-def send_turns_to_cozeloop(turns: List[Dict[str, Any]], session_id: str, model_name: str = "codex",
-                           history_context: Optional[List[Dict[str, Any]]] = None) -> Optional[List[Dict[str, Any]]]:
-    """Send conversation turns to CozeLoop for tracing.
-
-    Span hierarchy:
-      root_span (codex_request) [input=user_input, output=final_response]
-        +-- turn_span (turn_0, turn_1, ...)
-              |-- model_span (assistant_response)
-              |-- tool_span (tool calls)
-              |-- subagent_span (subagent calls with nested turns)
-
-    Returns the updated history_context on success, or None on failure.
-    """
-    if not turns:
-        return history_context
-
-    debug_log(f"Initializing CozeLoop client for session: {session_id}")
-    token = get_fresh_token()
-    if token:
-        os.environ["COZELOOP_API_TOKEN"] = token
-        hook_log(f"token resolved prefix={token[:12]}...")
-        print(f"[CozeLoop] Token 获取成功 ({token[:12]}...)", file=sys.stderr)
-    else:
-        hook_log(
-            "token missing "
-            f"has_cozeloop_token={bool(os.environ.get('COZELOOP_API_TOKEN'))} "
-            f"has_coze_token={bool(os.environ.get('COZE_API_TOKEN'))} "
-            f"api_base_url={bool(get_api_base_url())}"
-        )
-        print("[CozeLoop] 警告: 未找到有效 Token，上报可能失败", file=sys.stderr)
-    creds = _load_credentials()
-    workspace_id = (creds or {}).get("workspace_id") or os.environ.get("COZELOOP_WORKSPACE_ID", "") or _DEFAULT_WORKSPACE_ID
-    os.environ["COZELOOP_WORKSPACE_ID"] = workspace_id
-    hook_log(f"workspace_id={workspace_id}")
-    upload_events: List[str] = []
-    client_kwargs = {
-        "ultra_large_report": True,
-        "upload_timeout": 120,
-        "trace_finish_event_processor": _make_finish_event_processor(upload_events),
-    }
-    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:
-        client_kwargs["api_token"] = token
-    client = cozeloop.new_client(**client_kwargs)
-    ctx: List[Dict[str, Any]] = list(history_context) if history_context else []
-
-    try:
-        # 整体时间范围：所有 user/assistant payload 的真实 timestamp 极值
-        _all_ts = []
-        for _t in turns:
-            _all_ts.extend(_turn_timestamps(_t))
-        root_start_dt = min(_all_ts) if _all_ts else None
-        root_end_dt = max(_all_ts) if _all_ts else None
-
-        with client.start_span(name="codex_request", span_type="main", start_time=root_start_dt) as root_span:
-            root_span.set_runtime(Runtime(library="codex-cli"))
-            root_tags = {
-                "thread_id": session_id,
-                "total_turns": len(turns),
-                "source": "codex_cli",
-            }
-            if root_start_dt is not None and root_end_dt is not None:
-                _set_finish_time_safe(root_span, root_end_dt)
-                root_tags["real_start_ms"] = _ts_ms(root_start_dt)
-                root_tags["real_end_ms"] = _ts_ms(root_end_dt)
-                root_tags["latency_ms"] = _ts_ms(root_end_dt) - _ts_ms(root_start_dt)
-            root_baggage = {
-                "thread_id": session_id,
-            }
-            # Inject coze-context kv (last occurrence across turns wins).
-            coze_tags = {}
-            for turn in turns:
-                t = {f"coze_{k}": v for k, v in turn_coze_context(turn).items()}
-                if t:
-                    coze_tags = t
-            if coze_tags:
-                root_tags.update(coze_tags)
-                root_baggage.update(coze_tags)
-            root_span.set_tags(root_tags)
-            root_span.set_baggage(root_baggage)
-
-            # Set root span input: all user messages
-            root_input_parts = []
-            for turn in turns:
-                text = turn.get("user_message_text", "")
-                if text:
-                    root_input_parts.append(text)
-            if root_input_parts:
-                root_span.set_input(truncate_text("\n\n".join(root_input_parts)))
-
-            # Set root span output: all assistant messages
-            root_output_parts = []
-            for turn in turns:
-                for assistant_payload in turn.get("assistant_messages", []):
-                    assistant_text = extract_assistant_text(assistant_payload)
-                    if assistant_text:
-                        root_output_parts.append(assistant_text)
-            if root_output_parts:
-                root_span.set_output(truncate_text("\n\n".join(root_output_parts)))
-
-            # Process each turn
-            for i, turn in enumerate(turns):
-                try:
-                    # turn 真实时间：start=user payload 时间；end=最后一条 assistant payload 时间
-                    turn_start_dt, turn_end_dt = _turn_bounds(turn)
-
-                    with client.start_span(name=f"turn_{i}", span_type="main", start_time=turn_start_dt) as turn_span:
-                        turn_span.set_runtime(Runtime(library="codex-cli"))
-                        _turn_tags = {
-                            "thread_id": session_id,
-                            "turn_index": i,
-                            "turn_id": turn.get("turn_id", ""),
-                            "source": "codex_cli",
-                        }
-                        if turn_start_dt is not None and turn_end_dt is not None:
-                            _set_finish_time_safe(turn_span, turn_end_dt)
-                            _turn_tags["real_start_ms"] = _ts_ms(turn_start_dt)
-                            _turn_tags["real_end_ms"] = _ts_ms(turn_end_dt)
-                            _turn_tags["latency_ms"] = _ts_ms(turn_end_dt) - _ts_ms(turn_start_dt)
-                        turn_span.set_tags(_turn_tags)
-
-                        # --- Model span for assistant response ---
-                        if turn.get("assistant_messages"):
-                            # model span start：第一条 assistant payload 时间，回退到 turn 起点
-                            _model_start_dt, _model_end_dt = _assistant_bounds(turn)
-                            if _model_start_dt is None:
-                                _model_start_dt = turn_start_dt
-                            if _model_end_dt is None:
-                                _model_end_dt = turn_end_dt
-                            with client.start_span(name="assistant_response", span_type="model", start_time=_model_start_dt) as model_span:
-                                model_span.set_runtime(Runtime(library="codex-cli"))
-                                model_span.set_model_name(model_name)
-                                if _model_start_dt is not None and _model_end_dt is not None:
-                                    _set_finish_time_safe(model_span, _model_end_dt)
-                                    model_span.set_tags({
-                                        "real_start_ms": _ts_ms(_model_start_dt),
-                                        "real_end_ms": _ts_ms(_model_end_dt),
-                                        "latency_ms": _ts_ms(_model_end_dt) - _ts_ms(_model_start_dt),
-                                    })
-
-                                # Build input messages: history + current turn input
-                                turn_input = turn.get("input_messages", [])
-                                if not turn_input:
-                                    turn_input = [{"role": "user", "content": turn.get("user_message_text", "")}]
-                                input_messages = ctx + turn_input
-
-                                model_messages = []
-                                for msg in input_messages:
-                                    model_messages.append(_make_model_message(
-                                        role=msg.get("role", "user"),
-                                        content=msg.get("content", "")
-                                    ))
-
-                                model_span.set_input(ModelInput(
-                                    messages=model_messages,
-                                    tools=[],
-                                    tool_choice=ModelToolChoice(type="", function=None)
-                                ))
-
-                                # Build output choices
-                                choices = []
-                                for assistant_payload in turn["assistant_messages"]:
-                                    assistant_text = extract_assistant_text(assistant_payload)
-                                    # Extract tool calls from assistant content
-                                    tc_list = []
-                                    for item in assistant_payload.get("content", []):
-                                        if isinstance(item, dict) and item.get("type") == "function_call":
-                                            tc_list.append(ModelToolCall(
-                                                id=item.get("call_id", ""),
-                                                type="function",
-                                                function=ModelToolCallFunction(
-                                                    name=item.get("name", ""),
-                                                    arguments=item.get("arguments", "")
-                                                )
-                                            ))
-
-                                    finish_reason = "tool_calls" if tc_list else "stop"
-                                    choices.append(ModelChoice(
-                                        finish_reason=finish_reason,
-                                        index=len(choices),
-                                        message=ModelMessage(
-                                            role="assistant",
-                                            content=assistant_text,
-                                            reasoning_content="",
-                                            parts=[],
-                                            name="",
-                                            tool_calls=tc_list,
-                                            tool_call_id="",
-                                            metadata={}
-                                        )
-                                    ))
-
-                                model_span.set_output(ModelOutput(choices=choices))
-
-                                # Set token usage
-                                token_usage = turn.get("token_usage", {})
-                                input_tokens = token_usage.get("input_tokens", 0)
-                                output_tokens = token_usage.get("output_tokens", 0)
-                                if input_tokens > 0:
-                                    model_span.set_input_tokens(input_tokens)
-                                if output_tokens > 0:
-                                    model_span.set_output_tokens(output_tokens)
-
-                        # --- Tool call spans ---
-                        for tool_call in turn.get("tool_calls", []):
-                            tool_name = tool_call.get("name", "unknown")
-                            tool_start_dt = _parse_ts(tool_call) or turn_start_dt
-                            tool_end_dt = None
-                            call_id = tool_call.get("call_id")
-                            for result in turn.get("tool_results", []):
-                                if result.get("call_id") == call_id:
-                                    tool_end_dt = _parse_ts(result)
-                                    break
-                            tool_finish_dt = _max_dt(tool_end_dt, tool_start_dt)
-                            with client.start_span(name=f"tool_{tool_name}", span_type="tool", start_time=tool_start_dt) as tool_span:
-                                tool_span.set_runtime(Runtime(library="codex-cli"))
-                                tool_tags = {
-                                    "tool_name": tool_name,
-                                    "call_id": call_id,
-                                }
-                                if tool_start_dt is not None and tool_finish_dt is not None:
-                                    _set_finish_time_safe(tool_span, tool_finish_dt)
-                                    tool_tags["real_start_ms"] = _ts_ms(tool_start_dt)
-                                    tool_tags["real_end_ms"] = _ts_ms(tool_finish_dt)
-                                    tool_tags["latency_ms"] = _ts_ms(tool_finish_dt) - _ts_ms(tool_start_dt)
-                                tool_span.set_tags(tool_tags)
-                                tool_span.set_input(
-                                    json.dumps(tool_call.get("input", {}), ensure_ascii=False)[:2000]
-                                )
-                                # Find matching tool result
-                                for result in turn.get("tool_results", []):
-                                    if result.get("call_id") == call_id:
-                                        output = result.get("output", "")
-                                        if isinstance(output, str) and len(output) > 2000:
-                                            output = output[:2000] + "..."
-                                        tool_span.set_output(str(output))
-                                        break
-
-                        # --- Subagent spans ---
-                        for sc in turn.get("subagent_calls", []):
-                            agent_id = sc.get("agent_id") or "unknown"
-                            nickname = sc.get("nickname") or agent_id
-                            subagent_start_dt = _parse_ts_value(sc.get("_start_ts")) or turn_start_dt
-                            subagent_end_dt = _parse_ts_value(sc.get("_end_ts")) or turn_end_dt
-                            subagent_finish_dt = _max_dt(subagent_end_dt, subagent_start_dt)
-
-                            with client.start_span(name=f"subagent_{nickname}", span_type="agent", start_time=subagent_start_dt) as subagent_span:
-                                subagent_span.set_runtime(Runtime(library="codex-cli"))
-                                subagent_tags = {
-                                    "agent_id": agent_id,
-                                    "agent_nickname": nickname,
-                                    "agent_role": sc.get("role") or "",
-                                    "agent_model": sc.get("model") or "",
-                                }
-                                if subagent_start_dt is not None and subagent_finish_dt is not None:
-                                    _set_finish_time_safe(subagent_span, subagent_finish_dt)
-                                    subagent_tags["real_start_ms"] = _ts_ms(subagent_start_dt)
-                                    subagent_tags["real_end_ms"] = _ts_ms(subagent_finish_dt)
-                                    subagent_tags["latency_ms"] = _ts_ms(subagent_finish_dt) - _ts_ms(subagent_start_dt)
-                                subagent_span.set_tags(subagent_tags)
-                                subagent_span.set_input(sc.get("message", "")[:2000])
-
-                                # Load and include saved subagent turn data
-                                sa_data = load_subagent_data(agent_id)
-                                if sa_data and sa_data.get("turns"):
-                                    sa_turns = sa_data["turns"]
-                                    sa_model = sa_data.get("model_name", "codex")
-
-                                    for si, sa_turn in enumerate(sa_turns):
-                                        sa_turn_start_dt, sa_turn_end_dt = _turn_bounds(sa_turn)
-                                        if sa_turn_start_dt is None:
-                                            sa_turn_start_dt = subagent_start_dt
-                                        if sa_turn_end_dt is None:
-                                            sa_turn_end_dt = sa_turn_start_dt
-                                        sa_turn_finish_dt = _max_dt(sa_turn_end_dt, sa_turn_start_dt)
-
-                                        with client.start_span(name=f"turn_{si}", span_type="main", start_time=sa_turn_start_dt) as sa_turn_span:
-                                            sa_turn_span.set_runtime(Runtime(library="codex-cli"))
-                                            sa_turn_tags = {
-                                                "turn_index": si,
-                                                "turn_id": sa_turn.get("turn_id", ""),
-                                                "agent_name": nickname,
-                                            }
-                                            if sa_turn_start_dt is not None and sa_turn_finish_dt is not None:
-                                                _set_finish_time_safe(sa_turn_span, sa_turn_finish_dt)
-                                                sa_turn_tags["real_start_ms"] = _ts_ms(sa_turn_start_dt)
-                                                sa_turn_tags["real_end_ms"] = _ts_ms(sa_turn_finish_dt)
-                                                sa_turn_tags["latency_ms"] = _ts_ms(sa_turn_finish_dt) - _ts_ms(sa_turn_start_dt)
-                                            sa_turn_span.set_tags(sa_turn_tags)
-
-                                            # Subagent model span
-                                            if sa_turn.get("assistant_messages"):
-                                                sa_model_start_dt, sa_model_end_dt = _assistant_bounds(sa_turn)
-                                                if sa_model_start_dt is None:
-                                                    sa_model_start_dt = sa_turn_start_dt
-                                                if sa_model_end_dt is None:
-                                                    sa_model_end_dt = sa_turn_end_dt
-                                                sa_model_finish_dt = _max_dt(sa_model_end_dt, sa_model_start_dt)
-                                                with client.start_span(name="assistant_response", span_type="model", start_time=sa_model_start_dt) as sa_model_span:
-                                                    sa_model_span.set_runtime(Runtime(library="codex-cli"))
-                                                    sa_model_span.set_model_name(sa_model)
-                                                    sa_model_tags = {"agent_name": nickname}
-                                                    if sa_model_start_dt is not None and sa_model_finish_dt is not None:
-                                                        _set_finish_time_safe(sa_model_span, sa_model_finish_dt)
-                                                        sa_model_tags["real_start_ms"] = _ts_ms(sa_model_start_dt)
-                                                        sa_model_tags["real_end_ms"] = _ts_ms(sa_model_finish_dt)
-                                                        sa_model_tags["latency_ms"] = _ts_ms(sa_model_finish_dt) - _ts_ms(sa_model_start_dt)
-                                                    sa_model_span.set_tags(sa_model_tags)
-
-                                                    sa_input = sa_turn.get("input_messages", [])
-                                                    if not sa_input:
-                                                        sa_input = [{"role": "user", "content": sa_turn.get("user_message_text", "")}]
-                                                    sa_model_messages = []
-                                                    for msg in sa_input:
-                                                        sa_model_messages.append(_make_model_message(
-                                                            role=msg.get("role", "user"),
-                                                            content=msg.get("content", "")
-                                                        ))
-                                                    sa_model_span.set_input(ModelInput(
-                                                        messages=sa_model_messages,
-                                                        tools=[],
-                                                        tool_choice=ModelToolChoice(type="", function=None)
-                                                    ))
-
-                                                    sa_choices = []
-                                                    for ap in sa_turn["assistant_messages"]:
-                                                        sa_choices.append(ModelChoice(
-                                                            finish_reason="stop",
-                                                            index=len(sa_choices),
-                                                            message=ModelMessage(
-                                                                role="assistant",
-                                                                content=extract_assistant_text(ap),
-                                                                reasoning_content="",
-                                                                parts=[],
-                                                                name="",
-                                                                tool_calls=[],
-                                                                tool_call_id="",
-                                                                metadata={}
-                                                            )
-                                                        ))
-                                                    sa_model_span.set_output(ModelOutput(choices=sa_choices))
-
-                                                    sa_token = sa_turn.get("token_usage", {})
-                                                    if sa_token.get("input_tokens", 0) > 0:
-                                                        sa_model_span.set_input_tokens(sa_token["input_tokens"])
-                                                    if sa_token.get("output_tokens", 0) > 0:
-                                                        sa_model_span.set_output_tokens(sa_token["output_tokens"])
-
-                                            # Subagent tool spans
-                                            for sa_tc in sa_turn.get("tool_calls", []):
-                                                sa_tool_name = sa_tc.get("name", "unknown")
-                                                sa_tool_start_dt = _parse_ts(sa_tc) or sa_turn_start_dt
-                                                sa_tool_end_dt = None
-                                                sa_cid = sa_tc.get("call_id")
-                                                for sa_r in sa_turn.get("tool_results", []):
-                                                    if sa_r.get("call_id") == sa_cid:
-                                                        sa_tool_end_dt = _parse_ts(sa_r)
-                                                        break
-                                                sa_tool_finish_dt = _max_dt(sa_tool_end_dt, sa_tool_start_dt)
-                                                with client.start_span(name=f"tool_{sa_tool_name}", span_type="tool", start_time=sa_tool_start_dt) as sa_tool_span:
-                                                    sa_tool_span.set_runtime(Runtime(library="codex-cli"))
-                                                    sa_tool_tags = {
-                                                        "tool_name": sa_tool_name,
-                                                        "call_id": sa_cid,
-                                                        "agent_name": nickname,
-                                                    }
-                                                    if sa_tool_start_dt is not None and sa_tool_finish_dt is not None:
-                                                        _set_finish_time_safe(sa_tool_span, sa_tool_finish_dt)
-                                                        sa_tool_tags["real_start_ms"] = _ts_ms(sa_tool_start_dt)
-                                                        sa_tool_tags["real_end_ms"] = _ts_ms(sa_tool_finish_dt)
-                                                        sa_tool_tags["latency_ms"] = _ts_ms(sa_tool_finish_dt) - _ts_ms(sa_tool_start_dt)
-                                                    sa_tool_span.set_tags(sa_tool_tags)
-                                                    sa_tool_span.set_input(
-                                                        json.dumps(sa_tc.get("input", {}), ensure_ascii=False)[:2000]
-                                                    )
-                                                    for sa_r in sa_turn.get("tool_results", []):
-                                                        if sa_r.get("call_id") == sa_cid:
-                                                            sa_out = sa_r.get("output", "")
-                                                            if isinstance(sa_out, str) and len(sa_out) > 2000:
-                                                                sa_out = sa_out[:2000] + "..."
-                                                            sa_tool_span.set_output(str(sa_out))
-                                                            break
-
-                                    debug_log(f"Included {len(sa_turns)} subagent turns for {nickname} ({agent_id})")
-                                else:
-                                    debug_log(f"No saved data found for subagent {nickname} ({agent_id})")
-
-                                result_text = sc.get("result") or ""
-                                if len(result_text) > 2000:
-                                    result_text = result_text[:2000] + "..."
-                                subagent_span.set_output(result_text)
-
-                        # Update conversation context for subsequent turns
-                        if turn.get("user_message_text"):
-                            ctx.append({"role": "user", "content": turn["user_message_text"]})
-                        for assistant_payload in turn.get("assistant_messages", []):
-                            assistant_text = extract_assistant_text(assistant_payload)
-                            if assistant_text:
-                                ctx.append({"role": "assistant", "content": assistant_text})
-
-                except Exception as e:
-                    debug_log(f"Error processing turn {i}: {e}")
-                    continue
-
-        hook_log(f"processed turns={len(turns)} session_id={session_id}")
-        debug_log(f"Successfully processed {len(turns)} turn(s) for session {session_id}")
-
-    except Exception as e:
-        hook_log(f"send exception={repr(e)}")
-        debug_log(f"An error occurred while sending traces to CozeLoop: {e}")
-        return None
-    finally:
-        client.close()
-        hook_log("client closed")
-        debug_log("CozeLoop client closed.")
-
-    if upload_events:
-        hook_log(f"upload failed state not advanced failures={len(upload_events)} detail={upload_events[-1][:500]}")
-        return None
-
-    return ctx
-
-
-# --- Main Execution ---
-
-def main():
-    """Main entry point for the Codex CozeLoop hook."""
-    print("[CozeLoop] Hook triggered (Codex).", file=sys.stderr)
-    hook_log("hook triggered")
-    debug_log("Codex CozeLoop hook started.")
-
-    # Check if tracing is enabled
-    if os.environ.get("TRACE_TO_COZELOOP", "").lower() == "false":
-        hook_log("skip trace disabled")
-        debug_log("TRACE_TO_COZELOOP is set to 'false', skipping")
-        return
-
-    # Read hook input from stdin
-    try:
-        raw_input = sys.stdin.read().strip()
-        if not raw_input:
-            hook_log("stdin empty, trying fallback")
-            debug_log("No input received from stdin")
-            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"stdin parse error={repr(e)}, trying fallback")
-        debug_log(f"Error reading hook input from stdin: {e}")
-        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("missing transcript_path, trying fallback")
-        debug_log("No transcript_path in hook input")
-        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"transcript not found path={transcript_path}, trying fallback")
-        debug_log(f"Transcript file not found: {transcript_path}")
-        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)
-    state = load_state(state_file)
-
-    # Read new entries
-    entries = read_rollout_messages(transcript_path, state["last_processed_line"])
-
-    if not entries:
-        hook_log(f"skip no new entries transcript={transcript_path}")
-        debug_log("No new entries to process")
-        return
-
-    hook_log(f"read entries={len(entries)} from_line={state['last_processed_line']} transcript={transcript_path}")
-    debug_log(f"Read {len(entries)} new entries from line {state['last_processed_line']}")
-
-    # Parse session identity
-    all_entries_for_meta = read_rollout_messages(transcript_path, 0)
-    session_info = parse_session_meta(all_entries_for_meta)
-
-    session_id = session_info["session_id"] or hook_input.get("session_id", "")
-    parent_session_id = session_info["parent_session_id"]
-    agent_nickname = session_info["agent_nickname"]
-    agent_role = session_info["agent_role"]
-    is_subagent = session_info["is_subagent"]
-    subagent_content_start = session_info.get("subagent_content_start_line")
-
-    # Filter subagent entries to only include their own content
-    if is_subagent and subagent_content_start is not None:
-        entries = [e for e in entries if e.get("_line_number", 0) >= subagent_content_start]
-        debug_log(f"Filtered subagent entries from line {subagent_content_start}, {len(entries)} remaining")
-
-    # Determine model name
-    model_name = "codex"
-    for entry in entries:
-        if entry.get("type") == "turn_context":
-            model_name = entry.get("payload", {}).get("model", model_name)
-            break
-
-    if not session_id:
-        session_id = f"codex_{datetime.now().strftime('%Y%m%d_%H%M%S')}_{os.getpid()}"
-
-    state["session_id"] = session_id
-    debug_log(f"Session ID: {session_id}, parent: {parent_session_id}, "
-              f"is_subagent: {is_subagent}, nickname: {agent_nickname}, model: {model_name}")
-
-    # Group entries into turns
-    turns = group_messages_into_turns(entries)
-    debug_log(f"Grouped into {len(turns)} turns")
-
-    # If this is a subagent, save data for parent to include later
-    if is_subagent:
-        save_subagent_data(session_id, {
-            "session_id": session_id,
-            "parent_session_id": parent_session_id,
-            "agent_nickname": agent_nickname,
-            "agent_role": agent_role,
-            "model_name": model_name,
-            "turns": turns[-1:],
-        })
-        last_line = max(e.get("_line_number", 0) for e in entries) + 1
-        state["last_processed_line"] = last_line
-        save_state(state_file, state)
-        hook_log(f"subagent saved session_id={session_id} turns={len(turns[-1:])} last_line={last_line}")
-        debug_log("Subagent data saved, hook completed")
-        return
-
-    # Send turns to CozeLoop — only if at least one turn carries coze-context.
-    if turns:
-        has_coze_ctx = any(
-            turn_coze_context(t)
-            for t in turns
-        )
-        if not has_coze_ctx:
-            hook_log(f"skip no coze-context turns={len(turns)} session_id={session_id}")
-            debug_log("No coze-context found in any turn, skipping upload.")
-            return
-        history_context = state.get("conversation_history", [])
-        updated_history = send_turns_to_cozeloop(
-            turns, session_id, model_name,
-            history_context=history_context,
-        )
-        if updated_history is not None:
-            last_line = max(e.get("_line_number", 0) for e in entries) + 1
-            state["last_processed_line"] = last_line
-            state["conversation_history"] = updated_history
-            save_state(state_file, state)
-            hook_log(f"state advanced last_line={last_line} session_id={session_id}")
-            debug_log(f"State updated, last processed line: {last_line}")
-        else:
-            hook_log(f"send failed state not advanced session_id={session_id}")
-            debug_log("Send failed, state not advanced")
-    else:
-        hook_log(f"skip no turns session_id={session_id}")
-        debug_log("No turns to send")
-
-    hook_log("hook completed")
-    debug_log("Codex CozeLoop hook completed.")
-
-
-if __name__ == "__main__":
-    main()
-
-`;
-
-// ─── 2b. Embedded OpenClaw plugin files ─────────────────────────────────────
-const OPENCLAW_PLUGIN_FILES = {
-  "dist/index.js": `import { CozeloopExporter } from "./cozeloop-exporter.js";
-import { readFileSync, readdirSync, existsSync } from "node:fs";
-import { join, resolve } from "node:path";
-import { createRequire } from "node:module";
-const require = createRequire(import.meta.url);
-const { version: PLUGIN_VERSION } = require("../package.json");
-import { homedir } from "node:os";
-function generateId(length = 16) {
-    const chars = "0123456789abcdef";
-    let result = "";
-    for (let i = 0; i < length; i++) {
-        result += chars[Math.floor(Math.random() * chars.length)];
-    }
-    return result;
-}
-function safeClone(value) {
-    if (typeof globalThis.structuredClone === "function") {
-        return globalThis.structuredClone(value);
-    }
-    return JSON.parse(JSON.stringify(value));
-}
-function resolveOpenclawStateDir() {
-    const override = process.env.OPENCLAW_STATE_DIR?.trim() || process.env.CLAWDBOT_STATE_DIR?.trim();
-    if (override)
-        return resolve(override.startsWith("~") ? override.replace(/^~(?=$|[\\\\/])/, homedir()) : override);
-    const home = homedir();
-    const newDir = join(home, ".openclaw");
-    try {
-        if (existsSync(newDir))
-            return newDir;
-    }
-    catch { /* ignore */ }
-    for (const legacy of [".clawdbot", ".moldbot", ".moltbot"]) {
-        const legacyDir = join(home, legacy);
-        try {
-            if (existsSync(legacyDir))
-                return legacyDir;
-        }
-        catch { /* ignore */ }
-    }
-    return newDir;
-}
-function resolveAgentIdFromHookCtx(hookCtx) {
-    const explicit = hookCtx.agentId?.trim()?.toLowerCase();
-    if (explicit)
-        return explicit;
-    const sessionKey = hookCtx.sessionKey?.trim()?.toLowerCase();
-    if (sessionKey) {
-        const match = sessionKey.match(/^agent:([^:]+):/);
-        if (match?.[1])
-            return match[1];
-    }
-    return "main";
-}
-function resolveSessionFile(hookCtx) {
-    try {
-        const stateDir = resolveOpenclawStateDir();
-        const agentId = resolveAgentIdFromHookCtx(hookCtx);
-        const sessionsDir = join(stateDir, "agents", agentId, "sessions");
-        const sessionId = (hookCtx.sessionId || "");
-        let targetFile;
-        const files = readdirSync(sessionsDir);
-        if (sessionId) {
-            for (const f of files) {
-                if (!f.endsWith(".jsonl"))
-                    continue;
-                if (f.includes(".deleted.") || f.includes(".reset."))
-                    continue;
-                if (f.startsWith(sessionId)) {
-                    targetFile = join(sessionsDir, f);
-                    break;
-                }
-            }
-        }
-        if (!targetFile) {
-            const jsonlFiles = files.filter((f) => f.endsWith(".jsonl") && !f.includes(".deleted.") && !f.includes(".reset."));
-            if (jsonlFiles.length > 0) {
-                targetFile = join(sessionsDir, jsonlFiles[jsonlFiles.length - 1]);
-            }
-        }
-        return targetFile;
-    }
-    catch {
-        return undefined;
-    }
-}
-function formatAssistantOutput(content, stopReason) {
-    const contentItems = Array.isArray(content) ? content : [];
-    const toolCalls = [];
-    const messageContent = [];
-    for (const item of contentItems) {
-        if (!item || typeof item !== "object") {
-            messageContent.push(item);
-            continue;
-        }
-        const itemType = item.type;
-        if (itemType === "toolCall") {
-            toolCalls.push({
-                function: {
-                    arguments: typeof item.arguments === "string" ? item.arguments : JSON.stringify(item.arguments ?? item.input ?? {}),
-                    name: item.name ?? "",
-                },
-                id: item.id ?? "",
-                type: "function",
-            });
-        }
-        else if (itemType === "text") {
-            messageContent.push({ type: "text", text: item.text ?? "" });
-        }
-        else if (itemType === "thinking") {
-            messageContent.push({
-                type: "thinking",
-                thinking: item.thinking ?? "",
-                signature: item.signature,
-            });
-        }
-        else {
-            messageContent.push(item);
-        }
-    }
-    const message = {
-        content: messageContent.length === 1 && messageContent[0]?.type === "text"
-            ? (messageContent[0].text ?? "")
-            : messageContent,
-        role: "assistant",
-        tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
-        function_call: null,
-        provider_specific_fields: null,
-    };
-    return {
-        choices: [
-            {
-                finish_reason: stopReason === "toolUse" ? "tool_calls" : "stop",
-                message,
-            },
-        ],
-    };
-}
-function convertAssistantContentForMessages(content) {
-    if (!Array.isArray(content))
-        return [{ type: "text", text: String(content ?? "") }];
-    const result = [];
-    for (const item of content) {
-        if (!item || typeof item !== "object") {
-            result.push(item);
-            continue;
-        }
-        if (item.type === "toolCall") {
-            result.push({
-                type: "tool_use",
-                id: item.id ?? "",
-                name: item.name ?? "",
-                input: item.arguments ?? item.input ?? {},
-            });
-        }
-        else if (item.type === "thinking") {
-            result.push({
-                type: "thinking",
-                thinking: item.thinking ?? "",
-                signature: item.signature,
-            });
-        }
-        else {
-            result.push(item);
-        }
-    }
-    return result;
-}
-function convertToolResultsForMessages(toolResultEntries) {
-    const messages = [];
-    for (const tr of toolResultEntries) {
-        let textContent = "";
-        if (Array.isArray(tr.content)) {
-            const parts = tr.content;
-            textContent = parts
-                .filter((p) => p?.type === "text")
-                .map((p) => String(p.text ?? ""))
-                .join("\\n");
-        }
-        else if (typeof tr.content === "string") {
-            textContent = tr.content;
-        }
-        else {
-            textContent = JSON.stringify(tr.content);
-        }
-        messages.push({
-            role: "tool",
-            content: textContent,
-            tool_call_id: tr.toolCallId ?? "",
-        });
-    }
-    return messages;
-}
-function parseEntryWrittenAt(entry) {
-    const ts = entry.timestamp;
-    if (typeof ts === "string") {
-        const ms = new Date(ts).getTime();
-        if (!Number.isNaN(ms))
-            return ms;
-    }
-    if (typeof ts === "number")
-        return ts;
-    return undefined;
-}
-function readCurrentTurnReactSequence(hookCtx) {
-    try {
-        const targetFile = resolveSessionFile(hookCtx);
-        if (!targetFile)
-            return { entries: [] };
-        const raw = readFileSync(targetFile, "utf-8");
-        const lines = raw.trim().split("\\n");
-        let lastUserIdx = -1;
-        let userWrittenAt;
-        let userContent;
-        for (let i = lines.length - 1; i >= 0; i--) {
-            const line = lines[i].trim();
-            if (!line)
-                continue;
-            try {
-                const entry = JSON.parse(line);
-                if (entry.type !== "message")
-                    continue;
-                const msg = entry.message;
-                if (msg?.role === "user") {
-                    lastUserIdx = i;
-                    userWrittenAt = parseEntryWrittenAt(entry);
-                    userContent = msg.content;
-                    break;
-                }
-            }
-            catch {
-                continue;
-            }
-        }
-        if (lastUserIdx < 0)
-            return { entries: [] };
-        const entries = [];
-        for (let i = lastUserIdx + 1; i < lines.length; i++) {
-            const line = lines[i].trim();
-            if (!line)
-                continue;
-            try {
-                const entry = JSON.parse(line);
-                if (entry.type !== "message")
-                    continue;
-                const msg = entry.message;
-                if (!msg)
-                    continue;
-                const writtenAt = parseEntryWrittenAt(entry);
-                if (msg.role === "assistant") {
-                    entries.push({
-                        type: "assistant",
-                        content: msg.content,
-                        provider: msg.provider,
-                        model: msg.model,
-                        usage: msg.usage,
-                        stopReason: msg.stopReason,
-                        timestamp: msg.timestamp,
-                        writtenAt,
-                    });
-                }
-                else if (msg.role === "toolResult") {
-                    entries.push({
-                        type: "toolResult",
-                        content: msg.content,
-                        toolCallId: msg.toolCallId,
-                        toolName: msg.toolName,
-                        isError: msg.isError,
-                        timestamp: msg.timestamp,
-                        writtenAt,
-                    });
-                }
-            }
-            catch {
-                continue;
-            }
-        }
-        return { entries, userWrittenAt, userContent };
-    }
-    catch {
-        return { entries: [] };
-    }
-}
-/**
- * Check if a content value contains multimodal parts (non-text types like image).
- */
-function hasMultimodalParts(content) {
-    if (!Array.isArray(content))
-        return false;
-    return content.some((item) => item && typeof item === "object" && item.type && item.type !== "text");
-}
-/**
- * Convert session-file content parts to the expected span input format.
- *
- * Session file stores images as:
- *   { type: "image", data: "<base64>", mimeType: "image/jpeg" }
- *
- * Span input expects:
- *   { type: "image_url", image_url: { url: "data:image/jpeg;base64,<base64>", name: "", detail: "" } }
- *
- * If the total size of all image data exceeds 3 MB, images are replaced with
- * a placeholder text part to avoid oversized span input.
- *
- * Text parts are kept as-is.
- */
-const IMAGE_SIZE_LIMIT = 1 * 1024 * 1024; // 1 MB
-function convertContentPartsForSpan(content) {
-    if (!Array.isArray(content))
-        return content;
-    const parts = content;
-    // Calculate total byte size of all image data (base64 length × 3/4 ≈ raw bytes)
-    let totalImageBytes = 0;
-    for (const part of parts) {
-        if (part?.type === "image" && typeof part.data === "string") {
-            totalImageBytes += Math.ceil(part.data.length * 3 / 4);
-        }
-    }
-    const exceedsLimit = totalImageBytes > IMAGE_SIZE_LIMIT;
-    return parts.map((part) => {
-        if (!part || typeof part !== "object")
-            return part;
-        if (part.type === "image" && typeof part.data === "string") {
-            if (exceedsLimit) {
-                return {
-                    type: "text",
-                    text: "[image data removed due to large size - already processed by model]",
-                };
-            }
-            const mimeType = part.mimeType || "image/png";
-            return {
-                type: "image_url",
-                image_url: {
-                    url: \`data:\${mimeType};base64,\${part.data}\`,
-                    name: "",
-                    detail: "",
-                },
-            };
-        }
-        return part;
-    });
-}
-function normalizeChannelId(input, defaultPlatform = "system") {
-    if (!input || input === "unknown") {
-        return \`\${defaultPlatform}/unknown\`;
-    }
-    if (input.includes("/")) {
-        // 已标准化的两段格式（无冒号），直接返回
-        if (!input.includes(":")) {
-            return input;
-        }
-        // 复合格式：尝试提取飞书用户标识
-        const feishuMatch = input.match(/(ou|oc|og)_[a-zA-Z0-9]+/);
-        if (feishuMatch) {
-            return \`feishu/\${feishuMatch[0]}\`;
-        }
-        // agent/xxx:yyy → agent/xxx
-        const slashIdx = input.indexOf("/");
-        const afterSlash = input.substring(slashIdx + 1);
-        const colonIdx = afterSlash.indexOf(":");
-        if (colonIdx > 0) {
-            return \`\${input.substring(0, slashIdx)}/\${afterSlash.substring(0, colonIdx)}\`;
-        }
-        return input;
-    }
-    const prefix = input.split(/[_:]/)[0];
-    switch (prefix) {
-        case "ou":
-        case "oc":
-        case "og":
-            return \`feishu/\${input}\`;
-        case "user":
-        case "chat":
-            return \`feishu/\${input.slice(prefix.length + 1)}\`;
-        case "agent":
-            return \`agent/\${input.slice(6)}\`;
-        default:
-            return \`\${defaultPlatform}/\${input}\`;
-    }
-}
-function resolveChannelId(ctx, eventFrom, defaultValue = "system/unknown") {
-    if (ctx.conversationId && /^(user|chat):/.test(ctx.conversationId)) {
-        return normalizeChannelId(ctx.conversationId);
-    }
-    if (eventFrom && /^feishu:/.test(eventFrom)) {
-        const platformId = eventFrom.slice(7);
-        return \`feishu/\${platformId}\`;
-    }
-    if (ctx.channelId && /^feishu\\/(ou|oc|og)_/.test(ctx.channelId)) {
-        return ctx.channelId;
-    }
-    const raw = ctx.sessionKey || ctx.channelId || eventFrom || defaultValue;
-    return normalizeChannelId(raw);
-}
-let lastUserChannelId;
-let lastUserTraceContext;
-let lastOpenclawSessionId;
-// Active agent context: set in before_agent_start, cleared in agent_end.
-// All hooks between these two (llm_input, llm_output, tool calls, messages)
-// use this to ensure every span lands in the same Trace.
-let activeAgentCtx;
-let activeAgentChannelId;
-// Latest user input captured from message_received, independent of any ctx.
-// Used by ensureRootSpan as a reliable fallback for the root span's input.
-let lastUserInput;
-let pendingToolCall;
-function resolveOpenclawSessionId(hookCtx, eventSessionId) {
-    const raw = hookCtx.sessionId?.trim() || eventSessionId?.trim();
-    if (!raw)
-        return undefined;
-    return raw;
-}
-const cozeloopTracePlugin = {
-    id: "openclaw-cozeloop-trace",
-    name: "OpenClaw CozeLoop Trace",
-    version: PLUGIN_VERSION,
-    description: "Report OpenClaw execution traces to CozeLoop via OpenTelemetry",
-    activate(api) {
-        const pluginConfig = api.pluginConfig || {};
-        const authorization = pluginConfig.authorization;
-        const workspaceId = pluginConfig.workspaceId;
-        if (!authorization || !workspaceId) {
-            api.logger.error("[CozeloopTrace] Missing required configuration: 'authorization' and 'workspaceId' must be provided");
-            return;
-        }
-        const config = {
-            endpoint: pluginConfig.endpoint || "https://api.coze.cn/v1/loop/opentelemetry",
-            authorization,
-            workspaceId,
-            serviceName: pluginConfig.serviceName || "openclaw-agent",
-            debug: pluginConfig.debug || false,
-            batchSize: pluginConfig.batchSize || 10,
-            batchInterval: pluginConfig.batchInterval || 5000,
-            enabledHooks: pluginConfig.enabledHooks,
-        };
-        const exporter = new CozeloopExporter(api, config);
-        const contextByChannelId = new Map();
-        const contextByRunId = new Map();
-        const shouldHookEnabled = (hookName) => {
-            if (!config.enabledHooks)
-                return true;
-            return config.enabledHooks.includes(hookName);
-        };
-        const getContextByChannel = (channelId) => {
-            return contextByChannelId.get(channelId);
-        };
-        const getContextByRun = (runId) => {
-            return contextByRunId.get(runId);
-        };
-        const getOriginalChannelId = (runId) => {
-            const ctx = contextByRunId.get(runId);
-            return ctx?.originalChannelId || ctx?.channelId;
-        };
-        const startTurn = (runId, channelId, originalChannelId, openclawSessionId) => {
-            const traceId = generateId(32);
-            const ctx = {
-                traceId,
-                rootSpanId: generateId(16),
-                runId,
-                turnId: runId,
-                channelId,
-                originalChannelId: originalChannelId || channelId,
-                openclawSessionId,
-            };
-            contextByChannelId.set(channelId, ctx);
-            contextByRunId.set(runId, ctx);
-            return ctx;
-        };
-        const endTurn = (channelId) => {
-            const ctx = contextByChannelId.get(channelId);
-            if (ctx) {
-                contextByChannelId.delete(channelId);
-                contextByRunId.delete(ctx.runId);
-            }
-        };
-        const getOrCreateContext = (rawChannelId, runId, hookName) => {
-            let channelId = rawChannelId;
-            let activeCtx = getContextByChannel(rawChannelId);
-            const effectiveRunId = runId || activeCtx?.runId || \`run-\${Date.now()}\`;
-            if (rawChannelId.startsWith("agent/") && effectiveRunId) {
-                const originalChannelId = getOriginalChannelId(effectiveRunId);
-                if (originalChannelId) {
-                    channelId = originalChannelId;
-                    activeCtx = getContextByChannel(originalChannelId) || activeCtx;
-                }
-            }
-            if (!activeCtx) {
-                activeCtx = getContextByRun(effectiveRunId);
-            }
-            if (!activeCtx && rawChannelId.startsWith("agent/") && lastUserTraceContext) {
-                activeCtx = lastUserTraceContext;
-                channelId = lastUserChannelId || channelId;
-                contextByChannelId.set(rawChannelId, activeCtx);
-                contextByRunId.set(effectiveRunId, activeCtx);
-                if (config.debug) {
-                    api.logger.info(\`[CozeloopTrace] LINKING agent to user context: hook=\${hookName}, agentChannel=\${rawChannelId}, userChannel=\${channelId}, traceId=\${activeCtx.traceId}\`);
-                }
-            }
-            let isNew = false;
-            if (!activeCtx) {
-                activeCtx = startTurn(effectiveRunId, channelId, rawChannelId !== channelId ? rawChannelId : undefined);
-                isNew = true;
-                if (config.debug) {
-                    api.logger.info(\`[CozeloopTrace] NEW TraceContext created: hook=\${hookName}, channelId=\${channelId}, runId=\${effectiveRunId}, traceId=\${activeCtx.traceId}\`);
-                }
-            }
-            else if (config.debug) {
-                api.logger.info(\`[CozeloopTrace] REUSING TraceContext: hook=\${hookName}, channelId=\${channelId}, runId=\${effectiveRunId}, traceId=\${activeCtx.traceId}\`);
-            }
-            return { ctx: activeCtx, channelId, isNew };
-        };
-        // Resolve context for hooks that fire between before_agent_start and
-        // agent_end.  When an agent is active, always return that agent's context
-        // so every span ends up in the same Trace regardless of channelId drift.
-        const resolveActiveContext = (rawChannelId, runId, hookName) => {
-            if (activeAgentCtx) {
-                if (config.debug) {
-                    api.logger.info(\`[CozeloopTrace] Using activeAgentCtx for \${hookName}: traceId=\${activeAgentCtx.traceId}, rootSpanId=\${activeAgentCtx.rootSpanId}\`);
-                }
-                return { ctx: activeAgentCtx, channelId: activeAgentChannelId || rawChannelId };
-            }
-            const { ctx, channelId } = getOrCreateContext(rawChannelId, runId, hookName);
-            return { ctx, channelId };
-        };
-        const createSpan = (ctx, channelId, name, type, startTime, endTime, attributes = {}, input, output, parentSpanId) => {
-            return {
-                name,
-                type: type,
-                startTime,
-                endTime,
-                attributes: {
-                    ...attributes,
-                    "session.id": ctx.openclawSessionId || channelId,
-                    "run.id": ctx.runId,
-                    "turn.id": ctx.turnId,
-                    "openclaw.channel_id": channelId,
-                },
-                input,
-                output,
-                traceId: ctx.traceId,
-                spanId: generateId(16),
-                parentSpanId: parentSpanId || ctx.rootSpanId,
-            };
-        };
-        const buildReactSpans = async (ctx, channelId, entries, initialInput, agentStartTime, userWrittenAt, skipCount, sessionUserContent) => {
-            const entriesToSkip = skipCount || 0;
-            const reactMessages = [];
-            if (initialInput && typeof initialInput === "object") {
-                const inputObj = initialInput;
-                if ("messages" in inputObj && Array.isArray(inputObj.messages)) {
-                    for (const msg of inputObj.messages) {
-                        const m = { role: String(msg.role || ""), content: safeClone(msg.content) };
-                        if (msg.tool_call_id) {
-                            m.tool_call_id = String(msg.tool_call_id);
-                        }
-                        reactMessages.push(m);
-                    }
-                }
-            }
-            // Enrich the last user message with multimodal content from the session
-            // file.  At llm_output time the session file is guaranteed to contain the
-            // full user message including image parts.
-            if (sessionUserContent && hasMultimodalParts(sessionUserContent)) {
-                const converted = convertContentPartsForSpan(safeClone(sessionUserContent));
-                if (config.debug) {
-                    // Log size check details
-                    const rawParts = sessionUserContent;
-                    let totalBytes = 0;
-                    let imageCount = 0;
-                    for (const p of rawParts) {
-                        if (p?.type === "image" && typeof p.data === "string") {
-                            imageCount++;
-                            totalBytes += Math.ceil(p.data.length * 3 / 4);
-                        }
-                    }
-                    const convertedParts = converted;
-                    const convertedTypes = convertedParts.map(p => String(p?.type ?? 'unknown'));
-                    api.logger.info(\`[CozeloopTrace] Multimodal enrichment: imageCount=\${imageCount}, totalImageBytes=\${totalBytes}, limit=\${IMAGE_SIZE_LIMIT}, exceedsLimit=\${totalBytes > IMAGE_SIZE_LIMIT}, convertedTypes=[\${convertedTypes.join(',')}]\`);
-                }
-                for (let mi = reactMessages.length - 1; mi >= 0; mi--) {
-                    if (reactMessages[mi].role === "user") {
-                        reactMessages[mi].content = converted;
-                        if (config.debug) {
-                            const parts = converted;
-                            api.logger.info(\`[CozeloopTrace] Enriched last user message in reactMessages with multimodal content: \${parts.length} parts, types=[\${parts.map(p => p.type).join(',')}]\`);
-                        }
-                        break;
-                    }
-                }
-                // Also update ctx.userInput so the root span carries multimodal content
-                if (!hasMultimodalParts(ctx.userInput)) {
-                    ctx.userInput = converted;
-                    if (!lastUserInput || !hasMultimodalParts(lastUserInput)) {
-                        lastUserInput = converted;
-                    }
-                }
-            }
-            else if (config.debug) {
-                const isArray = Array.isArray(sessionUserContent);
-                if (isArray) {
-                    const items = sessionUserContent;
-                    api.logger.info(\`[CozeloopTrace] Multimodal enrichment skipped: sessionUserContent=array[\${items.length}] types=[\${items.map(i => String(i?.type ?? typeof i)).join(',')}], hasMultimodal=false\`);
-                }
-                else {
-                    api.logger.info(\`[CozeloopTrace] Multimodal enrichment skipped: sessionUserContent=\${sessionUserContent === undefined ? 'undefined' : typeof sessionUserContent}\`);
-                }
-            }
-            let reactRound = 0;
-            let modelSpanCount = 0;
-            let prevWrittenAt = userWrittenAt || agentStartTime;
-            for (let i = 0; i < entries.length; i++) {
-                const entry = entries[i];
-                const entryWrittenAt = entry.writtenAt || prevWrittenAt;
-                // Whether this entry was already exported in a previous llm_output call.
-                const alreadyExported = i < entriesToSkip;
-                if (entry.type === "assistant") {
-                    reactRound++;
-                    if (!alreadyExported) {
-                        modelSpanCount++;
-                        const provider = entry.provider || ctx.lastModelProvider || "unknown";
-                        const model = entry.model || ctx.lastModelId || "unknown";
-                        const spanStartTime = prevWrittenAt;
-                        const spanEndTime = entryWrittenAt;
-                        const modelSpan = createSpan(ctx, channelId, \`\${provider}/\${model}\`, "model", spanStartTime, spanEndTime, {
-                            "gen_ai.provider.name": provider,
-                            "gen_ai.request.model": model,
-                            "gen_ai.usage.input_tokens": entry.usage?.input ?? 0,
-                            "gen_ai.usage.output_tokens": entry.usage?.output ?? 0,
-                            "react_round": reactRound,
-                        }, { messages: reactMessages.map((msg) => safeClone(msg)) }, formatAssistantOutput(entry.content, entry.stopReason));
-                        await exporter.export(modelSpan);
-                    }
-                    reactMessages.push({
-                        role: "assistant",
-                        content: convertAssistantContentForMessages(entry.content),
-                    });
-                    prevWrittenAt = entryWrittenAt;
-                }
-                else if (entry.type === "toolResult") {
-                    if (!alreadyExported) {
-                        const toolSpanStartTime = prevWrittenAt;
-                        const toolSpanEndTime = entryWrittenAt;
-                        let toolInput = undefined;
-                        for (let j = i - 1; j >= 0; j--) {
-                            if (entries[j].type === "assistant") {
-                                const assistantContent = entries[j].content;
-                                if (Array.isArray(assistantContent)) {
-                                    for (const item of assistantContent) {
-                                        if (item?.type === "toolCall" && item.id === entry.toolCallId) {
-                                            toolInput = { name: item.name, arguments: item.arguments ?? item.input };
-                                            break;
-                                        }
-                                    }
-                                }
-                                break;
-                            }
-                        }
-                        const toolAttrs = {};
-                        if (entry.isError) {
-                            toolAttrs["error.msg"] = "tool returned error";
-                        }
-                        const toolSpan = createSpan(ctx, channelId, entry.toolName || "unknown_tool", "tool", toolSpanStartTime, toolSpanEndTime, toolAttrs, toolInput, entry.content);
-                        await exporter.export(toolSpan);
-                    }
-                    const consecutiveToolResults = [entry];
-                    let lastToolWrittenAt = entryWrittenAt;
-                    while (i + 1 < entries.length && entries[i + 1].type === "toolResult") {
-                        i++;
-                        const nextTr = entries[i];
-                        const nextAlreadyExported = i < entriesToSkip;
-                        consecutiveToolResults.push(nextTr);
-                        const nextWrittenAt = nextTr.writtenAt || lastToolWrittenAt;
-                        lastToolWrittenAt = nextWrittenAt;
-                        if (!nextAlreadyExported) {
-                            let nextToolInput = undefined;
-                            for (let j = i - 1; j >= 0; j--) {
-                                if (entries[j].type === "assistant") {
-                                    const ac = entries[j].content;
-                                    if (Array.isArray(ac)) {
-                                        for (const item of ac) {
-                                            if (item?.type === "toolCall" && item.id === nextTr.toolCallId) {
-                                                nextToolInput = { name: item.name, arguments: item.arguments ?? item.input };
-                                                break;
-                                            }
-                                        }
-                                    }
-                                    break;
-                                }
-                            }
-                            const nextToolAttrs = {};
-                            if (nextTr.isError) {
-                                nextToolAttrs["error.msg"] = "tool returned error";
-                            }
-                            const nextToolSpan = createSpan(ctx, channelId, nextTr.toolName || "unknown_tool", "tool", prevWrittenAt, nextWrittenAt, nextToolAttrs, nextToolInput, nextTr.content);
-                            await exporter.export(nextToolSpan);
-                            prevWrittenAt = nextWrittenAt;
-                        }
-                    }
-                    const toolResultMsgs = convertToolResultsForMessages(consecutiveToolResults);
-                    reactMessages.push(...toolResultMsgs);
-                    // Use the last tool's timestamp so the next model span starts after
-                    // all tools, not just after the first one.
-                    prevWrittenAt = lastToolWrittenAt;
-                }
-            }
-            return modelSpanCount;
-        };
-        api.on("gateway_stop", async () => {
-            await exporter.dispose();
-        });
-        if (shouldHookEnabled("gateway_start")) {
-            api.on("gateway_start", async (event) => {
-                const now = Date.now();
-                const { ctx, channelId } = getOrCreateContext("system/gateway", undefined, "gateway_start");
-                const span = createSpan(ctx, channelId, "gateway_start", "gateway", now, now, {
-                    "gateway.version": event.version || "unknown",
-                    "gateway.working_dir": event.workingDir || process.cwd(),
-                });
-                await exporter.export(span);
-                if (config.debug) {
-                    api.logger.info(\`[CozeloopTrace] Exported gateway_start span, traceId=\${ctx.traceId}\`);
-                }
-            });
-        }
-        if (shouldHookEnabled("session_start")) {
-            api.on("session_start", async (event, hookCtx) => {
-                // Refresh token if expiring soon (< 10 min)
-                await exporter.refreshAuthIfNeeded();
-                const rawChannelId = resolveChannelId(hookCtx, event.sessionId);
-                if (config.debug) {
-                    api.logger.info(\`[CozeloopTrace] session_start: \${rawChannelId}\`);
-                }
-                const { ctx } = getOrCreateContext(rawChannelId, undefined, "session_start");
-                const ocSessionId = resolveOpenclawSessionId(hookCtx, event.sessionId);
-                if (ocSessionId) {
-                    ctx.openclawSessionId = ocSessionId;
-                    lastOpenclawSessionId = ocSessionId;
-                }
-                ctx.openclawSessionId = ctx.openclawSessionId || lastOpenclawSessionId;
-            });
-        }
-        if (shouldHookEnabled("message_received")) {
-            api.on("message_received", async (event, hookCtx) => {
-                const rawChannelId = resolveChannelId(hookCtx, event.from || event.metadata?.senderId);
-                if (config.debug) {
-                    api.logger.info(\`[CozeloopTrace] message_received hookCtx: \${JSON.stringify({ channelId: hookCtx.channelId, sessionKey: hookCtx.sessionKey, conversationId: hookCtx.conversationId })}, event.from=\${event.from}\`);
-                }
-                const { ctx, channelId } = getOrCreateContext(rawChannelId, undefined, "message_received");
-                const ocSessionId = resolveOpenclawSessionId(hookCtx);
-                if (ocSessionId) {
-                    ctx.openclawSessionId = ocSessionId;
-                    lastOpenclawSessionId = ocSessionId;
-                }
-                ctx.openclawSessionId = ctx.openclawSessionId || lastOpenclawSessionId;
-                let role = event.role;
-                if (!role && event.from) {
-                    role = "user";
-                }
-                const isNonAgentChannel = !rawChannelId.startsWith("agent/");
-                if (isNonAgentChannel) {
-                    if (role === "user" || !role) {
-                        lastUserChannelId = channelId;
-                        lastUserTraceContext = ctx;
-                        ctx.userInput = event.content;
-                        lastUserInput = event.content;
-                        if (config.debug) {
-                            api.logger.info(\`[CozeloopTrace] Saved user context: channelId=\${channelId}, traceId=\${ctx.traceId}\`);
-                        }
-                    }
-                    if (!ctx.userInput) {
-                        ctx.userInput = event.content;
-                    }
-                    if (!lastUserTraceContext) {
-                        lastUserTraceContext = ctx;
-                        lastUserChannelId = channelId;
-                    }
-                }
-            });
-        }
-        if (shouldHookEnabled("message_sending")) {
-            api.on("message_sending", async (event, hookCtx) => {
-                if (lastUserTraceContext) {
-                    lastUserTraceContext.lastOutput = event.content;
-                    if (config.debug) {
-                        api.logger.info(\`[CozeloopTrace] Captured output for root span: traceId=\${lastUserTraceContext.traceId}, content=\${typeof event.content === 'string' ? event.content.substring(0, 100) : 'non-string'}\`);
-                    }
-                }
-                else {
-                    const rawChannelId = resolveChannelId(hookCtx, event.to);
-                    const { ctx } = resolveActiveContext(rawChannelId, undefined, "message_sending");
-                    ctx.lastOutput = event.content;
-                    if (config.debug) {
-                        api.logger.info(\`[CozeloopTrace] Captured output (fallback) for root span: traceId=\${ctx.traceId}\`);
-                    }
-                }
-            });
-        }
-        if (shouldHookEnabled("message_sent")) {
-            api.on("message_sent", async (event, hookCtx) => {
-                if (event.content && event.success) {
-                    if (lastUserTraceContext) {
-                        lastUserTraceContext.lastOutput = event.content;
-                        if (config.debug) {
-                            api.logger.info(\`[CozeloopTrace] Captured output from message_sent: traceId=\${lastUserTraceContext.traceId}\`);
-                        }
-                    }
-                    else {
-                        const rawChannelId = resolveChannelId(hookCtx, event.to);
-                        const { ctx } = resolveActiveContext(rawChannelId, undefined, "message_sent");
-                        ctx.lastOutput = event.content;
-                        if (config.debug) {
-                            api.logger.info(\`[CozeloopTrace] Captured output from message_sent (fallback): traceId=\${ctx.traceId}\`);
-                        }
-                    }
-                }
-            });
-        }
-        let lastLlmInput = undefined;
-        let lastLlmStartTime = undefined;
-        let lastLlmSpanId = undefined;
-        if (shouldHookEnabled("llm_input")) {
-            api.on("llm_input", async (event, hookCtx) => {
-                const rawChannelId = resolveChannelId(hookCtx);
-                if (config.debug) {
-                    api.logger.info(\`[CozeloopTrace] llm_input hookCtx: \${JSON.stringify({ channelId: hookCtx.channelId, sessionKey: hookCtx.sessionKey, conversationId: hookCtx.conversationId })}, event.runId=\${event.runId}\`);
-                }
-                const { ctx } = resolveActiveContext(rawChannelId, event.runId, "llm_input");
-                const ocSessionId = resolveOpenclawSessionId(hookCtx);
-                if (ocSessionId) {
-                    ctx.openclawSessionId = ocSessionId;
-                    lastOpenclawSessionId = ocSessionId;
-                }
-                ctx.openclawSessionId = ctx.openclawSessionId || lastOpenclawSessionId;
-                ctx.llmStartTime = Date.now();
-                ctx.llmSpanId = generateId(16);
-                ctx.lastModelProvider = event.provider;
-                ctx.lastModelId = event.model;
-                ctx.reactCount = 0;
-                // If userInput was never set (no message_received hook fired), capture
-                // the first llm prompt as the user input for the root span.
-                if (!ctx.userInput && event.prompt) {
-                    ctx.userInput = event.prompt;
-                    if (!lastUserInput) {
-                        lastUserInput = event.prompt;
-                    }
-                }
-                // Fallback: ensure root + agent spans exist in case before_agent_start
-                // was not fired (older OpenClaw versions or resumed sessions).
-                const channelIdForSpans = activeAgentChannelId || rawChannelId;
-                await ensureRootSpan(ctx, channelIdForSpans);
-                await ensureAgentSpan(ctx, channelIdForSpans);
-                const messages = [];
-                if (event.systemPrompt) {
-                    messages.push({ role: "system", content: safeClone(event.systemPrompt) });
-                }
-                if (event.historyMessages && event.historyMessages.length > 0) {
-                    messages.push(...event.historyMessages.map((msg) => safeClone(msg)));
-                }
-                if (event.prompt) {
-                    messages.push({ role: "user", content: safeClone(event.prompt) });
-                }
-                const convertToolCallInPlace = (target) => {
-                    if (target.type !== "toolCall")
-                        return;
-                    target.type = "tool_use";
-                    if ("arguments" in target) {
-                        target.input = target.arguments;
-                        delete target.arguments;
-                    }
-                };
-                const convertToolCallDeepInPlace = (value) => {
-                    if (!value)
-                        return;
-                    if (Array.isArray(value)) {
-                        for (const item of value) {
-                            convertToolCallDeepInPlace(item);
-                        }
-                        return;
-                    }
-                    if (typeof value !== "object")
-                        return;
-                    const obj = value;
-                    convertToolCallInPlace(obj);
-                    if ("content" in obj) {
-                        convertToolCallDeepInPlace(obj.content);
-                    }
-                };
-                for (const message of messages) {
-                    convertToolCallDeepInPlace(message);
-                    if ("toolCallId" in message) {
-                        message.tool_call_id = message.toolCallId;
-                        delete message.toolCallId;
-                    }
-                    if (message.role === "toolResult") {
-                        message.role = "tool";
-                    }
-                }
-                ctx.llmInput = {
-                    "messages": messages,
-                };
-                lastLlmInput = ctx.llmInput;
-                lastLlmStartTime = ctx.llmStartTime;
-                lastLlmSpanId = ctx.llmSpanId;
-                if (config.debug) {
-                    api.logger.info(\`[CozeloopTrace] LLM input started: \${event.provider}/\${event.model}, runId=\${event.runId}, traceId=\${ctx.traceId}\`);
-                }
-            });
-        }
-        if (shouldHookEnabled("llm_output")) {
-            api.on("llm_output", async (event, hookCtx) => {
-                const rawChannelId = resolveChannelId(hookCtx);
-                if (config.debug) {
-                    api.logger.info(\`[CozeloopTrace][DEBUG] llm_output event.usage=\${JSON.stringify(event.usage)}\`);
-                    api.logger.info(\`[CozeloopTrace][DEBUG] llm_output event.lastAssistant=\${JSON.stringify(event.lastAssistant)}\`);
-                    api.logger.info(\`[CozeloopTrace][DEBUG] llm_output event keys=\${JSON.stringify(Object.keys(event))}\`);
-                    api.logger.info(\`[CozeloopTrace] llm_output hookCtx: \${JSON.stringify({ channelId: hookCtx.channelId, sessionKey: hookCtx.sessionKey, conversationId: hookCtx.conversationId })}, event.runId=\${event.runId}\`);
-                }
-                const { ctx, channelId } = resolveActiveContext(rawChannelId, event.runId, "llm_output");
-                const now = Date.now();
-                const startTime = ctx.llmStartTime || lastLlmStartTime || now;
-                if (event.assistantTexts && event.assistantTexts.length > 0) {
-                    const outputText = event.assistantTexts.join("\\n");
-                    ctx.lastOutput = outputText;
-                    if (lastUserTraceContext) {
-                        lastUserTraceContext.lastOutput = outputText;
-                    }
-                    if (config.debug) {
-                        api.logger.info(\`[CozeloopTrace] Captured output from llm_output (will use last): traceId=\${ctx.traceId}, length=\${outputText.length}\`);
-                    }
-                }
-                const llmInput = ctx.llmInput || lastLlmInput;
-                const llmSpanId = ctx.llmSpanId || lastLlmSpanId;
-                if (config.debug) {
-                    api.logger.info(\`[CozeloopTrace] llm_output ctx: traceId=\${ctx.traceId}, rootSpanId=\${ctx.rootSpanId}, llmSpanId=\${llmSpanId || "none"}, hasInput=\${!!llmInput}\`);
-                }
-                let sessionBasedSuccess = false;
-                try {
-                    const { entries, userWrittenAt, userContent } = readCurrentTurnReactSequence(hookCtx);
-                    const hasAssistantEntry = entries.some((e) => e.type === "assistant");
-                    if (entries.length > 0 && hasAssistantEntry) {
-                        const agentStart = ctx.agentStartTime || ctx.llmStartTime || lastLlmStartTime || now;
-                        const skipCount = ctx.sessionBasedExportedCount || 0;
-                        const modelCount = await buildReactSpans(ctx, channelId, entries, llmInput, agentStart, userWrittenAt, skipCount, userContent);
-                        if (modelCount > 0) {
-                            sessionBasedSuccess = true;
-                            ctx.sessionBasedSpansCreated = true;
-                            // Remember how many entries we exported so the next llm_output
-                            // call skips them and avoids duplicate spans.
-                            ctx.sessionBasedExportedCount = entries.length;
-                            if (config.debug) {
-                                api.logger.info(\`[CozeloopTrace] Session-based react spans created: modelCount=\${modelCount}, totalEntries=\${entries.length}, skipped=\${skipCount}, traceId=\${ctx.traceId}\`);
-                            }
-                        }
-                    }
-                }
-                catch {
-                    if (config.debug) {
-                        api.logger.info(\`[CozeloopTrace] Session-based span creation failed, falling back to hook data, traceId=\${ctx.traceId}\`);
-                    }
-                }
-                if (!sessionBasedSuccess) {
-                    if (ctx.pendingToolSpans) {
-                        for (const pts of ctx.pendingToolSpans) {
-                            const toolSpan = createSpan(ctx, channelId, pts.toolName, "tool", pts.toolStartTime, pts.toolEndTime, pts.toolError ? { "error.msg": String(pts.toolError) } : {}, pts.toolInput, pts.toolError ? { error: pts.toolError } : pts.toolOutput);
-                            toolSpan.spanId = pts.toolSpanId;
-                            await exporter.export(toolSpan);
-                            if (config.debug) {
-                                api.logger.info(\`[CozeloopTrace] Exported pending tool span (fallback): \${pts.toolName}, spanId=\${pts.toolSpanId}, traceId=\${ctx.traceId}\`);
-                            }
-                        }
-                    }
-                    const lastAssistantUsage = event.lastAssistant?.usage;
-                    const inputTokens = event.usage?.input ?? lastAssistantUsage?.input ?? 0;
-                    const outputTokens = event.usage?.output ?? lastAssistantUsage?.output ?? 0;
-                    const spanAttributes = {
-                        "gen_ai.provider.name": event.provider,
-                        "gen_ai.request.model": event.model,
-                        "gen_ai.usage.input_tokens": inputTokens,
-                        "gen_ai.usage.output_tokens": outputTokens,
-                    };
-                    const finalOutput = formatAssistantOutput(event.assistantTexts?.map((t) => ({ type: "text", text: t })) ?? [], "stop");
-                    const span = createSpan(ctx, channelId, \`\${event.provider}/\${event.model}\`, "model", startTime, now, spanAttributes, llmInput, finalOutput);
-                    if (llmSpanId) {
-                        span.spanId = llmSpanId;
-                    }
-                    if (config.debug) {
-                        api.logger.info(\`[CozeloopTrace] llm_output span created (fallback): spanId=\${span.spanId}, parentSpanId=\${span.parentSpanId}\`);
-                    }
-                    await exporter.export(span);
-                    if (config.debug) {
-                        api.logger.info(\`[CozeloopTrace] Exported LLM span (fallback): \${event.provider}/\${event.model}, duration=\${now - startTime}ms, traceId=\${ctx.traceId}\`);
-                    }
-                }
-                ctx.llmStartTime = undefined;
-                ctx.llmSpanId = undefined;
-                ctx.llmInput = undefined;
-                ctx.reactCount = 0;
-                ctx.pendingToolSpans = undefined;
-                ctx.sessionBasedSpansCreated = undefined;
-                lastLlmInput = undefined;
-                lastLlmStartTime = undefined;
-                lastLlmSpanId = undefined;
-            });
-        }
-        if (shouldHookEnabled("before_tool_call")) {
-            api.on("before_tool_call", async (event, hookCtx) => {
-                const rawChannelId = resolveChannelId(hookCtx);
-                if (config.debug) {
-                    api.logger.info(\`[CozeloopTrace] before_tool_call hookCtx: \${JSON.stringify({ channelId: hookCtx.channelId, sessionKey: hookCtx.sessionKey, conversationId: hookCtx.conversationId })}, toolName=\${event.toolName}\`);
-                }
-                const { ctx, channelId } = resolveActiveContext(rawChannelId, undefined, "before_tool_call");
-                pendingToolCall = {
-                    toolName: event.toolName,
-                    toolSpanId: generateId(16),
-                    toolStartTime: Date.now(),
-                    toolInput: event.params,
-                    traceContext: ctx,
-                    channelId: channelId,
-                };
-                ctx.reactCount = (ctx.reactCount || 0) + 1;
-                if (config.debug) {
-                    api.logger.info(\`[CozeloopTrace] Tool call started: \${event.toolName}, spanId=\${pendingToolCall.toolSpanId}, traceId=\${ctx.traceId}\`);
-                }
-            });
-        }
-        if (shouldHookEnabled("after_tool_call")) {
-            api.on("after_tool_call", async (event, hookCtx) => {
-                if (config.debug) {
-                    api.logger.info(\`[CozeloopTrace] after_tool_call hookCtx: \${JSON.stringify({ channelId: hookCtx.channelId, sessionKey: hookCtx.sessionKey, conversationId: hookCtx.conversationId })}, toolName=\${event.toolName}\`);
-                }
-                if (!pendingToolCall || pendingToolCall.toolName !== event.toolName) {
-                    if (config.debug) {
-                        api.logger.info(\`[CozeloopTrace] Skipping after_tool_call: no pending tool or name mismatch, toolName=\${event.toolName}, pending=\${pendingToolCall?.toolName}\`);
-                    }
-                    return;
-                }
-                const { toolName, toolSpanId, toolStartTime, toolInput, traceContext } = pendingToolCall;
-                pendingToolCall = undefined;
-                const now = Date.now();
-                if (!traceContext.pendingToolSpans) {
-                    traceContext.pendingToolSpans = [];
-                }
-                traceContext.pendingToolSpans.push({
-                    toolName,
-                    toolSpanId,
-                    toolStartTime,
-                    toolEndTime: now,
-                    toolInput,
-                    toolOutput: event.error ? { error: event.error } : event.result,
-                    toolError: event.error ? String(event.error) : undefined,
-                });
-                if (config.debug) {
-                    api.logger.info(\`[CozeloopTrace] Collected pending tool span: \${toolName}, spanId=\${toolSpanId}, duration=\${now - toolStartTime}ms, traceId=\${traceContext.traceId}\`);
-                }
-            });
-        }
-        // Helper: finalize a trace — end agent span (if open), end root span, flush,
-        // and clean up all state.  Called from agent_end (normal path) and
-        // session_end (fallback for old OpenClaw versions that don't emit agent_end).
-        let traceFinalized = false;
-        const finalizeTrace = (ctx, channelId, agentEndAttrs, agentOutput) => {
-            if (traceFinalized)
-                return;
-            traceFinalized = true;
-            const now = Date.now();
-            // End agent span if still open.
-            if (ctx.agentSpanId) {
-                exporter.endSpanById(ctx.agentSpanId, now, agentEndAttrs || {}, agentOutput);
-                if (config.debug) {
-                    api.logger.info(\`[CozeloopTrace] Ended agent span: spanId=\${ctx.agentSpanId}, traceId=\${ctx.traceId}\`);
-                }
-                ctx.agentSpanId = undefined;
-                ctx.agentStartTime = undefined;
-            }
-            const rootSpanId = ctx.rootSpanId;
-            const rootSpanStartTime = ctx.rootSpanStartTime;
-            const userInput = ctx.userInput || (lastUserTraceContext ? lastUserTraceContext.userInput : undefined) || lastUserInput;
-            const traceId = ctx.traceId;
-            const hasRootSpan = !!rootSpanStartTime;
-            const savedLastUserChannelId = lastUserChannelId;
-            const originalChannelId = ctx.originalChannelId || channelId;
-            setTimeout(async () => {
-                if (hasRootSpan) {
-                    const finalOutput = ctx.lastOutput || (lastUserTraceContext ? lastUserTraceContext.lastOutput : undefined);
-                    if (config.debug) {
-                        api.logger.info(\`[CozeloopTrace] Ending root span with input=\${userInput ? 'present' : 'missing'}, output=\${finalOutput ? 'present' : 'missing'}\`);
-                    }
-                    const endTime = Date.now();
-                    exporter.endSpanById(rootSpanId, endTime, {
-                        "request.duration_ms": endTime - (rootSpanStartTime || 0),
-                    }, finalOutput, userInput);
-                    if (config.debug) {
-                        api.logger.info(\`[CozeloopTrace] Ended root span: spanId=\${rootSpanId}, duration=\${endTime - (rootSpanStartTime || 0)}ms, traceId=\${traceId}\`);
-                    }
-                }
-                await exporter.flush();
-                exporter.endTrace(rootSpanId);
-                if (activeAgentCtx === ctx) {
-                    activeAgentCtx = undefined;
-                    activeAgentChannelId = undefined;
-                }
-                if (savedLastUserChannelId) {
-                    endTurn(savedLastUserChannelId);
-                }
-                if (originalChannelId && originalChannelId !== savedLastUserChannelId) {
-                    endTurn(originalChannelId);
-                }
-                lastUserChannelId = undefined;
-                lastUserTraceContext = undefined;
-                lastUserInput = undefined;
-                traceFinalized = false;
-            }, 200);
-        };
-        // Helper: ensure root openclaw_request span is started for a given context.
-        // Must be called before creating the agent span so that the exporter's
-        // currentRootContext is set and the agent span becomes a proper child.
-        const ensureRootSpan = async (ctx, channelId) => {
-            // Check both: rootSpanStartTime indicates we created a root span before,
-            // but the exporter's traceContexts may have been cleaned up by a previous
-            // turn's deferred endTrace(). If the exporter no longer has the entry we
-            // must recreate the root span.
-            if (ctx.rootSpanStartTime && exporter.hasTraceContext(ctx.rootSpanId)) {
-                return;
-            }
-            const now = Date.now();
-            ctx.rootSpanStartTime = now;
-            // Generate a fresh rootSpanId when the old one was cleaned up, so we
-            // don't collide with the previous turn's IDs.
-            const isRebuild = !exporter.hasTraceContext(ctx.rootSpanId);
-            if (isRebuild) {
-                ctx.rootSpanId = generateId(16);
-                // This is a new turn reusing a stale ctx — clear the previous turn's
-                // userInput, exported count, and agent span so we don't carry over
-                // stale state. The agent span must be recreated under the new root.
-                ctx.userInput = undefined;
-                ctx.sessionBasedExportedCount = undefined;
-                ctx.agentSpanId = undefined;
-                ctx.agentStartTime = undefined;
-            }
-            // Resolve user input: prefer ctx.userInput set by this turn's
-            // message_received, fall back to lastUserTraceContext, then lastUserInput.
-            if (!ctx.userInput) {
-                ctx.userInput = lastUserTraceContext?.userInput || lastUserInput;
-            }
-            const rootSpanData = {
-                name: "openclaw_request",
-                type: "entry",
-                startTime: now,
-                attributes: {
-                    "session.id": ctx.openclawSessionId || channelId,
-                    "run.id": ctx.runId,
-                    "turn.id": ctx.turnId,
-                    "openclaw.channel_id": channelId,
-                },
-                input: ctx.userInput,
-                traceId: ctx.traceId,
-                spanId: ctx.rootSpanId,
-            };
-            await exporter.startSpan(rootSpanData, ctx.rootSpanId);
-            if (config.debug) {
-                api.logger.info(\`[CozeloopTrace] ensureRootSpan: created root span, rootSpanId=\${ctx.rootSpanId}, traceContextsHas=\${exporter.hasTraceContext(ctx.rootSpanId)}\`);
-            }
-        };
-        // Helper: ensure the agent span exists for a given context.
-        // Safe to call multiple times — only creates the span once.
-        const ensureAgentSpan = async (ctx, channelId, agentId) => {
-            if (ctx.agentSpanId)
-                return;
-            const effectiveAgentId = agentId || "main";
-            const now = Date.now();
-            ctx.agentStartTime = now;
-            ctx.agentSpanId = generateId(16);
-            const spanData = {
-                name: effectiveAgentId,
-                type: "agent",
-                startTime: now,
-                attributes: {
-                    "agent.id": effectiveAgentId,
-                    "session.id": ctx.openclawSessionId || channelId,
-                    "run.id": ctx.runId,
-                    "turn.id": ctx.turnId,
-                    "openclaw.channel_id": channelId,
-                },
-                traceId: ctx.traceId,
-                spanId: ctx.agentSpanId,
-                parentSpanId: ctx.rootSpanId,
-            };
-            await exporter.startSpan(spanData, ctx.agentSpanId);
-            // Set active agent context so all subsequent hooks use the same Trace.
-            activeAgentCtx = ctx;
-            activeAgentChannelId = channelId;
-            if (config.debug) {
-                api.logger.info(\`[CozeloopTrace] ensureAgentSpan: created agent span, agentId=\${effectiveAgentId}, spanId=\${ctx.agentSpanId}, traceId=\${ctx.traceId}\`);
-            }
-        };
-        if (shouldHookEnabled("before_agent_start")) {
-            api.on("before_agent_start", async (event, hookCtx) => {
-                const rawChannelId = resolveChannelId(hookCtx);
-                const agentId = hookCtx.agentId || event.agentId || "main";
-                if (config.debug) {
-                    api.logger.info(\`[CozeloopTrace] before_agent_start hookCtx: \${JSON.stringify({ channelId: hookCtx.channelId, sessionKey: hookCtx.sessionKey, conversationId: hookCtx.conversationId, agentId: hookCtx.agentId })}, event.agentId=\${event.agentId}\`);
-                }
-                const { ctx, channelId } = getOrCreateContext(rawChannelId, undefined, "before_agent_start");
-                const ocSessionId = resolveOpenclawSessionId(hookCtx);
-                if (ocSessionId) {
-                    ctx.openclawSessionId = ocSessionId;
-                    lastOpenclawSessionId = ocSessionId;
-                }
-                ctx.openclawSessionId = ctx.openclawSessionId || lastOpenclawSessionId;
-                await ensureRootSpan(ctx, channelId);
-                await ensureAgentSpan(ctx, channelId, agentId);
-            });
-        }
-        if (shouldHookEnabled("agent_end")) {
-            api.on("agent_end", async (event, hookCtx) => {
-                const rawChannelId = resolveChannelId(hookCtx);
-                if (config.debug) {
-                    api.logger.info(\`[CozeloopTrace] agent_end hookCtx: \${JSON.stringify({ channelId: hookCtx.channelId, sessionKey: hookCtx.sessionKey, conversationId: hookCtx.conversationId })}\`);
-                }
-                // Use activeAgentCtx if available, otherwise fall back to resolution.
-                const ctx = activeAgentCtx || getOrCreateContext(rawChannelId, undefined, "agent_end").ctx;
-                const channelId = activeAgentChannelId || rawChannelId;
-                finalizeTrace(ctx, channelId, {
-                    "agent.duration_ms": event.durationMs || 0,
-                    "agent.message_count": event.messageCount || 0,
-                    "agent.tool_call_count": event.toolCallCount || 0,
-                    "agent.total_tokens": event.usage?.total || 0,
-                }, { usage: event.usage, cost: event.cost });
-            });
-        }
-        // Fallback: on session_end, if agent_end was never fired (old OpenClaw
-        // versions), finalize the trace here so that agent + root spans get ended
-        // and exported.
-        if (shouldHookEnabled("session_end")) {
-            api.on("session_end", async (event, hookCtx) => {
-                const rawChannelId = resolveChannelId(hookCtx, event.sessionId);
-                if (config.debug) {
-                    api.logger.info(\`[CozeloopTrace] session_end: \${rawChannelId}\`);
-                }
-                const ctx = activeAgentCtx || lastUserTraceContext;
-                if (ctx && ctx.rootSpanStartTime) {
-                    const channelId = activeAgentChannelId || lastUserChannelId || rawChannelId;
-                    if (config.debug) {
-                        api.logger.info(\`[CozeloopTrace] session_end: finalizing trace as fallback, traceId=\${ctx.traceId}\`);
-                    }
-                    finalizeTrace(ctx, channelId);
-                }
-                else {
-                    const { channelId } = getOrCreateContext(rawChannelId, undefined, "session_end");
-                    endTurn(channelId);
-                }
-            });
-        }
-        api.logger.info(\`[CozeloopTrace] Plugin activated (endpoint: \${config.endpoint}, workspace: \${config.workspaceId})\`);
-    },
-};
-export default cozeloopTracePlugin;
-`,
-  "dist/cozeloop-exporter.js": `import { trace, context, SpanKind, SpanStatusCode } from "@opentelemetry/api";
-import { BasicTracerProvider, BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
-import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-proto";
-import { Resource } from "@opentelemetry/resources";
-import { ATTR_SERVICE_NAME, ATTR_SERVICE_INSTANCE_ID } from "@opentelemetry/semantic-conventions";
-import { hostname } from "os";
-import { basename, join } from "path";
-import { createRequire } from "node:module";
-import { readFileSync, writeFileSync, mkdirSync } from "fs";
-import { homedir } from "os";
-import https from "https";
-
-const require = createRequire(import.meta.url);
-const { version: PLUGIN_VERSION } = require("../package.json");
-
-// ── Token refresh helpers ─────────────────────────────────────────────────
-const _CLIENT_ID = "46371084383473718052118955183420.app.coze";
-const _COZE_API  = "https://api.coze.cn";
-const _REFRESH_THRESHOLD_MS = 10 * 60 * 1000;
-const _CREDS_PATH = join(homedir(), ".cozeloop", "credentials.json");
-
-function _loadCreds() {
-    try { return JSON.parse(readFileSync(_CREDS_PATH, "utf8")); }
-    catch { return null; }
-}
-
-function _saveCreds(c) {
-    try {
-        mkdirSync(join(homedir(), ".cozeloop"), { recursive: true });
-        writeFileSync(_CREDS_PATH, JSON.stringify(c, null, 2), { mode: 0o600 });
-    } catch { /* non-fatal */ }
-}
-
-async function _refreshToken(refreshTok) {
-    return new Promise((resolve) => {
-        const body = JSON.stringify({ grant_type: "refresh_token", client_id: _CLIENT_ID, refresh_token: refreshTok });
-        const req = https.request(\`\${_COZE_API}/api/permission/oauth2/token\`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body), "x-tt-env": "ppe_cozelab", "x-use-ppe": "1" },
-        }, (res) => {
-            let buf = "";
-            res.on("data", c => buf += c);
-            res.on("end", () => {
-                try {
-                    const d = JSON.parse(buf);
-                    if (d.access_token) {
-                        const existing = _loadCreds() ?? {};
-                        const creds = {
-                            access_token: d.access_token,
-                            refresh_token: d.refresh_token ?? refreshTok,
-                            expires_at: (d.expires_in ?? 0) * 1000,  // unix timestamp in seconds
-                            workspace_id: existing.workspace_id ?? "",
-                        };
-                        _saveCreds(creds);
-                        resolve(creds.access_token);
-                    } else { resolve(null); }
-                } catch { resolve(null); }
-            });
-        });
-        req.on("error", () => resolve(null));
-        req.setTimeout(10000, () => { req.destroy(); resolve(null); });
-        req.write(body);
-        req.end();
-    });
-}
-
-async function getRefreshedToken(currentAuthorization) {
-    const creds = _loadCreds();
-    if (!creds) return currentAuthorization; // no creds file, keep as-is
-    const remaining = (creds.expires_at ?? 0) - Date.now();
-    if (remaining > _REFRESH_THRESHOLD_MS) return \`Bearer \${creds.access_token}\`;
-    if (creds.refresh_token) {
-        const newToken = await _refreshToken(creds.refresh_token);
-        if (newToken) return \`Bearer \${newToken}\`;
-    }
-    return null;
-}
-// ─────────────────────────────────────────────────────────────────────────
-
-export class CozeloopExporter {
-    config;
-    api;
-    provider = null;
-    tracer = null;
-    initialized = false;
-    initPromise = null;
-    // Per-trace context: keyed by the plugin-level rootSpanId so that
-    // concurrent or overlapping traces never stomp on each other.
-    traceContexts = new Map();
-    openSpans = new Map();
-    // Extra attributes derived from environment variables, applied to every span.
-    envAttributes = {};
-    constructor(api, config) {
-        this.api = api;
-        this.config = config;
-        this.envAttributes = this.parseEnvAttributes();
-    }
-    parseEnvAttributes() {
-        const attrs = {};
-        // COZE_PROJECT_ID -> project_id
-        const projectId = process.env.COZE_PROJECT_ID?.trim();
-        if (projectId) {
-            attrs["project_id"] = projectId;
-        }
-        // COZELOOP_UDF_TAGS -> udf_ prefixed keys
-        const tagsRaw = process.env.COZELOOP_UDF_TAGS?.trim();
-        if (tagsRaw) {
-            const pairs = tagsRaw.split(",");
-            for (const pair of pairs) {
-                const eqIdx = pair.indexOf("=");
-                if (eqIdx < 0) {
-                    this.api.logger.error(\`[CozeloopTrace] Invalid COZELOOP_UDF_TAGS entry (missing '='): "\${pair}"\`);
-                    continue;
-                }
-                const key = pair.substring(0, eqIdx);
-                const value = pair.substring(eqIdx + 1);
-                // Validate: key and value must not contain '=' or ','
-                if (key.includes("=") || key.includes(",")) {
-                    this.api.logger.error(\`[CozeloopTrace] Invalid COZELOOP_UDF_TAGS key contains '=' or ',': "\${key}"\`);
-                    continue;
-                }
-                if (value.includes("=") || value.includes(",")) {
-                    this.api.logger.error(\`[CozeloopTrace] Invalid COZELOOP_UDF_TAGS value contains '=' or ',': "\${value}"\`);
-                    continue;
-                }
-                if (!key) {
-                    this.api.logger.error(\`[CozeloopTrace] Invalid COZELOOP_UDF_TAGS entry (empty key): "\${pair}"\`);
-                    continue;
-                }
-                attrs[\`udf_\${key}\`] = value;
-            }
-        }
-        return attrs;
-    }
-    async refreshAuthIfNeeded() {
-        const fresh = await getRefreshedToken(this.config.authorization);
-        if (fresh && fresh !== this.config.authorization) {
-            this.api.logger.info("[CozeloopTrace] Token refreshed, re-initializing exporter...");
-            this.config.authorization = fresh;
-            // Reset so initialize() re-creates the exporter with the new token
-            this.initialized = false;
-            this.initPromise = null;
-            if (this.provider) {
-                try { await this.provider.shutdown(); } catch { /* ignore */ }
-                this.provider = null;
-                this.tracer = null;
-            }
-        } else if (fresh === null) {
-            this.api.logger.error("[CozeloopTrace] Local credentials exist but token refresh failed; refusing to reuse stale authorization.");
-            this.config.authorization = "";
-        }
-    }
-    async ensureInitialized() {
-        if (this.initialized)
-            return;
-        if (this.initPromise)
-            return this.initPromise;
-        this.initPromise = this.initialize();
-        await this.initPromise;
-    }
-    async initialize() {
-        this.api.logger.info(\`[CozeloopTrace] Initializing exporter...\`);
-        const instanceName = this.config.serviceName || basename(process.cwd()) || "openclaw-agent";
-        const instanceId = \`\${instanceName}@\${hostname()}:\${process.pid}\`;
-        const resource = new Resource({
-            [ATTR_SERVICE_NAME]: this.config.serviceName,
-            [ATTR_SERVICE_INSTANCE_ID]: instanceId,
-            "host.name": hostname(),
-        });
-        const authorization = this.config.authorization;
-        const workspaceId = this.config.workspaceId;
-        this.api.logger.info(\`[CozeloopTrace] Using authorization, workspaceId=\${workspaceId}, tokenLength=\${authorization?.length}\`);
-        const exporter = new OTLPTraceExporter({
-            url: \`\${this.config.endpoint}/v1/traces\`,
-            headers: {
-                "Authorization": authorization,
-                "cozeloop-workspace-id": workspaceId,
-                "x-tt-env": "ppe_cozelab",
-                "x-use-ppe": "1",
-            },
-        });
-        this.provider = new BasicTracerProvider({ resource });
-        this.provider.addSpanProcessor(new BatchSpanProcessor(exporter, {
-            maxQueueSize: 100,
-            maxExportBatchSize: this.config.batchSize || 10,
-            scheduledDelayMillis: this.config.batchInterval || 5000,
-        }));
-        // Do NOT call this.provider.register() — it sets the global TracerProvider
-        // singleton, so if the plugin is activated more than once (e.g. gateway +
-        // plugins subsystem), the second instance would silently get a NOOP tracer
-        // while its hooks override those of the first instance, causing all trace
-        // operations to become no-ops.  Instead, obtain the tracer directly from
-        // our own provider instance.
-        this.tracer = this.provider.getTracer("openclaw-cozeloop-trace", PLUGIN_VERSION);
-        this.initialized = true;
-        this.api.logger.info(\`[CozeloopTrace] Exporter initialized with Authorization, workspaceId=\${workspaceId}\`);
-    }
-    async startSpan(spanData, spanId) {
-        try {
-            await this.ensureInitialized();
-            this.doStartSpan(spanData, spanId);
-        }
-        catch (err) {
-            this.api.logger.error(\`[CozeloopTrace] Failed to start span: \${err}\`);
-        }
-    }
-    doStartSpan(spanData, spanId) {
-        if (!this.tracer)
-            return;
-        const spanKind = this.getSpanKind(spanData.type);
-        const isRoot = !spanData.parentSpanId;
-        const isAgent = spanData.type === "agent";
-        // Resolve parent context:
-        // - Root spans: no parent, use active context.
-        // - Agent/child spans: look up traceContexts by parentSpanId (which is
-        //   always the rootSpanId set by index.ts createSpan / ensureRootSpan).
-        const traceCtx = spanData.parentSpanId
-            ? this.traceContexts.get(spanData.parentSpanId)
-            : undefined;
-        if (!isRoot && !traceCtx && this.config.debug) {
-            const keys = Array.from(this.traceContexts.keys());
-            this.api.logger.info(\`[CozeloopTrace] doStartSpan() cannot find parent context: \` +
-                \`parentSpanId=\${spanData.parentSpanId}, spanName=\${spanData.name}, type=\${spanData.type}, \` +
-                \`traceContextKeys=[\${keys.join(",")}]\`);
-        }
-        let parentContext;
-        if (isRoot) {
-            parentContext = context.active();
-        }
-        else if (isAgent) {
-            parentContext = traceCtx?.rootContext || context.active();
-        }
-        else {
-            parentContext = traceCtx?.agentContext || traceCtx?.rootContext || context.active();
-        }
-        const runtimeTag = {
-            language: "nodejs",
-            library: "openclaw",
-        };
-        if (process.env.COZELOOP_SCENE) {
-            runtimeTag.scene = process.env.COZELOOP_SCENE;
-        }
-        const systemTagRuntime = JSON.stringify(runtimeTag);
-        const span = this.tracer.startSpan(spanData.name, {
-            kind: spanKind,
-            startTime: spanData.startTime,
-            attributes: {
-                "cozeloop.span_type": spanData.type,
-                "cozeloop.system_tag_runtime": systemTagRuntime,
-                ...this.envAttributes,
-                ...this.flattenAttributes(spanData.attributes),
-            },
-        }, parentContext);
-        if (isRoot) {
-            const rootContext = trace.setSpan(context.active(), span);
-            this.traceContexts.set(spanId, { rootSpan: span, rootContext });
-            if (this.config.debug) {
-                const sc = span.spanContext();
-                this.api.logger.info(\`[CozeloopTrace] Created ROOT span: name=\${spanData.name}, traceId=\${sc.traceId}, spanId=\${sc.spanId}\`);
-            }
-        }
-        if (isAgent && traceCtx) {
-            traceCtx.agentSpan = span;
-            traceCtx.agentContext = trace.setSpan(traceCtx.rootContext, span);
-            if (this.config.debug) {
-                const sc = span.spanContext();
-                this.api.logger.info(\`[CozeloopTrace] Created AGENT span: name=\${spanData.name}, traceId=\${sc.traceId}, spanId=\${sc.spanId}\`);
-            }
-        }
-        this.setSpanInputOutput(span, spanData);
-        this.openSpans.set(spanId, span);
-        if (this.config.debug && !isRoot && !isAgent) {
-            const spanContext = span.spanContext();
-            this.api.logger.info(\`[CozeloopTrace] Started span: name=\${spanData.name}, type=\${spanData.type}, \` +
-                \`traceId=\${spanContext.traceId}, spanId=\${spanContext.spanId}\`);
-        }
-    }
-    endSpanById(spanId, endTime, additionalAttrs, output, input) {
-        const span = this.openSpans.get(spanId);
-        if (!span) {
-            if (this.config.debug) {
-                this.api.logger.info(\`[CozeloopTrace] Span not found for ending: spanId=\${spanId}\`);
-            }
-            return;
-        }
-        if (additionalAttrs) {
-            for (const [key, value] of Object.entries(additionalAttrs)) {
-                if (value !== undefined && value !== null) {
-                    span.setAttribute(key, value);
-                }
-            }
-        }
-        if (input !== undefined) {
-            const inputStr = typeof input === "string" ? input : JSON.stringify(input);
-            span.setAttribute("cozeloop.input", inputStr.substring(0, 3200000));
-        }
-        if (output !== undefined) {
-            const outputStr = typeof output === "string" ? output : JSON.stringify(output);
-            span.setAttribute("cozeloop.output", outputStr.substring(0, 3200000));
-        }
-        span.setStatus({ code: SpanStatusCode.OK });
-        span.end(endTime || Date.now());
-        this.openSpans.delete(spanId);
-        if (this.config.debug) {
-            const sc = span.spanContext();
-            this.api.logger.info(\`[CozeloopTrace] Ended span: spanId=\${spanId}, traceId=\${sc.traceId}\`);
-        }
-    }
-    async export(spanData) {
-        try {
-            await this.ensureInitialized();
-            if (!this.tracer)
-                return;
-            const spanKind = this.getSpanKind(spanData.type);
-            const isRoot = !spanData.parentSpanId;
-            const isAgent = spanData.type === "agent";
-            const traceCtx = spanData.parentSpanId
-                ? this.traceContexts.get(spanData.parentSpanId)
-                : undefined;
-            if (!isRoot && !traceCtx) {
-                // Only warn for span types that are expected to be inside a trace
-                // (agent, model, tool). message/session/gateway spans may fire before
-                // the root span is created and that is normal.
-                const criticalTypes = new Set(["agent", "model", "tool"]);
-                if (criticalTypes.has(spanData.type) && this.config.debug) {
-                    const keys = Array.from(this.traceContexts.keys());
-                    this.api.logger.info(\`[CozeloopTrace] export() cannot find parent context: \` +
-                        \`parentSpanId=\${spanData.parentSpanId}, spanName=\${spanData.name}, type=\${spanData.type}, \` +
-                        \`traceContextKeys=[\${keys.join(",")}]\`);
-                }
-            }
-            let parentContext;
-            if (isRoot) {
-                parentContext = context.active();
-            }
-            else if (isAgent) {
-                parentContext = traceCtx?.rootContext || context.active();
-            }
-            else {
-                parentContext = traceCtx?.agentContext || traceCtx?.rootContext || context.active();
-            }
-            const runtimeTag = {
-                language: "nodejs",
-                library: "openclaw",
-            };
-            if (process.env.COZELOOP_SCENE) {
-                runtimeTag.scene = process.env.COZELOOP_SCENE;
-            }
-            const systemTagRuntime = JSON.stringify(runtimeTag);
-            const span = this.tracer.startSpan(spanData.name, {
-                kind: spanKind,
-                startTime: spanData.startTime,
-                attributes: {
-                    "cozeloop.span_type": spanData.type,
-                    "cozeloop.system_tag_runtime": systemTagRuntime,
-                    ...this.envAttributes,
-                    ...this.flattenAttributes(spanData.attributes),
-                },
-            }, parentContext);
-            if (isRoot) {
-                const rootContext = trace.setSpan(context.active(), span);
-                const spanId = spanData.spanId || "export-root";
-                this.traceContexts.set(spanId, { rootSpan: span, rootContext });
-                if (this.config.debug) {
-                    const sc = span.spanContext();
-                    this.api.logger.info(\`[CozeloopTrace] Created ROOT span: name=\${spanData.name}, traceId=\${sc.traceId}, spanId=\${sc.spanId}\`);
-                }
-            }
-            this.setSpanInputOutput(span, spanData);
-            const hasError = spanData.attributes["error"] === true || spanData.attributes["tool.error"] === true;
-            if (hasError) {
-                span.setStatus({ code: SpanStatusCode.ERROR });
-            }
-            else {
-                span.setStatus({ code: SpanStatusCode.OK });
-            }
-            span.end(spanData.endTime || Date.now());
-            if (this.config.debug) {
-                const spanContext = span.spanContext();
-                this.api.logger.info(\`[CozeloopTrace] Created span: name=\${spanData.name}, type=\${spanData.type}, \` +
-                    \`traceId=\${spanContext.traceId}, spanId=\${spanContext.spanId}, isRoot=\${isRoot}\`);
-            }
-        }
-        catch (err) {
-            this.api.logger.error(\`[CozeloopTrace] Failed to export span: \${err}\`);
-        }
-    }
-    setSpanInputOutput(span, spanData) {
-        if (spanData.input !== undefined) {
-            const inputStr = typeof spanData.input === "string"
-                ? spanData.input
-                : JSON.stringify(spanData.input);
-            span.setAttribute("cozeloop.input", inputStr.substring(0, 3200000));
-        }
-        if (spanData.output !== undefined) {
-            const outputStr = typeof spanData.output === "string"
-                ? spanData.output
-                : JSON.stringify(spanData.output);
-            span.setAttribute("cozeloop.output", outputStr.substring(0, 3200000));
-        }
-    }
-    hasTraceContext(rootSpanId) {
-        return this.traceContexts.has(rootSpanId);
-    }
-    endTrace(rootSpanId) {
-        if (rootSpanId) {
-            this.traceContexts.delete(rootSpanId);
-        }
-        else {
-            this.traceContexts.clear();
-            this.openSpans.clear();
-        }
-        if (this.config.debug) {
-            this.api.logger.info(\`[CozeloopTrace] Trace ended, context cleared\${rootSpanId ? \` for rootSpanId=\${rootSpanId}\` : ' (all)'}\`);
-        }
-    }
-    getSpanKind(type) {
-        switch (type) {
-            case "entry":
-            case "gateway":
-                return SpanKind.SERVER;
-            case "model":
-                return SpanKind.CLIENT;
-            case "tool":
-                return SpanKind.CLIENT;
-            default:
-                return SpanKind.INTERNAL;
-        }
-    }
-    flattenAttributes(attrs) {
-        const result = {};
-        for (const [key, value] of Object.entries(attrs)) {
-            if (value !== undefined && value !== null) {
-                result[key] = value;
-            }
-        }
-        return result;
-    }
-    async flush() {
-        if (this.provider) {
-            await this.provider.forceFlush();
-        }
-    }
-    async dispose() {
-        if (this.provider) {
-            await this.provider.shutdown();
-        }
-    }
-}
-`,
-  "dist/span-manager.js": `function generateId(length = 16) {
-    const chars = "0123456789abcdef";
-    let result = "";
-    for (let i = 0; i < length; i++) {
-        result += chars[Math.floor(Math.random() * chars.length)];
-    }
-    return result;
-}
-export class SpanManager {
-    activeSpans = new Map();
-    sessionTraceMap = new Map();
-    turnSpanMap = new Map();
-    generateTraceId() {
-        return generateId(32);
-    }
-    generateSpanId() {
-        return generateId(16);
-    }
-    getOrCreateTraceId(sessionId) {
-        let traceId = this.sessionTraceMap.get(sessionId);
-        if (!traceId) {
-            traceId = this.generateTraceId();
-            this.sessionTraceMap.set(sessionId, traceId);
-        }
-        return traceId;
-    }
-    startSpan(sessionId, name, type, attributes = {}, input, parentSpanId) {
-        const traceId = this.getOrCreateTraceId(sessionId);
-        const spanId = this.generateSpanId();
-        const span = {
-            name,
-            type,
-            startTime: Date.now(),
-            attributes: {
-                ...attributes,
-                "session.id": sessionId,
-            },
-            input,
-            parentSpanId,
-            traceId,
-            spanId,
-        };
-        this.activeSpans.set(spanId, span);
-        return span;
-    }
-    endSpan(spanId, output, additionalAttributes) {
-        const span = this.activeSpans.get(spanId);
-        if (!span)
-            return undefined;
-        span.endTime = Date.now();
-        span.output = output;
-        if (additionalAttributes) {
-            Object.assign(span.attributes, additionalAttributes);
-        }
-        this.activeSpans.delete(spanId);
-        return span;
-    }
-    getSpan(spanId) {
-        return this.activeSpans.get(spanId);
-    }
-    setTurnSpan(turnId, spanId) {
-        this.turnSpanMap.set(turnId, spanId);
-    }
-    getTurnSpanId(turnId) {
-        return this.turnSpanMap.get(turnId);
-    }
-    clearSession(sessionId) {
-        this.sessionTraceMap.delete(sessionId);
-        for (const [turnId, spanId] of this.turnSpanMap.entries()) {
-            const span = this.activeSpans.get(spanId);
-            if (span && span.attributes["session.id"] === sessionId) {
-                this.turnSpanMap.delete(turnId);
-                this.activeSpans.delete(spanId);
-            }
-        }
-    }
-}
-`,
-  "dist/types.js": `export {};
-`,
-  "openclaw.plugin.json": `{
-  "id": "openclaw-cozeloop-trace",
-  "name": "OpenClaw CozeLoop Trace",
-  "version": "0.1.12",
-  "description": "Report OpenClaw execution traces to CozeLoop via OpenTelemetry",
-  "type": "plugin",
-  "entry": "./dist/index.js",
-  "configSchema": {
-    "type": "object",
-    "properties": {
-      "endpoint": {
-        "type": "string",
-        "default": "https://api.coze.cn/v1/loop/opentelemetry",
-        "description": "CozeLoop OTLP endpoint URL"
-      },
-      "authorization": {
-        "type": "string",
-        "default": "",
-        "description": "Authorization header value"
-      },
-      "workspaceId": {
-        "type": "string",
-        "default": "",
-        "description": "Cozeloop workspace ID"
-      },
-      "serviceName": {
-        "type": "string",
-        "default": "openclaw-agent",
-        "description": "Service name for traces"
-      },
-      "debug": {
-        "type": "boolean",
-        "default": false,
-        "description": "Enable debug logging"
-      },
-      "batchSize": {
-        "type": "number",
-        "default": 10,
-        "description": "Number of spans to buffer before sending"
-      },
-      "batchInterval": {
-        "type": "number",
-        "default": 5000,
-        "description": "Maximum time (ms) to wait before sending buffered spans"
-      },
-      "enabledHooks": {
-        "type": "array",
-        "items": {
-          "type": "string"
-        },
-        "description": "List of hooks to enable (if not set, all hooks are enabled)"
-      }
-    }
-  }
-}
-`,
-  "package.json": `{
-  "name": "@cozeloop/openclaw-cozeloop-trace",
-  "version": "0.1.12",
-  "description": "OpenClaw Plugin for reporting traces to CozeLoop via OpenTelemetry",
-  "type": "module",
-  "main": "dist/index.js",
-  "exports": {
-    ".": "./dist/index.js"
-  },
-  "openclaw": {
-    "extensions": [
-      "./dist/index.js"
-    ]
-  },
-  "scripts": {
-    "build": "tsc",
-    "dev": "tsc --watch",
-    "clean": "rm -rf dist",
-    "prepublishOnly": "npm run build"
-  },
-  "files": [
-    "dist",
-    "openclaw.plugin.json"
-  ],
-  "keywords": [
-    "openclaw",
-    "plugin",
-    "cozeloop",
-    "tracing",
-    "opentelemetry"
-  ],
-  "author": "",
-  "license": "MIT",
-  "devDependencies": {
-    "@types/node": "^20.0.0",
-    "typescript": "^5.0.0"
-  },
-  "dependencies": {
-    "@opentelemetry/api": "^1.7.0",
-    "@opentelemetry/exporter-trace-otlp-proto": "^0.48.0",
-    "@opentelemetry/resources": "^1.22.0",
-    "@opentelemetry/sdk-trace-base": "^1.22.0",
-    "@opentelemetry/semantic-conventions": "^1.22.0"
-  }
-}
-`,
-};
-
-// ─── 2c. Embedded refresh script ──────────────────────────────────────────────
-const COZELOOP_REFRESH_PY = `\
-#!/usr/bin/env python3
-"""
-CozeLoop token refresh hook — runs at SessionStart.
-Checks credentials.json and refreshes the token if expiring soon.
-Writes the fresh token back so subsequent Stop hooks pick it up.
-"""
-import json, os, sys, time, urllib.request
-from pathlib import Path
-
-CLIENT_ID = "46371084383473718052118955183420.app.coze"
-COZE_API  = "https://api.coze.cn"
-THRESHOLD = 10 * 60  # 10 minutes
-CREDS     = Path.home() / ".cozeloop" / "credentials.json"
-
-def load():
-    try: return json.loads(CREDS.read_text())
-    except: return None
-
-def save(c):
-    CREDS.parent.mkdir(parents=True, exist_ok=True)
-    CREDS.write_text(json.dumps(c, indent=2))
-    os.chmod(CREDS, 0o600)
-
-def refresh(rt):
-    try:
-        body = json.dumps({"grant_type":"refresh_token","client_id":CLIENT_ID,"refresh_token":rt}).encode()
-        req = urllib.request.Request(f"{COZE_API}/api/permission/oauth2/token",
-            data=body, headers={
-                "Content-Type":"application/json",
-                "x-tt-env":"ppe_cozelab",
-                "x-use-ppe":"1",
-            })
-        with urllib.request.urlopen(req, timeout=10) as r:
-            d = json.loads(r.read())
-        if d.get("access_token"):
-            existing = load() or {}
-            save({"access_token":d["access_token"],
-                  "refresh_token":d.get("refresh_token",rt),
-                  "expires_at":d.get("expires_in",0)*1000,
-                  "workspace_id":existing.get("workspace_id","")})
-            return True
-    except Exception as e:
-        print(f"[cozeloop_refresh] refresh failed: {e}", file=sys.stderr)
-    return False
-
-def main():
-    creds = load()
-    if not creds: return
-    remaining = (creds.get("expires_at",0)/1000) - time.time()
-    if remaining > THRESHOLD: return  # still fresh
-    print(f"[cozeloop_refresh] token expiring in {int(remaining)}s, refreshing...", file=sys.stderr)
-    if creds.get("refresh_token"):
-        if refresh(creds["refresh_token"]):
-            print("[cozeloop_refresh] token refreshed OK", file=sys.stderr)
-        else:
-            print("[cozeloop_refresh] refresh failed, token may expire soon", file=sys.stderr)
-
-main()
-
-`;
 
 // ─── 3. Param parsing ────────────────────────────────────────────────────────
 function parseArgs() {
@@ -5249,9 +565,9 @@ function writeClaudeCodeHook(patToken, workspaceId, pythonCmd, configBaseDir, cl
       existing.env.OTEL_ENDPOINT = otelEndpoint;
       delete existing.env.COZELOOP_API_BASE_URL;
     }
-    // PPE 泳道：cozeloop SDK 读这两个环境变量，自动注入 x-tt-env / x-use-ppe header
-    existing.env.x_tt_env  = PPE_TT_ENV;
-    existing.env.x_use_ppe = PPE_USE_PPE;
+    // 切正式环境：移除历史注入的 PPE 泳道 env（旧版本曾写入 x_tt_env/x_use_ppe）
+    delete existing.env.x_tt_env;
+    delete existing.env.x_use_ppe;
     return existing;
   });
   try {
@@ -5308,9 +624,6 @@ function writeCodexHook(token, workspaceId, pythonCmd, codexHome, cloud) {
   } else if (otelEndpoint) {
     envLines.push(shellEnvLine('OTEL_ENDPOINT', otelEndpoint));
   }
-  // PPE 泳道：cozeloop SDK 读这两个环境变量，自动注入 x-tt-env / x-use-ppe header
-  envLines.push(shellEnvLine('x_tt_env', PPE_TT_ENV));
-  envLines.push(shellEnvLine('x_use_ppe', PPE_USE_PPE));
   const envContent = envLines.join('\n') + '\n';
   try {
     fs.writeFileSync(envFile, envContent, { mode: 0o600 });
@@ -5653,7 +966,6 @@ function httpsPost(url, body, extraHeaders) {
     const req = https.request(
       { hostname: u.hostname, port: u.port || undefined, path: u.pathname + u.search, method: 'POST',
         headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(data),
-                   'x-tt-env': PPE_TT_ENV, 'x-use-ppe': PPE_USE_PPE,
                    ...(extraHeaders || {}) } },
       (res) => {
         let buf = '';
@@ -5738,8 +1050,6 @@ def http_diag():
         headers={
             "Content-Type": "application/json",
             "Authorization": "Bearer " + os.environ.get("COZELOOP_API_TOKEN", ""),
-            "x-tt-env": os.environ.get("x_tt_env", ""),
-            "x-use-ppe": os.environ.get("x_use_ppe", ""),
         },
         method="POST",
     )
@@ -5789,8 +1099,6 @@ except Exception as e:
     COZELOOP_API_TOKEN: token,
     COZELOOP_PAIR_CODE: pair,
     COZELOOP_TOKEN_SOURCE: tokenSource || '',
-    x_tt_env: PPE_TT_ENV,
-    x_use_ppe: PPE_USE_PPE,
   };
   if (apiBase) env.COZELOOP_API_BASE_URL = apiBase;
   // 打出 SDK 实际使用的 ingest base，便于核对云端注入的 api_base_url 是否正确（无 /api 残留）。
@@ -6042,8 +1350,7 @@ function openClawPluginHasRefresh(home) {
 
 function httpsGet(url, headers) {
   return new Promise((resolve, reject) => {
-    // 合并 PPE 泳道 header
-    const h = { ...(headers || {}), 'x-tt-env': PPE_TT_ENV, 'x-use-ppe': PPE_USE_PPE };
+    const h = { ...(headers || {}) };
     const req = https.get(url, { headers: h }, (res) => {
       let buf = '';
       res.on('data', c => buf += c);