@anvia/langfuse 0.3.9 → 0.4.0

package/dist/index.js

@@ -20,21 +20,30 @@ function modelParameters(request) {
   return params;
 }
 function usageDetails(usage) {
+  if (usage.details !== void 0 && Object.keys(usage.details).length > 0) {
+    return { ...usage.details };
+  }
   return {
-    inputTokens: usage.inputTokens,
-    outputTokens: usage.outputTokens,
-    totalTokens: usage.totalTokens,
-    cachedInputTokens: usage.cachedInputTokens,
-    cacheCreationInputTokens: usage.cacheCreationInputTokens
+    input: usage.inputTokens,
+    output: usage.outputTokens,
+    total: usage.totalTokens
   };
 }
 function usageDetailsFromRecord(usage) {
+  if (isRecord(usage.details)) {
+    const details = Object.fromEntries(
+      Object.entries(usage.details).filter(
+        (entry) => typeof entry[1] === "number" && Number.isFinite(entry[1]) && entry[1] >= 0
+      )
+    );
+    if (Object.keys(details).length > 0) {
+      return details;
+    }
+  }
   return {
-    inputTokens: numberValue(usage.inputTokens) ?? 0,
-    outputTokens: numberValue(usage.outputTokens) ?? 0,
-    totalTokens: numberValue(usage.totalTokens) ?? (numberValue(usage.inputTokens) ?? 0) + (numberValue(usage.outputTokens) ?? 0),
-    cachedInputTokens: numberValue(usage.cachedInputTokens) ?? 0,
-    cacheCreationInputTokens: numberValue(usage.cacheCreationInputTokens) ?? 0
+    input: numberValue(usage.inputTokens) ?? 0,
+    output: numberValue(usage.outputTokens) ?? 0,
+    total: numberValue(usage.totalTokens) ?? (numberValue(usage.inputTokens) ?? 0) + (numberValue(usage.outputTokens) ?? 0)
   };
 }
 function childMetadata(args, agentId, agentName, childTurn) {
@@ -121,6 +130,8 @@ var LangfuseScoreError = class extends Error {
     }
   }
 };
+var RetryableLangfuseScoreError = class extends LangfuseScoreError {
+};
 var defaultSleep = (ms) => new Promise((resolve) => {
   setTimeout(resolve, ms);
 });
