@librechat/agents 1.4.0

package/src/run.ts

@@ -0,0 +1,132 @@
+// src/run.ts
+import type { BaseCallbackHandler, CallbackHandlerMethods } from '@langchain/core/callbacks/base';
+import type { BaseMessage, MessageContentComplex } from '@langchain/core/messages';
+import type { RunnableConfig } from '@langchain/core/runnables';
+import type { ClientCallbacks, SystemCallbacks } from '@/graphs/Graph';
+import type * as t from '@/types';
+import { GraphEvents, Providers, Callback } from '@/common';
+import { StandardGraph } from '@/graphs/Graph';
+import { HandlerRegistry } from '@/events';
+
+export class Run<T extends t.BaseGraphState> {
+  graphRunnable?: t.CompiledWorkflow<T, Partial<T>, string>;
+  // private collab!: CollabGraph;
+  // private taskManager!: TaskManager;
+  private handlerRegistry: HandlerRegistry;
+  private Graph: StandardGraph | undefined;
+  provider: Providers | undefined;
+  run_id: string | undefined;
+
+  private constructor(config: t.RunConfig) {
+    const handlerRegistry = new HandlerRegistry();
+
+    if (config.customHandlers) {
+      for (const [eventType, handler] of Object.entries(config.customHandlers)) {
+        handlerRegistry.register(eventType, handler);
+      }
+    }
+
+    this.handlerRegistry = handlerRegistry;
+
+    if (config.graphConfig.type === 'standard' || !config.graphConfig.type) {
+      this.provider = config.graphConfig.llmConfig.provider;
+      this.graphRunnable = this.createStandardGraph(config.graphConfig) as unknown as t.CompiledWorkflow<T, Partial<T>, string>;
+      if (this.Graph) {
+        this.Graph.handlerRegistry = handlerRegistry;
+      }
+    }
+  }
+
+  private createStandardGraph(config: t.StandardGraphConfig): t.CompiledWorkflow<t.IState, Partial<t.IState>, string> {
+    const { runId, llmConfig, instructions, additional_instructions, tools = [] } = config;
+    const { provider, ...clientOptions } = llmConfig;
+
+    const standardGraph = new StandardGraph({
+      runId,
+      tools,
+      provider,
+      instructions,
+      clientOptions,
+      additional_instructions,
+    });
+    this.Graph = standardGraph;
+    return standardGraph.createWorkflow();
+  }
+
+  static async create<T extends t.BaseGraphState>(config: t.RunConfig): Promise<Run<T>> {
+    return new Run<T>(config);
+  }
+
+  getRunMessages(): BaseMessage[] | undefined {
+    if (!this.Graph) {
+      throw new Error('Graph not initialized. Make sure to use Run.create() to instantiate the Run.');
+    }
+    return this.Graph.getRunMessages();
+  }
+
+  async processStream(
+    inputs: t.IState,
+    config: Partial<RunnableConfig> & { version: 'v1' | 'v2' },
+    clientCallbacks?: ClientCallbacks,
+  ): Promise<MessageContentComplex[] | undefined> {
+    if (!this.graphRunnable) {
+      throw new Error('Run not initialized. Make sure to use Run.create() to instantiate the Run.');
+    }
+    if (!this.Graph) {
+      throw new Error('Graph not initialized. Make sure to use Run.create() to instantiate the Run.');
+    }
+
+    this.Graph.resetValues();
+    const provider = this.Graph.provider;
+    const hasTools = this.Graph.tools ? this.Graph.tools.length > 0 : false;
+    if (clientCallbacks) {
+      /* TODO: conflicts with callback manager */
+      const callbacks = config.callbacks as (BaseCallbackHandler | CallbackHandlerMethods)[] || [];
+      config.callbacks = callbacks.concat(this.getCallbacks(clientCallbacks));
+    }
+    const stream = this.graphRunnable.streamEvents(inputs, config);
+
+    for await (const event of stream) {
+      const { data, name, metadata, ...info } = event;
+
+      let eventName: t.EventName = info.event;
+      if (hasTools && provider === Providers.ANTHROPIC && eventName === GraphEvents.CHAT_MODEL_STREAM) {
+        /* Skipping CHAT_MODEL_STREAM event for Anthropic due to double-call edge case */
+        continue;
+      }
+
+      if (eventName && eventName === GraphEvents.ON_CUSTOM_EVENT) {
+        eventName = name;
+      }
+
+      // console.log(`Event: ${event.event} | Executing Event: ${eventName}`);
+
+      const handler = this.handlerRegistry.getHandler(eventName);
+      if (handler) {
+        handler.handle(eventName, data, metadata, this.Graph);
+      }
+    }
+
+    return this.Graph.getContentParts();
+  }
+
+  private createSystemCallback<K extends keyof ClientCallbacks>(
+    clientCallbacks: ClientCallbacks,
+    key: K
+  ): SystemCallbacks[K] {
+    return ((...args: unknown[]) => {
+      const clientCallback = clientCallbacks[key];
+      if (clientCallback && this.Graph) {
+        (clientCallback as (...args: unknown[]) => void)(this.Graph, ...args);
+      }
+    }) as SystemCallbacks[K];
+  }
+
+  getCallbacks(clientCallbacks: ClientCallbacks): SystemCallbacks {
+    return {
+      [Callback.TOOL_ERROR]: this.createSystemCallback(clientCallbacks, Callback.TOOL_ERROR),
+      [Callback.TOOL_START]: this.createSystemCallback(clientCallbacks, Callback.TOOL_START),
+      [Callback.TOOL_END]: this.createSystemCallback(clientCallbacks, Callback.TOOL_END),
+    };
+  }
+}

