@librechat/agents 3.2.68 → 3.3.1

package/dist/cjs/prompts/activityLabel.cjs

@@ -0,0 +1,101 @@
+const require_langfuseToolOutputTracing = require("../langfuseToolOutputTracing.cjs");
+//#region src/prompts/activityLabel.ts
+/**
+* Default system prompt for fast-model activity labeling.
+*
+* Style synthesized from Claude Code's tool-use summary prompt (git-subject
+* register, past tense, distinctive nouns) and claude.ai's observed group
+* headers (5–9 words describing a mixed reasoning + tool block, e.g.
+* "Synthesized version data and curated comparative framework").
+*/
+const ACTIVITY_LABEL_PROMPT = `Write a short label describing what this block of agent activity accomplished. It appears as the header of a collapsed activity group in a chat UI.
+
+Rules:
+- 5 to 9 words, past-tense verb first
+- Name the most distinctive subject (file, API, topic); drop articles and filler
+- Describe outcomes, not mechanics; if something failed, say so plainly
+- Output only the label — no quotes, no punctuation at the end, no preamble
+
+Examples:
+- Searched Node.js release notes and changelogs
+- Compared runtime versions across official sources
+- Fixed failing auth middleware tests
+- Read project config and dependency manifests
+- Attempted database migration, hit permission errors`;
+/** Truncates a serialized value for the label prompt. */
+function truncateForLabel(value, maxLength) {
+	if (value.length <= maxLength) return value;
+	return value.slice(0, Math.max(0, maxLength - 1)) + "…";
+}
+const ABORT_SERIALIZATION = Symbol("abort-label-serialization");
+/**
+* Serializes a tool value for the prompt WITHOUT materializing huge JSON:
+* the output is clipped to a few hundred characters anyway, so a multi-
+* megabyte tool result must not be stringified in full on the label path.
+* Strings clip immediately; structured values serialize under a character
+* budget and degrade to a shape summary once it is exhausted.
+*/
+function serializeForLabel(value, limit) {
+	if (value == null) return "";
+	if (typeof value === "string") return value.length > limit ? value.slice(0, limit + 1) : value;
+	let budget = limit * 4;
+	try {
+		return JSON.stringify(value, (_key, nested) => {
+			if (budget <= 0) throw ABORT_SERIALIZATION;
+			if (typeof nested === "string") {
+				const clipped = nested.length > limit ? nested.slice(0, limit) : nested;
+				budget -= clipped.length;
+				return clipped;
+			}
+			budget -= 8;
+			return nested;
+		}) ?? "";
+	} catch (error) {
+		if (error === ABORT_SERIALIZATION) return Array.isArray(value) ? `[Array(${value.length})]` : "[Object]";
+		return String(value);
+	}
+}
+const INPUT_CONTEXT_LIMIT = 200;
+const MAX_THINKING_EXCERPTS = 4;
+/** A label is 5-9 words; no batch needs more than this many entries to
+*  produce one, and the cap keeps a 200-call programmatic batch from
+*  building an enormous prompt out of per-field-bounded pieces. */
+const MAX_PROMPT_ENTRIES = 12;
+/**
+* Builds the user prompt for a fast-model activity label. Pure — exported
+* for direct testing of redaction and truncation behavior.
+*/
+function buildActivityLabelPrompt({ entries, charLimit, thinkingExcerpts, lastAssistantText, redaction }) {
+	const clip = truncateForLabel;
+	/** Reasoning and intent text can quote tool output verbatim — including
+	*  output from EARLIER calls to a redacted tool that this batch does not
+	*  contain — so any active policy (global disable or a configured
+	*  redacted-name list) drops both wholesale. There is no reliable way to
+	*  scrub a quoted fragment out of free-form model prose. */
+	const excerptsRedacted = redaction != null && (redaction.enabled === false || redaction.redactedToolNames.size > 0);
+	const sections = [];
+	/** Intent text is free-form assistant prose that can quote a redacted
+	*  tool result just as reasoning can, so it shares the excerpts' fate. */
+	if (!excerptsRedacted && lastAssistantText != null && lastAssistantText.length > 0) sections.push(`Intent (assistant's last message): ${clip(lastAssistantText, INPUT_CONTEXT_LIMIT)}`);
+	if (!excerptsRedacted && thinkingExcerpts != null && thinkingExcerpts.length > 0) sections.push("Reasoning excerpts:\n" + thinkingExcerpts.slice(0, MAX_THINKING_EXCERPTS).map((excerpt) => `- ${clip(excerpt, charLimit)}`).join("\n"));
+	if (entries.length > 0) {
+		const shown = entries.slice(0, MAX_PROMPT_ENTRIES);
+		const omitted = entries.length - shown.length;
+		sections.push("Tool calls:\n" + shown.map((entry) => {
+			const input = clip(serializeForLabel(entry.toolInput, charLimit), charLimit);
+			const redacted = redaction != null && require_langfuseToolOutputTracing.shouldRedactTool(entry.toolName, redaction);
+			let outcome;
+			if (redacted) outcome = redaction.redactionText;
+			else if (entry.status === "error") outcome = `ERROR: ${clip(entry.error ?? "unknown error", charLimit)}`;
+			else outcome = clip(serializeForLabel(entry.toolOutput, charLimit), charLimit);
+			return `- ${entry.toolName}(${input}) → ${outcome}`;
+		}).join("\n") + (omitted > 0 ? `\n- …and ${omitted} more tool ${omitted === 1 ? "call" : "calls"}` : ""));
+	}
+	sections.push("Label:");
+	return sections.join("\n\n");
+}
+//#endregion
+exports.ACTIVITY_LABEL_PROMPT = ACTIVITY_LABEL_PROMPT;
+exports.buildActivityLabelPrompt = buildActivityLabelPrompt;
+
+//# sourceMappingURL=activityLabel.cjs.map

