@librechat/agents 3.1.88 → 3.1.90

package/dist/esm/tools/subagent/SubagentExecutor.mjs

@@ -1,17 +1,24 @@
 import { nanoid } from 'nanoid';
 import { BaseCallbackHandler } from '@langchain/core/callbacks/base';
 import { HumanMessage } from '@langchain/core/messages';
-import { GraphEvents, Callback } from '../../common/enum.mjs';
+import { GraphEvents, Callback, StepTypes } from '../../common/enum.mjs';
 import { executeHooks } from '../../hooks/executeHooks.mjs';
 import '../../hooks/createWorkspacePolicyHook.mjs';
 
 const DEFAULT_MAX_TURNS = 25;
 const RECURSION_MULTIPLIER = 3;
 const ERROR_MESSAGE_MAX_CHARS = 200;
+const MAX_PENDING_SUBAGENT_UPDATES = 64;
 const HOOK_FALLBACK = Object.freeze({
     additionalContexts: [],
     errors: [],
 });
+const LANGGRAPH_RUNTIME_CONFIG_PREFIX = '__pregel_';
+const LANGGRAPH_CHECKPOINT_CONFIG_KEYS = new Set([
+    'checkpoint_id',
+    'checkpoint_map',
+    'checkpoint_ns',
+]);
 class SubagentExecutor {
     configs;
     parentSignal;
@@ -110,7 +117,7 @@ class SubagentExecutor {
             agents: [childInputs],
             tokenCounter: this.tokenCounter,
         });
