@librechat/agents 3.0.1 → 3.0.2

package/src/proto/original_script.ts

@@ -1,126 +0,0 @@
-// src/main.ts
-import dotenv from 'dotenv';
-import { TavilySearchResults } from '@langchain/community/tools/tavily_search';
-import type * as t from '@/types';
-import {
-  ChatModelStreamHandler,
-  LLMStreamHandler,
-} from '@/stream';
-import { GraphEvents, Providers } from '@/common';
-import { Processor } from '@/processor';
-
-dotenv.config();
-
-const userName = 'Jo';
-const location = 'New York';
-const currentDate = new Date().toLocaleString();
-
-async function testStreaming() {
-  const conversationHistory: string[][] = [];
-
-  const customHandlers = {
-    [GraphEvents.LLM_STREAM]: new LLMStreamHandler(),
-    [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
-    [GraphEvents.LLM_START]: {
-      handle: (event: string, data: t.StreamEventData) => {
-        console.dir(data, { depth: null });
-      }
-    },
-    [GraphEvents.LLM_END]: {
-      handle: (event: string, data: t.StreamEventData) => {
-        console.dir(data, { depth: null });
-
-        const response = data.output.generations[0][0].message.content;
-
-        if (response.trim() !== '') {
-          conversationHistory.push(['assistant', response]);
-          console.log('Updated conversation history:', conversationHistory);
-        }
-      }
-    },
-    [GraphEvents.CHAT_MODEL_END]: {
-      handle: (event: string, data: t.StreamEventData) => {
-        const response = data?.output?.content;
-
-        if (Array.isArray(response)) {
-          console.dir(response, { depth: null });
-        } else if (typeof response === 'string' && response.trim() !== '') {
-          conversationHistory.push(['assistant', response]);
-          console.log('Updated conversation history:', conversationHistory);
-        }
-      }
-    },
-    [GraphEvents.TOOL_END]: {
-      handle: (event: string, data: t.StreamEventData) => {
-        console.dir(data, { depth: null });
-      }
-    },
-  };
-
-  const llmConfig: t.LLMConfig = {
-    provider: Providers.OPENAI,
-    model: 'gpt-4o',
-    temperature: 0.7,
-  };
-
-  // const llmConfig: t.LLMConfig = {
-  //   provider: Providers.ANTHROPIC,
-  //   model: 'claude-3-haiku-20240307',
-  //   streaming: true,
-  // };
-
-  // const llmConfig: t.LLMConfig = {
-  //   provider: Providers.MISTRALAI,
-  //   model: 'mistral-large-latest',
-  // };
-
-  // const llmConfig: t.LLMConfig = {
-  //   provider: Providers.VERTEXAI,
-  //   modelName: 'gemini-1.5-flash-001',
-  //   streaming: true,
-  // };
-
-  // const llmConfig: t.LLMConfig = {
-  //   provider: Providers.BEDROCK,
-  //   model: 'anthropic.claude-3-sonnet-20240229-v1:0',
-  //   region: process.env.BEDROCK_AWS_REGION,
-  //   credentials: {
-  //     accessKeyId: process.env.BEDROCK_AWS_ACCESS_KEY_ID!,
-  //     secretAccessKey: process.env.BEDROCK_AWS_SECRET_ACCESS_KEY!,
-  //   },
-  // };
-
-  const processor = new Processor({
-    llmConfig,
-    customHandlers,
-    tools: [new TavilySearchResults({})],
-  });
-
-  const config = {
-    configurable: { thread_id: 'conversation-num-1' },
-    streamMode: 'values',
-    version: 'v2' as const,
-  };
-
-  console.log('\nTest 1: Initial greeting');
-
-  conversationHistory.push(['user', `Hi I'm ${userName}.`]);
-  let inputs = { messages: conversationHistory };
-  await processor.processStream(inputs, config);
-
-  console.log('\nTest 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(['user', userMessage]);
-
-  inputs = { messages: conversationHistory };
-  await processor.processStream(inputs, config);
-
-}
-
-testStreaming();

package/src/proto/standard.ts

@@ -1,100 +0,0 @@
-// src/main_standard.ts
-import dotenv from 'dotenv';
-import { TavilySearchResults } from '@langchain/community/tools/tavily_search';
-import type * as t from '@/types';
-import {
-  ChatModelStreamHandler,
-  LLMStreamHandler,
-} from '@/stream';
-import { GraphEvents, Providers } from '@/common';
-import { Processor } from '@/processor';
-import { HumanMessage, BaseMessage } from '@langchain/core/messages';
-
-dotenv.config();
-
-const userName = 'Jo';
-const location = 'New York';
-const currentDate = new Date().toLocaleString();
-
-async function testStandardStreaming() {
-  const conversationHistory: BaseMessage[] = [];
-
-  const customHandlers = {
-    [GraphEvents.LLM_STREAM]: new LLMStreamHandler(),
-    [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
-    [GraphEvents.LLM_START]: {
-      handle: (event: string, data: t.StreamEventData) => {
-        console.dir(data, { depth: null });
-      }
-    },
-    [GraphEvents.LLM_END]: {
-      handle: (event: string, data: t.StreamEventData) => {
-        console.dir(data, { depth: null });
-
-        const response = data.output.generations[0][0].message.content;
-
-        if (response.trim() !== '') {
-          conversationHistory.push(new HumanMessage(response));
-          console.log('Updated conversation history:', conversationHistory);
-        }
-      }
-    },
-    [GraphEvents.CHAT_MODEL_END]: {
-      handle: (event: string, data: t.StreamEventData) => {
-        const response = data?.output?.content;
-
-        if (Array.isArray(response)) {
-          console.dir(response, { depth: null });
-        } else if (typeof response === 'string' && response.trim() !== '') {
-          conversationHistory.push(new HumanMessage(response));
-          console.log('Updated conversation history:', conversationHistory);
-        }
-      }
-    },
-    [GraphEvents.TOOL_END]: {
-      handle: (event: string, data: t.StreamEventData) => {
-        console.dir(data, { depth: null });
-      }
-    },
-  };
-
-  const processor = await Processor.create<t.IState>({
-    graphConfig: {
-      type: 'standard',
-      llmConfig: {
-        provider: Providers.OPENAI,
-        model: 'gpt-4',
-        temperature: 0.7,
-      },
-      tools: [new TavilySearchResults({})],
-    },
-    customHandlers,
-  });
-
-  const config = {
-    configurable: { thread_id: 'conversation-num-1' },
-    streamMode: 'values',
-    version: 'v2' as const,
-  };
-
-  console.log('\nTest 1: Initial greeting');
-
-  conversationHistory.push(new HumanMessage(`Hi I'm ${userName}.`));
-  let inputs = { messages: conversationHistory };
-  await processor.processStream(inputs, config);
-
-  console.log('\nTest 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 };
-  await processor.processStream(inputs, config);
-}
-
-testStandardStreaming();

package/src/proto/stream.ts

@@ -1,56 +0,0 @@
-import type { ChatGenerationChunk } from '@langchain/core/outputs';
-import type { RunnableConfig } from '@langchain/core/runnables';
-import type { AIMessageChunk } from '@langchain/core/messages';
-import type * as t from '@/types/graph';
-
-export interface EventHandler {
-  handle(event: string, data: t.StreamEventData): void;
-}
-
-export class HandlerRegistry {
-    private handlers: Map<string, EventHandler> = new Map();
-
-    register(eventType: string, handler: EventHandler) {
-        this.handlers.set(eventType, handler);
-    }
-
-    getHandler(eventType: string): EventHandler | undefined {
-        return this.handlers.get(eventType);
-    }
-}
-
-export class LLMStreamHandler implements EventHandler {
-    handle(event: string, data: t.StreamEventData) {
-        const chunk: ChatGenerationChunk = data?.chunk;
-        const msg = chunk.message as AIMessageChunk;
-        if (msg.tool_call_chunks && msg.tool_call_chunks.length > 0) {
-            console.log(msg.tool_call_chunks);
-        } else {
-            const content = msg.content || '';
-            if (typeof content === 'string') {
-                process.stdout.write(content);
-            }
-        }
-    }
-}
-
-export class GraphStreamProcessor {
-    private handlerRegistry: HandlerRegistry;
-
-    constructor(handlerRegistry: HandlerRegistry) {
-        this.handlerRegistry = handlerRegistry;
-    }
-
-    async processStream<RunInput>(
-        graph: t.Graph,
-        inputs: RunInput,
-        config: Partial<RunnableConfig> & { version: 'v1' | 'v2' },
-    ) {
-        for await (const event of graph.streamEvents(inputs, config)) {
-            const handler = this.handlerRegistry.getHandler(event.event);
-            if (handler) {
-                handler.handle(event.event, event.data);
-            }
-        }
-    }
-}

package/src/proto/tasks.ts

@@ -1,118 +0,0 @@
-import fs from 'fs';
-import util from 'util';
-import dotenv from 'dotenv';
-import { HumanMessage } from '@langchain/core/messages';
-import type * as t from '@/types';
-import {
-  ChatModelStreamHandler,
-} from '@/stream';
-import { Processor } from '@/processor';
-import { taskManagerPrompt } from '@/prompts/taskmanager';
-import { tavilyTool, chartTool } from '@/tools/example';
-import { GraphEvents, Providers } from '@/common';
-
-dotenv.config();
-
-// Create a write stream
-const logFile = fs.createWriteStream('output.log', { flags: 'a' });
-
-// Redirect console.log and console.error
-const originalConsoleLog = console.log;
-const originalConsoleError = console.error;
-
-console.log = function(...args) {
-  logFile.write(util.format.apply(null, args) + '\n');
-  originalConsoleLog.apply(console, args);
-};
-
-console.error = function(...args) {
-  logFile.write(util.format.apply(null, args) + '\n');
-  originalConsoleError.apply(console, args);
-};
-
-async function testTaskManagerStreaming() {
-  const customHandlers = {
-    [GraphEvents.LLM_STREAM]: new LLMStreamHandler(),
-    [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
-    [GraphEvents.LLM_START]: {
-      handle: (event: string, data: t.StreamEventData) => {
-        console.log('LLM Start:', event);
-      }
-    },
-    [GraphEvents.LLM_END]: {
-      handle: (event: string, data: t.StreamEventData) => {
-        console.log('LLM End:', event);
-      }
-    },
-    [GraphEvents.CHAT_MODEL_END]: {
-      handle: (event: string, data: t.StreamEventData) => {
-        console.log('Chat Model End:', event);
-      }
-    },
-    [GraphEvents.TOOL_END]: {
-      handle: (event: string, data: t.StreamEventData) => {
-        console.log('Tool End:', event);
-        console.dir(data, { depth: null });
-      }
-    },
-  };
-
-  const processor = await Processor.create<TaskManagerStateChannels>({
-    graphConfig: {
-      type: 'taskmanager',
-      members: [
-        {
-          name: 'researcher',
-          systemPrompt: 'You are a web researcher. You may use the Tavily search engine to search the web for important information, so the Chart Generator in your team can make useful plots.',
-          tools: [tavilyTool],
-          llmConfig: {
-            provider: Providers.OPENAI,
-            model: 'gpt-4o',
-            temperature: 0,
-          },
-        },
-        {
-          name: 'chart_generator',
-          systemPrompt: 'You excel at generating bar charts. Use the researcher\'s information to generate the charts.',
-          tools: [chartTool],
-          llmConfig: {
-            provider: Providers.OPENAI,
-            model: 'gpt-4o',
-            temperature: 0.2,
-          },
-        },
-      ],
-      supervisorConfig: {
-        systemPrompt: taskManagerPrompt,
-        llmConfig: {
-          provider: Providers.OPENAI,
-          model: 'gpt-4o',
-          temperature: 0,
-        },
-      },
-    },
-    customHandlers,
-  });
-
-  const config = {
-    configurable: { thread_id: 'taskmanager-conversation-1' },
-    streamMode: 'values',
-    version: 'v2' as const,
-  };
-
-  console.log('\nTaskManager Test: Create a chart');
-
-  const input = {
-    messages: [new HumanMessage('Create a chart showing the population growth of the top 5 most populous countries over the last 50 years.')],
-  };
-
-  await processor.processStream(input, config);
-}
-
-async function main() {
-  await testTaskManagerStreaming();
-}
-
-main().catch(console.error).finally(() => {
-  logFile.end();
-});

package/src/proto/tools/global_analysis_tools.ts

@@ -1,86 +0,0 @@
-// src/tools/global_analysis_tools.ts
-import { DynamicStructuredTool } from '@langchain/core/tools';
-import { z } from 'zod';
-import fetch from 'node-fetch';
-
-export const WeatherDataTool = new DynamicStructuredTool({
-    name: 'get_weather_data',
-    description: 'Fetches current weather data for a given city.',
-    schema: z.object({
-        city: z.string(),
-    }),
-    func: async ({ city }) => {
-        try {
-            // Try OpenMeteo API first (doesn't require API key)
-            const url = 'https://api.open-meteo.com/v1/forecast?latitude=52.52&longitude=13.41&current_weather=true';
-            const response = await fetch(url);
-            const data = await response.json();
-
-            if (data.error) {
-                throw new Error(data.reason);
-            }
-
-            return JSON.stringify(data);
-        } catch (error) {
-            console.error(`Error fetching weather data: ${(error as Error).message}`);
-            // Implement fallback or return error message
-            return JSON.stringify({ error: 'Unable to fetch weather data. Please try again later.' });
-        }
-    }
-});
-
-// Time Zone Tool
-export const TimeZoneTool = new DynamicStructuredTool({
-    name: 'get_time_zone_info',
-    description: 'Fetches time zone information for a given location.',
-    schema: z.object({
-        latitude: z.number(),
-        longitude: z.number(),
-    }),
-    func: async ({ latitude, longitude }) => {
-        const url = `http://api.geonames.org/timezoneJSON?lat=${latitude}&lng=${longitude}&username=demo`;
-        const response = await fetch(url);
-        const data = await response.json();
-        return JSON.stringify(data);
-    }
-});
-
-// Currency Conversion Tool
-export const CurrencyConversionTool = new DynamicStructuredTool({
-    name: 'convert_currency',
-    description: 'Converts an amount from one currency to another.',
-    schema: z.object({
-        from: z.string(),
-        to: z.string(),
-        amount: z.number(),
-    }),
-    func: async ({ from, to, amount }) => {
-        const url = `https://api.exchangerate-api.com/v4/latest/${from}`;
-        const response = await fetch(url);
-        const data = await response.json();
-        const rate = data.rates[to];
-        const convertedAmount = amount * rate;
-        return JSON.stringify({
-            from,
-            to,
-            amount,
-            convertedAmount,
-            rate,
-        });
-    }
-});
-
-// IP Geolocation Tool
-export const IPGeolocationTool = new DynamicStructuredTool({
-    name: 'get_ip_geolocation',
-    description: 'Fetches geolocation information for a given IP address.',
-    schema: z.object({
-        ip: z.string(),
-    }),
-    func: async ({ ip }) => {
-        const url = `http://ip-api.com/json/${ip}`;
-        const response = await fetch(url);
-        const data = await response.json();
-        return JSON.stringify(data);
-    }
-});

package/src/proto/tools/space_mission_tools.ts

@@ -1,60 +0,0 @@
-// src/tools/space_mission_tools.ts
-import { DynamicStructuredTool } from '@langchain/core/tools';
-import { z } from 'zod';
-import fetch from 'node-fetch';
-import { createHash } from 'crypto';
-
-// NASA APOD (Astronomy Picture of the Day) Tool
-export const NasaAPODTool = new DynamicStructuredTool({
-    name: 'get_nasa_apod',
-    description: 'Fetches NASA\'s Astronomy Picture of the Day.',
-    schema: z.object({
-        date: z.string().optional(),
-    }),
-    func: async ({ date }) => {
-        const apiKey = process.env.NASA_API_KEY;
-        const url = `https://api.nasa.gov/planetary/apod?api_key=${apiKey}${date ? `&date=${date}` : ''}`;
-        const response = await fetch(url);
-        const data = await response.json();
-        return JSON.stringify(data);
-    }
-});
-
-// ISS Location Tool
-export const ISSLocationTool = new DynamicStructuredTool({
-    name: 'get_iss_location',
-    description: 'Fetches the current location of the International Space Station.',
-    schema: z.object({}),
-    func: async () => {
-        const url = 'http://api.open-notify.org/iss-now.json';
-        const response = await fetch(url);
-        const data = await response.json();
-        return JSON.stringify(data);
-    }
-});
-
-// Space Launch Schedule Tool
-export const LaunchScheduleTool = new DynamicStructuredTool({
-    name: 'get_launch_schedule',
-    description: 'Fetches upcoming space launches.',
-    schema: z.object({
-        limit: z.number().optional(),
-    }),
-    func: async ({ limit = 5 }) => {
-        const url = `https://ll.thespacedevs.com/2.2.0/launch/upcoming/?limit=${limit}`;
-        const response = await fetch(url);
-        const data = await response.json();
-        return JSON.stringify(data);
-    }
-});
-
-// Mission ID Generator Tool
-export const MissionIDGenerator = new DynamicStructuredTool({
-    name: 'generate_mission_id',
-    description: 'Generates a unique ID for space missions.',
-    schema: z.object({}),
-    func: async () => {
-        const uniqueID = createHash('sha256').update(Date.now().toString()).digest('hex');
-        return `MISSION-${uniqueID.substring(0, 8)}`;
-    }
-});

package/src/proto/vertexai.ts

@@ -1,54 +0,0 @@
-import { AgentExecutor , createToolCallingAgent } from 'langchain/agents';
-import { StructuredTool } from '@langchain/core/tools';
-import { BaseMessage } from '@langchain/core/messages';
-import { ChatPromptTemplate } from '@langchain/core/prompts';
-import { ChatVertexAI, ChatVertexAIInput } from '@langchain/google-vertexai';
-import { RunnableSequence, RunnablePassthrough } from '@langchain/core/runnables';
-
-type VertexAIToolCallingAgentInput = {
-  vertexAIConfig: ChatVertexAIInput;
-  tools: StructuredTool[];
-  chatHistory: BaseMessage[];
-};
-
-export function createVertexAgent({
-  vertexAIConfig,
-  tools,
-  chatHistory,
-}: VertexAIToolCallingAgentInput) {
-  // Define the LLM
-  const llm = new ChatVertexAI(vertexAIConfig);
-
-  // Define the prompt template
-  const prompt = ChatPromptTemplate.fromMessages([
-    ['system', 'You are a helpful assistant'],
-    ['human', '{input}'],
-    ['human', 'Current conversation:\n{chat_history}'],
-    ['human', 'Human: {input}'],
-    ['assistant', '{agent_scratchpad}'],
-  ]);
-
-  // Create the agent
-  const agent = createToolCallingAgent({
-    llm,
-    tools,
-    prompt,
-  });
-
-  // Create the agent executor
-  const agentExecutor = new AgentExecutor({
-    agent,
-    tools,
-  });
-
-  // Create the runnable
-  const runnable = RunnableSequence.from([
-    {
-      input: new RunnablePassthrough(),
-      chat_history: () => chatHistory,
-    },
-    agentExecutor,
-  ]);
-
-  return runnable;
-}