package/dist/cjs/prompts/activityLabel.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"activityLabel.cjs","names":["shouldRedactTool"],"sources":["../../../src/prompts/activityLabel.ts"],"sourcesContent":["import type { ResolvedLangfuseToolOutputTracingConfig } from '@/langfuseRuntimeContext';\nimport type { ActivityLabelToolEntry } from '@/types/activityLabel';\nimport { shouldRedactTool } from '@/langfuseToolOutputTracing';\n\n/**\n * Default system prompt for fast-model activity labeling.\n *\n * Style synthesized from Claude Code's tool-use summary prompt (git-subject\n * register, past tense, distinctive nouns) and claude.ai's observed group\n * headers (5–9 words describing a mixed reasoning + tool block, e.g.\n * \"Synthesized version data and curated comparative framework\").\n */\nexport const ACTIVITY_LABEL_PROMPT = `Write a short label describing what this block of agent activity accomplished. It appears as the header of a collapsed activity group in a chat UI.\n\nRules:\n- 5 to 9 words, past-tense verb first\n- Name the most distinctive subject (file, API, topic); drop articles and filler\n- Describe outcomes, not mechanics; if something failed, say so plainly\n- Output only the label — no quotes, no punctuation at the end, no preamble\n\nExamples:\n- Searched Node.js release notes and changelogs\n- Compared runtime versions across official sources\n- Fixed failing auth middleware tests\n- Read project config and dependency manifests\n- Attempted database migration, hit permission errors`;\n\n/** Truncates a serialized value for the label prompt. */\nexport function truncateForLabel(value: string, maxLength: number): string {\n  if (value.length <= maxLength) {\n    return value;\n  }\n  return value.slice(0, Math.max(0, maxLength - 1)) + '…';\n}\n\nconst ABORT_SERIALIZATION = Symbol('abort-label-serialization');\n\n/**\n * Serializes a tool value for the prompt WITHOUT materializing huge JSON:\n * the output is clipped to a few hundred characters anyway, so a multi-\n * megabyte tool result must not be stringified in full on the label path.\n * Strings clip immediately; structured values serialize under a character\n * budget and degrade to a shape summary once it is exhausted.\n */\nfunction serializeForLabel(value: unknown, limit: number): string {\n  if (value == null) {\n    return '';\n  }\n  if (typeof value === 'string') {\n    return value.length > limit ? value.slice(0, limit + 1) : value;\n  }\n  let budget = limit * 4;\n  try {\n    return (\n      JSON.stringify(value, (_key, nested: unknown) => {\n        if (budget <= 0) {\n          throw ABORT_SERIALIZATION;\n        }\n        if (typeof nested === 'string') {\n          const clipped =\n            nested.length > limit ? nested.slice(0, limit) : nested;\n          budget -= clipped.length;\n          return clipped;\n        }\n        budget -= 8;\n        return nested;\n      }) ?? ''\n    );\n  } catch (error) {\n    if (error === ABORT_SERIALIZATION) {\n      return Array.isArray(value) ? `[Array(${value.length})]` : '[Object]';\n    }\n    return String(value);\n  }\n}\n\nconst INPUT_CONTEXT_LIMIT = 200;\nconst MAX_THINKING_EXCERPTS = 4;\n/** A label is 5-9 words; no batch needs more than this many entries to\n *  produce one, and the cap keeps a 200-call programmatic batch from\n *  building an enormous prompt out of per-field-bounded pieces. */\nconst MAX_PROMPT_ENTRIES = 12;\n\nexport type BuildActivityLabelPromptParams = {\n  entries: ActivityLabelToolEntry[];\n  charLimit: number;\n  thinkingExcerpts?: string[];\n  lastAssistantText?: string;\n  /**\n   * Resolved tool-output tracing policy. The label prompt becomes Langfuse\n   * generation input, so outputs/errors excluded from tracing (global\n   * disable or `redactedToolNames`) must never appear in it — the same\n   * redaction the span processor applies to structured tool observations.\n   */\n  redaction?: ResolvedLangfuseToolOutputTracingConfig;\n};\n\n/**\n * Builds the user prompt for a fast-model activity label. Pure — exported\n * for direct testing of redaction and truncation behavior.\n */\nexport function buildActivityLabelPrompt({\n  entries,\n  charLimit,\n  thinkingExcerpts,\n  lastAssistantText,\n  redaction,\n}: BuildActivityLabelPromptParams): string {\n  const clip = truncateForLabel;\n  /** Reasoning and intent text can quote tool output verbatim — including\n   *  output from EARLIER calls to a redacted tool that this batch does not\n   *  contain — so any active policy (global disable or a configured\n   *  redacted-name list) drops both wholesale. There is no reliable way to\n   *  scrub a quoted fragment out of free-form model prose. */\n  const excerptsRedacted =\n    redaction != null &&\n    (redaction.enabled === false || redaction.redactedToolNames.size > 0);\n  const sections: string[] = [];\n  /** Intent text is free-form assistant prose that can quote a redacted\n   *  tool result just as reasoning can, so it shares the excerpts' fate. */\n  if (\n    !excerptsRedacted &&\n    lastAssistantText != null &&\n    lastAssistantText.length > 0\n  ) {\n    sections.push(\n      `Intent (assistant's last message): ${clip(lastAssistantText, INPUT_CONTEXT_LIMIT)}`\n    );\n  }\n  if (\n    !excerptsRedacted &&\n    thinkingExcerpts != null &&\n    thinkingExcerpts.length > 0\n  ) {\n    sections.push(\n      'Reasoning excerpts:\\n' +\n        thinkingExcerpts\n          .slice(0, MAX_THINKING_EXCERPTS)\n          .map((excerpt) => `- ${clip(excerpt, charLimit)}`)\n          .join('\\n')\n    );\n  }\n  if (entries.length > 0) {\n    const shown = entries.slice(0, MAX_PROMPT_ENTRIES);\n    const omitted = entries.length - shown.length;\n    sections.push(\n      'Tool calls:\\n' +\n        shown\n          .map((entry) => {\n            const input = clip(\n              serializeForLabel(entry.toolInput, charLimit),\n              charLimit\n            );\n            const redacted =\n              redaction != null && shouldRedactTool(entry.toolName, redaction);\n            let outcome: string;\n            if (redacted) {\n              outcome = redaction.redactionText;\n            } else if (entry.status === 'error') {\n              outcome = `ERROR: ${clip(entry.error ?? 'unknown error', charLimit)}`;\n            } else {\n              outcome = clip(\n                serializeForLabel(entry.toolOutput, charLimit),\n                charLimit\n              );\n            }\n            return `- ${entry.toolName}(${input}) → ${outcome}`;\n          })\n          .join('\\n') +\n        (omitted > 0\n          ? `\\n- …and ${omitted} more tool ${omitted === 1 ? 'call' : 'calls'}`\n          : '')\n    );\n  }\n  sections.push('Label:');\n  return sections.join('\\n\\n');\n}\n"],"mappings":";;;;;;;;;;AAYA,MAAa,wBAAwB;;;;;;;;;;;;;;;AAgBrC,SAAgB,iBAAiB,OAAe,WAA2B;CACzE,IAAI,MAAM,UAAU,WAClB,OAAO;CAET,OAAO,MAAM,MAAM,GAAG,KAAK,IAAI,GAAG,YAAY,CAAC,CAAC,IAAI;AACtD;AAEA,MAAM,sBAAsB,OAAO,2BAA2B;;;;;;;;AAS9D,SAAS,kBAAkB,OAAgB,OAAuB;CAChE,IAAI,SAAS,MACX,OAAO;CAET,IAAI,OAAO,UAAU,UACnB,OAAO,MAAM,SAAS,QAAQ,MAAM,MAAM,GAAG,QAAQ,CAAC,IAAI;CAE5D,IAAI,SAAS,QAAQ;CACrB,IAAI;EACF,OACE,KAAK,UAAU,QAAQ,MAAM,WAAoB;GAC/C,IAAI,UAAU,GACZ,MAAM;GAER,IAAI,OAAO,WAAW,UAAU;IAC9B,MAAM,UACJ,OAAO,SAAS,QAAQ,OAAO,MAAM,GAAG,KAAK,IAAI;IACnD,UAAU,QAAQ;IAClB,OAAO;GACT;GACA,UAAU;GACV,OAAO;EACT,CAAC,KAAK;CAEV,SAAS,OAAO;EACd,IAAI,UAAU,qBACZ,OAAO,MAAM,QAAQ,KAAK,IAAI,UAAU,MAAM,OAAO,MAAM;EAE7D,OAAO,OAAO,KAAK;CACrB;AACF;AAEA,MAAM,sBAAsB;AAC5B,MAAM,wBAAwB;;;;AAI9B,MAAM,qBAAqB;;;;;AAoB3B,SAAgB,yBAAyB,EACvC,SACA,WACA,kBACA,mBACA,aACyC;CACzC,MAAM,OAAO;;;;;;CAMb,MAAM,mBACJ,aAAa,SACZ,UAAU,YAAY,SAAS,UAAU,kBAAkB,OAAO;CACrE,MAAM,WAAqB,CAAC;;;CAG5B,IACE,CAAC,oBACD,qBAAqB,QACrB,kBAAkB,SAAS,GAE3B,SAAS,KACP,sCAAsC,KAAK,mBAAmB,mBAAmB,GACnF;CAEF,IACE,CAAC,oBACD,oBAAoB,QACpB,iBAAiB,SAAS,GAE1B,SAAS,KACP,0BACE,iBACG,MAAM,GAAG,qBAAqB,CAAC,CAC/B,KAAK,YAAY,KAAK,KAAK,SAAS,SAAS,GAAG,CAAC,CACjD,KAAK,IAAI,CAChB;CAEF,IAAI,QAAQ,SAAS,GAAG;EACtB,MAAM,QAAQ,QAAQ,MAAM,GAAG,kBAAkB;EACjD,MAAM,UAAU,QAAQ,SAAS,MAAM;EACvC,SAAS,KACP,kBACE,MACG,KAAK,UAAU;GACd,MAAM,QAAQ,KACZ,kBAAkB,MAAM,WAAW,SAAS,GAC5C,SACF;GACA,MAAM,WACJ,aAAa,QAAQA,kCAAAA,iBAAiB,MAAM,UAAU,SAAS;GACjE,IAAI;GACJ,IAAI,UACF,UAAU,UAAU;QACf,IAAI,MAAM,WAAW,SAC1B,UAAU,UAAU,KAAK,MAAM,SAAS,iBAAiB,SAAS;QAElE,UAAU,KACR,kBAAkB,MAAM,YAAY,SAAS,GAC7C,SACF;GAEF,OAAO,KAAK,MAAM,SAAS,GAAG,MAAM,MAAM;EAC5C,CAAC,CAAC,CACD,KAAK,IAAI,KACX,UAAU,IACP,YAAY,QAAQ,aAAa,YAAY,IAAI,SAAS,YAC1D,GACR;CACF;CACA,SAAS,KAAK,QAAQ;CACtB,OAAO,SAAS,KAAK,MAAM;AAC7B"}

