@librechat/agents 1.4.0

package/dist/types/index.d.ts

@@ -0,0 +1,8 @@
+export * from './run';
+export * from './stream';
+export * from './events';
+export * from './messages';
+export * from './graphs';
+export * from './common';
+export * from './utils';
+export type * from './types';

package/dist/types/llm/providers.d.ts

@@ -0,0 +1,4 @@
+import type * as t from '@/types';
+import { Providers } from '@/common';
+export declare const llmProviders: Record<Providers, t.ChatModelConstructor>;
+export declare const getChatModelClass: (provider: Providers) => t.ChatModelConstructor;

package/dist/types/messages.d.ts

@@ -0,0 +1,10 @@
+import { AIMessageChunk, HumanMessage, ToolMessage, AIMessage, BaseMessage } from '@langchain/core/messages';
+import type * as t from '@/types';
+export declare function getConverseOverrideMessage({ userMessage, lastMessageX, lastMessageY }: {
+    userMessage: string[];
+    lastMessageX: AIMessageChunk;
+    lastMessageY: ToolMessage;
+}): HumanMessage;
+export declare function modifyDeltaProperties(obj?: AIMessageChunk): AIMessageChunk | undefined;
+export declare function formatAnthropicMessage(message: AIMessageChunk): AIMessage;
+export declare function convertMessagesToContent(messages: BaseMessage[]): t.MessageContentComplex[];

package/dist/types/prompts/collab.d.ts

@@ -0,0 +1 @@
+export declare const supervisorPrompt = "You are a supervisor tasked with managing a conversation between the\nfollowing workers: {members}. Given the following user request,\nrespond with the worker to act next. Each worker will perform a\ntask and respond with their results and status. Multiple workers can work at once, and they can use multiple tools at once. Each worker can run their tools multiple times per task. When finished,\nrespond with FINISH.";

package/dist/types/prompts/index.d.ts

@@ -0,0 +1,2 @@
+export * from './collab';
+export * from './taskmanager';

package/dist/types/prompts/taskmanager.d.ts

@@ -0,0 +1,41 @@
+export declare const taskManagerPrompt = "You are a Task Manager responsible for efficiently coordinating a team of specialized workers: {members}. Your PRIMARY and SOLE OBJECTIVE is to fulfill the user's specific request as quickly and effectively as possible.\n\nCRITICAL GUIDELINES:\n1. The user's request is your CHIEF CONCERN. Every action must directly contribute to fulfilling this request.\n2. Aim to complete the entire task in NO MORE THAN 2-3 TURNS, unless explicitly instructed otherwise.\n3. Eliminate all superfluous activity. Each task must be essential to achieving the user's goal.\n4. Assign no more than 5 tasks per turn, and only if absolutely necessary.\n5. Be concise and direct in your task assignments.\n6. End the process IMMEDIATELY once the user's request is fulfilled by setting 'end' to true and assigning no new tasks.\n\nYour responsibilities:\n1. Analyze the user's request and break it down into the minimum necessary subtasks.\n2. Assign these essential tasks to the most appropriate team members based on their skills and tools.\n3. Prioritize tasks to ensure the most efficient path to completion.\n4. Continuously evaluate if the user's request has been fully addressed.\n5. End the process IMMEDIATELY once the user's request is fulfilled.\n\nTask Assignment Guidelines:\n- Assign only the most crucial tasks required to meet the user's needs.\n- Multiple tasks can be assigned to the same team member if it improves efficiency.\n- Always specify the tool to use if applicable.\n- Consider task dependencies to minimize the number of turns.\n\nAfter each round:\n- Critically assess if the user's request has been fully addressed.\n- If more work is genuinely needed, assign only the most essential remaining tasks.\n- If the user's request has been fulfilled or can be fulfilled with the results at hand, set 'end' to true and assign no new tasks.\n\nREMEMBER: Your success is measured by how quickly and effectively you fulfill the user's request, not by the number of tasks assigned or turns taken. Excessive deliberation or unnecessary tasks are counterproductive. Focus solely on the user's needs and conclude the process as soon as those needs are met.";
+export declare const assignTasksFunctionDescription = "Assign the minimum necessary tasks to team members to fulfill the user's request as quickly as possible. Assign up to 5 tasks maximum per turn, only if absolutely necessary. Each task must specify the team member, a concise description, and the tool to use if applicable.";
+export declare const assignTasksFunctionParameters: {
+    type: string;
+    properties: {
+        tasks: {
+            type: string;
+            items: {
+                type: string;
+                properties: {
+                    member: {
+                        type: string;
+                        description: string;
+                    };
+                    description: {
+                        type: string;
+                        description: string;
+                    };
+                    tool: {
+                        type: string;
+                        description: string;
+                    };
+                };
+                required: string[];
+            };
+            description: string;
+        };
+    };
+    required: string[];
+};
+export declare const endProcessFunctionDescription = "End the process when the user's request has been fulfilled.";
+export declare const endProcessFunctionParameters: {
+    type: string;
+    properties: {
+        reason: {
+            type: string;
+            description: string;
+        };
+    };
+    required: string[];
+};

