@librechat/agents 1.4.0

package/src/scripts/cli4.ts

@@ -0,0 +1,182 @@
+/* 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 { ModelEndHandler, ToolEndHandler } from '@/events';
+import { ChatModelStreamHandler } from '@/stream';
+
+
+import { getArgs } from '@/scripts/args';
+import { Run } from '@/run';
+import { GraphEvents, Callback, Providers } from '@/common';
+import { getLLMConfig } from '@/utils/llmConfig';
+
+const conversationHistory: BaseMessage[] = [];
+async function testStandardStreaming(): Promise<void> {
+  const { userName, location, provider, currentDate } = await getArgs();
+  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: string, data: t.StreamEventData): void => {
+        console.log('====== ON_RUN_STEP_COMPLETED ======');
+        console.dir(data, { depth: null });
+      }
+    },
+    [GraphEvents.ON_RUN_STEP]: {
+      handle: (_event: string, data: t.StreamEventData): void => {
+        console.log('====== ON_RUN_STEP ======');
+        console.dir(data, { depth: null });
+      }
+    },
+    [GraphEvents.ON_RUN_STEP_DELTA]: {
+      handle: (_event: string, data: t.StreamEventData): void => {
+        console.log('====== ON_RUN_STEP_DELTA ======');
+        console.dir(data, { depth: null });
+      }
+    },
+    [GraphEvents.ON_MESSAGE_DELTA]: {
+      handle: (_event: string, data: t.StreamEventData): void => {
+        console.log('====== ON_MESSAGE_DELTA ======');
+        console.dir(data, { depth: null });
+      }
+    },
+    [GraphEvents.TOOL_START]: {
+      handle: (_event: string, data: t.StreamEventData, metadata?: Record<string, unknown>): void => {
+        console.log('====== TOOL_START ======');
+        console.dir(data, { depth: null });
+      }
+    },
+    // [GraphEvents.LLM_STREAM]: new LLMStreamHandler(),
+    // [GraphEvents.LLM_START]: {
+    //   handle: (_event: string, data: t.StreamEventData): void => {
+    //     console.log('====== LLM_START ======');
+    //     console.dir(data, { depth: null });
+    //   }
+    // },
+    // [GraphEvents.LLM_END]: {
+    //   handle: (_event: string, data: t.StreamEventData): void => {
+    //     console.log('====== LLM_END ======');
+    //     console.dir(data, { depth: null });
+    //   }
+    // },
+    /*
+    [GraphEvents.CHAIN_START]: {
+      handle: (_event: string, data: t.StreamEventData): void => {
+        console.log('====== CHAIN_START ======');
+        // console.dir(data, { depth: null });
+      }
+    },
+    [GraphEvents.CHAIN_END]: {
+      handle: (_event: string, data: t.StreamEventData): void => {
+        console.log('====== CHAIN_END ======');
+        // console.dir(data, { depth: null });
+      }
+    },
+    */
+    // [GraphEvents.CHAT_MODEL_START]: {
+    //   handle: (_event: string, _data: t.StreamEventData): void => {
+    //     console.log('====== CHAT_MODEL_START ======');
+    //     console.dir(_data, { depth: null });
+    //     // Intentionally left empty
+    //   }
+    // },
+  };
+
+  // const llmConfig = getLLMConfig(provider);
+  let llmConfig = getLLMConfig(Providers.OPENAI);
+
+  const graphConfig: t.StandardGraphConfig  = {
+    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}.`,
+  };
+
+  let run = await Run.create<t.IState>({
+    graphConfig,
+    customHandlers,
+  });
+
+  const config = {
+    configurable: {
+      provider,
+      thread_id: 'conversation-num-1',
+    },
+    streamMode: 'values',
+    version: 'v2' as const,
+  };
+
+  console.log(' Test 1: OpenAI Tool Usage');
+
+  // conversationHistory.push(new HumanMessage(`Hi I'm ${userName}.`));
+  conversationHistory.push(new HumanMessage(`search for good sunrise hikes near ${location}
+then search weather in ${location} for today which is ${currentDate}`));
+  let inputs = {
+    messages: conversationHistory,
+  };
+  const contentParts = await run.processStream(inputs, config,
+  //   {
+  //   [Callback.TOOL_START]: (graph, ...args) => {
+  //       console.log('TOOL_START callback');
+  //   },
+  //   [Callback.TOOL_END]: (graph, ...args) => {
+  //       console.log('TOOL_END callback');
+  //   },
+  // }
+);
+  const finalMessages = run.getRunMessages();
+  if (finalMessages) {
+    conversationHistory.push(...finalMessages);
+  }
+
+  console.log(' Test 2: Anthropic Follow-up Response');
+
+  // const userMessage = `
+  // Make a search for the weather in ${location} today, which is ${currentDate}.
+  // Make sure to always refer to me by name.
+  // After giving me a thorough summary, tell me a joke about the weather forecast we went over.
+  // `;
+  const userMessage = `Thanks!`;
+
+  conversationHistory.push(new HumanMessage(userMessage));
+
+  inputs = {
+    messages: conversationHistory,
+  };
+
+  llmConfig = getLLMConfig(Providers.ANTHROPIC);
+  graphConfig.llmConfig = llmConfig;
+  config.configurable.provider = Providers.ANTHROPIC;
+
+  run = await Run.create<t.IState>({
+    graphConfig,
+    customHandlers,
+  });
+
+  const contentParts2 = await run.processStream(inputs, config);
+  const finalMessages2 = run.getRunMessages();
+  if (finalMessages2) {
+    conversationHistory.push(...finalMessages2);
+    // console.dir(conversationHistory, { depth: null });
+  }
+}
+
+process.on('unhandledRejection', (reason, promise) => {
+  console.error('Unhandled Rejection at:', promise, 'reason:', reason);
+  console.log('Conversation history:');
+  console.dir(conversationHistory, { depth: null });
+  process.exit(1);
+});
+
+testStandardStreaming().catch((err) => {
+  console.error(err);
+  console.log('Conversation history:');
+  console.dir(conversationHistory, { depth: null });
+  process.exit(1);
+});

