@librechat/agents 2.4.30 → 2.4.33

package/src/events.ts

@@ -1,9 +1,12 @@
 /* eslint-disable no-console */
 // src/events.ts
-import type { UsageMetadata, BaseMessageFields } from '@langchain/core/messages';
+import type {
+  UsageMetadata,
+  BaseMessageFields,
+} from '@langchain/core/messages';
 import type { Graph } from '@/graphs';
 import type * as t from '@/types';
-import { handleToolCalls } from '@/stream';
+import { handleToolCalls } from '@/tools/handlers';
 import { Providers } from '@/common';
 
 export class HandlerRegistry {
@@ -27,7 +30,12 @@ export class ModelEndHandler implements t.EventHandler {
     this.collectedUsage = collectedUsage;
   }
 
-  handle(event: string, data: t.ModelEndData, metadata?: Record<string, unknown>, graph?: Graph): void {
+  handle(
+    event: string,
+    data: t.ModelEndData,
+    metadata?: Record<string, unknown>,
+    graph?: Graph
+  ): void {
     if (!graph || !metadata) {
       console.warn(`Graph or metadata not found in ${event} event`);
       return;
@@ -43,9 +51,12 @@ export class ModelEndHandler implements t.EventHandler {
     }
 
     console.log(`====== ${event.toUpperCase()} ======`);
-    console.dir({
-      usage,
-    }, { depth: null });
+    console.dir(
+      {
+        usage,
+      },
+      { depth: null }
+    );
 
     if (metadata.provider !== Providers.GOOGLE) {
       return;
@@ -60,7 +71,12 @@ export class ToolEndHandler implements t.EventHandler {
   constructor(callback?: t.ToolEndCallback) {
     this.callback = callback;
   }
-  handle(event: string, data: t.StreamEventData | undefined, metadata?: Record<string, unknown>, graph?: Graph): void {
+  handle(
+    event: string,
+    data: t.StreamEventData | undefined,
+    metadata?: Record<string, unknown>,
+    graph?: Graph
+  ): void {
     if (!graph || !metadata) {
       console.warn(`Graph or metadata not found in ${event} event`);
       return;
@@ -74,14 +90,17 @@ export class ToolEndHandler implements t.EventHandler {
 
     this.callback?.(toolEndData, metadata);
 
-    graph.handleToolCallCompleted({ input: toolEndData.input, output: toolEndData.output }, metadata);
+    graph.handleToolCallCompleted(
+      { input: toolEndData.input, output: toolEndData.output },
+      metadata
+    );
   }
 }
 
 export class TestLLMStreamHandler implements t.EventHandler {
   handle(event: string, data: t.StreamEventData | undefined): void {
     const chunk = data?.chunk;
-    const  isMessageChunk = !!(chunk && 'message' in chunk);
+    const isMessageChunk = !!(chunk && 'message' in chunk);
     const msg = isMessageChunk ? chunk.message : undefined;
     if (msg && msg.tool_call_chunks && msg.tool_call_chunks.length > 0) {
       console.log(msg.tool_call_chunks);
@@ -116,11 +135,17 @@ export class TestChatStreamHandler implements t.EventHandler {
 }
 
 export class LLMStreamHandler implements t.EventHandler {
-  handle(event: string, data: t.StreamEventData | undefined, metadata?: Record<string, unknown>): void {
+  handle(
+    event: string,
+    data: t.StreamEventData | undefined,
+    metadata?: Record<string, unknown>
+  ): void {
     const chunk = data?.chunk;
-    const  isMessageChunk = !!(chunk && 'message' in chunk);
+    const isMessageChunk = !!(chunk && 'message' in chunk);
     const msg = isMessageChunk && chunk.message;
-    if (metadata) { console.log(metadata); }
+    if (metadata) {
+      console.log(metadata);
+    }
     if (msg && msg.tool_call_chunks && msg.tool_call_chunks.length > 0) {
       console.log(msg.tool_call_chunks);
     } else if (msg && msg.content) {
@@ -133,12 +158,21 @@ export class LLMStreamHandler implements t.EventHandler {
   }
 }
 
-export const createMetadataAggregator = (_collected?: Record<string, NonNullable<BaseMessageFields['response_metadata']>>[]): t.MetadataAggregatorResult => {
+export const createMetadataAggregator = (
+  _collected?: Record<
+    string,
+    NonNullable<BaseMessageFields['response_metadata']>
+  >[]
+): t.MetadataAggregatorResult => {
   const collected = _collected || [];
 
   const handleLLMEnd: t.HandleLLMEnd = (output) => {
     const { generations } = output;
-    const lastMessageOutput = (generations[generations.length - 1] as (t.StreamGeneration | undefined)[] | undefined)?.[0];
+    const lastMessageOutput = (
+      generations[generations.length - 1] as
+        | (t.StreamGeneration | undefined)[]
+        | undefined
+    )?.[0];
     if (!lastMessageOutput) {
       return;
     }
@@ -149,4 +183,4 @@ export const createMetadataAggregator = (_collected?: Record<string, NonNullable
   };
 
   return { handleLLMEnd, collected };
-};
+};

package/src/graphs/Graph.ts

@@ -105,7 +105,8 @@ export abstract class Graph<
   lastToken?: string;
   tokenTypeSwitch?: 'reasoning' | 'content';
   reasoningKey: 'reasoning_content' | 'reasoning' = 'reasoning_content';
-  currentTokenType: ContentTypes.TEXT | ContentTypes.THINK = ContentTypes.TEXT;
+  currentTokenType: ContentTypes.TEXT | ContentTypes.THINK | 'think_and_text' =
+    ContentTypes.TEXT;
   messageStepHasToolCalls: Map<string, boolean> = new Map();
   messageIdsByStepKey: Map<string, string> = new Map();
   prelimMessageIdsByStepKey: Map<string, string> = new Map();
@@ -303,7 +304,10 @@ export class StandardGraph extends Graph<t.BaseGraphState, GraphNode> {
       metadata.langgraph_step as number,
       metadata.checkpoint_ns as string,
     ];
-    if (this.currentTokenType === ContentTypes.THINK) {
+    if (
+      this.currentTokenType === ContentTypes.THINK ||
+      this.currentTokenType === 'think_and_text'
+    ) {
       keyList.push('reasoning');
     }
 

package/src/index.ts

@@ -10,6 +10,8 @@ export * from './graphs';
 
 /* Tools */
 export * from './tools/CodeExecutor';
+export * from './tools/handlers';
+export * from './tools/search';
 
 /* Misc. */
 export * from './common';

package/src/messages/ids.ts

@@ -0,0 +1,26 @@
+// src/stream.ts
+import { nanoid } from 'nanoid';
+import type { Graph } from '@/graphs';
+import type * as t from '@/types';
+
+export const getMessageId = (
+  stepKey: string,
+  graph: Graph<t.BaseGraphState>,
+  returnExistingId = false
+): string | undefined => {
+  const messageId = graph.messageIdsByStepKey.get(stepKey);
+  if (messageId != null && messageId) {
+    return returnExistingId ? messageId : undefined;
+  }
+
+  const prelimMessageId = graph.prelimMessageIdsByStepKey.get(stepKey);
+  if (prelimMessageId != null && prelimMessageId) {
+    graph.prelimMessageIdsByStepKey.delete(stepKey);
+    graph.messageIdsByStepKey.set(stepKey, prelimMessageId);
+    return prelimMessageId;
+  }
+
+  const message_id = `msg_${nanoid()}`;
+  graph.messageIdsByStepKey.set(stepKey, message_id);
+  return message_id;
+};

package/src/messages/index.ts

@@ -1,3 +1,4 @@
 export * from './core';
+export * from './ids';
 export * from './prune';
 export * from './format';

package/src/scripts/search.ts

@@ -0,0 +1,146 @@
+/* eslint-disable no-console */
+// src/scripts/cli.ts
+import { config } from 'dotenv';
+config();
+import { HumanMessage, BaseMessage } from '@langchain/core/messages';
+import type * as t from '@/types';
+import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
+import { ToolEndHandler, ModelEndHandler } from '@/events';
+import { createSearchTool } from '@/tools/search';
+
+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>({
+    runId: 'test-run-id',
+    graphConfig: {
+      type: 'standard',
+      llmConfig,
+      tools: [createSearchTool()],
+      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}.`,
+    },
+    returnContent: true,
+    customHandlers,
+  });
+
+  const config = {
+    configurable: {
+      provider,
+      thread_id: 'conversation-num-1',
+    },
+    streamMode: 'values',
+    version: 'v2' as const,
+  };
+
+  console.log('Test 1: Search query (search tool test)');
+
+  // const userMessage = `
+  // Make a search for the weather in ${location} today, which is ${currentDate}.
+  // Before making the search, please let me know what you're about to do, then immediately start searching without hesitation.
+  // 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.
+  // `;
+  // const userMessage = 'Are massage guns good?';
+  // const userMessage = 'What is functional programming?';
+  const userMessage = "Get me today's trending news.";
+  // const userMessage = "search recent italy earthquake volcano activity";
+  // const userMessage =
+  //   "use 'Trump' as the exact search query and tell me what you find.";
+
+  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);
+});