pi-langfuse 1.5.16 → 1.5.17

package/README.md

@@ -109,12 +109,38 @@ export LANGFUSE_CAPTURE_TOOL_IO=false
 export LANGFUSE_CAPTURE_SYSTEM_PROMPT=false
 export LANGFUSE_CAPTURE_CWD=false
 export LANGFUSE_CAPTURE_SOURCE_METADATA=false
+export LANGFUSE_CAPTURE_PATHS=false
 ```
 
 Source metadata remains off in every preset unless `LANGFUSE_CAPTURE_SOURCE_METADATA=true` is set explicitly.
+The same holds for absolute paths and `LANGFUSE_CAPTURE_PATHS`.
 
 All captured payloads are redacted before upload. The extension masks common API keys, bearer tokens, passwords, cookies, private keys, Langfuse keys, GitHub/npm/AWS-style tokens, and local absolute paths.
 
+### Absolute paths
+
+By default, local absolute paths (`/Users/...`, `/home/...`, `/tmp/...`, `C:\Users\...`) are
+replaced everywhere with a stable `[PATH_HASH:<12 hex chars>]` digest, so usernames and repository
+names never reach Langfuse. This applies to inputs, outputs, tool I/O, tool error messages, and the
+`cwd` metadata field. Opt in to see real paths in traces:
+
+```bash
+export LANGFUSE_CAPTURE_PATHS=true
+```
+
+Or persist it in `config.json`:
+
+```json
+{ "capture": { "LANGFUSE_CAPTURE_PATHS": "true" } }
+```
+
+Like `LANGFUSE_CAPTURE_SOURCE_METADATA`, this stays off in every privacy preset until it is set
+explicitly, and it only affects paths — secret masking (tokens, keys, cookies, passwords) is always
+on regardless. Note that `LANGFUSE_CAPTURE_CWD=false` is a different control: it drops the `cwd`
+metadata field entirely rather than changing how paths are rendered.
+
+`/langfuse-status` reports the current setting under `Capture: absolute paths`.
+
 ### Payload limits
 
 Before upload, payloads are shaped: strings are truncated and deeply nested or

package/README_CN.md

@@ -109,12 +109,36 @@ export LANGFUSE_CAPTURE_TOOL_IO=false
 export LANGFUSE_CAPTURE_SYSTEM_PROMPT=false
 export LANGFUSE_CAPTURE_CWD=false
 export LANGFUSE_CAPTURE_SOURCE_METADATA=false
+export LANGFUSE_CAPTURE_PATHS=false
 ```
 
 所有隐私预设默认都关闭源码元数据；只有显式设置 `LANGFUSE_CAPTURE_SOURCE_METADATA=true` 才会启用。
+绝对路径与 `LANGFUSE_CAPTURE_PATHS` 同理。
 
 所有被采集的负载在上传前仍会脱敏。扩展会隐藏常见 API key、Bearer token、密码、Cookie、私钥、Langfuse key、GitHub/npm/AWS 风格 token，并对本地绝对路径做 hash。
 