package/dist/types/run.d.ts

@@ -0,0 +1,21 @@
+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 { Providers } from '@/common';
+export declare class Run<T extends t.BaseGraphState> {
+    graphRunnable?: t.CompiledWorkflow<T, Partial<T>, string>;
+    private handlerRegistry;
+    private Graph;
+    provider: Providers | undefined;
+    run_id: string | undefined;
+    private constructor();
+    private createStandardGraph;
+    static create<T extends t.BaseGraphState>(config: t.RunConfig): Promise<Run<T>>;
+    getRunMessages(): BaseMessage[] | undefined;
+    processStream(inputs: t.IState, config: Partial<RunnableConfig> & {
+        version: 'v1' | 'v2';
+    }, clientCallbacks?: ClientCallbacks): Promise<MessageContentComplex[] | undefined>;
+    private createSystemCallback;
+    getCallbacks(clientCallbacks: ClientCallbacks): SystemCallbacks;
+}

package/dist/types/scripts/args.d.ts

@@ -0,0 +1,6 @@
+export declare function getArgs(): Promise<{
+    userName: string;
+    location: string;
+    provider: string;
+    currentDate: string;
+}>;

package/dist/types/scripts/cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/scripts/cli2.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/scripts/cli3.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/scripts/cli4.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/scripts/cli5.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/scripts/empty_input.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/stream.d.ts

@@ -0,0 +1,5 @@
+import type { Graph } from '@/graphs';
+import type * as t from '@/types';
+export declare class ChatModelStreamHandler implements t.EventHandler {
+    handle(event: string, data: t.StreamEventData, metadata?: Record<string, unknown>, graph?: Graph): void;
+}

package/dist/types/tools/ToolNode.d.ts

@@ -0,0 +1,15 @@
+import { END } from '@langchain/langgraph';
+import type { MessagesState } from '@langchain/langgraph/dist/graph/message';
+import type { BaseMessage } from '@langchain/core/messages';
+import type * as t from '@/types';
+import { RunnableCallable } from '@/utils';
+import { GraphNodeKeys } from '@/common';
+export declare class ToolNode<T extends BaseMessage[] | MessagesState> extends RunnableCallable<T, T> {
+    tools: t.GenericTool[];
+    private toolMap;
+    private loadRuntimeTools?;
+    handleToolErrors: boolean;
+    constructor({ tools, toolMap, name, tags, handleToolErrors, loadRuntimeTools, }: t.ToolNodeConstructorParams);
+    private run;
+}
+export declare function toolsCondition(state: BaseMessage[] | MessagesState): GraphNodeKeys.TOOLS | typeof END;

package/dist/types/tools/example.d.ts

