@librechat/agents 3.4.3 → 3.4.4

package/dist/esm/run.mjs

@@ -1,13 +1,13 @@
 import { SUBAGENT_RESUME_ATTEMPT_CONFIG_KEY, SUBAGENT_RESUME_MANIFEST_CONFIG_KEY, requireValidSubagentResumeManifest, stripSubagentResumeManifest } from "./tools/subagent/SubagentReplay.mjs";
-import { getTraceIdSeed } from "./langfuseRuntimeContext.mjs";
 import { hasToolOutputTracingConfig, resolveLangfuseConfig, resolveToolOutputTracingConfig } from "./langfuseConfig.mjs";
-import { resolveLangfuseRuntimeScope, withLangfuseRuntimeScope } from "./langfuseRuntimeScope.mjs";
-import { createLangfuseHandler, createLangfuseTraceMetadata, disposeLangfuseHandler, getLangfuseTraceName, isLangfuseCallbackHandler, withLangfuseAttributes } from "./langfuse.mjs";
 import "./common/constants.mjs";
 import "./common/enum.mjs";
 import "./common/index.mjs";
-import { ACTIVITY_LABEL_PROMPT, buildActivityLabelPrompt } from "./prompts/activityLabel.mjs";
-import { appendCallbacks, findCallback } from "./utils/callbacks.mjs";
+import { getTraceIdSeed } from "./langfuseRuntimeContext.mjs";
+import { resolveLangfuseRuntimeScope, withLangfuseRuntimeScope } from "./langfuseRuntimeScope.mjs";
+import { ACTIVITY_LABEL_PROMPT, ACTIVITY_PHASE_LABEL_PROMPT, buildActivityLabelPrompt, buildActivityPhaseLabelPrompt, normalizeActivityPhaseLabel } from "./prompts/activityLabel.mjs";
+import { createLangfuseHandler, createLangfuseTraceMetadata, disposeLangfuseHandler, getLangfuseTraceName, isLangfuseCallbackHandler, withLangfuseAttributes } from "./langfuse.mjs";
+import { appendCallbacks, filterCallbacks, findCallback } from "./utils/callbacks.mjs";
 import { createCompletionTitleRunnable, createTitleRunnable } from "./utils/title.mjs";
 import { applyGraphRuntimeConfig } from "./graphs/applyGraphRuntimeConfig.mjs";
 import { createTokenCounter, encodingForModel } from "./utils/tokens.mjs";
@@ -24,8 +24,8 @@ import { PromptTemplate } from "@langchain/core/prompts";
 import { RunnableLambda } from "@langchain/core/runnables";
 import { AzureChatOpenAI, ChatOpenAI } from "@langchain/openai";
 import { BaseCallbackHandler } from "@langchain/core/callbacks/base";
-import { BaseMessage, HumanMessage, SystemMessage } from "@langchain/core/messages";
 import { Command, INTERRUPT, MemorySaver, isInterrupted } from "@langchain/langgraph";