@@ -139,6 +150,7 @@ var ScoreQueue = class {
   pending = [];
   timer = null;
   flushing = null;
+  closed = false;
   baseUrl;
   publicKey;
   secretKey;
@@ -164,9 +176,12 @@ var ScoreQueue = class {
     this.clearTimer = options.clearTimer ?? defaultClearTimer;
   }
   enqueue(score) {
+    if (this.closed) {
+      throw new Error("Langfuse score queue is shut down");
+    }
     this.pending.push(score);
     if (this.pending.length >= this.batchSize) {
-      void this.flush();
+      this.triggerBackgroundFlush();
       return;
     }
     this.scheduleTimer();
@@ -175,24 +190,36 @@ var ScoreQueue = class {
     return this.pending.length;
   }
   async flush() {
-    if (this.flushing !== null) {
-      await this.flushing;
-      return;
-    }
-    if (this.pending.length === 0) {
-      this.clearScheduledTimer();
-      return;
-    }
-    const batch = this.pending.splice(0, this.pending.length);
     this.clearScheduledTimer();
-    this.flushing = this.sendBatch(batch).finally(() => {
-      this.flushing = null;
-    });
-    await this.flushing;
+    while (true) {
+      if (this.flushing !== null) {
+        await this.flushing;
+        if (this.pending.length === 0) {
+          return;
+        }
+        continue;
+      }
+      if (this.pending.length === 0) {
+        return;
+      }
+      const draining = this.drain();
+      this.flushing = draining;
+      try {
+        await draining;
+      } finally {
+        if (this.flushing === draining) {
+          this.flushing = null;
+        }
+      }
+    }
   }
   async shutdown() {
+    this.closed = true;
     this.clearScheduledTimer();
-    await this.flush();
+    try {
+      await this.flush();
+    } catch {
+    }
   }
   scheduleTimer() {
     if (this.timer !== null) {
@@ -200,9 +227,13 @@ var ScoreQueue = class {
     }
     this.timer = this.setTimer(() => {
       this.timer = null;
-      void this.flush();
+      this.triggerBackgroundFlush();
     }, this.flushIntervalMs);
   }
+  triggerBackgroundFlush() {
+    void this.flush().catch(() => {
+    });
+  }
   clearScheduledTimer() {
     if (this.timer !== null) {
       this.clearTimer(this.timer);
@@ -245,12 +276,35 @@ var ScoreQueue = class {
         await this.sleep(computeBackoff(attempt));
       }
     }
-    throw new LangfuseScoreError(
+    throw new RetryableLangfuseScoreError(
       `Langfuse score batch failed after ${this.maxRetries} attempts`,
       scores,
       lastError
     );
   }
+  async drain() {
+    let permanentError;
+    while (this.pending.length > 0) {
+      const batch = this.pending.splice(0, this.batchSize);
+      try {
+        await this.sendBatch(batch);
+      } catch (error) {
+        if (error instanceof RetryableLangfuseScoreError) {
+          this.pending.unshift(...batch);
+          throw error;
+        }
+        if (error instanceof LangfuseScoreError) {
+          permanentError ??= error;
+          continue;
+        }
+        this.pending.unshift(...batch);
+        throw error;
+      }
+    }
+    if (permanentError !== void 0) {
+      throw permanentError;
+    }
+  }
 };
 function buildScoreBody(score) {
   const body = {
@@ -947,29 +1001,42 @@ function cloneRegex(source, flags) {
 }
 function redactValue(value, depth, redactStringFn) {
   if (depth > MAX_DEPTH) return value;
-  if (typeof value === "string") return redactStringFn(value);
+  if (typeof value === "string") {
+    return isBase64DataUrl(value) ? value : redactStringFn(value);
+  }
   if (Array.isArray(value))
     return value.map((entry) => redactValue(entry, depth + 1, redactStringFn));
   if (value !== null && typeof value === "object") {
+    if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) {
+      return value;
+    }
+    const record = value;
     const out = {};
-    for (const [key, entry] of Object.entries(value)) {
-      out[key] = redactValue(entry, depth + 1, redactStringFn);
+    for (const [key, entry] of Object.entries(record)) {
+      if (key === "data" && typeof entry === "string" && (record.type === "base64" || record.type === "image" || record.type === "encrypted" || record.type === "redacted")) {
+        out[key] = entry;
+      } else {
+        out[key] = redactValue(entry, depth + 1, redactStringFn);
+      }
     }
     return out;
   }
   return value;
 }
 function redactMessage(message, redactStringFn) {
-  if (!Array.isArray(message.content)) return message;
-  const newContent = message.content.map((part) => {
-    if (part === null || typeof part !== "object") return part;
-    const rec = part;
-    if (rec.type === "text" && typeof rec.text === "string") {
-      return { ...part, text: redactStringFn(rec.text) };
-    }
-    return part;
-  });
-  return { ...message, content: newContent };
+  if (message.role === "system") {
+    return { ...message, content: redactStringFn(message.content) };
+  }
+  return {
+    ...message,
+    content: redactMessageContent(message.content, redactStringFn)
+  };
+}
+function redactMessageContent(value, redactStringFn) {
+  return redactValue(value, 0, redactStringFn);
+}
+function isBase64DataUrl(value) {
+  return /^data:[^;,]+;base64,/i.test(value);
 }
 
 // src/tracing.ts
@@ -982,6 +1049,107 @@ import {
 import { resourceFromAttributes } from "@opentelemetry/resources";
 import { NodeSDK } from "@opentelemetry/sdk-node";
 import { SEMRESATTRS_SERVICE_NAME } from "@opentelemetry/semantic-conventions";
+
+// src/capture.ts
+var DEFAULT_CAPTURE_MAX_BYTES = 262144;
+var MIN_CAPTURE_MAX_BYTES = 96;
+function validateCaptureMaxBytes(value) {
+  const resolved = value ?? DEFAULT_CAPTURE_MAX_BYTES;
+  if (!Number.isInteger(resolved) || resolved < MIN_CAPTURE_MAX_BYTES) {
+    throw new TypeError(
+      `Langfuse captureMaxBytes must be an integer of at least ${MIN_CAPTURE_MAX_BYTES}`
+    );
+  }
+  return resolved;
+}
+function sanitizeTraceValue(value, maxBytes) {
+  validateCaptureMaxBytes(maxBytes);
+  const sanitized = sanitizeValue(value, 0, /* @__PURE__ */ new WeakSet());
+  let serialized;
+  try {
+    serialized = JSON.stringify(sanitized) ?? String(sanitized);
+  } catch {
+    return omitted("unserializable");
+  }
+  const originalBytes = utf8Bytes(serialized);
+  if (originalBytes <= maxBytes) {
+    return sanitized;
+  }
+  const preview = boundedPreview(serialized, originalBytes, maxBytes);
+  return {
+    anviaTraceValue: "truncated",
+    originalBytes,
+    preview
+  };
+}
+function sanitizeValue(value, depth, seen) {
+  if (depth > 16) {
+    return omitted("depth");
+  }
+  if (typeof value === "string") {
+    if (/^data:[^;,]+;base64,/i.test(value)) {
+      return omitted("base64", utf8Bytes(value));
+    }
+    return value;
+  }
+  if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) {
+    const byteLength = value.byteLength;
+    return omitted("binary", byteLength);
+  }
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  if (seen.has(value)) {
+    return omitted("circular");
+  }
+  seen.add(value);
+  if (Array.isArray(value)) {
+    const result2 = value.map((entry) => sanitizeValue(entry, depth + 1, seen));
+    seen.delete(value);
+    return result2;
+  }
+  const record = value;
+  const result = {};
+  for (const [key, entry] of Object.entries(record)) {
+    if (key === "data" && typeof entry === "string" && (record.type === "base64" || record.type === "image" && typeof record.mediaType === "string")) {
+      result[key] = omitted("base64", utf8Bytes(entry));
+      continue;
+    }
+    result[key] = sanitizeValue(entry, depth + 1, seen);
+  }
+  seen.delete(value);
+  return result;
+}
+function omitted(reason, originalBytes) {
+  return {
+    anviaTraceValue: "omitted",
+    reason,
+    ...originalBytes === void 0 ? {} : { originalBytes }
+  };
+}
+function boundedPreview(value, originalBytes, maxBytes) {
+  let low = 0;
+  let high = value.length;
+  while (low < high) {
+    const middle = Math.ceil((low + high) / 2);
+    const candidate = {
+      anviaTraceValue: "truncated",
+      originalBytes,
+      preview: value.slice(0, middle)
+    };
+    if (utf8Bytes(JSON.stringify(candidate)) <= maxBytes) {
+      low = middle;
+    } else {
+      high = middle - 1;
+    }
+  }
+  return value.slice(0, low);
+}
+function utf8Bytes(value) {
+  return typeof Buffer === "undefined" ? new TextEncoder().encode(value).byteLength : Buffer.byteLength(value, "utf8");
+}
+
+// src/tracing.ts
 var langfuse = {
   create(options = {}) {
     return new LangfuseAgentObserver(options);
@@ -1001,6 +1169,8 @@ var LangfuseAgentObserver = class {
   redactor;
   redactInputs;
   redactOutputs;
+  captureMode;
+  captureMaxBytes;
   constructor(options) {
     const resolvedConfig = resolveLangfuseConfig(options);
     this[langfuseResolvedConfigSymbol] = resolvedConfig;
@@ -1041,23 +1211,31 @@ var LangfuseAgentObserver = class {
     }) : null;
     this.redactInputs = options.redactInputs;
     this.redactOutputs = options.redactOutputs;
+    this.captureMode = options.captureMode ?? "safe";
+    this.captureMaxBytes = validateCaptureMaxBytes(options.captureMaxBytes);
     this.redactor = options.redactInputs !== void 0 || options.redactOutputs !== void 0 ? createPiiRedactor(options.redaction) : void 0;
   }
   async startRun(args) {
     const traceId = args.trace?.traceId;
-    const redactedInput = this.maybeRedactInput({
+    const capturedInput = this.captureInput({
+      instructions: args.instructions,
       prompt: args.prompt,
       history: args.history
     });
+    const capturedTraceMetadata = this.captureInput(args.trace?.metadata ?? {});
     const metadata = {
       agentName: args.agentName,
       agentDescription: args.agentDescription,
       maxTurns: args.maxTurns
     };
     if (this.serviceName !== void 0) metadata.serviceName = this.serviceName;
-    Object.assign(metadata, args.trace?.metadata);
+    if (isRecord(capturedTraceMetadata)) {
+      Object.assign(metadata, capturedTraceMetadata);
+    } else {
+      metadata.traceMetadata = capturedTraceMetadata;
+    }
     const rootAttributes = {
-      input: redactedInput,
+      input: capturedInput,
       metadata
     };
     if (args.trace?.version !== void 0) {
@@ -1075,7 +1253,7 @@ var LangfuseAgentObserver = class {
         }
       }
     );
-    applyTraceAttributes(root, args);
+    applyTraceAttributes(root, args, capturedTraceMetadata);
     const promptRef = resolvePromptRef(args);
     const runObserver = new LangfuseRunObserver(
       root,
@@ -1087,7 +1265,9 @@ var LangfuseAgentObserver = class {
       {
         redactor: this.redactor,
         redactInputs: this.redactInputs,
-        redactOutputs: this.redactOutputs
+        redactOutputs: this.redactOutputs,
+        captureMode: this.captureMode,
+        captureMaxBytes: this.captureMaxBytes
       }
     );
     this.currentHandle = runObserver.getHandle();
@@ -1118,13 +1298,9 @@ var LangfuseAgentObserver = class {
   getCurrentTrace() {
     return this.currentHandle;
   }
-  maybeRedactInput(value) {
-    if (this.redactor === void 0 || this.redactInputs === void 0) return value;
-    return applyRedaction(this.redactor, value, this.redactInputs);
-  }
-  maybeRedactOutput(value) {
-    if (this.redactor === void 0 || this.redactOutputs === void 0) return value;
-    return applyRedaction(this.redactor, value, this.redactOutputs);
+  captureInput(value) {
+    const redacted = this.redactor === void 0 || this.redactInputs === void 0 ? value : applyRedaction(this.redactor, value, this.redactInputs);
+    return sanitizeTraceValue(redacted, this.captureMaxBytes);
   }
   async score(args) {
     if (args.traceId === void 0 || args.traceId.length === 0) {
@@ -1196,7 +1372,7 @@ function buildScoreBody2(score) {
   }
   return body;
 }
-function applyTraceAttributes(root, args) {
+function applyTraceAttributes(root, args, capturedMetadata) {
   const traceName = args.trace?.name ?? args.agentName;
   if (traceName !== void 0) {
     root.otelSpan.setAttribute(LangfuseOtelSpanAttributes.TRACE_NAME, traceName);
@@ -1210,7 +1386,9 @@ function applyTraceAttributes(root, args) {
   if (args.trace?.tags !== void 0) {
     root.otelSpan.setAttribute(LangfuseOtelSpanAttributes.TRACE_TAGS, args.trace.tags);
   }
-  for (const [key, value] of Object.entries(args.trace?.metadata ?? {})) {
+  for (const [key, value] of Object.entries(
+    isRecord(capturedMetadata) ? capturedMetadata : { value: capturedMetadata }
+  )) {
     const serialized = serializeMetadataValue(value);
     if (serialized === void 0) {
       continue;
@@ -1238,9 +1416,6 @@ function applyRedaction(redactor, value, mode) {
   if (typeof value === "string") {
     return redactor.redactString(value);
   }
-  if (Array.isArray(value)) {
-    return redactor.redactMessages(value);
-  }
   if (value !== null && typeof value === "object") {
     return redactor.redactObject(value);
   }
@@ -1250,6 +1425,9 @@ function resolvePromptRef(args) {
   if (args.promptRef !== void 0) {
     return args.promptRef;
   }
+  if (args.trace?.promptRef !== void 0) {
+    return args.trace.promptRef;
+  }
   const metadata = args.trace?.metadata;
   if (metadata === void 0) {
     return void 0;
@@ -1291,6 +1469,19 @@ function serializeMetadataValue(value) {
     return "<failed to serialize>";
   }
 }
+function asMetadata(value) {
+  return isRecord(value) ? value : { value };
+}
+function eventStartTime(value) {
+  if (value instanceof Date) {
+    return Number.isNaN(value.getTime()) ? void 0 : value;
+  }
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const parsed = new Date(value);
+  return Number.isNaN(parsed.getTime()) ? void 0 : parsed;
+}
 var LangfuseRunObserver = class {
   constructor(root, trace, promptRef, redaction) {
     this.root = root;
@@ -1300,6 +1491,8 @@ var LangfuseRunObserver = class {
     this.redactor = redaction.redactor;
     this.redactInputs = redaction.redactInputs;
     this.redactOutputs = redaction.redactOutputs;
+    this.captureMode = redaction.captureMode;
+    this.captureMaxBytes = redaction.captureMaxBytes;
   }
   root;
   trace;
@@ -1313,24 +1506,41 @@ var LangfuseRunObserver = class {
   redactor;
   redactInputs;
   redactOutputs;
+  captureMode;
+  captureMaxBytes;
   redactInputValue(value) {
-    if (this.redactor === void 0 || this.redactInputs === void 0) return value;
-    return applyRedaction(this.redactor, value, this.redactInputs);
+    const redacted = this.redactor === void 0 || this.redactInputs === void 0 ? value : applyRedaction(this.redactor, value, this.redactInputs);
+    return sanitizeTraceValue(redacted, this.captureMaxBytes);
   }
   redactOutputValue(value) {
-    if (this.redactor === void 0 || this.redactOutputs === void 0) return value;
-    return applyRedaction(this.redactor, value, this.redactOutputs);
+    const redacted = this.redactor === void 0 || this.redactOutputs === void 0 ? value : applyRedaction(this.redactor, value, this.redactOutputs);
+    return sanitizeTraceValue(redacted, this.captureMaxBytes);
   }
   startGeneration(args) {
     this.closeEarlierTurns(args.turn);
     const turn = this.turnSpan(args.turn);
-    const redactedChatHistory = this.redactInputValue(modelInputMessages(args.request.chatHistory));
+    const safeInput = {
+      instructions: args.request.instructions,
+      messages: modelInputMessages(args.request.chatHistory)
+    };
+    if (this.captureMode === "full") {
+      safeInput.documents = args.request.documents;
+      safeInput.tools = args.request.tools;
+      safeInput.providerTools = args.request.providerTools;
+      safeInput.outputSchema = args.request.outputSchema;
+      safeInput.additionalParams = args.request.additionalParams;
+    }
     const metadata = {
       turn: args.turn,
-      toolCount: args.request.tools.length,
-      hasOutputSchema: args.request.outputSchema !== void 0
+      documentCount: args.request.documents.length,
+      toolNames: args.request.tools.map((tool) => tool.name),
+      providerToolNames: args.request.providerTools?.map((tool) => tool.name) ?? [],
+      hasOutputSchema: args.request.outputSchema !== void 0,
+      additionalParamKeys: isRecord(args.request.additionalParams) ? Object.keys(args.request.additionalParams) : []
     };
-    if (args.providerRequest !== void 0) metadata.providerRequest = args.providerRequest;
+    if (this.captureMode === "full" && args.providerRequest !== void 0) {
+      metadata.providerRequest = args.providerRequest;
+    }
     if (args.modelInfo !== void 0) {
       const modelInfo = {
         provider: args.modelInfo.provider,
@@ -1342,36 +1552,43 @@ var LangfuseRunObserver = class {
       metadata.modelInfo = modelInfo;
     }
     Object.assign(metadata, promptMetadata(this.promptRef));
-    const generation = turn.startObservation(
-      `model.turn.${args.turn}`,
-      {
-        input: redactedChatHistory,
-        model: args.request.model ?? "default",
-        modelParameters: modelParameters(args.request),
-        metadata
-      },
-      { asType: "generation" }
-    );
-    return new LangfuseGenerationObserver(generation, this);
+    const generationAttributes = {
+      input: this.redactInputValue(safeInput),
+      model: args.request.model ?? args.modelInfo?.defaultModel ?? "default",
+      modelParameters: modelParameters(args.request),
+      metadata: asMetadata(this.redactInputValue(metadata))
+    };
+    if (this.promptRef?.version !== void 0) {
+      generationAttributes.prompt = {
+        name: this.promptRef.name,
+        version: this.promptRef.version,
+        isFallback: false
+      };
+    }
+    const generation = turn.startObservation(`model.turn.${args.turn}`, generationAttributes, {
+      asType: "generation"
+    });
+    return new LangfuseGenerationObserver(generation, this, /* @__PURE__ */ new Date());
   }
   startTool(args) {
     const turn = this.turnSpan(args.turn);
-    const redactedArgs = this.redactInputValue(args.args);
     const metadata = {
       turn: args.turn,
       internalCallId: args.internalCallId,
       toolCallId: args.toolCallId
     };
-    if (args.toolDefinition !== void 0) metadata.toolDefinition = args.toolDefinition;
-    if (args.toolMetadata !== void 0) metadata.toolMetadata = args.toolMetadata;
+    if (this.captureMode === "full") {
+      if (args.toolDefinition !== void 0) metadata.toolDefinition = args.toolDefinition;
+      if (args.toolMetadata !== void 0) metadata.toolMetadata = args.toolMetadata;
+    }
     const tool = turn.startObservation(
       `tool.${args.toolName}`,
       {
-        input: {
-          args: redactedArgs,
+        input: this.redactInputValue({
+          args: args.args,
           toolCall: args.toolCall
-        },
-        metadata
+        }),
+        metadata: asMetadata(this.redactInputValue(metadata))
       },
       { asType: "tool" }
     );
@@ -1380,34 +1597,52 @@ var LangfuseRunObserver = class {
   end(args) {
     this.closeAllTurns();
     const redactedOutput = this.redactOutputValue(args.output);
+    const metadata = {
+      usage: args.usage,
+      messageCount: args.messages.length,
+      sources: this.redactOutputValue(args.sources),
+      providerToolCalls: this.redactOutputValue(args.providerToolCalls)
+    };
+    if (this.captureMode === "full") {
+      metadata.messages = this.redactTranscript(args.messages);
+    }
     this.root.update({
       output: redactedOutput,
-      metadata: {
-        usage: args.usage,
-        messages: args.messages
-      }
+      metadata
     }).end();
     this.clearCurrentHandle?.();
   }
   error(args) {
     this.closeAllTurns();
+    const redactedError = this.redactOutputValue(errorMessage(args.error));
+    const metadata = {
+      usage: args.usage,
+      messageCount: args.messages.length
+    };
+    if (this.captureMode === "full") {
+      metadata.messages = this.redactTranscript(args.messages);
+    }
     this.root.update({
       level: "ERROR",
-      statusMessage: errorMessage(args.error),
+      statusMessage: typeof redactedError === "string" ? redactedError : "Agent run failed",
       output: {
-        error: errorMessage(args.error)
+        error: redactedError
       },
-      metadata: {
-        usage: args.usage,
-        messages: args.messages
-      }
+      metadata
     }).end();
     this.clearCurrentHandle?.();
   }
   event(args) {
-    const metadata = {};
-    Object.assign(metadata, args.attributes);
-    this.root.startObservation(args.name, { metadata }, { asType: "event" }).end();
+    const metadata = asMetadata(this.redactOutputValue(args.attributes ?? {}));
+    const attributes = { metadata };
+    if (args.level !== void 0) {
+      attributes.level = args.level;
+    }
+    const startTime = eventStartTime(args.timestamp);
+    this.root.startObservation(args.name, attributes, {
+      asType: "event",
+      ...startTime === void 0 ? {} : { startTime }
+    });
   }
   getHandle() {
     return this.handle;
@@ -1417,13 +1652,15 @@ var LangfuseRunObserver = class {
       traceId: this.trace.traceId ?? "",
       observationId: this.trace.observationId ?? "",
       addAttributes: (attributes) => {
-        this.root.update({ metadata: attributes });
+        this.root.update({ metadata: asMetadata(this.redactOutputValue(attributes)) });
         this.setCurrentHandle?.(this.handle);
       },
       addEvent: (name, attributes) => {
-        const metadata = {};
-        Object.assign(metadata, attributes);
-        this.root.startObservation(name, { metadata }, { asType: "event" }).end();
+        this.root.startObservation(
+          name,
+          { metadata: asMetadata(this.redactOutputValue(attributes ?? {})) },
+          { asType: "event" }
+        );
         this.setCurrentHandle?.(this.handle);
       }
     };
@@ -1457,17 +1694,27 @@ var LangfuseRunObserver = class {
     }
     this.turnSpans.clear();
   }
+  isFullCapture() {
+    return this.captureMode === "full";
+  }
+  redactTranscript(messages) {
+    const inputRedacted = this.redactor === void 0 || this.redactInputs === void 0 ? messages : applyRedaction(this.redactor, messages, this.redactInputs);
+    const outputRedacted = this.redactor === void 0 || this.redactOutputs === void 0 ? inputRedacted : applyRedaction(this.redactor, inputRedacted, this.redactOutputs);
+    return sanitizeTraceValue(outputRedacted, this.captureMaxBytes);
+  }
 };
 var LangfuseGenerationObserver = class {
-  constructor(generation, run) {
+  constructor(generation, run, startedAt) {
     this.generation = generation;
     this.run = run;
+    this.startedAt = startedAt;
   }
   generation;
   run;
+  startedAt;
   update(args) {
     this.generation.update({
-      output: { delta: args.delta }
+      output: this.run.redactOutputValue({ delta: args.delta })
     });
   }
   end(args) {
@@ -1475,21 +1722,30 @@ var LangfuseGenerationObserver = class {
     const redactedChoice = this.run.redactOutputValue(args.response.choice);
     const metadata = { turn: args.turn };
     if (args.firstDeltaMs !== void 0) metadata.firstDeltaMs = args.firstDeltaMs;
-    this.generation.update({
-      output: {
-        messageId: args.response.messageId,
-        content: redactedChoice,
-        text: redactedText
-      },
+    const output = {
+      messageId: args.response.messageId,
+      content: redactedChoice,
+      text: redactedText,
+      sources: this.run.redactOutputValue(args.response.sources),
+      providerToolCalls: this.run.redactOutputValue(args.response.providerToolCalls)
+    };
+    const completionStartTime = args.firstDeltaMs === void 0 ? void 0 : new Date(this.startedAt.getTime() + args.firstDeltaMs);
+    const update = {
+      output,
       usageDetails: usageDetails(args.response.usage),
       metadata
-    }).end();
+    };
+    if (completionStartTime !== void 0) {
+      update.completionStartTime = completionStartTime;
+    }
+    this.generation.update(update).end();
   }
   error(args) {
+    const redactedError = this.run.redactOutputValue(errorMessage(args.error));
     this.generation.update({
       level: "ERROR",
-      statusMessage: errorMessage(args.error),
-      output: { error: errorMessage(args.error) },
+      statusMessage: typeof redactedError === "string" ? redactedError : "Generation failed",
+      output: { error: redactedError },
       metadata: { turn: args.turn }
     }).end();
   }
@@ -1515,36 +1771,129 @@ var LangfuseToolObserver = class {
     const childTurn = typeof child.turn === "number" ? child.turn : args.turn;
     const agent = this.childAgent(agentId, agentName, args);
     if (child.type === "turn_start") {
+      const promptMessage = isRecord(child.prompt) ? child.prompt : void 0;
+      const historyMessages = Array.isArray(child.history) ? child.history.filter(isRecord) : [];
+      agent.startObservation(
+        `${agentLabel(agentId, agentName)}.turn.${childTurn}.start`,
+        {
+          input: this.run.redactInputValue({
+            prompt: promptMessage === void 0 ? void 0 : modelInputMessage(promptMessage),
+            history: modelInputMessages(historyMessages)
+          }),
+          metadata: asMetadata(
+            this.run.redactInputValue(childMetadata(args, agentId, agentName, childTurn))
+          )
+        },
+        { asType: "event" }
+      );
+      return;
+    }
+    if (child.type === "generation_start" && isRecord(child.request)) {
+      const request = child.request;
+      const modelInfo = isRecord(child.modelInfo) ? child.modelInfo : void 0;
+      const messages = Array.isArray(request.chatHistory) ? modelInputMessages(request.chatHistory.filter(isRecord)) : [];
+      const input = {
+        instructions: typeof request.instructions === "string" ? request.instructions : void 0,
+        messages
+      };
+      if (this.run.isFullCapture()) {
+        input.documents = request.documents;
+        input.tools = request.tools;
+        input.providerTools = request.providerTools;
+        input.outputSchema = request.outputSchema;
+        input.additionalParams = request.additionalParams;
+      }
+      const toolNames = Array.isArray(request.tools) ? request.tools.filter(isRecord).map((tool) => tool.name).filter((name) => typeof name === "string") : [];
+      const providerToolNames = Array.isArray(request.providerTools) ? request.providerTools.filter(isRecord).map((tool) => tool.name).filter((name) => typeof name === "string") : [];
       const generation = agent.startObservation(
         `${agentLabel(agentId, agentName)}.model.turn.${childTurn}`,
         {
-          input: {
-            prompt: modelInputMessage(child.prompt),
-            history: modelInputMessages(child.history)
-          },
-          metadata: childMetadata(args, agentId, agentName, childTurn)
+          input: this.run.redactInputValue(input),
+          model: typeof request.model === "string" ? request.model : typeof modelInfo?.defaultModel === "string" ? modelInfo.defaultModel : "default",
+          modelParameters: modelParameters(request),
+          metadata: asMetadata(
+            this.run.redactInputValue({
+              ...childMetadata(args, agentId, agentName, childTurn),
+              documentCount: Array.isArray(request.documents) ? request.documents.length : 0,
+              toolNames,
+              providerToolNames,
+              hasOutputSchema: request.outputSchema !== void 0,
+              modelInfo
+            })
+          )
         },
         { asType: "generation" }
       );
-      this.childGenerations.set(generationKey(agentId, childTurn), generation);
+      this.childGenerations.set(generationKey(agentId, childTurn), {
+        generation,
+        startedAt: /* @__PURE__ */ new Date()
+      });
       return;
     }
     if (child.type === "turn_end") {
-      const generation = this.childGenerations.get(generationKey(agentId, childTurn));
-      if (generation !== void 0) {
+      const childGeneration = this.childGenerations.get(generationKey(agentId, childTurn));
+      if (childGeneration !== void 0) {
         const update = {
-          output: child.response,
-          metadata: childMetadata(args, agentId, agentName, childTurn)
+          output: this.run.redactOutputValue(child.response),
+          metadata: asMetadata(
+            this.run.redactOutputValue(childMetadata(args, agentId, agentName, childTurn))
+          )
         };
         if (isRecord(child.response) && isRecord(child.response.usage)) {
           update.usageDetails = usageDetailsFromRecord(child.response.usage);
         }
-        generation.update(update).end();
+        if (typeof child.firstDeltaMs === "number") {
+          update.completionStartTime = new Date(
+            childGeneration.startedAt.getTime() + child.firstDeltaMs
+          );
+        }
+        childGeneration.generation.update(update).end();
         this.childGenerations.delete(generationKey(agentId, childTurn));
       }
       return;
     }
+    if (child.type === "text_delta" || child.type === "reasoning_delta" || child.type === "tool_call_delta") {
+      const childGeneration = this.childGenerations.get(generationKey(agentId, childTurn));
+      childGeneration?.generation.update({
+        output: this.run.redactOutputValue({ delta: child })
+      });
+      return;
+    }
+    if (child.type === "source" || child.type === "provider_tool_call") {
+      const childGeneration = this.childGenerations.get(generationKey(agentId, childTurn));
+      const parent = childGeneration?.generation ?? agent;
+      parent.startObservation(
+        `${agentLabel(agentId, agentName)}.${child.type}`,
+        {
+          output: this.run.redactOutputValue(
+            child.type === "source" ? child.source : child.toolCall
+          ),
+          metadata: asMetadata(
+            this.run.redactOutputValue(childMetadata(args, agentId, agentName, childTurn))
+          )
+        },
+        { asType: "event" }
+      );
+      return;
+    }
+    if (child.type === "guardrail_decision") {
+      agent.startObservation(
+        `${agentLabel(agentId, agentName)}.guardrail`,
+        {
+          output: this.run.redactOutputValue(child.decision),
+          metadata: asMetadata(
+            this.run.redactOutputValue(childMetadata(args, agentId, agentName, childTurn))
+          )
+        },
+        { asType: "guardrail" }
+      ).end();
+      return;
+    }
     if (child.type === "tool_call" && isRecord(child.toolCall)) {
+      const childGeneration = this.childGenerations.get(generationKey(agentId, childTurn));
+      childGeneration?.generation.update({
+        output: this.run.redactOutputValue({ toolCall: child.toolCall })
+      });
       const toolCall = child.toolCall;
       const toolCallFunction = isRecord(toolCall.function) ? toolCall.function : void 0;
       const toolName = typeof toolCallFunction?.name === "string" ? toolCallFunction.name : "tool";
@@ -1552,15 +1901,17 @@ var LangfuseToolObserver = class {
       const childTool = agent.startObservation(
         `${agentLabel(agentId, agentName)}.${toolName}`,
         {
-          input: {
+          input: this.run.redactInputValue({
             args: toolCallFunction?.arguments ?? {},
             toolCall
-          },
-          metadata: {
-            ...childMetadata(args, agentId, agentName, childTurn),
-            toolName,
-            toolCallId
-          }
+          }),
+          metadata: asMetadata(
+            this.run.redactInputValue({
+              ...childMetadata(args, agentId, agentName, childTurn),
+              toolName,
+              toolCallId
+            })
+          )
         },
         { asType: "tool" }
       );
@@ -1581,30 +1932,49 @@ var LangfuseToolObserver = class {
       if (childTool !== void 0) {
         childTool.ended = true;
         childTool.tool.update({
-          output: typeof child.result === "string" ? child.result : child,
-          metadata: {
-            ...childMetadata(args, agentId, agentName, childTurn),
-            toolName,
-            toolCallId,
-            internalCallId: typeof child.internalCallId === "string" ? child.internalCallId : void 0,
-            args: typeof child.args === "string" ? child.args : void 0
-          }
+          output: this.run.redactOutputValue(
+            typeof child.result === "string" ? child.result : child
+          ),
+          metadata: asMetadata(
+            this.run.redactInputValue({
+              ...childMetadata(args, agentId, agentName, childTurn),
+              toolName,
+              toolCallId,
+              internalCallId: typeof child.internalCallId === "string" ? child.internalCallId : void 0,
+              args: typeof child.args === "string" ? child.args : void 0
+            })
+          )
         }).end();
       }
       return;
     }
     if (child.type === "final") {
-      const update = { output: child.output };
-      if (isRecord(child.usage)) update.metadata = { usage: child.usage };
+      const update = {
+        output: this.run.redactOutputValue(child.output)
+      };
+      const metadata = {};
+      if (isRecord(child.usage)) metadata.usage = child.usage;
+      if (this.run.isFullCapture() && Array.isArray(child.messages)) {
+        metadata.messages = this.run.redactTranscript(child.messages);
+      }
+      if (Object.keys(metadata).length > 0) update.metadata = metadata;
       agent.update(update).end();
       this.childAgents.delete(agentId);
       return;
     }
     if (child.type === "error") {
+      const redactedError = this.run.redactOutputValue(errorMessage(child.error));
+      const childGeneration = this.childGenerations.get(generationKey(agentId, childTurn));
+      childGeneration?.generation.update({
+        level: "ERROR",
+        statusMessage: typeof redactedError === "string" ? redactedError : "Generation failed",
+        output: { error: redactedError }
+      }).end();
+      this.childGenerations.delete(generationKey(agentId, childTurn));
       const update = {
         level: "ERROR",
-        statusMessage: errorMessage(child.error),
-        output: { error: errorMessage(child.error) }
+        statusMessage: typeof redactedError === "string" ? redactedError : "Child agent failed",
+        output: { error: redactedError }
       };
       if (isRecord(child.usage)) update.metadata = { usage: child.usage };
       agent.update(update).end();
@@ -1634,10 +2004,11 @@ var LangfuseToolObserver = class {
   }
   error(args) {
     this.endOpenChildren();
+    const redactedError = this.run.redactOutputValue(errorMessage(args.error));
     this.tool.update({
       level: "ERROR",
-      statusMessage: errorMessage(args.error),
-      output: { error: errorMessage(args.error) },
+      statusMessage: typeof redactedError === "string" ? redactedError : "Tool failed",
+      output: { error: redactedError },
       metadata: {
         turn: args.turn,
         internalCallId: args.internalCallId,
@@ -1653,7 +2024,9 @@ var LangfuseToolObserver = class {
     const agent = this.tool.startObservation(
       `${agentLabel(agentId, agentName)}.run`,
       {
-        metadata: childMetadata(args, agentId, agentName, args.turn)
+        metadata: asMetadata(
+          this.run.redactInputValue(childMetadata(args, agentId, agentName, args.turn))
+        )
       },
       { asType: "agent" }
     );
@@ -1674,7 +2047,7 @@ var LangfuseToolObserver = class {
   }
   endOpenChildren() {
     for (const generation of this.childGenerations.values()) {
-      generation.end();
+      generation.generation.end();
     }
     this.childGenerations.clear();
     for (const tool of this.childTools) {