@@ -0,0 +1,26 @@
+import { TavilySearchResults } from '@langchain/community/tools/tavily_search';
+import { DynamicStructuredTool } from '@langchain/core/tools';
+import { z } from 'zod';
+export declare const chartTool: DynamicStructuredTool<z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        value: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        value: number;
+        label: string;
+    }, {
+        value: number;
+        label: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    data: {
+        value: number;
+        label: string;
+    }[];
+}, {
+    data: {
+        value: number;
+        label: string;
+    }[];
+}>>;
+export declare const tavilyTool: TavilySearchResults;

package/dist/types/types/graph.d.ts

@@ -0,0 +1,108 @@
+import type { StateGraphArgs, StateGraph, CompiledStateGraph } from '@langchain/langgraph';
+import type { BaseMessage, AIMessageChunk } from '@langchain/core/messages';
+import type { ChatGenerationChunk } from '@langchain/core/outputs';
+import type { Graph } from '@/graphs';
+import { RunnableConfig } from '@langchain/core/runnables';
+export type BaseGraphState = {
+    messages: BaseMessage[];
+};
+export type IState = BaseGraphState;
+export interface EventHandler {
+    handle(event: string, data: StreamEventData, metadata?: Record<string, unknown>, graph?: Graph): void;
+}
+export type GraphStateChannels<T extends BaseGraphState> = StateGraphArgs<T>['channels'];
+export type Workflow<T extends BaseGraphState = BaseGraphState, U extends Partial<T> = Partial<T>, N extends string = string> = StateGraph<T, U, N>;
+export type CompiledWorkflow<T extends BaseGraphState = BaseGraphState, U extends Partial<T> = Partial<T>, N extends string = string> = CompiledStateGraph<T, U, N>;
+export type EventStreamCallbackHandlerInput = Parameters<CompiledWorkflow['streamEvents']>[2] extends Omit<infer T, 'autoClose'> ? T : never;
+export type StreamChunk = ChatGenerationChunk & {
+    message: AIMessageChunk;
+} | AIMessageChunk;
+/**
+ * Data associated with a StreamEvent.
+ */
+export type StreamEventData = {
+    /**
+     * The input passed to the runnable that generated the event.
+     * Inputs will sometimes be available at the *START* of the runnable, and
+     * sometimes at the *END* of the runnable.
+     * If a runnable is able to stream its inputs, then its input by definition
+     * won't be known until the *END* of the runnable when it has finished streaming
+     * its inputs.
+     */
+    input?: unknown;
+    /**
+     * The output of the runnable that generated the event.
+     * Outputs will only be available at the *END* of the runnable.
+     * For most runnables, this field can be inferred from the `chunk` field,
+     * though there might be some exceptions for special cased runnables (e.g., like
+     * chat models), which may return more information.
+     */
+    output?: unknown;
+    /**
+     * A streaming chunk from the output that generated the event.
+     * chunks support addition in general, and adding them up should result
+     * in the output of the runnable that generated the event.
+     */
+    chunk?: StreamChunk;
+    /**
+     * Runnable config for invoking other runnables within handlers.
+     */
+    config?: RunnableConfig;
+    /**
+     * Custom result from the runnable that generated the event.
+     */
+    result?: unknown;
+};
+/**
+ * A streaming event.
+ *
+ * Schema of a streaming event which is produced from the streamEvents method.
+ */
+export type StreamEvent = {
+    /**
+     * Event names are of the format: on_[runnable_type]_(start|stream|end).
+     *
+     * Runnable types are one of:
+     * - llm - used by non chat models
+     * - chat_model - used by chat models
+     * - prompt --  e.g., ChatPromptTemplate
+     * - tool -- LangChain tools
+     * - chain - most Runnables are of this type
+     *
+     * Further, the events are categorized as one of:
+     * - start - when the runnable starts
+     * - stream - when the runnable is streaming
+     * - end - when the runnable ends
+     *
+     * start, stream and end are associated with slightly different `data` payload.
+     *
+     * Please see the documentation for `EventData` for more details.
+     */
+    event: string;
+    /** The name of the runnable that generated the event. */
+    name: string;
+    /**
+     * An randomly generated ID to keep track of the execution of the given runnable.
+     *
+     * Each child runnable that gets invoked as part of the execution of a parent runnable
+     * is assigned its own unique ID.
+     */
+    run_id: string;
+    /**
+     * Tags associated with the runnable that generated this event.
+     * Tags are always inherited from parent runnables.
+     */
+    tags?: string[];
+    /** Metadata associated with the runnable that generated this event. */
+    metadata: Record<string, unknown>;
+    /**
+     * Event data.
+     *
+     * The contents of the event data depend on the event type.
+     */
+    data: StreamEventData;
+};
+export type GraphConfig = {
+    provider: string;
+    thread_id?: string;
+};

