coze_lab 0.1.52 → 0.1.54

package/index.js

@@ -96,6 +96,7 @@ const C = {
 };
 
 function log(prefix, color, msg) {
+  if (process.env.COZELAB_ONBOARD_VERBOSE !== '1') return;
   console.log(`${color}${prefix}${C.reset} ${msg}`);
 }
 const ok   = (msg) => log('[✓]', C.green,  msg);
@@ -123,6 +124,7 @@ function errorBox(lines) {
 }
 
 function warnBox(lines) {
+  if (process.env.COZELAB_ONBOARD_VERBOSE !== '1') return;
   box(lines, C.yellow);
 }
 
@@ -549,6 +551,48 @@ function isVersionAtLeast(version, minVersion) {
   return true;
 }
 
+// Codex docs now use [features].hooks as the canonical key; codex_hooks is a
+// deprecated alias. Keep the alias only for explicitly detected older CLIs.
+const CODEX_CANONICAL_HOOKS_FEATURE_MIN_VERSION = '0.134.0';
+
+function codexHooksFeatureKey(version) {
+  const hasKnownVersion = parseVersionNumbers(version).length > 0;
+  if (hasKnownVersion && !isVersionAtLeast(version, CODEX_CANONICAL_HOOKS_FEATURE_MIN_VERSION)) {
+    return 'codex_hooks';
+  }
+  return 'hooks';
+}
+
+function normalizeCodexHooksFeatureConfig(configToml, codexVersion) {
+  const featureKey = codexHooksFeatureKey(codexVersion);
+  const lines = String(configToml || '').replace(/\r\n/g, '\n').split('\n');
+  if (lines.length && lines[lines.length - 1] === '') lines.pop();
+
+  const featureHeaderRe = /^\s*\[features\]\s*(?:#.*)?$/;
+  const tableHeaderRe = /^\s*\[\[?[^\]]+\]\]?\s*(?:#.*)?$/;
+  const hookFeatureRe = /^\s*(hooks|codex_hooks)\s*=/;
+  const featureIdx = lines.findIndex((line) => featureHeaderRe.test(line));
+
+  if (featureIdx === -1) {
+    const out = [...lines];
+    if (out.length && out[out.length - 1].trim() !== '') out.push('');
+    out.push('[features]', `${featureKey} = true`);
+    return out.join('\n') + '\n';
+  }
+
+  let endIdx = featureIdx + 1;
+  while (endIdx < lines.length && !tableHeaderRe.test(lines[endIdx])) {
+    endIdx += 1;
+  }
+
+  const before = lines.slice(0, featureIdx);
+  const section = lines.slice(featureIdx, endIdx).filter((line, idx) => idx === 0 || !hookFeatureRe.test(line));
+  section.splice(1, 0, `${featureKey} = true`);
+  const after = lines.slice(endIdx);
+
+  return [...before, ...section, ...after].join('\n') + '\n';
+}
+
 // ─── 7. Hook writers ─────────────────────────────────────────────────────────
 const fs   = require('fs');
 const path = require('path');
@@ -729,13 +773,14 @@ function writeClaudeCodeHook(token, workspaceId, pythonCmd, configBaseDir, cloud
 // 传入动态目录（如 coze-bridge 的 /tmp/coze-bridge-codex-home-xxx）即可 per-agent 生效。
 // 本地 --agent-id 从 config.patToken 写入 token，并用 COZELOOP_TOKEN_SOURCE 标记来源。
 // cloud=true 时写 COZELAB_ONBOARD_CLOUD，并带入 sandbox 注入的 trace token。
-function writeCodexHook(token, workspaceId, pythonCmd, codexHome, cloud, tokenSource) {
+function writeCodexHook(token, workspaceId, pythonCmd, codexHome, cloud, tokenSource, codexVersion) {
   const home       = codexHome || path.join(os.homedir(), '.codex');
   const hooksDir   = path.join(home, 'hooks');
   const hookScript = path.join(hooksDir, 'cozeloop_hook.py');
   const envFile    = path.join(hooksDir, 'cozeloop.env');
   const logFile    = path.join(hooksDir, 'cozeloop.log');
   const hooksJson  = path.join(home, 'hooks.json');
+  const configToml = path.join(home, 'config.toml');
 
   // 1. Write Python hook script
   ensureDir(hooksDir);
@@ -810,9 +855,22 @@ function writeCodexHook(token, workspaceId, pythonCmd, codexHome, cloud, tokenSo
     errorBox([`ERROR: Cannot write ${hooksJson}`, '', e.message]);
   }
   ok(`Hook registered in ${hooksJson}`);
+
+  // 4. Normalize Codex hook feature flag. hooks.json carries hook definitions;
+  //    config.toml carries the on/off feature gate. Re-running onboard should
+  //    clean the deprecated codex_hooks alias for modern Codex versions.
+  const featureKey = codexHooksFeatureKey(codexVersion);
+  try {
+    const existingConfig = fs.existsSync(configToml) ? fs.readFileSync(configToml, 'utf8') : '';
+    const nextConfig = normalizeCodexHooksFeatureConfig(existingConfig, codexVersion);
+    atomicWriteFileSync(configToml, nextConfig);
+  } catch (e) {
+    errorBox([`ERROR: Cannot update ${configToml}`, '', e.message]);
+  }
+  ok(`Codex hooks feature enabled via [features].${featureKey} in ${configToml}`);
   warn('Codex hook trust: 首次启动 Codex 会提示 "Hooks need review"。在该提示按 t（Trust all and continue），或在会话内运行 /hooks 后按 t，即可一次性信任全部 hook 启用 trace 上报。');
 
-  return { hookScript, envFile, hooksJson, logFile };
+  return { hookScript, envFile, hooksJson, configToml, logFile };
 }
 
 function resolveCodexHome(args) {
@@ -1291,8 +1349,6 @@ except Exception as e:
   } else {
     warn(`trace 上报失败: SDK selfcheck exit ${result.code}`);
     info(`trace selfcheck api_base_url=${apiBase || COZE_API}, token_source=${tokenSource || 'unknown'}`);
-    const snippet = String(body || '').slice(0, 300);
-    if (snippet) console.log(snippet);
   }
   return { success, status: result.code || 0, body, traceId: '', pairCode: pair, apiBaseUrl: apiBase, tokenSource, logid: parsed?.logid || extractLogid(body) || '' };
 }
@@ -1365,8 +1421,6 @@ async function verifyCloudTraceReport(token, workspaceId, pairCode, tokenSource)
       info(`查询方可用 pair_code=${pair} 在 CozeLoop 回查确认该 trace 已落库。`);
     } else {
       warn(`trace 上报失败: HTTP ${res.status}${formatLogid(res.logid || '')}`);
-      const snippet = (res.body || '').slice(0, 300);
-      if (snippet) console.log(snippet);
     }
     return { success, status: res.status, body: res.body || '', traceId, pairCode: pair, apiBaseUrl: apiBase, tokenSource, logid: res.logid || extractLogid(res.body || '') };
   } catch (e) {
@@ -1431,8 +1485,6 @@ async function verifyTraceReport(token, workspaceId, pairCode, tracesUrl) {
     info(`查询方可用 pair_code=${pair} 在 CozeLoop 回查确认该 trace 已落库。`);
   } else {
     warn(`trace 上报失败: HTTP ${res.status}${formatLogid(res.logid || '')}`);
-    const snippet = (res.body || '').slice(0, 300);
-    if (snippet) console.log(snippet);
   }
   return { success, status: res.status, body: res.body, traceId, pairCode: pair, logid: res.logid || extractLogid(res.body || '') };
 }
