@librechat/agents 3.0.0 → 3.0.2

package/src/proto/example_new.ts

@@ -1,68 +0,0 @@
-import dotenv from 'dotenv';
-import { ToolNode } from '@langchain/langgraph/prebuilt';
-import { TavilySearchResults } from '@langchain/community/tools/tavily_search';
-import { ChatAnthropic } from '@langchain/anthropic';
-import { AIMessage, BaseMessage } from '@langchain/core/messages';
-import { SqliteSaver } from '@langchain/langgraph/checkpoint/sqlite';
-import { START, END, MessageGraph } from '@langchain/langgraph';
-dotenv.config();
-
-// Define the function that determines whether to continue or not
-/* @ts-ignore */
-function shouldContinue(messages) {
-    const lastMessage = messages[messages.length - 1];
-    // If there is no function call, then we finish
-    if (!(lastMessage instanceof AIMessage && lastMessage.tool_calls)) {
-        return END;
-    } else {
-        return 'action';
-    }
-}
-
-// Define tools and model
-const tools = [new TavilySearchResults({ maxResults: 1 })];
-const model = new ChatAnthropic({ model: 'claude-3-haiku-20240307' }).bindTools(tools);
-
-// Define the workflow
-const workflow = new MessageGraph()
-    .addNode('agent', model)
-/* @ts-ignore */
-    .addNode('action', new ToolNode(tools));
-
-workflow.addEdge(START, 'agent');
-workflow.addConditionalEdges('agent', shouldContinue);
-workflow.addEdge('action', 'agent');
-
-// Set up memory
-const memory = SqliteSaver.fromConnString(':memory:');
-
-// Compile the app
-const app = workflow.compile({ checkpointer: memory, interruptBefore: ['action'] });
-
-// Run the graph
-async function runGraph() {
-    const thread = { configurable: { thread_id: '4' } };
-
-    console.log('Initial run:');
-    for await (const event of await app.stream(
-        [['user', 'what is the weather in sf currently']],
-        { ...thread, streamMode: 'values' }
-    )) {
-        for (const v of event.values()) {
-            console.log(v);
-        }
-    }
-
-    console.log('\nResuming after interruption:');
-    for await (const event of await app.stream(null, {
-        ...thread,
-        streamMode: 'values',
-    })) {
-        for (const v of event.values()) {
-            console.log(v);
-        }
-    }
-}
-
-// Execute the graph
-runGraph().catch(console.error);

package/src/proto/example_old.ts

