@librechat/agents 3.3.0 → 3.3.2

package/dist/cjs/stream.cjs

@@ -782,12 +782,98 @@ hasToolCallChunks: ${hasToolCallChunks}
 function createContentAggregator() {
 	const contentParts = [];
 	const stepMap = /* @__PURE__ */ new Map();
-	const toolCallIdMap = /* @__PURE__ */ new Map();
+	const toolCallContentIndexMap = /* @__PURE__ */ new Map();
+	const sourceContentIndexMap = /* @__PURE__ */ new Map();
+	const toolStepContentMap = /* @__PURE__ */ new Map();
+	let indexedContentLength = 0;
+	/** Physical append cursor; event/chunk indices are correlation keys, not array offsets. */
+	let nextContentIndex = 0;
 	const contentMetaMap = /* @__PURE__ */ new Map();
 	const getFirstContentPart = (content) => {
 		if (content == null) return;
 		return Array.isArray(content) ? content[0] : content;
 	};
+	const indexContentPart = (index, contentPart) => {
+		if (contentPart == null) return;
+		if (contentPart.type === "tool_call") {
+			const toolCallId = contentPart.tool_call.id;
+			if (toolCallId != null && toolCallId !== "") toolCallContentIndexMap.set(toolCallId, index);
+		}
+		const hasAgentId = contentPart.agentId != null && contentPart.agentId !== "";
+		const hasGroupId = contentPart.groupId != null;
+		if (hasAgentId || hasGroupId) {
+			const existingMeta = contentMetaMap.get(index) ?? {};
+			if (hasAgentId) existingMeta.agentId = contentPart.agentId;
+			if (hasGroupId) existingMeta.groupId = contentPart.groupId;
+			contentMetaMap.set(index, existingMeta);
+		}
+	};
+	const syncSeededContent = () => {
+		/** Hosts can seed pre-pause content after creating the aggregator. */
+		for (let index = indexedContentLength; index < contentParts.length; index++) indexContentPart(index, contentParts[index]);
+		indexedContentLength = contentParts.length;
+		nextContentIndex = Math.max(nextContentIndex, contentParts.length);
+	};
+	const getToolCallContentIndex = (toolCallId) => {
+		if (toolCallId == null || toolCallId === "") return;
+		syncSeededContent();
+		return toolCallContentIndexMap.get(toolCallId);
+	};
+	const allocateContentIndex = (minimumIndex = 0) => {
+		syncSeededContent();
+		const contentIndex = Math.max(nextContentIndex, minimumIndex);
+		nextContentIndex = contentIndex + 1;
+		return contentIndex;
+	};
+	const resolveSourceContentIndex = (sourceIndex) => {
+		const existingIndex = sourceContentIndexMap.get(sourceIndex);
+		if (existingIndex != null) return existingIndex;
+		const contentIndex = allocateContentIndex(sourceIndex);
+		sourceContentIndexMap.set(sourceIndex, contentIndex);
+		return contentIndex;
+	};
+	const createToolStepContentState = (contentIndex) => ({
+		indices: new Set([contentIndex]),
+		chunkIndices: /* @__PURE__ */ new Map(),
+		unclaimedIndices: new Set([contentIndex]),
+		unboundIndices: new Set([contentIndex]),
+		callIdsByIndex: /* @__PURE__ */ new Map()
+	});
+	const registerToolContentIndex = (state, contentIndex, toolCallId) => {
+		if (!state.indices.has(contentIndex)) {
+			state.indices.add(contentIndex);
+			state.unclaimedIndices.add(contentIndex);
+			state.unboundIndices.add(contentIndex);
+		}
+		if (toolCallId != null && toolCallId !== "") {
+			const existingToolCallId = state.callIdsByIndex.get(contentIndex);
+			if (existingToolCallId != null && existingToolCallId !== toolCallId && toolCallContentIndexMap.get(existingToolCallId) === contentIndex) toolCallContentIndexMap.delete(existingToolCallId);
+			toolCallContentIndexMap.set(toolCallId, contentIndex);
+			state.callIdsByIndex.set(contentIndex, toolCallId);
+			state.unboundIndices.delete(contentIndex);
+		}
+	};
+	const takeFirstIndex = (indices) => {
+		const contentIndex = indices.values().next().value;
+		if (contentIndex != null) indices.delete(contentIndex);
+		return contentIndex;
+	};
+	const setContentMeta = (index, runStep) => {
+		const hasAgentId = runStep.agentId != null && runStep.agentId !== "";
+		const hasGroupId = runStep.groupId != null;
+		if (!hasAgentId && !hasGroupId) return;
+		const existingMeta = contentMetaMap.get(index) ?? {};
+		if (hasAgentId) existingMeta.agentId = runStep.agentId;
+		if (hasGroupId) existingMeta.groupId = runStep.groupId;
+		contentMetaMap.set(index, existingMeta);
+	};
+	const applyContentMetadata = (index) => {
+		const contentPart = contentParts[index];
+		if (contentPart == null) return;
+		const meta = contentMetaMap.get(index);
+		if (meta?.agentId != null) contentPart.agentId = meta.agentId;
+		if (meta?.groupId != null) contentPart.groupId = meta.groupId;
+	};
 	const updateContent = (index, contentPart, finalUpdate = false) => {
 		if (!contentPart) {
 			console.warn("No content part found in 'updateContent'");
@@ -837,9 +923,13 @@ function createContentAggregator() {
 			/** When args are a valid object, they are likely already invoked */
 			let args = finalUpdate || typeof existingContent?.tool_call?.args === "object" || typeof toolCallArgs === "object" ? contentPart.tool_call.args : (existingContent?.tool_call?.args ?? "") + (toolCallArgs ?? "");
 			if (finalUpdate && args == null && existingContent?.tool_call?.args != null) args = existingContent.tool_call.args;
+			const id = getNonEmptyValue([incomingId, existingContent?.tool_call?.id]) ?? "";
+			const name = getNonEmptyValue([incomingName, existingContent?.tool_call?.name]) ?? "";
+			const existingToolCallId = existingContent?.tool_call?.id;
+			if (existingToolCallId != null && existingToolCallId !== "" && existingToolCallId !== id && toolCallContentIndexMap.get(existingToolCallId) === index) toolCallContentIndexMap.delete(existingToolCallId);
 			const newToolCall = {
-				id: getNonEmptyValue([incomingId, existingContent?.tool_call?.id]) ?? "",
-				name: getNonEmptyValue([incomingName, existingContent?.tool_call?.name]) ?? "",
+				id,
+				name,
 				args,
 				type: "tool_call"
 			};
@@ -857,10 +947,10 @@ function createContentAggregator() {
 				type: "tool_call",
 				tool_call: newToolCall
 			};
+			indexContentPart(index, contentParts[index]);
+			indexedContentLength = Math.max(indexedContentLength, index + 1);
 		}
-		const meta = contentMetaMap.get(index);
-		if (meta?.agentId != null) contentParts[index].agentId = meta.agentId;
-		if (meta?.groupId != null) contentParts[index].groupId = meta.groupId;
+		applyContentMetadata(index);
 	};
 	const aggregateContent = ({ event, data }) => {
 		if (event === "on_summarize_delta") {
@@ -879,33 +969,52 @@ function createContentAggregator() {
 			const runStep = stepMap.get(summary.boundary.messageId);
 			if (!runStep) return;
 			contentParts[runStep.index] = summary;
+			applyContentMetadata(runStep.index);
 			return;
 		}
 		if (event === "on_run_step") {
-			const runStep = data;
+			const incomingRunStep = data;
+			const toolCalls = incomingRunStep.stepDetails.type === "tool_calls" ? incomingRunStep.stepDetails.tool_calls : void 0;
+			syncSeededContent();
+			let runStepIndex;
+			const toolCallIndices = [];
+			if (toolCalls && toolCalls.length > 0) {
+				for (let index = 0; index < toolCalls.length; index++) {
+					const toolCallId = toolCalls[index].id;
+					let contentIndex = getToolCallContentIndex(toolCallId);
+					if (contentIndex == null) contentIndex = index === 0 ? resolveSourceContentIndex(incomingRunStep.index) : allocateContentIndex();
+					else if (index === 0) sourceContentIndexMap.set(incomingRunStep.index, contentIndex);
+					toolCallIndices.push(contentIndex);
+				}
+				runStepIndex = toolCallIndices[0];
+			} else runStepIndex = resolveSourceContentIndex(incomingRunStep.index);
+			const runStep = runStepIndex !== incomingRunStep.index ? {
+				...incomingRunStep,
+				index: runStepIndex
+			} : incomingRunStep;
 			stepMap.set(runStep.id, runStep);
-			const hasAgentId = runStep.agentId != null && runStep.agentId !== "";
-			const hasGroupId = runStep.groupId != null;
-			if (hasAgentId || hasGroupId) {
-				const existingMeta = contentMetaMap.get(runStep.index) ?? {};
-				if (hasAgentId) existingMeta.agentId = runStep.agentId;
-				if (hasGroupId) existingMeta.groupId = runStep.groupId;
-				contentMetaMap.set(runStep.index, existingMeta);
-			}
+			setContentMeta(runStep.index, runStep);
 			if (runStep.summary != null) updateContent(runStep.index, runStep.summary);
-			if (runStep.stepDetails.type === "tool_calls" && runStep.stepDetails.tool_calls) runStep.stepDetails.tool_calls.forEach((toolCall) => {
-				const toolCallId = toolCall.id ?? "";
-				if ("id" in toolCall && toolCallId) toolCallIdMap.set(runStep.id, toolCallId);
-				const contentPart = {
-					type: "tool_call",
-					tool_call: {
-						args: toolCall.args,
-						name: toolCall.name,
-						id: toolCallId
-					}
-				};
-				updateContent(runStep.index, contentPart);
-			});
+			if (runStep.stepDetails.type === "tool_calls") {
+				const toolStepContent = toolStepContentMap.get(runStep.id) ?? createToolStepContentState(runStep.index);
+				registerToolContentIndex(toolStepContent, runStep.index);
+				runStep.stepDetails.tool_calls?.forEach((toolCall, toolCallIndex) => {
+					const contentIndex = toolCallIndices[toolCallIndex] ?? runStep.index;
+					const toolCallId = toolCall.id ?? "";
+					registerToolContentIndex(toolStepContent, contentIndex, toolCallId);
+					const contentPart = {
+						type: "tool_call",
+						tool_call: {
+							args: toolCall.args,
+							name: toolCall.name,
+							id: toolCallId
+						}
+					};
+					setContentMeta(contentIndex, runStep);
+					updateContent(contentIndex, contentPart);
+				});
+				toolStepContentMap.set(runStep.id, toolStepContent);
+			}
 		} else if (event === "on_message_delta") {
 			const messageDelta = data;
 			const runStep = stepMap.get(messageDelta.id);
@@ -918,7 +1027,14 @@ function createContentAggregator() {
 		} else if (event === "on_agent_update" && data?.agent_update) {
 			const contentPart = data;
 			if (!contentPart) return;
-			updateContent(contentPart.agent_update.index, contentPart);
+			const contentIndex = resolveSourceContentIndex(contentPart.agent_update.index);
+			updateContent(contentIndex, {
+				...contentPart,
+				agent_update: {
+					...contentPart.agent_update,
+					index: contentIndex
+				}
+			});
 		} else if (event === "on_reasoning_delta") {
 			const reasoningDelta = data;
 			const runStep = stepMap.get(reasoningDelta.id);
@@ -935,35 +1051,75 @@ function createContentAggregator() {
 				console.warn("No run step or runId found for run step delta event");
 				return;
 			}
-			if (runStepDelta.delta.type === "tool_calls" && runStepDelta.delta.tool_calls) runStepDelta.delta.tool_calls.forEach((toolCallDelta) => {
-				const toolCallId = toolCallIdMap.get(runStepDelta.id);
-				const contentPart = {
-					type: "tool_call",
-					tool_call: {
-						args: toolCallDelta.args ?? "",
-						name: toolCallDelta.name,
-						id: toolCallId,
-						auth: runStepDelta.delta.auth,
-						expires_at: runStepDelta.delta.expires_at
+			if (runStepDelta.delta.type === "tool_calls" && runStepDelta.delta.tool_calls) {
+				const toolStepContent = toolStepContentMap.get(runStepDelta.id) ?? createToolStepContentState(runStep.index);
+				runStepDelta.delta.tool_calls.forEach((toolCallDelta) => {
+					const chunkIndex = typeof toolCallDelta.index === "number" ? toolCallDelta.index : void 0;
+					const explicitToolCallId = toolCallDelta.id != null && toolCallDelta.id !== "" ? toolCallDelta.id : void 0;
+					let contentIndex = getToolCallContentIndex(explicitToolCallId);
+					if (contentIndex == null && chunkIndex != null) contentIndex = toolStepContent.chunkIndices.get(chunkIndex);
+					const soleContentIndex = toolStepContent.indices.size === 1 ? toolStepContent.indices.values().next().value : void 0;
+					if (contentIndex == null && explicitToolCallId == null && soleContentIndex != null && (chunkIndex == null || toolStepContent.callIdsByIndex.has(soleContentIndex) || toolStepContent.unclaimedIndices.has(soleContentIndex))) contentIndex = soleContentIndex;
+					if (contentIndex == null) {
+						if (chunkIndex == null && explicitToolCallId == null) {
+							console.warn("No tool call id or chunk index found for run step delta event");
+							return;
+						}
+						contentIndex = explicitToolCallId == null ? takeFirstIndex(toolStepContent.unclaimedIndices) : takeFirstIndex(toolStepContent.unboundIndices);
+						contentIndex ??= allocateContentIndex();
 					}
-				};
-				updateContent(runStep.index, contentPart);
-			});
+					registerToolContentIndex(toolStepContent, contentIndex, explicitToolCallId);
+					if (chunkIndex != null) {
+						toolStepContent.chunkIndices.set(chunkIndex, contentIndex);
+						toolStepContent.unclaimedIndices.delete(contentIndex);
+						toolStepContent.unboundIndices.delete(contentIndex);
+					}
+					const toolCallId = explicitToolCallId ?? toolStepContent.callIdsByIndex.get(contentIndex);
+					const contentPart = {
+						type: "tool_call",
+						tool_call: {
+							args: toolCallDelta.args ?? "",
+							name: toolCallDelta.name,
+							id: toolCallId,
+							auth: runStepDelta.delta.auth,
+							expires_at: runStepDelta.delta.expires_at
+						}
+					};
+					setContentMeta(contentIndex, runStep);
+					updateContent(contentIndex, contentPart);
+				});
+				toolStepContentMap.set(runStepDelta.id, toolStepContent);
+			}
 		} else if (event === "on_run_step_completed") {
 			const { result } = data;
 			const { id: stepId } = result;
 			const runStep = stepMap.get(stepId);
-			if (!runStep) {
-				console.warn("No run step or runId found for completed step event");
-				return;
-			}
-			if (result.type === "summary" && "summary" in result) contentParts[runStep.index] = result.summary;
-			else if ("tool_call" in result) {
+			if (result.type === "summary" && "summary" in result) {
+				if (!runStep) {
+					console.warn("No run step or runId found for completed step event");
+					return;
+				}
+				contentParts[runStep.index] = result.summary;
+				applyContentMetadata(runStep.index);
+			} else if ("tool_call" in result) {
+				let contentIndex = getToolCallContentIndex(result.tool_call.id);
+				if (contentIndex == null && runStep != null) {
+					const toolStepContent = toolStepContentMap.get(runStep.id);
+					if (toolStepContent?.indices.size === 1) contentIndex = toolStepContent.indices.values().next().value;
+					else if (toolStepContent == null) {
+						if (((runStep.stepDetails.type === "tool_calls" ? runStep.stepDetails.tool_calls : void 0)?.length ?? 0) <= 1) contentIndex = runStep.index;
+					}
+				}
+				if (contentIndex == null) {
+					console.warn("No run step or tool call found for completed step event");
+					return;
+				}
+				if (runStep != null) setContentMeta(contentIndex, runStep);
 				const contentPart = {
 					type: "tool_call",
 					tool_call: result.tool_call
 				};
-				updateContent(runStep.index, contentPart, true);
+				updateContent(contentIndex, contentPart, true);
 			}
 		}
 	};