oh-langfuse 0.1.59 → 0.1.61

package/codex_langfuse_notify.py

@@ -13,42 +13,42 @@ import re
 import sys
 import time
 import hashlib
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple
-from urllib.parse import urlparse
-
-
-def codex_langfuse_config_path() -> Path:
-    codex_dir = Path(os.environ.get("CODEX_HOME") or (Path.home() / ".codex"))
-    return codex_dir / "langfuse" / "config.json"
-
-
-def read_langfuse_base_url_from_config() -> Optional[str]:
-    try:
-        path = codex_langfuse_config_path()
-        if not path.exists():
-            return None
-        data = json.loads(path.read_text(encoding="utf-8-sig"))
-        if isinstance(data, dict):
-            value = data.get("baseUrl") or data.get("host")
-            if isinstance(value, str) and value.strip():
-                return value.strip()
-    except Exception:
-        return None
-    return None
-
-
-def configure_langfuse_no_proxy() -> None:
-    hosts = ["localhost", "127.0.0.1"]
-    values = [
-        *(os.environ.get(key) for key in ("LANGFUSE_HOST", "LANGFUSE_BASEURL", "CODEX_LANGFUSE_BASE_URL")),
-        read_langfuse_base_url_from_config(),
-    ]
-    for value in values:
-        if not value:
-            continue
+from urllib.parse import urlparse
+
+
+def codex_langfuse_config_path() -> Path:
+    codex_dir = Path(os.environ.get("CODEX_HOME") or (Path.home() / ".codex"))
+    return codex_dir / "langfuse" / "config.json"
+
+
+def read_langfuse_base_url_from_config() -> Optional[str]:
+    try:
+        path = codex_langfuse_config_path()
+        if not path.exists():
+            return None
+        data = json.loads(path.read_text(encoding="utf-8-sig"))
+        if isinstance(data, dict):
+            value = data.get("baseUrl") or data.get("host")
+            if isinstance(value, str) and value.strip():
+                return value.strip()
+    except Exception:
+        return None
+    return None
+
+
+def configure_langfuse_no_proxy() -> None:
+    hosts = ["localhost", "127.0.0.1"]
+    values = [
+        *(os.environ.get(key) for key in ("LANGFUSE_HOST", "LANGFUSE_BASEURL", "CODEX_LANGFUSE_BASE_URL")),
+        read_langfuse_base_url_from_config(),
+    ]
+    for value in values:
+        if not value:
+            continue
         parsed = urlparse(value if "://" in value else f"http://{value}")
         if parsed.hostname:
             hosts.append(parsed.hostname)
@@ -85,8 +85,8 @@ LOG_FILE = STATE_DIR / "codex_langfuse_notify.log"
 DEBUG = os.environ.get("CODEX_LANGFUSE_DEBUG", "").lower() == "true"
 MAX_CHARS = int(os.environ.get("CODEX_LANGFUSE_MAX_CHARS", "20000"))
 METRICS_SCHEMA_VERSION = "1.1"
-AGENT_NAME = "codex"
-AGENT_TURN_NAME = "Codex Agent Turn"
+AGENT_NAME = "codex"
+AGENT_TURN_NAME = "Codex Agent Turn"
 
 
 def log(level: str, message: str) -> None:
@@ -147,6 +147,53 @@ class SessionState:
     offset: int = 0
     buffer: str = ""
     turn_count: int = 0