package/dist/types/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from './graph';
+export * from './llm';
+export * from './run';
+export * from './stream';
+export * from './tools';

package/dist/types/types/llm.d.ts

@@ -0,0 +1,25 @@
+import { ChatOpenAI } from '@langchain/openai';
+import { ChatAnthropic } from '@langchain/anthropic';
+import { ChatMistralAI } from '@langchain/mistralai';
+import { ChatBedrockConverse } from '@langchain/aws';
+import { ChatVertexAI } from '@langchain/google-vertexai';
+import { BedrockChat, BedrockChatFields } from '@langchain/community/chat_models/bedrock/web';
+import type { ChatVertexAIInput } from '@langchain/google-vertexai';
+import type { ChatBedrockConverseInput } from '@langchain/aws';
+import type { ChatMistralAIInput } from '@langchain/mistralai';
+import type { AnthropicInput } from '@langchain/anthropic';
+import type { OpenAIInput } from '@langchain/openai';
+import { Providers } from '@/common';
+export type OpenAIClientOptions = Partial<OpenAIInput>;
+export type AnthropicClientOptions = Partial<AnthropicInput>;
+export type MistralAIClientOptions = Partial<ChatMistralAIInput>;
+export type VertexAIClientOptions = Partial<ChatVertexAIInput>;
+export type BedrockClientOptions = Partial<BedrockChatFields>;
+export type BedrockConverseClientOptions = Partial<ChatBedrockConverseInput>;
+export type ClientOptions = OpenAIClientOptions | AnthropicClientOptions | MistralAIClientOptions | VertexAIClientOptions | BedrockClientOptions | BedrockConverseClientOptions;
+export type ChatModel = typeof ChatAnthropic | typeof ChatOpenAI | typeof ChatMistralAI | typeof ChatVertexAI | typeof BedrockChat | typeof ChatBedrockConverse;
+export type LLMConfig = {
+    provider: Providers;
+} & ClientOptions;
+export type ChatModelInstance = ChatOpenAI | ChatAnthropic | ChatMistralAI | ChatVertexAI | BedrockChat | ChatBedrockConverse;
+export type ChatModelConstructor = new (config: ClientOptions) => ChatModelInstance;

package/dist/types/types/run.d.ts

