@librechat/agents 3.2.2 → 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,52 +1,56 @@
 // src/run.ts
-import { initializeLangfuseTracing } 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',
@@ -552,9 +556,7 @@ export class Run<_T extends t.BaseGraphState> {
   }
 
   private shouldClearHookSession(streamThrew: boolean): boolean {
-    return (
-      this._interrupt == null || this._haltedReason != null || streamThrew
-    );
+    return this._interrupt == null || this._haltedReason != null || streamThrew;
   }
 
   private isAwaitingResume(streamThrew: boolean): boolean {
@@ -584,9 +586,7 @@ export class Run<_T extends t.BaseGraphState> {
   private getStreamToolOutputTracingLangfuseConfig(
     graph: StandardGraph | MultiAgentGraph
   ): t.LangfuseConfig | undefined {
-    const toolOutputTracingConfigs = Array.from(
-      graph.agentContexts.values()
-    )
+    const toolOutputTracingConfigs = Array.from(graph.agentContexts.values())
       .map((context) => {
         return resolveLangfuseConfig(this.langfuse, context.langfuse)
           ?.toolOutputTracing;
@@ -732,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({
@@ -742,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]);
     }
 
@@ -906,10 +907,30 @@ export class Run<_T extends t.BaseGraphState> {
     };
 
     try {
-      await withLangfuseToolOutputTracingConfig(
-        streamLangfuseConfig,
-        consumeStream,
-        this.getStreamToolOutputTracingLangfuseConfig(graph)
+      // When opted in, seed the root trace id from this run's id so feedback /
+      // other external signals can be attached to the trace later without a
+      // lookup (see SeededTraceIdGenerator in ./instrumentation).
+      await runWithTraceIdSeed(
+        streamLangfuseConfig?.deterministicTraceId === true
+          ? this.id
+          : undefined,
+        () =>
+          withLangfuseToolOutputTracingConfig(
+            streamLangfuseConfig,
+            () =>
+              withLangfuseAttributes(
+                {
+                  langfuse: streamLangfuseConfig,
+                  userId,
+                  sessionId,
+                  traceName,
+                  traceMetadata,
+                  tags: ['librechat', 'agent'],
+                },
+                consumeStream
+              ),
+            this.getStreamToolOutputTracingLangfuseConfig(graph)
+          )
       );
     } catch (err) {
       streamThrew = true;
@@ -1253,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
@@ -1264,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'],
       });
@@ -1354,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) {
@@ -1378,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/deterministic-trace-id.test.ts

@@ -0,0 +1,50 @@
+import { createHash } from 'node:crypto';
+import {
+  initializeLangfuseTracing,
+  runWithTraceIdSeed,
+} from '@/instrumentation';
+
+const langfuse = {
+  publicKey: 'pk-lf-test',
+  secretKey: 'sk-lf-test',
+  baseUrl: 'http://localhost:3999',
+};
+
+/** sha256(seed) → first 32 hex chars; what `@langfuse/tracing` `createTraceId` produces. */
+const expectedTraceId = (seed: string): string =>
+  createHash('sha256').update(seed, 'utf8').digest('hex').slice(0, 32);
+
+describe('deterministic Langfuse trace ids', () => {
+  it('derives the root trace id from the seed when run inside runWithTraceIdSeed', () => {
+    const provider = initializeLangfuseTracing(langfuse);
+    expect(provider).toBeDefined();
+    const tracer = provider!.getTracer('deterministic-trace-id-test');
+
+    const seed = 'response-message-id-1234';
+    let traceId: string | undefined;
+    runWithTraceIdSeed(seed, () => {
+      const span = tracer.startSpan('AgentRun');
+      traceId = span.spanContext().traceId;
+      span.end();
+    });
+
+    expect(traceId).toBe(expectedTraceId(seed));
+  });
+
+  it('falls back to a random trace id when no seed is active', () => {
+    const provider = initializeLangfuseTracing(langfuse);
+    const tracer = provider!.getTracer('deterministic-trace-id-test');
+
+    const span = tracer.startSpan('AgentRun');
+    const traceId = span.spanContext().traceId;
+    span.end();
+
+    expect(traceId).toMatch(/^[0-9a-f]{32}$/);
+    expect(traceId).not.toBe(expectedTraceId('response-message-id-1234'));
+  });
+
+  it('runWithTraceIdSeed is a passthrough when the seed is undefined', () => {
+    const sentinel = {};
+    expect(runWithTraceIdSeed(undefined, () => sentinel)).toBe(sentinel);
+  });
+});

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.';