@amaster.ai/dsh-langfuse 0.1.34 → 0.1.35

package/README.md

@@ -37,6 +37,7 @@ Disabled by default. Configure via the profile's `cordis.patch.yml`:
         baseUrl: https://cloud.langfuse.com
         traceName: dsh-turn
         captureContent: true            # set false to record metadata only
+        maxPayloadBytes: 262144          # per-LLM-call request/raw/output cap (256 KiB)
         userId: developer
         tags: [coding, experiment-a]
         environment: development
@@ -53,6 +54,8 @@ Buffered spans drain on `session/flush(session)`; the exporter shuts down with t
 
 With `captureContent: true`, both `llm-call` and `llm-request` inputs contain every `llm/stream` request option except the non-serializable `AbortSignal`. New request fields pass through without a plugin update. For image-bearing requests, generation input is updated to a display projection; `llm-request` retains the original attachment references. Langfuse's separate generation `modelParameters` attribute summarizes the known sampling fields; it is not part of either request input. These are dsh-side values, not exact provider HTTP payloads: adapters may add defaults, project messages/tools, or rename fields after this seam. With `captureContent: false`, the collector keeps chunk/tool-call counts and usage without buffering text, reasoning, tool arguments, or raw chunks; inputs keep structural counts while the separate `modelParameters` attribute keeps safe parameter metadata; reply excerpts, reasoning, tool arguments/results, error text, and media are withheld from observation names and IO.
 
+`maxPayloadBytes` independently bounds each captured request, raw chunk stream, and assembled output per LLM call (default 256 KiB). Oversized requests become a bounded preview; oversized streams retain only fitting chunks/prefixes and set `metadata.truncated`. These limits apply only to telemetry copies: forwarded chunks and original messages/results stay unchanged. Session disposal closes that session's active LLM/tool observations; a child whose activation rolls back before `subagent/start` closes immediately, while an already-started child still closes at `subagent/end`.
+
 Configured Langfuse credentials and `pk-lf-*` / `sk-lf-*` values are redacted across reporter payloads, names, status messages, and labels. `redactFields` replaces matching payload fields recursively, including JSON-encoded arguments, ignoring case. Name excerpts are derived after redaction. Delta blocks are also checked as assembled text so fragmented credentials cannot bypass the mask: affected blocks keep their record count/type/index, with sanitized text in the first delta and later deltas cleared. Redaction only changes telemetry copies; original messages/results and the forwarded stream stay intact. The exporter applies the same mask to IO and metadata as a final safeguard. User/tags are explicit metadata and remain when content capture is off.
 
 ## Reasoning, images, and turn results

package/lib/client.js

@@ -115,16 +115,38 @@ export class LangfuseReporter {
         this.config = config;
         this.ready = this.init();
     }
