@librechat/agents 1.4.2 → 1.4.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@librechat/agents",
-  "version": "1.4.2",
+  "version": "1.4.4",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/esm/main.mjs",
   "types": "./dist/types/index.d.ts",
@@ -39,7 +39,9 @@
     "clean": "node ./config/clean.js",
     "script": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/cli.ts",
     "bun:cli": "bun -r dotenv/config ./src/scripts/cli.ts --provider 'bedrock' --name 'Jo' --location 'New York, NY'",
-    "start:cli": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/cli.ts --provider 'anthropic' --name 'Jo' --location 'New York, NY'",
+    "start:cli": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/cli.ts --provider 'openAI' --name 'Jo' --location 'New York, NY'",
+    "content": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/content.ts --provider 'bedrock' --name 'Jo' --location 'New York, NY'",
+    "abort": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/abort.ts --provider 'bedrock' --name 'Jo' --location 'New York, NY'",
     "start:cli2": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/cli2.ts --provider 'anthropic' --name 'Jo' --location 'New York, NY'",
     "script2": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/proto/example_test.ts",
     "script3": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/proto/example_test_anthropic.ts",
@@ -61,10 +63,10 @@
     "@aws-crypto/sha256-js": "^5.2.0",
     "@aws-sdk/credential-provider-node": "^3.613.0",
     "@aws-sdk/types": "^3.609.0",
-    "@langchain/anthropic": "^0.2.14",
-    "@langchain/aws": "^0.0.6",
+    "@langchain/anthropic": "^0.2.15",
+    "@langchain/aws": "^0.0.10",
     "@langchain/community": "^0.2.20",
-    "@langchain/core": "^0.2.18",
+    "@langchain/core": "^0.2.31",
     "@langchain/google-vertexai": "^0.0.20",
     "@langchain/langgraph": "^0.0.31",
     "@langchain/mistralai": "^0.0.26",
@@ -74,10 +76,9 @@
     "@smithy/util-utf8": "^2.0.0",
     "dotenv": "^16.4.5",
     "langchain": "^0.2.10",
