@librechat/agents 3.1.88 → 3.1.90

package/src/graphs/Graph.ts

@@ -145,6 +145,14 @@ export abstract class Graph<
   /** Set of invoked tool call IDs from non-message run steps completed mid-run, if any */
   invokedToolIds?: Set<string>;
   handlerRegistry: HandlerRegistry | undefined;
+  /**
+   * True when event-driven tool execution can be routed through callbacks even
+   * though this graph intentionally does not own the full handler registry.
+   * Self-spawned subagent graphs use this shape: their callback forwarder sends
+   * `ON_TOOL_EXECUTE` to the parent's handler, while child run-step events stay
+   * wrapped as `ON_SUBAGENT_UPDATE` instead of leaking as parent events.
+   */
+  eventToolExecutionAvailable: boolean = false;
   hookRegistry: HookRegistry | undefined;
   /**
    * Run-scoped HITL configuration. When `humanInTheLoop?.enabled` is
@@ -167,10 +175,8 @@ export abstract class Graph<
   eagerEventToolExecution: t.EagerEventToolExecutionConfig | undefined;
   eagerEventToolExecutions: Map<string, t.EagerEventToolExecution> = new Map();
   eagerEventToolUsageCount: Map<string, number> = new Map();
-  private eagerEventToolUsageCountsByAgentId: Map<
-    string,
-    Map<string, number>
-  > = new Map();
+  private eagerEventToolUsageCountsByAgentId: Map<string, Map<string, number>> =
+    new Map();
   eagerEventToolCallChunks: Map<string, t.EagerEventToolCallChunkState> =
     new Map();
   /**
@@ -1554,7 +1560,23 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
           parentAgentId: agentContext.agentId,
           tokenCounter: agentContext.tokenCounter,
           maxDepth: effectiveSubagentDepth,
-          createChildGraph: (input): StandardGraph => new StandardGraph(input),
+          createChildGraph: (input): StandardGraph => {
+            const childGraph = new StandardGraph(input);
+            childGraph.hookRegistry = this.hookRegistry;
+            /**
+             * Do not propagate `humanInTheLoop` into the child graph yet:
+             * nested subagent interrupts need a stable child checkpoint and
+             * resume bridge. Child hooks still fire; `ask` decisions fail
+             * closed inside the subagent until that flow is implemented.
+             */
+            childGraph.toolOutputReferences = this.toolOutputReferences;
+            childGraph.eagerEventToolExecution = this.eagerEventToolExecution;
+            childGraph.toolExecution = this.toolExecution;
+            childGraph.eventToolExecutionAvailable =
+              this.handlerRegistry?.getHandler(GraphEvents.ON_TOOL_EXECUTE) !=
+              null;
+            return childGraph;
+          },
         });
 
         const subagentTool = tool(async (rawInput, config) => {

package/src/hooks/__tests__/executeHooks.test.ts

@@ -109,6 +109,44 @@ describe('executeHooks', () => {
     consoleWarnSpy.mockRestore();
   });
 
+  describe('abort listener management', () => {
+    it('uses one abort listener for many hooks on one matcher', async () => {
+      const registry = new HookRegistry();
+      const listenerCounts = new Map<AbortSignal, number>();
+      let maxAbortListeners = 0;
+      const addEventListenerSpy = jest
+        .spyOn(AbortSignal.prototype, 'addEventListener')
+        .mockImplementation(function (
+          this: AbortSignal,
+          type: string,
+          _listener: EventListenerOrEventListenerObject | null
+        ): void {
+          if (type !== 'abort') {
+            return;
+          }
+          const count = (listenerCounts.get(this) ?? 0) + 1;
+          listenerCounts.set(this, count);
+          maxAbortListeners = Math.max(maxAbortListeners, count);
+        });
+      const hooks = Array.from({ length: 12 }, () =>
+        runStartHook(async (): Promise<RunStartHookOutput> => ({}))
+      );
+
+      try {
+        registry.register('RunStart', { hooks });
+
+        await executeHooks({
+          registry,
+          input: runStartInput(),
+          timeoutMs: 1000,
+        });
+        expect(maxAbortListeners).toBe(1);
+      } finally {
+        addEventListenerSpy.mockRestore();
+      }
+    });
+  });
+
   describe('empty matcher set', () => {
     it('returns an empty aggregated result when no matchers are registered', async () => {
       const registry = new HookRegistry();

package/src/hooks/executeHooks.ts

@@ -46,6 +46,11 @@ interface HookOutcome {
   timedOut: boolean;
 }
 
+interface AbortRace {
+  promise: Promise<never>;
+  cleanup: () => void;
+}
+
 function freshResult(): AggregatedHookResult {
   return {
     additionalContexts: [],
@@ -110,10 +115,10 @@ async function runHook(
   hook: WideCallback,
   input: HookInput,
   signal: AbortSignal,
+  abortPromise: Promise<never>,
   matcher: WideMatcher
 ): Promise<HookOutcome> {
   const hookPromise = Promise.resolve().then(() => hook(input, signal));
-  const { promise: abortPromise, cleanup } = makeAbortPromise(signal);
   try {
     const output = await Promise.race([hookPromise, abortPromise]);
     return { matcher, output, error: null, timedOut: false };
@@ -124,8 +129,22 @@ async function runHook(
       error: describeError(err),
       timedOut: isTimeout(err),
     };
+  }
+}
+
+async function runMatcherHooks(
+  matcher: WideMatcher,
+  input: HookInput,
+  signal: AbortSignal
+): Promise<HookOutcome[]> {
+  const abortRace: AbortRace = makeAbortPromise(signal);
+  const tasks = matcher.hooks.map((hook) =>
+    runHook(hook, input, signal, abortRace.promise, matcher)
+  );
+  try {
+    return await Promise.all(tasks);
   } finally {
-    cleanup();
+    abortRace.cleanup();
   }
 }
 
@@ -373,7 +392,7 @@ export async function executeHooks(
   }
 
   // --- SYNC CRITICAL SECTION: once-matcher removal must complete before any await ---
-  const tasks: Promise<HookOutcome>[] = [];
+  const tasks: Promise<HookOutcome[]>[] = [];
   for (const matcher of matchers) {
     if (!matchesQuery(matcher.pattern, matchQuery)) {
       continue;
@@ -381,18 +400,19 @@ export async function executeHooks(
     if (matcher.once === true) {
       registry.removeMatcher(event, matcher, sessionId);
     }
+    if (matcher.hooks.length === 0) {
+      continue;
+    }
     const perHookTimeout = matcher.timeout ?? timeoutMs;
     const matcherSignal = combineSignals(signal, perHookTimeout);
-    for (const hook of matcher.hooks) {
-      tasks.push(runHook(hook, input, matcherSignal, matcher));
-    }
+    tasks.push(runMatcherHooks(matcher, input, matcherSignal));
   }
   // --- END SYNC CRITICAL SECTION ---
   if (tasks.length === 0) {
     return freshResult();
   }
 
-  const outcomes = await Promise.all(tasks);
+  const outcomes = (await Promise.all(tasks)).flat();
   reportErrors(outcomes, event, logger);
   const aggregated = fold(outcomes);
   /**

package/src/llm/anthropic/index.ts

@@ -17,9 +17,13 @@ import type {
   ChatAnthropicToolType,
   AnthropicMCPServerURLDefinition,
   AnthropicContextManagementConfigParam,
+  AnthropicRequestOptions,
 } from '@/llm/anthropic/types';
 import { _makeMessageChunkFromAnthropicEvent } from './utils/message_outputs';
-import { _convertMessagesToAnthropicPayload } from './utils/message_inputs';
+import {
+  _convertMessagesToAnthropicPayload,
+  stripUnsupportedAssistantPrefill,
+} from './utils/message_inputs';
 import { handleToolChoice } from './utils/tools';
 
 const DEFAULT_STREAM_DELAY = 25;
@@ -591,6 +595,26 @@ export class CustomAnthropic extends ChatAnthropicMessages {
     });
   }
 
+  protected override async createStreamWithRetry(
+    request: AnthropicStreamingMessageCreateParams,
+    options?: AnthropicRequestOptions
+  ): ReturnType<ChatAnthropicMessages['createStreamWithRetry']> {
+    return super.createStreamWithRetry(
+      stripUnsupportedAssistantPrefill(request),
+      options
+    );
+  }
+
+  protected override async completionWithRetry(
+    request: AnthropicMessageCreateParams,
+    options: AnthropicRequestOptions
+  ): ReturnType<ChatAnthropicMessages['completionWithRetry']> {
+    return super.completionWithRetry(
+      stripUnsupportedAssistantPrefill(request),
+      options
+    );
+  }
+
   async *_streamResponseChunks(
     messages: BaseMessage[],
     options: this['ParsedCallOptions'],
@@ -599,11 +623,11 @@ export class CustomAnthropic extends ChatAnthropicMessages {
     this.resetTokenEvents();
     const params = this.invocationParams(options);
     const formattedMessages = _convertMessagesToAnthropicPayload(messages);
-    const payload = {
+    const payload = stripUnsupportedAssistantPrefill({
       ...params,
       ...formattedMessages,
       stream: true,
-    } as const;
+    } as const);
     const coerceContentToString =
       !_toolsInParams(payload) &&
       !_documentsInParams(payload) &&

package/src/llm/anthropic/llm.spec.ts

@@ -64,7 +64,11 @@ import type {
   ToolEndEvent,
   TPayload,
 } from '@/types';
-import { _convertMessagesToAnthropicPayload } from './utils/message_inputs';
+import {
+  _convertMessagesToAnthropicPayload,
+  modelDisallowsAssistantPrefill,
+  stripUnsupportedAssistantPrefill,
+} from './utils/message_inputs';
 import {
   _makeMessageChunkFromAnthropicEvent,
   getAnthropicUsageMetadata,
@@ -2637,6 +2641,61 @@ describe('Anthropic Reasoning with contentBlocks', () => {
   });
 });
 
+describe('Claude assistant prefill compatibility', () => {
+  test.each([
+    'claude-sonnet-4-6',
+    'claude-sonnet-4-6@20260217',
+    'claude-opus-4-7',
+    'claude-opus-4-10',
+    'global.anthropic.claude-opus-4-6-v1:0',
+    'anthropic/claude-sonnet-4.6',
+    'anthropic/claude-sonnet-4.12',
+  ])('detects %s as not supporting assistant prefill', (model) => {
+    expect(modelDisallowsAssistantPrefill(model)).toBe(true);
+  });
+
+  test.each([
+    'claude-sonnet-4-5-20250929',
+    'claude-opus-4-20250514',
+    'anthropic.claude-opus-4-20250514-v1:0',
+    'gpt-5.4',
+  ])('leaves %s prefill support unchanged', (model) => {
+    expect(modelDisallowsAssistantPrefill(model)).toBe(false);
+  });
+
+  test('strips trailing assistant messages for Claude 4.6+ requests', () => {
+    const request = {
+      model: 'claude-opus-4-6',
+      max_tokens: 100,
+      messages: [
+        { role: 'user' as const, content: 'What changed?' },
+        { role: 'assistant' as const, content: 'Draft prefill' },
+        { role: 'assistant' as const, content: 'Another prefill' },
+      ],
+    };
+
+    const sanitized = stripUnsupportedAssistantPrefill(request);
+
+    expect(sanitized).not.toBe(request);
+    expect(sanitized.messages).toEqual([
+      { role: 'user', content: 'What changed?' },
+    ]);
+  });
+
+  test('does not strip assistant messages for older Claude models', () => {
+    const request = {
+      model: 'claude-sonnet-4-5-20250929',
+      max_tokens: 100,
+      messages: [
+        { role: 'user' as const, content: 'Write JSON only.' },
+        { role: 'assistant' as const, content: '{' },
+      ],
+    };
+
+    expect(stripUnsupportedAssistantPrefill(request)).toBe(request);
+  });
+});
+
 const opus46Model = 'claude-opus-4-6';
 
 describe('Opus 4.6', () => {

package/src/llm/anthropic/utils/message_inputs.ts

@@ -49,6 +49,10 @@ type GoogleFunctionCallBlock = MessageContentComplex & {
 };
 
 const ANTHROPIC_EMPTY_TEXT_PLACEHOLDER = '_';
+const CLAUDE_4_RELEASE_DATE_MODEL_PATTERN =
+  /claude-(?:opus|sonnet|haiku)-4-\d{8}(?:[-.@]|$)/i;
+const CLAUDE_4_MINOR_MODEL_PATTERN =
+  /claude-(?:opus|sonnet|haiku)-4[-.](\d+)(?:[-.@]|$)/i;
 
 function _formatImage(imageUrl: string) {
   const parsed = parseBase64DataUrl({ dataUrl: imageUrl });
@@ -796,6 +800,48 @@ export function _convertMessagesToAnthropicPayload(
   } as AnthropicMessageCreateParams;
 }
 
+export function modelDisallowsAssistantPrefill(model?: string): boolean {
+  const modelId = model ?? '';
+  if (CLAUDE_4_RELEASE_DATE_MODEL_PATTERN.test(modelId)) {
+    return false;
+  }
+
+  const match = CLAUDE_4_MINOR_MODEL_PATTERN.exec(modelId);
+  if (!match) {
+    return false;
+  }
+  return Number(match[1]) >= 6;
+}
+
+export function stripUnsupportedAssistantPrefill<
+  T extends Pick<AnthropicMessageCreateParams, 'messages'> & { model?: string },
+>(request: T): T {
+  if (!modelDisallowsAssistantPrefill(request.model)) {
+    return request;
+  }
+
+  const messages = request.messages;
+  if (
+    messages.length <= 1 ||
+    messages[messages.length - 1]?.role !== 'assistant'
+  ) {
+    return request;
+  }
+
+  const nextMessages = [...messages];
+  while (
+    nextMessages.length > 1 &&
+    nextMessages[nextMessages.length - 1]?.role === 'assistant'
+  ) {
+    nextMessages.pop();
+  }
+
+  return {
+    ...request,
+    messages: nextMessages,
+  };
+}
+
 function mergeMessages(messages: AnthropicMessageCreateParams['messages']) {
   if (messages.length <= 1) {
     return messages;

package/src/specs/subagent.test.ts

@@ -1,4 +1,4 @@
-import { HumanMessage } from '@langchain/core/messages';
+import { AIMessage, HumanMessage } from '@langchain/core/messages';
 import { FakeListChatModel } from '@langchain/core/utils/testing';
 import type { ToolCall } from '@langchain/core/messages/tool';
 import type { RunnableConfig } from '@langchain/core/runnables';
@@ -220,6 +220,92 @@ describe('Subagent Integration', () => {
     expect(subagentTool).toBeDefined();
   });
 
+  it('inherits eager event-tool settings into self-spawn child graphs', async () => {
+    const originalCreateWorkflow = StandardGraph.prototype.createWorkflow;
+    const observedChildGraphs: Array<{
+      eagerEventToolExecution: StandardGraph['eagerEventToolExecution'];
+      toolOutputReferences: StandardGraph['toolOutputReferences'];
+      eventToolExecutionAvailable: boolean;
+    }> = [];
+    const createWorkflowSpy = jest
+      .spyOn(StandardGraph.prototype, 'createWorkflow')
+      .mockImplementation(function (this: StandardGraph) {
+        if (this.runId?.includes('_sub_') === true) {
+          observedChildGraphs.push({
+            eagerEventToolExecution: this.eagerEventToolExecution,
+            toolOutputReferences: this.toolOutputReferences,
+            eventToolExecutionAvailable: this.eventToolExecutionAvailable,
+          });
+          return {
+            invoke: jest.fn(async () => ({
+              messages: [new AIMessage('child done')],
+            })),
+          } as unknown as ReturnType<StandardGraph['createWorkflow']>;
+        }
+        return originalCreateWorkflow.call(this);
+      });
+
+    const agentWithSelfSpawn: t.AgentInputs = {
+      agentId: 'self-parent',
+      provider: Providers.OPENAI,
+      clientOptions: { modelName: 'gpt-4o-mini', apiKey: 'test-key' },
+      instructions: 'Agent with self-spawn for context isolation.',
+      maxContextTokens: 8000,
+      toolDefinitions: [{ name: 'mcp_lookup' }],
+      subagentConfigs: [
+        {
+          type: 'isolated',
+          name: 'Isolated Worker',
+          description: 'Runs a task with isolated context',
+          self: true,
+        },
+      ],
+    };
+
+    const run = await Run.create<t.IState>({
+      runId: `self-spawn-eager-${Date.now()}`,
+      graphConfig: {
+        type: 'standard',
+        agents: [agentWithSelfSpawn],
+      },
+      customHandlers: {
+        [GraphEvents.ON_TOOL_EXECUTE]: {
+          handle: async () => undefined,
+        },
+      },
+      eagerEventToolExecution: { enabled: true },
+      toolOutputReferences: { enabled: true },
+      returnContent: true,
+      skipCleanup: true,
+    });
+
+    const context = (run.Graph as StandardGraph).agentContexts.get(
+      'self-parent'
+    );
+    const subagentTool = (context?.graphTools as t.GenericTool[]).find(
+      (tool) => 'name' in tool && tool.name === Constants.SUBAGENT
+    );
+    expect(subagentTool).toBeDefined();
+
+    await subagentTool!.invoke(
+      {
+        description: 'Use your MCP tool.',
+        subagent_type: 'isolated',
+      },
+      callerConfig
+    );
+
+    expect(observedChildGraphs).toEqual([
+      {
+        eagerEventToolExecution: { enabled: true },
+        toolOutputReferences: { enabled: true },
+        eventToolExecutionAvailable: true,
+      },
+    ]);
+
+    createWorkflowSpy.mockRestore();
+  });
+
   it('should not create subagent tool when maxSubagentDepth is 0', async () => {
     const agentWithZeroDepth: t.AgentInputs = {
       ...createParentAgent(),