+    /** Whether a payload property should be replaced without inspecting its value. */
+    shouldRedactField(key) {
+        return !!this.config.redactFields?.some((field) => field.toLowerCase() === key.toLowerCase());
+    }
     /** Clone telemetry only; never mutate harness-owned messages or tool results. */
     mask(data) {
         const secrets = [this.config.publicKey, this.config.secretKey].filter(Boolean);
         const fields = new Set(this.config.redactFields?.map((key) => key.toLowerCase()));
         const seen = new WeakSet();
         const redactText = (text) => {
-            const ranges = Array.from(text.matchAll(/(?:pk|sk)-lf-[\w-]+/g), (match) => [match.index, match.index + match[0].length]);
+            const markedRanges = Array.from(text.matchAll(/\[REDACTED\]/g), (match) => [match.index, match.index + match[0].length]);
+            const ranges = [];
+            let markerIndex = 0;
+            const addRange = (start, stop) => {
+                // Existing markers are atomic: a second mask must never expand them.
+                // Walk the sorted marker list once instead of rescanning it per match.
+                while (markerIndex < markedRanges.length && markedRanges[markerIndex][1] <= start)
+                    markerIndex += 1;
+                if (markerIndex < markedRanges.length &&
+                    start < markedRanges[markerIndex][1] &&
+                    stop > markedRanges[markerIndex][0])
+                    return;
+                ranges.push([start, stop]);
+            };
+            for (const match of text.matchAll(/(?:pk|sk)-lf-[\w-]+/g))
+                addRange(match.index, match.index + match[0].length);
             for (const secret of secrets) {
+                // Each independent scan starts at the first marker. Do not reset for
+                // every match, or a large marker list becomes quadratic again.
+                markerIndex = 0;
                 for (let index = text.indexOf(secret); index !== -1; index = text.indexOf(secret, index + 1)) {
-                    ranges.push([index, index + secret.length]);
+                    addRange(index, index + secret.length);
                 }
             }
             let output = '';
@@ -346,6 +368,12 @@ export class LangfuseReporter {
             // v5 observation attributes have no `name` — renames ride the OTEL span.
             if (update.name)
                 generation.otelSpan.updateName(update.name);
+        }
+        catch (error) {
+            console.error('[dsh-langfuse] generation end failed:', error);
+        }
+        // An update failure must not strand the observation: v5 exports only ended spans.
+        try {
             generation.end(endedAt);
         }
         catch (error) {
@@ -418,6 +446,12 @@ export class LangfuseReporter {
             if (update.output !== undefined && this.roots.has(span)) {
                 span.setTraceIO({ output: update.output });
             }
+        }
+        catch (error) {
+            console.error('[dsh-langfuse] span end failed:', error);
+        }
+        // Always close the span, even when its final attributes could not be written.
+        try {
             span.end(endedAt);
         }
         catch (error) {

package/lib/index.js

@@ -54,6 +54,11 @@ export const Config = Schema.object({
     traceName: Schema.string().default('dsh-turn'),
     /** Include full message/tool payloads in Langfuse IO. Disable to log metadata only. */
     captureContent: Schema.boolean().default(true),
+    maxPayloadBytes: Schema.number()
+        .min(1)
+        .step(1)
+        .default(256 * 1024)
+        .description('maximum captured request, raw-stream, and assembled-output bytes per LLM call'),
     redactFields: Schema.array(Schema.string())
         .default([])
         .description('case-insensitive payload fields to redact'),
@@ -125,6 +130,260 @@ function requestBodyOf(options, captureContent) {
     const { signal: _, ...body } = options;
     return body;
 }
+const newPayloadBudget = (maxBytes) => ({
+    remaining: maxBytes,
+    truncated: false,
+});
+/** Take a UTF-8 prefix without ever exceeding the remaining content-byte budget. */
+function takePayloadText(value, budget) {
+    const bytes = Buffer.byteLength(value);
+    if (bytes <= budget.remaining) {
+        budget.remaining -= bytes;
+        return value;
+    }
+    budget.truncated = true;
+    if (budget.remaining <= 0)
+        return '';
+    let low = 0;
+    let high = value.length;
+    while (low < high) {
+        const middle = Math.ceil((low + high) / 2);
+        if (Buffer.byteLength(value.slice(0, middle)) <= budget.remaining)
+            low = middle;
+        else
+            high = middle - 1;
+    }
+    budget.remaining = 0;
+    return value.slice(0, low);
+}
+/** Build a preview whose complete JSON value, including its wrapper, fits the remaining cap. */
+function previewPayload(serialized, budget) {
+    const remaining = budget.remaining;
+    const marker = { truncated: true };
+    const withPreview = { ...marker, preview: '' };
+    if (Buffer.byteLength(JSON.stringify(withPreview)) <= remaining) {
+        let low = 0;
+        let high = serialized.length;
+        while (low < high) {
+            const middle = Math.ceil((low + high) / 2);
+            const candidate = { ...marker, preview: serialized.slice(0, middle) };
+            if (Buffer.byteLength(JSON.stringify(candidate)) <= remaining)
+                low = middle;
+            else
+                high = middle - 1;
+        }
+        budget.remaining = 0;
+        return { ...marker, preview: serialized.slice(0, low) };
+    }
+    if (Buffer.byteLength(JSON.stringify(marker)) <= remaining) {
+        budget.remaining = 0;
+        return marker;
+    }
+    // Even the marker is too large: retain a plain string prefix, still capped
+    // after JSON quoting/escaping rather than by source-string bytes.
+    let low = 0;
+    let high = serialized.length;
+    while (low < high) {
+        const middle = Math.ceil((low + high) / 2);
+        if (Buffer.byteLength(JSON.stringify(serialized.slice(0, middle))) <= remaining)
+            low = middle;
+        else
+            high = middle - 1;
+    }
+    budget.remaining = 0;
+    return low > 0 ? serialized.slice(0, low) : remaining >= 2 ? '' : 0;
+}
+const MAX_ATOMIC_MASK_BYTES = 64 * 1024;
+/** Redact leaves while serializing, so an oversized payload never needs a full mask or stringify. */
+function boundMaskedPayload(input, budget, reporter) {
+    const seen = new WeakSet();
+    const parts = [];
+    let remaining = budget.remaining;
+    let overflow = false;
+    const append = (text) => {
+        if (overflow || text === undefined)
+            return;
+        const bytes = Buffer.byteLength(text);
+        if (bytes > remaining) {
+            // The node was already masked atomically; a serialized prefix is safe.
+            parts.push(takePayloadText(text, { remaining, truncated: true }));
+            remaining = 0;
+            overflow = true;
+            return;
+        }
+        parts.push(text);
+        remaining -= bytes;
+    };
+    const write = (value) => {
+        if (overflow || value === undefined)
+            return undefined;
+        if (value === null || typeof value !== 'object' || value instanceof Date) {
+            if (typeof value === 'string' &&
+                Buffer.byteLength(value) > MAX_ATOMIC_MASK_BYTES &&
+                Buffer.byteLength(value) > remaining) {
+                overflow = true;
+                return undefined;
+            }
+            const masked = reporter.mask(value);
+            append(JSON.stringify(masked));
+            return masked;
+        }
+        if (seen.has(value)) {
+            append(JSON.stringify('[Circular]'));
+            return '[Circular]';
+        }
+        seen.add(value);
+        if (Array.isArray(value)) {
+            append('[');
+            const result = [];
+            for (const [index, item] of value.entries()) {
+                if (overflow)
+                    break;
+                if (index > 0)
+                    append(',');
+                if (item === undefined) {
+                    append('null');
+                    result.push(null);
+                }
+                else {
+                    const masked = write(item);
+                    if (!overflow)
+                        result.push(masked);
+                }
+            }
+            append(']');
+            seen.delete(value);
+            return result;
+        }
+        append('{');
+        const result = Object.create(null);
+        let first = true;
+        for (const key in value) {
+            if (overflow)
+                break;
+            if (!Object.hasOwn(value, key))
+                continue;
+            const child = value[key];
+            if (child === undefined && !reporter.shouldRedactField(key))
+                continue;
+            if (!first)
+                append(',');
+            first = false;
+            append(JSON.stringify(reporter.mask(key)));
+            append(':');
+            if (reporter.shouldRedactField(key)) {
+                append(JSON.stringify('[REDACTED]'));
+                result[key] = '[REDACTED]';
+            }
+            else {
+                const masked = write(child);
+                if (!overflow)
+                    result[key] = masked;
+            }
+        }
+        append('}');
+        seen.delete(value);
+        return result;
+    };
+    try {
+        const masked = write(input);
+        if (!overflow) {
+            budget.remaining = remaining;
+            return masked;
+        }
+    }
+    catch {
+        budget.truncated = true;
+        return previewPayload('', budget);
+    }
+    budget.truncated = true;
+    return previewPayload(parts.join(''), budget);
+}
+/** Bound a structured payload without changing its shape when it fits. */
+function boundPayload(input, budget, reporter) {
+    if (reporter)
+        return boundMaskedPayload(input, budget, reporter);
+    let serialized;
+    try {
+        serialized = JSON.stringify(input) ?? '';
+    }
+    catch {
+        budget.truncated = true;
+        return previewPayload('', budget);
+    }
+    const bytes = Buffer.byteLength(serialized);
+    if (bytes <= budget.remaining) {
+        budget.remaining -= bytes;
+        return input;
+    }
+    budget.truncated = true;
+    return previewPayload(serialized, budget);
+}
+/** Keep only whole chunks that fit; stream accounting still processes every original chunk. */
+function capturePayloadChunk(chunk, chunks, budget) {
+    if (budget.remaining <= 0) {
+        budget.truncated = true;
+        return;
+    }
+    let serialized;
+    try {
+        serialized = JSON.stringify(chunk) ?? '';
+    }
+    catch {
+        chunks.length = 0;
+        budget.truncated = true;
+        budget.remaining = 0;
+        return;
+    }
+    // Account for the final raw array too: [] around the first chunk and one
+    // comma per additional retained chunk, after redaction has changed lengths.
+    const bytes = Buffer.byteLength(serialized) + (chunks.length === 0 ? 2 : 1);
+    if (bytes > budget.remaining) {
+        // Partial groups are unsafe: a retained prefix may be a secret fragment.
+        chunks.length = 0;
+        budget.truncated = true;
+        budget.remaining = 0;
+        return;
+    }
+    chunks.push(chunk);
+    budget.remaining -= bytes;
+}
+/** Append only while the full assembled text fits; otherwise drop the whole channel. */
+function appendAssembledText(current, delta, budget) {
+    const bytes = Buffer.byteLength(delta);
+    if (bytes > budget.remaining) {
+        budget.truncated = true;
+        budget.remaining = 0;
+        return '';
+    }
+    budget.remaining -= bytes;
+    return current + delta;
+}
+/** Charge the whole tool-call envelope, not only its argument text. */
+function captureToolCall(call, calls, budget) {
+    if (budget.remaining <= 0) {
+        budget.truncated = true;
+        return;
+    }
+    const envelope = {
+        ...call,
+        function: { ...call.function, arguments: '' },
+    };
+    const bytes = Buffer.byteLength(JSON.stringify(envelope));
+    if (bytes > budget.remaining) {
+        budget.truncated = true;
+        budget.remaining = 0;
+        return;
+    }
+    budget.remaining -= bytes;
+    calls.push({
+        ...call,
+        function: {
+            ...call.function,
+            arguments: takePayloadText(call.function.arguments, budget),
+        },
+    });
+}
 /** Generation names carry the reply's first non-empty line (capped) for list readability. */
 function enhanceWithFirstLine(base, text) {
     const firstLine = text
@@ -269,6 +528,7 @@ export function apply(ctx, config) {
     const toolResults = new WeakMap();
     const openHooks = new Map();
     const openOperations = new Set();
+    const operationSessions = new Map();
     const traceContexts = new Map();
     const pendingMedia = new Set();
     const mediaFor = new WeakMap();
@@ -635,10 +895,11 @@ export function apply(ctx, config) {
         if (!parentSessionId)
             return;
         const childId = session.id;
-        // Parent under the enclosing delegation tool span when one is open
-        // (foreground runs execute inside the parent's tools/execute), else the
-        // parent's own subagent span (nested delegation), else the root trace.
-        const parentObservation = openToolSpans.get(parentSessionId)?.at(-1) ??
+        // Parent under the enclosing delegation tool span only when it is unique;
+        // concurrent tools have no reliable stack-top ordering, so use the known
+        // parent subagent/root instead of attributing the child to an arbitrary tool.
+        const openTools = openToolSpans.get(parentSessionId) ?? [];
+        const parentObservation = (openTools.length === 1 ? openTools[0] : undefined) ??
             children.get(parentSessionId)?.span ??
             traceFor(parentSessionId);
         const span = reporter.startSpan(parentObservation, {
@@ -651,6 +912,7 @@ export function apply(ctx, config) {
         children.set(childId, {
             parentSessionId,
             span,
+            started: false,
             hasInput: false,
             turnTrace: children.get(parentSessionId)?.turnTrace ??
                 sessions.get(rootSessionId(parentSessionId) ?? '')?.trace,
@@ -660,13 +922,17 @@ export function apply(ctx, config) {
         const child = children.get(info.id);
         if (!child)
             return; // remote (ACP) runs have no local session — nothing to nest
+        child.started = true;
         reporter.updateSpan(child.span, { metadata: { provider: info.provider, local: info.local } });
     });
     ctx.on('subagent/end', (info) => {
         const child = children.get(info.id);
         if (!child)
             return;
-        if (info.stopReason === 'error')
+        // A background child can finish after the parent moved to another turn.
+        // Only mark the root that was active when this child was created.
+        if (info.stopReason === 'error' &&
+            sessions.get(rootSessionId(info.id) ?? '')?.trace === child.turnTrace)
             noteError(info.id);
         children.delete(info.id);
         afterMedia(child.span, (endedAt) => reporter.endSpan(child.span, {
@@ -913,6 +1179,16 @@ export function apply(ctx, config) {
     });
     ctx.on('session/disposed', (session) => {
         const sessionId = session.id;
+        for (const close of [...openOperations]) {
+            if (operationSessions.get(close) === sessionId)
+                close();
+        }
+        const child = children.get(sessionId);
+        if (child && !child.started) {
+            // Activation rollback disposes the session without subagent/start/end.
+            children.delete(sessionId);
+            afterMedia(child.span, (endedAt) => reporter.endSpan(child.span, { level: 'WARNING', statusMessage: 'subagent activation rolled back' }, endedAt));
+        }
         closeHooks(sessionId);
         const state = sessions.get(sessionId);
         sessions.delete(sessionId);
@@ -951,7 +1227,12 @@ export function apply(ctx, config) {
         const oneOffRoot = options.sessionId ? null : parent;
         const generationName = options.purpose ? `llm-call [${options.purpose}]` : 'llm-call';
         const modelParameters = modelParametersOf(options, config.captureContent);
-        const input = requestBodyOf(options, config.captureContent);
+        const maxPayloadBytes = config.maxPayloadBytes ?? 256 * 1024;
+        const requestBudget = newPayloadBudget(maxPayloadBytes);
+        const rawBudget = newPayloadBudget(maxPayloadBytes);
+        const outputBudget = newPayloadBudget(maxPayloadBytes);
+        const requestBody = requestBodyOf(options, config.captureContent);
+        const input = boundPayload(requestBody, requestBudget, reporter);
         const generation = reporter.startGeneration(parent, {
             name: generationName,
             model: options.model,
@@ -966,7 +1247,12 @@ export function apply(ctx, config) {
             enrichInput(generation, Promise.all(options.messages.map(async (message) => ({
                 ...message,
                 content: await displayBlocks(message.content, ctx.get('attachments'), mediaOptions, options.signal, budget),
-            }))).then((messages) => ({ ...input, messages })));
+            }))).then((messages) => {
+                const enrichmentBudget = newPayloadBudget(maxPayloadBytes);
+                const enriched = boundPayload({ ...requestBody, messages }, enrichmentBudget, reporter);
+                requestBudget.truncated ||= enrichmentBudget.truncated;
+                return enriched;
+            }));
         }
         // The rawest request a plugin can observe: the loop-built GenerateOptions
         // verbatim, pre-adapter (the provider HTTP body is assembled inside the
@@ -1005,6 +1291,7 @@ export function apply(ctx, config) {
             closed = true;
             const endedAt = new Date();
             openOperations.delete(closeCall);
+            operationSessions.delete(closeCall);
             const failure = finish && (finish.kind === 'error' || finish.kind === 'aborted') ? finish : undefined;
             // No terminal finish chunk (the consumer abandoned the stream or
             // the adapter cut it short): the call's outcome is unknown — mark
@@ -1026,20 +1313,33 @@ export function apply(ctx, config) {
                 level = 'WARNING';
                 statusMessage = 'stream closed before the terminal finish chunk';
             }
+            // Redact complete grouped deltas before the final serialized bound;
+            // streaming capture has already bounded memory and dropped overflow whole.
+            const finalRawBudget = newPayloadBudget(maxPayloadBytes);
+            const rawOutput = boundPayload(reporter.mask(redactChunks(rawChunks, reporter)), finalRawBudget);
+            rawBudget.truncated ||= finalRawBudget.truncated;
             reporter.endSpan(requestSpan, {
-                output: config.captureContent ? redactChunks(rawChunks, reporter) : undefined,
+                output: config.captureContent ? rawOutput : undefined,
                 level,
                 statusMessage,
-                metadata: { chunkCount },
+                metadata: {
+                    chunkCount,
+                    truncated: requestBudget.truncated || rawBudget.truncated || undefined,
+                },
             }, endedAt);
             if (level === 'ERROR')
                 noteError(options.sessionId);
+            // A final independent safety bound covers the complete output envelope;
+            // an exhausted streaming budget must not erase an otherwise valid prefix.
+            const finalOutputBudget = newPayloadBudget(maxPayloadBytes);
+            const output = boundPayload(outputBody(), finalOutputBudget, reporter);
+            outputBudget.truncated ||= finalOutputBudget.truncated;
             // Partial progress counts on every path: whatever streamed is kept.
             afterMedia(generation, (endedAt) => reporter.endGeneration(generation, {
                 name: config.captureContent
                     ? enhanceWithFirstLine(generationName, reporter.mask(text))
                     : undefined,
-                output: outputBody(),
+                output,
                 usage,
                 completionStartTime,
                 level,
@@ -1049,11 +1349,16 @@ export function apply(ctx, config) {
                     errorCode: failure?.failure?.code,
                     incomplete: finish ? undefined : true,
                     toolCallCount: toolCallCount > 0 ? toolCallCount : undefined,
+                    truncated: requestBudget.truncated ||
+                        rawBudget.truncated ||
+                        outputBudget.truncated ||
+                        undefined,
                 },
             }, endedAt), endedAt);
             reporter.endSpan(oneOffRoot, {}, endedAt);
         };
         openOperations.add(closeCall);
+        operationSessions.set(closeCall, options.sessionId);
         let stream;
         try {
             stream = next();
@@ -1073,7 +1378,7 @@ export function apply(ctx, config) {
                     }
                     chunkCount += 1;
                     if (config.captureContent)
-                        rawChunks.push(chunk);
+                        capturePayloadChunk(chunk, rawChunks, rawBudget);
                     // TTFT is the first real token — block boundaries, usage frames and
                     // empty heartbeat deltas are not completions (the predicate above).
                     if (completionStartTime === undefined && isTokenDelta(chunk)) {
@@ -1082,21 +1387,39 @@ export function apply(ctx, config) {
                     switch (chunk.type) {
                         case 'text-delta':
                             if (config.captureContent)
-                                text += chunk.text;
+                                text = appendAssembledText(text, chunk.text, outputBudget);
                             break;
                         case 'reasoning-delta':
                             if (config.captureContent)
-                                reasoning += chunk.text;
+                                reasoning = appendAssembledText(reasoning, chunk.text, outputBudget);
                             break;
                         case 'block-end':
                             if (chunk.block.type === 'tool-call') {
                                 toolCallCount += 1;
-                                if (config.captureContent)
-                                    toolCalls.push({
+                                if (config.captureContent) {
+                                    if (outputBudget.remaining <= 0) {
+                                        outputBudget.truncated = true;
+                                        break;
+                                    }
+                                    const envelopeBytes = Buffer.byteLength(JSON.stringify({
+                                        id: chunk.block.id,
+                                        type: 'function',
+                                        function: { name: chunk.block.name, arguments: '' },
+                                    }));
+                                    if (envelopeBytes > outputBudget.remaining) {
+                                        outputBudget.truncated = true;
+                                        outputBudget.remaining = 0;
+                                        break;
+                                    }
+                                    captureToolCall({
                                         id: chunk.block.id,
                                         type: 'function',
-                                        function: { name: chunk.block.name, arguments: chunk.block.arguments },
-                                    });
+                                        function: {
+                                            name: chunk.block.name,
+                                            arguments: reporter.mask(chunk.block.arguments),
+                                        },
+                                    }, toolCalls, outputBudget);
+                                }
                             }
                             break;
                         case 'usage':
@@ -1159,6 +1482,7 @@ export function apply(ctx, config) {
             closed = true;
             const endedAt = new Date();
             openOperations.delete(closeTool);
+            operationSessions.delete(closeTool);
             toolResults.delete(exec);
             if (sessionId && toolCalls.get(sessionId)?.get(exec.callId)?.span === span) {
                 const calls = toolCalls.get(sessionId);
@@ -1186,6 +1510,7 @@ export function apply(ctx, config) {
                 end();
         }
         openOperations.add(closeTool);
+        operationSessions.set(closeTool, sessionId);
         toolResults.set(exec, (result) => {
             if (closed)
                 return;

package/lib/types/client.d.ts

@@ -92,6 +92,8 @@ export declare class LangfuseReporter {
     /** Settles (never rejects) once the lazy SDK import+wiring finished. */
     readonly ready: Promise<void>;
     constructor(config: LangfuseConnectionConfig);
+    /** Whether a payload property should be replaced without inspecting its value. */
+    shouldRedactField(key: string): boolean;
     /** Clone telemetry only; never mutate harness-owned messages or tool results. */
     mask<T>(data: T): T;
     /** Dynamically import the SDK and wire the isolated export pipeline. */

package/lib/types/index.d.ts

@@ -70,39 +70,41 @@ export declare const name = "dsh-langfuse";
  * prefer fail-fast wiring.
  */
 export declare const inject: string[];
-export declare const Config: Schema<Schemastery.ObjectS<{
-    enabled: Schema<boolean, boolean>;
-    publicKey: Schema<string, string>;
-    secretKey: Schema<string, string>;
-    baseUrl: Schema<string, string>;
-    traceName: Schema<string, string>;
+export declare const Config: Schema<Schemastery.ObjectS<NoInfer<{
+    enabled: Schema<boolean, boolean, "defined">;
+    publicKey: Schema<string, string, "defined">;
+    secretKey: Schema<string, string, "defined">;
+    baseUrl: Schema<string, string, "defined">;
+    traceName: Schema<string, string, "defined">;
     /** Include full message/tool payloads in Langfuse IO. Disable to log metadata only. */
-    captureContent: Schema<boolean, boolean>;
-    redactFields: Schema<string[], string[]>;
-    userId: Schema<string, string>;
-    tags: Schema<string[], string[]>;
-    environment: Schema<string, string>;
-    release: Schema<string, string>;
-    captureMedia: Schema<boolean, boolean>;
-    maxMediaBytes: Schema<number, number>;
-    mediaTimeoutMs: Schema<number, number>;
-}>, Schemastery.ObjectT<{
-    enabled: Schema<boolean, boolean>;
-    publicKey: Schema<string, string>;
-    secretKey: Schema<string, string>;
-    baseUrl: Schema<string, string>;
-    traceName: Schema<string, string>;
+    captureContent: Schema<boolean, boolean, "defined">;
+    maxPayloadBytes: Schema<number, number, "defined">;
+    redactFields: Schema<string[], string[], "defined">;
+    userId: Schema<string, string, "defined">;
+    tags: Schema<string[], string[], "defined">;
+    environment: Schema<string, string, "defined">;
+    release: Schema<string, string, "defined">;
+    captureMedia: Schema<boolean, boolean, "defined">;
+    maxMediaBytes: Schema<number, number, "defined">;
+    mediaTimeoutMs: Schema<number, number, "defined">;
+}>>, Schemastery.ObjectT<NoInfer<{
+    enabled: Schema<boolean, boolean, "defined">;
+    publicKey: Schema<string, string, "defined">;
+    secretKey: Schema<string, string, "defined">;
+    baseUrl: Schema<string, string, "defined">;
+    traceName: Schema<string, string, "defined">;
     /** Include full message/tool payloads in Langfuse IO. Disable to log metadata only. */
-    captureContent: Schema<boolean, boolean>;
-    redactFields: Schema<string[], string[]>;
-    userId: Schema<string, string>;
-    tags: Schema<string[], string[]>;
-    environment: Schema<string, string>;
-    release: Schema<string, string>;
-    captureMedia: Schema<boolean, boolean>;
-    maxMediaBytes: Schema<number, number>;
-    mediaTimeoutMs: Schema<number, number>;
-}>>;
+    captureContent: Schema<boolean, boolean, "defined">;
+    maxPayloadBytes: Schema<number, number, "defined">;
+    redactFields: Schema<string[], string[], "defined">;
+    userId: Schema<string, string, "defined">;
+    tags: Schema<string[], string[], "defined">;
+    environment: Schema<string, string, "defined">;
+    release: Schema<string, string, "defined">;
+    captureMedia: Schema<boolean, boolean, "defined">;
+    maxMediaBytes: Schema<number, number, "defined">;
+    mediaTimeoutMs: Schema<number, number, "defined">;
+}>>, "plain">;
 export interface LangfusePluginConfig {
     enabled: boolean;
     publicKey: string;
@@ -110,6 +112,7 @@ export interface LangfusePluginConfig {
     baseUrl: string;
     traceName: string;
     captureContent: boolean;
+    maxPayloadBytes?: number;
     redactFields?: string[];
     userId?: string;
     tags?: string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amaster.ai/dsh-langfuse",
-  "version": "0.1.34",
+  "version": "0.1.35",
   "description": "Langfuse observability plugin for DeepSeek Harness: one generation per LLM call with a nested llm-request span, one span per tool call, one trace per session turn, subagent child sessions nested under the parent's tree.",
   "type": "module",
   "main": "lib/index.js",
@@ -32,7 +32,7 @@
     }
   },
   "dependencies": {
-    "@deepseek-ai/schemastery": "^3.18.1"
+    "@deepseek-ai/schemastery": "^3.18.5"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
@@ -65,16 +65,16 @@
   },
   "devDependencies": {
     "@deepseek-ai/cordis": "4.0.5",
-    "@deepseek-ai/dsh-agent": "0.2.1-rc.4",
-    "@deepseek-ai/dsh-attachment": "0.2.1-rc.4",
-    "@deepseek-ai/dsh-hook-protocol": "0.2.1-rc.4",
-    "@deepseek-ai/dsh-llm": "0.2.1-rc.4",
-    "@deepseek-ai/dsh-ptc-runtime": "0.2.1-rc.4",
-    "@deepseek-ai/dsh-session": "0.2.1-rc.4",
-    "@deepseek-ai/dsh-session-projection": "0.2.1-rc.4",
-    "@deepseek-ai/dsh-subagent": "0.2.1-rc.4",
-    "@deepseek-ai/dsh-tools": "0.2.1-rc.4",
-    "@deepseek-ai/dsh-util-time": "0.2.1-rc.4",
+    "@deepseek-ai/dsh-agent": "0.2.1-rc.5",
+    "@deepseek-ai/dsh-attachment": "0.2.1-rc.5",
+    "@deepseek-ai/dsh-hook-protocol": "0.2.1-rc.5",
+    "@deepseek-ai/dsh-llm": "0.2.1-rc.5",
+    "@deepseek-ai/dsh-ptc-runtime": "0.2.1-rc.5",
+    "@deepseek-ai/dsh-session": "0.2.1-rc.5",
+    "@deepseek-ai/dsh-session-projection": "0.2.1-rc.5",
+    "@deepseek-ai/dsh-subagent": "0.2.1-rc.5",
+    "@deepseek-ai/dsh-tools": "0.2.1-rc.5",
+    "@deepseek-ai/dsh-util-time": "0.2.1-rc.5",
     "@langfuse/otel": "5.10.1",
     "@langfuse/tracing": "5.10.1",
     "@opentelemetry/api": "^1.9.1",