@juspay/neurolink 12.53.0 → 12.54.0

package/dist/core/toolExecutionGuards.js

@@ -33,7 +33,15 @@ export function guardToolExecutor(name, execute, guards) {
         // The span wraps the CALL, not the guard: a timeout or an abort is a fact
         // about this tool invocation and belongs inside its observation.
         const wrapInSpan = guards.withToolSpan;
-        const call = wrapInSpan ? () => wrapInSpan(name, invoke) : invoke;
+        const toolCallId = typeof opts === "object" &&
+            opts !== null &&
+            "toolCallId" in opts &&
+            typeof opts.toolCallId === "string"
+            ? opts.toolCallId
+            : undefined;
+        const call = wrapInSpan
+            ? () => wrapInSpan(name, invoke, { args, toolCallId })
+            : invoke;
         guards.onProgress?.();
         try {
             const raced = guards.abortSignal

package/dist/providers/googleVertex/client.js

@@ -43,7 +43,7 @@ import { createStreamChannel } from "../../core/streamChannel.js";
 import { toNativeToolDeclarations } from "../../core/nativeToolFormat.js";
 import { getAvailableInputTokens, getContextWindowSize, } from "../../constants/contextWindows.js";
 import { resolveLiveTool } from "../../tools/toolDiscovery.js";
-import { ATTR, LANGFUSE_ATTR, spanJsonAttribute, tracers, withClientSpan, withClientStreamSpan, withSpan, } from "../../telemetry/index.js";
+import { ATTR, LANGFUSE_ATTR, spanContentAttribute, spanJsonAttribute, spanModelRequestAttribute, tracers, withClientSpan, withClientStreamSpan, withSpan, } from "../../telemetry/index.js";
 import { SpanKind, SpanStatusCode, context as otelContext, trace as otelTrace, } from "@opentelemetry/api";
 import { calculateCost } from "../../utils/pricing.js";
 import { transformToolExecutions } from "../../utils/transformationUtils.js";
@@ -3459,7 +3459,7 @@ export class GoogleVertexProvider extends BaseProvider {
         // Usage lives ONLY on the generation spans (Langfuse sums usage across
         // observations for trace totals, so repeating it on the turn double-counts).
         const offeredToolNames = (tools ?? []).map((anthropicTool) => anthropicTool.name);
-        const turnInputAttribute = spanJsonAttribute({
+        const turnInputAttribute = spanModelRequestAttribute({
             system: systemPromptWithSchema,
             messages: sanitizeAnthropicMessagesForTrace(messages),
         });
@@ -3543,6 +3543,7 @@ export class GoogleVertexProvider extends BaseProvider {
         const loopPromise = (async () => {
             let step = 0;
             const currentMessages = [...messages];
+            let stepConversation = currentMessages;
             // Step-cap / abort bookkeeping (mirrors the generate twin): read by the
             // terminal recovery block after the loop and by the finishReason
             // mapping written into finishReasonRef.
@@ -3569,18 +3570,34 @@ export class GoogleVertexProvider extends BaseProvider {
                 // migration. Shared with resolveToolOnMiss below: the old dispatch
                 // opened the span before the executor lookup, so a tool hydrated
                 // mid-turn was observed exactly like one declared up front.
-                const withToolSpan = (toolCallName, run) => {
+                const withToolSpan = (toolCallName, run, call) => {
+                    // Arguments are inputs: honour the same opt-out the AI SDK path uses.
+                    const argsAttribute = call?.args !== undefined &&
+                        process.env.NEUROLINK_RECORD_INPUTS?.trim().toLowerCase() !==
+                            "false"
+                        ? spanContentAttribute(call.args)
+                        : undefined;
                     const toolSpan = tracers.mcp.startSpan("ai.toolCall", {
                         kind: SpanKind.INTERNAL,
                         attributes: {
                             [LANGFUSE_ATTR.OBSERVATION_TYPE]: "tool",
                             [ATTR.GEN_AI_TOOL_NAME]: toolCallName,
                             "ai.toolCall.name": toolCallName,
+                            ...(call?.toolCallId
+                                ? { "ai.toolCall.id": call.toolCallId }
+                                : {}),
+                            ...(argsAttribute !== undefined
+                                ? {
+                                    "ai.toolCall.args": argsAttribute,
+                                    [LANGFUSE_ATTR.OBSERVATION_INPUT]: argsAttribute,
+                                }
+                                : {}),
                         },
                     }, turnContext);
                     const finish = (output, errorMessage) => {
-                        toolSpan.setAttribute("ai.toolCall.result", spanJsonAttribute(output));
-                        toolSpan.setAttribute(LANGFUSE_ATTR.OBSERVATION_OUTPUT, spanJsonAttribute(output));
+                        const outputAttribute = spanContentAttribute(output);
+                        toolSpan.setAttribute("ai.toolCall.result", outputAttribute);
+                        toolSpan.setAttribute(LANGFUSE_ATTR.OBSERVATION_OUTPUT, outputAttribute);
                         if (errorMessage) {
                             toolSpan.setAttribute(LANGFUSE_ATTR.OBSERVATION_LEVEL, "ERROR");
                             toolSpan.setAttribute(LANGFUSE_ATTR.OBSERVATION_STATUS_MESSAGE, errorMessage);
@@ -3742,6 +3759,7 @@ export class GoogleVertexProvider extends BaseProvider {
                     ...baseAdapter,
                     buildStepRequest: (conversation, engineStep) => {
                         step = engineStep + 1;
+                        stepConversation = conversation;
                         turnClock.noteProgress();
                         return baseAdapter.buildStepRequest(conversation, engineStep);
                     },
@@ -3782,9 +3800,9 @@ export class GoogleVertexProvider extends BaseProvider {
                                     temperature: requestParams.temperature,
                                     top_p: requestParams.top_p,
                                 }),
-                                [LANGFUSE_ATTR.OBSERVATION_INPUT]: spanJsonAttribute({
+                                [LANGFUSE_ATTR.OBSERVATION_INPUT]: spanModelRequestAttribute({
                                     system: systemPromptWithSchema,
-                                    messages: sanitizeAnthropicMessagesForTrace(currentMessages),
+                                    messages: sanitizeAnthropicMessagesForTrace(stepConversation),
                                 }),
                                 [LANGFUSE_ATTR.OBSERVATION_METADATA]: spanJsonAttribute({
                                     step,
@@ -3812,7 +3830,13 @@ export class GoogleVertexProvider extends BaseProvider {
                             turnCacheUsage.creation += result.usage.cacheWriteTokens ?? 0;
                             turnCacheUsage.creation5m += result.usage.cacheWrite5mTokens ?? 0;
                             turnCacheUsage.creation1h += result.usage.cacheWrite1hTokens ?? 0;
-                            generationSpan.setAttribute(LANGFUSE_ATTR.OBSERVATION_OUTPUT, spanJsonAttribute({ text: result.text }));
+                            generationSpan.setAttribute(LANGFUSE_ATTR.OBSERVATION_OUTPUT, spanContentAttribute({
+                                text: result.text,
+                                ...(result.toolCalls.length > 0
+                                    ? { toolCalls: result.toolCalls }
+                                    : {}),
+                            }));
+                            generationSpan.setAttribute(`${LANGFUSE_ATTR.OBSERVATION_METADATA}.finishReason`, result.rawStopReason ?? "unknown");
                             return result;
                         }
                         catch (error) {
@@ -4339,7 +4363,7 @@ export class GoogleVertexProvider extends BaseProvider {
                 if (turnCacheUsage.creation > 0) {
                     usage.cacheCreationTokens = turnCacheUsage.creation;
                 }
-                const turnOutputAttribute = spanJsonAttribute({
+                const turnOutputAttribute = spanContentAttribute({
                     text: aggregatedTurnText,
                     ...(structuredOutputRef.value
                         ? { structuredOutput: structuredOutputRef.value }
@@ -4357,6 +4381,7 @@ export class GoogleVertexProvider extends BaseProvider {
                     toolCallCount: metadata.totalToolExecutions,
                     toolsCalled: toolsUsedRef.filter((name) => name !== "final_result"),
                     structuredOutput: useFinalResultTool,
+                    ...(stopReasonRef.value ? { stopReason: stopReasonRef.value } : {}),
                     usage: {
                         input: usage.input,
                         output: usage.output,
@@ -4366,10 +4391,25 @@ export class GoogleVertexProvider extends BaseProvider {
                         input_cache_creation_1h: turnCacheUsage.creation1h,
                     },
                 }));
+                // How the turn ended, on the trace itself, so an evaluator can select
+                // only turns that finished ("completed") and skip capped, timed-out,
+                // aborted and failed ones. A trace holding several turns keeps the last
+                // one's; each turn's own is in its observation metadata above.
+                if (stopReasonRef.value) {
+                    turnSpan.setAttribute(`${LANGFUSE_ATTR.TRACE_METADATA}.stopReason`, stopReasonRef.value);
+                }
                 turnSpan.setStatus({ code: SpanStatusCode.OK });
                 channel.close();
             }
             catch (err) {
+                turnSpan.setAttribute(LANGFUSE_ATTR.OBSERVATION_METADATA, spanJsonAttribute({
+                    toolsOffered: offeredToolNames,
+                    toolCount: offeredToolNames.length,
+                    maxSteps,
+                    structuredOutput: useFinalResultTool,
+                    stopReason: "provider-error",
+                }));
+                turnSpan.setAttribute(`${LANGFUSE_ATTR.TRACE_METADATA}.stopReason`, "provider-error");
                 turnSpan.setStatus({
                     code: SpanStatusCode.ERROR,
                     message: err instanceof Error ? err.message : String(err),
@@ -5635,7 +5675,7 @@ export class GoogleVertexProvider extends BaseProvider {
                 "";
             // Set generation input before the call so error paths still carry the
             // request; output is set after the native call resolves.
-            const generationInputAttribute = spanJsonAttribute({
+            const generationInputAttribute = spanModelRequestAttribute({
                 ...(mergedOptions.systemPrompt
                     ? { system: mergedOptions.systemPrompt }
                     : {}),
@@ -5676,7 +5716,7 @@ export class GoogleVertexProvider extends BaseProvider {
                         });
                         nativeResult = await this.runNativeGenerateWithMiddleware(mergedOptions, modelName, (effectiveOptions) => this.executeNativeGemini3GenerateWithSchemaFallback(effectiveOptions, modelName));
                     }
-                    executionSpan.setAttribute(LANGFUSE_ATTR.OBSERVATION_OUTPUT, spanJsonAttribute(nativeResult?.content ?? ""));
+                    executionSpan.setAttribute(LANGFUSE_ATTR.OBSERVATION_OUTPUT, spanContentAttribute(nativeResult?.content ?? ""));
                     return nativeResult;
                 });
                 this.attachUsageAndCostAttributes(generateSpan, modelName, result?.usage);
@@ -5685,7 +5725,7 @@ export class GoogleVertexProvider extends BaseProvider {
                 // enabled / useAiResponse is false, so the cost is zero on
                 // non-TTS paths.
                 result = await this.synthesizeAIResponseIfNeeded(result, options);
-                generateSpan.setAttribute(LANGFUSE_ATTR.OBSERVATION_OUTPUT, spanJsonAttribute(result?.content ?? ""));
+                generateSpan.setAttribute(LANGFUSE_ATTR.OBSERVATION_OUTPUT, spanContentAttribute(result?.content ?? ""));
                 // Fire onFinish lifecycle callback for the native generate path.
                 // Pipeline A providers get this for free via the AI SDK middleware
                 // wrapper (LifecycleMiddleware); native @google/genai bypasses

package/dist/services/server/ai/observability/instrumentation.d.ts

@@ -124,6 +124,8 @@ export declare function setLangfuseContext<T = void>(context: {
     requestId?: string | null;
     traceName?: string | null;
     metadata?: Record<string, unknown> | null;
+    /** Langfuse trace tags, set on the trace's root span */
+    tags?: string[] | null;
     /** Explicit operation name (overrides auto-detection) */
     operationName?: string | null;
     /** Override global autoDetectOperationName for this context */

package/dist/services/server/ai/observability/instrumentation.js

@@ -298,6 +298,9 @@ class ContextEnricher {
             span.setAttribute("langfuse.trace.name", traceName);
             span.setAttribute("trace.name", traceName);
         }
+        if (isRootSpan && context?.tags && context.tags.length > 0) {
+            span.setAttribute("langfuse.trace.tags", [...context.tags]);
+        }
         // Set operation name as separate attribute for filtering/analytics
         if (operationName) {
             span.setAttribute("gen_ai.operation.name", operationName);
@@ -1163,6 +1166,7 @@ export async function setLangfuseContext(context, callback) {
         metadata: context.metadata !== undefined
             ? context.metadata
             : currentContext.metadata,
+        tags: context.tags !== undefined ? context.tags : currentContext.tags,
         // Operation name support
         operationName: context.operationName !== undefined
             ? context.operationName

package/dist/telemetry/attributes.d.ts

@@ -1,3 +1,4 @@
+import type { SpanModelRequest } from "../types/index.js";
 export declare const ATTR: {
     readonly GEN_AI_SYSTEM: "gen_ai.system";
     readonly GEN_AI_MODEL: "gen_ai.request.model";
@@ -114,6 +115,8 @@ export declare const LANGFUSE_ATTR: {
     readonly TRACE_NAME: "langfuse.trace.name";
     readonly TRACE_INPUT: "langfuse.trace.input";
     readonly TRACE_OUTPUT: "langfuse.trace.output";
+    readonly TRACE_TAGS: "langfuse.trace.tags";
+    readonly TRACE_METADATA: "langfuse.trace.metadata";
     readonly OBSERVATION_TYPE: "langfuse.observation.type";
     readonly OBSERVATION_INPUT: "langfuse.observation.input";
     readonly OBSERVATION_OUTPUT: "langfuse.observation.output";
@@ -127,6 +130,24 @@ export declare const LANGFUSE_ATTR: {
 };
 /** Default ceiling for serialized span attribute values. */
 export declare const SPAN_ATTRIBUTE_MAX_CHARS = 40000;
+/**
+ * Returns a copy of `value` with credentials masked: values under keys such as
+ * `access_token`, `password`, `authorization` or `set-cookie`, bearer tokens
+ * and `name=value` credentials inside text. Content with nothing sensitive in
+ * it serializes exactly as it did before. Throws only if the value cannot be
+ * walked; callers on the tracing path use `spanContentAttribute`, which turns
+ * that into an omitted value instead of a leak or a failed turn.
+ */
+export declare function redactSpanContent(value: unknown): unknown;
+/**
+ * `spanJsonAttribute` for content a person or model wrote or a tool returned
+ * (arguments, results, answers), with credentials masked first. Use the plain
+ * form for metadata such as usage counts and server ids.
+ *
+ * A structured value over the cap is shortened by trimming its longest
+ * strings, so the attribute stays valid JSON instead of ending mid-token.
+ */
+export declare function spanContentAttribute(value: unknown, maxChars?: number): string;
 /**
  * Serialize an arbitrary value for a span attribute, hard-capped at
  * `maxChars` so a pathological prompt or tool result can't put megabytes
@@ -134,3 +155,14 @@ export declare const SPAN_ATTRIBUTE_MAX_CHARS = 40000;
  * JSON-stringified with a String() fallback for circular structures.
  */
 export declare function spanJsonAttribute(value: unknown, maxChars?: number): string;
+/**
+ * Serialize a model request for a span attribute without losing the
+ * conversation to the cap.
+ *
+ * A head cut keeps the system prompt and drops everything after it, so a long
+ * system prompt hides every message, the user's question included. Here the
+ * prompt and the newest messages are budgeted first, older messages are
+ * dropped whole and counted, and the system prompt gets whatever room is left.
+ * The result is always valid JSON.
+ */
+export declare function spanModelRequestAttribute(rawRequest: SpanModelRequest, maxChars?: number): string;

package/dist/telemetry/attributes.js

@@ -125,6 +125,8 @@ export const LANGFUSE_ATTR = {
     TRACE_NAME: "langfuse.trace.name",
     TRACE_INPUT: "langfuse.trace.input",
     TRACE_OUTPUT: "langfuse.trace.output",
+    TRACE_TAGS: "langfuse.trace.tags",
+    TRACE_METADATA: "langfuse.trace.metadata",
     OBSERVATION_TYPE: "langfuse.observation.type",
     OBSERVATION_INPUT: "langfuse.observation.input",
     OBSERVATION_OUTPUT: "langfuse.observation.output",
@@ -138,6 +140,174 @@ export const LANGFUSE_ATTR = {
 };
 /** Default ceiling for serialized span attribute values. */
 export const SPAN_ATTRIBUTE_MAX_CHARS = 40_000;
+/** Opening of the system prompt a model-request attribute always keeps. */
+const SYSTEM_PROMPT_FLOOR_CHARS = 2_000;
+/** Room for the "...[truncated N chars]" note, kept outside that opening. */
+const TRUNCATION_NOTE_ALLOWANCE_CHARS = 48;
+const MIN_SHRINKABLE_STRING_CHARS = 64;
+const REDACTED_VALUE = "[REDACTED]";
+const REDACTION_FAILED_VALUE = "[content omitted: redaction failed]";
+const SENSITIVE_KEY_PATTERN = /(authorization|password|passwd|secret|apikey|privatekey|token|credential|signature)/;
+const COOKIE_KEY_PATTERN = /^(set)?cookies?$/;
+// Cheap pre-check: text without any of these is returned untouched, so the
+// common case costs one regex scan and stays byte-identical.
+const SENSITIVE_HINT_PATTERN = /authorization|password|passwd|secret|api[_-]?key|private[_-]?key|token|credential|signature|cookie|bearer/i;
+function isSensitiveKey(key) {
+    const normalized = key.replace(/[_-]/g, "").toLowerCase();
+    return (SENSITIVE_KEY_PATTERN.test(normalized) ||
+        COOKIE_KEY_PATTERN.test(normalized));
+}
+// JSON that a tool returned as text, carried inside JSON the model sees as a
+// string, has its quotes escaped once per level of nesting, and each level
+// doubles the backslashes before the quote: one, three, seven.
+const ESCAPED_QUOTE_BACKSLASHES = [1, 3, 7];
+const ESCAPED_PAIR_PATTERNS = ESCAPED_QUOTE_BACKSLASHES.map((backslashes) => {
+    const quote = `${"\\\\".repeat(backslashes)}"`;
+    return new RegExp(`${quote}([^"\\\\]{1,80})${quote}(\\s*:\\s*)${quote}((?:(?!${quote})[\\s\\S]){0,8192})${quote}`, "g");
+});
+/**
+ * Masks credentials in text that is about to be written to a span: bearer
+ * tokens, `name=value` credentials in URLs and form bodies, and the values of
+ * sensitive keys in JSON text (tool results arrive as JSON strings).
+ */
+function redactText(text) {
+    if (!SENSITIVE_HINT_PATTERN.test(text)) {
+        return text;
+    }
+    let redacted = text
+        .replace(/\bBearer\s+[\w.\-+/=]{16,}/gi, `Bearer ${REDACTED_VALUE}`)
+        .replace(/\b(access_token|refresh_token|id_token|api_key|apikey|client_secret|password|signature|credential)=([^&\s"]+)/gi, `$1=${REDACTED_VALUE}`)
+        .replace(/"([^"\\]{1,80})"(\s*:\s*)"(?:[^"\\]|\\.)*"/g, (match, key, separator) => isSensitiveKey(key) ? `"${key}"${separator}"${REDACTED_VALUE}"` : match);
+    ESCAPED_QUOTE_BACKSLASHES.forEach((backslashes, index) => {
+        const quote = `${"\\".repeat(backslashes)}"`;
+        redacted = redacted.replace(ESCAPED_PAIR_PATTERNS[index], (match, key, separator) => isSensitiveKey(key)
+            ? `${quote}${key}${quote}${separator}${quote}${REDACTED_VALUE}${quote}`
+            : match);
+    });
+    return redacted;
+}
+function redactNode(value, ancestors) {
+    if (typeof value === "string") {
+        return redactText(value);
+    }
+    if (value === null || typeof value !== "object") {
+        return value;
+    }
+    if (ancestors.has(value)) {
+        return "[circular]";
+    }
+    ancestors.add(value);
+    try {
+        if ("toJSON" in value && typeof value.toJSON === "function") {
+            return redactNode(value.toJSON(), ancestors);
+        }
+        if (Array.isArray(value)) {
+            return value.map((entry) => redactNode(entry, ancestors));
+        }
+        // No prototype, so a key named __proto__ is data rather than an assignment.
+        const redacted = Object.create(null);
+        for (const [key, entry] of Object.entries(value)) {
+            // Counts and flags under a sensitive-looking name (input_tokens: 5) are
+            // not credentials; only text and structures are masked.
+            redacted[key] =
+                isSensitiveKey(key) &&
+                    (typeof entry === "string" ||
+                        (typeof entry === "object" && entry !== null))
+                    ? REDACTED_VALUE
+                    : redactNode(entry, ancestors);
+        }
+        return redacted;
+    }
+    finally {
+        ancestors.delete(value);
+    }
+}
+/**
+ * Returns a copy of `value` with credentials masked: values under keys such as
+ * `access_token`, `password`, `authorization` or `set-cookie`, bearer tokens
+ * and `name=value` credentials inside text. Content with nothing sensitive in
+ * it serializes exactly as it did before. Throws only if the value cannot be
+ * walked; callers on the tracing path use `spanContentAttribute`, which turns
+ * that into an omitted value instead of a leak or a failed turn.
+ */
+export function redactSpanContent(value) {
+    return redactNode(value, new WeakSet());
+}
+function redactSafely(value) {
+    try {
+        return redactSpanContent(value);
+    }
+    catch {
+        return REDACTION_FAILED_VALUE;
+    }
+}
+const MAX_SHRINK_ATTEMPTS = 200;
+/**
+ * Cuts the longest string inside `root` down by at least `excess` characters,
+ * in place, and says whether it found one worth cutting. Only ever called on
+ * the copy `redactSpanContent` made, never on the caller's own data.
+ */
+function shrinkLongestString(root, excess) {
+    let owner;
+    let ownerKey = "";
+    let longestText = "";
+    const visited = new Set();
+    const pending = [root];
+    while (pending.length > 0) {
+        const node = pending.pop();
+        if (node === undefined || visited.has(node)) {
+            continue;
+        }
+        visited.add(node);
+        for (const [key, entry] of Object.entries(node)) {
+            if (typeof entry === "string") {
+                if (entry.length > longestText.length &&
+                    entry.length > MIN_SHRINKABLE_STRING_CHARS) {
+                    longestText = entry;
+                    owner = node;
+                    ownerKey = key;
+                }
+            }
+            else if (entry !== null && typeof entry === "object") {
+                pending.push(entry);
+            }
+        }
+    }
+    if (owner === undefined) {
+        return false;
+    }
+    const keep = Math.max(MIN_SHRINKABLE_STRING_CHARS / 2, longestText.length - excess - TRUNCATION_NOTE_ALLOWANCE_CHARS);
+    Reflect.set(owner, ownerKey, `${longestText.slice(0, keep)}...[truncated ${longestText.length - keep} chars]`);
+    return true;
+}
+/**
+ * `spanJsonAttribute` for content a person or model wrote or a tool returned
+ * (arguments, results, answers), with credentials masked first. Use the plain
+ * form for metadata such as usage counts and server ids.
+ *
+ * A structured value over the cap is shortened by trimming its longest
+ * strings, so the attribute stays valid JSON instead of ending mid-token.
+ */
+export function spanContentAttribute(value, maxChars = SPAN_ATTRIBUTE_MAX_CHARS) {
+    const redacted = redactSafely(value);
+    if (redacted === null || typeof redacted !== "object") {
+        return spanJsonAttribute(redacted, maxChars);
+    }
+    let serialized;
+    try {
+        serialized = JSON.stringify(redacted) ?? String(redacted);
+    }
+    catch {
+        return spanJsonAttribute(redacted, maxChars);
+    }
+    for (let attempt = 0; serialized.length > maxChars && attempt < MAX_SHRINK_ATTEMPTS; attempt++) {
+        if (!shrinkLongestString(redacted, serialized.length - maxChars)) {
+            break;
+        }
+        serialized = JSON.stringify(redacted);
+    }
+    return spanJsonAttribute(serialized, maxChars);
+}
 /**
  * Serialize an arbitrary value for a span attribute, hard-capped at
  * `maxChars` so a pathological prompt or tool result can't put megabytes
@@ -162,3 +332,122 @@ export function spanJsonAttribute(value, maxChars = SPAN_ATTRIBUTE_MAX_CHARS) {
     }
     return serialized;
 }
+/**
+ * Serialize a model request for a span attribute without losing the
+ * conversation to the cap.
+ *
+ * A head cut keeps the system prompt and drops everything after it, so a long
+ * system prompt hides every message, the user's question included. Here the
+ * prompt and the newest messages are budgeted first, older messages are
+ * dropped whole and counted, and the system prompt gets whatever room is left.
+ * The result is always valid JSON.
+ */
+export function spanModelRequestAttribute(rawRequest, maxChars = SPAN_ATTRIBUTE_MAX_CHARS) {
+    // Credentials are masked before anything is measured, so budgets apply to
+    // what is actually written. Each message is masked on its own: one that
+    // cannot be walked is omitted without losing the rest of the conversation.
+    const request = {
+        ...(rawRequest.system !== undefined
+            ? { system: redactSafely(rawRequest.system) }
+            : {}),
+        ...(rawRequest.messages !== undefined
+            ? {
+                messages: rawRequest.messages.map((message) => redactSafely(message)),
+            }
+            : {}),
+        ...(rawRequest.prompt !== undefined
+            ? { prompt: redactText(rawRequest.prompt) }
+            : {}),
+    };
+    const serialize = (value) => {
+        try {
+            return typeof value === "string"
+                ? value
+                : (JSON.stringify(value) ?? String(value));
+        }
+        catch {
+            return String(value);
+        }
+    };
+    // Sizes are measured as JSON, which is what the attribute carries: escaping
+    // makes a JSON string longer than its text.
+    const jsonLength = (value) => {
+        try {
+            return (JSON.stringify(value) ?? "null").length;
+        }
+        catch {
+            return Number.POSITIVE_INFINITY;
+        }
+    };
+    // Never returns an empty string for non-empty text: when nothing fits, the
+    // truncation note alone says the value existed and how long it was.
+    const fitText = (text, budget) => {
+        if (jsonLength(text) <= budget) {
+            return text;
+        }
+        let keep = budget;
+        for (let attempt = 0; attempt < 12 && keep > 0; attempt++) {
+            const candidate = `${text.slice(0, keep)}...[truncated ${text.length - keep} chars]`;
+            const size = jsonLength(candidate);
+            if (size <= budget) {
+                return candidate;
+            }
+            keep = Math.floor((keep * budget) / size) - 1;
+        }
+        return `[truncated ${text.length} chars]`;
+    };
+    // Room for keys, brackets and the omitted-message count.
+    let remaining = maxChars - 128;
+    // The system prompt always keeps its opening, so a trace still shows which
+    // prompt was in use. Reserved before the messages are budgeted and returned
+    // to the system prompt afterwards; a request that fits is unaffected.
+    const systemFloor = request.system !== undefined
+        ? Math.min(jsonLength(request.system), SYSTEM_PROMPT_FLOOR_CHARS + TRUNCATION_NOTE_ALLOWANCE_CHARS)
+        : 0;
+    remaining -= systemFloor;
+    let prompt;
+    if (request.prompt !== undefined) {
+        prompt = fitText(request.prompt, remaining);
+        remaining -= jsonLength(prompt);
+    }
+    const messages = request.messages ?? [];
+    const kept = [];
+    for (let index = messages.length - 1; index >= 0; index--) {
+        const size = jsonLength(messages[index]) + 1;
+        if (size <= remaining) {
+            kept.unshift(messages[index]);
+            remaining -= size;
+            continue;
+        }
+        if (kept.length === 0 && remaining > 64) {
+            const excerpt = fitText(serialize(messages[index]), remaining - 32);
+            kept.unshift({ truncatedMessage: excerpt });
+            remaining -= jsonLength(excerpt) + 32;
+        }
+        break;
+    }
+    const omittedMessages = messages.length - kept.length;
+    remaining += systemFloor;
+    const body = {};
+    if (request.system !== undefined) {
+        body.system =
+            jsonLength(request.system) <= remaining
+                ? request.system
+                : fitText(serialize(request.system), Math.max(0, remaining));
+    }
+    if (request.messages !== undefined) {
+        body.messages = kept;
+    }
+    if (omittedMessages > 0) {
+        body.omittedMessages = omittedMessages;
+    }
+    if (prompt !== undefined) {
+        body.prompt = prompt;
+    }
+    try {
+        return JSON.stringify(body);
+    }
+    catch {
+        return spanJsonAttribute(body, maxChars);
+    }
+}

package/dist/telemetry/index.d.ts

@@ -1,7 +1,7 @@
 export { TelemetryService } from "./telemetryService.js";
 export { tracers } from "./tracers.js";
 export { withSpan, withClientSpan, withStreamSpan, withClientStreamSpan, } from "./withSpan.js";
-export { ATTR, LANGFUSE_ATTR, SPAN_ATTRIBUTE_MAX_CHARS, spanJsonAttribute, } from "./attributes.js";
+export { ATTR, LANGFUSE_ATTR, SPAN_ATTRIBUTE_MAX_CHARS, redactSpanContent, spanContentAttribute, spanJsonAttribute, spanModelRequestAttribute, } from "./attributes.js";
 /**
  * Initialize telemetry for NeuroLink
  * Reuses an existing global TracerProvider when one is already registered,

package/dist/telemetry/index.js

@@ -2,7 +2,7 @@
 export { TelemetryService } from "./telemetryService.js";
 export { tracers } from "./tracers.js";
 export { withSpan, withClientSpan, withStreamSpan, withClientStreamSpan, } from "./withSpan.js";
-export { ATTR, LANGFUSE_ATTR, SPAN_ATTRIBUTE_MAX_CHARS, spanJsonAttribute, } from "./attributes.js";
+export { ATTR, LANGFUSE_ATTR, SPAN_ATTRIBUTE_MAX_CHARS, redactSpanContent, spanContentAttribute, spanJsonAttribute, spanModelRequestAttribute, } from "./attributes.js";
 import { logger } from "../utils/logger.js";
 /**
  * Initialize telemetry for NeuroLink

package/dist/types/loopEngine.d.ts

@@ -346,6 +346,13 @@ export type AnthropicLoopAdapterConfig<TMessage = Anthropic.Messages.MessagePara
  * it, so this cannot quietly give a provider behaviour its hand-rolled loops
  * never had.
  */
+/** One model-requested tool call, as recorded on the tool's observability span. */
+export type ToolSpanCall = {
+    /** Arguments the model passed to the tool. */
+    args?: Record<string, unknown>;
+    /** The model's id for this call, shared with the tool_use block that requested it. */
+    toolCallId?: string;
+};
 export type ToolExecutionGuards = {
     /**
      * Upper bound on a single execute(). Omit, or pass `null`, for no bound.
@@ -380,8 +387,12 @@ export type ToolExecutionGuards = {
      * mark a FAILURE THAT WAS RETURNED rather than thrown: MCP tools report
      * errors in their payload, and an observation that only watches for
      * exceptions records those calls as successful.
+     *
+     * `call` carries the arguments the model passed and the model's id for the
+     * call, so the observation can show what was asked and be paired with the
+     * request that asked it.
      */
-    withToolSpan?: <T>(name: string, run: () => Promise<T>) => Promise<T>;
+    withToolSpan?: <T>(name: string, run: () => Promise<T>, call?: ToolSpanCall) => Promise<T>;
 };
 /**
  * @deprecated Renamed to `ToolExecutionGuards` — the guards were never

package/dist/types/observability.d.ts

@@ -229,6 +229,12 @@ export type TraceView = {
  * Extended context for Langfuse spans.
  * Supports all Langfuse trace attributes for rich observability.
  */
+/** A model request serialized onto a span: the system prompt plus messages, or a bare prompt. */
+export type SpanModelRequest = {
+    system?: unknown;
+    messages?: readonly unknown[];
+    prompt?: string;
+};
 export type LangfuseContext = {
     userId?: string | null;
     sessionId?: string | null;
@@ -240,6 +246,8 @@ export type LangfuseContext = {
     traceName?: string | null;
     /** Custom metadata to attach to spans */
     metadata?: Record<string, unknown> | null;
+    /** Langfuse trace tags, set on the trace's root span (e.g. to label what a trace is for) */
+    tags?: string[] | null;
     /**
      * Explicit operation name (e.g., "ai.streamText", "chat", "embeddings").
      * If set, overrides auto-detection from the span name.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "12.53.0",
+  "version": "12.54.0",
   "packageManager": "pnpm@10.15.1",
   "description": "The pipe layer of an AI nervous system: one interface connecting provider neurons to your application, across three inference types — generate, stream and decide. `decide` returns typed, calibrated judgements from a non-generative model (~400ms, ~$0.00002/call) for routing, tool selection and context budgeting. MCP-native (4 transports), voice TTS/STT/realtime, RAG, agents, memory, compaction, 9 observability exporters. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · TypeSafe Jev and more.",
   "author": {
@@ -113,6 +113,7 @@
     "test:adjust-body-after-400": "pnpm exec tsx test/continuous-test-suite-adjust-body-after-400.ts",
     "test:zod3-schema-native-path": "pnpm exec tsx test/continuous-test-suite-zod3-schema-native-path.ts",
     "test:forced-tool-declared": "pnpm exec tsx test/continuous-test-suite-forced-tool-declared.ts",
+    "test:span-content-redaction": "pnpm exec tsx test/continuous-test-suite-span-content-redaction.ts",
     "test:voice-turn-memory": "pnpm exec tsx test/continuous-test-suite-voice-turn-memory.ts",
     "test:error-classification-e2e": "pnpm exec tsx test/continuous-test-suite-error-classification-e2e.ts",
     "test:error-classifier-contract": "pnpm exec tsx test/continuous-test-suite-error-classifier-contract.ts",