@librechat/agents 3.2.21 → 3.2.31

package/src/messages/labelContentByAgent.test.ts

@@ -1,6 +1,6 @@
-import { ContentTypes } from '@/common';
-import { labelContentByAgent } from './format';
 import type { MessageContentComplex, ToolCallContent } from '@/types';
+import { labelContentByAgent } from './format';
+import { ContentTypes } from '@/common';
 
 /**
  * Type guard to check if content is ToolCallContent

package/src/messages/prune.ts

@@ -9,8 +9,8 @@ import type {
   MessageContentComplex,
   ReasoningContentText,
 } from '@/types/stream';
-import type { TokenCounter } from '@/types/run';
 import type { ContextPruningConfig } from '@/types/graph';
+import type { TokenCounter } from '@/types/run';
 import {
   calculateMaxToolResultChars,
   truncateToolResultContent,

package/src/messages/reducer.ts

@@ -1,10 +1,10 @@
+import { v4 } from 'uuid';
 import {
   BaseMessage,
   RemoveMessage,
   BaseMessageLike,
   coerceMessageLikeToMessage,
 } from '@langchain/core/messages';
-import { v4 } from 'uuid';
 
 export const REMOVE_ALL_MESSAGES = '__remove_all__';
 

package/src/messages/tools.ts

@@ -1,8 +1,8 @@
 // src/messages/toolDiscovery.ts
 import { AIMessageChunk, ToolMessage } from '@langchain/core/messages';
 import type { BaseMessage } from '@langchain/core/messages';
-import { Constants } from '@/common';
 import { findLastIndex } from './core';
+import { Constants } from '@/common';
 
 type ToolSearchArtifact = {
   tool_references?: Array<{ tool_name: string }>;

package/src/openai/__tests__/openai.test.ts

@@ -1,11 +1,11 @@
-import { GraphEvents } from '@/common';
+import type * as t from '@/types';
 import {
   createChatCompletionChunk,
   createOpenAIHandlers,
   createOpenAIStreamTracker,
   sendOpenAIFinalChunk,
 } from '@/openai';
-import type * as t from '@/types';
+import { GraphEvents } from '@/common';
 
 describe('OpenAI-compatible adapters', () => {
   it('creates chunks and streams message deltas as SSE data', async () => {

package/src/openai/index.ts

@@ -1,6 +1,6 @@
-import { GraphEvents } from '@/common';
 import type { UsageMetadata } from '@langchain/core/messages';
 import type * as t from '@/types';
+import { GraphEvents } from '@/common';
 
 export interface OpenAICompatibleWriter {
   write(data: string): void | Promise<void>;

package/src/responses/__tests__/responses.test.ts

@@ -1,11 +1,11 @@
-import { GraphEvents } from '@/common';
+import type * as t from '@/types';
 import {
   buildResponse,
   createResponseTracker,
   createResponsesEventHandlers,
   emitResponseCompleted,
 } from '@/responses';
-import type * as t from '@/types';
+import { GraphEvents } from '@/common';
 
 describe('Responses-compatible adapters', () => {
   it('streams semantic response events through a generic writer', async () => {

package/src/responses/index.ts

@@ -1,6 +1,6 @@
-import { GraphEvents } from '@/common';
 import type { UsageMetadata } from '@langchain/core/messages';
 import type * as t from '@/types';
+import { GraphEvents } from '@/common';
 
 export interface ResponsesCompatibleWriter {
   write(data: string): void | Promise<void>;

package/src/run.ts

@@ -1,55 +1,56 @@
 // src/run.ts
-import {
-  initializeLangfuseTracing,
-  runWithTraceIdSeed,
-} from './instrumentation';
+import { HumanMessage } from '@langchain/core/messages';
 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 {
   Command,
   INTERRUPT,
   MemorySaver,
   isInterrupted,
 } from '@langchain/langgraph';
-import { HumanMessage } from '@langchain/core/messages';
-import { BaseCallbackHandler } from '@langchain/core/callbacks/base';
 import type {
   MessageContentComplex,
   BaseMessage,
 } from '@langchain/core/messages';
 import type { StringPromptValue } from '@langchain/core/prompt_values';
 import type { RunnableConfig } from '@langchain/core/runnables';
+import type { HookRegistry } from '@/hooks';
 import type * as t from '@/types';
-import {
-  createCompletionTitleRunnable,
-  createTitleRunnable,
-} from '@/utils/title';
-import { createTokenCounter, encodingForModel } from '@/utils/tokens';
-import { GraphEvents, Callback, TitleMethod } from '@/common';
-import { MultiAgentGraph } from '@/graphs/MultiAgentGraph';
-import { StandardGraph } from '@/graphs/Graph';
-import { initializeModel } from '@/llm/init';
-import { HandlerRegistry } from '@/events';
-import { executeHooks } from '@/hooks';
-import { isOpenAILike } from '@/utils/llm';
-import {
-  appendCallbacks,
-  findCallback,
-  type CallbackEntry,
-} from '@/utils/callbacks';
 import {
   createLangfuseTraceMetadata,
   createLangfuseHandler,
   disposeLangfuseHandler,
   getLangfuseTraceName,
   isLangfuseCallbackHandler,
+  withLangfuseAttributes,
 } from '@/langfuse';
 import {
   resolveLangfuseConfig,
   withLangfuseToolOutputTracingConfig,
 } from '@/langfuseToolOutputTracing';
-import type { HookRegistry } from '@/hooks';
+import {
+  appendCallbacks,
+  findCallback,
+  type CallbackEntry,
+} from '@/utils/callbacks';
+import {
+  createCompletionTitleRunnable,
+  createTitleRunnable,
+} from '@/utils/title';
+import {
+  initializeLangfuseTracing,
+  runWithTraceIdSeed,
+} from './instrumentation';
+import { createTokenCounter, encodingForModel } from '@/utils/tokens';
+import { GraphEvents, Callback, TitleMethod } from '@/common';
+import { MultiAgentGraph } from '@/graphs/MultiAgentGraph';
+import { StandardGraph } from '@/graphs/Graph';
+import { initializeModel } from '@/llm/init';
+import { HandlerRegistry } from '@/events';
+import { isOpenAILike } from '@/utils/llm';
+import { executeHooks } from '@/hooks';
 
 export const defaultOmitOptions = new Set([
   'stream',
@@ -731,6 +732,7 @@ export class Run<_T extends t.BaseGraphState> {
       agentId: graph.defaultAgentId,
       agentName: primaryContext?.name,
     });
+    const traceName = config.runName ?? getLangfuseTraceName(traceMetadata);
     const streamLangfuseConfig = this.getStreamLangfuseConfig(graph);
     initializeLangfuseTracing(streamLangfuseConfig);
     const langfuseHandler = createLangfuseHandler({
@@ -741,7 +743,7 @@ export class Run<_T extends t.BaseGraphState> {
       tags: ['librechat', 'agent'],
     });
     if (langfuseHandler != null) {
-      config.runName = config.runName ?? getLangfuseTraceName(traceMetadata);
+      config.runName = traceName;
       config.callbacks = appendCallbacks(config.callbacks, [langfuseHandler]);
     }
 
@@ -915,7 +917,18 @@ export class Run<_T extends t.BaseGraphState> {
         () =>
           withLangfuseToolOutputTracingConfig(
             streamLangfuseConfig,
-            consumeStream,
+            () =>
+              withLangfuseAttributes(
+                {
+                  langfuse: streamLangfuseConfig,
+                  userId,
+                  sessionId,
+                  traceName,
+                  traceMetadata,
+                  tags: ['librechat', 'agent'],
+                },
+                consumeStream
+              ),
             this.getStreamToolOutputTracingLangfuseConfig(graph)
           )
       );
@@ -1261,6 +1274,9 @@ export class Run<_T extends t.BaseGraphState> {
     titlePromptTemplate,
   }: t.RunTitleOptions): Promise<{ language?: string; title?: string }> {
     let titleLangfuseHandler: CallbackEntry | undefined;
+    let titleLangfuseConfig: t.LangfuseConfig | undefined;
+    let titleUserId: string | undefined;
+    let titleSessionId: string | undefined;
     const titleContext =
       this.Graph == null
         ? undefined
@@ -1272,23 +1288,23 @@ export class Run<_T extends t.BaseGraphState> {
     const titleRunName = getLangfuseTraceName(traceMetadata, 'LibreChat Title');
 
     if (chainOptions != null) {
-      const userId =
+      titleUserId =
         typeof chainOptions.configurable?.user_id === 'string'
           ? chainOptions.configurable.user_id
           : undefined;
-      const sessionId =
+      titleSessionId =
         typeof chainOptions.configurable?.thread_id === 'string'
           ? chainOptions.configurable.thread_id
           : undefined;
-      const titleLangfuseConfig = resolveLangfuseConfig(
+      titleLangfuseConfig = resolveLangfuseConfig(
         this.langfuse,
         titleContext?.langfuse
       );
       initializeLangfuseTracing(titleLangfuseConfig);
       titleLangfuseHandler = createLangfuseHandler({
         langfuse: titleLangfuseConfig,
-        userId,
-        sessionId,
+        userId: titleUserId,
+        sessionId: titleSessionId,
         traceMetadata,
         tags: ['librechat', 'title'],
       });
@@ -1362,15 +1378,30 @@ export class Run<_T extends t.BaseGraphState> {
       runName: chainOptions?.runName ?? titleRunName,
     });
 
+    const invokeTitleChain = (
+      runtimeConfig: Partial<RunnableConfig>
+    ): Promise<{ language?: string; title?: string }> =>
+      withLangfuseAttributes(
+        {
+          langfuse: titleLangfuseConfig,
+          userId: titleUserId,
+          sessionId: titleSessionId,
+          traceName: runtimeConfig.runName ?? titleRunName,
+          traceMetadata,
+          tags: ['librechat', 'title'],
+        },
+        () =>
+          fullChain.invoke(
+            { input: inputText, output: response },
+            runtimeConfig
+          )
+      );
+
     try {
       try {
         return await withLangfuseToolOutputTracingConfig(
           this.langfuse,
-          () =>
-            fullChain.invoke(
-              { input: inputText, output: response },
-              invokeConfig
-            ),
+          () => invokeTitleChain(invokeConfig),
           titleContext?.langfuse
         );
       } catch (_e) {
@@ -1386,11 +1417,7 @@ export class Run<_T extends t.BaseGraphState> {
         });
         return await withLangfuseToolOutputTracingConfig(
           this.langfuse,
-          () =>
-            fullChain.invoke(
-              { input: inputText, output: response },
-              safeConfig as Partial<RunnableConfig>
-            ),
+          () => invokeTitleChain(safeConfig as Partial<RunnableConfig>),
           titleContext?.langfuse
         );
       }

package/src/session/AgentSession.ts

@@ -1,11 +1,10 @@
 import { MemorySaver } from '@langchain/langgraph';
 import { HumanMessage, BaseMessage } from '@langchain/core/messages';
-import type { RunnableConfig } from '@langchain/core/runnables';
 import type {
   BaseCheckpointSaver,
   CheckpointTuple,
 } from '@langchain/langgraph';
-import type { HookRegistry } from '@/hooks';
+import type { RunnableConfig } from '@langchain/core/runnables';
 import type {
   AgentSessionConfig,
   AgentSessionCheckpointing,
@@ -22,15 +21,16 @@ import type {
   SessionEntry,
   SessionForkOptions,
 } from './types';
+import type { HookRegistry } from '@/hooks';
 import type * as t from '@/types';
+import { deserializeMessage } from './messageSerialization';
+import { createSummarizeNode } from '@/summarization/node';
+import { JsonlSessionStore } from './JsonlSessionStore';
 import { AgentContext } from '@/agents/AgentContext';
 import { ContentTypes, GraphEvents } from '@/common';
-import { Run } from '@/run';
 import { createRunId, createSessionId } from './ids';
-import { deserializeMessage } from './messageSerialization';
-import { JsonlSessionStore } from './JsonlSessionStore';
 import { createRunHandlers } from './handlers';
-import { createSummarizeNode } from '@/summarization/node';
+import { Run } from '@/run';
 
 function isBaseMessage(value: unknown): value is BaseMessage {
   return (

package/src/session/JsonlSessionStore.ts

@@ -1,5 +1,6 @@
 import { homedir } from 'os';
 import { createHash } from 'crypto';
+import { SystemMessage } from '@langchain/core/messages';
 import { basename, dirname, isAbsolute, join, resolve } from 'path';
 import {
   access,
@@ -10,6 +11,7 @@ import {
   stat,
   writeFile,
 } from 'fs/promises';
+import type { BaseMessage } from '@langchain/core/messages';
 import type {
   CreateSessionFileOptions,
   SessionBranchOptions,
@@ -26,15 +28,13 @@ import type {
   SessionStateEntry,
   SessionTreeNode,
 } from './types';
-import type { BaseMessage } from '@langchain/core/messages';
-import { SystemMessage } from '@langchain/core/messages';
-import { createEntryId, createSessionId, createTimestamp } from './ids';
 import {
   deserializeMessage,
   getMessageRole,
   serializeMessage,
   toJsonValue,
 } from './messageSerialization';
+import { createEntryId, createSessionId, createTimestamp } from './ids';
 
 const SESSION_VERSION = 1;
 const DEFAULT_SESSION_ROOT = join(

package/src/session/__tests__/JsonlSessionStore.test.ts

@@ -1,19 +1,19 @@
-import { mkdtemp, readFile, rm, writeFile } from 'fs/promises';
-import { dirname, join } from 'path';
 import { tmpdir } from 'os';
+import { dirname, join } from 'path';
+import { MemorySaver } from '@langchain/langgraph';
+import { mkdtemp, readFile, rm, writeFile } from 'fs/promises';
 import {
   AIMessage,
   HumanMessage,
   RemoveMessage,
 } from '@langchain/core/messages';
-import { MemorySaver } from '@langchain/langgraph';
-import type { BaseMessage } from '@langchain/core/messages';
 import type { Checkpoint, CheckpointMetadata } from '@langchain/langgraph';
+import type { BaseMessage } from '@langchain/core/messages';
+import type * as t from '@/types';
 import { JsonlSessionStore, createAgentSession } from '@/session';
 import { toJsonValue } from '@/session/messageSerialization';
 import * as providers from '@/llm/providers';
 import { GraphEvents } from '@/common';
-import type * as t from '@/types';
 import { Run } from '@/run';
 
 type MockRun = {

package/src/session/__tests__/handlers.test.ts

@@ -1,8 +1,8 @@
+import type { AgentSessionStreamEvent } from '@/session';
+import type * as t from '@/types';
 import { ContentTypes, GraphEvents, StepTypes } from '@/common';
 import { composeEventHandlers } from '@/events';
 import { createRunHandlers } from '@/session';
-import type { AgentSessionStreamEvent } from '@/session';
-import type * as t from '@/types';
 
 describe('createRunHandlers', () => {
   it('emits live session events through the same graph handlers before user handlers', async () => {

package/src/session/handlers.ts

@@ -1,15 +1,15 @@
 import type { UsageMetadata } from '@langchain/core/messages';
-import { GraphEvents } from '@/common';
-import { ModelEndHandler, ToolEndHandler } from '@/events';
-import { createContentAggregator } from '@/stream';
-import type * as t from '@/types';
 import type {
   AgentSessionHandlersResult,
   AgentSessionStreamEvent,
   AgentSessionUsage,
 } from './types';
-import { createTimestamp } from './ids';
+import type * as t from '@/types';
+import { ModelEndHandler, ToolEndHandler } from '@/events';
 import { toJsonValue } from './messageSerialization';
+import { createContentAggregator } from '@/stream';
+import { createTimestamp } from './ids';
+import { GraphEvents } from '@/common';
 
 type CompletedRunStepResult =
   | t.ToolEndEvent

package/src/session/types.ts

@@ -1,6 +1,6 @@
 import type { RunnableConfig } from '@langchain/core/runnables';
-import type { BaseMessage } from '@langchain/core/messages';
 import type { BaseCheckpointSaver } from '@langchain/langgraph';
+import type { BaseMessage } from '@langchain/core/messages';
 import type * as t from '@/types';
 
 export type JsonPrimitive = string | number | boolean | null;

package/src/specs/agent-handoffs.test.ts

@@ -1,8 +1,8 @@
 // src/specs/agent-handoffs.test.ts
 import { DynamicStructuredTool } from '@langchain/core/tools';
 import { AIMessage, HumanMessage, ToolMessage } from '@langchain/core/messages';
-import type { ToolCall } from '@langchain/core/messages/tool';
 import type { RunnableConfig } from '@langchain/core/runnables';
+import type { ToolCall } from '@langchain/core/messages/tool';
 import type * as t from '@/types';
 import { Providers, GraphEvents, Constants } from '@/common';
 import { StandardGraph } from '@/graphs/Graph';

package/src/specs/langfuse-callbacks.test.ts

@@ -1,8 +1,8 @@
-import { CallbackManager } from '@langchain/core/callbacks/manager';
 import { HumanMessage } from '@langchain/core/messages';
+import { CallbackManager } from '@langchain/core/callbacks/manager';
+import type * as t from '@/types';
 import { Providers } from '@/common';
 import { Run } from '@/run';
-import type * as t from '@/types';
 
 const mockSpan = {
   end: jest.fn(),

package/src/specs/langfuse-metadata.test.ts

@@ -1,4 +1,5 @@
 import { CallbackHandler } from '@langfuse/langchain';
+import { propagateAttributes } from '@langfuse/tracing';
 import { Providers } from '@/common';
 import { Run } from '@/run';
 
@@ -6,9 +7,17 @@ jest.mock('@langfuse/langchain', () => ({
   CallbackHandler: jest.fn().mockImplementation(() => ({})),
 }));
 
+jest.mock('@langfuse/tracing', () => ({
+  ...jest.requireActual('@langfuse/tracing'),
+  propagateAttributes: jest.fn((_params, action: () => unknown) => action()),
+}));
+
 const MockedCallbackHandler = CallbackHandler as jest.MockedClass<
   typeof CallbackHandler
 >;
+const MockedPropagateAttributes = propagateAttributes as jest.MockedFunction<
+  typeof propagateAttributes
+>;
 
 async function createTestRun(
   agentName?: string,
@@ -70,6 +79,35 @@ describe('Langfuse trace metadata includes agentName', () => {
     expect(ctorArgs?.traceMetadata).toMatchObject({ agentName: 'DWAINE' });
   });
 
+  it('propagates Langfuse identity around processStream observations', async () => {
+    const run = await createTestRun('DWAINE');
+    await run.processStream(
+      { messages: [] },
+      {
+        configurable: {
+          thread_id: 'thread-123',
+          user_id: 'user-456',
+          requestBody: { parentMessageId: 'parent-789' },
+        },
+        version: 'v2',
+      }
+    );
+
+    expect(MockedPropagateAttributes).toHaveBeenCalledTimes(1);
+    expect(MockedPropagateAttributes.mock.calls[0][0]).toMatchObject({
+      userId: 'user-456',
+      sessionId: 'thread-123',
+      traceName: 'LibreChat Agent: DWAINE',
+      tags: ['librechat', 'agent'],
+      metadata: {
+        messageId: 'test-run-id',
+        parentMessageId: 'parent-789',
+        agentId: 'agent_abc123',
+        agentName: 'DWAINE',
+      },
+    });
+  });
+
   it('falls back to agentId when agent has no explicit name', async () => {
     const run = await createTestRun();
     await run.processStream(
@@ -93,6 +131,7 @@ describe('Langfuse trace metadata includes agentName', () => {
     );
 
     expect(MockedCallbackHandler).not.toHaveBeenCalled();
+    expect(MockedPropagateAttributes).not.toHaveBeenCalled();
   });
 
   it('does not create the legacy CallbackHandler when explicit agent config is supplied', async () => {

package/src/specs/langfuse-tool-output-tracing.test.ts

@@ -1,5 +1,5 @@
-import { AIMessage, ToolMessage, HumanMessage } from '@langchain/core/messages';
 import { LangfuseOtelSpanAttributes } from '@langfuse/tracing';
+import { AIMessage, ToolMessage, HumanMessage } from '@langchain/core/messages';
 import type { ReadableSpan } from '@opentelemetry/sdk-trace-base';
 import type { BaseMessage } from '@langchain/core/messages';
 import type { TPayload } from '@/types';

package/src/specs/multi-agent-summarization.test.ts

@@ -9,21 +9,21 @@
  *
  * Uses FakeListChatModel — no API keys required.
  */