@@ -1534,8 +1586,6 @@ async function verifyOpenClawTraceLink(cloud, pairCode) {
     ok(`openclaw 插件实际 token 上报正常 (token=${tokenPrefix}..., HTTP ${res.status}${formatLogid(res.logid || '')})`);
   } else {
     warn(`openclaw 插件实际 token 上报失败: HTTP ${res.status}${formatLogid(res.logid || '')} (token=${tokenPrefix}...)`);
-    const snippet = (res.body || '').slice(0, 300);
-    if (snippet) console.log(snippet);
     // 4100/401 = 该 token 已失效。指出根因与修复方式。
     if (res.status === 401 || /\b4100\b/.test(res.body || '')) {
       info('插件配置的 token 已失效。运行时上报会 401，span 会丢失。');
@@ -1576,9 +1626,7 @@ function openClawNextStep(written) {
 }
 
 async function main() {
-  console.log('');
   info(`CozeLoop Onboard CLI starting... (coze_lab v${PACKAGE_VERSION})`);
-  console.log('');
 
   const args = validateArgs(parseArgs());
 
@@ -1607,7 +1655,6 @@ async function main() {
         '请确认 ~/.coze/agents/<id>/config.json 包含 patToken 后重试。',
       ]);
     }
-    console.log('');
     const result = await verifyTraceReport(token, WORKSPACE_ID, args.pairCode, getOtelTracesUrl(false));
     // 若本机装了 openclaw 插件，额外校验插件【实际配置的静态 token】——通用 verify 用刚刷新的
     // token 测不到它。任一失败则整体判失败（exit 1）。
@@ -1617,14 +1664,28 @@ async function main() {
       try {
         const cfg = JSON.parse(fs.readFileSync(ocConfigPath, 'utf8'));
         if (cfg?.plugins?.entries?.['openclaw-cozeloop-trace']?.config?.authorization) {
-          console.log('');
           info('检测到 openclaw cozeloop-trace 插件，校验其实际 token...');
           const ocRes = await verifyOpenClawTraceLink(args.cloud, args.pairCode);
           ocOk = ocRes.success;
         }
       } catch { /* 读不了就跳过 openclaw 校验 */ }
     }
-    process.exit(result.success && ocOk ? 0 : 1);
+    if (result.success && ocOk) {
+      successBox([
+        `Verify:      coze_lab v${PACKAGE_VERSION}`,
+        `Trace:       OK (pair_code=${result.pairCode})`,
+      ]);
+      return;
+    }
+    errorBox([
+      'ERROR: trace 上报自检失败',
+      '',
+      `HTTP ${result.status}`,
+      `logid=${result.logid || extractLogid(result.body) || ''}`,
+      (result.body || '').slice(0, 300),
+      '',
+      '请确认 CozeLoop Token 具备 Trace ingest 权限，再重试。',
+    ]);
   }
 
   const { agent } = args;