@@ -0,0 +1,53 @@
+import type * as z from 'zod';
+import type { BaseMessage } from '@langchain/core/messages';
+import type { StructuredTool } from '@langchain/core/tools';
+import type * as e from '@/common/enum';
+import type * as g from '@/types/graph';
+import type * as t from '@/types/tools';
+import type * as l from '@/types/llm';
+export type ZodObjectAny = z.ZodObject<any, any, any, any>;
+export type StandardGraphConfig = {
+    runId?: string;
+    type?: 'standard';
+    provider?: e.Providers;
+    instructions?: string;
+    llmConfig: l.LLMConfig;
+    tools?: t.GenericTool[];
+    toolMap?: t.ToolMap;
+    additional_instructions?: string;
+    clientOptions?: Record<string, unknown>;
+};
+export interface AgentStateChannels {
+    messages: BaseMessage[];
+    next: string;
+    [key: string]: unknown;
+    instructions?: string;
+    additional_instructions?: string;
+}
+export interface Member {
+    name: string;
+    systemPrompt: string;
+    tools: StructuredTool[];
+    llmConfig: l.LLMConfig;
+}
+export type CollaborativeGraphConfig = {
+    type: 'collaborative';
+    members: Member[];
+    supervisorConfig: {
+        systemPrompt?: string;
+        llmConfig: l.LLMConfig;
+    };
+};
+export type TaskManagerGraphConfig = {
+    type: 'taskmanager';
+    members: Member[];
+    supervisorConfig: {
+        systemPrompt?: string;
+        llmConfig: l.LLMConfig;
+    };
+};
+export type RunConfig = {
+    graphConfig: StandardGraphConfig | CollaborativeGraphConfig | TaskManagerGraphConfig;
+    customHandlers?: Record<string, g.EventHandler>;
+    runId?: string;
+};

package/dist/types/types/stream.d.ts

@@ -0,0 +1,134 @@
+import type { MessageContentImageUrl, MessageContentText, ToolMessage } from '@langchain/core/messages';
+import type { ToolCall, ToolCallChunk } from '@langchain/core/messages/tool';
+import { StepTypes } from '@/common/enum';
+/** Event names are of the format: on_[runnable_type]_(start|stream|end).
+
+Runnable types are one of:
+
+llm - used by non chat models
+chat_model - used by chat models
+prompt -- e.g., ChatPromptTemplate
+tool -- LangChain tools
+chain - most Runnables are of this type
+Further, the events are categorized as one of:
+
+start - when the runnable starts
+stream - when the runnable is streaming
+end - when the runnable ends
+start, stream and end are associated with slightly different data payload.
+
+Please see the documentation for EventData for more details. */
+export type EventName = string;
+export type RunStep = {
+    type: StepTypes;
+    id: string;
+    runId?: string;
+    index: number;
+    stepIndex?: number;
+    stepDetails: StepDetails;
+    usage: null | {};
+};
+/**
+ * Represents a run step delta i.e. any changed fields on a run step during
+ * streaming.
+ */
+export interface RunStepDeltaEvent {
+    /**
+     * The identifier of the run step, which can be referenced in API endpoints.
+     */
+    id: string;
+    /**
+     * The delta containing the fields that have changed on the run step.
+     */
+    delta: ToolCallDelta;
+}
+export type StepDetails = MessageCreationDetails | ToolCallsDetails;
+export type StepCompleted = ToolCallCompleted;
+export type MessageCreationDetails = {
+    type: StepTypes.MESSAGE_CREATION;
+    message_creation: {
+        message_id: string;
+    };
+};
+export type ToolEndData = {
+    input: string | Record<string, unknown>;
+    output: ToolMessage;
+};
+export type ProcessedToolCall = {
+    name: string;
+    args: string | Record<string, unknown>;
+    id: string;
+    output: string;
+    progress: number;
+};
+export type ProcessedContent = {
+    type: ContentType;
+    text?: string;
+    tool_call?: ProcessedToolCall;
+};
+export type ToolCallCompleted = {
+    type: 'tool_call';
+    tool_call: ProcessedToolCall;
+};
+export type ToolCompleteEvent = ToolCallCompleted & {
+    /** The Step Id of the Tool Call */
+    id: string;
+    /** The content index of the tool call */
+    index: number;
+    type: 'tool_call';
+};
+export type ToolCallsDetails = {
+    type: StepTypes.TOOL_CALLS;
+    tool_calls: AgentToolCall[];
+};
+export type ToolCallDelta = {
+    type: StepTypes.TOOL_CALLS;
+    tool_calls: ToolCallChunk[];
+};
+export type AgentToolCall = {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string | object;
+    };
+} | ToolCall;
+export interface ExtendedMessageContent {
+    type?: string;
+    text?: string;
+    input?: string;
+    index?: number;
+    id?: string;
+    name?: string;
+}
+/**
+ * Represents a message delta i.e. any changed fields on a message during
+ * streaming.
+ */
+export interface MessageDeltaEvent {
+    /**
+     * The identifier of the message, which can be referenced in API endpoints.
+     */
+    id: string;
+    /**
+     * The delta containing the fields that have changed on the Message.
+     */
+    delta: MessageDelta;
+}
+/**
+ * The delta containing the fields that have changed on the Message.
+ */
+export interface MessageDelta {
+    /**
+     * The content of the message in array of text and/or images.
+     */
+    content?: MessageContentComplex[];
+}
+export type ContentType = 'text' | 'image_url' | 'tool_call' | string;
+export type MessageContentComplex = (MessageContentText | MessageContentImageUrl | (Record<string, any> & {
+    type?: 'text' | 'image_url' | string;
+}) | (Record<string, any> & {
+    type?: never;
+})) & {
+    tool_call_ids?: string[];
+};