package/src/scripts/cli5.ts

@@ -0,0 +1,182 @@
+/* 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 { ModelEndHandler, ToolEndHandler } from '@/events';
+import { ChatModelStreamHandler } from '@/stream';
+
+
+import { getArgs } from '@/scripts/args';
+import { Run } from '@/run';
+import { GraphEvents, Callback, Providers } from '@/common';
+import { getLLMConfig } from '@/utils/llmConfig';
+
+const conversationHistory: BaseMessage[] = [];
+async function testStandardStreaming(): Promise<void> {
+  const { userName, location, provider, currentDate } = await getArgs();
+  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: string, data: t.StreamEventData): void => {
+        console.log('====== ON_RUN_STEP_COMPLETED ======');
+        console.dir(data, { depth: null });
+      }
+    },
+    [GraphEvents.ON_RUN_STEP]: {
+      handle: (_event: string, data: t.StreamEventData): void => {
+        console.log('====== ON_RUN_STEP ======');
+        console.dir(data, { depth: null });
+      }
+    },
+    [GraphEvents.ON_RUN_STEP_DELTA]: {
+      handle: (_event: string, data: t.StreamEventData): void => {
+        console.log('====== ON_RUN_STEP_DELTA ======');
+        console.dir(data, { depth: null });
+      }
+    },
+    [GraphEvents.ON_MESSAGE_DELTA]: {
+      handle: (_event: string, data: t.StreamEventData): void => {
+        console.log('====== ON_MESSAGE_DELTA ======');
+        console.dir(data, { depth: null });
+      }
+    },
+    [GraphEvents.TOOL_START]: {
+      handle: (_event: string, data: t.StreamEventData, metadata?: Record<string, unknown>): void => {
+        console.log('====== TOOL_START ======');
+        console.dir(data, { depth: null });
+      }
+    },
+    // [GraphEvents.LLM_STREAM]: new LLMStreamHandler(),
+    // [GraphEvents.LLM_START]: {
+    //   handle: (_event: string, data: t.StreamEventData): void => {
+    //     console.log('====== LLM_START ======');
+    //     console.dir(data, { depth: null });
+    //   }
+    // },
+    // [GraphEvents.LLM_END]: {
+    //   handle: (_event: string, data: t.StreamEventData): void => {
+    //     console.log('====== LLM_END ======');
+    //     console.dir(data, { depth: null });
+    //   }
+    // },
+    /*
+    [GraphEvents.CHAIN_START]: {
+      handle: (_event: string, data: t.StreamEventData): void => {
+        console.log('====== CHAIN_START ======');
+        // console.dir(data, { depth: null });
+      }
+    },
+    [GraphEvents.CHAIN_END]: {
+      handle: (_event: string, data: t.StreamEventData): void => {
+        console.log('====== CHAIN_END ======');
+        // console.dir(data, { depth: null });
+      }
+    },
+    */
+    // [GraphEvents.CHAT_MODEL_START]: {
+    //   handle: (_event: string, _data: t.StreamEventData): void => {
+    //     console.log('====== CHAT_MODEL_START ======');
+    //     console.dir(_data, { depth: null });
+    //     // Intentionally left empty
+    //   }
+    // },
+  };
+
+  // const llmConfig = getLLMConfig(provider);
+  let llmConfig = getLLMConfig(Providers.ANTHROPIC);
+
+  const graphConfig: t.StandardGraphConfig  = {
+    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}.`,
+  };
+
+  let run = await Run.create<t.IState>({
+    graphConfig,
+    customHandlers,
+  });
+
+  const config = {
+    configurable: {
+      provider: Providers.ANTHROPIC,
+      thread_id: 'conversation-num-1',
+    },
+    streamMode: 'values',
+    version: 'v2' as const,
+  };
+
+  console.log(' Test 1: Anthropic Tool Usage');
+
+  // conversationHistory.push(new HumanMessage(`Hi I'm ${userName}.`));
+  conversationHistory.push(new HumanMessage(`search for good sunrise hikes near ${location}
+then search weather in ${location} for today which is ${currentDate}`));
+  let inputs = {
+    messages: conversationHistory,
+  };
+  const contentParts = await run.processStream(inputs, config,
+  //   {
+  //   [Callback.TOOL_START]: (graph, ...args) => {
+  //       console.log('TOOL_START callback');
+  //   },
+  //   [Callback.TOOL_END]: (graph, ...args) => {
+  //       console.log('TOOL_END callback');
+  //   },
+  // }
+);
+  const finalMessages = run.getRunMessages();
+  if (finalMessages) {
+    conversationHistory.push(...finalMessages);
+  }
+
+  console.log(' Test 2: OpenAI Follow-up Response');
+
+  // const userMessage = `
+  // Make a search for the weather in ${location} today, which is ${currentDate}.
+  // Make sure to always refer to me by name.
+  // After giving me a thorough summary, tell me a joke about the weather forecast we went over.
+  // `;
+  const userMessage = `Thanks!`;
+
+  conversationHistory.push(new HumanMessage(userMessage));
+
+  inputs = {
+    messages: conversationHistory,
+  };
+
+  llmConfig = getLLMConfig(Providers.OPENAI);
+  graphConfig.llmConfig = llmConfig;
+  config.configurable.provider = Providers.OPENAI;
+
+  run = await Run.create<t.IState>({
+    graphConfig,
+    customHandlers,
+  });
+
+  const contentParts2 = await run.processStream(inputs, config);
+  const finalMessages2 = run.getRunMessages();
+  if (finalMessages2) {
+    conversationHistory.push(...finalMessages2);
+    // console.dir(conversationHistory, { depth: null });
+  }
+}
+
+process.on('unhandledRejection', (reason, promise) => {
+  console.error('Unhandled Rejection at:', promise, 'reason:', reason);
+  console.log('Conversation history:');
+  console.dir(conversationHistory, { depth: null });
+  process.exit(1);
+});
+
+testStandardStreaming().catch((err) => {
+  console.error(err);
+  console.log('Conversation history:');
+  console.dir(conversationHistory, { depth: null });
+  process.exit(1);
+});