@@ -1638,7 +1699,6 @@ async function main() {
   }
   if (args.agentId) {
     info(`目标 agent: ${args.agentId} (framework=${agent}, workspace=${agentWorkspace || 'N/A'}, deploy=${args.cloud ? 'cloud' : 'local'}, reason=${args.deployReason || 'n/a'})`);
-    console.log('');
   }
 
   // Step 1: Resolve trace token.
@@ -1683,12 +1743,9 @@ async function main() {
       ]);
     }
   }
-  console.log('');
-
   // Step 2: Detect agent binary
   info('Step 2/5: Detecting agent...');
   const version = detectAgent(agent, args.cloud);
-  console.log('');
 
   // Step 3: Environment checks
   info('Step 3/5: Checking environment...');
@@ -1698,7 +1755,6 @@ async function main() {
     checkCozeloopSdk(pythonCmd, { cloud: args.cloud });
   }
   checkVersionWhitelist(agent, version);
-  console.log('');
 
   // Step 4: Write hook configuration
   info('Step 4/5: Writing hook configuration...');
@@ -1723,14 +1779,13 @@ async function main() {
       info(`已创建云端 Codex 配置目录: ${codexHome}`);
     }
     if (codexHome) info(`Codex 配置目录: ${codexHome}`);
-    written = writeCodexHook(token, WORKSPACE_ID, pythonCmd, codexHome, args.cloud, tokenSource);
+    written = writeCodexHook(token, WORKSPACE_ID, pythonCmd, codexHome, args.cloud, tokenSource, version);
   } else {
     // openclaw：云端用 traceAgentIds allowlist 做 per-agent 放行。
     written = writeOpenClawHook(token, WORKSPACE_ID, args.agentId, args.cloud, args.force, tokenSource) || {};
   }
   // 走到这里说明 detectAgent / 环境检查 / 写 hook 配置全部成功 → 注入成功。
   cloudResult.inject = 'ok';