package/src/scripts/args.ts

@@ -0,0 +1,42 @@
+// src/scripts/args.ts
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+
+export async function getArgs(): Promise<{ userName: string; location: string; provider: string; currentDate: string; }> {
+  const argv = yargs(hideBin(process.argv))
+    .option('name', {
+      alias: 'n',
+      type: 'string',
+      description: 'User name',
+      default: 'Jo'
+    })
+    .option('location', {
+      alias: 'l',
+      type: 'string',
+      description: 'User location',
+      default: 'New York'
+    })
+    .option('provider', {
+      alias: 'p',
+      type: 'string',
+      description: 'LLM provider',
+      choices: ['openAI', 'anthropic', 'mistralai', 'vertexai', 'aws'],
+      default: 'openAI'
+    })
+    .help()
+    .alias('help', 'h')
+    .argv;
+
+  const args = await argv;
+  const userName = args.name as string;
+  const location = args.location as string;
+  const provider = args.provider as string;
+  const currentDate = new Date().toLocaleString();
+
+  return {
+    userName,
+    location,
+    provider,
+    currentDate
+  };
+}

package/src/scripts/cli.ts

@@ -0,0 +1,166 @@
+/* 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 } 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);
+
+  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: Initial greeting');
+
+  conversationHistory.push(new HumanMessage(`Hi I'm ${userName}.`));
+  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: Weather query');
+
+  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.
+  `;
+
+  conversationHistory.push(new HumanMessage(userMessage));
+
+  inputs = {
+    messages: conversationHistory,
+  };
+  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/cli2.ts

@@ -0,0 +1,124 @@
+/* eslint-disable no-console */
+// src/scripts/cli2.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 } from '@/stream';
+import { TestLLMStreamHandler } from '@/events';
+
+import { getArgs } from '@/scripts/args';
+import { Run } from '@/run';
+import { GraphEvents } from '@/common';
+import { getLLMConfig } from '@/utils/llmConfig';
+
+const conversationHistory: BaseMessage[] = [];
+
+async function executePersonalizedQuerySuite(): Promise<void> {
+  const { userName, location, provider, currentDate } = await getArgs();
+  
+  const customHandlers = {
+    [GraphEvents.LLM_STREAM]: new TestLLMStreamHandler(),
+    [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
+    [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.CHAT_MODEL_START]: {
+      handle: (_event: string, _data: t.StreamEventData): void => {
+        console.log('====== CHAT_MODEL_START ======');
+        console.dir(_data, { depth: null });
+      }
+    },
+    [GraphEvents.CHAT_MODEL_END]: {
+      handle: (_event: string, _data: t.StreamEventData): void => {
+        console.log('====== CHAT_MODEL_END ======');
+        console.dir(_data, { depth: null });
+      }
+    },
+    [GraphEvents.TOOL_START]: {
+      handle: (_event: string, data: t.StreamEventData): void => {
+        console.log('====== TOOL_START ======');
+        console.dir(data, { depth: null });
+      }
+    },
+    [GraphEvents.TOOL_END]: {
+      handle: (_event: string, data: t.StreamEventData): void => {
+        console.log('====== TOOL_END ======');
+        console.dir(data, { depth: null });
+      }
+    },
+  };
+
+  const llmConfig = getLLMConfig(provider);
+
+  const run = await Run.create<t.IState>({
+    graphConfig: {
+      type: 'standard',
+      llmConfig,
+      tools: [new TavilySearchResults()],
+    },
+    customHandlers,
+  });
+
+  const sessionConfig = {
+    configurable: {
+      provider,
+      thread_id: `${userName}-session-${Date.now()}`,
+      instructions: `You are a knowledgeable and friendly AI assistant. Tailor your responses to ${userName}'s interests in ${location}.`,
+      additional_instructions: `Ensure each topic is thoroughly researched. Today is ${currentDate}. Maintain a warm, personalized tone throughout.`
+    },
+    streamMode: 'values',
+    version: 'v2' as const,
+  };
+
+  console.log(`Initiating personalized query suite for ${userName}`);
+
+  const queryTopics = [
+    { task: "current weather", description: "Provide a detailed weather forecast" },
+    { task: "popular tourist attraction", description: "Describe a notable sight" },
+    { task: "upcoming events", description: "List major events or festivals this week" },
+    // { task: "famous local dish", description: "Share a recipe for a regional specialty" },
+    // { task: "local humor", description: "Tell a joke related to the area or findings" }
+  ];
+
+  const userPrompt = `
+  Greetings! I'm ${userName}, currently in ${location}. Today's date is ${currentDate}.
+  I'm seeking information on various aspects of ${location}. Please address the following:
+
+  ${queryTopics.map((topic, index) => `${index + 1}. ${topic.description} in ${location}.`).join('\n  ')}
+
+  For each topic, conduct a separate search to ensure accuracy and depth.
+  In your response, please address me as ${userName} and maintain a friendly, informative tone.
+  `;
+
+  conversationHistory.push(new HumanMessage(userPrompt));
+
+  const runInput = {
+    messages: conversationHistory,
+  };
+
+  const contentParts = await run.processStream(runInput, sessionConfig);
+  const finalMessages = run.getRunMessages();
+  if (finalMessages) {
+    conversationHistory.push(...finalMessages);
+    console.log("AI Assistant's Response:");
+    console.dir(conversationHistory, { depth: null });
+  }
+}
+
+executePersonalizedQuerySuite().catch((error) => {
+  console.error("An error occurred during the query suite execution:", error);
+  console.log("Final conversation state:");
+  console.dir(conversationHistory, { depth: null });
+  process.exit(1);
+});

package/src/scripts/cli3.ts

@@ -0,0 +1,175 @@
+/* eslint-disable no-console */
+// src/scripts/cli.ts
+import { config } from 'dotenv';
+config();
+import { z } from "zod";
+import { HumanMessage, BaseMessage } from '@langchain/core/messages';
+import type { RunnableConfig } from '@langchain/core/runnables';
+import { TavilySearchResults } from '@langchain/community/tools/tavily_search';
+import { tool } from "@langchain/core/tools";
+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 } 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]: {
+      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 getWeather = tool(async ({ location }) => {
+    if (location === "SAN FRANCISCO") {
+      return "It's 60 degrees and foggy";
+    } else if (location.toLowerCase() === "san francisco") {
+      throw new Error("Input queries must be all capitals");
+    } else {
+      throw new Error("Invalid input.");
+    }
+  }, {
+    name: "get_weather",
+    description: "Call to get the current weather",
+    schema: z.object({
+      location: z.string(),
+    }),
+  });
+
+  const run = await Run.create<t.IState>({
+    graphConfig: {
+      type: 'standard',
+      llmConfig,
+      tools: [getWeather],
+      // tools: [new TavilySearchResults()],
+    },
+    customHandlers,
+  });
+
+  const config = {
+    configurable: {
+      provider,
+      thread_id: 'conversation-num-1',
+      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}.`
+    },
+    streamMode: 'values',
+    version: 'v2' as const,
+  };
+
+  console.log(' Test 1: Initial greeting');
+
+  conversationHistory.push(new HumanMessage(`Hi I'm ${userName}.`));
+  let inputs = {
+    messages: conversationHistory,
+  };
+  const contentParts = await run.processStream(inputs, config, {
+    [Callback.TOOL_ERROR]: (graph, error, toolId) => {
+      console.error(`Tool ${toolId} failed with error: ${error.message}`);
+    },
+  });
+  const finalMessages = run.getRunMessages();
+  if (finalMessages) {
+    conversationHistory.push(...finalMessages);
+  }
+
+  console.log(' Test 2: Weather query');
+
+  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.
+  `;
+
+  conversationHistory.push(new HumanMessage(userMessage));
+
+  inputs = {
+    messages: conversationHistory,
+  };
+  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);
+});