package/dist/cjs/run.cjs

@@ -1,6 +1,8 @@
+const require_langfuseRuntimeContext = require("./langfuseRuntimeContext.cjs");
 const require_langfuseConfig = require("./langfuseConfig.cjs");
 const require_langfuseRuntimeScope = require("./langfuseRuntimeScope.cjs");
 const require_langfuse = require("./langfuse.cjs");
+const require_activityLabel = require("./prompts/activityLabel.cjs");
 const require_callbacks = require("./utils/callbacks.cjs");
 require("./common/enum.cjs");
 require("./common/index.cjs");
@@ -9,16 +11,16 @@ const require_tokens = require("./utils/tokens.cjs");
 const require_instrumentation = require("./instrumentation.cjs");
 const require_llm = require("./utils/llm.cjs");
 const require_events = require("./events.cjs");
+const require_init = require("./llm/init.cjs");
 const require_executeHooks = require("./hooks/executeHooks.cjs");
 require("./hooks/index.cjs");
-const require_init = require("./llm/init.cjs");
 const require_Graph = require("./graphs/Graph.cjs");
 const require_MultiAgentGraph = require("./graphs/MultiAgentGraph.cjs");
-let _langchain_core_messages = require("@langchain/core/messages");
 let _langchain_core_prompts = require("@langchain/core/prompts");
 let _langchain_core_runnables = require("@langchain/core/runnables");
 let _langchain_openai = require("@langchain/openai");
 let _langchain_core_callbacks_base = require("@langchain/core/callbacks/base");