-  console.log('');
 
   // Success summary（用实际写入路径，per-agent / 自定义 CODEX_HOME 时也准确）
   const summaryLines = [
@@ -1745,6 +1800,7 @@ async function main() {
   } else if (agent === 'codex') {
     summaryLines.push(`Hook script: ${written.hookScript || '~/.codex/hooks/cozeloop_hook.py'}`);
     summaryLines.push(`Config:      ${written.hooksJson || '~/.codex/hooks.json'}`);
+    if (written.configToml) summaryLines.push(`Feature:     ${written.configToml}`);
     summaryLines.push(`Credentials: ${written.envFile || '~/.codex/hooks/cozeloop.env'}`);
     if (written.logFile) summaryLines.push(`Hook log:    ${written.logFile}`);
   } else {
@@ -1755,13 +1811,10 @@ async function main() {
 
   // Enterprise policy note for Claude Code
   if (agent === 'claude-code') {
-    console.log('');
     info('注意：企业托管模式下若 allowManagedHooksOnly=true，需管理员在策略中放行本地 hook。');
   }
   // Trace permission reminder for all agents
-  console.log('');
   info('确保 CozeLoop Token 具备 Trace ingest 权限，否则 hook 触发但上报会失败。');
-  console.log('');
 
   // Step 5: Verify trace reporting end-to-end
   info('Step 5/5: 验证 trace 上报链路...');
@@ -1783,7 +1836,6 @@ async function main() {
     cloudResult.logid = verifyResult.logid || extractLogid(verifyResult.body) || cloudResult.logid;
     cloudResult.message = `trace 上报自检失败 HTTP ${verifyResult.status}: ${(verifyResult.body || '').slice(0, 200)}`;
     warn('trace 上报自检失败，但 hook 配置已写入（云端放行）。');
-    console.log('');
     emitCloudResult();
     successBox(summaryLines);
     return;
@@ -1799,7 +1851,6 @@ async function main() {
       '请确认 CozeLoop Token 具备 Trace ingest 权限，再重试。',
     ]);   // errorBox 内部 process.exit(1)
   }
-  console.log('');
 
   emitCloudResult();
   successBox(summaryLines);
@@ -1833,5 +1884,7 @@ module.exports = {
   atomicWriteFileSync,
   VERSION_WHITELIST,
   VERSION_SUPPORT,
+  codexHooksFeatureKey,
+  normalizeCodexHooksFeatureConfig,
   isVersionAtLeast,
 };

package/package.json

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

package/scripts/claude-code/cozeloop_hook.py

@@ -230,6 +230,7 @@ def _make_finish_event_processor(upload_events: Optional[List[str]] = None):
     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:
@@ -393,6 +394,73 @@ def format_content(content: Any, truncate: int = 4096) -> str:
     return str(content)[:truncate]
 
 
+def _normalize_assistant_content(content: Any) -> Dict[str, Any]:
+    """Split supported Claude content without retaining protected payloads."""
+    result = {
+        "text": [],
+        "reasoning": [],
+        "tool_calls": [],
+        "parts": [],
+        "protected": {"source": "", "count": 0, "bytes": 0},
+        "unknown_types": {},
+    }
+    if isinstance(content, str):
+        if content:
+            result["text"].append(content)
+        return result
+    if not isinstance(content, list):
+        return result
+    for item in content:
+        if not isinstance(item, dict):
+            continue
+        item_type = item.get("type", "")
+        if item_type == "text":
+            text = item.get("text", "")
+            if text:
+                result["text"].append(text)
+                result["parts"].append(
+                    ModelMessagePart(type=ModelMessagePartType.TEXT, text=text)
+                )
+        elif item_type == "thinking":
+            thinking = item.get("thinking", "")
+            if thinking:
+                result["reasoning"].append(thinking)
+        elif item_type == "redacted_thinking":
+            data = item.get("data", "")
+            if isinstance(data, str) and data:
+                result["protected"]["source"] = "redacted_thinking"
+                result["protected"]["count"] += 1
+                result["protected"]["bytes"] += len(data.encode("utf-8"))
+        elif item_type == "tool_use":
+            result["tool_calls"].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:
+            key = item_type or "unknown"
+            result["unknown_types"][key] = result["unknown_types"].get(key, 0) + 1
+    return result
+
+
+def _set_protected_reasoning_tags(span, normalized: Dict[str, Any]):
+    protected = normalized.get("protected") or {}
+    if not protected.get("count"):
+        return
+    span.set_tags({
+        "protected_reasoning_source": protected.get("source", ""),
+        "protected_reasoning_count": protected.get("count", 0),
+        "protected_reasoning_bytes": protected.get("bytes", 0),
+    })
+
+
 # --- Message Parsing and Grouping ---
 
 def is_tool_result_message(msg: Dict[str, Any]) -> bool:
@@ -1080,44 +1148,11 @@ def send_turns_to_cozeloop(turns: List[Dict[str, Any]], session_id: str, history
                                     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)
-
+                                normalized = _normalize_assistant_content(raw_content)
+                                text_parts = normalized["text"]
+                                thinking_parts = normalized["reasoning"]
+                                tool_call_list = normalized["tool_calls"]
+                                parts_list = normalized["parts"]
                                 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"
@@ -1138,6 +1173,7 @@ def send_turns_to_cozeloop(turns: List[Dict[str, Any]], session_id: str, history
                                 )
 
                                 model_span.set_output(ModelOutput(choices=[output_choice]))
+                                _set_protected_reasoning_tags(model_span, normalized)
 
                                 # Set token usage for this specific model call
                                 usage = assistant_message_obj.get("usage", {})
@@ -1243,42 +1279,11 @@ def send_turns_to_cozeloop(turns: List[Dict[str, Any]], session_id: str, history
                                                     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_normalized = _normalize_assistant_content(sub_content)
+                                                sub_text_parts = sub_normalized["text"]
+                                                sub_tc_list = sub_normalized["tool_calls"]
+                                                sub_parts_list = sub_normalized["parts"]
+                                                sub_thinking_parts = sub_normalized["reasoning"]
                                                 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"
@@ -1296,6 +1301,7 @@ def send_turns_to_cozeloop(turns: List[Dict[str, Any]], session_id: str, history
                                                         metadata={}
                                                     )
                                                 )]))