@@ -1,201 +0,0 @@
-import fs from 'fs/promises';
-import { pull } from 'langchain/hub';
-import { ChatAnthropic } from '@langchain/anthropic';
-import type { ChatPromptTemplate } from '@langchain/core/prompts';
-import { AgentExecutor, createToolCallingAgent, AgentStep } from 'langchain/agents';
-import { TavilySearchResults } from '@langchain/community/tools/tavily_search';
-import type { RunLogPatch } from '@langchain/core/tracers/log_stream';
-import dotenv from 'dotenv';
-
-type ExtractedJSONPatchOperation = Pick<RunLogPatch, 'ops'>;
-type OperationType = ExtractedJSONPatchOperation extends { ops: (infer T)[] } ? T : never;
-
-// Load environment variables from .env file
-dotenv.config();
-
-// Define the tools the agent will have access to.
-const tools = [new TavilySearchResults({})];
-
-const llm = new ChatAnthropic({
-    model: 'claude-3-haiku-20240307',
-    streaming: true,
-});
-
-// Get the prompt to use - you can modify this!
-// If you want to see the prompt in full, you can at:
-// https://smith.langchain.com/hub/hwchase17/openai-functions-agent
-const prompt = await pull<ChatPromptTemplate>(
-    'hwchase17/openai-functions-agent'
-);
-
-const agent = await createToolCallingAgent({
-    llm,
-    tools,
-    prompt,
-});
-
-const agentExecutor = new AgentExecutor({
-    agent,
-    tools,
-});
-
-const logStream = await agentExecutor.streamLog({
-    input: 'what are the current US election polls 2024. today is 7/6/24',
-});
-
-const finalState: RunLogPatch[] = [];
-const outputs: RunLogPatch[] = [];
-let accumulatedOutput = '';
-let accumulatedArguments = '';
-
-let functionName: string | undefined = undefined;
-
-function processStreamedOutput(op: any) {
-    let output = '';
-    if (op.value.text !== undefined) {
-        output += op.value.text;
-    }
-    if (op.value.message && op.value.message.kwargs) {
-        const kwargs = op.value.message.kwargs;
-        if (kwargs.content) {
-            output += kwargs.content;
-        }
-    }
-    if (output) {
-        accumulatedOutput += output;
-        process.stdout.write(output);
-    }
-}
-
-// A helper function to handle the event pattern for logged arguments
-function handleLoggedArgument(loggedArgument: any) {
-    if (loggedArgument.value?.message?.additional_kwargs?.function_call) {
-        const functionCall = loggedArgument.value.message.additional_kwargs.function_call;
-
-        if (functionCall.name) {
-            functionName = functionCall.name;
-            process.stdout.write(`Logged Function Name:
-        ${JSON.stringify(functionCall, null, 2)}
-      `);
-        }
-
-        if (functionCall.arguments) {
-            accumulatedArguments += functionCall.arguments;
-            // Print the part of the argument as it comes
-            // process.stdout.write(`Logged Argument: { "arguments": "${functionCall.arguments}" }\n`);
-            process.stdout.write(`Logged Argument:\n${JSON.stringify(functionCall, null, 2)}`);
-        }
-
-        // Check if the full arguments string has been accumulated
-        if (accumulatedArguments.startsWith('{') && accumulatedArguments.endsWith('}')) {
-            // Build the final logged argument string
-            const completeArguments = accumulatedArguments;
-            const namePart = functionName ? `"name": "${functionName}", ` : '';
-
-            console.log(`\nLogged Argument: {\n  ${namePart}"arguments": ${completeArguments}\n}\n`);
-
-            // Reset accumulators
-            accumulatedArguments = '';
-            functionName = undefined;
-        }
-    }
-}
-
-for await (const chunk of logStream) {
-    finalState.push(chunk);
-    outputs.push(chunk);
-
-    if (!chunk.ops) continue;
-
-    for (const op of chunk.ops) {
-        if (isStreamedOutput(op)) {
-            processStreamedOutput(op);
-            if (hasFunctionCall(op)) {
-                handleLoggedArgument(op);
-            }
-        } else if (isFinalOutput(op)) {
-            printFinalOutput(op);
-        }
-    }
-}
-
-function isStreamedOutput(op: OperationType) {
-    return op.op === 'add' && (
-        op.path.includes('/streamed_output/-') ||
-    op.path.includes('/streamed_output_str/-')
-    );
-}
-
-function hasFunctionCall(op: OperationType) {
-    return (op as any)?.['value']?.message?.additional_kwargs?.function_call;
-}
-
-function isFinalOutput(op: OperationType) {
-    return op.op === 'add' &&
-         op.value?.output &&
-         op.path?.startsWith('/logs/') &&
-         op.path?.endsWith('final_output') &&
-         !op.path?.includes('Runnable');
-}
-
-function printFinalOutput(op: OperationType) {
-    process.stdout.write(JSON.stringify(op, null, 2));
-    process.stdout.write(`
-
-########################_START_##########################
-        ${JSON.stringify((op as any)?.['value']?.output, null, 2)}
-########################__END__##########################
-
-        `);
-}
-
-// Define types for the final output structure
-interface FinalOutput {
-  id: string;
-  streamed_output: Array<{
-    intermediateSteps?: AgentStep[];
-    output?: string;
-  }>;
-  final_output?: {
-    output: string;
-  };
-  logs: Record<string, any>;
-}
-
-// Process finalState to create FinalOutput
-const finalOutput: FinalOutput = {
-    id: '',
-    streamed_output: [],
-    logs: {},
-};
-
-for (const patch of finalState) {
-    if (patch.ops) {
-        for (const op of patch.ops) {
-            if (op.op === 'add' || op.op === 'replace') {
-                if (op.path === '/id') {
-                    finalOutput.id = op.value;
-                } else if (op.path === '/streamed_output/-') {
-                    finalOutput.streamed_output.push(op.value);
-                } else if (op.path === '/final_output') {
-                    finalOutput.final_output = op.value;
-                } else if (op.path.startsWith('/logs/')) {
-                    const logKey = op.path.split('/')[2];
-                    finalOutput.logs[logKey] = op.value;
-                }
-            }
-        }
-    }
-}
-
-// Save outputs to a JSON file
-await fs.writeFile('outputs.json', JSON.stringify(outputs, null, 2));
-console.log('\n\nOutputs have been saved to outputs.json');
-
-// Save the final state separately
-await fs.writeFile('final_output.json', JSON.stringify(finalOutput, null, 2));
-console.log('\n\nFinal output has been saved to final_output.json');
-
-// Save the cleaned-up accumulated output
-await fs.writeFile('cleaned_output.txt', accumulatedOutput);
-console.log('\n\nCleaned output has been saved to cleaned_output.txt');

