@librechat/agents 2.1.6 → 2.1.8

package/src/stream.ts

@@ -47,59 +47,56 @@ export const handleToolCalls = (toolCalls?: ToolCall[], metadata?: Record<string
     return;
   }
 
-  const tool_calls: ToolCall[] = [];
-  const tool_call_ids: string[] = [];
+
+  const stepKey = graph.getStepKey(metadata);
+  
   for (const tool_call of toolCalls) {
     const toolCallId = tool_call.id ?? `toolu_${nanoid()}`;
     tool_call.id = toolCallId;
     if (!toolCallId || graph.toolCallStepIds.has(toolCallId)) {
       continue;
     }
+    
+    let prevStepId = '';
+    let prevRunStep: t.RunStep | undefined;
+    try {
+      prevStepId = graph.getStepIdByKey(stepKey, graph.contentData.length - 1);
+      prevRunStep = graph.getRunStep(prevStepId);
+    } catch (e) {
+      // no previous step
+    }
 
-    tool_calls.push(tool_call);
-    tool_call_ids.push(toolCallId);
-  }
-
-  const stepKey = graph.getStepKey(metadata);
-
-  let prevStepId = '';
-  let prevRunStep: t.RunStep | undefined;
-  try {
-    prevStepId = graph.getStepIdByKey(stepKey, graph.contentData.length - 1);
-    prevRunStep = graph.getRunStep(prevStepId);
-  } catch (e) {
-    // no previous step
-  }
+    const dispatchToolCallIds = (lastMessageStepId: string): void => {
+      graph.dispatchMessageDelta(lastMessageStepId, {
+        content: [{
+          type: 'text',
+          text: '',
+          tool_call_ids: [toolCallId],
+        }],
+      });
+    };
+      /* If the previous step exists and is a message creation */
+    if (prevStepId && prevRunStep && prevRunStep.type === StepTypes.MESSAGE_CREATION) {
+      dispatchToolCallIds(prevStepId);
+      graph.messageStepHasToolCalls.set(prevStepId, true);
+      /* If the previous step doesn't exist or is not a message creation */
+    } else if (!prevRunStep || prevRunStep.type !== StepTypes.MESSAGE_CREATION) {
+      const messageId = getMessageId(stepKey, graph, true) ?? '';
+      const stepId = graph.dispatchRunStep(stepKey, {
+        type: StepTypes.MESSAGE_CREATION,
+        message_creation: {
+          message_id: messageId,
+        },
+      });
+      dispatchToolCallIds(stepId);
+      graph.messageStepHasToolCalls.set(prevStepId, true);
+    }
 
-  const dispatchToolCallIds = (lastMessageStepId: string): void => {
-    graph.dispatchMessageDelta(lastMessageStepId, {
-      content: [{
-        type: 'text',
-        text: '',
-        tool_call_ids,
-      }],
-    });
-  };
-    /* If the previous step exists and is a message creation */
-  if (prevStepId && prevRunStep && prevRunStep.type === StepTypes.MESSAGE_CREATION) {
-    dispatchToolCallIds(prevStepId);
-    graph.messageStepHasToolCalls.set(prevStepId, true);
-    /* If the previous step doesn't exist or is not a message creation */
-  } else if (!prevRunStep || prevRunStep.type !== StepTypes.MESSAGE_CREATION) {
-    const messageId = getMessageId(stepKey, graph, true) ?? '';
-    const stepId = graph.dispatchRunStep(stepKey, {
-      type: StepTypes.MESSAGE_CREATION,
-      message_creation: {
-        message_id: messageId,
-      },
-    });
-    dispatchToolCallIds(stepId);
-    graph.messageStepHasToolCalls.set(prevStepId, true);
+      graph.dispatchRunStep(stepKey, {
+        type: StepTypes.TOOL_CALLS,
+        tool_calls: [tool_call],
+      });
   }