package/src/scripts/empty_input.ts

@@ -0,0 +1,136 @@
+import { z } from 'zod';
+import { config } from 'dotenv';
+config();
+import { HumanMessage } from '@langchain/core/messages';
+import { tool } from "@langchain/core/tools";
+import { getArgs } from '@/scripts/args';
+import { Run } from '@/run';
+import { getLLMConfig } from '@/utils/llmConfig';
+import { ChatModelStreamHandler } from '@/stream';
+import { ToolEndHandler, ModelEndHandler } from '@/events';
+import { GraphEvents } from '@/common';
+import type * as t from '@/types';
+
+const pingServerTool = tool(
+  () => {
+    return 'server has been pinged';
+  },
+  {
+    name: 'pingServer',
+    description: 'Ping server',
+    schema: z.object({}),
+  }
+);
+
+async function testPingServer(): Promise<void> {
+  const { provider } = await getArgs();
+  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: string, data: t.StreamEventData): void => {
+        console.log('====== ON_RUN_STEP_COMPLETED ======');
+        console.dir(data, { depth: null });
+      }
+    },
+    [GraphEvents.ON_RUN_STEP]: {
+      handle: (_event: string, data: t.StreamEventData): void => {
+        console.log('====== ON_RUN_STEP ======');
+        console.dir(data, { depth: null });
+      }
+    },
+    [GraphEvents.ON_RUN_STEP_DELTA]: {
+      handle: (_event: string, data: t.StreamEventData): void => {
+        console.log('====== ON_RUN_STEP_DELTA ======');
+        console.dir(data, { depth: null });
+      }
+    },
+    [GraphEvents.ON_MESSAGE_DELTA]: {
+      handle: (_event: string, data: t.StreamEventData): void => {
+        console.log('====== ON_MESSAGE_DELTA ======');
+        console.dir(data, { depth: null });
+      }
+    },
+    [GraphEvents.TOOL_START]: {
+      handle: (_event: string, data: t.StreamEventData, metadata?: Record<string, unknown>): void => {
+        console.log('====== TOOL_START ======');
+        console.dir(data, { depth: null });
+      }
+    },
+    // [GraphEvents.LLM_STREAM]: new LLMStreamHandler(),
+    // [GraphEvents.LLM_START]: {
+    //   handle: (_event: string, data: t.StreamEventData): void => {
+    //     console.log('====== LLM_START ======');
+    //     console.dir(data, { depth: null });
+    //   }
+    // },
+    // [GraphEvents.LLM_END]: {
+    //   handle: (_event: string, data: t.StreamEventData): void => {
+    //     console.log('====== LLM_END ======');
+    //     console.dir(data, { depth: null });
+    //   }
+    // },
+    /*
+    [GraphEvents.CHAIN_START]: {
+      handle: (_event: string, data: t.StreamEventData): void => {
+        console.log('====== CHAIN_START ======');
+        // console.dir(data, { depth: null });
+      }
+    },
+    [GraphEvents.CHAIN_END]: {
+      handle: (_event: string, data: t.StreamEventData): void => {
+        console.log('====== CHAIN_END ======');
+        // console.dir(data, { depth: null });
+      }
+    },
+    */
+    // [GraphEvents.CHAT_MODEL_START]: {
+    //   handle: (_event: string, _data: t.StreamEventData): void => {
+    //     console.log('====== CHAT_MODEL_START ======');
+    //     console.dir(_data, { depth: null });
+    //     // Intentionally left empty
+    //   }
+    // },
+  };
+
+  const llmConfig = getLLMConfig(provider);
+
+  const run = await Run.create<t.IState>({
+    graphConfig: {
+      type: 'standard',
+      llmConfig,
+      tools: [pingServerTool],
+      instructions: 'You are a helpful AI assistant.',
+    },
+    customHandlers,
+  });
+
+  const config = {
+    configurable: {
+      provider,
+      thread_id: 'ping-server-test',
+    },
+    streamMode: 'values',
+    version: 'v2' as const,
+  };
+
+  console.log('Pinging server test:');
+
+  const userMessage = "Please ping the server.";
+  const inputs = {
+    messages: [new HumanMessage(userMessage)],
+  };
+
+  const contentParts = await run.processStream(inputs, config);
+  const finalMessages = run.getRunMessages();
+  if (finalMessages) {
+    console.log('\nFinal messages:');
+    console.dir(finalMessages, { depth: null });
+  }
+}
+
+testPingServer().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/src/stream.ts