-        const forwarder = forwardingEnabled
+        const forwarding = forwardingEnabled
             ? this.createForwarderCallback({
                 parentRegistry: parentRegistry,
                 subagentType,
@@ -119,6 +126,7 @@ class SubagentExecutor {
                 parentToolCallId,
             })
             : undefined;
+        const forwarder = forwarding?.handler;
         if (forwarder) {
             await this.emitSubagentUpdate(parentRegistry, {
                 childRunId,
@@ -151,10 +159,11 @@ class SubagentExecutor {
              */
             const callbacks = forwarder ? [forwarder] : [];
             /**
-             * Inherit the parent's `configurable` verbatim — host-set fields
+             * Inherit the parent's host `configurable` — host-set fields
              * (`requestBody`, `user`, `userMCPAuthMap`, etc.) AND the run-
              * identity fields (`run_id`, `parent_run_id`, `thread_id`) all
-             * propagate.
+             * propagate. LangGraph's own runtime keys are excluded because the
+             * child graph creates its own scratchpad/checkpoint/abort plumbing.
              *
              * Run-identity propagation is intentional and matches the
              * convention this executor itself already uses for `SubagentStart`
@@ -178,7 +187,7 @@ class SubagentExecutor {
              * For now the inheritance path matches LibreChat's primary use
              * case (synchronous subagents within a single user turn).
              */
-            const inheritedConfigurable = params.parentConfigurable ?? {};
+            const inheritedConfigurable = sanitizeChildConfigurable(params.parentConfigurable);
             result = await workflow.invoke({ messages: [new HumanMessage(description)] }, {
                 recursionLimit: maxTurns * RECURSION_MULTIPLIER,
                 signal: this.parentSignal,
@@ -193,6 +202,7 @@ class SubagentExecutor {
         catch (error) {
             const errorMessage = truncateErrorMessage(error);
             if (forwarder) {
+                await forwarding.drain();
                 await this.emitSubagentUpdate(parentRegistry, {
                     childRunId,
                     subagentType,
@@ -234,6 +244,7 @@ class SubagentExecutor {
             });
         }
         if (forwarder) {
+            await forwarding.drain();
             await this.emitSubagentUpdate(parentRegistry, {
                 childRunId,
                 subagentType,
@@ -296,25 +307,67 @@ class SubagentExecutor {
             if (!handler) {
                 return;
             }
-            const event = {
-                runId: parentRunId,
-                subagentRunId: childRunId,
-                subagentType,
-                subagentAgentId,
-                parentAgentId,
-                parentToolCallId,
-                phase,
-                data,
-                label: summarizeEvent(eventName, data),
-                timestamp: new Date().toISOString(),
-            };
             try {
+                const event = {
+                    runId: parentRunId,
+                    subagentRunId: childRunId,
+                    subagentType,
+                    subagentAgentId,
+                    parentAgentId,
+                    parentToolCallId,
+                    phase,
+                    data: sanitizeForwardedSubagentUpdateData(eventName, data),
+                    label: summarizeEvent(eventName, data),
+                    timestamp: new Date().toISOString(),
+                };
                 await handler.handle(GraphEvents.ON_SUBAGENT_UPDATE, event);
             }
             catch {
                 /* observational — swallow */
             }
         };
+        const queuedUpdates = [];
+        let drainPromise;
+        const enqueue = (update) => {
+            if (queuedUpdates.length >= MAX_PENDING_SUBAGENT_UPDATES) {
+                const dropIndex = queuedUpdates.findIndex((queued) => isDroppableSubagentUpdatePhase(queued.phase));
+                if (dropIndex >= 0) {
+                    queuedUpdates.splice(dropIndex, 1);
+                }
+                else if (isDroppableSubagentUpdatePhase(update.phase)) {
+                    return;
+                }
+            }
+            queuedUpdates.push(update);
+        };
+        const drain = async () => {
+            if (drainPromise != null) {
+                await drainPromise;
+                return;
+            }
+            drainPromise = (async () => {
+                while (queuedUpdates.length > 0) {
+                    const update = queuedUpdates.shift();
+                    if (update == null) {
+                        continue;
+                    }
+                    await wrap(update.eventName, update.phase, update.data);
+                }
+            })();
+            try {
+                await drainPromise;
+            }
+            finally {
+                drainPromise = undefined;
+                if (queuedUpdates.length > 0) {
+                    await drain();
+                }
+            }
+        };
+        const scheduleWrap = (eventName, phase, data) => {
+            enqueue({ eventName, phase, data });
+            void drain();
+        };
         const handler = BaseCallbackHandler.fromMethods({
             [Callback.CUSTOM_EVENT]: async (eventName, data) => {
                 if (eventName === GraphEvents.ON_TOOL_EXECUTE) {
@@ -326,27 +379,27 @@ class SubagentExecutor {
                      * We also surface a short notice in the subagent-update stream so
                      * the UI can show "calling <tool>" for each tool the child spawns.
                      */
-                    await wrap(eventName, 'run_step', data);
+                    scheduleWrap(eventName, 'run_step', data);
                     return;
                 }
                 if (eventName === GraphEvents.ON_RUN_STEP) {
-                    await wrap(eventName, 'run_step', data);
+                    scheduleWrap(eventName, 'run_step', data);
                     return;
                 }
                 if (eventName === GraphEvents.ON_RUN_STEP_DELTA) {
-                    await wrap(eventName, 'run_step_delta', data);
+                    scheduleWrap(eventName, 'run_step_delta', data);
                     return;
                 }
                 if (eventName === GraphEvents.ON_RUN_STEP_COMPLETED) {
-                    await wrap(eventName, 'run_step_completed', data);
+                    scheduleWrap(eventName, 'run_step_completed', data);
                     return;
                 }
                 if (eventName === GraphEvents.ON_MESSAGE_DELTA) {
-                    await wrap(eventName, 'message_delta', data);
+                    scheduleWrap(eventName, 'message_delta', data);
                     return;
                 }
                 if (eventName === GraphEvents.ON_REASONING_DELTA) {
-                    await wrap(eventName, 'reasoning_delta', data);
+                    scheduleWrap(eventName, 'reasoning_delta', data);
                     return;
                 }
             },
@@ -354,15 +407,251 @@ class SubagentExecutor {
         /**
          * `awaitHandlers = true` is required so the child's `ToolNode` actually
          * blocks on the parent's `ON_TOOL_EXECUTE` handler until it resolves
-         * the batch request. The same flag applies to observational events
-         * (message_delta, run_step, …), which means a slow
-         * `ON_SUBAGENT_UPDATE` handler on the host serializes the child
-         * stream. If host-side latency becomes a concern, a future
-         * refinement could split operational and observational events into
-         * separate callback handlers with distinct await semantics.
+         * the batch request. Observational `ON_SUBAGENT_UPDATE` calls are queued
+         * behind a bounded sequential dispatcher so host UI publication cannot
+         * backpressure each child emission or run unbounded concurrent publishes.
+         * The executor drains this queue before terminal stop/error envelopes to
+         * preserve phase ordering.
          */
         handler.awaitHandlers = true;
-        return handler;
+        return { handler, drain };
+    }
+}
+function sanitizeChildConfigurable(parentConfigurable) {
+    if (parentConfigurable == null) {
+        return {};
+    }
+    return Object.fromEntries(Object.entries(parentConfigurable).filter(([key]) => !isLangGraphRuntimeConfigKey(key)));
+}
+function isLangGraphRuntimeConfigKey(key) {
+    return (key.startsWith(LANGGRAPH_RUNTIME_CONFIG_PREFIX) ||
+        LANGGRAPH_CHECKPOINT_CONFIG_KEYS.has(key));
+}
+function sanitizeForwardedSubagentUpdateData(eventName, data) {
+    if (eventName === GraphEvents.ON_TOOL_EXECUTE) {
+        return sanitizeToolExecuteUpdateData(data);
+    }
+    if (eventName === GraphEvents.ON_RUN_STEP) {
+        return sanitizeRunStepUpdateData(data);
+    }
+    if (eventName === GraphEvents.ON_RUN_STEP_DELTA) {
+        return sanitizeRunStepDeltaUpdateData(data);
+    }
+    if (eventName === GraphEvents.ON_RUN_STEP_COMPLETED) {
+        return sanitizeRunStepCompletedUpdateData(data);
+    }
+    if (eventName === GraphEvents.ON_MESSAGE_DELTA) {
+        return sanitizeMessageDeltaUpdateData(data);
+    }
+    if (eventName === GraphEvents.ON_REASONING_DELTA) {
+        return sanitizeReasoningDeltaUpdateData(data);
+    }
+    return undefined;
+}
+function isDroppableSubagentUpdatePhase(phase) {
+    return (phase === 'message_delta' ||
+        phase === 'reasoning_delta' ||
+        phase === 'run_step_delta');
+}
+function sanitizeToolExecuteUpdateData(data) {
+    const request = data;
+    const toolCalls = Array.isArray(request.toolCalls)
+        ? request.toolCalls.map(sanitizeToolCallForUpdate)
+        : [];
+    const sanitized = { toolCalls };
+    if (typeof request.agentId === 'string') {
+        sanitized.agentId = request.agentId;
+    }
+    return sanitized;
+}
+function sanitizeToolCallForUpdate(call) {
+    const sanitized = {
+        id: call.id,
+        name: call.name,
+        args: call.args,
+    };
+    return sanitized;
+}
+function sanitizeRunStepUpdateData(data) {
+    if (!isObjectLike(data)) {
+        return undefined;
+    }
+    const step = data;
+    const sanitized = {};
+    assignString(sanitized, 'agentId', step.agentId);
+    assignNumber(sanitized, 'groupId', step.groupId);
+    assignString(sanitized, 'id', step.id);
+    assignNumber(sanitized, 'index', step.index);
+    assignString(sanitized, 'runId', step.runId);
+    assignNumber(sanitized, 'stepIndex', step.stepIndex);
+    assignString(sanitized, 'type', step.type);
+    if (step.summary !== undefined) {
+        sanitized.summary = step.summary;
+    }
+    if (step.usage !== undefined) {
+        sanitized.usage = step.usage;
+    }
+    sanitized.stepDetails = sanitizeStepDetails(step.stepDetails);
+    return sanitized;
+}
+function sanitizeRunStepDeltaUpdateData(data) {
+    if (!isObjectLike(data)) {
+        return undefined;
+    }
+    const event = data;
+    const sanitized = {};
+    assignString(sanitized, 'id', event.id);
+    sanitized.delta = sanitizeToolCallDelta(event.delta);
+    return sanitized;
+}
+function sanitizeRunStepCompletedUpdateData(data) {
+    if (!isObjectLike(data)) {
+        return undefined;
+    }
+    const event = data;
+    return { result: sanitizeStepCompleted(event.result) };
+}
+function sanitizeMessageDeltaUpdateData(data) {
+    if (!isObjectLike(data)) {
+        return undefined;
+    }
+    const event = data;
+    const sanitized = {};
+    assignString(sanitized, 'id', event.id);
+    if (event.delta != null) {
+        sanitized.delta = {};
+        if (event.delta.content !== undefined) {
+            sanitized.delta.content = event.delta.content;
+        }
+        if (event.delta.tool_call_ids !== undefined) {
+            sanitized.delta.tool_call_ids = event.delta.tool_call_ids;
+        }
+    }
+    return sanitized;
+}
+function sanitizeReasoningDeltaUpdateData(data) {
+    if (!isObjectLike(data)) {
+        return undefined;
+    }
+    const event = data;
+    const sanitized = {};
+    assignString(sanitized, 'id', event.id);
+    if (event.delta?.content !== undefined) {
+        sanitized.delta = { content: event.delta.content };
+    }
+    return sanitized;
+}
+function sanitizeStepDetails(stepDetails) {
+    if (!isObjectLike(stepDetails)) {
+        return undefined;
+    }
+    const rawDetails = stepDetails;
+    if (rawDetails.type === StepTypes.MESSAGE_CREATION) {
+        const sanitized = {
+            type: StepTypes.MESSAGE_CREATION,
+        };
+        const messageId = rawDetails.message_creation?.message_id;
+        if (typeof messageId === 'string') {
+            sanitized.message_creation = { message_id: messageId };
+        }
+        return sanitized;
+    }
+    if (rawDetails.type === StepTypes.TOOL_CALLS) {
+        const sanitized = {
+            type: StepTypes.TOOL_CALLS,
+        };
+        if (Array.isArray(rawDetails.tool_calls)) {
+            sanitized.tool_calls = rawDetails.tool_calls.map(sanitizeAgentToolCall);
+        }
+        return sanitized;
+    }
+    return undefined;
+}
+function sanitizeToolCallDelta(delta) {
+    if (!isObjectLike(delta)) {
+        return undefined;
+    }
+    const sanitized = {};
+    assignString(sanitized, 'auth', delta.auth);
+    assignNumber(sanitized, 'expires_at', delta.expires_at);
+    assignString(sanitized, 'type', delta.type);
+    if (delta.summary !== undefined) {
+        sanitized.summary = delta.summary;
+    }
+    if (Array.isArray(delta.tool_calls)) {
+        sanitized.tool_calls = delta.tool_calls.map(sanitizeAgentToolCall);
+    }
+    return sanitized;
+}
+function sanitizeStepCompleted(data) {
+    if (!isObjectLike(data)) {
+        return undefined;
+    }
+    const completed = data;
+    if (completed.type === 'summary') {
+        return {
+            type: 'summary',
+            summary: completed.summary,
+        };
+    }
+    if (completed.type !== 'tool_call') {
+        return undefined;
+    }
+    const sanitized = { type: 'tool_call' };
+    assignString(sanitized, 'id', completed.id);
+    assignNumber(sanitized, 'index', completed.index);
+    sanitized.tool_call = sanitizeProcessedToolCall(completed.tool_call);
+    return sanitized;
+}
+function sanitizeProcessedToolCall(toolCall) {
+    if (!isObjectLike(toolCall)) {
+        return undefined;
+    }
+    const call = toolCall;
+    const sanitized = {};
+    assignString(sanitized, 'id', call.id);
+    assignString(sanitized, 'name', call.name);
+    if (call.args !== undefined) {
+        sanitized.args = call.args;
+    }
+    assignString(sanitized, 'output', call.output);
+    assignNumber(sanitized, 'progress', call.progress);
+    return sanitized;
+}
+function sanitizeAgentToolCall(toolCall) {
+    if (!isObjectLike(toolCall)) {
+        return {};
+    }
+    const call = toolCall;
+    const sanitized = {};
+    assignString(sanitized, 'id', call.id);
+    assignString(sanitized, 'name', call.name);
+    assignString(sanitized, 'type', call.type);
+    if (call.args !== undefined) {
+        sanitized.args = call.args;
+    }
+    if (isObjectLike(call.function)) {
+        const fn = {};
+        assignString(fn, 'name', call.function.name);
+        if (typeof call.function.arguments === 'string' ||
+            isObjectLike(call.function.arguments)) {
+            fn.arguments = call.function.arguments;
+        }
+        sanitized.function = fn;
+    }
+    return sanitized;
+}
+function isObjectLike(value) {
+    return value != null && typeof value === 'object' && !Array.isArray(value);
+}
+function assignString(target, key, value) {
+    if (typeof value === 'string') {
+        target[key] = value;
+    }
+}
+function assignNumber(target, key, value) {
+    if (typeof value === 'number') {
+        target[key] = value;
     }
 }
 /**
@@ -532,5 +821,5 @@ function truncateErrorMessage(error) {
     return `${message.slice(0, ERROR_MESSAGE_MAX_CHARS)}...`;
 }
 
-export { SubagentExecutor, buildChildInputs, filterSubagentResult, resolveSubagentConfigs, summarizeEvent };
+export { SubagentExecutor, buildChildInputs, filterSubagentResult, resolveSubagentConfigs, sanitizeForwardedSubagentUpdateData, summarizeEvent };
 //# sourceMappingURL=SubagentExecutor.mjs.map