@librechat/agents 3.3.3 → 3.3.5

package/src/stream.dispatch.test.ts

@@ -0,0 +1,63 @@
+import type * as t from '@/types';
+import {
+  ChatModelStreamHandler,
+  dispatchesChatModelStream,
+  SDK_STREAM_DISPATCH,
+} from '@/stream';
+import { composeEventHandlers } from '@/events';
+import { GraphEvents } from '@/common';
+
+const inert: t.EventHandler = {
+  handle: (): void => {
+    /* renders nothing */
+  },
+};
+
+describe('dispatchesChatModelStream', () => {
+  it('recognizes the dispatcher itself', () => {
+    expect(dispatchesChatModelStream(new ChatModelStreamHandler())).toBe(true);
+  });
+
+  it('is false for a handler that owns no content-part dispatch', () => {
+    expect(dispatchesChatModelStream(inert)).toBe(false);
+  });
+
+  it('is false for nothing registered', () => {
+    expect(dispatchesChatModelStream(undefined)).toBe(false);
+  });
+
+  /**
+   * The reason identity is not a usable test: hosts wrap handlers, and every
+   * wrapper fails `instanceof` while still driving the same dispatch. A run
+   * that seals on that basis would be sealing against its own contract.
+   */
+  it('sees through a composed wrapper in either position', () => {
+    const first = composeEventHandlers(
+      { [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler() },
+      { [GraphEvents.CHAT_MODEL_STREAM]: inert }
+    )[GraphEvents.CHAT_MODEL_STREAM];
+    const second = composeEventHandlers(
+      { [GraphEvents.CHAT_MODEL_STREAM]: inert },
+      { [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler() }
+    )[GraphEvents.CHAT_MODEL_STREAM];
+
+    expect(first).not.toBeInstanceOf(ChatModelStreamHandler);
+    expect(second).not.toBeInstanceOf(ChatModelStreamHandler);
+    expect(dispatchesChatModelStream(first)).toBe(true);
+    expect(dispatchesChatModelStream(second)).toBe(true);
+  });
+
+  it('does not brand a composition of inert handlers', () => {
+    const composed = composeEventHandlers(
+      { [GraphEvents.CHAT_MODEL_STREAM]: inert },
+      { [GraphEvents.CHAT_MODEL_STREAM]: inert }
+    )[GraphEvents.CHAT_MODEL_STREAM];
+    expect(dispatchesChatModelStream(composed)).toBe(false);
+  });
+
+  it('exposes the brand as a cross-realm-safe registered symbol', () => {
+    expect(SDK_STREAM_DISPATCH).toBe(
+      Symbol.for('@librechat/agents:chatModelStreamDispatch')
+    );
+  });
+});

package/src/stream.ts

@@ -26,6 +26,10 @@ import {
   coerceRecordArgs,
   normalizeError,
 } from '@/tools/eagerEventExecution';
+import {
+  serializeStructuredValueBounded,
+  serializeToolContentBounded,
+} from '@/utils/toolContent';
 import {
   handleServerToolResult,
   handleToolCallChunks,
@@ -841,15 +845,20 @@ async function dispatchEagerToolCompletions(args: {
     if (stepId === '') {
       continue;
     }
-    const output =
-      result.status === 'error'
-        ? `Error: ${result.errorMessage ?? 'Unknown error'}\n Please fix your mistakes.`
-        : truncateToolResultContent(
-          typeof result.content === 'string'
-            ? result.content
-            : JSON.stringify(result.content),
-          maxToolResultChars
-        );
+    let output: string;
+    if (result.status === 'error') {
+      output = truncateToolResultContent(
+        `Error: ${result.errorMessage ?? 'Unknown error'}\n Please fix your mistakes.`,
+        maxToolResultChars
+      );
+    } else if (typeof result.content === 'string') {
+      output = truncateToolResultContent(result.content, maxToolResultChars);
+    } else {
+      output = serializeStructuredValueBounded(
+        result.content,
+        maxToolResultChars
+      ).content;
+    }
 
     try {
       const dispatched = await safeDispatchCustomEvent(
@@ -861,7 +870,10 @@ async function dispatchEagerToolCompletions(args: {
             type: 'tool_call' as const,
             eager: true,
             tool_call: {
-              args: JSON.stringify(record.request.args),
+              args: serializeToolContentBounded(
+                record.request.args,
+                maxToolResultChars
+              ),
               name: record.toolName,
               id: result.toolCallId,
               output,
@@ -1388,7 +1400,34 @@ function shouldSkipLateOpenRouterReasoningChunk({
   );
 }
 
+/**
+ * Brands a handler as one that dispatches content parts for the SDK — either
+ * `ChatModelStreamHandler` itself or a wrapper forwarding to one.
+ *
+ * Identity alone is not a usable contract here. Hosts compose and wrap
+ * handlers (`composeEventHandlers`, `createRunHandlers`), and every wrapper
+ * fails `instanceof` while still driving the same dispatch. A brand survives
+ * wrapping, so "does this handler own content-part dispatch" can be answered
+ * about a value the SDK did not construct.
+ */
+export const SDK_STREAM_DISPATCH = Symbol.for(
+  '@librechat/agents:chatModelStreamDispatch'
+);
+
+/** True when `handler` is, or forwards to, the SDK's stream dispatcher. */
+export function dispatchesChatModelStream(handler?: t.EventHandler): boolean {
+  if (handler == null) {
+    return false;
+  }
+  if (handler instanceof ChatModelStreamHandler) {
+    return true;
+  }
+  return Reflect.get(handler, SDK_STREAM_DISPATCH) === true;
+}
+
 export class ChatModelStreamHandler implements t.EventHandler {
+  readonly [SDK_STREAM_DISPATCH] = true;
+
   async handle(
     event: string,
     data: t.StreamEventData,
@@ -1834,13 +1873,16 @@ export function createContentAggregator(): t.ContentAggregatorResult {
     number,
     { agentId?: string; groupId?: number }
   >();
-  const getFirstContentPart = (
+  /** A delta's content may carry several parts (e.g. Google server-side tool
+   *  chunks emit multiple reasoning entries at once); every entry must reach
+   *  the step's slot, in order, or streamed text is silently lost. */
+  const getDeltaContentParts = (
     content?: t.MessageDelta['content'] | t.MessageContentComplex
-  ): t.MessageContentComplex | undefined => {
+  ): t.MessageContentComplex[] => {
     if (content == null) {
-      return undefined;
+      return [];
     }
-    return Array.isArray(content) ? content[0] : content;
+    return Array.isArray(content) ? content : [content];
   };
   const indexContentPart = (
     index: number,
@@ -2248,11 +2290,7 @@ export function createContentAggregator(): t.ContentAggregatorResult {
             const contentIndex =
               toolCallIndices[toolCallIndex] ?? runStep.index;
             const toolCallId = toolCall.id ?? '';
-            registerToolContentIndex(
-              toolStepContent,
-              contentIndex,
-              toolCallId
-            );
+            registerToolContentIndex(toolStepContent, contentIndex, toolCallId);
             const contentPart: t.MessageContentComplex = {
               type: ContentTypes.TOOL_CALL,
               tool_call: {
@@ -2276,8 +2314,7 @@ export function createContentAggregator(): t.ContentAggregatorResult {
         return;
       }
 
-      const contentPart = getFirstContentPart(messageDelta.delta.content);
-      if (contentPart != null) {
+      for (const contentPart of getDeltaContentParts(messageDelta.delta.content)) {
         updateContent(runStep.index, contentPart);
       }
     } else if (
@@ -2306,8 +2343,7 @@ export function createContentAggregator(): t.ContentAggregatorResult {
         return;
       }
 
-      const contentPart = getFirstContentPart(reasoningDelta.delta.content);
-      if (contentPart != null) {
+      for (const contentPart of getDeltaContentParts(reasoningDelta.delta.content)) {
         updateContent(runStep.index, contentPart);
       }
     } else if (event === GraphEvents.ON_RUN_STEP_DELTA) {

package/src/summarization/__tests__/node.test.ts

@@ -1045,6 +1045,83 @@ describe('recency window — first-turn protection', () => {
     expect(tailToolMsg!.content).not.toContain('FULL_ORIGINAL_OUTPUT');
   });
 
+  it('bounds restored tool originals and preserves ToolMessage metadata', async () => {
+    captureEvents();
+
+    let restoredToolMessage: ToolMessage | undefined;
+    const invokeMock = jest.fn().mockImplementation((messages: unknown) => {
+      restoredToolMessage = (messages as Array<unknown>).find(
+        (message) => message instanceof ToolMessage
+      ) as ToolMessage | undefined;
+      return Promise.resolve({ content: 'summary' });
+    });
+    jest.spyOn(providers, 'getChatModelClass').mockReturnValue(
+      class {
+        constructor() {
+          return { invoke: invokeMock };
+        }
+      } as never
+    );
+
+    const artifact = { source: 'clickhouse', rows: 1_000 };
+    const originalToolMessage = new ToolMessage({
+      content: 'masked-stub',
+      tool_call_id: 'bounded',
+      name: 'run_select_query',
+      status: 'success',
+      artifact,
+      metadata: { traceId: 'trace-1' },
+      additional_kwargs: { retained: true },
+      response_metadata: { requestId: 'request-1' },
+    });
+    const agentContext = createAgentContext({
+      maxContextTokens: 2_000,
+      summarizationConfig: { retainRecent: { turns: 0 } },
+      setSummary: jest.fn(),
+    });
+    agentContext.pendingOriginalToolContent = new Map([
+      [2, `[{"rows":"${'x'.repeat(20_000)}"}]`],
+    ]);
+
+    const summarizeNode = createSummarizeNode({
+      agentContext,
+      graph: mockGraph() as never,
+      generateStepId,
+    });
+    await summarizeNode(
+      {
+        messages: [
+          new HumanMessage('query the table'),
+          new AIMessage({
+            content: '',
+            tool_calls: [{ id: 'bounded', name: 'run_select_query', args: {} }],
+          }),
+          originalToolMessage,
+        ],
+        summarizationRequest: {
+          remainingContextTokens: 0,
+          agentId: 'agent_0',
+        },
+      },
+      {} as RunnableConfig
+    );
+
+    expect(restoredToolMessage).toBeDefined();
+    expect(typeof restoredToolMessage!.content).toBe('string');
+    expect(String(restoredToolMessage!.content).length).toBeLessThanOrEqual(
+      2_400
+    );
+    expect(restoredToolMessage!.content).toContain('[truncated:');
+    expect(restoredToolMessage!.status).toBe('success');
+    expect(restoredToolMessage!.artifact).toBe(artifact);
+    expect(restoredToolMessage!.metadata).toEqual({ traceId: 'trace-1' });
+    expect(restoredToolMessage!.additional_kwargs).toEqual({ retained: true });
+    expect(restoredToolMessage!.response_metadata).toEqual({
+      requestId: 'request-1',
+    });
+    expect(originalToolMessage.content).toBe('masked-stub');
+  });
+
   it('preserves tail-relevant pendingOriginalToolContent entries (reindexed) for future summaries', async () => {
     captureEvents();
 

package/src/summarization/node.ts

@@ -10,6 +10,12 @@ import type { AgentContext } from '@/agents/AgentContext';
 import type { HookRegistry } from '@/hooks';
 import type { OnChunk } from '@/llm/invoke';
 import type * as t from '@/types';
+import {
+  cloneToolMessageWithContent,
+  compactToolContent,
+  isComputerCallOutputMessage,
+  serializeToolContentBounded,
+} from '@/utils/toolContent';
 import {
   addTailCacheControl,
   resolvePromptCacheTtl,
@@ -28,6 +34,7 @@ import {
 } from '@/common';
 import { safeDispatchCustomEvent, emitAgentLog } from '@/utils/events';
 import { attemptInvoke, tryFallbackProviders } from '@/llm/invoke';
+import { calculateMaxToolResultChars } from '@/utils/truncation';
 import { createRemoveAllMessage } from '@/messages/reducer';
 import { getMaxOutputTokensKey } from '@/llm/request';
 import { initializeModel } from '@/llm/init';
@@ -206,10 +213,10 @@ function extractToolFailuresSection(messages: BaseMessage[]): string {
     }
 
     const toolName = toolMsg.name ?? 'tool';
-    const content =
-      typeof toolMsg.content === 'string'
-        ? toolMsg.content
-        : JSON.stringify(toolMsg.content);
+    const content = serializeToolContentBounded(
+      toolMsg.content,
+      MAX_TOOL_FAILURE_CHARS * 4
+    );
     const normalized = content.replace(/\s+/g, ' ').trim();
     const summary =
       normalized.length > MAX_TOOL_FAILURE_CHARS
@@ -250,25 +257,45 @@ function enrichSummary(summaryText: string, messages: BaseMessage[]): string {
  */
 function restoreOriginalToolContent(
   messages: BaseMessage[],
-  originalToolContent: Map<number, string> | undefined
+  originalToolContent: Map<number, string> | undefined,
+  maxContextTokens?: number
 ): BaseMessage[] {
   if (originalToolContent == null || originalToolContent.size === 0) {
     return messages;
   }
-  const restored = [...messages];
-  for (const [idx, content] of originalToolContent) {
-    const msg = restored[idx];
-    if (msg instanceof ToolMessage) {
-      restored[idx] = new ToolMessage({
-        content,
-        tool_call_id: msg.tool_call_id,
-        name: msg.name,
-        id: msg.id,
-        additional_kwargs: msg.additional_kwargs,
-        response_metadata: msg.response_metadata,
-      });
+
+  const restorable: Array<{
+    index: number;
+    message: ToolMessage;
+    content: string;
+  }> = [];
+  for (const [index, content] of originalToolContent) {
+    const message = messages[index];
+    if (
+      message instanceof ToolMessage &&
+      !isComputerCallOutputMessage(message)
+    ) {
+      restorable.push({ index, message, content });
     }
   }
+  if (restorable.length === 0) {
+    return messages;
+  }
+
+  /**
+   * Restored originals improve checkpoint quality, but they still feed a
+   * provider call. Share one tool-result budget across every restoration so
+   * several previously masked results cannot overflow the summarizer.
+   */
+  let remainingChars = calculateMaxToolResultChars(maxContextTokens);
+  const restored = [...messages];
+  for (let i = 0; i < restorable.length; i++) {
+    const { index, message, content } = restorable[i];
+    const maxChars = Math.floor(remainingChars / (restorable.length - i));
+    const compacted = compactToolContent(content, maxChars).content;
+    restored[index] = cloneToolMessageWithContent(message, compacted);
+    remainingChars -= serializeToolContentBounded(compacted, maxChars).length;
+  }
   return restored;
 }
 
@@ -845,7 +872,8 @@ export function createSummarizeNode({
 
     const restoredMessages = restoreOriginalToolContent(
       state.messages,
-      originalPending
+      originalPending,
+      agentContext.maxContextTokens
     );
 
     const runnableConfig = config ?? graph.config;