+import { FakeListChatModel } from '@langchain/core/utils/testing';
 import {
   HumanMessage,
   AIMessage,
   BaseMessage,
   UsageMetadata,
 } from '@langchain/core/messages';
-import { FakeListChatModel } from '@langchain/core/utils/testing';
 import type * as t from '@/types';
 import { ToolEndHandler, ModelEndHandler } from '@/events';
-import { GraphEvents, Providers } from '@/common';
-import { createContentAggregator } from '@/stream';
 import { createTokenCounter } from '@/utils/tokens';
+import { createContentAggregator } from '@/stream';
+import { GraphEvents, Providers } from '@/common';
 import { getLLMConfig } from '@/utils/llmConfig';
-import { Run } from '@/run';
 import * as providers from '@/llm/providers';
+import { Run } from '@/run';
 
 function getSummaryText(summary: t.SummaryContentBlock | undefined): string {
   if (!summary) return '';

package/src/specs/subagent.test.ts

@@ -1,9 +1,8 @@
-import { AIMessage, HumanMessage } from '@langchain/core/messages';
 import { FakeListChatModel } from '@langchain/core/utils/testing';
-import type { ToolCall } from '@langchain/core/messages/tool';
+import { AIMessage, HumanMessage } from '@langchain/core/messages';
 import type { RunnableConfig } from '@langchain/core/runnables';
+import type { ToolCall } from '@langchain/core/messages/tool';
 import type * as t from '@/types';
-import { Run } from '@/run';
 import {
   Constants,
   GraphEvents,
@@ -13,6 +12,7 @@ import {
   StandardGraph,
 } from '@/index';
 import * as providers from '@/llm/providers';
+import { Run } from '@/run';
 
 const CHILD_RESPONSE = 'Research result: Paris is the capital of France.';
 

package/src/specs/summarization-unit.test.ts

@@ -12,8 +12,8 @@ import {
   createPruneMessages,
 } from '@/messages/prune';
 import { shouldTriggerSummarization } from '@/summarization/index';
-import { Providers } from '@/common';
 import { SummarizationTrigger } from '@/types';
+import { Providers } from '@/common';
 
 // ---------------------------------------------------------------------------
 // Shared helpers

package/src/specs/thinking-handoff.test.ts

@@ -1,7 +1,7 @@
 // src/specs/thinking-handoff.test.ts
 import { HumanMessage, ToolMessage } from '@langchain/core/messages';
-import type { ToolCall } from '@langchain/core/messages/tool';
 import type { RunnableConfig } from '@langchain/core/runnables';
+import type { ToolCall } from '@langchain/core/messages/tool';
 import type * as t from '@/types';
 import { Providers, Constants } from '@/common';
 import { StandardGraph } from '@/graphs/Graph';

package/src/splitStream.test.ts

@@ -225,6 +225,54 @@ describe('ContentAggregator empty deltas', () => {
   });
 });
 