package/src/proto/example_test.ts

@@ -1,152 +0,0 @@
-import { BaseMessage, HumanMessage } from "@langchain/core/messages";
-import { ChatAnthropic } from "@langchain/anthropic";
-import { ChatPromptTemplate } from "@langchain/core/prompts";
-import { TavilySearchResults } from '@langchain/community/tools/tavily_search';
-import { RunnableConfig } from "@langchain/core/runnables";
-import {
-  END,
-  // MemorySaver,
-  START,
-  StateGraph,
-  StateGraphArgs,
-} from "@langchain/langgraph";
-
-interface IState {
-  messages: BaseMessage[];
-  userInfo: string;
-}
-
-async function main() {
-
-const graphState: StateGraphArgs<IState>["channels"] = {
-  messages: {
-    value: (x: BaseMessage[], y: BaseMessage[]) => x.concat(y),
-    default: () => [],
-  },
-  userInfo: {
-    value: (x?: string, y?: string) => {
-      return y ? y : x ? x : "N/A";
-    },
-    default: () => "N/A",
-  },
-};
-
-const promptTemplate = ChatPromptTemplate.fromMessages([
-  ["system", "You are a helpful assistant.\n\n## User Info:\n{userInfo}"],
-  ["placeholder", "{messages}"],
-]);
-
-const initializeModel = (bindTools = false) => {
-  const model = new ChatAnthropic({
-    // model: "claude-3-haiku-20240307",
-    model: 'claude-3-5-sonnet-20240620'
-  })
-  if (bindTools) {
-    return model.bindTools([new TavilySearchResults()]);
-  }
-  return model;
-}
-
-const callModel = async (
-  state: { messages: BaseMessage[]; userInfo: string },
-  config?: RunnableConfig,
-) => {
-  const { messages, userInfo } = state;
-  
-  /*
-
-  This correctly streams tokens when 
-  we don't bind tools, but if we do, it fails.
-
-  */
-  const model = initializeModel(true);
-  // const model = initializeModel();
-  const chain = promptTemplate.pipe(model);
-  const response = await chain.invoke(
-    {
-      messages,
-      userInfo,
-    },
-    config,
-  );
-  return { messages: [response] };
-};
-
-const fetchUserInformation = async (
-  _: { messages: BaseMessage[] },
-  config?: RunnableConfig,
-) => {
-  const userDB = {
-    user1: {
-      name: "John Doe",
-      email: "jod@langchain.ai",
-      phone: "+1234567890",
-    },
-    user2: {
-      name: "Jane Doe",
-      email: "jad@langchain.ai",
-      phone: "+0987654321",
-    },
-  };
-  const userId = config?.configurable?.user;
-  if (userId) {
-    const user = userDB[userId as keyof typeof userDB];
-    if (user) {
-      return {
-        userInfo:
-          `Name: ${user.name}\nEmail: ${user.email}\nPhone: ${user.phone}`,
-      };
-    }
-  }
-  return { userInfo: "N/A" };
-};
-
-const workflow = new StateGraph({
-  channels: graphState,
-})
-  .addNode("fetchUserInfo", fetchUserInformation)
-  .addNode("agent", callModel)
-  .addEdge(START, "fetchUserInfo")
-  .addEdge("fetchUserInfo", "agent")
-  .addEdge("agent", END);
-
-// Here we only save in-memory
-// let memory = new MemorySaver();
-// const graph = workflow.compile({ checkpointer: memory });
-const graph = workflow.compile();
-
-
-const config = {
-  configurable: {
-    user: "user1",
-  },
-};
-const inputs = {
-  messages: [new HumanMessage("Could you remind me of my email?")],
-};
-
-  const stream = graph.streamEvents(inputs, {
-    ...config,
-    version: "v2",
-    streamMode: "values",
-  });
-for await (const { event, data } of stream) {
-
-  if (event === "on_chat_model_start") {
-    console.log('=======CHAT_MODEL_START=======');
-    console.dir(data, { depth: null });
-  } else if (event === "on_chat_model_stream") {
-    console.dir(data, { depth: null });
-  } else if (event === "on_chat_model_end") {
-    console.log('=======CHAT_MODEL_END=======');
-    console.dir(data, { depth: null });
-  } else {
-    console.log(event);
-  }
-}
-}
-
-main().catch((err) => {
-  console.error(err);
-  process.exit(1);
-});