package/dist/types/types/tools.d.ts

@@ -0,0 +1,24 @@
+import type { RunnableToolLike } from '@langchain/core/runnables';
+import type { StructuredToolInterface } from '@langchain/core/tools';
+import type { ToolCall } from '@langchain/core/messages/tool';
+/** Replacement type for `import type { ToolCall } from '@langchain/core/messages/tool'` in order to have stringified args typed */
+export type CustomToolCall = {
+    name: string;
+    args: string | Record<string, any>;
+    id?: string;
+    type?: 'tool_call';
+};
+export type GenericTool = StructuredToolInterface | RunnableToolLike;
+export type ToolMap = Map<string, GenericTool>;
+export type ToolRefs = {
+    tools: GenericTool[];
+    toolMap?: ToolMap;
+};
+export type ToolRefGenerator = (tool_calls: ToolCall[]) => ToolRefs;
+export type ToolNodeOptions = {
+    name?: string;
+    tags?: string[];
+    handleToolErrors?: boolean;
+    loadRuntimeTools?: ToolRefGenerator;
+};
+export type ToolNodeConstructorParams = ToolRefs & ToolNodeOptions;

package/dist/types/utils/graph.d.ts

@@ -0,0 +1,2 @@
+export declare const resetIfNotEmpty: <T>(value: T, resetValue: T) => T;
+export declare const joinKeys: (args: (string | number | undefined)[]) => string;

package/dist/types/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './graph';
+export * from './run';

package/dist/types/utils/llmConfig.d.ts

@@ -0,0 +1,2 @@
+import type * as t from '@/types';
+export declare function getLLMConfig(provider: string): t.LLMConfig;

package/dist/types/utils/logging.d.ts

@@ -0,0 +1 @@
+export declare function setupLogging(logFileName: string): void;

package/dist/types/utils/run.d.ts

@@ -0,0 +1,20 @@
+import { CallbackManagerForChainRun } from '@langchain/core/callbacks/manager';
+import { Runnable, RunnableConfig } from '@langchain/core/runnables';
+export interface RunnableCallableArgs extends Partial<any> {
+    name?: string;
+    func: (...args: any[]) => any;
+    tags?: string[];
+    trace?: boolean;
+    recurse?: boolean;
+}
+export declare class RunnableCallable<I = unknown, O = unknown> extends Runnable<I, O> {
+    lc_namespace: string[];
+    func: (...args: any[]) => any;
+    tags?: string[];
+    config?: RunnableConfig;
+    trace: boolean;
+    recurse: boolean;
+    constructor(fields: RunnableCallableArgs);
+    protected _tracedInvoke(input: I, config?: Partial<RunnableConfig>, runManager?: CallbackManagerForChainRun): Promise<O>;
+    invoke(input: any, options?: Partial<RunnableConfig> | undefined): Promise<any>;
+}