promptlayer 1.1.0 → 1.2.0

package/vendor/claude-agents/trace/hooks/parse_stop_transcript.py

@@ -0,0 +1,375 @@
+#!/usr/bin/env python3
+"""Parse a Claude transcript and return finalized turn/tool/llm spans as JSON."""
+
+import json
+import os
+import sys
+from datetime import datetime, timezone
+
+
+def parse_iso_to_ns(raw):
+    if not raw:
+        return None
+    try:
+        dt = datetime.fromisoformat(raw.replace("Z", "+00:00"))
+        return int(dt.timestamp() * 1_000_000_000)
+    except Exception:
+        return None
+
+
+def safe_int(value, default=0):
+    try:
+        return int(value)
+    except Exception:
+        return default
+
+
+def stringify(value):
+    if isinstance(value, str):
+        return value
+    if value is None:
+        return ""
+    return json.dumps(value, ensure_ascii=False)
+
+
+def content_to_text(content):
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        parts = []
+        for block in content:
+            if isinstance(block, dict) and block.get("type") == "text":
+                text = block.get("text")
+                if isinstance(text, str) and text:
+                    parts.append(text)
+                    continue
+            serialized = stringify(block)
+            if serialized:
+                parts.append(serialized)
+        return "\n".join(parts).strip()
+    if isinstance(content, dict) and content.get("type") == "text":
+        text = content.get("text")
+        if isinstance(text, str):
+            return text
+    return stringify(content)
+
+
+def message_text(content):
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        parts = []
+        for block in content:
+            if isinstance(block, dict) and block.get("type") == "text":
+                text = block.get("text")
+                if isinstance(text, str) and text:
+                    parts.append(text)
+        return "\n".join(parts).strip()
+    return ""
+
+
+def flatten_indexed(prefix, items, out):
+    for i, item in enumerate(items):
+        for key, value in item.items():
+            attr_key = f"{prefix}.{i}.{key}"
+            if isinstance(value, (dict, list)):
+                out[attr_key] = json.dumps(value, ensure_ascii=False)
+            else:
+                out[attr_key] = value
+
+
+def append_history_item(history, item):
+    if (
+        item.get("role") == "user"
+        and history
+        and history[-1].get("role") == "user"
+        and history[-1].get("content") == item.get("content")
+    ):
+        return
+    history.append(item)
+
+
+def is_tool_result_user(rec):
+    if rec.get("type") != "user":
+        return False
+    content = rec.get("message", {}).get("content")
+    return (
+        isinstance(content, list)
+        and len(content) > 0
+        and isinstance(content[0], dict)
+        and content[0].get("type") == "tool_result"
+    )
+
+
+def parse_transcript(transcript_path, turn_start_fallback, pending_payloads, expected_session_id=None):
+    records = []
+    with open(transcript_path, encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                rec = json.loads(line)
+                if expected_session_id:
+                    rec_session_id = rec.get("sessionId") if isinstance(rec, dict) else None
+                    if rec_session_id and rec_session_id != expected_session_id:
+                        continue
+                records.append(rec)
+            except Exception:
+                continue
+
+    if not records:
+        now_ns = int(datetime.now(timezone.utc).timestamp() * 1_000_000_000)
+        return {"turn": {"start_ns": now_ns, "end_ns": now_ns}, "tools": [], "llms": []}
+
+    turn_start_idx = 0
+    for i in range(len(records) - 1, -1, -1):
+        rec = records[i]
+        if rec.get("type") != "user":
+            continue
+        if is_tool_result_user(rec):
+            continue
+        turn_start_idx = i
+        break
+
+    history = []
+    tools = []
+    llms = []
+    pending_tool_uses = []
+    pending_payload_idx = 0
+    saw_human_input = False
+
+    turn_start_ns = turn_start_fallback
+    turn_end_ns = turn_start_fallback
+    last_input_ns = turn_start_fallback
+
+    for idx, rec in enumerate(records):
+        emit_for_turn = idx >= turn_start_idx
+        timestamp_ns = parse_iso_to_ns(rec.get("timestamp"))
+        if emit_for_turn and timestamp_ns is not None:
+            if turn_start_ns is None or timestamp_ns < turn_start_ns:
+                turn_start_ns = timestamp_ns
+            if turn_end_ns is None or timestamp_ns > turn_end_ns:
+                turn_end_ns = timestamp_ns
+
+        rec_type = rec.get("type")
+        if rec_type == "queue-operation":
+            operation = stringify(rec.get("operation"))
+            if operation == "enqueue":
+                content = content_to_text(rec.get("content"))
+                if content:
+                    append_history_item(history, {"role": "user", "content": content})
+                    last_input_ns = timestamp_ns or last_input_ns
+                    saw_human_input = True
+            continue
+
+        if rec_type == "user":
+            content = rec.get("message", {}).get("content")
+            if is_tool_result_user(rec):
+                block = content[0]
+                tool_use_id = stringify(block.get("tool_use_id"))
+                tool_result_content = block.get("content")
+                is_error = bool(block.get("is_error", False))
+
+                match_idx = None
+                for idx, item in enumerate(pending_tool_uses):
+                    if tool_use_id and item.get("id") == tool_use_id:
+                        match_idx = idx
+                        break
+                if match_idx is None and pending_tool_uses:
+                    match_idx = 0
+                tool_use = pending_tool_uses.pop(match_idx) if match_idx is not None else {}
+
+                payload = {}
+                if emit_for_turn and pending_payload_idx < len(pending_payloads):
+                    maybe_payload = pending_payloads[pending_payload_idx]
+                    pending_payload_idx += 1
+                    if isinstance(maybe_payload, dict):
+                        payload = maybe_payload
+
+                tool_name = stringify(payload.get("tool_name")) or stringify(tool_use.get("name")) or "Tool"
+                function_input = payload.get("function_input", tool_use.get("input", {}))
+                function_output = payload.get(
+                    "function_output",
+                    {"content": tool_result_content, "is_error": is_error},
+                )
+
+                tool_start_ns = safe_int(tool_use.get("start_ns"), 0) or timestamp_ns or turn_start_ns
+                tool_end_ns = timestamp_ns or tool_start_ns
+                if tool_start_ns is None:
+                    tool_start_ns = tool_end_ns
+                if tool_end_ns is None:
+                    tool_end_ns = tool_start_ns
+
+                if emit_for_turn:
+                    tools.append(
+                        {
+                            "name": f"Tool: {tool_name}",
+                            "start_ns": int(tool_start_ns),
+                            "end_ns": int(tool_end_ns),
+                            "attributes": {
+                                "source": "claude-code",
+                                "hook": "PostToolUse",
+                                "node_type": "CODE_EXECUTION",
+                                "tool_name": tool_name,
+                                "function_input": function_input,
+                                "function_output": function_output,
+                            },
+                        }
+                    )
+
+                history.append(
+                    {
+                        "role": "tool",
+                        "tool_call_id": tool_use_id,
+                        "content": stringify(tool_result_content),
+                    }
+                )
+                last_input_ns = timestamp_ns or last_input_ns
+                continue
+
+            user_text = content_to_text(content)
+            append_history_item(history, {"role": "user", "content": user_text})
+            last_input_ns = timestamp_ns or last_input_ns
+            saw_human_input = True
+            continue
+
+        if rec_type != "assistant":
+            continue
+
+        msg = rec.get("message", {})
+        model = stringify(msg.get("model")) or "claude"
+        msg_id = stringify(msg.get("id"))
+        stop_reason = stringify(msg.get("stop_reason"))
+        usage = msg.get("usage", {})
+        if not isinstance(usage, dict):
+            usage = {}
+
+        prompt_tokens = safe_int(usage.get("input_tokens"), 0)
+        completion_tokens = safe_int(usage.get("output_tokens"), 0)
+        output_text = message_text(msg.get("content"))
+
+        tool_calls = []
+        content_blocks = msg.get("content")
+        if isinstance(content_blocks, list):
+            for block in content_blocks:
+                if not isinstance(block, dict) or block.get("type") != "tool_use":
+                    continue
+                call_id = stringify(block.get("id"))
+                call_name = stringify(block.get("name")) or "tool"
+                call_input = block.get("input", {})
+                tool_calls.append(
+                    {
+                        "id": call_id,
+                        "type": "function",
+                        "function": {
+                            "name": call_name,
+                            "arguments": json.dumps(call_input, ensure_ascii=False),
+                        },
+                    }
+                )
+                pending_tool_uses.append(
+                    {
+                        "id": call_id,
+                        "name": call_name,
+                        "input": call_input,
+                        "start_ns": timestamp_ns,
+                    }
+                )
+
+        # Claude can emit intermediate assistant records that contain only
+        # empty thinking blocks. Those should not consume the user's prompt.
+        if not output_text and not tool_calls:
+            continue
+
+        llm_start_ns = last_input_ns or timestamp_ns or turn_start_ns
+        llm_end_ns = timestamp_ns or llm_start_ns
+        if llm_start_ns is None:
+            llm_start_ns = llm_end_ns
+        if llm_end_ns is None:
+            llm_end_ns = llm_start_ns
+
+        provider = "anthropic" if model.startswith("claude") else "unknown"
+
+        attrs = {
+            "source": "claude-code",
+            "hook": "Stop",
+            "node_type": "PROMPT_TEMPLATE",
+            "promptlayer.prompt_history_mode": "full_session",
+            "gen_ai.operation.name": "chat",
+            "gen_ai.provider.name": provider,
+            "gen_ai.request.model": model,
+            "gen_ai.response.model": model,
+            "gen_ai.usage.input_tokens": prompt_tokens,
+            "gen_ai.usage.output_tokens": completion_tokens,
+        }
+        if msg_id:
+            attrs["gen_ai.response.id"] = msg_id
+        if stop_reason:
+            attrs["gen_ai.completion.0.finish_reason"] = stop_reason
+
+        flatten_indexed("gen_ai.prompt", history, attrs)
+
+        completion_item = {"role": "assistant", "content": output_text}
+        if tool_calls:
+            completion_item["tool_calls"] = tool_calls
+        flatten_indexed("gen_ai.completion", [completion_item], attrs)
+
+        span_name = "LLM Call (User)" if saw_human_input else "LLM call"
+
+        if emit_for_turn:
+            llms.append(
+                {
+                    "name": span_name,
+                    "start_ns": int(llm_start_ns),
+                    "end_ns": int(llm_end_ns),
+                    "attributes": attrs,
+                }
+            )
+
+        assistant_history = {"role": "assistant", "content": output_text}
+        if tool_calls:
+            assistant_history["tool_calls"] = tool_calls
+        history.append(assistant_history)
+        saw_human_input = False
+
+    if turn_start_ns is None:
+        turn_start_ns = int(datetime.now(timezone.utc).timestamp() * 1_000_000_000)
+    if turn_end_ns is None:
+        turn_end_ns = turn_start_ns
+
+    return {
+        "turn": {"start_ns": int(turn_start_ns), "end_ns": int(turn_end_ns)},
+        "tools": tools,
+        "llms": llms,
+    }
+
+
+def main():
+    if len(sys.argv) < 3:
+        print(
+            json.dumps(
+                {"error": "Usage: parse_stop_transcript.py <transcript_path> <turn_start_ns> [session_id]"}
+            )
+        )
+        return 1
+
+    transcript_path = sys.argv[1]
+    turn_start_fallback = safe_int(sys.argv[2], 0) or None
+    expected_session_id = sys.argv[3] if len(sys.argv) > 3 else None
+
+    pending_raw = os.environ.get("PL_PENDING_TOOL_CALLS", "[]")
+    try:
+        pending_payloads = json.loads(pending_raw)
+    except Exception:
+        pending_payloads = []
+    if not isinstance(pending_payloads, list):
+        pending_payloads = []
+
+    parsed = parse_transcript(transcript_path, turn_start_fallback, pending_payloads, expected_session_id)
+    print(json.dumps(parsed, ensure_ascii=False, separators=(",", ":")))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/vendor/claude-agents/trace/hooks/post_tool_use.sh

@@ -0,0 +1,41 @@
+#!/bin/bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+# shellcheck source=plugins/trace/hooks/lib.sh
+source "$SCRIPT_DIR/lib.sh"
+
+tracing_enabled || exit 0
+check_requirements || exit 0
+
+input="$(cat)"
+session_id="$(echo "$input" | jq -r '.session_id // empty')"
+tool_name="$(echo "$input" | jq -r '.tool_name // empty')"
+tool_input="$(echo "$input" | jq -c '.tool_input // {}')"
+tool_output="$(echo "$input" | jq -c '.tool_response // .output // {}')"
+[[ -z "$session_id" || -z "$tool_name" ]] && exit 0
+
+ensure_session_initialized "$session_id"
+
+trace_id="$(get_session_state "$session_id" trace_id)"
+[[ -z "$trace_id" ]] && exit 0
+turn_start_ns="$(get_session_state "$session_id" current_turn_start_ns)"
+if [[ -z "$turn_start_ns" ]]; then
+	set_session_state "$session_id" current_turn_start_ns "$(now_ns)"
+fi
+
+attrs="$(jq -nc \
+	--arg source claude-code \
+	--arg hook PostToolUse \
+	--arg tool_name "$tool_name" \
+	--argjson function_input "$tool_input" \
+	--argjson function_output "$tool_output" \
+	'{source:$source,hook:$hook,tool_name:$tool_name,node_type:"CODE_EXECUTION",function_input:$function_input,function_output:$function_output}')"
+
+pending_tool_calls="$(get_session_state "$session_id" pending_tool_calls)"
+[[ -z "$pending_tool_calls" ]] && pending_tool_calls='[]'
+
+pending_tool_calls="$(echo "$pending_tool_calls" | jq -c --argjson attrs "$attrs" '. + [$attrs]')"
+set_session_state "$session_id" pending_tool_calls "$pending_tool_calls"
+
+log "INFO" "PostToolUse captured session_id=$session_id tool=$tool_name"

package/vendor/claude-agents/trace/hooks/session_end.sh

@@ -0,0 +1,37 @@
+#!/bin/bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+# shellcheck source=plugins/trace/hooks/lib.sh
+source "$SCRIPT_DIR/lib.sh"
+
+tracing_enabled || exit 0
+check_requirements || exit 0
+
+input="$(cat)"
+session_id="$(echo "$input" | jq -r '.session_id // empty')"
+[[ -z "$session_id" ]] && exit 0
+
+acquire_session_lock "$session_id" || exit 0
+trap 'release_session_lock' EXIT
+
+trace_id="$(get_session_state "$session_id" trace_id)"
+session_span_id="$(get_session_state "$session_id" session_span_id)"
+session_parent_span_id="$(get_session_state "$session_id" session_parent_span_id)"
+session_start_ns="$(get_session_state "$session_id" session_start_ns)"
+[[ -z "$trace_id" || -z "$session_span_id" ]] && exit 0
+[[ -z "$session_start_ns" ]] && session_start_ns="$(now_ns)"
+
+release_session_lock
+trap - EXIT
+
+# Always emit/re-emit root span with final end time. The server upserts on
+# span_id conflict, so this safely updates the end time and lifecycle attribute.
+end_ns="$(now_ns)"
+attrs='{"source":"claude-code","hook":"SessionEnd","node_type":"WORKFLOW","session.lifecycle":"complete"}'
+emit_span "$trace_id" "$session_span_id" "$session_parent_span_id" "Claude Code session" "1" "$session_start_ns" "$end_ns" "$attrs" || true
+
+acquire_session_lock "$session_id" || exit 0
+trap 'release_session_lock' EXIT
+rm -f "$PL_SESSION_STATE_DIR/$session_id.json"
+log "INFO" "SessionEnd finalized session_id=$session_id"

package/vendor/claude-agents/trace/hooks/session_start.sh

@@ -0,0 +1,57 @@
+#!/bin/bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+# shellcheck source=plugins/trace/hooks/lib.sh
+source "$SCRIPT_DIR/lib.sh"
+
+tracing_enabled || exit 0
+check_requirements || exit 0
+
+input="$(cat)"
+session_id="$(echo "$input" | jq -r '.session_id // empty')"
+[[ -z "$session_id" ]] && session_id="$(uuidgen | tr '[:upper:]' '[:lower:]')"
+
+existing_trace_id="$(get_session_state "$session_id" trace_id)"
+existing_session_span_id="$(get_session_state "$session_id" session_span_id)"
+if [[ -n "$existing_trace_id" && -n "$existing_session_span_id" ]]; then
+	if [[ -z "$(get_session_state "$session_id" session_start_ns)" ]]; then
+		set_session_state "$session_id" session_start_ns "$(now_ns)"
+	fi
+	if [[ -z "$(get_session_state "$session_id" pending_tool_calls)" ]]; then
+		set_session_state "$session_id" pending_tool_calls "[]"
+	fi
+	if [[ -z "$(get_session_state "$session_id" session_parent_span_id)" ]]; then
+		set_session_state "$session_id" session_parent_span_id ""
+	fi
+	if [[ -z "$(get_session_state "$session_id" session_traceparent_version)" ]]; then
+		set_session_state "$session_id" session_traceparent_version ""
+	fi
+	if [[ -z "$(get_session_state "$session_id" session_trace_flags)" ]]; then
+		set_session_state "$session_id" session_trace_flags ""
+	fi
+	if [[ -z "$(get_session_state "$session_id" trace_context_source)" ]]; then
+		set_session_state "$session_id" trace_context_source "generated"
+	fi
+	log "INFO" "SessionStart ignored existing state session_id=$session_id trace_id=$existing_trace_id"
+	exit 0
+fi
+
+load_initial_trace_context || true
+trace_id="${PL_INITIAL_TRACE_ID:-}"
+[[ -z "$trace_id" ]] && trace_id="$(generate_trace_id)"
+span_id="$(generate_span_id)"
+start_ns="$(now_ns)"
+
+set_session_state "$session_id" trace_id "$trace_id"
+set_session_state "$session_id" session_span_id "$span_id"
+set_session_state "$session_id" session_parent_span_id "${PL_INITIAL_PARENT_SPAN_ID:-}"
+set_session_state "$session_id" session_start_ns "$start_ns"
+set_session_state "$session_id" current_turn_start_ns ""
+set_session_state "$session_id" pending_tool_calls "[]"
+set_session_state "$session_id" session_init_source "session_start_hook"
+set_session_state "$session_id" session_traceparent_version "${PL_INITIAL_TRACEPARENT_VERSION:-}"
+set_session_state "$session_id" session_trace_flags "${PL_INITIAL_TRACE_FLAGS:-}"
+set_session_state "$session_id" trace_context_source "${PL_INITIAL_TRACE_CONTEXT_SOURCE:-generated}"
+
+log "INFO" "SessionStart captured session_id=$session_id trace_id=$trace_id"

package/vendor/claude-agents/trace/hooks/stop_hook.sh

@@ -0,0 +1,123 @@
+#!/bin/bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+# shellcheck source=plugins/trace/hooks/lib.sh
+source "$SCRIPT_DIR/lib.sh"
+
+tracing_enabled || exit 0
+check_requirements || exit 0
+
+input="$(cat)"
+session_id="$(echo "$input" | jq -r '.session_id // empty')"
+transcript_path="$(echo "$input" | jq -r '.transcript_path // empty')"
+
+if [[ -z "$session_id" && -n "$transcript_path" ]]; then
+	session_id="$(basename "$transcript_path" .jsonl)"
+fi
+[[ -z "$session_id" ]] && exit 0
+spans_file="$(mktemp "${TMPDIR:-/tmp}/pl-stop-spans.XXXXXX")"
+cleanup() {
+	rm -f "$spans_file"
+	release_session_lock
+}
+trap cleanup EXIT
+
+add_span_to_batch() {
+	local trace="$1"
+	local span="$2"
+	local parent="$3"
+	local span_name="$4"
+	local span_kind="$5"
+	local start="$6"
+	local end="$7"
+	local attrs="$8"
+
+	local span_json
+	span_json="$(build_span_json "$trace" "$span" "$parent" "$span_name" "$span_kind" "$start" "$end" "$attrs")" || return 1
+	printf '%s\n' "$span_json" >>"$spans_file"
+}
+
+acquire_session_lock "$session_id" || exit 0
+ensure_session_initialized "$session_id"
+
+trace_id="$(get_session_state "$session_id" trace_id)"
+session_span_id="$(get_session_state "$session_id" session_span_id)"
+session_parent_span_id="$(get_session_state "$session_id" session_parent_span_id)"
+turn_start_ns="$(get_session_state "$session_id" current_turn_start_ns)"
+pending_tool_calls="$(get_session_state "$session_id" pending_tool_calls)"
+session_init_source="$(get_session_state "$session_id" session_init_source)"
+session_start_ns="$(get_session_state "$session_id" session_start_ns)"
+
+[[ -z "$trace_id" || -z "$session_span_id" ]] && exit 0
+[[ -z "$pending_tool_calls" ]] && pending_tool_calls='[]'
+[[ -z "$session_start_ns" ]] && session_start_ns="$(now_ns)"
+
+[[ -z "$turn_start_ns" ]] && turn_start_ns="$(now_ns)"
+
+# Keep lock scope short: snapshot + clear turn-specific mutable state.
+set_session_state "$session_id" current_turn_start_ns ""
+set_session_state "$session_id" pending_tool_calls "[]"
+
+release_session_lock
+
+parse_transcript_with_retry() {
+	local attempts=0
+	local parsed llm_count
+	while true; do
+		parsed="$(PL_PENDING_TOOL_CALLS="$pending_tool_calls" python3 "$SCRIPT_DIR/parse_stop_transcript.py" "$transcript_path" "$turn_start_ns" "$session_id")"
+		llm_count="$(echo "$parsed" | jq -r '.llms | length')"
+		if [[ "$llm_count" -gt 0 || $attempts -ge 10 ]]; then
+			echo "$parsed"
+			return 0
+		fi
+		attempts=$((attempts + 1))
+		sleep 0.2
+	done
+}
+
+if [[ -z "$transcript_path" || ! -f "$transcript_path" ]]; then
+	log "WARN" "Stop missing transcript session_id=$session_id"
+else
+	parsed="$(parse_transcript_with_retry)"
+
+	turn_start_ns="$(echo "$parsed" | jq -r '.turn.start_ns')"
+	turn_end_ns="$(echo "$parsed" | jq -r '.turn.end_ns')"
+
+	# Emit (or re-emit) the root session span eagerly so the trace is visible
+	# in the UI before the session ends. The server upserts on span_id conflict,
+	# so re-emitting with an updated end time is safe.
+	if [[ "$session_init_source" == "lazy_init" ]]; then
+		session_hook_attr="StopFallback"
+		session_lifecycle_attr="stop_fallback"
+	else
+		session_hook_attr="Stop"
+		session_lifecycle_attr="in_progress"
+	fi
+	session_attrs="{\"source\":\"claude-code\",\"hook\":\"$session_hook_attr\",\"node_type\":\"WORKFLOW\",\"session.lifecycle\":\"$session_lifecycle_attr\"}"
+	add_span_to_batch "$trace_id" "$session_span_id" "$session_parent_span_id" "Claude Code session" "1" "$session_start_ns" "$turn_end_ns" "$session_attrs" || true
+
+	while IFS= read -r tool; do
+		[[ -z "$tool" ]] && continue
+		span_id="$(generate_span_id)"
+		name="$(echo "$tool" | jq -r '.name')"
+		start_ns="$(echo "$tool" | jq -r '.start_ns')"
+		end_ns="$(echo "$tool" | jq -r '.end_ns')"
+		attrs="$(echo "$tool" | jq -c '.attributes')"
+		add_span_to_batch "$trace_id" "$span_id" "$session_span_id" "$name" "3" "$start_ns" "$end_ns" "$attrs" || true
+	done < <(echo "$parsed" | jq -c '.tools[]?')
+
+	while IFS= read -r llm; do
+		[[ -z "$llm" ]] && continue
+		span_id="$(generate_span_id)"
+		name="$(echo "$llm" | jq -r '.name')"
+		start_ns="$(echo "$llm" | jq -r '.start_ns')"
+		end_ns="$(echo "$llm" | jq -r '.end_ns')"
+		attrs="$(echo "$llm" | jq -c '.attributes')"
+		add_span_to_batch "$trace_id" "$span_id" "$session_span_id" "$name" "3" "$start_ns" "$end_ns" "$attrs" || true
+	done < <(echo "$parsed" | jq -c '.llms[]?')
+fi
+
+emit_spans_batch_file "$spans_file" || true
+
+log "INFO" "Stop finalized session_id=$session_id"

package/vendor/claude-agents/trace/hooks/user_prompt_submit.sh

@@ -0,0 +1,25 @@
+#!/bin/bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+# shellcheck source=plugins/trace/hooks/lib.sh
+source "$SCRIPT_DIR/lib.sh"
+
+tracing_enabled || exit 0
+check_requirements || exit 0
+
+input="$(cat)"
+session_id="$(echo "$input" | jq -r '.session_id // empty')"
+[[ -z "$session_id" ]] && exit 0
+
+ensure_session_initialized "$session_id"
+
+trace_id="$(get_session_state "$session_id" trace_id)"
+session_span_id="$(get_session_state "$session_id" session_span_id)"
+[[ -z "$trace_id" || -z "$session_span_id" ]] && exit 0
+start_ns="$(now_ns)"
+
+set_session_state "$session_id" current_turn_start_ns "$start_ns"
+set_session_state "$session_id" pending_tool_calls "[]"
+
+log "INFO" "UserPromptSubmit captured session_id=$session_id"

package/vendor/claude-agents/vendor_metadata.json

@@ -0,0 +1,5 @@
+{
+  "repository": "https://github.com/MagnivOrg/promptlayer-claude-plugins",
+  "commit_sha": "7dff044080588cffb9b690fcdf772ee0b4f336da",
+  "timestamp": "2026-03-18T19:12:56.156Z"
+}

package/.github/CODEOWNERS

@@ -1 +0,0 @@
-* @jzone3