+let _langchain_core_messages = require("@langchain/core/messages");
 let _langchain_langgraph = require("@langchain/langgraph");
 //#region src/run.ts
 const defaultOmitOptions = new Set([
@@ -99,6 +101,10 @@ var Run = class Run {
 	* lets callers assert the type they expect.
 	*/
 	_interrupt;
+	/** Per-run sequence for batch-unique activity-label trace-seed fallbacks. */
+	activityLabelSeq = 0;
+	/** Distinguishes sibling forks started from the same explicit checkpoint. */
+	checkpointForkSeq = 0;
 	_haltedReason;
 	constructor(config) {
 		const runId = config.runId ?? "";
@@ -462,7 +468,18 @@ var Run = class Run {
 		* block so the sidecars survive both ends of the interrupt
 		* boundary.
 		*/
-		if (!isResume) graph.resetValues(streamOptions?.keepContent);
+		if (!isResume) {
+			const checkpointThreadId = typeof config.configurable?.thread_id === "string" ? config.configurable.thread_id : void 0;
+			const checkpointNamespace = typeof config.configurable?.checkpoint_ns === "string" ? config.configurable.checkpoint_ns : "";
+			const checkpointId = typeof config.configurable?.checkpoint_id === "string" ? config.configurable.checkpoint_id : "";
+			const checkpointScope = checkpointThreadId == null ? void 0 : JSON.stringify([
+				checkpointThreadId,
+				checkpointNamespace,
+				checkpointId,
+				checkpointId === "" ? 0 : ++this.checkpointForkSeq
+			]);
+			graph.resetValues(streamOptions?.keepContent, checkpointScope);
+		}
 		this._interrupt = void 0;
 		this._haltedReason = void 0;
 		this.hookRegistry?.clearHaltSignal(this.id);
@@ -960,6 +977,163 @@ var Run = class Run {
 			await require_langfuse.disposeLangfuseHandler(titleLangfuseHandler);
 		}
 	}
+	/**
+	* Generates a short activity label for a completed tool/reasoning block
+	* using a fast model. Mirrors `generateTitle`'s Langfuse wiring so the
+	* call is traced under the conversation's session (sessionId from
+	* `chainOptions.configurable.thread_id`) with its own tags — never as an
+	* orphan trace. The payload contains no human messages by design: intent
+	* comes from `lastAssistantText`, content from reasoning excerpts and
+	* tool entries.
+	*/
+	async generateActivityLabel({ provider, clientOptions, entries, thinkingExcerpts, lastAssistantText, prompt, charLimit = 600, chainOptions, traceSeed, agentId }) {
+		if (entries.length === 0 && !(thinkingExcerpts && thinkingExcerpts.length > 0)) return {};
+		const labelSeq = ++this.activityLabelSeq;
+		/** Resolve the LABELED agent's context: its Langfuse overlay carries the
+		*  trace metadata and the tool-output redaction policy that must govern
+		*  this label. */
+		const requestedContext = this.Graph == null || agentId == null ? void 0 : this.Graph.agentContexts.get(agentId);
+		/** Fail closed: an explicit but unknown/stale `agentId` must NOT silently
+		*  fall back to the default agent, whose redaction policy may be weaker
+		*  than the labeled agent's. Skip generation entirely instead. */
+		if (agentId != null && requestedContext == null) return {};
+		const labelContext = this.Graph == null ? void 0 : requestedContext ?? this.Graph.agentContexts.get(this.Graph.defaultAgentId);
+		const traceMetadata = require_langfuse.createLangfuseTraceMetadata({
+			messageId: "activity-label-" + this.id,
+			agentName: labelContext?.name
+		});
+		const labelRunName = require_langfuse.getLangfuseTraceName(traceMetadata, "LibreChat Activity Label");
+		/** Shallow-cloned: activity labels run once per tool batch, and writing
+		*  the Langfuse handler back onto a host-reused `chainOptions` would
+		*  accumulate duplicate callbacks across batches. */
+		const labelChainOptions = { ...chainOptions ?? {} };
+		const labelUserId = typeof labelChainOptions.configurable?.user_id === "string" ? labelChainOptions.configurable.user_id : void 0;
+		const labelSessionId = typeof labelChainOptions.configurable?.thread_id === "string" ? labelChainOptions.configurable.thread_id : void 0;
+		const labelLangfuseConfig = require_langfuseConfig.resolveLangfuseConfig(this.langfuse, labelContext?.langfuse);
+		require_instrumentation.initializeLangfuseTracing(labelLangfuseConfig);
+		/** Seed policy, threading two constraints:
+		*  1. `runWithLangfuseRuntimeContext` SPREADS the surrounding context, so
+		*     an absent seed INHERITS the parent run's and collapses every label
+		*     into that trace. When a parent seed is active we must override it
+		*     with a per-label one.
+		*  2. Without deterministic tracing there is no parent seed, and forcing
+		*     one here would make label trace ids deterministic when neither
+		*     `processStream` nor `generateTitle` are — so leave it unset.
+		*  Seeded when determinism is opted into OR a parent seed is live;
+		*  otherwise unseeded, matching the other generation paths. */
+		const inheritedTraceSeed = require_langfuseRuntimeContext.getTraceIdSeed();
+		const labelTraceSeed = labelLangfuseConfig?.deterministicTraceId === true || inheritedTraceSeed != null ? traceSeed ?? `activity-label-${this.id}-${labelSeq}` : void 0;
+		const labelRuntimeScope = require_langfuseRuntimeScope.resolveLangfuseRuntimeScope({
+			runLangfuse: this.langfuse,
+			langfuseOverlay: labelContext?.langfuse,
+			traceIdSeed: labelTraceSeed
+		});
+		/** Handler only when a session id resolved from
+		*  `chainOptions.configurable.thread_id`: without it the label call has
+		*  no conversation identity, and tracing it would create an orphan
+		*  trace outside any session — worse than not tracing at all. */
+		/** Declared then conditionally assigned (title precedent): a ternary
+		*  around the object literal makes eslint's indent rule and prettier
+		*  disagree, and both gate CI. */
+		let labelLangfuseHandler;
+		if (labelSessionId != null) labelLangfuseHandler = require_langfuse.createLangfuseHandler({
+			langfuse: labelLangfuseConfig,
+			userId: labelUserId,
+			sessionId: labelSessionId,
+			traceMetadata,
+			tags: ["librechat", "activity-label"],
+			traceIdSeed: labelLangfuseConfig?.deterministicTraceId === true ? labelTraceSeed : void 0
+		});
+		if (labelLangfuseHandler != null) labelChainOptions.callbacks = require_callbacks.appendCallbacks(labelChainOptions.callbacks, [labelLangfuseHandler]);
+		/** The label prompt becomes Langfuse generation input, so the resolved
+		*  tool-output redaction policy (global disable / redactedToolNames)
+		*  applies to it exactly as to structured tool observations. */
+		let redaction = require_langfuseConfig.hasToolOutputTracingConfig(this.langfuse, labelContext?.langfuse) ? require_langfuseConfig.resolveToolOutputTracingConfig(this.langfuse, labelContext?.langfuse) : void 0;
+		/** Multi-agent graph with no `agentId`: the caller did not say WHICH
+		*  agent ran this batch, so resolving from the default agent could trace
+		*  raw output that a stricter sibling's policy forbids. Fold every
+		*  agent's policy into the strictest one instead of guessing. */
+		const agentContexts = this.Graph?.agentContexts;
+		if (agentId == null && agentContexts != null && agentContexts.size > 1) for (const context of agentContexts.values()) {
+			if (!require_langfuseConfig.hasToolOutputTracingConfig(this.langfuse, context.langfuse)) continue;
+			const candidate = require_langfuseConfig.resolveToolOutputTracingConfig(this.langfuse, context.langfuse);
+			if (redaction == null) {
+				redaction = candidate;
+				continue;
+			}
+			redaction = {
+				enabled: redaction.enabled === false ? false : candidate.enabled,
+				redactedToolNames: new Set([...redaction.redactedToolNames, ...candidate.redactedToolNames]),
+				redactedToolNameMatchMode: redaction.redactedToolNameMatchMode === "partial" || candidate.redactedToolNameMatchMode === "partial" ? "partial" : "exact",
+				redactionText: redaction.redactionText
+			};
+		}
+		/** An active redaction policy suppresses free-form reasoning/intent, so
+		*  a reasoning-only block has nothing describable left — skip the model
+		*  call rather than paying for a label built from the prompt alone. */
+		const freeFormSuppressed = redaction != null && (redaction.enabled === false || redaction.redactedToolNames.size > 0);
+		if (entries.length === 0 && freeFormSuppressed) return {};
+		const userPrompt = require_activityLabel.buildActivityLabelPrompt({
+			entries,
+			charLimit,
+			thinkingExcerpts,
+			lastAssistantText,
+			redaction
+		});
+		const model = require_init.initializeModel({
+			provider,
+			clientOptions: {
+				...clientOptions ?? {},
+				streaming: false
+			}
+		});
+		/** Distinct run id per label call: callback/tracing integrations key
+		*  in-flight runs by it, so reusing the parent run's id would collide
+		*  across successive (or concurrent) label batches. */
+		const labelRunId = `${this.id}-activity-${labelSeq}`;
+		const invokeConfig = Object.assign({}, labelChainOptions, {
+			run_id: labelRunId,
+			runId: labelRunId,
+			runName: labelChainOptions.runName ?? labelRunName
+		});
+		const invokeLabel = (runtimeConfig) => require_langfuse.withLangfuseAttributes({
+			langfuse: labelLangfuseConfig,
+			userId: labelUserId,
+			sessionId: labelSessionId,
+			traceName: runtimeConfig.runName ?? labelRunName,
+			traceMetadata,
+			tags: ["librechat", "activity-label"]
+		}, () => model.invoke([new _langchain_core_messages.SystemMessage(prompt ?? require_activityLabel.ACTIVITY_LABEL_PROMPT), new _langchain_core_messages.HumanMessage(userPrompt)], runtimeConfig));
+		const extractLabel = (response) => {
+			const content = response?.content;
+			let text = "";
+			if (typeof content === "string") text = content;
+			else if (Array.isArray(content)) text = content.map((block) => typeof block === "string" ? block : block.text ?? "").join("");
+			return text.trim().replace(/^["']|["']$/g, "");
+		};
+		try {
+			let response;
+			try {
+				response = await require_langfuseRuntimeScope.withLangfuseRuntimeScope(labelRuntimeScope, () => invokeLabel(invokeConfig));
+			} catch (error) {
+				/** Retry ONLY recognized callback/tracer failures (the EventStream
+				*  tracer class of errors the stripped-callbacks fallback exists
+				*  for). Aborts and provider failures rethrow — retrying those
+				*  doubles traffic/cost and can restart cancelled requests. */
+				const aborted = labelChainOptions.signal?.aborted === true || error?.name === "AbortError";
+				const callbackFailure = /callback|tracer|event.?stream/i.test(String(error?.stack ?? error?.message ?? ""));
+				if (aborted || !callbackFailure) throw error;
+				const langfuseHandler = require_callbacks.findCallback(invokeConfig.callbacks, require_langfuse.isLangfuseCallbackHandler);
+				const { callbacks: _cb, ...rest } = invokeConfig;
+				const safeConfig = Object.assign({}, rest, { callbacks: langfuseHandler ? [langfuseHandler] : [] });
+				response = await require_langfuseRuntimeScope.withLangfuseRuntimeScope(labelRuntimeScope, () => invokeLabel(safeConfig));
+			}
+			const label = extractLabel(response);
+			return label.length > 0 ? { label } : {};
+		} finally {
+			await require_langfuse.disposeLangfuseHandler(labelLangfuseHandler);
+		}
+	}
 };
 function findLastMessageOfType(messages, type) {
 	for (let i = messages.length - 1; i >= 0; i--) if (messages[i].getType() === type) return messages[i];