package/src/proto/example_test_anthropic.ts

@@ -1,100 +0,0 @@
-import { BaseMessage, HumanMessage, AIMessageChunk, AIMessage } from "@langchain/core/messages";
-import { ChatAnthropic } from "@langchain/anthropic";
-import { ChatPromptTemplate } from "@langchain/core/prompts";
-import { TavilySearchResults } from '@langchain/community/tools/tavily_search';
-import { RunnableConfig } from "@langchain/core/runnables";
-import { ToolNode } from '@langchain/langgraph/prebuilt';
-import {
-  END,
-  START,
-  StateGraph,
-  StateGraphArgs,
-} from "@langchain/langgraph";
-
-interface IState {
-  messages: BaseMessage[];
-}
-
-async function main() {
-  const graphState: StateGraphArgs<IState>["channels"] = {
-    messages: {
-      value: (x: BaseMessage[], y: BaseMessage[]) => x.concat(y),
-      default: () => [],
-    },
-  };
-
-  const promptTemplate = ChatPromptTemplate.fromMessages([
-    ["system", "You are a helpful assistant."],
-    ["placeholder", "{messages}"],
-  ]);
-
-  const initializeModel = (bindTools = false) => {
-    const model = new ChatAnthropic({
-      model: 'claude-3-5-sonnet-20240620'
-    })
-    if (bindTools) {
-      return model.bindTools([new TavilySearchResults()]);
-    }
-    return model;
-  }
-  
-  const callModel = async (
-    state: { messages: BaseMessage[] },
-    config?: RunnableConfig,
-  ) => {
-    const { messages } = state;
-    
-    const model = initializeModel(true);
-    const chain = promptTemplate.pipe(model);
-    const response = await chain.invoke(
-      {
-        messages,
-      },
-      config,
-    );
-    return { messages: [response] };
-  };
-
-  const tools = [new TavilySearchResults()];
-  const toolNode = new ToolNode<IState>(tools);
-
-  const routeMessage = (state: IState): string => {
-    const lastMessage = state.messages[state.messages.length - 1] as AIMessage;
-    if (!lastMessage?.tool_calls?.length) {
-      return END;
-    }
-    return "tools";
-  };
-
-  const workflow = new StateGraph({
-    channels: graphState,
-  })
-    .addNode("agent", callModel)
-    .addNode("tools", toolNode)
-    .addEdge(START, "agent")
-    .addConditionalEdges("agent", routeMessage)
-    .addEdge("tools", "agent");
-
-  const graph = workflow.compile();
-
-  const inputs = {
-    messages: [new HumanMessage("Could you search the internet for information about LangChain?")],
-  };
-
-  const stream = graph.streamEvents(inputs, {
-    version: "v2",
-    streamMode: "values",
-  });
-
-  for await (const { event, data } of stream) {
-    console.log(event)
-    if (event === "on_chat_model_stream") {
-      console.log(data);
-    }
-  }
-}
-
-main().catch((err) => {
-  console.error(err);
-  process.exit(1);
-});