-  graph.dispatchRunStep(stepKey, {
-    type: StepTypes.TOOL_CALLS,
-    tool_calls,
-  });
 };
 
 export class ChatModelStreamHandler implements t.EventHandler {
@@ -213,11 +210,11 @@ hasToolCallChunks: ${hasToolCallChunks}
       graph.dispatchMessageDelta(stepId, {
         content,
       });
-    } else if (content.every((c) => c.type?.startsWith(ContentTypes.THINKING))) {
+    } else if (content.every((c) => c.type?.startsWith(ContentTypes.THINKING) || c.type?.startsWith(ContentTypes.REASONING_CONTENT))) {
       graph.dispatchReasoningDelta(stepId, {
         content: content.map((c) => ({
           type: ContentTypes.THINK,
-          think: (c as t.ThinkingContentText).thinking,
+          think: (c as t.ThinkingContentText).thinking ?? (c as t.BedrockReasoningContentText).reasoningText?.text ?? '',
       }))});
     }
   }
@@ -230,14 +227,31 @@ hasToolCallChunks: ${hasToolCallChunks}
     stepKey: string;
     toolCallChunks: ToolCallChunk[],
   }): void => {
-    const prevStepId = graph.getStepIdByKey(stepKey, graph.contentData.length - 1);
-    const prevRunStep = graph.getRunStep(prevStepId);
+    let prevStepId: string;
+    let prevRunStep: t.RunStep | undefined;
+    try {
+      prevStepId = graph.getStepIdByKey(stepKey, graph.contentData.length - 1);
+      prevRunStep = graph.getRunStep(prevStepId);
+    } catch (e) {
+      /** Edge Case: If no previous step exists, create a new message creation step */
+      const message_id = getMessageId(stepKey, graph, true) ?? '';
+      prevStepId = graph.dispatchRunStep(stepKey, {
+        type: StepTypes.MESSAGE_CREATION,
+        message_creation: {
+          message_id,
+        },
+      });
+      prevRunStep = graph.getRunStep(prevStepId);
+    }
+
     const _stepId = graph.getStepIdByKey(stepKey, prevRunStep?.index);
+    
     /** Edge Case: Tool Call Run Step or `tool_call_ids` never dispatched */
     const tool_calls: ToolCall[] | undefined =
-    prevStepId && prevRunStep && prevRunStep.type === StepTypes.MESSAGE_CREATION
-      ? []
-      : undefined;
+      prevStepId && prevRunStep && prevRunStep.type === StepTypes.MESSAGE_CREATION
+        ? []
+        : undefined;
+    
     /** Edge Case: `id` and `name` fields cannot be empty strings */
     for (const toolCallChunk of toolCallChunks) {
       if (toolCallChunk.name === '') {
@@ -278,7 +292,7 @@ hasToolCallChunks: ${hasToolCallChunks}
   };
   handleReasoning(chunk: Partial<AIMessageChunk>, graph: Graph): void {
     let reasoning_content = chunk.additional_kwargs?.[graph.reasoningKey] as string | undefined;
-    if (Array.isArray(chunk.content) && chunk.content[0]?.type === 'thinking') {
+    if (Array.isArray(chunk.content) && (chunk.content[0]?.type === 'thinking' || chunk.content[0]?.type === 'reasoning_content')) {
       reasoning_content = 'valid';
     }
     if (reasoning_content != null && reasoning_content && (chunk.content == null || chunk.content === '' || reasoning_content === 'valid')) {

package/src/types/stream.ts

@@ -221,7 +221,14 @@ export type ThinkingContentText = {
   type: ContentTypes.THINKING;
   index?: number;
   signature?: string;
-  thinking: string;
+  thinking?: string;
+};
+
+/** Bedrock's Reasoning Content Block Format */
+export type BedrockReasoningContentText = {
+  type: ContentTypes.REASONING_CONTENT;
+  index?: number;
+  reasoningText: { text?: string; signature?: string; }
 };
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/src/utils/llmConfig.ts

@@ -75,7 +75,7 @@ export const llmConfigs: Record<string, t.LLMConfig | undefined> = {
   },
   [Providers.VERTEXAI]: {
     provider: Providers.VERTEXAI,
-    modelName: 'gemini-2.0-flash-exp',
+    modelName: 'gemini-2.0-flash-001',
     streaming: true,
     streamUsage: true,
     keyFile: process.env.VERTEXAI_KEY_FILE,