+describe('ContentAggregator provider-specific parts', () => {
+  it('should preserve Gemini server-side tool content blocks', () => {
+    const { contentParts, aggregateContent } = createContentAggregator();
+    const toolCallPart: t.MessageContentComplex = {
+      type: 'toolCall',
+      toolCall: {
+        id: 'server-search-1',
+        name: 'google_search',
+        args: {},
+      },
+    };
+    const toolResponsePart: t.MessageContentComplex = {
+      type: 'toolResponse',
+      toolResponse: {
+        id: 'server-search-1',
+        name: 'google_search',
+        response: { results: [] },
+      },
+    };
+
+    aggregateContent({
+      event: GraphEvents.ON_RUN_STEP,
+      data: createRunStep('step_tool_call'),
+    });
+    aggregateContent({
+      event: GraphEvents.ON_MESSAGE_DELTA,
+      data: {
+        id: 'step_tool_call',
+        delta: { content: [toolCallPart] },
+      },
+    });
+    aggregateContent({
+      event: GraphEvents.ON_RUN_STEP,
+      data: { ...createRunStep('step_tool_response'), index: 1 },
+    });
+    aggregateContent({
+      event: GraphEvents.ON_MESSAGE_DELTA,
+      data: {
+        id: 'step_tool_response',
+        delta: { content: [toolResponsePart] },
+      },
+    });
+
+    expect(contentParts[0]).toEqual(toolCallPart);
+    expect(contentParts[1]).toEqual(toolResponsePart);
+  });
+});
+
 describe('ContentAggregator with SplitStreamHandler', () => {
   it('should aggregate content from multiple message blocks', async () => {
     const runId = nanoid();