+    uploaded_turn_ids: set = field(default_factory=set)
+    uploaded_turn_fallback_keys: set = field(default_factory=set)
+
+
+@dataclass
+class CodexToolCall:
+    id: str
+    name: str
+    input: Any = None
+    output: Any = None
+    start_time: Optional[str] = None
+    end_time: Optional[str] = None
+    status: Optional[str] = None
+    error: Optional[str] = None
+
+
+@dataclass
+class CodexStep:
+    start_time: Optional[str] = None
+    end_time: Optional[str] = None
+    assistant_text: str = ""
+    reasoning: str = ""
+    usage: Dict[str, Any] = field(default_factory=dict)
+    tool_calls: List[CodexToolCall] = field(default_factory=list)
+
+
+@dataclass
+class CodexTurn:
+    turn_id: Optional[str] = None
+    start_time: Optional[str] = None
+    end_time: Optional[str] = None
+    completed: bool = False
+    aborted: bool = False
+    user_text: str = ""
+    user_text_fallback: str = ""
+    final_output: str = ""
+    model: Optional[str] = None
+    invocation_params: Dict[str, Any] = field(default_factory=dict)
+    steps: List[CodexStep] = field(default_factory=list)
+    total_usage: Dict[str, Any] = field(default_factory=dict)
+    subagent_thread_ids: List[str] = field(default_factory=list)
+
+
+@dataclass
+class CodexParsedSession:
+    session_meta: Dict[str, Any]
+    turns: List[CodexTurn]
 
 
 def read_json_if_exists(path: Path) -> Dict[str, Any]:
@@ -277,6 +324,8 @@ def load_session_state(state: Dict[str, Any], key: str) -> SessionState:
         offset=int(raw.get("offset", 0) or 0),
         buffer=str(raw.get("buffer", "") or ""),
         turn_count=int(raw.get("turn_count", 0) or 0),
+        uploaded_turn_ids={str(item) for item in raw.get("uploaded_turn_ids", []) if item},
+        uploaded_turn_fallback_keys={str(item) for item in raw.get("uploaded_turn_fallback_keys", []) if item},
     )
 
 
@@ -285,10 +334,31 @@ def save_session_state(state: Dict[str, Any], key: str, ss: SessionState) -> Non
         "offset": ss.offset,
         "buffer": ss.buffer,
         "turn_count": ss.turn_count,
+        "uploaded_turn_ids": sorted(ss.uploaded_turn_ids),
+        "uploaded_turn_fallback_keys": sorted(ss.uploaded_turn_fallback_keys),
         "updated": datetime.now(timezone.utc).isoformat(),
     }
 
 
+def read_all_jsonl(path: Path) -> List[Dict[str, Any]]:
+    out: List[Dict[str, Any]] = []
+    try:
+        with open(path, "r", encoding="utf-8", errors="replace") as f:
+            for line in f:
+                raw = line.strip()
+                if not raw:
+                    continue
+                try:
+                    item = json.loads(raw)
+                    if isinstance(item, dict):
+                        out.append(item)
+                except Exception as e:
+                    debug(f"jsonl row parse failed: {e}")
+    except Exception as e:
+        debug(f"read_all_jsonl failed: {e}")
+    return out
+
+
 def read_new_jsonl(path: Path, ss: SessionState) -> Tuple[List[Dict[str, Any]], SessionState]:
     out: List[Dict[str, Any]] = []
     try:
@@ -717,6 +787,27 @@ def summarize_skill_usages(skill_usages: List[Dict[str, str]]) -> List[Dict[str,
     return list(summary.values())
 
 
+def is_codex_wrapper_text(text: str) -> bool:
+    stripped = (text or "").strip()
+    return stripped.startswith("<environment_context") or stripped.startswith("<user_instructions")
+
+
+def append_text(existing: str, text: str) -> str:
+    text = text or ""
+    if not text:
+        return existing or ""
+    return f"{existing}\n{text}" if existing else text
+
+
+def parse_tool_input(value: Any) -> Any:
+    if isinstance(value, str):
+        try:
+            return json.loads(value)
+        except Exception:
+            return value
+    return value
+
+
 def get_payload(row: Dict[str, Any]) -> Dict[str, Any]:
     payload = row.get("payload")
     return payload if isinstance(payload, dict) else {}
@@ -748,6 +839,183 @@ def extract_usage(rows: List[Dict[str, Any]]) -> Dict[str, Any]:
     return usage
 
 
+def parse_codex_session(rows: List[Dict[str, Any]]) -> CodexParsedSession:
+    session_meta: Dict[str, Any] = {"session_path": ""}
+    turns: List[CodexTurn] = []
+    turn: Optional[CodexTurn] = None
+    step: Optional[CodexStep] = None
+    tool_calls_by_id: Dict[str, CodexToolCall] = {}
+    last_ts: Optional[str] = None
+
+    def ensure_turn(ts: Optional[str]) -> CodexTurn:
+        nonlocal turn
+        if turn is None:
+            turn = CodexTurn(start_time=ts, end_time=ts)
+        return turn
+
+    def ensure_step(ts: Optional[str]) -> CodexStep:
+        nonlocal step
+        if step is None:
+            step = CodexStep(start_time=ts, end_time=ts)
+        return step
+
+    def close_step(ts: Optional[str], usage: Optional[Dict[str, Any]] = None) -> None:
+        nonlocal step
+        if step is None or turn is None:
+            return
+        step.end_time = ts or step.end_time
+        if isinstance(usage, dict):
+            step.usage = usage
+        turn.steps.append(step)
+        step = None
+
+    def finish_turn(ts: Optional[str], completed: bool, aborted: bool) -> None:
+        nonlocal turn, step, tool_calls_by_id
+        if turn is None:
+            return
+        close_step(ts)
+        turn.end_time = ts or turn.end_time
+        turn.completed = completed
+        turn.aborted = aborted
+        if not turn.user_text:
+            turn.user_text = turn.user_text_fallback
+        if not turn.final_output:
+            for candidate in reversed(turn.steps):
+                if candidate.assistant_text:
+                    turn.final_output = candidate.assistant_text
+                    break
+        turns.append(turn)
+        turn = None
+        step = None
+        tool_calls_by_id = {}
+
+    for row in rows:
+        ts = str(row.get("timestamp") or last_ts or "")
+        last_ts = ts
+        row_type = row.get("type")
+        payload = get_payload(row)
+
+        if row_type == "session_meta":
+            session_meta.update(payload)
+            continue
+
+        if row_type == "turn_context":
+            t = ensure_turn(ts)
+            model = payload.get("model")
+            if isinstance(model, str) and model.strip():
+                t.model = model.strip()
+            if isinstance(payload, dict):
+                t.invocation_params = dict(payload)
+            continue
+
+        if row_type == "response_item":
+            item_type = payload.get("type")
+            t = ensure_turn(ts)
+            if item_type == "message":
+                role = payload.get("role")
+                text = extract_text(payload.get("content"))
+                if role == "assistant" and text:
+                    s = ensure_step(ts)
+                    s.assistant_text = append_text(s.assistant_text, text)
+                elif role == "user" and text and not is_codex_wrapper_text(text) and not t.user_text_fallback:
+                    t.user_text_fallback = text
+            elif item_type == "reasoning":
+                text = extract_text(payload.get("content") or payload.get("summary"))
+                if text:
+                    s = ensure_step(ts)
+                    s.reasoning = append_text(s.reasoning, text)
+            elif item_type in ("function_call", "custom_tool_call"):
+                call_id = first_string(str(payload.get("call_id") or ""), str(payload.get("id") or "")) or ""
+                call = CodexToolCall(
+                    id=call_id,
+                    name=first_string(str(payload.get("name") or "")) or "tool",
+                    input=parse_tool_input(payload.get("arguments") if item_type == "function_call" else payload.get("input")),
+                    start_time=ts,
+                )
+                ensure_step(ts).tool_calls.append(call)
+                if call_id:
+                    tool_calls_by_id[call_id] = call
+            elif item_type in ("function_call_output", "custom_tool_call_output"):
+                call_id = str(payload.get("call_id") or "")
+                call = tool_calls_by_id.get(call_id)
+                if call:
+                    call.output = payload.get("output")
+                    call.end_time = ts
+            continue
+
+        if row_type != "event_msg":
+            continue
+
+        event_type = payload.get("type")
+        if event_type == "task_started":
+            if turn is not None:
+                finish_turn(ts, completed=False, aborted=False)
+            turn = CodexTurn(
+                turn_id=first_string(str(payload.get("turn_id") or "")),
+                start_time=ts,
+                end_time=ts,
+            )
+            step = None
+            tool_calls_by_id = {}
+            continue
+
+        t = ensure_turn(ts)
+        if event_type == "user_message" and isinstance(payload.get("message"), str):
+            if not t.user_text:
+                t.user_text = payload["message"]
+        elif event_type == "agent_message" and isinstance(payload.get("message"), str):
+            t.final_output = payload["message"]
+        elif event_type == "token_count":
+            info = payload.get("info")
+            if isinstance(info, dict):
+                total = info.get("total_token_usage")
+                if isinstance(total, dict):
+                    t.total_usage = total
+                last = info.get("last_token_usage")
+                close_step(ts, last if isinstance(last, dict) else None)
+        elif event_type == "task_complete":
+            finish_turn(ts, completed=True, aborted=False)
+        elif event_type == "turn_aborted":
+            finish_turn(ts, completed=True, aborted=True)
+        else:
+            if event_type == "collab_agent_spawn_end" and isinstance(payload.get("new_thread_id"), str):
+                t.subagent_thread_ids.append(payload["new_thread_id"])
+            call_id = payload.get("call_id")
+            if isinstance(call_id, str) and isinstance(event_type, str) and event_type.endswith("_end"):
+                call = tool_calls_by_id.get(call_id)
+                if call:
+                    call.end_time = ts
+                    if isinstance(payload.get("status"), str):
+                        call.status = payload["status"]
+                    if payload.get("status") in ("failed", "declined"):
+                        call.error = first_string(
+                            str(payload.get("stderr") or ""),
+                            str(payload.get("error") or ""),
+                            str(payload.get("message") or ""),
+                        )
+                    if call.output is None:
+                        call.output = {
+                            "stdout": payload.get("stdout"),
+                            "stderr": payload.get("stderr"),
+                            "success": payload.get("success"),
+                            "status": payload.get("status"),
+                            "aggregated_output": payload.get("aggregated_output"),
+                        }
+                    elif isinstance(call.output, str) and payload.get("stdout") is not None:
+                        call.output = {
+                            "stdout": payload.get("stdout"),
+                            "stderr": payload.get("stderr"),
+                            "success": payload.get("success"),
+                            "status": payload.get("status"),
+                            "aggregated_output": payload.get("aggregated_output"),
+                        }
+
+    if turn is not None:
+        finish_turn(last_ts, completed=False, aborted=False)
+
+    return CodexParsedSession(session_meta=session_meta, turns=turns)
+
+
 def usage_details_from_codex(usage: Dict[str, Any]) -> Dict[str, int]:
     raw = usage.get("last_token_usage")
     if not isinstance(raw, dict):
@@ -825,6 +1093,77 @@ def collect_turn_material(rows: List[Dict[str, Any]]) -> Dict[str, Any]:
     }
 
 
+def codex_turn_usage_details(turn: CodexTurn) -> Dict[str, int]:
+    for step in reversed(turn.steps):
+        details = usage_details_from_codex({"last_token_usage": step.usage})
+        if details:
+            return details
+    return {}
+
+
+def codex_turn_material(turn: CodexTurn) -> Dict[str, Any]:
+    tool_calls: List[Dict[str, Any]] = []
+    tool_results: List[Dict[str, Any]] = []
+    skill_sources: List[Any] = [turn.invocation_params]
+    for step in turn.steps:
+        skill_sources.append(step.reasoning)
+        for call in step.tool_calls:
+            tool_calls.append({"id": call.id, "name": call.name, "input": call.input})
+            tool_results.append({
+                "id": call.id,
+                "name": call.name,
+                "output": call.output,
+                "status": call.status,
+                "error": call.error,
+                "start_time": call.start_time,
+                "end_time": call.end_time,
+            })
+            skill_sources.append({"name": call.name, "input": call.input, "output": call.output})
+    return {
+        "user_text": turn.user_text,
+        "assistant_text": turn.final_output or "\n\n".join(step.assistant_text for step in turn.steps if step.assistant_text),
+        "tool_calls": tool_calls,
+        "tool_results": tool_results,
+        "skill_detection_sources": skill_sources,
+    }
+
+
+def codex_turn_upload_key(session_path: Path, turn: CodexTurn, index: int) -> Tuple[str, str]:
+    if turn.turn_id:
+        return "turn_id", str(turn.turn_id)
+    seed = {
+        "session_path": str(session_path),
+        "index": index,
+        "start_time": turn.start_time,
+        "end_time": turn.end_time,
+        "user_text": turn.user_text,
+        "final_output": turn.final_output,
+        "aborted": turn.aborted,
+    }
+    digest = hashlib.sha256(json.dumps(seed, ensure_ascii=False, sort_keys=True).encode("utf-8")).hexdigest()
+    return "fallback", digest
+
+
+def should_upload_codex_turn(ss: SessionState, session_path: Path, turn: CodexTurn, index: int) -> bool:
+    if not (turn.completed or turn.aborted):
+        return False
+    material = codex_turn_material(turn)
+    if not material.get("assistant_text") and not material.get("tool_calls") and not material.get("tool_results"):
+        return False
+    kind, value = codex_turn_upload_key(session_path, turn, index)
+    if kind == "turn_id":
+        return value not in ss.uploaded_turn_ids
+    return value not in ss.uploaded_turn_fallback_keys
+
+
+def mark_codex_turn_uploaded(ss: SessionState, session_path: Path, turn: CodexTurn, index: int) -> None:
+    kind, value = codex_turn_upload_key(session_path, turn, index)
+    if kind == "turn_id":
+        ss.uploaded_turn_ids.add(value)
+    else:
+        ss.uploaded_turn_fallback_keys.add(value)
+
+
 def emit_codex_turn(
     langfuse: Langfuse,
     session_id: str,
@@ -832,13 +1171,13 @@ def emit_codex_turn(
     turn_num: int,
     session_path: Path,
     meta: Dict[str, Any],
-    material: Dict[str, Any],
-    usage: Dict[str, Any],
+    turn: CodexTurn,
 ) -> None:
+    material = codex_turn_material(turn)
     user_text, user_meta = truncate(material.get("user_text") or "")
     assistant_text, assistant_meta = truncate(material.get("assistant_text") or "")
-    usage_details = usage_details_from_codex(usage)
-    model = first_string(meta.get("model"), meta.get("model_provider")) or "codex"
+    usage_details = codex_turn_usage_details(turn)
+    model = first_string(turn.model, meta.get("model"), meta.get("model_provider")) or "codex"
     tool_calls = material.get("tool_calls") or []
     tool_results = material.get("tool_results") or []
     skill_usages = detect_turn_skill_usages(material, discover_known_skills())
@@ -863,11 +1202,11 @@ def emit_codex_turn(
     with propagate_attributes(
         user_id=user_id,
         session_id=session_id,
-        trace_name=AGENT_TURN_NAME,
-        tags=[AGENT_NAME],
-    ):
-        with langfuse.start_as_current_observation(
-            name=AGENT_TURN_NAME,
+        trace_name=AGENT_TURN_NAME,
+        tags=[AGENT_NAME],
+    ):
+        with langfuse.start_as_current_observation(
+            name=AGENT_TURN_NAME,
             input={"role": "user", "content": user_text},
             output={"role": "assistant", "content": assistant_text},
             metadata={
@@ -881,8 +1220,13 @@ def emit_codex_turn(
                 "originator": meta.get("originator"),
                 "cli_version": meta.get("cli_version"),
                 "user_text": user_meta,
-                "usage": usage,
+                "usage": {"last_token_usage": usage_details},
                 "skills": skill_summary,
+                "codex_turn_id": turn.turn_id or "",
+                "completed": turn.completed,
+                "aborted": turn.aborted,
+                "subagent_thread_ids": turn.subagent_thread_ids,
+                "step_count": len(turn.steps),
             },
         ) as trace_span:
             with langfuse.start_as_current_observation(
@@ -940,6 +1284,10 @@ def emit_codex_turn(
                         "tool_name": result.get("name"),
                         "turn_number": turn_num,
                         "output_meta": output_meta,
+                        "status": result.get("status"),
+                        "error": result.get("error"),
+                        "start_time": result.get("start_time"),
+                        "end_time": result.get("end_time"),
                         "metrics_schema_version": METRICS_SCHEMA_VERSION,
                     },
                 ) as tool_obs:
@@ -1000,28 +1348,46 @@ def main() -> int:
             state = read_json_if_exists(STATE_FILE)
             key = session_key(session_path)
             ss = load_session_state(state, key)
-            rows, ss = read_new_jsonl(session_path, ss)
+            rows = read_all_jsonl(session_path)
             if not rows:
+                try:
+                    ss.offset = session_path.stat().st_size
+                    ss.buffer = ""
+                except Exception:
+                    pass
                 save_session_state(state, key, ss)
                 write_json_atomic(STATE_FILE, state)
                 return 0
 
-            material = collect_turn_material(rows)
-            if not material.get("assistant_text") and not material.get("tool_calls") and not material.get("tool_results"):
+            try:
+                ss.offset = session_path.stat().st_size
+                ss.buffer = ""
+            except Exception:
+                pass
+
+            parsed = parse_codex_session(rows)
+            if not parsed.turns:
                 save_session_state(state, key, ss)
                 write_json_atomic(STATE_FILE, state)
                 return 0
 
             meta = get_session_meta(rows, session_path)
+            meta.update({k: v for k, v in parsed.session_meta.items() if v not in (None, "")})
+            meta.setdefault("session_path", str(session_path))
             session_id = first_string(str(meta.get("id")) if meta.get("id") else "", session_path.stem) or session_path.stem
-            usage = extract_usage(rows)
-            turn_num = ss.turn_count + 1
+            uploaded = 0
 
-            try:
-                emit_codex_turn(langfuse, session_id, user_id, turn_num, session_path, meta, material, usage)
-                ss.turn_count = turn_num
-            except Exception as e:
-                debug(f"emit_codex_turn failed: {e}")
+            for index, turn in enumerate(parsed.turns, start=1):
+                if not should_upload_codex_turn(ss, session_path, turn, index):
+                    continue
+                turn_num = ss.turn_count + 1
+                try:
+                    emit_codex_turn(langfuse, session_id, user_id, turn_num, session_path, meta, turn)
+                    mark_codex_turn_uploaded(ss, session_path, turn, index)
+                    ss.turn_count = turn_num
+                    uploaded += 1
+                except Exception as e:
+                    debug(f"emit_codex_turn failed: {e}")
 
             save_session_state(state, key, ss)
             write_json_atomic(STATE_FILE, state)
@@ -1030,7 +1396,7 @@ def main() -> int:
             langfuse.flush()
         except Exception:
             pass
-        log("INFO", f"Processed Codex turn {ss.turn_count} for {session_path}")
+        log("INFO", f"Processed {uploaded} Codex turn(s), total {ss.turn_count} for {session_path}")
         return 0
     except Exception as e:
         debug(f"unexpected failure: {e}")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-langfuse",
-  "version": "0.1.59",
+  "version": "0.1.61",
   "private": false,
   "type": "module",
   "description": "Use npm scripts to configure Claude Code / OpenCode / Codex with Langfuse tracing.",
@@ -27,11 +27,11 @@
     "scripts/log-filter-utils.mjs",
     "scripts/metrics-utils.mjs",
     "scripts/runtime-state-utils.mjs",
-    "scripts/update-langfuse-runtime.mjs",
-    "scripts/update-utils.mjs",
-    "scripts/verify-update-runtime.mjs",
-    "scripts/verify-update-utils.mjs",
-    "langfuse_hook.py",
+    "scripts/update-langfuse-runtime.mjs",
+    "scripts/update-utils.mjs",
+    "scripts/verify-update-runtime.mjs",
+    "scripts/verify-update-utils.mjs",
+    "langfuse_hook.py",
     "codex_langfuse_notify.py",
     "README.md",
     "SELF_VERIFY.md",