oh-langfuse 0.1.41 → 0.1.43

package/langfuse_hook.py

@@ -10,12 +10,40 @@ import re
 import sys
 import time
 import hashlib
-from dataclasses import dataclass
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple
-
-# --- Langfuse import (fail-open) ---
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+from urllib.parse import urlparse
+
+
+def configure_langfuse_no_proxy() -> None:
+    hosts = ["localhost", "127.0.0.1"]
+    for key in ("LANGFUSE_HOST", "LANGFUSE_BASEURL", "CC_LANGFUSE_BASE_URL"):
+        value = os.environ.get(key)
+        if not value:
+            continue
+        parsed = urlparse(value if "://" in value else f"http://{value}")
+        if parsed.hostname:
+            hosts.append(parsed.hostname)
+        if parsed.netloc:
+            hosts.append(parsed.netloc)
+    existing = []
+    for key in ("NO_PROXY", "no_proxy"):
+        existing.extend([item.strip() for item in os.environ.get(key, "").split(",") if item.strip()])
+    merged = []
+    for item in [*existing, *hosts]:
+        if item and item not in merged:
+            merged.append(item)
+    if merged:
+        value = ",".join(merged)
+        os.environ["NO_PROXY"] = value
+        os.environ["no_proxy"] = value
+
+
+configure_langfuse_no_proxy()
+
+# --- Langfuse import (fail-open) ---
 try:
     from langfuse import Langfuse, propagate_attributes
 except Exception as e:
@@ -37,7 +65,8 @@ LOCK_FILE = STATE_DIR / "langfuse_state.lock"
 
 DEBUG = os.environ.get("CC_LANGFUSE_DEBUG", "").lower() == "true"
 MAX_CHARS = int(os.environ.get("CC_LANGFUSE_MAX_CHARS", "20000"))
-METRICS_SCHEMA_VERSION = "1.0"
+METRICS_SCHEMA_VERSION = "1.1"
+AGENT_NAME = "claude"
 
 # ----------------- Logging -----------------
 def _log(level: str, message: str) -> None:
@@ -318,11 +347,17 @@ def build_interaction_metadata(
     model: Optional[str],
     user_message_count: int = 1,
     assistant_message_count: int = 1,
+    skill_use_events: Optional[List[Dict[str, Any]]] = None,
 ) -> Dict[str, Any]:
     tokens = normalize_token_metrics(token_metrics)
     interaction_id = build_interaction_id(source, session_id, turn_number)