+                                                _set_protected_reasoning_tags(sub_model_span, sub_normalized)
 
                                                 # Distribute tokens evenly; remainder goes to last step
                                                 step_in = per_step_in + (remainder_in if sk == n_model_steps - 1 else 0)
@@ -1435,7 +1441,7 @@ def send_turns_to_cozeloop(turns: List[Dict[str, Any]], session_id: str, history
 def _rt_state_key_header():
     return "rt_root_header"
 
-def _flatten_completed_steps(turns: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+def _flatten_completed_steps(turns: List[Dict[str, Any]], is_terminal: bool = False) -> List[Dict[str, Any]]:
     """把 turns 线性展开成 step 列表；只取【已完成】的 step。
 
     一个 step（assistant 一次模型调用 + 其触发的 tool_results）视为已完成的判定：
@@ -1454,7 +1460,7 @@ def _flatten_completed_steps(turns: List[Dict[str, Any]]) -> List[Dict[str, Any]
     for idx, item in enumerate(flat):
         is_global_last = (idx == len(flat) - 1)
         has_results = bool(item["step"].get("tool_results"))
-        if (not is_global_last) or has_results:
+        if is_terminal or (not is_global_last) or has_results:
             completed.append(item)
     return completed, len(flat)
 
@@ -1546,7 +1552,7 @@ def send_steps_realtime(turns, session_id, history_turns, state, coze_tags_overr
             debug_log(f"[rt] root created+finished trace_id={getattr(root_ctx,'trace_id','?')}")
 
         # ---- 发新完成的 step ----
-        completed, total_steps = _flatten_completed_steps(turns)
+        completed, total_steps = _flatten_completed_steps(turns, is_terminal=is_terminal)
         last_global = state.get("rt_last_global_step", 0)
         new_items = completed[last_global:]
         # 批量节流：非终态时，距上次上报不足 REALTIME_BATCH_INTERVAL 秒则本次不发，
@@ -1581,16 +1587,33 @@ def send_steps_realtime(turns, session_id, history_turns, state, coze_tags_overr
             if step_start_dt is not None and step_end_dt is not None:
                 _set_finish_time_safe(mspan, step_end_dt)
             raw_content = amo.get("content", [])
-            text_parts = []
-            if isinstance(raw_content, list):
-                for it in raw_content:
-                    if isinstance(it, dict) and it.get("type") == "text" and it.get("text"):
-                        text_parts.append(it["text"])
-            elif isinstance(raw_content, str):
-                text_parts.append(raw_content)
-            mspan.set_input(format_content((assistant_msg.get("message", {}) or {}).get("content")))
-            if text_parts:
-                mspan.set_output("\n".join(text_parts))
+            normalized = _normalize_assistant_content(raw_content)
+            turn_user = item["turn"].get("user_message", {}).get("message", {})
+            turn_user_content = turn_user.get("content") if turn_user else None
+            input_messages = list(_build_history_messages(history_turns or []))
+            if not is_empty_content(turn_user_content):
+                input_messages.append(_make_message("user", format_content(turn_user_content)))
+            mspan.set_input(ModelInput(
+                messages=input_messages,
+                tools=[],
+                tool_choice=ModelToolChoice(type="", function=None),
+            ))
+            output_choice = ModelChoice(
+                finish_reason="tool_calls" if normalized["tool_calls"] else "stop",
+                index=0,
+                message=ModelMessage(
+                    role="assistant",
+                    content="\n".join(normalized["text"]),
+                    reasoning_content="\n".join(normalized["reasoning"]),
+                    parts=normalized["parts"],
+                    name="",
+                    tool_calls=normalized["tool_calls"],
+                    tool_call_id="",
+                    metadata={},
+                ),
+            )
+            mspan.set_output(ModelOutput(choices=[output_choice]))
+            _set_protected_reasoning_tags(mspan, normalized)
             usage = amo.get("usage", {})
             it_tok = _usage_int(usage, "input_tokens") + _usage_int(usage, "cache_creation_input_tokens") + _usage_int(usage, "cache_read_input_tokens")
             if it_tok > 0:

package/scripts/codex/cozeloop_hook.py

@@ -575,6 +575,48 @@ def extract_assistant_text(payload: Dict[str, Any]) -> str:
     return "\n".join(parts)
 
 
+def _protected_reasoning_meta(source: str, payload: Any) -> Dict[str, Any]:
+    """Return safe metadata for protected reasoning without retaining payload."""
+    if not isinstance(payload, str) or not payload:
+        return {}
+    return {
+        "source": source,
+        "count": 1,
+        "bytes": len(payload.encode("utf-8")),
+    }
+
+
+def extract_reasoning_record(payload: Dict[str, Any]) -> Dict[str, Any]:
+    """Normalize a Codex reasoning item, excluding encrypted content itself."""
+    parts = [
+        item.get("text", "")
+        for item in payload.get("summary", [])
+        if isinstance(item, dict)
+        and item.get("type") == "summary_text"
+        and item.get("text")
+    ]
+    return {
+        "content": "",
+        "reasoning": "\n".join(parts),
+        "protected": _protected_reasoning_meta(
+            "encrypted_content", payload.get("encrypted_content")
+        ),
+        "_ts": payload.get("_ts"),
+        "_line_number": payload.get("_line_number", -1),
+        "source": "response_item.reasoning",
+    }
+
+
+def _json_text(value: Any) -> str:
+    """Render structured tool values deterministically for trace display."""
+    if isinstance(value, str):
+        return value
+    try:
+        return json.dumps(value, ensure_ascii=False)
+    except (TypeError, ValueError):
+        return str(value)
+
+
 def extract_message_content_text(payload: Dict[str, Any]) -> str:
     """Extract all text content from a message payload regardless of role."""
     parts = []
@@ -669,6 +711,10 @@ def _turn_timestamps(turn):
         dt = _parse_ts(item)
         if dt:
             values.append(dt)
+    for item in turn.get("model_records", []):
+        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))
@@ -758,6 +804,7 @@ def group_messages_into_turns(entries: List[Dict[str, Any]]) -> List[Dict[str, A
                     "user_message": None,
                     "user_message_text": "",
                     "assistant_messages": [],
+                    "model_records": [],
                     "tool_calls": [],
                     "tool_results": [],
                     "input_messages": [],
@@ -775,6 +822,17 @@ def group_messages_into_turns(entries: List[Dict[str, Any]]) -> List[Dict[str, A
                 if current_turn is not None:
                     info = payload.get("info") or {}
                     current_turn["token_usage"] = info.get("last_token_usage", {})
+            elif msg_type in ("agent_reasoning", "agent_message") and current_turn is not None:
+                text = payload.get("text") if msg_type == "agent_reasoning" else payload.get("message")
+                if isinstance(text, str) and text:
+                    current_turn["model_records"].append({
+                        "content": text if msg_type == "agent_message" else "",
+                        "reasoning": text if msg_type == "agent_reasoning" else "",
+                        "protected": {},
+                        "_ts": payload.get("_ts"),
+                        "_line_number": entry.get("_line_number", -1),
+                        "source": f"event_msg.{msg_type}",
+                    })
             continue
 
         # --- Content items ---
@@ -795,6 +853,14 @@ def group_messages_into_turns(entries: List[Dict[str, Any]]) -> List[Dict[str, A
                 elif role == "assistant":
                     if current_turn is not None:
                         current_turn["assistant_messages"].append(payload)
+                        current_turn["model_records"].append({
+                            "content": extract_assistant_text(payload),
+                            "reasoning": "",
+                            "protected": {},
+                            "_ts": payload.get("_ts"),
+                            "_line_number": entry.get("_line_number", -1),
+                            "source": "response_item.message",
+                        })
                 elif role in ("developer", "system"):
                     if current_turn is not None:
                         current_turn["input_messages"].append({
@@ -810,16 +876,25 @@ def group_messages_into_turns(entries: List[Dict[str, Any]]) -> List[Dict[str, A
                                 "content": text,
                             })
 
-            elif item_type == "function_call":
+            elif item_type == "reasoning":
+                if current_turn is not None:
+                    record = extract_reasoning_record(payload)
+                    record["_line_number"] = entry.get("_line_number", -1)
+                    current_turn["model_records"].append(record)
+
+            elif item_type in ("function_call", "custom_tool_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 item_type == "custom_tool_call":
+                    args = payload.get("input", "")
+                else:
+                    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 = {
@@ -846,11 +921,12 @@ def group_messages_into_turns(entries: List[Dict[str, Any]]) -> List[Dict[str, A
                         "call_id": call_id,
                         "name": name,
                         "input": args,
+                        "custom": item_type == "custom_tool_call",
                         "_ts": payload.get("_ts"),
                     })
                     pending_calls[call_id] = {"kind": "tool", "_start_ts": payload.get("_ts")}
 
-            elif item_type == "function_call_output":
+            elif item_type in ("function_call_output", "custom_tool_call_output"):
                 if current_turn is None:
                     continue
                 call_id = payload.get("call_id")
@@ -896,10 +972,35 @@ def group_messages_into_turns(entries: List[Dict[str, Any]]) -> List[Dict[str, A
     if current_turn is not None:
         turns.append(current_turn)
 
+    # Codex may duplicate visible commentary/reasoning in response_item and
+    # event_msg. Prefer response_item, then retain event-only fallbacks.
+    for turn in turns:
+        seen = set()
+        deduped = []
+        records = sorted(
+            turn.get("model_records", []),
+            key=lambda record: (
+                1 if str(record.get("source", "")).startswith("event_msg.") else 0,
+                record.get("_line_number", -1),
+            ),
+        )
+        for record in records:
+            category = "reasoning" if record.get("reasoning") else "content"
+            text = record.get(category, "").strip()
+            key = (category, text)
+            if text and key in seen:
+                continue
+            if text:
+                seen.add(key)
+            deduped.append(record)
+        turn["model_records"] = sorted(
+            deduped, key=lambda record: record.get("_line_number", -1)
+        )
+
     # 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"]
+        if t["user_message"] is not None or t["assistant_messages"] or t.get("model_records")
     ]
 
     return turns
@@ -1439,7 +1540,8 @@ def send_steps_realtime(turns, session_id, state, model_name="codex", coze_tags_
                 if turn.get("user_message_text"):
                     first_user_text = turn["user_message_text"]
                     break
-            root_start_dt = _parse_ts_value(turns[0].get("tool_calls", [{}])[0].get("_ts")) if turns and turns[0].get("tool_calls") else None
+            all_timestamps = [dt for turn in turns for dt in _turn_timestamps(turn)]
+            root_start_dt = min(all_timestamps) if all_timestamps else None
             root_span = client.start_span(name="codex_request", span_type="main",
                                           start_time=root_start_dt, start_new_trace=True)
             root_span.set_runtime(Runtime(library="codex-cli"))
@@ -1460,6 +1562,83 @@ def send_steps_realtime(turns, session_id, state, model_name="codex", coze_tags_
                 return None
             hook_log(f"[rt] root created trace_id={getattr(root_ctx,'trace_id','?')}")
 
+        # Model-visible records use their own line watermark. They are not
+        # coupled to tool completion because reasoning/commentary can occur in
+        # turns with no tools at all.
+        model_records = []
+        for turn in turns:
+            for record in turn.get("model_records", []):
+                model_records.append((turn, record))
+        model_records.sort(key=lambda item: item[1].get("_line_number", -1))
+        last_model_line = state.get("rt_last_model_line", -1)
+        model_sent = 0
+        max_model_line = last_model_line
+        for turn, record in model_records:
+            line = record.get("_line_number", -1)
+            if line <= last_model_line:
+                continue
+            content = record.get("content", "")
+            reasoning = record.get("reasoning", "")
+            protected = record.get("protected") or {}
+            if not content and not reasoning and not protected:
+                max_model_line = max(max_model_line, line)
+                continue
+            start_dt = _parse_ts_value(record.get("_ts"))
+            mspan = client.start_span(
+                name=f"model_content_{line}", span_type="model",
+                start_time=start_dt, child_of=root_ctx,
+            )
+            mspan.set_runtime(Runtime(library="codex-cli"))
+            try:
+                mspan.set_model_name(model_name)
+            except Exception:
+                pass
+            if turn.get("user_message_text"):
+                mspan.set_input(ModelInput(
+                    messages=[_make_model_message("user", turn["user_message_text"])],
+                    tools=[],
+                    tool_choice=ModelToolChoice(type="", function=None),
+                ))
+            choice = ModelChoice(
+                finish_reason="stop",
+                index=0,
+                message=ModelMessage(
+                    role="assistant",
+                    content=content,
+                    reasoning_content=reasoning,
+                    parts=[],
+                    name="",
+                    tool_calls=[],
+                    tool_call_id="",
+                    metadata={},
+                ),
+            )
+            mspan.set_output(ModelOutput(choices=[choice]))
+            tags = {
+                "model_record_line": line,
+                "model_record_source": record.get("source", "unknown"),
+            }
+            if protected:
+                tags.update({
+                    "protected_reasoning_source": protected.get("source", ""),
+                    "protected_reasoning_count": protected.get("count", 0),
+                    "protected_reasoning_bytes": protected.get("bytes", 0),
+                })
+            mspan.set_tags(tags)
+            if start_dt is not None:
+                _set_finish_time_safe(mspan, start_dt)
+            mspan.finish()
+            client.flush()
+            if upload_events:
+                hook_log(f"[rt] upload failed after model flush line={line} detail={upload_events[-1][:500]}")
+                if max_model_line > last_model_line:
+                    state["rt_last_model_line"] = max_model_line
+                return None
+            max_model_line = line
+            model_sent += 1
+        if max_model_line > last_model_line:
+            state["rt_last_model_line"] = max_model_line
+
         # 线性展开所有 tool_call（带 result 的才算完成），按全局序增量发
         flat = []
         for ti, turn in enumerate(turns):
@@ -1496,7 +1675,7 @@ def send_steps_realtime(turns, session_id, state, model_name="codex", coze_tags_
             except Exception: pass
             if start_dt and end_dt:
                 _set_finish_time_safe(mspan, end_dt)
-            mspan.set_input(truncate_text(json.dumps(tc.get("input", {}), ensure_ascii=False)))
+            mspan.set_input(truncate_text(_json_text(tc.get("input", {}))))
             mspan_ctx = client.get_span_from_header(mspan.to_header())
             mspan.finish()
 
@@ -1506,9 +1685,9 @@ def send_steps_realtime(turns, session_id, state, model_name="codex", coze_tags_
             if end_dt:
                 _set_finish_time_safe(tspan, end_dt)
             tspan.set_tags({"tool_name": tname, "tool_call_id": tc.get("call_id"), "step_index": gidx})
-            tspan.set_input(truncate_text(json.dumps(tc.get("input", {}), ensure_ascii=False)))
+            tspan.set_input(truncate_text(_json_text(tc.get("input", {}))))
             if result is not None:
-                tspan.set_output(truncate_text(str(result.get("output", ""))))
+                tspan.set_output(truncate_text(_json_text(result.get("output", ""))))
             tspan.finish()
             sent += 1
             client.flush()  # 每个 tool_call 立即 flush → 结束即可见
@@ -1601,7 +1780,7 @@ def send_steps_realtime(turns, session_id, state, model_name="codex", coze_tags_
             hook_log(f"[rt] upload failed state not advanced detail={upload_events[-1][:500]}")
             return None
 
-        hook_log(f"[rt] sent {sent} tool span(s), {token_sent} token span(s), last_tool={state['rt_last_tool']}, last_token_line={state.get('rt_last_token_line', -1)}, terminal={is_terminal}")
+        hook_log(f"[rt] sent {model_sent} model span(s), {sent} tool span(s), {token_sent} token span(s), last_model_line={state.get('rt_last_model_line', -1)}, last_tool={state['rt_last_tool']}, last_token_line={state.get('rt_last_token_line', -1)}, terminal={is_terminal}")
         return True
     except Exception as e:
         hook_log(f"[rt] error: {e}")