@@ -0,0 +1,145 @@
+// src/stream.ts
+import { nanoid } from 'nanoid';
+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';
+
+const getMessageId = (stepKey: string, graph: Graph<t.BaseGraphState>): string | undefined => {
+  const messageId = graph.messageIdsByStepKey.get(stepKey);
+  if (messageId) {
+    return;
+  }
+
+  const prelimMessageId = graph.prelimMessageIdsByStepKey.get(stepKey);
+  if (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;
+};
+
+export class ChatModelStreamHandler implements t.EventHandler {
+  handle(event: string, data: t.StreamEventData, metadata?: Record<string, unknown>, graph?: Graph): void {
+    if (!graph) {
+      throw new Error('Graph not found');
+    }
+
+    const chunk = data.chunk as AIMessageChunk;
+    const content = chunk?.content;
+
+    if (!graph.config) {
+      throw new Error('Config not found in graph');
+    }
+
+    if (!chunk) {
+      console.warn(`No chunk found in ${event} event`);
+      return;
+    }
+
+    const hasToolCalls = chunk.tool_calls && chunk.tool_calls.length > 0;
+    const hasToolCallChunks = chunk.tool_call_chunks && chunk.tool_call_chunks.length > 0;
+
+    if (hasToolCalls && chunk.tool_calls?.every((tc) => tc.id)) {
+      const tool_calls: ToolCall[] = [];
+      for (const tool_call of chunk.tool_calls) {
+        if (!tool_call.id || graph.toolCallStepIds.has(tool_call.id)) {
+          continue;
+        }
+
+        tool_calls.push(tool_call);
+      }
+
+      const stepKey = graph.getStepKey(metadata);
+      graph.dispatchRunStep(stepKey, {
+        type: StepTypes.TOOL_CALLS,
+        tool_calls,
+      });
+    }
+
+    const isEmptyContent = !content || !content.length;
+    const isEmptyChunk = isEmptyContent && !hasToolCallChunks;
+    if (isEmptyChunk && chunk.id && chunk.id?.startsWith('msg')) {
+      if (graph.messageIdsByStepKey.has(chunk.id)) {
+        return;
+      } else if (graph.prelimMessageIdsByStepKey.has(chunk.id)) {
+        return;
+      }
+
+      const stepKey = graph.getStepKey(metadata);
+      graph.prelimMessageIdsByStepKey.set(stepKey, chunk.id);
+      return;
+    } else if (isEmptyChunk) {
+      return;
+    }
+
+    const stepKey = graph.getStepKey(metadata);
+
+    if (hasToolCallChunks && chunk.tool_call_chunks?.length && typeof chunk.tool_call_chunks[0]?.index === 'number') {
+      const stepId = graph.getStepIdByKey(stepKey, chunk.tool_call_chunks[0].index);
+      graph.dispatchRunStepDelta(stepId, {
+        type: StepTypes.TOOL_CALLS,
+        tool_calls: chunk.tool_call_chunks,
+      });
+    }
+
+    if (isEmptyContent) {
+      return;
+    }
+
+    const message_id = getMessageId(stepKey, graph);
+    if (message_id) {
+      graph.dispatchRunStep(stepKey, {
+        type: StepTypes.MESSAGE_CREATION,
+        message_creation: {
+          message_id,
+        },
+      });
+    }
+
+    const stepId = graph.getStepIdByKey(stepKey);
+    const runStep = graph.getRunStep(stepId);
+    if (!runStep) {
+      // eslint-disable-next-line no-console
+      console.warn(`\n
+==============================================================
+
+
+Run step for ${stepId} does not exist, cannot dispatch delta event.
+
+event: ${event}
+stepId: ${stepId}
+stepKey: ${stepKey}
+message_id: ${message_id}
+hasToolCalls: ${hasToolCalls}
+hasToolCallChunks: ${hasToolCallChunks}
+
+==============================================================
+\n`);
+      return;
+    }
+
+    /* 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)) {
+      return;
+    } else if (typeof content === 'string') {
+      graph.dispatchMessageDelta(stepId, {
+        content: [{
+          type: 'text',
+          text: content,
+        }],
+      });
+    } else if (content?.every((c) => c.type?.startsWith('text'))) {
+      graph.dispatchMessageDelta(stepId, {
+        content,
+      });
+    }
+  }
+}