-    "nanoid": "^3.3.4"
+    "nanoid": "^3.3.7"
   },
   "resolutions": {
-    "@langchain/core": "0.2.18",
     "@smithy/eventstream-codec": "^2.2.0",
     "@smithy/protocol-http": "^3.0.6",
     "@smithy/signature-v4": "^2.0.10",

package/src/common/enum.ts

@@ -97,6 +97,23 @@ export enum StepTypes {
   MESSAGE_CREATION = 'message_creation'
 }
 
+export enum ContentTypes {
+  TEXT = 'text',
+  TOOL_CALL = 'tool_call',
+  IMAGE_FILE = 'image_file',
+  IMAGE_URL = 'image_url',
+  ERROR = 'error',
+}
+
+export enum ToolCallTypes {
+  FUNCTION = 'function',
+  RETRIEVAL = 'retrieval',
+  FILE_SEARCH = 'file_search',
+  CODE_INTERPRETER = 'code_interpreter',
+  /* Agents Tool Call */
+  TOOL_CALL = 'tool_call',
+}
+
 export enum Callback {
   TOOL_ERROR = 'handleToolError',
   TOOL_START = 'handleToolStart',

package/src/graphs/Graph.ts

@@ -85,7 +85,7 @@ export class StandardGraph extends Graph<
     provider,
     clientOptions,
     instructions,
-    additional_instructions,
+    additional_instructions = '',
   } : {
     runId?: string;
     provider: Providers;
@@ -104,7 +104,7 @@ export class StandardGraph extends Graph<
     this.graphState = this.createGraphState();
     this.boundModel = this.initializeModel();
 
-    let finalInstructions = instructions;
+    let finalInstructions = instructions ?? '';
     if (additional_instructions) {
       finalInstructions = finalInstructions ? `${finalInstructions}\n\n${additional_instructions}` : additional_instructions;
     }
@@ -244,7 +244,7 @@ export class StandardGraph extends Graph<
 
   createCallModel() {
     return async (state: t.BaseGraphState, config?: RunnableConfig): Promise<Partial<t.BaseGraphState>> => {
-      const { provider } = (config?.configurable as t.GraphConfig) ?? {} ;
+      const { provider } = (config?.configurable as t.GraphConfig | undefined) ?? {} ;
       if (!config || !provider) {
         throw new Error(`No ${config ? 'provider' : 'config'} provided`);
       }

package/src/run.ts

@@ -90,7 +90,8 @@ export class Run<T extends t.BaseGraphState> {
       const { data, name, metadata, ...info } = event;
 
       let eventName: t.EventName = info.event;
-      if (hasTools && provider === Providers.ANTHROPIC && eventName === GraphEvents.CHAT_MODEL_STREAM) {
+      const isDoubleCallProvider = provider === Providers.ANTHROPIC || provider === Providers.BEDROCK;
+      if (hasTools && isDoubleCallProvider && eventName === GraphEvents.CHAT_MODEL_STREAM) {
         /* Skipping CHAT_MODEL_STREAM event for Anthropic due to double-call edge case */
         continue;
       }

package/src/scripts/abort.ts

@@ -0,0 +1,136 @@
+/* eslint-disable no-console */
+// src/scripts/cli.ts
+import { config } from 'dotenv';
+config();
+import { HumanMessage, BaseMessage } from '@langchain/core/messages';
+import { TavilySearchResults } from '@langchain/community/tools/tavily_search';
+import type * as t from '@/types';
+import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
+import { ToolEndHandler } from '@/events';
+
+import { getArgs } from '@/scripts/args';
+import { Run } from '@/run';
+import { GraphEvents, Callback } from '@/common';
+import { getLLMConfig } from '@/utils/llmConfig';
+
+const conversationHistory: BaseMessage[] = [];
+
+async function testStandardStreaming(): Promise<void> {
+  const { userName, location, provider, currentDate } = await getArgs();
+  const { contentParts, aggregateContent } = createContentAggregator();
+  const controller = new AbortController();
+
+  const customHandlers = {
+    [GraphEvents.TOOL_END]: new ToolEndHandler(),
+    [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
+    [GraphEvents.ON_RUN_STEP_COMPLETED]: {
+      handle: (event: GraphEvents.ON_RUN_STEP_COMPLETED, data: t.StreamEventData): void => {
+        console.log('====== ON_RUN_STEP_COMPLETED ======');
+        aggregateContent({ event, data: data as unknown as { result: t.ToolEndEvent } });
+      }
+    },
+    [GraphEvents.ON_RUN_STEP]: {
+      handle: (event: GraphEvents.ON_RUN_STEP, data: t.StreamEventData): void => {
+        console.log('====== ON_RUN_STEP ======');
+        console.dir(data, { depth: null });
+        aggregateContent({ event, data: data as t.RunStep });
+      }
+    },
+    [GraphEvents.ON_RUN_STEP_DELTA]: {
+      handle: (event: GraphEvents.ON_RUN_STEP_DELTA, data: t.StreamEventData): void => {
+        console.log('====== ON_RUN_STEP_DELTA ======');
+        console.dir(data, { depth: null });
+        aggregateContent({ event, data: data as t.RunStepDeltaEvent });
+      }
+    },
+    [GraphEvents.ON_MESSAGE_DELTA]: {
+      handle: (event: GraphEvents.ON_MESSAGE_DELTA, data: t.StreamEventData): void => {
+        console.log('====== ON_MESSAGE_DELTA ======');
+        console.dir(data, { depth: null });
+        aggregateContent({ event, data: data as t.MessageDeltaEvent });
+      }
+    },
+    [GraphEvents.TOOL_START]: {
+      handle: (_event: string, data: t.StreamEventData, metadata?: Record<string, unknown>): void => {
+        console.log('====== TOOL_START ======');
+      }
+    },
+  };
+
+  const llmConfig = getLLMConfig(provider);
+
+  const run = await Run.create<t.IState>({
+    graphConfig: {
+      type: 'standard',
+      llmConfig,
+      tools: [new TavilySearchResults()],
+      instructions: 'You are a friendly AI assistant. Always address the user by their name.',
+      additional_instructions: `The user's name is ${userName} and they are located in ${location}.`,
+    },
+    customHandlers,
+  });
+
+  const config = {
+    configurable: {
+      provider,
+      thread_id: 'conversation-num-1',
+    },
+    signal: controller.signal,
+    streamMode: 'values',
+    version: 'v2' as const,
+  };
+
+  console.log('Test 1: Weather query (content parts test)');
+
+  const userMessage = `
+  Make a search for the weather in ${location} today, which is ${currentDate}.
+  Make sure to always refer to me by name, which is ${userName}.
+  After giving me a thorough summary, tell me a joke about the weather forecast we went over.
+  `;
+
+  conversationHistory.push(new HumanMessage(userMessage));
+
+  const inputs = {
+    messages: conversationHistory,
+  };
+
+  // Set a timeout to abort the operation after 5 seconds
+  setTimeout(() => {
+    controller.abort();
+    console.log('Operation aborted');
+    console.log('Current content parts:');
+    console.dir(contentParts, { depth: null });
+  }, 8000);
+
+  try {
+    const finalContentParts = await run.processStream(inputs, config);
+    const finalMessages = run.getRunMessages();
+    if (finalMessages) {
+      conversationHistory.push(...finalMessages);
+      console.dir(conversationHistory, { depth: null });
+    }
+    console.dir(finalContentParts, { depth: null });
+  } catch (error) {
+    if ((error as Error)?.name === 'AbortError') {
+      console.log('Operation was aborted');
+    } else {
+      console.error('An error occurred:', error);
+    }
+  }
+
+  console.log('\n\n====================\n\n');
+  console.dir(contentParts, { depth: null });
+}
+
+process.on('unhandledRejection', (reason, promise) => {
+  console.error('Unhandled Rejection at:', promise, 'reason:', reason);
+  console.log('Conversation history:');
+  process.exit(1);
+});
+
+testStandardStreaming().catch((err) => {
+  console.error(err);
+  console.log('Conversation history:');
+  console.dir(conversationHistory, { depth: null });
+  process.exit(1);
+});

package/src/scripts/content.ts

@@ -0,0 +1,118 @@
+/* eslint-disable no-console */
+// src/scripts/cli.ts
+import { config } from 'dotenv';
+config();
+import { HumanMessage, BaseMessage } from '@langchain/core/messages';
+import { TavilySearchResults } from '@langchain/community/tools/tavily_search';
+import type * as t from '@/types';
+import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
+import { ToolEndHandler } from '@/events';
+
+
+import { getArgs } from '@/scripts/args';
+import { Run } from '@/run';
+import { GraphEvents, Callback } from '@/common';
+import { getLLMConfig } from '@/utils/llmConfig';
+
+const conversationHistory: BaseMessage[] = [];
+async function testStandardStreaming(): Promise<void> {
+  const { userName, location, provider, currentDate } = await getArgs();
+  const { contentParts, aggregateContent } = createContentAggregator();
+  const customHandlers = {
+    [GraphEvents.TOOL_END]: new ToolEndHandler(),
+    // [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(),
+    [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
+    [GraphEvents.ON_RUN_STEP_COMPLETED]: {
+      handle: (event: GraphEvents.ON_RUN_STEP_COMPLETED, data: t.StreamEventData): void => {
+        console.log('====== ON_RUN_STEP_COMPLETED ======');
+        // console.dir(data, { depth: null });
+        aggregateContent({ event, data: data as unknown as { result: t.ToolEndEvent } });
+      }
+    },
+    [GraphEvents.ON_RUN_STEP]: {
+      handle: (event: GraphEvents.ON_RUN_STEP, data: t.StreamEventData): void => {
+        console.log('====== ON_RUN_STEP ======');
+        console.dir(data, { depth: null });
+        aggregateContent({ event, data: data as t.RunStep });
+      }
+    },
+    [GraphEvents.ON_RUN_STEP_DELTA]: {
+      handle: (event: GraphEvents.ON_RUN_STEP_DELTA, data: t.StreamEventData): void => {
+        console.log('====== ON_RUN_STEP_DELTA ======');
+        console.dir(data, { depth: null });
+        aggregateContent({ event, data: data as t.RunStepDeltaEvent });
+      }
+    },
+    [GraphEvents.ON_MESSAGE_DELTA]: {
+      handle: (event: GraphEvents.ON_MESSAGE_DELTA, data: t.StreamEventData): void => {
+        console.log('====== ON_MESSAGE_DELTA ======');
+        console.dir(data, { depth: null });
+        aggregateContent({ event, data: data as t.MessageDeltaEvent });
+      }
+    },
+    [GraphEvents.TOOL_START]: {
+      handle: (_event: string, data: t.StreamEventData, metadata?: Record<string, unknown>): void => {
+        console.log('====== TOOL_START ======');
+        // console.dir(data, { depth: null });
+      }
+    },
+  };
+
+  const llmConfig = getLLMConfig(provider);
+
+  const run = await Run.create<t.IState>({
+    graphConfig: {
+      type: 'standard',
+      llmConfig,
+      tools: [new TavilySearchResults()],
+      instructions: 'You are a friendly AI assistant. Always address the user by their name.',
+      additional_instructions: `The user's name is ${userName} and they are located in ${location}.`,
+    },
+    customHandlers,
+  });
+
+  const config = {
+    configurable: {
+      provider,
+      thread_id: 'conversation-num-1',
+    },
+    streamMode: 'values',
+    version: 'v2' as const,
+  };
+
+  console.log('Test 1: Weather query (content parts test)');
+
+  const userMessage = `
+  Make a search for the weather in ${location} today, which is ${currentDate}.
+  Make sure to always refer to me by name, which is ${userName}.
+  After giving me a thorough summary, tell me a joke about the weather forecast we went over.
+  `;
+
+  conversationHistory.push(new HumanMessage(userMessage));
+
+  const inputs = {
+    messages: conversationHistory,
+  };
+  const finalContentParts = await run.processStream(inputs, config);
+  const finalMessages = run.getRunMessages();
+  if (finalMessages) {
+    conversationHistory.push(...finalMessages);
+    console.dir(conversationHistory, { depth: null });
+  }
+  console.dir(finalContentParts, { depth: null });
+  console.log('\n\n====================\n\n');
+  console.dir(contentParts, { depth: null });
+}
+
+process.on('unhandledRejection', (reason, promise) => {
+  console.error('Unhandled Rejection at:', promise, 'reason:', reason);
+  console.log('Conversation history:');
+  process.exit(1);
+});
+
+testStandardStreaming().catch((err) => {
+  console.error(err);
+  console.log('Conversation history:');
+  console.dir(conversationHistory, { depth: null });
+  process.exit(1);
+});

package/src/stream.ts

@@ -4,16 +4,25 @@ import type { AIMessageChunk } from '@langchain/core/messages';
 import type { ToolCall } from '@langchain/core/messages/tool';
 import type { Graph } from '@/graphs';
 import type * as t from '@/types';
-import { StepTypes } from '@/common';
+import { StepTypes, ContentTypes, GraphEvents, ToolCallTypes } from '@/common';
+
+function getNonEmptyValue(possibleValues: string[]): string | undefined {
+  for (const value of possibleValues) {
+    if (value && value.trim() !== '') {
+      return value;
+    }
+  }
+  return undefined;
+}
 
 const getMessageId = (stepKey: string, graph: Graph<t.BaseGraphState>): string | undefined => {
   const messageId = graph.messageIdsByStepKey.get(stepKey);
-  if (messageId) {
+  if (messageId != null && messageId) {
     return;
   }
 
   const prelimMessageId = graph.prelimMessageIdsByStepKey.get(stepKey);
-  if (prelimMessageId) {
+  if (prelimMessageId != null && prelimMessageId) {
     graph.prelimMessageIdsByStepKey.delete(stepKey);
     graph.messageIdsByStepKey.set(stepKey, prelimMessageId);
     return prelimMessageId;
@@ -31,7 +40,7 @@ export class ChatModelStreamHandler implements t.EventHandler {
     }
 
     const chunk = data.chunk as AIMessageChunk;
-    const content = chunk?.content;
+    const content = chunk.content;
 
     if (!graph.config) {
       throw new Error('Config not found in graph');
@@ -42,8 +51,8 @@ export class ChatModelStreamHandler implements t.EventHandler {
       return;
     }
 
-    const hasToolCalls = chunk.tool_calls && chunk.tool_calls.length > 0;
-    const hasToolCallChunks = chunk.tool_call_chunks && chunk.tool_call_chunks.length > 0;
+    const hasToolCalls = (chunk.tool_calls && chunk.tool_calls.length > 0) ?? false;
+    const hasToolCallChunks = (chunk.tool_call_chunks && chunk.tool_call_chunks.length > 0) ?? false;
 
     if (hasToolCalls && chunk.tool_calls?.every((tc) => tc.id)) {
       const tool_calls: ToolCall[] = [];
@@ -64,7 +73,7 @@ export class ChatModelStreamHandler implements t.EventHandler {
 
     const isEmptyContent = !content || !content.length;
     const isEmptyChunk = isEmptyContent && !hasToolCallChunks;
-    if (isEmptyChunk && chunk.id && chunk.id?.startsWith('msg')) {
+    if (isEmptyChunk && chunk.id && chunk.id.startsWith('msg')) {
       if (graph.messageIdsByStepKey.has(chunk.id)) {
         return;
       } else if (graph.prelimMessageIdsByStepKey.has(chunk.id)) {
@@ -92,7 +101,7 @@ export class ChatModelStreamHandler implements t.EventHandler {
       return;
     }
 
-    const message_id = getMessageId(stepKey, graph);
+    const message_id = getMessageId(stepKey, graph) ?? '';
     if (message_id) {
       graph.dispatchRunStep(stepKey, {
         type: StepTypes.MESSAGE_CREATION,
@@ -127,7 +136,7 @@ hasToolCallChunks: ${hasToolCallChunks}
     /* Note: tool call chunks may have non-empty content that matches the current tool chunk generation */
     if (typeof content === 'string' && runStep.type === StepTypes.TOOL_CALLS) {
       return;
-    } else if (hasToolCallChunks && chunk.tool_call_chunks?.some((tc) => tc.args === content)) {
+    } else if (hasToolCallChunks && (chunk.tool_call_chunks?.some((tc) => tc.args === content) ?? false)) {
       return;
     } else if (typeof content === 'string') {
       graph.dispatchMessageDelta(stepId, {
@@ -136,10 +145,169 @@ hasToolCallChunks: ${hasToolCallChunks}
           text: content,
         }],
       });
-    } else if (content?.every((c) => c.type?.startsWith('text'))) {
+    } else if (content.every((c) => c.type?.startsWith('text'))) {
       graph.dispatchMessageDelta(stepId, {
         content,
       });
     }
   }
-}
+}
+
+export type ContentAggregatorResult = {
+  contentParts: Array<t.MessageContentComplex | undefined>;
+  aggregateContent: ({ event, data }: {
+    event: GraphEvents;
+    data: t.RunStep | t.MessageDeltaEvent | t.RunStepDeltaEvent | {
+        result: t.ToolEndEvent;
+    };
+}) => void
+};
+
+export function createContentAggregator(): ContentAggregatorResult {
+  const contentParts: Array<t.MessageContentComplex | undefined> = [];
+  const stepMap = new Map<string, t.RunStep>();
+  const toolCallIdMap = new Map<string, string>();
+
+  const updateContent = (
+    index: number,
+    contentPart: t.MessageContentComplex,
+    finalUpdate = false,
+  ): void => {
+    const partType = contentPart.type ?? '';
+    if (!partType) {
+      console.warn('No content type found in content part');
+      return;
+    }
+
+    if (!contentParts[index]) {
+      contentParts[index] = { type: partType };
+    }
+
+    if (
+      partType.startsWith(ContentTypes.TEXT) &&
+      ContentTypes.TEXT in contentPart &&
+      typeof contentPart.text === 'string'
+    ) {
+      const currentContent = contentParts[index] as { type: ContentTypes.TEXT; text: string };
+      contentParts[index] = {
+        type: ContentTypes.TEXT,
+        text: (currentContent.text || '') + contentPart.text,
+      };
+    } else if (partType === ContentTypes.IMAGE_URL && 'image_url' in contentPart) {
+      const currentContent = contentParts[index] as { type: 'image_url'; image_url: string };
+      contentParts[index] = {
+        ...currentContent,
+      };
+    } else if (partType === ContentTypes.TOOL_CALL && 'tool_call' in contentPart) {
+      const existingContent = contentParts[index] as Omit<t.ToolCallContent, 'tool_call'> & { tool_call?: ToolCall } | undefined;
+
+      const args = finalUpdate
+        ? contentPart.tool_call.args
+        : (existingContent?.tool_call?.args || '') + (contentPart.tool_call.args ?? '');
+
+      const id = getNonEmptyValue([contentPart.tool_call.id, existingContent?.tool_call?.id]) ?? '';
+      const name =
+        getNonEmptyValue([contentPart.tool_call.name, existingContent?.tool_call?.name]) ?? '';
+
+      const newToolCall: ToolCall & t.PartMetadata = {
+        id,
+        name,
+        args,
+        type: ToolCallTypes.TOOL_CALL,
+      };
+
+      if (finalUpdate) {
+        newToolCall.progress = 1;
+        newToolCall.output = contentPart.tool_call.output;
+      }
+
+      contentParts[index] = {
+        type: ContentTypes.TOOL_CALL,
+        tool_call: newToolCall,
+      };
+    }
+  };
+
+  const aggregateContent = ({ event, data }: {
+    event: GraphEvents;
+    data: t.RunStep | t.MessageDeltaEvent | t.RunStepDeltaEvent | { result: t.ToolEndEvent };
+  }): void => {
+
+    if (event === GraphEvents.ON_RUN_STEP) {
+      const runStep = data as t.RunStep;
+      stepMap.set(runStep.id, runStep);
+
+      // Store tool call IDs if present
+      if (runStep.stepDetails.type === StepTypes.TOOL_CALLS) {
+        runStep.stepDetails.tool_calls.forEach((toolCall) => {
+          const toolCallId = toolCall.id ?? '';
+          if ('id' in toolCall && toolCallId) {
+            toolCallIdMap.set(runStep.id, toolCallId);
+          }
+        });
+      }
+    } else if (event === GraphEvents.ON_MESSAGE_DELTA) {
+      const messageDelta = data as t.MessageDeltaEvent;
+      const runStep = stepMap.get(messageDelta.id);
+      if (!runStep) {
+        console.warn('No run step or runId found for message delta event');
+        return;
+      }
+
+      if (messageDelta.delta.content) {
+        const contentPart = Array.isArray(messageDelta.delta.content)
+          ? messageDelta.delta.content[0]
+          : messageDelta.delta.content;
+
+        updateContent(runStep.index, contentPart);
+      }
+    } else if (event === GraphEvents.ON_RUN_STEP_DELTA) {
+      const runStepDelta = data as t.RunStepDeltaEvent;
+      const runStep = stepMap.get(runStepDelta.id);
+      if (!runStep) {
+        console.warn('No run step or runId found for run step delta event');
+        return;
+      }
+
+      if (
+        runStepDelta.delta.type === StepTypes.TOOL_CALLS &&
+        runStepDelta.delta.tool_calls
+      ) {
+
+        runStepDelta.delta.tool_calls.forEach((toolCallDelta) => {
+          const toolCallId = toolCallIdMap.get(runStepDelta.id) ?? '';
+
+          const contentPart: t.MessageContentComplex = {
+            type: ContentTypes.TOOL_CALL,
+            tool_call: {
+              name: toolCallDelta.name ?? '',
+              args: toolCallDelta.args ?? '',
+              id: toolCallId,
+            },
+          };
+
+          updateContent(runStep.index, contentPart);
+        });
+      }
+    } else if (event === GraphEvents.ON_RUN_STEP_COMPLETED) {
+      const { result } = data as unknown as { result: t.ToolEndEvent };
+
+      const { id: stepId } = result;
+
+      const runStep = stepMap.get(stepId);
+      if (!runStep) {
+        console.warn('No run step or runId found for completed tool call event');
+        return;
+      }
+
+      const contentPart: t.MessageContentComplex = {
+        type: ContentTypes.TOOL_CALL,
+        tool_call: result.tool_call,
+      };
+
+      updateContent(runStep.index, contentPart, true);
+    }
+  };
+
+  return { contentParts, aggregateContent };
+}

package/src/types/graph.ts

@@ -123,4 +123,12 @@ export type StreamEvent = {
 export type GraphConfig = {
     provider: string;
     thread_id?: string;
+};
+
+export type PartMetadata = {
+  progress?: number;
+  asset_pointer?: string;
+  status?: string;
+  action?: boolean;
+  output?: string;
 };

package/src/types/stream.ts

@@ -112,8 +112,8 @@ export type ToolCallsDetails = {
 };
 
 export type ToolCallDelta = {
-  type: StepTypes.TOOL_CALLS;
-  tool_calls: ToolCallChunk[]; // #new
+  type: StepTypes;
+  tool_calls?: ToolCallChunk[]; // #new
 };
 
 export type AgentToolCall = {

package/src/types/tools.ts

@@ -2,6 +2,7 @@
 import type { RunnableToolLike } from '@langchain/core/runnables';
 import type { StructuredToolInterface } from '@langchain/core/tools';
 import type { ToolCall } from '@langchain/core/messages/tool';
+import { ContentTypes } from '@/common';
 
 /** Replacement type for `import type { ToolCall } from '@langchain/core/messages/tool'` in order to have stringified args typed */
 export type CustomToolCall = {
@@ -10,6 +11,7 @@ export type CustomToolCall = {
   args: string | Record<string, any>;
   id?: string;
   type?: 'tool_call';
+  output?: string;
 }
 
 export type GenericTool = StructuredToolInterface | RunnableToolLike;
@@ -28,4 +30,18 @@ export type ToolNodeOptions = {
   loadRuntimeTools?: ToolRefGenerator;
 };
 
-export type ToolNodeConstructorParams = ToolRefs & ToolNodeOptions;
+export type ToolNodeConstructorParams = ToolRefs & ToolNodeOptions;
+
+export type ToolEndEvent = {
+  /** The Step Id of the Tool Call */
+  id: string;
+  /** The Completed Tool Call */
+  tool_call: ToolCall;
+  /** The content index of the tool call */
+  index: number;
+};
+
+export type ToolCallContent = {
+  type: ContentTypes.TOOL_CALL;
+  tool_call: ToolCall;
+};