@narumitw/pi-langfuse 0.50.1 → 0.50.2

package/dist/index.ts

@@ -0,0 +1,1478 @@
+// @generated by scripts/build-runtime.mjs; do not edit.
+// @ts-nocheck -- generated JavaScript uses a .ts extension for Pi's Jiti loader.
+
+// src/config.ts
+import { randomUUID } from "node:crypto";
+import { chmod, mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+var CONFIG_FILE_NAME = "pi-langfuse.json";
+var DEFAULT_BASE_URL = "https://us.cloud.langfuse.com";
+function langfuseConfigPath() {
+  return join(getAgentDir(), CONFIG_FILE_NAME);
+}
+var configSaveQueues = /* @__PURE__ */ new Map();
+function writeLangfuseConfig(patch, path = langfuseConfigPath()) {
+  const previous = configSaveQueues.get(path) ?? Promise.resolve();
+  const operation = previous.then(() => writeLangfuseConfigNow(patch, path));
+  const tail = operation.then(
+    () => void 0,
+    () => void 0
+  );
+  configSaveQueues.set(path, tail);
+  void tail.then(() => {
+    if (configSaveQueues.get(path) === tail) configSaveQueues.delete(path);
+  });
+  return operation;
+}
+async function writeLangfuseConfigNow(patch, path) {
+  const currentDocument = await readLangfuseDocumentForUpdate(path);
+  const normalized = normalizeLangfuseConfig({ ...currentDocument, ...patch });
+  if (!normalized.ok) throw new Error(normalized.reason);
+  const {
+    publicKey: _publicKey,
+    secretKey: _secretKey,
+    baseUrl: _baseUrl,
+    environment: _environment,
+    release: _release,
+    userId: _userId,
+    captureContent: _captureContent,
+    ...unknownFields
+  } = currentDocument;
+  const nextDocument = { ...unknownFields, ...normalized.config };
+  await mkdir(dirname(path), { recursive: true, mode: 448 });
+  const tempPath = `${path}.${process.pid}.${randomUUID()}.tmp`;
+  try {
+    await writeFile(tempPath, `${JSON.stringify(nextDocument, null, 2)}
+`, {
+      encoding: "utf8",
+      mode: 384
+    });
+    await chmod(tempPath, 384);
+    await rename(tempPath, path);
+    return normalized.config;
+  } catch (error) {
+    await rm(tempPath, { force: true }).catch(() => void 0);
+    throw error;
+  }
+}
+async function readLangfuseDocumentForUpdate(path) {
+  let parsed;
+  try {
+    parsed = JSON.parse(await readFile(path, "utf8"));
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") return {};
+    throw new Error(
+      `Cannot update ${CONFIG_FILE_NAME} because the existing file is malformed or unreadable; repair it first.`
+    );
+  }
+  const normalized = normalizeLangfuseConfig(parsed);
+  if (!normalized.ok) {
+    throw new Error(
+      `Cannot update ${CONFIG_FILE_NAME} because the existing file has invalid recognized fields; repair it first.`
+    );
+  }
+  return { ...parsed };
+}
+async function loadLangfuseConfig(path = langfuseConfigPath()) {
+  await configSaveQueues.get(path);
+  const warnings = [];
+  const permissionFailure = await ensurePrivatePermissions(path, warnings);
+  if (permissionFailure) {
+    return {
+      ok: false,
+      path,
+      warnings,
+      reason: `Refusing to load credentials: ${permissionFailure}`
+    };
+  }
+  let text;
+  try {
+    text = await readFile(path, "utf8");
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return { ok: false, path, warnings, reason: `Configuration file not found: ${path}` };
+    }
+    return {
+      ok: false,
+      path,
+      warnings,
+      reason: `Failed to read ${path}: ${formatError(error)}`
+    };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return {
+      ok: false,
+      path,
+      warnings,
+      reason: `Failed to parse ${path} as JSON; repair the file before retrying.`
+    };
+  }
+  const normalized = normalizeLangfuseConfig(parsed);
+  if (!normalized.ok) return { ok: false, path, warnings, reason: normalized.reason };
+  return { ok: true, config: normalized.config, path, warnings };
+}
+function normalizeLangfuseConfig(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return { ok: false, reason: "pi-langfuse.json must contain a JSON object." };
+  }
+  const input = value;
+  const publicKey = normalizeString(input.publicKey);
+  const secretKey = normalizeString(input.secretKey);
+  if (!publicKey) {
+    return { ok: false, reason: "pi-langfuse.json requires a literal publicKey string." };
+  }
+  if (!secretKey) {
+    return { ok: false, reason: "pi-langfuse.json requires a literal secretKey string." };
+  }
+  if (isInterpolation(publicKey)) {
+    return {
+      ok: false,
+      reason: "pi-langfuse.json publicKey must be literal; environment and command interpolation are not supported."
+    };
+  }
+  if (isInterpolation(secretKey)) {
+    return {
+      ok: false,
+      reason: "pi-langfuse.json secretKey must be literal; environment and command interpolation are not supported."
+    };
+  }
+  const rawBaseUrl = input.baseUrl === void 0 ? DEFAULT_BASE_URL : normalizeString(input.baseUrl);
+  if (!rawBaseUrl) {
+    return { ok: false, reason: "pi-langfuse.json baseUrl must be a non-empty string." };
+  }
+  const baseUrl = normalizeBaseUrl(rawBaseUrl);
+  if (!baseUrl) {
+    return {
+      ok: false,
+      reason: "pi-langfuse.json baseUrl must use HTTP or HTTPS without credentials, a query, or a fragment."
+    };
+  }
+  if (input.captureContent !== void 0 && typeof input.captureContent !== "boolean") {
+    return { ok: false, reason: "pi-langfuse.json captureContent must be a boolean." };
+  }
+  const environment = optionalString(input.environment, "environment");
+  if (!environment.ok) return environment;
+  if (environment.value && (environment.value.length > 40 || !/^(?!langfuse)[a-z0-9_-]+$/u.test(environment.value))) {
+    return {
+      ok: false,
+      reason: "pi-langfuse.json environment must be at most 40 lowercase letters, numbers, hyphens, or underscores and must not start with langfuse."
+    };
+  }
+  const release = optionalString(input.release, "release");
+  if (!release.ok) return release;
+  const userId = optionalString(input.userId, "userId");
+  if (!userId.ok) return userId;
+  if (userId.value && userId.value.length > 200) {
+    return { ok: false, reason: "pi-langfuse.json userId must be at most 200 characters." };
+  }
+  return {
+    ok: true,
+    config: {
+      publicKey,
+      secretKey,
+      baseUrl,
+      ...environment.value ? { environment: environment.value } : {},
+      ...release.value ? { release: release.value } : {},
+      ...userId.value ? { userId: userId.value } : {},
+      captureContent: input.captureContent ?? true
+    }
+  };
+}
+async function ensurePrivatePermissions(path, warnings) {
+  try {
+    const file = await stat(path);
+    if ((file.mode & 511) !== 384) {
+      await chmod(path, 384);
+      const repaired = await stat(path);
+      if ((repaired.mode & 511) !== 384) {
+        throw new Error(`permissions remained ${(repaired.mode & 511).toString(8)}`);
+      }
+      warnings.push(`Restricted ${path} permissions to 0600.`);
+    }
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") return void 0;
+    const failure = `Failed to enforce 0600 permissions for ${path}: ${formatError(error)}`;
+    warnings.push(failure);
+    return failure;
+  }
+  return void 0;
+}
+function normalizeBaseUrl(value) {
+  try {
+    const url = new URL(value);
+    if (url.protocol !== "http:" && url.protocol !== "https:") return void 0;
+    if (url.username || url.password || url.search || url.hash) return void 0;
+    return url.toString().replace(/\/+$/, "");
+  } catch {
+    return void 0;
+  }
+}
+function optionalString(value, name) {
+  if (value === void 0) return { ok: true };
+  const normalized = normalizeString(value);
+  return normalized ? { ok: true, value: normalized } : { ok: false, reason: `pi-langfuse.json ${name} must be a non-empty string.` };
+}
+function normalizeString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function isInterpolation(value) {
+  return value.startsWith("$") || value.startsWith("!");
+}
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
+}
+function formatError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// 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") {
+    const bounded = truncateString(value, Math.min(MAX_STRING_LENGTH, budget.remaining));
+    const redacted = bounded.replace(BASE64_DATA_URI, BASE64_DATA_URI_OMITTED);
+    return consume(redacted, 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;
+        }
+        budget.remaining -= keyBytes + 4;
+        const property = readProperty(record, key);
+        if (redactData && key === "data") {
+          output[key] = consume("[base64 omitted]", budget);
+        } else if (!property.ok) output[key] = consume("[unreadable property]", budget);
+        else output[key] = 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 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 = {
+      "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 } : {},
+      "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: "pi.trace",
+      sessionId: this.context.sessionId,
+      ...this.context.userId ? { userId: this.context.userId } : {},
+      version: TRACE_SCHEMA_VERSION,
+      input: traceInput,
+      metadata,
+      tags: ["pi", ...gitTag ? [gitTag] : []]
+    });
+  }
+  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 }
+    );
+    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");
+  }
+  async flush() {
+    await this.backend.forceFlush();
+  }
+  async shutdown(snapshot) {
+    this.closeActiveTrace("Pi shut down before the active trace settled.", snapshot, "interrupted");
+    await this.backend.shutdown();
+  }
+  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 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/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 createBackend = dependencies.createBackend ?? (async (config) => {
+    const { createProductionBackend } = await import("./chunks/runtime-NX5HM7IU.js");
+    return createProductionBackend(config);
+  });
+  return function langfuse(pi) {
+    const resolveGit = dependencies.resolveGitMetadata ?? ((cwd) => resolveGitMetadata((command, args, options) => pi.exec(command, args, options), cwd));
+    let recorder;
+    let activeConfig;
+    let configPath;
+    let initializationError;
+    let hasStoredConfig = false;
+    let configurationNotice;
+    let sessionGeneration = 0;
+    let menuController = new AbortController();
+    let configWriteQueue = Promise.resolve();
+    let nextAttemptReason;
+    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: [
+              ...recorder ? [{ 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 menuRecorder = recorder;
+            const menuConfig = activeConfig;
+            if (!menuRecorder) {
+              ctx.ui.notify("Langfuse tracing is not enabled for this session.", "warning");
+              return { kind: "close" };
+            }
+            try {
+              await menuRecorder.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: ${formatError2(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: ${formatError2(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)
+    });
+    pi.on("session_start", async (_event, ctx) => {
+      const generation = ++sessionGeneration;
+      menuController.abort(new DOMException("Langfuse session replaced", "AbortError"));
+      menuController = new AbortController();
+      recorder = void 0;
+      activeConfig = void 0;
+      configPath = void 0;
+      initializationError = void 0;
+      hasStoredConfig = false;
+      configurationNotice = void 0;
+      nextAttemptReason = void 0;
+      await configWriteQueue;
+      if (generation !== sessionGeneration) return;
+      const result = await loadConfig();
+      if (generation !== sessionGeneration) return;
+      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;
+      }
+      hasStoredConfig = true;
+      try {
+        const backend = await createBackend(result.config);
+        if (generation !== sessionGeneration) {
+          await backend.shutdown().catch(() => void 0);
+          return;
+        }
+        activeConfig = result.config;
+        recorder = new TraceRecorder(backend, {
+          sessionId: ctx.sessionManager.getSessionId(),
+          ...result.config.userId ? { userId: result.config.userId } : {},
+          cwd: ctx.cwd,
+          mode: ctx.mode,
+          captureContent: result.config.captureContent
+        });
+      } catch (error) {
+        if (generation !== sessionGeneration) return;
+        initializationError = `Langfuse tracing could not start: ${formatError2(error, result.config)}`;
+        ctx.ui.notify(initializationError, "warning");
+      }
+    });
+    pi.on("before_agent_start", async (event, ctx) => {
+      nextAttemptReason = void 0;
+      const activeRecorder = recorder;
+      if (!activeRecorder) return;
+      const git = await resolveGit(ctx.cwd).catch(() => void 0);
+      if (recorder !== activeRecorder) return;
+      activeRecorder.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: contextSnapshot(ctx)
+      });
+    });
+    pi.on("agent_start", () => {
+      if (!recorder) return;
+      recorder.beginAttempt(nextAttemptReason ? { reason: nextAttemptReason } : void 0);
+      nextAttemptReason = void 0;
+    });
+    pi.on("turn_start", (event, ctx) => {
+      if (!recorder) return;
+      ensureActiveRun(recorder, ctx);
+      recorder.beginTurn(event.turnIndex);
+    });
+    pi.on("before_provider_request", (event, ctx) => {
+      if (!recorder) return;
+      ensureActiveRun(recorder, ctx);
+      recorder.beginGeneration({
+        payload: event.payload,
+        payloadStage: "before_provider_request",
+        model: ctx.model ? { provider: ctx.model.provider, id: ctx.model.id, api: ctx.model.api } : void 0,
+        thinkingLevel: pi.getThinkingLevel()
+      });
+    });
+    pi.on("after_provider_response", (event) => {
+      recorder?.recordProviderResponse(event.status, event.headers);
+    });
+    pi.on("message_update", (event) => {
+      if (isRealOutputDelta(event.assistantMessageEvent)) recorder?.markGenerationFirstOutput();
+    });
+    pi.on("message_end", (event) => {
+      if (event.message.role === "assistant") recorder?.markGenerationEnd();
+    });
+    pi.on("turn_end", (event) => {
+      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) => {
+      recorder?.beginTool(event.toolCallId, event.toolName, event.args);
+    });
+    pi.on("tool_execution_update", (event) => {
+      recorder?.recordToolProgress(event.toolCallId);
+    });
+    pi.on("tool_result", (event) => {
+      recorder?.recordToolInput(event.toolCallId, event.input);
+    });
+    pi.on("tool_execution_end", (event) => {
+      recorder?.finishTool(event.toolCallId, {
+        content: event.result.content,
+        details: event.result.details,
+        isError: event.isError
+      });
+    });
+    pi.on("agent_end", (event) => {
+      const message = findLastAssistant(event.messages);
+      recorder?.finishAttempt(message);
+    });
+    pi.on("session_before_compact", (event) => {
+      recorder?.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 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) => {
+      recorder?.settle(contextSnapshot(ctx));
+      nextAttemptReason = void 0;
+    });
+    pi.on("session_shutdown", async (event, ctx) => {
+      const generation = ++sessionGeneration;
+      menuController.abort(new DOMException("Langfuse session shut down", "AbortError"));
+      const activeRecorder = recorder;
+      const shutdownConfig = activeConfig;
+      const pendingConfigWrite = configWriteQueue;
+      const shutdownSnapshot = activeRecorder ? contextSnapshot(ctx) : void 0;
+      recorder = void 0;
+      activeConfig = void 0;
+      await pendingConfigWrite;
+      if (!activeRecorder) return;
+      try {
+        if (event.reason === "quit") await activeRecorder.shutdown(shutdownSnapshot);
+        else {
+          activeRecorder.interrupt(
+            `Pi session ended before settlement (${event.reason}).`,
+            shutdownSnapshot
+          );
+          await activeRecorder.flush();
+        }
+      } catch (error) {
+        if (generation !== sessionGeneration) return;
+        ctx.ui.notify(
+          `Langfuse shutdown export failed: ${formatError2(error, shutdownConfig)}`,
+          "error"
+        );
+      }
+    });
+  };
+}
+function ensureActiveRun(recorder, ctx) {
+  if (!recorder.hasActiveTrace()) {
+    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)
+    });
+  }
+  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;
+}
+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;
+}
+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 formatError2(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();
+export {
+  langfuse_default as default
+};
+//# sourceMappingURL=index.ts.map