+import { AIMessage, BaseMessage, HumanMessage, SystemMessage } from "@langchain/core/messages";
 //#region src/run.ts
 const defaultOmitOptions = new Set([
 	"stream",
@@ -133,6 +133,10 @@ var Run = class Run {
 	_interrupt;
 	/** Per-run sequence for batch-unique activity-label trace-seed fallbacks. */
 	activityLabelSeq = 0;
+	/** Per-run sequence for parent activity-phase trace and invocation ids. */
+	activityPhaseLabelSeq = 0;
+	/** Latest user turn used to keep detached phase roots conversation-shaped. */
+	activityPhaseTraceInput;
 	/** Distinguishes sibling forks started from the same explicit checkpoint. */
 	checkpointForkSeq = 0;
 	_haltedReason;
@@ -519,6 +523,7 @@ var Run = class Run {
 		*/
 		const isResume = inputs instanceof Command;
 		const stateInputs = isResume ? void 0 : inputs;
+		if (stateInputs != null) this.activityPhaseTraceInput = findActivityPhaseTraceInput(stateInputs.messages);
 		/**
 		* Every honored seal costs one extra superstep, so a preemption-enabled
 		* run reserves headroom for its whole seal budget. Without it, a
@@ -1036,7 +1041,11 @@ var Run = class Run {
 		const persistedInterrupt = getFirstPersistedInterrupt(snapshot);
 		if (persistedInterrupt == null) return;
 		const persistedMessages = getPersistedMessages(snapshot);
-		if (persistedMessages != null) this.Graph?.restoreCheckpointMessages(persistedMessages, getResumeUpdateMessages(resumeUpdate));
+		if (persistedMessages != null) {
+			const resumeMessages = getResumeUpdateMessages(resumeUpdate);
+			this.Graph?.restoreCheckpointMessages(persistedMessages, resumeMessages);
+			this.activityPhaseTraceInput = findActivityPhaseTraceInput(resumeMessages == null ? persistedMessages : [...persistedMessages, ...resumeMessages]);
+		}
 		const checkpointConfigurable = snapshot.config?.configurable;
 		const checkpointId = checkpointConfigurable?.checkpoint_id;
 		const checkpointNs = checkpointConfigurable?.checkpoint_ns;
@@ -1169,7 +1178,7 @@ var Run = class Run {
 	* comes from `lastAssistantText`, content from reasoning excerpts and
 	* tool entries.
 	*/
-	async generateActivityLabel({ provider, clientOptions, entries, thinkingExcerpts, lastAssistantText, previousLabels, prompt, charLimit = 600, chainOptions, traceSeed, agentId }) {
+	async generateActivityLabel({ provider, clientOptions, entries, thinkingExcerpts, lastAssistantText, lastAssistantPhase, previousLabels, 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
@@ -1266,7 +1275,7 @@ var Run = class Run {
 			entries,
 			charLimit,
 			thinkingExcerpts,
-			lastAssistantText,
+			lastAssistantText: lastAssistantPhase === "final_answer" ? void 0 : lastAssistantText,
 			previousLabels,
 			redaction
 		});
@@ -1318,8 +1327,8 @@ var Run = class Run {
 				const callbackFailure = /callback|tracer|event.?stream/i.test(String(error?.stack ?? error?.message ?? ""));
 				if (aborted || !callbackFailure) throw error;
 				const langfuseHandler = findCallback(invokeConfig.callbacks, isLangfuseCallbackHandler);
-				const { callbacks: _cb, ...rest } = invokeConfig;
-				const safeConfig = Object.assign({}, rest, { callbacks: langfuseHandler ? [langfuseHandler] : [] });
+				const { callbacks, ...rest } = invokeConfig;
+				const safeConfig = Object.assign({}, rest, { callbacks: filterCallbacks(callbacks, (callback) => callback === langfuseHandler) });
 				response = await withLangfuseRuntimeScope(labelRuntimeScope, () => invokeLabel(safeConfig));
 			}
 			const label = extractLabel(response);
@@ -1328,16 +1337,197 @@ var Run = class Run {
 			await disposeLangfuseHandler(labelLangfuseHandler);
 		}
 	}
+	/**
+	* Generates one parent summary for two or more logical activities. The
+	* summary model is traced as a dedicated activity-phase agent root in the
+	* conversation session, with the model callback recorded as its generation
+	* child. No session id means no phase trace, avoiding orphan observations.
+	*/
+	async generateActivityPhaseLabel({ provider, clientOptions, activities, totalActivityCount, assistantContext, closingTextPhase, prompt, charLimit = 600, chainOptions, traceSeed, sourceRunId, sourceTraceId, responseId, phaseIndex, status = "completed", agentIds }) {
+		if (activities.length < 2) return {};
+		const phaseSeq = ++this.activityPhaseLabelSeq;
+		const hasUnattributedActivity = activities.some((activity) => activity.agentId == null);
+		const hasOmittedActivitiesWithoutAgentIds = agentIds == null && (totalActivityCount ?? activities.length) > activities.length;
+		const contributingAgentIds = [...new Set([...agentIds ?? [], ...activities.flatMap((activity) => activity.agentId == null ? [] : [activity.agentId])])];
+		const agentContexts = this.Graph?.agentContexts;
+		if (contributingAgentIds.some((agentId) => agentContexts?.get(agentId) == null)) return {};
+		const phaseContext = this.Graph == null ? void 0 : this.Graph.agentContexts.get(this.Graph.defaultAgentId);
+		const phaseLangfuseConfig = resolveLangfuseConfig(this.langfuse, phaseContext?.langfuse);
+		let redaction = hasToolOutputTracingConfig(this.langfuse, phaseContext?.langfuse) ? resolveToolOutputTracingConfig(this.langfuse, phaseContext?.langfuse) : void 0;
+		const redactionContexts = contributingAgentIds.length > 0 && !hasUnattributedActivity && !hasOmittedActivitiesWithoutAgentIds ? contributingAgentIds.flatMap((agentId) => {
+			const context = agentContexts?.get(agentId);
+			return context == null ? [] : [context];
+		}) : Array.from(agentContexts?.values() ?? []);
+		for (const context of redactionContexts) {
+			if (!hasToolOutputTracingConfig(this.langfuse, context.langfuse)) continue;
+			const candidate = 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
+			};
+		}
+		const userPrompt = buildActivityPhaseLabelPrompt({
+			activities,
+			totalActivityCount,
+			charLimit,
+			assistantContext,
+			redaction
+		});
+		if (userPrompt === "") return {};
+		const phaseChainOptions = { ...chainOptions ?? {} };
+		const phaseUserId = typeof phaseChainOptions.configurable?.user_id === "string" ? phaseChainOptions.configurable.user_id : void 0;
+		const phaseSessionId = typeof phaseChainOptions.configurable?.thread_id === "string" ? phaseChainOptions.configurable.thread_id : void 0;
+		const resolvedPhaseIndex = phaseIndex ?? phaseSeq - 1;
+		const phaseMessageId = responseId ?? `activity-phase-${this.id}-${resolvedPhaseIndex}`;
+		const phaseAgentId = this.Graph?.defaultAgentId;
+		const phaseAgentName = phaseContext?.name;
+		const phaseParentMessageId = phaseChainOptions.configurable?.requestBody?.parentMessageId;
+		const phaseMetadata = {
+			sourceRunId: sourceRunId ?? this.id,
+			...sourceTraceId == null ? {} : { sourceTraceId },
+			responseId: phaseMessageId,
+			phaseIndex: resolvedPhaseIndex,
+			activityCount: Math.max(activities.length, totalActivityCount ?? 0),
+			status,
+			contributingAgentIds,
+			...typeof phaseParentMessageId === "string" ? { parentMessageId: phaseParentMessageId } : {},
+			...phaseAgentId == null ? {} : { agentId: phaseAgentId },
+			...phaseAgentName == null ? {} : { agentName: phaseAgentName },
+			...closingTextPhase == null ? {} : { closingTextPhase }
+		};
+		const traceMetadata = {
+			...createLangfuseTraceMetadata({
+				messageId: phaseMessageId,
+				parentMessageId: phaseParentMessageId,
+				agentId: phaseAgentId,
+				agentName: phaseAgentName
+			}),
+			sourceRunId: String(phaseMetadata.sourceRunId),
+			...sourceTraceId == null ? {} : { sourceTraceId },
+			responseId: phaseMessageId,
+			phaseIndex: String(resolvedPhaseIndex),
+			activityCount: String(phaseMetadata.activityCount),
+			status,
+			...contributingAgentIds.length === 0 ? {} : { contributingAgentIds: contributingAgentIds.join(",") },
+			...closingTextPhase == null ? {} : { closingTextPhase }
+		};
+		const phaseRunName = getLangfuseTraceName(traceMetadata, "LibreChat Activity Phase");
+		const phaseTraceName = phaseChainOptions.runName ?? phaseRunName;
+		const phaseTags = [
+			"librechat",
+			"activity-phase",
+			"agent-run-summary",
+			"agent"
+		];
+		initializeLangfuseTracing(phaseLangfuseConfig);
+		const inheritedTraceSeed = getTraceIdSeed();
+		const phaseTraceSeed = phaseLangfuseConfig?.deterministicTraceId === true || inheritedTraceSeed != null ? traceSeed ?? `activity-phase-${this.id}-${resolvedPhaseIndex}` : void 0;
+		const phaseScopeRunId = `activity-phase:${this.id}:${phaseSeq}:${nanoid()}`;
+		const phaseRuntimeScope = resolveLangfuseRuntimeScope({
+			runLangfuse: this.langfuse,
+			langfuseOverlay: phaseContext?.langfuse,
+			traceIdSeed: phaseTraceSeed,
+			runId: phaseScopeRunId
+		});
+		let phaseLangfuseHandler;
+		const sourceUserText = this.activityPhaseTraceInput ?? findActivityPhaseTraceInput(this.Graph?.getRunMessages() ?? []);
+		if (phaseSessionId != null && sourceUserText != null) phaseLangfuseHandler = createLangfuseHandler({
+			langfuse: phaseLangfuseConfig,
+			userId: phaseUserId,
+			sessionId: phaseSessionId,
+			traceMetadata,
+			tags: phaseTags,
+			traceIdSeed: phaseLangfuseConfig?.deterministicTraceId === true ? phaseTraceSeed : void 0,
+			runId: phaseScopeRunId,
+			toolOutputTracing: phaseRuntimeScope.toolOutputTracing,
+			traceName: phaseTraceName
+		});
+		if (phaseLangfuseHandler != null) phaseChainOptions.callbacks = appendCallbacks(phaseChainOptions.callbacks, [phaseLangfuseHandler]);
+		const model = initializeModel({
+			provider,
+			clientOptions: {
+				...clientOptions ?? {},
+				streaming: false
+			}
+		});
+		const phaseRunId = `${this.id}-activity-phase-${phaseSeq}`;
+		const invokeConfig = Object.assign({}, phaseChainOptions, {
+			run_id: phaseRunId,
+			runId: phaseRunId,
+			runName: "summarize-activity-phase",
+			tags: [...new Set([...phaseChainOptions.tags ?? [], ...phaseTags])],
+			metadata: {
+				...phaseChainOptions.metadata ?? {},
+				...phaseMetadata
+			}
+		});
+		const invokeModel = (runtimeConfig) => model.invoke([new SystemMessage(prompt ?? ACTIVITY_PHASE_LABEL_PROMPT), new HumanMessage(userPrompt)], runtimeConfig);
+		const invokeWithCallbackFallback = async (runtimeConfig) => {
+			try {
+				return await invokeModel(runtimeConfig);
+			} catch (error) {
+				const aborted = runtimeConfig.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 = findCallback(runtimeConfig.callbacks, isLangfuseCallbackHandler);
+				const { callbacks, ...rest } = runtimeConfig;
+				return invokeModel(Object.assign({}, rest, { callbacks: filterCallbacks(callbacks, (callback) => callback === langfuseHandler) }));
+			}
+		};
+		const extractPhaseLabel = (response) => {
+			const content = response?.content;
+			if (typeof content === "string") return normalizeActivityPhaseLabel(content);
+			if (!Array.isArray(content)) return "";
+			return normalizeActivityPhaseLabel(content.map((block) => typeof block === "string" ? block : block.text ?? "").join(""));
+		};
+		const phaseRunnable = new RunnableLambda({ func: async (_input, runtimeConfig) => {
+			const label = extractPhaseLabel(await invokeWithCallbackFallback(runtimeConfig ?? {}));
+			return label.length > 0 ? {
+				label,
+				messages: [new AIMessage(label)]
+			} : { messages: [] };
+		} }).withConfig({ runName: "summarize-activity-phase" });
+		try {
+			const result = await withLangfuseRuntimeScope(phaseRuntimeScope, () => withLangfuseAttributes({
+				langfuse: phaseLangfuseConfig,
+				userId: phaseUserId,
+				sessionId: phaseSessionId,
+				traceName: phaseTraceName,
+				traceMetadata,
+				tags: phaseTags
+			}, () => phaseRunnable.invoke({ messages: sourceUserText == null ? [] : [new HumanMessage(sourceUserText)] }, invokeConfig)));
+			return result.label == null ? {} : { label: result.label };
+		} finally {
+			await disposeLangfuseHandler(phaseLangfuseHandler);
+		}
+	}
 };
 function findLastMessageOfType(messages, type) {
 	for (let i = messages.length - 1; i >= 0; i--) if (messages[i].getType() === type) return messages[i];
 }
+function findActivityPhaseTraceInput(messages) {
+	for (let i = messages.length - 1; i >= 0; i--) {
+		const message = messages[i];
+		if (message.getType() !== "human" || message.additional_kwargs?.role === "system" || message.additional_kwargs?.isMeta === true) continue;
+		const input = extractPromptText(message).trim();
+		if (input !== "") return input;
+	}
+}
 function extractPromptText(message) {
 	const content = message.content;
 	if (typeof content === "string") return content;
 	if (!Array.isArray(content)) return String(content);
 	const parts = [];
-	for (const block of content) if (typeof block === "object" && "type" in block && block.type === "text" && "text" in block && typeof block.text === "string") parts.push(block.text);
+	for (const block of content) {
+		const textBlock = block;
+		if (textBlock != null && (textBlock.type === "text" || textBlock.type === "input_text") && typeof textBlock.text === "string") parts.push(textBlock.text);
+	}
 	return parts.join("\n");
 }
 //#endregion