+    events = list(skill_use_events or [])
+    skill_names_all = [str(event.get("skill_name") or "") for event in events if event.get("skill_name")]
+    unique_skill_names = list(dict.fromkeys(skill_names_all))
+    effective_skill_count = len(events) if events else int(skill_use_count or 0)
     return {
         "source": source,
+        "agent": source,
         "user_id": user_id or "",
         "session_id": session_id,
         "interaction_id": interaction_id,
@@ -332,17 +367,23 @@ def build_interaction_metadata(
         "assistant_message_count": assistant_message_count,
         "tool_call_count": int(tool_call_count or 0),
         "tool_result_count": int(tool_result_count or 0),
-        "skill_use_count": int(skill_use_count or 0),
+        "skill_use_count": effective_skill_count,
+        "unique_skill_count": len(unique_skill_names),
+        "repeated_skill_count": max(0, effective_skill_count - len(unique_skill_names)),
         **tokens,
         "model": model,
         "turn_number": int(turn_number or 0),
         "efficiency": {
             "tokens_per_interaction": tokens.get("total_tokens"),
             "tool_calls_per_interaction": int(tool_call_count or 0),
-            "skills_per_interaction": int(skill_use_count or 0),
+            "skills_per_interaction": effective_skill_count,
             "output_input_token_ratio": _ratio(tokens.get("output_tokens"), tokens.get("input_tokens")),
             "tokens_per_tool_call": _ratio(tokens.get("total_tokens"), int(tool_call_count or 0)),
         },
+        **({
+            "skill_names": unique_skill_names,
+            "skill_names_all": skill_names_all,
+        } if events else {}),
     }
 
 def discover_known_skills(extra_roots: Optional[List[Path]] = None) -> set:
@@ -367,16 +408,31 @@ def discover_known_skills(extra_roots: Optional[List[Path]] = None) -> set:
 def _skill_namespace(name: str) -> str:
     return name.split(":", 1)[0] if ":" in name else ""
 
+def _skill_event_type(detected_by: str) -> str:
+    return "invoked" if detected_by in ("tool_call", "plugin_event", "attribution_skill", "slash_command") else "detected"
+
+def _skill_id_segment(name: str) -> str:
+    segment = re.sub(r"[^A-Za-z0-9_.:-]+", "-", str(name or "").strip()).strip("-")
+    return (segment or "unknown")[:96]
+
 def detect_skill_usages(tool_calls: List[Dict[str, Any]], known_skills: set) -> List[Dict[str, str]]:
-    found: Dict[str, str] = {}
+    found: List[Dict[str, str]] = []
+    seen_call_ids: set = set()
     for call in tool_calls or []:
         tool_name = str(call.get("name") or "")
+        call_id = str(call.get("id") or call.get("call_id") or call.get("callId") or call.get("tool_call_id") or call.get("toolCallId") or "").strip()
         input_obj = call.get("input") if isinstance(call.get("input"), (dict, list, str)) else {}
         if tool_name.lower() == "skill" and isinstance(input_obj, dict):
             for key in ("skill_name", "skill", "name"):
                 value = input_obj.get(key)
                 if isinstance(value, str) and value.strip():
-                    found[value.strip()] = "tool_call"
+                    name = value.strip()
+                    if call_id:
+                        dedupe_key = f"call:{call_id}"
+                        if dedupe_key in seen_call_ids:
+                            break
+                        seen_call_ids.add(dedupe_key)
+                    found.append({"name": name, "skill_namespace": _skill_namespace(name), "detected_by": "tool_call", "skill_call_id": call_id})
                     break
         try:
             text = json.dumps(input_obj, ensure_ascii=False)
@@ -385,11 +441,143 @@ def detect_skill_usages(tool_calls: List[Dict[str, Any]], known_skills: set) ->
         for match in re.finditer(r"([A-Za-z]:)?[^\"'\n\r]*[\\/]+([^\\/\"'\n\r]+)[\\/]+SKILL\.md", text, re.IGNORECASE):
             candidate = match.group(2)
             if candidate and (candidate in known_skills or not known_skills):
-                found[candidate] = "skill_file_path"
-    return [
-        {"name": name, "skill_namespace": _skill_namespace(name), "detected_by": detected_by}
-        for name, detected_by in sorted(found.items())
-    ]
+                found.append({"name": candidate, "skill_namespace": _skill_namespace(candidate), "detected_by": "skill_file_path"})
+    return found
+
+def _skill_usage(name: str, detected_by: str, skill_call_id: str = "") -> Dict[str, str]:
+    clean = str(name or "").strip().lstrip("/")
+    return {
+        "name": clean,
+        "skill_namespace": _skill_namespace(clean),
+        "detected_by": detected_by,
+        "skill_call_id": str(skill_call_id or "").strip(),
+    }
+
+def _accept_skill_candidate(name: Any, known_skills: set, trusted: bool = False) -> str:
+    clean = str(name or "").strip().lstrip("/")
+    if not clean:
+        return ""
+    if trusted or not known_skills or clean in known_skills:
+        return clean
+    return ""
+
+def _detect_skill_usages_from_text(text: str, known_skills: set) -> List[Dict[str, str]]:
+    found: List[Dict[str, str]] = []
+    if not text:
+        return found
+
+    for pattern in (
+        r"<command-name>\s*/?([^<\s]+)\s*</command-name>",
+        r"<command-message>\s*/?([^<\s]+)\s*</command-message>",
+    ):
+        for match in re.finditer(pattern, text, re.IGNORECASE):
+            name = _accept_skill_candidate(match.group(1), known_skills)
+            if name:
+                found.append(_skill_usage(name, "slash_command"))
+
+    for match in re.finditer(r"Base directory for this skill:\s*([^\r\n]+)", text, re.IGNORECASE):
+        path_text = match.group(1)
+        path_match = re.search(r"[\\/](?:skills|skill)[\\/]([^\\/\"\r\n]+)", path_text, re.IGNORECASE)
+        if path_match:
+            name = _accept_skill_candidate(path_match.group(1), known_skills)
+            if name:
+                found.append(_skill_usage(name, "skill_file_path"))
+
+    return found
+
+def _attribution_skill_from_row(row: Dict[str, Any]) -> str:
+    if not isinstance(row, dict):
+        return ""
+    value = row.get("attributionSkill") or row.get("attribution_skill")
+    if isinstance(value, str) and value.strip():
+        return value.strip()
+    message = row.get("message")
+    if isinstance(message, dict):
+        value = message.get("attributionSkill") or message.get("attribution_skill")
+        if isinstance(value, str) and value.strip():
+            return value.strip()
+    return ""
+
+def _dedupe_turn_skill_usages(usages: List[Dict[str, str]]) -> List[Dict[str, str]]:
+    out: List[Dict[str, str]] = []
+    seen_call_ids: set = set()
+    seen_detected_names: set = set()
+    for usage in usages or []:
+        name = str(usage.get("name") or "").strip()
+        if not name:
+            continue
+        call_id = str(usage.get("skill_call_id") or "").strip()
+        if call_id:
+            key = f"call:{call_id}"
+            if key in seen_call_ids:
+                continue
+            seen_call_ids.add(key)
+            out.append(usage)
+            continue
+
+        detected_by = str(usage.get("detected_by") or "")
+        if detected_by in ("attribution_skill", "slash_command", "skill_file_path"):
+            key = f"name:{name}"
+            if key in seen_detected_names:
+                continue
+            seen_detected_names.add(key)
+        out.append(usage)
+    return out
+
+def detect_turn_skill_usages(turn: "Turn", tool_calls: List[Dict[str, Any]], known_skills: set) -> List[Dict[str, str]]:
+    found = list(detect_skill_usages(tool_calls, known_skills))
+    rows = [turn.user_msg, *turn.assistant_msgs]
+
+    for row in rows:
+        attributed = _accept_skill_candidate(_attribution_skill_from_row(row), known_skills, trusted=True)
+        if attributed:
+            found.append(_skill_usage(attributed, "attribution_skill"))
+        found.extend(_detect_skill_usages_from_text(extract_text(get_content(row)), known_skills))
+
+    return _dedupe_turn_skill_usages(found)
+
+def build_skill_use_events(interaction_id: str, skill_usages: List[Dict[str, str]]) -> List[Dict[str, Any]]:
+    events: List[Dict[str, Any]] = []
+    deduped: List[Dict[str, str]] = []
+    seen_call_ids: set = set()
+    for skill in skill_usages or []:
+        call_id = str(skill.get("skill_call_id") or "").strip()
+        if call_id:
+            dedupe_key = f"call:{call_id}"
+            if dedupe_key in seen_call_ids:
+                continue
+            seen_call_ids.add(dedupe_key)
+        deduped.append(skill)
+    total = len(deduped)
+    for index, skill in enumerate(deduped, start=1):
+        name = str(skill.get("name") or "").strip()
+        if not name:
+            continue
+        detected_by = str(skill.get("detected_by") or "metadata")
+        call_id = str(skill.get("skill_call_id") or "").strip()
+        events.append({
+            "skill_use_id": f"{interaction_id}:skill:{index}:{_skill_id_segment(name)}",
+            "skill_use_index": index,
+            "skill_use_count_in_interaction": total,
+            "skill_event_type": _skill_event_type(detected_by),
+            "skill_trigger": "unknown",
+            "skill_name": name,
+            "skill_use_count": 1,
+            "skill_namespace": skill.get("skill_namespace") or _skill_namespace(name),
+            "detected_by": detected_by,
+            **({"skill_call_id": call_id} if call_id else {}),
+        })
+    return events
+
+def summarize_skill_usages(skill_usages: List[Dict[str, str]]) -> List[Dict[str, Any]]:
+    summary: Dict[str, Dict[str, Any]] = {}
+    for item in skill_usages or []:
+        name = item.get("name")
+        if not name:
+            continue
+        entry = summary.setdefault(name, {"name": name, "count": 0, "detected_by": item.get("detected_by")})
+        entry["count"] += 1
+    return list(summary.values())
 
 def get_model(msg: Dict[str, Any]) -> str:
     m = msg.get("message")
@@ -609,7 +797,9 @@ def emit_turn(
     usage_details = get_usage(last_assistant)
 
     tool_calls = _tool_calls_from_assistants(turn.assistant_msgs)
-    skill_usages = detect_skill_usages(tool_calls, discover_known_skills())
+    skill_usages = detect_turn_skill_usages(turn, tool_calls, discover_known_skills())
+    interaction_id = build_interaction_id("claude", session_id, turn_num)
+    skill_use_events = build_skill_use_events(interaction_id, skill_usages)
     interaction_meta = build_interaction_metadata(
         "claude",
         user_id,
@@ -618,15 +808,13 @@ def emit_turn(
         usage_details,
         len(tool_calls),
         len(turn.tool_results_by_id),
-        len(skill_usages),
+        len(skill_use_events),
         model,
         user_message_count=1,
         assistant_message_count=len(turn.assistant_msgs),
+        skill_use_events=skill_use_events,
     )
-    skill_summary = [
-        {"name": item["name"], "count": 1, "detected_by": item["detected_by"]}
-        for item in skill_usages
-    ]
+    skill_summary = summarize_skill_usages(skill_usages)
 
     # attach tool outputs
     for c in tool_calls:
@@ -642,15 +830,17 @@ def emit_turn(
     with propagate_attributes(
         user_id=user_id,
         session_id=session_id,
-        trace_name=f"Claude Code - Turn {turn_num}",
-        tags=["claude-code"],
+        trace_name="Agent Turn",
+        tags=[AGENT_NAME],
     ):
-        with langfuse.start_as_current_observation(
-            name=f"Claude Code - Turn {turn_num}",
+        with langfuse.start_as_current_observation(
+            name="Agent Turn",
             input={"role": "user", "content": user_text},
+            output={"role": "assistant", "content": assistant_text},
             metadata={
                 **interaction_meta,
-                "source": "claude",
+                "source": AGENT_NAME,
+                "agent": AGENT_NAME,
                 "session_id": session_id,
                 "turn_number": turn_num,
                 "transcript_path": str(transcript_path),
@@ -658,17 +848,9 @@ def emit_turn(
                 "skills": skill_summary,
             },
         ) as trace_span:
-            with langfuse.start_as_current_observation(
-                name="AI Interaction",
-                input={"role": "user", "content": user_text},
-                output={"role": "assistant", "content": assistant_text},
-                metadata=interaction_meta,
-            ):
-                pass
-
             # LLM generation
             with langfuse.start_as_current_observation(
-                name="Claude Response",
+                name="Agent Response",
                 as_type="generation",
                 model=model,
                 input={"role": "user", "content": user_text},
@@ -678,7 +860,8 @@ def emit_turn(
                     "assistant_text": assistant_text_meta,
                     "tool_count": len(tool_calls),
                     "usage_details": usage_details,
-                    "source": "claude",
+                    "source": AGENT_NAME,
+                    "agent": AGENT_NAME,
                     "user_id": user_id or "",
                     "session_id": session_id,
                     "interaction_id": interaction_meta["interaction_id"],
@@ -687,24 +870,6 @@ def emit_turn(
             ):
                 pass
 
-            for skill in skill_usages:
-                with langfuse.start_as_current_observation(
-                    name="Skill Use",
-                    metadata={
-                        "source": "claude",
-                        "user_id": user_id or "",
-                        "session_id": session_id,
-                        "interaction_id": interaction_meta["interaction_id"],
-                        "skill_name": skill["name"],
-                        "skill_use_count": 1,
-                        "skill_namespace": skill["skill_namespace"],
-                        "detected_by": skill["detected_by"],
-                        "turn_number": turn_num,
-                        "metrics_schema_version": METRICS_SCHEMA_VERSION,
-                    },
-                ):
-                    pass
-
             # Tool observations
             for tc in tool_calls:
                 in_obj = tc["input"]
@@ -715,11 +880,12 @@ def emit_turn(
                     in_meta = None
 
                 with langfuse.start_as_current_observation(
-                    name=f"Tool: {tc['name']}",
+                    name="Tool Call",
                     as_type="tool",
                     input=in_obj,
                     metadata={
-                        "source": "claude",
+                        "source": AGENT_NAME,
+                        "agent": AGENT_NAME,
                         "user_id": user_id or "",
                         "session_id": session_id,
                         "interaction_id": interaction_meta["interaction_id"],

package/package.json

@@ -1,47 +1,47 @@
 {
   "name": "oh-langfuse",
-  "version": "0.1.41",
+  "version": "0.1.43",
   "private": false,
   "type": "module",
-  "description": "Use npm scripts to configure Claude Code / OpenCode / Codex with Langfuse tracing.",
-  "engines": {
-    "node": ">=16"
-  },
-  "bin": {
+  "description": "Use npm scripts to configure Claude Code / OpenCode / Codex with Langfuse tracing.",
+  "engines": {
+    "node": ">=16"
+  },
+  "bin": {
     "oh-langfuse": "bin/cli.js",
     "code-tool-langfuse": "bin/cli.js"
   },
   "files": [
-    "bin",
-    "scripts/auto-update-runtime.mjs",
-    "scripts/codex-langfuse-check.mjs",
-    "scripts/codex-langfuse-setup.mjs",
-    "scripts/json-utils.mjs",
-    "scripts/langfuse-check.mjs",
-    "scripts/langfuse-setup.mjs",
-    "scripts/opencode-langfuse-check.mjs",
-    "scripts/opencode-langfuse-run.mjs",
-    "scripts/opencode-langfuse-setup.mjs",
-    "scripts/resolve-opencode-cli.mjs",
-    "scripts/real-self-verify.mjs",
-    "scripts/log-filter-utils.mjs",
-    "scripts/metrics-utils.mjs",
-    "scripts/runtime-state-utils.mjs",
-    "scripts/update-langfuse-runtime.mjs",
-    "scripts/update-utils.mjs",
+    "bin",
+    "scripts/auto-update-runtime.mjs",
+    "scripts/codex-langfuse-check.mjs",
+    "scripts/codex-langfuse-setup.mjs",
+    "scripts/json-utils.mjs",
+    "scripts/langfuse-check.mjs",
+    "scripts/langfuse-setup.mjs",
+    "scripts/opencode-langfuse-check.mjs",
+    "scripts/opencode-langfuse-run.mjs",
+    "scripts/opencode-langfuse-setup.mjs",
+    "scripts/resolve-opencode-cli.mjs",
+    "scripts/real-self-verify.mjs",
+    "scripts/log-filter-utils.mjs",
+    "scripts/metrics-utils.mjs",
+    "scripts/runtime-state-utils.mjs",
+    "scripts/update-langfuse-runtime.mjs",
+    "scripts/update-utils.mjs",
     "langfuse_hook.py",
-    "codex_langfuse_notify.py",
+    "codex_langfuse_notify.py",
     "README.md",
     "SELF_VERIFY.md",
-    "CODEX_LANGFUSE_PLAN.md",
+    "CODEX_LANGFUSE_PLAN.md",
     "setup-langfuse.bat",
     "setup-langfuse.sh"
   ],
-  "scripts": {
-    "start": "node bin/cli.js",
-    "check": "node --check bin/cli.js",
-    "test": "node --test tests/*.test.mjs",
-    "pack:check": "npm pack --dry-run",
+  "scripts": {
+    "start": "node bin/cli.js",
+    "check": "node --check bin/cli.js",
+    "test": "node --test tests/*.test.mjs",
+    "pack:check": "npm pack --dry-run",
     "claude:setup": "node scripts/langfuse-setup.mjs",
     "claude:check": "node scripts/langfuse-check.mjs",
     "langfuse:setup": "node scripts/langfuse-setup.mjs",
@@ -54,10 +54,10 @@
     "opencode:langfuse:run": "node scripts/opencode-langfuse-run.mjs",
     "codex:setup": "node scripts/codex-langfuse-setup.mjs",
     "codex:check": "node scripts/codex-langfuse-check.mjs",
-    "codex:langfuse:setup": "node scripts/codex-langfuse-setup.mjs",
-    "codex:langfuse:check": "node scripts/codex-langfuse-check.mjs",
-    "update": "node scripts/update-langfuse-runtime.mjs",
-    "self:verify": "node scripts/real-self-verify.mjs"
-  },
+    "codex:langfuse:setup": "node scripts/codex-langfuse-setup.mjs",
+    "codex:langfuse:check": "node scripts/codex-langfuse-check.mjs",
+    "update": "node scripts/update-langfuse-runtime.mjs",
+    "self:verify": "node scripts/real-self-verify.mjs"
+  },
   "dependencies": {}
 }

package/scripts/auto-update-runtime.mjs

@@ -112,8 +112,10 @@ async function main() {
 }
 
 main()
-  .then((code) => process.exit(code))
+  .then((code) => {
+    process.exitCode = code;
+  })
   .catch((error) => {
     console.error(`[WARN] oh-langfuse auto-update skipped: ${error?.message || String(error)}`);
-    process.exit(0);
+    process.exitCode = 0;
   });