@narumitw/pi-langfuse 0.50.6 → 0.51.0

package/dist/index.js

@@ -0,0 +1,1551 @@
+// @generated by scripts/build-runtime.mjs; do not edit.
+// @ts-nocheck -- the generated entry uses a .ts extension for Pi's Jiti loader.
+import {
+  DEFAULT_BASE_URL,
+  createLangfuseRuntimeFromBackend,
+  getLangfuseRuntimeInternal,
+  loadLangfuseConfig,
+  normalizeLangfuseConfig,
+  writeLangfuseConfig
+} from "./chunks/chunk-IASLJKKB.js";
+
+// src/git.ts
+var GIT_LOOKUP_TIMEOUT_MS = 1e3;
+var MAX_GIT_BRANCH_LENGTH = 256;
+async function resolveGitMetadata(exec, cwd) {
+  const [branchResult, commit] = await Promise.all([resolveGitBranch(exec, cwd), resolveGitCommit(exec, cwd)]);
+  if (!branchResult.resolved) return void 0;
+  if (branchResult.branch) {
+    return {
+      branch: branchResult.branch,
+      ...commit ? { commit } : {},
+      detached: false
+    };
+  }
+  return commit ? { commit, detached: true } : void 0;
+}
+async function resolveGitBranch(exec, cwd) {
+  try {
+    const result = await exec("git", ["symbolic-ref", "--quiet", "--short", "HEAD"], {
+      cwd,
+      timeout: GIT_LOOKUP_TIMEOUT_MS
+    });
+    if (result.killed) return { resolved: false };
+    if (result.code === 1) return { resolved: true };
+    if (result.code !== 0) return { resolved: false };
+    const branch = normalizeGitBranch(result.stdout);
+    return branch ? { resolved: true, branch } : { resolved: false };
+  } catch {
+    return { resolved: false };
+  }
+}
+async function resolveGitCommit(exec, cwd) {
+  try {
+    const result = await exec("git", ["rev-parse", "--verify", "--short=12", "HEAD"], {
+      cwd,
+      timeout: GIT_LOOKUP_TIMEOUT_MS
+    });
+    if (result.code !== 0 || result.killed) return void 0;
+    const commit = result.stdout.trim();
+    return /^[0-9a-f]{4,64}$/iu.test(commit) ? commit.toLowerCase() : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function normalizeGitBranch(value) {
+  const branch = value.trim();
+  if (!branch || branch.length > MAX_GIT_BRANCH_LENGTH) return void 0;
+  for (const character of branch) {
+    const code = character.codePointAt(0) ?? 0;
+    if (code <= 31 || code === 127) return void 0;
+  }
+  return branch;
+}
+
+// src/sanitizer.ts
+var MAX_CAPTURE_BYTES = 64 * 1024;
+var MAX_STRING_LENGTH = 5e4;
+var MAX_COLLECTION_LENGTH = 200;
+var MAX_DEPTH = 12;
+var TRUNCATED = "[truncated: content budget exceeded]";
+var BASE64_DATA_URI = /data:[^,\s"'`]*;base64,[^\s"'`]*/gi;
+var BASE64_DATA_URI_OMITTED = "[base64 data URI omitted]";
+var OPAQUE_SIGNATURE_KEYS = /* @__PURE__ */ new Set(["thinkingSignature", "textSignature", "thoughtSignature"]);
+function sanitizeTraceValue(value) {
+  const budget = { remaining: MAX_CAPTURE_BYTES };
+  const sanitized = sanitize(value, /* @__PURE__ */ new WeakSet(), 0, budget);
+  return serializedBytes(sanitized) <= MAX_CAPTURE_BYTES ? sanitized : TRUNCATED;
+}
+function sanitize(value, active, depth, budget) {
+  if (budget.remaining <= byteLength(TRUNCATED)) return TRUNCATED;
+  if (value === null || typeof value === "number" || typeof value === "boolean") {
+    return consume(value, budget);
+  }
+  if (typeof value === "string") {
+    return consume(sanitizeString(value, Math.min(MAX_STRING_LENGTH, budget.remaining)), budget);
+  }
+  if (typeof value === "bigint") return consume(value.toString(), budget);
+  if (typeof value === "undefined" || typeof value === "function" || typeof value === "symbol") {
+    return void 0;
+  }
+  if (value instanceof Date) {
+    return consume(Number.isNaN(value.getTime()) ? "[invalid date]" : value.toISOString(), budget);
+  }
+  if (value instanceof Error) {
+    return sanitize({ name: value.name, message: value.message }, active, depth, budget);
+  }
+  if (depth >= MAX_DEPTH) return consume("[maximum depth reached]", budget);
+  if (active.has(value)) return consume("[circular]", budget);
+  active.add(value);
+  let result;
+  if (Array.isArray(value)) {
+    const items = [];
+    for (const item of value.slice(0, MAX_COLLECTION_LENGTH)) {
+      if (budget.remaining <= byteLength(TRUNCATED)) break;
+      items.push(sanitize(item, active, depth + 1, budget));
+    }
+    if (items.length < value.length) items.push(`[${value.length - items.length} items omitted]`);
+    result = items;
+  } else {
+    const record = value;
+    const output = {};
+    const objectType = readProperty(record, "type").value;
+    const redactData = objectType === "image" || objectType === "base64";
+    let visited = 0;
+    let processed = 0;
+    let omitted = false;
+    try {
+      for (const key in record) {
+        if (visited >= MAX_COLLECTION_LENGTH || budget.remaining <= byteLength(TRUNCATED)) {
+          omitted = true;
+          break;
+        }
+        visited += 1;
+        if (!Object.hasOwn(record, key) || OPAQUE_SIGNATURE_KEYS.has(key)) continue;
+        const keyBudget = Math.min(MAX_STRING_LENGTH, Math.max(0, budget.remaining - 4));
+        if (key.length > keyBudget) {
+          omitted = true;
+          break;
+        }
+        const keyBytes = byteLength(key);
+        if (keyBytes > keyBudget) {
+          omitted = true;
+          break;
+        }
+        const sanitizedKey = sanitizeString(key, keyBudget);
+        budget.remaining -= byteLength(sanitizedKey) + 4;
+        const property = readProperty(record, key);
+        if (redactData && key === "data") {
+          output[sanitizedKey] = consume("[base64 omitted]", budget);
+        } else if (!property.ok) output[sanitizedKey] = consume("[unreadable property]", budget);
+        else output[sanitizedKey] = sanitize(property.value, active, depth + 1, budget);
+        processed += 1;
+      }
+    } catch {
+      if (processed === 0) {
+        active.delete(value);
+        return consume("[unreadable object]", budget);
+      }
+      omitted = true;
+    }
+    if (omitted) output.$truncated = "additional object entries omitted";
+    result = output;
+  }
+  active.delete(value);
+  return result;
+}
+function readProperty(record, key) {
+  try {
+    return { ok: true, value: record[key] };
+  } catch {
+    return { ok: false };
+  }
+}
+function consume(value, budget) {
+  const size = serializedBytes(value);
+  if (size > budget.remaining) {
+    budget.remaining -= byteLength(TRUNCATED);
+    return TRUNCATED;
+  }
+  budget.remaining -= size;
+  return value;
+}
+function sanitizeString(value, maxBytes) {
+  return truncateString(value, maxBytes).replace(BASE64_DATA_URI, BASE64_DATA_URI_OMITTED);
+}
+function truncateString(value, maxBytes) {
+  const boundedPrefix = value.slice(0, maxBytes);
+  if (boundedPrefix.length === value.length && byteLength(boundedPrefix) <= maxBytes) {
+    return boundedPrefix;
+  }
+  const suffix = "\u2026 [truncated]";
+  const target = Math.max(0, maxBytes - byteLength(suffix) - 2);
+  let bytes = 0;
+  let output = "";
+  for (const character of boundedPrefix) {
+    const size = byteLength(character);
+    if (bytes + size > target) break;
+    output += character;
+    bytes += size;
+  }
+  return `${output}${suffix}`;
+}
+function serializedBytes(value) {
+  return byteLength(JSON.stringify(value) ?? "null");
+}
+function byteLength(value) {
+  return Buffer.byteLength(value, "utf8");
+}
+
+// src/tracing.ts
+var TRACE_SCHEMA_VERSION = "2";
+var MAX_HEADER_VALUE_LENGTH = 1024;
+var CONTENT_DISABLED = "[content capture disabled]";
+var ALLOWED_RESPONSE_HEADERS = /* @__PURE__ */ new Set([
+  "anthropic-ratelimit-requests-limit",
+  "anthropic-ratelimit-requests-remaining",
+  "anthropic-ratelimit-requests-reset",
+  "anthropic-ratelimit-tokens-limit",
+  "anthropic-ratelimit-tokens-remaining",
+  "anthropic-ratelimit-tokens-reset",
+  "cf-ray",
+  "openai-request-id",
+  "request-id",
+  "retry-after",
+  "x-amzn-requestid",
+  "x-request-id",
+  "x-ratelimit-limit-requests",
+  "x-ratelimit-limit-tokens",
+  "x-ratelimit-remaining-requests",
+  "x-ratelimit-remaining-tokens",
+  "x-ratelimit-reset-requests",
+  "x-ratelimit-reset-tokens"
+]);
+var TraceRecorder = class {
+  constructor(backend, context) {
+    this.backend = backend;
+    this.context = context;
+  }
+  backend;
+  context;
+  root;
+  attempt;
+  attemptIndex;
+  turn;
+  turnIndex;
+  generation;
+  tools = /* @__PURE__ */ new Map();
+  duplicateToolIds = /* @__PURE__ */ new Set();
+  compaction;
+  lastOutput;
+  lastAssistant;
+  lastAttemptOutcome;
+  unresolvedToolErrors = 0;
+  startSnapshot;
+  counters = emptyCounters();
+  startObservation(name, attributes, options) {
+    const { sessionId, userId } = this.context;
+    return this.backend.start(name, { ...attributes, sessionId, ...userId ? { userId } : {} }, options);
+  }
+  hasActiveTrace() {
+    return this.root !== void 0;
+  }
+  hasActiveAttempt() {
+    return this.attempt !== void 0;
+  }
+  beginAgent(input) {
+    if (this.root) this.closeActiveTrace("Interrupted by a new Pi run.", void 0, "interrupted");
+    this.lastOutput = void 0;
+    this.lastAssistant = void 0;
+    this.lastAttemptOutcome = void 0;
+    this.unresolvedToolErrors = 0;
+    this.duplicateToolIds.clear();
+    this.startSnapshot = input.snapshot;
+    this.counters = emptyCounters();
+    const traceInput = this.capture({
+      prompt: input.prompt,
+      ...hasItems(input.images) ? { images: input.images } : {}
+    });
+    const metadata = {
+      ...customTraceMetadata(this.context.metadata),
+      "pi.cwd": this.context.cwd,
+      ...input.git?.branch ? { "pi.git.branch": input.git.branch } : {},
+      ...input.git?.commit ? { "pi.git.commit": input.git.commit } : {},
+      ...input.git ? { "pi.git.detached": input.git.detached } : {},
+      "pi.mode": this.context.mode,
+      ...input.model?.id ? { "pi.model": input.model.id } : {},
+      ...input.model?.provider ? { "pi.provider": input.model.provider } : {},
+      ...input.requestId ? { "pi.request.id": input.requestId } : {},
+      "pi.session.id": this.context.sessionId,
+      "pi.trace.schema_version": Number(TRACE_SCHEMA_VERSION),
+      ...snapshotMetadata("start", input.snapshot)
+    };
+    const attributes = { input: traceInput, metadata, version: TRACE_SCHEMA_VERSION };
+    const gitTag = input.git?.branch ? `branch:${input.git.branch}` : input.git?.detached ? "git:detached" : void 0;
+    this.root = this.startObservation("pi.agent", attributes, { asType: "agent" });
+    this.root.updateTrace?.({
+      name: normalizeTraceName(this.context.traceName),
+      sessionId: this.context.sessionId,
+      ...this.context.userId ? { userId: this.context.userId } : {},
+      version: TRACE_SCHEMA_VERSION,
+      input: traceInput,
+      metadata,
+      tags: traceTags(this.context.tags, gitTag)
+    });
+    const traceId = this.root.traceId;
+    if (traceId && this.context.onTraceId) {
+      try {
+        void Promise.resolve(this.context.onTraceId(traceId)).catch(() => void 0);
+      } catch {
+      }
+    }
+  }
+  beginAttempt(input = {}) {
+    if (!this.root) return;
+    if (this.attempt) {
+      this.closeAttempt(void 0, "Interrupted by the next Pi attempt.", "interrupted");
+    }
+    const index = this.counters.attempts;
+    this.counters.attempts += 1;
+    this.lastAssistant = void 0;
+    this.unresolvedToolErrors = 0;
+    this.attemptIndex = index;
+    this.attempt = this.startObservation(
+      "pi.attempt",
+      {
+        metadata: {
+          "pi.attempt.index": index,
+          ...input.reason ? { "pi.attempt.reason": input.reason } : {}
+        },
+        version: TRACE_SCHEMA_VERSION
+      },
+      { asType: "span", parent: this.root }
+    );
+  }
+  finishAttempt(message) {
+    if (message?.role === "assistant") this.finishAssistant(message);
+    if (!this.attempt) return;
+    const outcome = this.unresolvedToolErrors > 0 ? "error" : classifyOutcome(message);
+    this.closeAttempt(
+      message,
+      this.unresolvedToolErrors > 0 ? "Pi attempt ended after a tool failure." : void 0,
+      outcome
+    );
+  }
+  beginTurn(turnIndex) {
+    if (!this.root) return;
+    if (this.turn) this.closeTurn("Interrupted by the next Pi turn.", "ERROR");
+    this.counters.turns += 1;
+    this.turnIndex = turnIndex;
+    this.turn = this.startObservation(
+      "pi.turn",
+      { metadata: { "pi.turn.index": turnIndex }, version: TRACE_SCHEMA_VERSION },
+      { asType: "span", parent: this.attempt ?? this.root }
+    );
+  }
+  finishTurn(turnIndex, result) {
+    if (!this.turn) return;
+    this.closeGeneration("Turn ended without a finalized assistant message.");
+    this.closeTools("Tool span ended when the Pi turn finished.");
+    const mismatched = this.turnIndex !== turnIndex;
+    const outcome = classifyOutcome(result.message);
+    this.turn.update({
+      metadata: {
+        "pi.turn.index": this.turnIndex ?? turnIndex,
+        "pi.turn.tool_result_count": result.toolResultCount,
+        ...result.message.stopReason ? { "pi.turn.stop_reason": result.message.stopReason } : {}
+      },
+      ...mismatched && outcome === "success" ? {
+        level: "WARNING",
+        statusMessage: `Turn ${turnIndex} ended while turn ${this.turnIndex} was active.`
+      } : severityForOutcome(outcome, result.message.errorMessage)
+    });
+    this.turn.end();
+    this.turn = void 0;
+    this.turnIndex = void 0;
+  }
+  beginGeneration(input = {}) {
+    if (!this.root) return;
+    this.closeGeneration("Interrupted by the next provider request.");
+    if (this.unresolvedToolErrors > 0) {
+      this.counters.recoveredErrors += this.unresolvedToolErrors;
+      this.unresolvedToolErrors = 0;
+    }
+    this.counters.generations += 1;
+    const requestMetadata = {
+      ...input.payloadStage ? { "pi.request.payload_stage": input.payloadStage } : {},
+      ...input.model?.provider ? { "pi.request.provider": input.model.provider } : {},
+      ...input.model?.id ? { "pi.request.model": input.model.id } : {},
+      ...input.model?.api ? { "pi.request.api": input.model.api } : {},
+      ...input.thinkingLevel ? { "pi.request.thinking_level": input.thinkingLevel } : {}
+    };
+    const observation = this.startObservation(
+      "pi.llm",
+      {
+        ...input.payload !== void 0 ? { input: this.capture(input.payload) } : {},
+        ...input.model?.id ? { model: input.model.id } : {},
+        ...input.thinkingLevel ? { modelParameters: { thinking_level: input.thinkingLevel } } : {},
+        ...Object.keys(requestMetadata).length > 0 ? { metadata: requestMetadata } : {},
+        version: TRACE_SCHEMA_VERSION
+      },
+      {
+        asType: "generation",
+        parent: this.turn ?? this.attempt ?? this.root,
+        ...input.startedAt === void 0 ? {} : { startTime: new Date(input.startedAt) }
+      }
+    );
+    this.generation = {
+      observation,
+      requestMetadata,
+      statuses: [],
+      headers: {}
+    };
+  }
+  recordProviderResponse(status, headers = {}) {
+    if (!this.generation) return;
+    this.generation.statuses.push(status);
+    Object.assign(this.generation.headers, allowlistedResponseHeaders(headers));
+  }
+  markGenerationFirstOutput(timestamp = Date.now()) {
+    if (this.generation && this.generation.completionStartTime === void 0) {
+      this.generation.completionStartTime = timestamp;
+    }
+  }
+  markGenerationEnd(endTime = Date.now()) {
+    if (this.generation && this.generation.endTime === void 0) {
+      this.generation.endTime = endTime;
+    }
+  }
+  finishAssistant(message) {
+    if (message.role !== "assistant") return;
+    this.lastAssistant = message;
+    this.lastOutput = this.capture(message.content);
+    if (!this.generation) return;
+    const state = this.generation;
+    const usageDetails = numericRecord({
+      input: message.usage?.input,
+      output: message.usage?.output,
+      cache_read_input_tokens: message.usage?.cacheRead,
+      cache_creation_input_tokens: message.usage?.cacheWrite,
+      total: message.usage?.totalTokens
+    });
+    const costDetails = positiveNumericRecord({
+      input: message.usage?.cost?.input,
+      output: message.usage?.cost?.output,
+      cache_read: message.usage?.cost?.cacheRead,
+      cache_write: message.usage?.cost?.cacheWrite,
+      total: message.usage?.cost?.total
+    });
+    const outcome = classifyOutcome(message);
+    const responseModel = message.responseModel ?? message.model;
+    const httpMetadata = generationHttpMetadata(state);
+    const recoveredStatuses = state.statuses.filter((status) => status >= 400).length;
+    if (outcome === "success" && recoveredStatuses > 0) {
+      this.counters.recoveredErrors += recoveredStatuses;
+    }
+    state.observation.update({
+      output: this.lastOutput,
+      ...state.completionStartTime !== void 0 ? { completionStartTime: new Date(state.completionStartTime) } : {},
+      ...responseModel ? { model: responseModel } : {},
+      ...Object.keys(usageDetails).length > 0 ? { usageDetails } : {},
+      ...Object.keys(costDetails).length > 0 ? { costDetails } : {},
+      metadata: {
+        ...state.requestMetadata,
+        ...httpMetadata,
+        ...message.provider ? { "pi.provider": message.provider, "pi.response.provider": message.provider } : {},
+        ...message.api ? { "pi.response.api": message.api } : {},
+        ...responseModel ? { "pi.response.model": responseModel } : {},
+        ...message.responseId ? { "pi.response.id": message.responseId } : {},
+        ...message.responseModel && message.model && message.responseModel !== message.model ? { "pi.requested_model": message.model } : {},
+        ...message.stopReason ? { "pi.stop_reason": message.stopReason } : {},
+        ...finiteNumber(message.usage?.reasoning) ? { "pi.usage.reasoning_tokens": message.usage.reasoning } : {},
+        ...finiteNumber(message.usage?.cacheWrite1h) ? { "pi.usage.cache_write_1h_tokens": message.usage.cacheWrite1h } : {}
+      },
+      ...severityForOutcome(outcome, message.errorMessage)
+    });
+    state.observation.end(state.endTime);
+    this.generation = void 0;
+  }
+  beginTool(toolCallId, toolName, args, startedAt = Date.now()) {
+    if (!this.root) return;
+    this.counters.tools += 1;
+    if (this.duplicateToolIds.has(toolCallId)) {
+      this.counters.toolErrors += 1;
+      const duplicate = this.startToolObservation(toolCallId, toolName, args);
+      duplicate.update({
+        level: "ERROR",
+        statusMessage: "Duplicate tool call ID cannot be correlated safely."
+      });
+      duplicate.end();
+      return;
+    }
+    const existing = this.tools.get(toolCallId);
+    if (existing) {
+      existing.observation.update({
+        level: "ERROR",
+        statusMessage: "Duplicate tool execution started."
+      });
+      existing.observation.end();
+      this.tools.delete(toolCallId);
+      this.counters.toolErrors += 2;
+      const duplicate = this.startToolObservation(toolCallId, toolName, args);
+      duplicate.update({
+        level: "ERROR",
+        statusMessage: "Duplicate tool call ID cannot be correlated safely."
+      });
+      duplicate.end();
+      this.duplicateToolIds.add(toolCallId);
+      return;
+    }
+    this.tools.set(toolCallId, {
+      observation: this.startToolObservation(toolCallId, toolName, args),
+      startedAt,
+      progressUpdates: 0
+    });
+  }
+  recordToolInput(toolCallId, input) {
+    if (input === void 0 || this.duplicateToolIds.has(toolCallId)) return;
+    this.tools.get(toolCallId)?.observation.update({ input: this.capture(input) });
+  }
+  recordToolProgress(toolCallId, timestamp = Date.now()) {
+    const tool = this.tools.get(toolCallId);
+    if (!tool) return;
+    tool.progressUpdates += 1;
+    tool.firstProgressAt ??= timestamp;
+  }
+  finishTool(toolCallId, result) {
+    if (this.duplicateToolIds.has(toolCallId)) return;
+    const tool = this.tools.get(toolCallId);
+    if (!tool) return;
+    if (result.isError) {
+      this.counters.toolErrors += 1;
+      this.unresolvedToolErrors += 1;
+    }
+    tool.observation.update({
+      output: this.capture({ content: result.content, details: result.details }),
+      metadata: {
+        "pi.tool.progress_update_count": tool.progressUpdates,
+        ...tool.firstProgressAt !== void 0 ? {
+          "pi.tool.time_to_first_progress_ms": Math.max(0, tool.firstProgressAt - tool.startedAt)
+        } : {}
+      },
+      ...result.isError ? { level: "ERROR", statusMessage: "Pi tool execution failed." } : {}
+    });
+    tool.observation.end();
+    this.tools.delete(toolCallId);
+  }
+  beginCompaction(input) {
+    if (!this.root) return;
+    this.closeCompaction("Interrupted by another Pi compaction.");
+    this.counters.compactions += 1;
+    this.compaction = {
+      observation: this.startObservation(
+        "pi.compaction",
+        {
+          metadata: {
+            "pi.compaction.reason": input.reason,
+            "pi.compaction.will_retry": input.willRetry,
+            ...finiteNumber(input.tokensBefore) ? { "pi.compaction.tokens_before": input.tokensBefore } : {},
+            "pi.compaction.messages_to_summarize": input.messagesToSummarize,
+            "pi.compaction.turn_prefix_messages": input.turnPrefixMessages,
+            "pi.compaction.branch_entries": input.branchEntries,
+            "pi.compaction.is_split_turn": input.isSplitTurn
+          },
+          version: TRACE_SCHEMA_VERSION
+        },
+        { asType: "span", parent: this.root }
+      )
+    };
+  }
+  finishCompaction(input) {
+    if (!this.compaction) return;
+    const details = structuralCompactionDetails(input.details);
+    const usage = numericRecord({
+      input: input.usage?.input,
+      output: input.usage?.output,
+      cache_read: input.usage?.cacheRead,
+      cache_write: input.usage?.cacheWrite,
+      total: input.usage?.totalTokens
+    });
+    const cost = positiveNumericRecord({
+      input: input.usage?.cost?.input,
+      output: input.usage?.cost?.output,
+      cache_read: input.usage?.cost?.cacheRead,
+      cache_write: input.usage?.cost?.cacheWrite,
+      total: input.usage?.cost?.total
+    });
+    this.compaction.observation.update({
+      metadata: {
+        "pi.compaction.reason": input.reason,
+        "pi.compaction.will_retry": input.willRetry,
+        "pi.compaction.from_extension": input.fromExtension,
+        ...finiteNumber(input.tokensBefore) ? { "pi.compaction.tokens_before": input.tokensBefore } : {},
+        ...details,
+        ...prefixRecord("pi.compaction.usage", usage),
+        ...prefixRecord("pi.compaction.cost", cost)
+      }
+    });
+    this.compaction.observation.end();
+    this.compaction = void 0;
+  }
+  settle(snapshot) {
+    this.closeActiveTrace(void 0, snapshot);
+  }
+  interrupt(statusMessage, snapshot) {
+    this.closeActiveTrace(statusMessage, snapshot, "interrupted");
+  }
+  dispose(statusMessage = "Pi session ended before the active trace settled.", snapshot) {
+    this.closeActiveTrace(statusMessage, snapshot, "interrupted");
+  }
+  closeActiveTrace(statusMessage, snapshot, forcedOutcome) {
+    this.closeTurn(statusMessage ?? "Pi turn ended when the agent run settled.");
+    this.closeAttempt(void 0, statusMessage, forcedOutcome ?? "interrupted");
+    this.closeCompaction(statusMessage ?? "Pi compaction ended when the agent run settled.");
+    if (!this.root) return;
+    const baseOutcome = forcedOutcome ?? this.lastAttemptOutcome ?? classifyOutcome(this.lastAssistant);
+    const recoveredErrorCount = this.counters.recoveredErrors + (baseOutcome === "success" ? this.counters.failedAttempts : 0);
+    const traceOutcome = baseOutcome === "success" && recoveredErrorCount > 0 ? "recovered_success" : baseOutcome;
+    const finalMetadata = {
+      "pi.trace.schema_version": Number(TRACE_SCHEMA_VERSION),
+      "pi.trace.outcome": traceOutcome,
+      ...this.lastAssistant?.stopReason ? { "pi.trace.stop_reason": this.lastAssistant.stopReason } : {},
+      "pi.trace.attempt_count": this.counters.attempts,
+      "pi.trace.turn_count": this.counters.turns,
+      "pi.trace.generation_count": this.counters.generations,
+      "pi.trace.tool_count": this.counters.tools,
+      "pi.trace.tool_error_count": this.counters.toolErrors,
+      "pi.trace.compaction_count": this.counters.compactions,
+      "pi.trace.recovered_error_count": recoveredErrorCount,
+      ...snapshotMetadata("start", this.startSnapshot),
+      ...snapshotMetadata("end", snapshot)
+    };
+    const finalAttributes = {
+      ...this.lastOutput !== void 0 ? { output: this.lastOutput } : {},
+      metadata: finalMetadata,
+      ...severityForOutcome(baseOutcome, statusMessage ?? this.lastAssistant?.errorMessage)
+    };
+    this.root.update(finalAttributes);
+    this.root.updateTrace?.({
+      ...this.lastOutput !== void 0 ? { output: this.lastOutput } : {},
+      metadata: finalMetadata,
+      version: TRACE_SCHEMA_VERSION
+    });
+    this.root.end();
+    this.root = void 0;
+    this.lastOutput = void 0;
+    this.lastAssistant = void 0;
+    this.lastAttemptOutcome = void 0;
+    this.unresolvedToolErrors = 0;
+    this.duplicateToolIds.clear();
+    this.startSnapshot = void 0;
+  }
+  closeAttempt(message, statusMessage, forcedOutcome) {
+    if (!this.attempt) return;
+    this.closeTurn(statusMessage ?? "Pi turn ended when the attempt finished.");
+    const outcome = forcedOutcome ?? classifyOutcome(message);
+    if (outcome === "error") this.counters.failedAttempts += 1;
+    this.lastAttemptOutcome = outcome;
+    this.attempt.update({
+      ...message?.content !== void 0 ? { output: this.capture(message.content) } : {},
+      metadata: {
+        "pi.attempt.index": this.attemptIndex ?? Math.max(0, this.counters.attempts - 1),
+        "pi.attempt.outcome": outcome,
+        ...message?.stopReason ? { "pi.attempt.stop_reason": message.stopReason } : {}
+      },
+      ...severityForOutcome(outcome, statusMessage ?? message?.errorMessage)
+    });
+    this.attempt.end();
+    this.attempt = void 0;
+    this.attemptIndex = void 0;
+    this.unresolvedToolErrors = 0;
+  }
+  startToolObservation(toolCallId, toolName, args) {
+    return this.startObservation(
+      `pi.tool.${toolName}`,
+      {
+        ...args !== void 0 ? { input: this.capture(args) } : {},
+        metadata: { "pi.tool.call_id": toolCallId, "pi.tool.name": toolName },
+        version: TRACE_SCHEMA_VERSION
+      },
+      { asType: "tool", parent: this.turn ?? this.attempt ?? this.root }
+    );
+  }
+  closeTurn(statusMessage, generationLevel = "WARNING") {
+    this.closeGeneration(statusMessage, generationLevel);
+    this.closeTools(statusMessage);
+    if (!this.turn) return;
+    this.turn.update({ level: "WARNING", statusMessage });
+    this.turn.end();
+    this.turn = void 0;
+    this.turnIndex = void 0;
+  }
+  closeTools(statusMessage) {
+    for (const tool of this.tools.values()) {
+      tool.observation.update({
+        level: "WARNING",
+        statusMessage,
+        metadata: {
+          "pi.tool.progress_update_count": tool.progressUpdates,
+          ...tool.firstProgressAt !== void 0 ? {
+            "pi.tool.time_to_first_progress_ms": Math.max(0, tool.firstProgressAt - tool.startedAt)
+          } : {}
+        }
+      });
+      tool.observation.end();
+    }
+    this.tools.clear();
+  }
+  closeGeneration(statusMessage, level = "ERROR") {
+    if (!this.generation) return;
+    this.generation.observation.update({
+      level,
+      statusMessage,
+      metadata: {
+        ...this.generation.requestMetadata,
+        ...generationHttpMetadata(this.generation)
+      }
+    });
+    this.generation.observation.end(this.generation.endTime);
+    this.generation = void 0;
+  }
+  closeCompaction(statusMessage) {
+    if (!this.compaction) return;
+    this.compaction.observation.update({ level: "WARNING", statusMessage });
+    this.compaction.observation.end();
+    this.compaction = void 0;
+  }
+  capture(value) {
+    return this.context.captureContent ? sanitizeTraceValue(value) : CONTENT_DISABLED;
+  }
+};
+function normalizeTraceName(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : "pi.trace";
+}
+function traceTags(customTags, gitTag) {
+  const tags = ["pi", ...gitTag ? [gitTag] : [], ...customTags ?? []];
+  return [...new Set(tags.map(sanitizeTraceTag).filter((tag) => tag !== void 0))];
+}
+function sanitizeTraceTag(value) {
+  if (typeof value !== "string" || !value.trim()) return void 0;
+  const sanitized = sanitizeTraceValue(value.trim());
+  return typeof sanitized === "string" && sanitized.trim() ? sanitized.trim() : void 0;
+}
+function customTraceMetadata(metadata) {
+  if (!metadata) return {};
+  const sanitized = sanitizeTraceValue(metadata);
+  if (!sanitized || typeof sanitized !== "object" || Array.isArray(sanitized)) return {};
+  return Object.fromEntries(Object.entries(sanitized).filter(([key]) => !key.startsWith("pi.")));
+}
+function generationHttpMetadata(state) {
+  const finalStatus = state.statuses.at(-1);
+  return {
+    ...state.statuses.length > 0 ? {
+      "http.response.status_codes": [...state.statuses],
+      "http.response.status_code": finalStatus,
+      "http.response.attempt_count": state.statuses.length,
+      "http.response.retry_count": Math.max(0, state.statuses.length - 1)
+    } : {},
+    ...Object.keys(state.headers).length > 0 ? { "http.response.headers": { ...state.headers } } : {}
+  };
+}
+function allowlistedResponseHeaders(headers) {
+  const output = {};
+  for (const [rawName, rawValue] of Object.entries(headers)) {
+    const name = rawName.toLowerCase();
+    if (!ALLOWED_RESPONSE_HEADERS.has(name) || typeof rawValue !== "string") continue;
+    output[name] = truncateString2(rawValue, MAX_HEADER_VALUE_LENGTH);
+  }
+  return output;
+}
+function structuralCompactionDetails(details) {
+  if (!details || typeof details !== "object" || Array.isArray(details)) return {};
+  const record = details;
+  return {
+    ...Array.isArray(record.readFiles) ? { "pi.compaction.read_file_count": record.readFiles.length } : {},
+    ...Array.isArray(record.modifiedFiles) ? { "pi.compaction.modified_file_count": record.modifiedFiles.length } : {}
+  };
+}
+function snapshotMetadata(prefix, snapshot) {
+  if (!snapshot) return {};
+  return {
+    ...snapshot.leafId ? { [`pi.trace.${prefix}_leaf_id`]: snapshot.leafId } : {},
+    ...snapshot.contextUsage ? {
+      ...finiteNumber(snapshot.contextUsage.tokens) ? { [`pi.trace.${prefix}_context_tokens`]: snapshot.contextUsage.tokens } : {},
+      [`pi.trace.${prefix}_context_window`]: snapshot.contextUsage.contextWindow,
+      ...finiteNumber(snapshot.contextUsage.percent) ? { [`pi.trace.${prefix}_context_percent`]: snapshot.contextUsage.percent } : {}
+    } : {}
+  };
+}
+function classifyOutcome(message) {
+  if (message?.role !== "assistant") return "interrupted";
+  if (message.stopReason === "error" || message.errorMessage) return "error";
+  if (message.stopReason === "aborted") return "aborted";
+  if (message.stopReason === "length") return "length";
+  return "success";
+}
+function severityForOutcome(outcome, statusMessage) {
+  if (outcome === "success") return {};
+  if (outcome === "error") {
+    return {
+      level: "ERROR",
+      statusMessage: statusMessage ?? "The Pi operation failed."
+    };
+  }
+  return {
+    level: "WARNING",
+    statusMessage: statusMessage ?? (outcome === "aborted" ? "The Pi operation was aborted." : outcome === "length" ? "The model reached its output limit." : "The Pi operation was interrupted.")
+  };
+}
+function prefixRecord(prefix, values) {
+  return Object.fromEntries(Object.entries(values).map(([key, value]) => [`${prefix}.${key}`, value]));
+}
+function truncateString2(value, maxBytes) {
+  const boundedPrefix = value.slice(0, maxBytes);
+  if (boundedPrefix.length === value.length && byteLength2(boundedPrefix) <= maxBytes) {
+    return boundedPrefix;
+  }
+  const suffix = "\u2026 [truncated]";
+  const target = Math.max(0, maxBytes - byteLength2(suffix) - 2);
+  let bytes = 0;
+  let output = "";
+  for (const character of boundedPrefix) {
+    const size = byteLength2(character);
+    if (bytes + size > target) break;
+    output += character;
+    bytes += size;
+  }
+  return `${output}${suffix}`;
+}
+function byteLength2(value) {
+  return Buffer.byteLength(value, "utf8");
+}
+function numericRecord(values) {
+  return Object.fromEntries(
+    Object.entries(values).filter((entry) => finiteNumber(entry[1]))
+  );
+}
+function positiveNumericRecord(values) {
+  return Object.fromEntries(
+    Object.entries(values).filter((entry) => finiteNumber(entry[1]) && entry[1] > 0)
+  );
+}
+function finiteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function hasItems(value) {
+  return Array.isArray(value) ? value.length > 0 : value !== void 0;
+}
+function emptyCounters() {
+  return {
+    attempts: 0,
+    turns: 0,
+    generations: 0,
+    tools: 0,
+    toolErrors: 0,
+    compactions: 0,
+    recoveredErrors: 0,
+    failedAttempts: 0
+  };
+}
+
+// src/pi-session.ts
+function createPiLangfuseSession(runtime, options = {}) {
+  const sessionOptions = snapshotSessionOptions(options);
+  return createPiLangfuseSessionController({
+    resolveSession: async () => ({ runtime, options: sessionOptions })
+  });
+}
+function createPiLangfuseSessionController(options) {
+  let binding;
+  let runtimeForShutdown;
+  let ownerRegistration;
+  let pendingInitialization;
+  const outstandingInitializations = /* @__PURE__ */ new Set();
+  let disposePromise;
+  let disposed = false;
+  let sessionGeneration = 0;
+  let requestId;
+  let requestIdRevision = 0;
+  let nextAttemptReason;
+  let lastSnapshot;
+  let pendingProviderGeneration;
+  const controller = {
+    extension(pi) {
+      if (disposed) throw new Error("A disposed Pi Langfuse session controller cannot be bound.");
+      registerHooks(pi);
+    },
+    setRequestId(value) {
+      requestId = normalizeOptionalString(value);
+      requestIdRevision += 1;
+    },
+    dispose() {
+      if (disposePromise) return disposePromise;
+      disposed = true;
+      const initializations = invalidateAllInitializations("disposed");
+      ownerRegistration = void 0;
+      sessionGeneration += 1;
+      closeBinding(binding, "Pi Langfuse session controller was disposed.", lastSnapshot);
+      runtimeForShutdown = void 0;
+      disposePromise = joinInitializations(initializations);
+      return disposePromise;
+    },
+    get active() {
+      return binding !== void 0;
+    },
+    get runtime() {
+      return binding?.runtime;
+    },
+    async flush() {
+      const runtime = binding?.runtime;
+      if (!runtime) throw new Error("Langfuse tracing is not enabled for this session.");
+      await runtime.flush();
+    }
+  };
+  function closeBinding(target, statusMessage, snapshot) {
+    if (!target) return;
+    const wasCurrent = binding === target;
+    if (wasCurrent) {
+      binding = void 0;
+      pendingProviderGeneration = void 0;
+    }
+    target.releaseRuntime();
+    target.recorder.dispose(statusMessage, snapshot);
+    if (wasCurrent) nextAttemptReason = void 0;
+  }
+  function invalidatePendingInitialization(reason) {
+    if (!pendingInitialization) return;
+    pendingInitialization.current = false;
+    pendingInitialization.reason = reason;
+    pendingInitialization = void 0;
+  }
+  function invalidateAllInitializations(reason) {
+    const initializations = [...outstandingInitializations];
+    for (const initialization of initializations) {
+      initialization.current = false;
+      initialization.reason = reason;
+    }
+    pendingInitialization = void 0;
+    return initializations;
+  }
+  function createPendingInitialization() {
+    let complete;
+    const completion = new Promise((resolve) => {
+      complete = resolve;
+    });
+    const initialization = { current: true, completion, complete };
+    outstandingInitializations.add(initialization);
+    return initialization;
+  }
+  async function joinInitializations(initializations) {
+    const results = await Promise.all(initializations.map(({ completion }) => completion));
+    const errors = results.flatMap((result) => result.ok ? [] : [result.error]);
+    if (errors.length === 1) throw errors[0];
+    if (errors.length > 1) throw new AggregateError(errors, "Pi Langfuse session initialization cleanup failed.");
+  }
+  async function initializeSession(registration, initialization, ctx) {
+    const generation = ++sessionGeneration;
+    closeBinding(binding, "Pi session was replaced before shutdown completed.", lastSnapshot);
+    lastSnapshot = contextSnapshot(ctx);
+    nextAttemptReason = void 0;
+    options.onSessionStart?.();
+    const isCurrent = () => !disposed && initialization.current && ownerRegistration === registration && generation === sessionGeneration;
+    let resolved;
+    try {
+      resolved = await options.resolveSession(ctx, isCurrent);
+    } catch (error) {
+      if (isCurrent()) options.onInitializationError?.(error, ctx);
+      return;
+    }
+    if (!isCurrent()) {
+      const reason = initialization.reason ?? "replaced";
+      if (resolved && options.shutdownRuntimeOnQuit && reason !== "quit" && reason !== "disposed" && (!runtimeForShutdown || runtimeForShutdown.closed)) {
+        runtimeForShutdown = resolved.runtime;
+      }
+      await resolved?.releaseIfStale?.(reason);
+      return;
+    }
+    if (!resolved) {
+      options.onSessionUnavailable?.();
+      return;
+    }
+    try {
+      const internal = getLangfuseRuntimeInternal(resolved.runtime);
+      const recorderOptions = createRecorderOptions(ctx, resolved.options);
+      const recorder = new TraceRecorder(internal.backend, recorderOptions);
+      const nextBinding = {};
+      const releaseRuntime = internal.registerSession((statusMessage) => {
+        closeBinding(nextBinding, statusMessage, lastSnapshot);
+      });
+      Object.assign(nextBinding, { registration, recorder, runtime: resolved.runtime, releaseRuntime });
+      if (!isCurrent()) {
+        releaseRuntime();
+        return;
+      }
+      binding = nextBinding;
+      if (options.shutdownRuntimeOnQuit) runtimeForShutdown = resolved.runtime;
+      options.onSessionReady?.(resolved);
+    } catch (error) {
+      if (isCurrent()) options.onInitializationError?.(error, ctx);
+    }
+  }
+  function registerHooks(pi) {
+    const registration = {};
+    const activeRecorder = () => activeRecorderFor(registration);
+    pi.on("session_start", async (_event, ctx) => {
+      if (disposed) return;
+      pendingProviderGeneration = void 0;
+      if (ownerRegistration && ownerRegistration !== registration) {
+        options.onInitializationError?.(
+          new Error("A Pi Langfuse session controller cannot manage multiple active Pi sessions."),
+          ctx
+        );
+        return;
+      }
+      invalidatePendingInitialization("replaced");
+      ownerRegistration = registration;
+      const initialization = createPendingInitialization();
+      pendingInitialization = initialization;
+      let result = { ok: true };
+      try {
+        await initializeSession(registration, initialization, ctx);
+      } catch (error) {
+        result = { ok: false, error };
+        throw error;
+      } finally {
+        initialization.complete(result);
+        outstandingInitializations.delete(initialization);
+        if (pendingInitialization === initialization) pendingInitialization = void 0;
+      }
+    });
+    pi.on("before_agent_start", async (event, ctx) => {
+      pendingProviderGeneration = void 0;
+      const active = ownerRegistration === registration ? binding : void 0;
+      if (!active || active.runtime.closed) return;
+      nextAttemptReason = void 0;
+      const git = await (options.resolveGitMetadata ? options.resolveGitMetadata(pi, ctx.cwd) : resolveGitMetadata((command, args, execOptions) => pi.exec(command, args, execOptions), ctx.cwd)).catch(() => void 0);
+      if (ownerRegistration !== registration || binding !== active || active.runtime.closed) return;
+      lastSnapshot = contextSnapshot(ctx);
+      startRootTrace((nextRequestId) => {
+        active.recorder.beginAgent({
+          prompt: event.prompt,
+          images: event.images,
+          model: ctx.model ? { provider: ctx.model.provider, id: ctx.model.id, api: ctx.model.api } : void 0,
+          git,
+          snapshot: lastSnapshot,
+          ...nextRequestId ? { requestId: nextRequestId } : {}
+        });
+      });
+    });
+    pi.on("agent_start", () => {
+      const recorder = activeRecorder();
+      if (!recorder) return;
+      recorder.beginAttempt(nextAttemptReason ? { reason: nextAttemptReason } : void 0);
+      nextAttemptReason = void 0;
+    });
+    pi.on("turn_start", (event, ctx) => {
+      const recorder = activeRecorder();
+      if (!recorder) return;
+      lastSnapshot = contextSnapshot(ctx);
+      ensureActiveRun(recorder, ctx, startRootTrace);
+      recorder.beginTurn(event.turnIndex);
+    });
+    pi.on("before_provider_request", (event, ctx) => {
+      if (!activeRecorder()) return;
+      lastSnapshot = contextSnapshot(ctx);
+      pendingProviderGeneration = {
+        startedAt: Date.now(),
+        payload: event.payload,
+        model: ctx.model ? { provider: ctx.model.provider, id: ctx.model.id, api: ctx.model.api } : void 0,
+        thinkingLevel: pi.getThinkingLevel(),
+        responses: []
+      };
+    });
+    pi.on("after_provider_response", (event) => {
+      pendingProviderGeneration?.responses.push({ status: event.status, headers: event.headers });
+    });
+    pi.on("message_start", (event, ctx) => {
+      if (event.message.role === "assistant") claimPendingProviderGeneration(ctx, activeRecorder());
+    });
+    pi.on("message_update", (event, ctx) => {
+      if (!isRealOutputDelta(event.assistantMessageEvent)) return;
+      const recorder = activeRecorder();
+      claimPendingProviderGeneration(ctx, recorder);
+      recorder?.markGenerationFirstOutput();
+    });
+    pi.on("message_end", (event, ctx) => {
+      if (event.message.role !== "assistant") return;
+      const recorder = activeRecorder();
+      claimPendingProviderGeneration(ctx, recorder);
+      recorder?.markGenerationEnd();
+    });
+    pi.on("turn_end", (event, ctx) => {
+      const recorder = activeRecorder();
+      if (!recorder) return;
+      if (event.message.role === "assistant") claimPendingProviderGeneration(ctx, recorder);
+      lastSnapshot = contextSnapshot(ctx);
+      if (event.message.role === "assistant") recorder.finishAssistant(event.message);
+      recorder.finishTurn(event.turnIndex, {
+        message: event.message,
+        toolResultCount: event.toolResults.length
+      });
+    });
+    pi.on("tool_execution_start", (event) => {
+      activeRecorder()?.beginTool(event.toolCallId, event.toolName, event.args);
+    });
+    pi.on("tool_execution_update", (event) => {
+      activeRecorder()?.recordToolProgress(event.toolCallId);
+    });
+    pi.on("tool_result", (event) => {
+      activeRecorder()?.recordToolInput(event.toolCallId, event.input);
+    });
+    pi.on("tool_execution_end", (event) => {
+      activeRecorder()?.finishTool(event.toolCallId, {
+        content: event.result.content,
+        details: event.result.details,
+        isError: event.isError
+      });
+    });
+    pi.on("agent_end", (event) => {
+      const message = findLastAssistant(event.messages);
+      activeRecorder()?.finishAttempt(message);
+    });
+    pi.on("session_before_compact", (event) => {
+      activeRecorder()?.beginCompaction({
+        reason: event.reason,
+        willRetry: event.willRetry,
+        tokensBefore: event.preparation.tokensBefore,
+        messagesToSummarize: event.preparation.messagesToSummarize.length,
+        turnPrefixMessages: event.preparation.turnPrefixMessages.length,
+        branchEntries: event.branchEntries.length,
+        isSplitTurn: event.preparation.isSplitTurn
+      });
+    });
+    pi.on("session_compact", (event) => {
+      const recorder = activeRecorder();
+      const entry = event.compactionEntry;
+      recorder?.finishCompaction({
+        reason: event.reason,
+        willRetry: event.willRetry,
+        fromExtension: event.fromExtension,
+        tokensBefore: entry.tokensBefore,
+        details: entry.details,
+        usage: entry.usage
+      });
+      if (event.willRetry && recorder?.hasActiveTrace()) nextAttemptReason = "post_compaction";
+    });
+    pi.on("agent_settled", (_event, ctx) => {
+      const recorder = activeRecorder();
+      if (!recorder) return;
+      lastSnapshot = contextSnapshot(ctx);
+      recorder.settle(lastSnapshot);
+      pendingProviderGeneration = void 0;
+      nextAttemptReason = void 0;
+    });
+    pi.on("session_shutdown", async (event, ctx) => {
+      if (ownerRegistration !== registration) return;
+      const initializations = invalidateAllInitializations(event.reason);
+      ownerRegistration = void 0;
+      const generation = ++sessionGeneration;
+      options.onSessionShutdown?.();
+      const active = binding?.registration === registration ? binding : void 0;
+      const runtime = active?.runtime ?? runtimeForShutdown;
+      lastSnapshot = active ? contextSnapshot(ctx) : lastSnapshot;
+      closeBinding(
+        active,
+        event.reason === "quit" ? "Pi shut down before the active trace settled." : `Pi session ended before settlement (${event.reason}).`,
+        lastSnapshot
+      );
+      let beforeDisposeFailure;
+      try {
+        await options.beforeSessionDispose?.();
+      } catch (error) {
+        beforeDisposeFailure = { error };
+      }
+      try {
+        await joinInitializations(initializations);
+        if (disposed || generation !== sessionGeneration) return;
+        if (beforeDisposeFailure) throw beforeDisposeFailure.error;
+        if (runtime) {
+          if (event.reason === "quit" && options.shutdownRuntimeOnQuit) await runtime.shutdown();
+          else if (options.flushOnReplacement) await runtime.flush();
+        }
+      } catch (error) {
+        if (!disposed && generation === sessionGeneration) options.onShutdownError?.(error, ctx);
+      }
+    });
+  }
+  function claimPendingProviderGeneration(ctx, recorder) {
+    const pending = pendingProviderGeneration;
+    if (!pending || !recorder) return;
+    pendingProviderGeneration = void 0;
+    ensureActiveRun(recorder, ctx, startRootTrace);
+    recorder.beginGeneration({
+      startedAt: pending.startedAt,
+      payload: pending.payload,
+      payloadStage: "before_provider_request",
+      model: pending.model,
+      thinkingLevel: pending.thinkingLevel
+    });
+    for (const response of pending.responses) recorder.recordProviderResponse(response.status, response.headers);
+  }
+  function startRootTrace(start) {
+    const revision = requestIdRevision;
+    const nextRequestId = requestId;
+    start(nextRequestId);
+    if (requestIdRevision === revision) requestId = void 0;
+  }
+  function activeRecorderFor(registration) {
+    return ownerRegistration === registration && binding?.registration === registration && !binding.runtime.closed ? binding.recorder : void 0;
+  }
+  return controller;
+}
+function createRecorderOptions(ctx, options = {}) {
+  const userId = normalizeUserId(options.userId);
+  return {
+    sessionId: normalizeOptionalString(options.sessionId) ?? ctx.sessionManager.getSessionId(),
+    ...userId ? { userId } : {},
+    cwd: ctx.cwd,
+    mode: ctx.mode,
+    captureContent: options.captureContent ?? true,
+    ...normalizeOptionalString(options.traceName) ? { traceName: normalizeOptionalString(options.traceName) } : {},
+    ...options.tags ? { tags: [...options.tags] } : {},
+    ...options.metadata ? { metadata: { ...options.metadata } } : {},
+    ...options.onTraceId ? { onTraceId: options.onTraceId } : {}
+  };
+}
+function snapshotSessionOptions(options) {
+  normalizeUserId(options.userId);
+  return {
+    ...options,
+    ...options.tags ? { tags: [...options.tags] } : {},
+    ...options.metadata ? { metadata: { ...options.metadata } } : {}
+  };
+}
+function ensureActiveRun(recorder, ctx, startRootTrace) {
+  if (!recorder.hasActiveTrace()) {
+    startRootTrace((nextRequestId) => {
+      recorder.beginAgent({
+        prompt: "[automatic continuation]",
+        model: ctx.model ? { provider: ctx.model.provider, id: ctx.model.id, api: ctx.model.api } : void 0,
+        snapshot: contextSnapshot(ctx),
+        ...nextRequestId ? { requestId: nextRequestId } : {}
+      });
+    });
+  }
+  if (!recorder.hasActiveAttempt()) recorder.beginAttempt();
+}
+function contextSnapshot(ctx) {
+  return {
+    leafId: typeof ctx.sessionManager.getLeafId === "function" ? ctx.sessionManager.getLeafId() : void 0,
+    contextUsage: ctx.getContextUsage()
+  };
+}
+function findLastAssistant(messages) {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+    if (message?.role === "assistant") return message;
+  }
+  return void 0;
+}
+function isRealOutputDelta(event) {
+  return (event.type === "text_delta" || event.type === "thinking_delta" || event.type === "toolcall_delta") && typeof event.delta === "string" && event.delta.length > 0;
+}
+function normalizeUserId(value) {
+  const userId = normalizeOptionalString(value);
+  if (userId && userId.length > 200) throw new Error("Langfuse userId must be at most 200 characters.");
+  return userId;
+}
+function normalizeOptionalString(value) {
+  if (typeof value !== "string" || !value.trim()) return void 0;
+  const sanitized = sanitizeTraceValue(value.trim());
+  return typeof sanitized === "string" && sanitized.trim() ? sanitized.trim() : void 0;
+}
+
+// src/langfuse.ts
+var FLUSH_ACTION = "Flush completed traces for this session";
+var SET_UP_ACTION = "Set up Langfuse for this Pi agent directory (restart required)";
+var UPDATE_ACTION = "Update Langfuse for this Pi agent directory (restart required)";
+var HELP_ACTION = "Show setup and privacy help";
+function createLangfuseExtension(dependencies = {}) {
+  const loadConfig = dependencies.loadConfig ?? loadLangfuseConfig;
+  const writeConfig = dependencies.writeConfig ?? writeLangfuseConfig;
+  const resolveInjectedGitMetadata = dependencies.resolveGitMetadata;
+  return function langfuse(pi) {
+    let activeConfig;
+    let loadingConfig;
+    let runtimeConfigForShutdown;
+    let shutdownConfig;
+    let configPath;
+    let initializationError;
+    let hasStoredConfig = false;
+    let configurationNotice;
+    let sessionGeneration = 0;
+    let menuController = new AbortController();
+    let configWriteQueue = Promise.resolve();
+    const tracing = createPiLangfuseSessionController({
+      onSessionStart() {
+        sessionGeneration += 1;
+        menuController.abort(new DOMException("Langfuse session replaced", "AbortError"));
+        menuController = new AbortController();
+        activeConfig = void 0;
+        loadingConfig = void 0;
+        shutdownConfig = void 0;
+        configPath = void 0;
+        initializationError = void 0;
+        hasStoredConfig = false;
+        configurationNotice = void 0;
+      },
+      onSessionShutdown() {
+        sessionGeneration += 1;
+        menuController.abort(new DOMException("Langfuse session shut down", "AbortError"));
+        shutdownConfig = activeConfig ?? runtimeConfigForShutdown ?? loadingConfig;
+        activeConfig = void 0;
+      },
+      async resolveSession(ctx, isCurrent) {
+        await configWriteQueue;
+        if (!isCurrent()) return void 0;
+        const result = await loadConfig();
+        if (!isCurrent()) return void 0;
+        configPath = result.path;
+        for (const warning of result.warnings) ctx.ui.notify(warning, "warning");
+        if (!result.ok) {
+          initializationError = formatConfigError(result);
+          ctx.ui.notify(initializationError, "warning");
+          return void 0;
+        }
+        hasStoredConfig = true;
+        loadingConfig = result.config;
+        const createBackend = dependencies.createBackend;
+        const ownsRuntime = createBackend !== void 0;
+        const runtime = createBackend ? createLangfuseRuntimeFromBackend(await createBackend(result.config)) : await (await import("./chunks/runtime-6MIKLWNJ.js")).createLangfuseRuntime({ config: result.config, env: false });
+        if (isCurrent() || !runtimeConfigForShutdown) runtimeConfigForShutdown = result.config;
+        if (isCurrent()) {
+          activeConfig = result.config;
+          loadingConfig = void 0;
+        }
+        return {
+          runtime,
+          releaseIfStale: async (reason) => {
+            if (ownsRuntime || reason === "quit") await runtime.shutdown();
+          },
+          options: {
+            ...result.config.userId ? { userId: result.config.userId } : {},
+            captureContent: result.config.captureContent
+          }
+        };
+      },
+      ...resolveInjectedGitMetadata ? { resolveGitMetadata: (_pi, cwd) => resolveInjectedGitMetadata(cwd) } : {},
+      onInitializationError(error, ctx) {
+        const config = loadingConfig;
+        loadingConfig = void 0;
+        initializationError = `Langfuse tracing could not start: ${formatError(error, config)}`;
+        ctx.ui.notify(initializationError, "warning");
+      },
+      beforeSessionDispose: async () => {
+        await configWriteQueue;
+      },
+      onShutdownError(error, ctx) {
+        ctx.ui.notify(`Langfuse shutdown export failed: ${formatError(error, shutdownConfig)}`, "error");
+      },
+      flushOnReplacement: true,
+      shutdownRuntimeOnQuit: true
+    });
+    async function showLangfuseMenu(ctx) {
+      if (!ctx.hasUI) {
+        ctx.ui.notify(formatNonInteractiveStatus(activeConfig, configPath, initializationError), "warning");
+        return;
+      }
+      const menuGeneration = sessionGeneration;
+      const menuSignal = menuController.signal;
+      const isCurrent = () => menuGeneration === sessionGeneration && !menuSignal.aborted;
+      const { defineMenu, runMenu } = await import("@narumitw/pi-tui-kit");
+      if (!isCurrent()) return;
+      const menu = defineMenu({
+        start: "main",
+        screens: {
+          main: () => ({
+            kind: "actions",
+            title: "Langfuse",
+            lines: formatMenuTitle(activeConfig, configPath, initializationError, configurationNotice).split("\n").slice(1),
+            items: [
+              ...tracing.active ? [{ id: "flush", label: FLUSH_ACTION, action: "flush" }] : [],
+              {
+                id: "configure",
+                label: hasStoredConfig ? UPDATE_ACTION : SET_UP_ACTION,
+                action: "configure"
+              },
+              { id: "help", label: HELP_ACTION, action: "help" }
+            ],
+            hint: "close"
+          })
+        },
+        actions: {
+          flush: async () => {
+            const menuConfig = activeConfig;
+            if (!tracing.active) {
+              ctx.ui.notify("Langfuse tracing is not enabled for this session.", "warning");
+              return { kind: "close" };
+            }
+            try {
+              await tracing.flush();
+              if (menuGeneration !== sessionGeneration) return { kind: "close" };
+              ctx.ui.notify("Langfuse traces flushed for this session.", "info");
+            } catch (error) {
+              if (menuGeneration !== sessionGeneration) return { kind: "close" };
+              ctx.ui.notify(`Langfuse flush failed: ${formatError(error, menuConfig)}`, "error");
+            }
+            return { kind: "close" };
+          },
+          configure: async () => {
+            const loaded = await loadConfig(configPath);
+            if (menuGeneration !== sessionGeneration) return { kind: "close" };
+            configPath = loaded.path;
+            const next = await promptForConfig(
+              ctx,
+              loaded.ok ? loaded.config : void 0,
+              () => menuGeneration === sessionGeneration
+            );
+            if (!next || menuGeneration !== sessionGeneration) return { kind: "close" };
+            try {
+              const write = configWriteQueue.then(() => writeConfig(next, loaded.path));
+              configWriteQueue = write.then(
+                () => void 0,
+                () => void 0
+              );
+              await write;
+              if (menuGeneration !== sessionGeneration) return { kind: "close" };
+              hasStoredConfig = true;
+              configurationNotice = "Saved; restart each Pi process to use it in subsequent sessions.";
+              ctx.ui.notify(
+                `Saved Langfuse config to ${loaded.path} for this Pi agent directory. Restart each Pi process to apply it to subsequent sessions.`,
+                "info"
+              );
+            } catch (error) {
+              if (menuGeneration !== sessionGeneration) return { kind: "close" };
+              ctx.ui.notify(`Failed to save Langfuse config: ${formatError(error, next)}`, "error");
+            }
+            return { kind: "close" };
+          },
+          help: async () => {
+            ctx.ui.notify(formatHelp(configPath), "info");
+            return { kind: "close" };
+          }
+        }
+      });
+      await runMenu(ctx, menu, {
+        getState: () => void 0,
+        signal: menuSignal,
+        isCurrent
+      });
+    }
+    pi.registerCommand("langfuse", {
+      description: "Open interactive Langfuse tracing controls",
+      handler: async (_args, ctx) => showLangfuseMenu(ctx)
+    });
+    tracing.extension(pi);
+  };
+}
+async function promptForConfig(ctx, current, isCurrent) {
+  const secretKey = await ctx.ui.input("Langfuse secret key (leave blank to keep existing):");
+  if (!isCurrent()) return void 0;
+  if (secretKey === void 0) {
+    ctx.ui.notify("Cancelled", "info");
+    return void 0;
+  }
+  const publicKey = await ctx.ui.input("Langfuse public key (leave blank to keep existing):");
+  if (!isCurrent()) return void 0;
+  if (publicKey === void 0) {
+    ctx.ui.notify("Cancelled", "info");
+    return void 0;
+  }
+  const baseUrl = await ctx.ui.input(
+    `Langfuse base URL (leave blank for default ${DEFAULT_BASE_URL}):`,
+    DEFAULT_BASE_URL
+  );
+  if (!isCurrent()) return void 0;
+  if (baseUrl === void 0) {
+    ctx.ui.notify("Cancelled", "info");
+    return void 0;
+  }
+  const patch = {
+    ...publicKey.trim() ? { publicKey: publicKey.trim() } : {},
+    ...secretKey.trim() ? { secretKey: secretKey.trim() } : {},
+    baseUrl: baseUrl.trim() || DEFAULT_BASE_URL
+  };
+  const normalized = normalizeLangfuseConfig({ ...current, ...patch });
+  if (!normalized.ok) {
+    ctx.ui.notify(`Invalid Langfuse config: ${normalized.reason}`, "error");
+    return void 0;
+  }
+  return patch;
+}
+function formatMenuTitle(activeConfig, configPath, initializationError, configurationNotice) {
+  const lines = ["Langfuse", "", "Current session:", `  Tracing: ${activeConfig ? "enabled" : "disabled"}`];
+  if (activeConfig) {
+    lines.push(
+      `  Endpoint: ${activeConfig.baseUrl}`,
+      `  Content capture: ${activeConfig.captureContent ? "enabled" : "disabled"}`
+    );
+  } else if (configurationNotice) {
+    lines.push("  State: tracing remains disabled until Pi restarts.");
+  } else if (initializationError) {
+    lines.push(`  Reason: ${initializationError}`);
+  }
+  lines.push(
+    "",
+    "Agent-directory configuration:",
+    `  Configuration: ${configPath ?? "unknown"}`,
+    "  Scope: this Pi agent directory; restart each Pi process to apply changes."
+  );
+  if (configurationNotice) lines.push(`  Pending: ${configurationNotice}`);
+  lines.push("", "What do you want to do?");
+  return lines.join("\n");
+}
+function formatNonInteractiveStatus(activeConfig, configPath, initializationError) {
+  return [
+    "/langfuse requires interactive UI.",
+    `Current session tracing: ${activeConfig ? "enabled" : "disabled"}`,
+    ...activeConfig ? [
+      `Endpoint: ${activeConfig.baseUrl}`,
+      `Content capture: ${activeConfig.captureContent ? "enabled" : "disabled"}`
+    ] : initializationError ? [`Reason: ${initializationError}`] : [],
+    `Configuration: ${configPath ?? "unknown"}`,
+    "Edit the private config manually, then restart each Pi process to apply it to subsequent sessions."
+  ].join("\n");
+}
+function formatHelp(configPath) {
+  return [
+    "Langfuse setup and privacy:",
+    "Run /langfuse in interactive Pi to manage tracing for the current session.",
+    `Configuration: ${configPath ?? "pi-langfuse.json"}`,
+    "The file belongs to this Pi agent directory; restart each Pi process after changing it.",
+    "Trace content may contain prompts, responses, tool arguments, tool results, and source code.",
+    "Git branch, commit, cwd, model, and usage remain in metadata when content capture is disabled.",
+    'Use "captureContent": false in the private config to export metadata only.'
+  ].join("\n");
+}
+function formatConfigError(result) {
+  const setupHint = result.reason.startsWith("Configuration file not found:") ? " Run /langfuse and choose Set up Langfuse." : "";
+  return `Langfuse tracing is disabled: ${result.reason}${setupHint}`;
+}
+function formatError(error, config) {
+  let message = error instanceof Error ? error.message : String(error);
+  const secrets = [config?.publicKey, config?.secretKey].filter((secret) => Boolean(secret)).sort((left, right) => right.length - left.length);
+  for (const secret of secrets) {
+    message = message.split(secret).join("[LANGFUSE_KEY_REDACTED]");
+  }
+  return message;
+}
+var langfuse_default = createLangfuseExtension();
+
+// src/public-api.ts
+async function createLangfuseRuntime(options = {}) {
+  const runtime = await import("./chunks/runtime-6MIKLWNJ.js");
+  return runtime.createLangfuseRuntime(options);
+}
+export {
+  createLangfuseRuntime,
+  createPiLangfuseSession,
+  langfuse_default as default
+};
+//# sourceMappingURL=index.js.map