+### 绝对路径
+
+默认情况下，本地绝对路径（`/Users/...`、`/home/...`、`/tmp/...`、`C:\Users\...`）会在所有位置被替换为
+稳定的 `[PATH_HASH:<12 位十六进制>]` 摘要，因此用户名和仓库名不会进入 Langfuse。该规则作用于输入、输出、
+工具 I/O、工具错误信息以及 `cwd` 元数据字段。若希望在 trace 中看到真实路径，需要显式开启：
+
+```bash
+export LANGFUSE_CAPTURE_PATHS=true
+```
+
+也可以持久化到 `config.json`：
+
+```json
+{ "capture": { "LANGFUSE_CAPTURE_PATHS": "true" } }
+```
+
+与 `LANGFUSE_CAPTURE_SOURCE_METADATA` 一样，它在所有隐私预设中默认关闭，且只影响路径；密钥脱敏（token、key、
+Cookie、密码）始终生效。注意 `LANGFUSE_CAPTURE_CWD=false` 是另一个控制项——它会直接丢弃 `cwd` 元数据字段，
+而不是改变路径的呈现方式。
+
+`/langfuse-status` 会在 `Capture: absolute paths` 下显示当前设置。
+
 ### 负载上限
 
 上传前会对负载做整形：字符串会被截断，过深或过宽的结构会被裁剪。这些上限让 trace 保持精简，同时保护

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-langfuse",
-	"version": "1.5.16",
+	"version": "1.5.17",
 	"description": "Langfuse extension for Pi coding agent",
 	"repository": {
 		"type": "git",

package/src/capture-policy.ts

@@ -1,4 +1,4 @@
-import { hashPath, redactValue } from "./redaction.js";
+import { hashPath, redactValue, type RedactOptions } from "./redaction.js";
 
 export interface CapturePolicy {
   readonly captureInputs: boolean;
@@ -7,6 +7,17 @@ export interface CapturePolicy {
   readonly captureSystemPrompt: boolean;
   readonly captureCwd: boolean;
   readonly captureSourceMetadata: boolean;
+  /**
+   * Capture local absolute paths verbatim. Off in every preset, like
+   * `captureSourceMetadata`: paths are replaced with `[PATH_HASH:...]` unless
+   * `LANGFUSE_CAPTURE_PATHS` opts in explicitly.
+   */
+  readonly capturePaths: boolean;
+}
+
+/** Redaction options implied by a policy, so path rendering follows the same switch everywhere. */
+export function redactOptionsFor(policy: CapturePolicy): Partial<RedactOptions> {
+  return { redactPaths: !policy.capturePaths };
 }
 
 export type PrivacyPreset = "metadata-only" | "prompts-only" | "conversations" | "full-debug";
@@ -38,6 +49,7 @@ const PRESETS: Record<PrivacyPreset, CapturePolicy> = {
     captureSystemPrompt: false,
     captureCwd: false,
     captureSourceMetadata: false,
+    capturePaths: false,
   },
   "prompts-only": {
     captureInputs: true,
@@ -46,6 +58,7 @@ const PRESETS: Record<PrivacyPreset, CapturePolicy> = {
     captureSystemPrompt: false,
     captureCwd: false,
     captureSourceMetadata: false,
+    capturePaths: false,
   },
   conversations: {
     captureInputs: true,
@@ -54,6 +67,7 @@ const PRESETS: Record<PrivacyPreset, CapturePolicy> = {
     captureSystemPrompt: false,
     captureCwd: false,
     captureSourceMetadata: false,
+    capturePaths: false,
   },
   "full-debug": {
     captureInputs: true,
@@ -62,6 +76,7 @@ const PRESETS: Record<PrivacyPreset, CapturePolicy> = {
     captureSystemPrompt: true,
     captureCwd: true,
     captureSourceMetadata: false,
+    capturePaths: false,
   },
 };
 
@@ -72,6 +87,7 @@ const FLAG_TO_FIELD = {
   LANGFUSE_CAPTURE_SYSTEM_PROMPT: "captureSystemPrompt",
   LANGFUSE_CAPTURE_CWD: "captureCwd",
   LANGFUSE_CAPTURE_SOURCE_METADATA: "captureSourceMetadata",
+  LANGFUSE_CAPTURE_PATHS: "capturePaths",
 } as const;
 
 function parseFlag(value: string | undefined): boolean | undefined {
@@ -109,18 +125,20 @@ function redactMetadata(metadata: Record<string, unknown> | undefined, policy: C
     return undefined;
   }
 
+  const redactOptions = redactOptionsFor(policy);
   const output: Record<string, unknown> = {};
   for (const [key, value] of Object.entries(metadata)) {
     if (key === "cwd") {
       if (!policy.captureCwd) {
         continue;
       }
-      output[key] = typeof value === "string" && /^(?:\/|[A-Za-z]:[\\/]|\\\\)/.test(value)
-        ? hashPath(value)
-        : redactValue(value);
+      output[key] =
+        !policy.capturePaths && typeof value === "string" && /^(?:\/|[A-Za-z]:[\\/]|\\\\)/.test(value)
+          ? hashPath(value)
+          : redactValue(value, redactOptions);
       continue;
     }
-    output[key] = redactValue(value);
+    output[key] = redactValue(value, redactOptions);
   }
   return Object.keys(output).length > 0 ? output : undefined;
 }
@@ -129,24 +147,25 @@ export function applyCapturePolicy(
   payload: RawTelemetryPayload,
   policy: CapturePolicy = createCapturePolicy(),
 ): CapturedTelemetryPayload {
+  const redactOptions = redactOptionsFor(policy);
   const captured: CapturedTelemetryPayload = {
     metadata: redactMetadata(payload.metadata, policy),
   };
 
   if (policy.captureInputs && "input" in payload) {
-    captured.input = redactValue(payload.input);
+    captured.input = redactValue(payload.input, redactOptions);
   }
   if (policy.captureOutputs && "output" in payload) {
-    captured.output = redactValue(payload.output);
+    captured.output = redactValue(payload.output, redactOptions);
   }
   if (policy.captureToolIo && "toolInput" in payload) {
-    captured.toolInput = redactValue(payload.toolInput);
+    captured.toolInput = redactValue(payload.toolInput, redactOptions);
   }
   if (policy.captureToolIo && "toolOutput" in payload) {
-    captured.toolOutput = redactValue(payload.toolOutput);
+    captured.toolOutput = redactValue(payload.toolOutput, redactOptions);
   }
   if (policy.captureSystemPrompt && "systemPrompt" in payload) {
-    captured.systemPrompt = redactValue(payload.systemPrompt);
+    captured.systemPrompt = redactValue(payload.systemPrompt, redactOptions);
   }
 
   return captured;

package/src/commands.ts

@@ -75,7 +75,7 @@ function isPrivacyPreset(value: string | undefined): value is PrivacyPreset {
 }
 
 function inferPreset(policy: CapturePolicy): PrivacyPreset | "custom" {
-  const entries: Array<[PrivacyPreset, Omit<CapturePolicy, "captureSourceMetadata">]> = [
+  const entries: Array<[PrivacyPreset, Omit<CapturePolicy, "captureSourceMetadata" | "capturePaths">]> = [
     [
       "metadata-only",
       {
@@ -140,6 +140,7 @@ function describePolicy(policy: CapturePolicy) {
     `captureSystemPrompt: ${policy.captureSystemPrompt}`,
     `captureCwd: ${policy.captureCwd}`,
     `captureSourceMetadata: ${policy.captureSourceMetadata}`,
+    `capturePaths: ${policy.capturePaths}`,
   ].join("\n");
 }
 
@@ -218,6 +219,7 @@ function formatStatus(configPath: string, env: Record<string, string | undefined
     `  tool IO: ${flag(policy.captureToolIo)}`,
     `  system prompt: ${flag(policy.captureSystemPrompt)}`,
     `  cwd: ${flag(policy.captureCwd)}`,
+    `  absolute paths: ${flag(policy.capturePaths)}`,
     `Active run: ${hasActiveAgentObservation() ? "yes" : "no"}`,
     `Last error: ${lastErrorSummary()}`,
   ].join("\n");

package/src/handlers/tool.ts

@@ -12,7 +12,7 @@ import {
   getCapturePolicy,
   getLimits,
 } from "../utils.js";
-import { applyCapturePolicy } from "../capture-policy.js";
+import { applyCapturePolicy, redactOptionsFor } from "../capture-policy.js";
 import { redactString } from "../redaction.js";
 
 export async function startToolObservation(event: Record<string, unknown>) {
@@ -87,6 +87,7 @@ export async function finishToolObservation(event: Record<string, unknown>) {
     event;
 
   try {
+    const policy = getCapturePolicy();
     const shapedOutput = shapePayload(output, { maxString: getLimits().maxToolPayload });
     const captured = applyCapturePolicy(
       {
@@ -97,7 +98,7 @@ export async function finishToolObservation(event: Record<string, unknown>) {
           isError,
         },
       },
-      getCapturePolicy(),
+      policy,
     );
     const outputBytes = estimatePayloadBytes(captured.toolOutput, getLimits().maxToolPayload);
     const durationMs = Math.max(0, Date.now() - activeTool.startedAt);
@@ -106,7 +107,9 @@ export async function finishToolObservation(event: Record<string, unknown>) {
       .update({
         output: captured.toolOutput,
         level: isError ? "ERROR" : "DEFAULT",
-        statusMessage: isError ? redactString(truncate(String(event.error ?? output), 1_000)) : undefined,
+        statusMessage: isError
+          ? redactString(truncate(String(event.error ?? output), 1_000), redactOptionsFor(policy))
+          : undefined,
         metadata: {
           ...(captured.metadata ?? {}),
           durationMs,

package/src/redaction.ts

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
 import { getLimits } from "./limits.js";
+import { state } from "./state.js";
 
 export const REDACTED = "[REDACTED_SECRET]";
 
@@ -8,8 +9,16 @@ export interface RedactOptions {
   maxArrayItems: number;
   maxObjectKeys: number;
   maxStringLength: number;
+  /** When false, absolute filesystem paths are emitted verbatim instead of `[PATH_HASH:...]`. */
+  redactPaths: boolean;
 }
 
+/**
+ * Fallback for callers that do not pass the resolved capture policy. Mirrors
+ * `getLimits()` by reading the session config, and defaults to redacting so a
+ * missing policy can never widen disclosure. Callers that hold a policy should
+ * pass `redactOptionsFor(policy)` instead of relying on this.
+ */
 function defaultOptions(): RedactOptions {
   const limits = getLimits();
   return {
@@ -17,6 +26,7 @@ function defaultOptions(): RedactOptions {
     maxArrayItems: limits.maxArrayItems,
     maxObjectKeys: limits.maxObjectKeys,
     maxStringLength: limits.maxString,
+    redactPaths: !(state.config?.capturePolicy?.capturePaths ?? false),
   };
 }
 
@@ -41,16 +51,20 @@ function truncate(value: string, maxStringLength: number): string {
 
 export function redactString(value: string, options: Partial<RedactOptions> = {}): string {
   const merged = { ...defaultOptions(), ...options };
-  const truncated = truncate(value, merged.maxStringLength);
-  return truncated
+  const secretsRedacted = truncate(value, merged.maxStringLength)
     .replace(PRIVATE_KEY_RE, REDACTED)
     .replace(BEARER_RE, REDACTED)
     .replace(KNOWN_TOKEN_RE, REDACTED)
-    .replace(SECRET_ASSIGNMENT_RE, (_match, key: string) => `${key}=${REDACTED}`)
-    .replace(ABSOLUTE_PATH_RE, (path: string) => {
-      const envSuffix = path.match(/([/\\]\.env(?:\.[A-Za-z0-9_-]+)?)$/)?.[1];
-      return `${hashPath(envSuffix ? path.slice(0, -envSuffix.length) : path)}${envSuffix ?? ""}`;
-    });
+    .replace(SECRET_ASSIGNMENT_RE, (_match, key: string) => `${key}=${REDACTED}`);
+
+  if (!merged.redactPaths) {
+    return secretsRedacted;
+  }
+
+  return secretsRedacted.replace(ABSOLUTE_PATH_RE, (path: string) => {
+    const envSuffix = path.match(/([/\\]\.env(?:\.[A-Za-z0-9_-]+)?)$/)?.[1];
+    return `${hashPath(envSuffix ? path.slice(0, -envSuffix.length) : path)}${envSuffix ?? ""}`;
+  });
 }
 
 function visit(value: unknown, options: RedactOptions, depth: number, seen: WeakSet<object>): unknown {

package/src/utils.ts

@@ -1,5 +1,5 @@
 import { getLimits } from "./limits.js";
-import { createCapturePolicy, type CapturePolicy } from "./capture-policy.js";
+import { createCapturePolicy, redactOptionsFor, type CapturePolicy } from "./capture-policy.js";
 import { redactValue } from "./redaction.js";
 import { state } from "./state.js";
 
@@ -140,6 +140,7 @@ export function shapePayload(
   return options.redact === false
     ? shaped
     : redactValue(shaped, {
+        ...redactOptionsFor(getCapturePolicy()),
         maxDepth: depth,
         maxStringLength: maxString,
         maxArrayItems,
@@ -369,6 +370,58 @@ export function getMessageFromEvent(event: Record<string, unknown>): Record<stri
   return undefined;
 }
 
+/**
+ * Langfuse buckets usage and cost details by substring match on the key name:
+ * `input` rolls up into the Input row of the breakdown, `output` into Output,
+ * and anything matching neither falls into the catch-all Other row. Camel-cased
+ * `cacheWrite` lands in Other, so cache is reported outside the Input bucket it
+ * belongs to and never reaches Langfuse's own price table, which resolves
+ * usage types by exact key match (`price.usageType === key`) and therefore
+ * cannot price cache for providers that do not report cost themselves.
+ *
+ * These are the key names Langfuse documents for Anthropic-style caching.
+ * Pi reports `input` exclusive of cached tokens, so the buckets stay
+ * non-overlapping and nothing is double counted. Emitting both spellings would
+ * be worse than either: the canonical key would be counted in Input and the
+ * camel-cased duplicate again in Other.
+ */
+const CACHE_READ_KEY = "cache_read_input_tokens";
+const CACHE_WRITE_KEY = "cache_creation_input_tokens";
+
+/**
+ * Anthropic prices one-hour cache writes at a different rate from the default
+ * five-minute ones, and Langfuse mirrors that with two TTL-specific usage keys.
+ * Pi reports the total under `cacheWrite` and the hour-TTL share of it under
+ * `cacheWrite1h`, so the two Langfuse buckets are `cacheWrite - cacheWrite1h`
+ * and `cacheWrite1h`. Both keys contain `input`, so the Input row of the
+ * breakdown is unchanged; only the price lookup differs.
+ */
+const CACHE_WRITE_5M_KEY = "input_cache_creation_5m";
+const CACHE_WRITE_1H_KEY = "input_cache_creation_1h";
+
+/**
+ * Pi emits `cacheWrite1h: 0` on every Anthropic-family response, so a zero
+ * carries no TTL information. Only a non-zero hour-TTL figure is a real
+ * breakdown; everything else stays on the TTL-agnostic key so dashboards and
+ * custom model prices keyed on it keep working.
+ */
+function splitCacheWrite(cacheWrite: number, cacheWrite1h: number): Record<string, number> {
+  if (!cacheWrite) {
+    return {};
+  }
+
+  const longWrite = Math.min(Math.max(cacheWrite1h, 0), cacheWrite);
+  if (!longWrite) {
+    return { [CACHE_WRITE_KEY]: cacheWrite };
+  }
+
+  const shortWrite = cacheWrite - longWrite;
+  return {
+    ...(shortWrite ? { [CACHE_WRITE_5M_KEY]: shortWrite } : {}),
+    [CACHE_WRITE_1H_KEY]: longWrite,
+  };
+}
+
 export function extractUsage(messageOrEvent: Record<string, unknown>): Record<string, number> | undefined {
   const usage = (messageOrEvent.usage ??
     (messageOrEvent.message && typeof messageOrEvent.message === "object"
@@ -383,13 +436,14 @@ export function extractUsage(messageOrEvent: Record<string, unknown>): Record<st
   const total = Number(usage.total ?? usage.totalTokens ?? usage.total_tokens ?? input + output);
   const cacheRead = Number(usage.cacheRead ?? usage.cache_read ?? usage.cachedTokens ?? 0);
   const cacheWrite = Number(usage.cacheWrite ?? usage.cache_write ?? 0);
+  const cacheWrite1h = Number(usage.cacheWrite1h ?? usage.cache_write_1h ?? 0);
 
   return {
     input,
     output,
     total,
-    ...(cacheRead ? { cacheRead } : {}),
-    ...(cacheWrite ? { cacheWrite } : {}),
+    ...(cacheRead ? { [CACHE_READ_KEY]: cacheRead } : {}),
+    ...splitCacheWrite(cacheWrite, cacheWrite1h),
   };
 }
 
@@ -405,12 +459,23 @@ export function extractCostDetails(messageOrEvent: Record<string, unknown>): Rec
 
   const input = Number(cost.input ?? cost.inputCost ?? 0);
   const output = Number(cost.output ?? cost.outputCost ?? 0);
-  const total = Number(cost.total ?? cost.totalCost ?? input + output);
-  if (input === 0 && output === 0 && total === 0) {
+  const cacheRead = Number(cost.cacheRead ?? cost.cache_read ?? 0);
+  // Pi has no per-TTL cost figure: `cost.cacheWrite` already prices the
+  // five-minute and one-hour shares at their own rates and sums them, so the
+  // cost side stays on the aggregate key even when usage is split by TTL.
+  const cacheWrite = Number(cost.cacheWrite ?? cost.cache_write ?? 0);
+  const total = Number(cost.total ?? cost.totalCost ?? input + output + cacheRead + cacheWrite);
+  if (input === 0 && output === 0 && cacheRead === 0 && cacheWrite === 0 && total === 0) {
     return undefined;
   }
 
-  return { input, output, total };
+  return {
+    input,
+    output,
+    total,
+    ...(cacheRead ? { [CACHE_READ_KEY]: cacheRead } : {}),
+    ...(cacheWrite ? { [CACHE_WRITE_KEY]: cacheWrite } : {}),
+  };
 }
 
 export function extractResponseMetadata(event: Record<string, unknown>): Record<string, unknown> {