@librechat/agents-types 1.4.1

package/graph.ts

@@ -0,0 +1,126 @@
+// src/types/graph.ts
+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';
+// import type { RunnableConfig } from '@langchain/core/runnables';
+
+export type BaseGraphState = {
+  messages: BaseMessage[];
+  // [key: string]: unknown;
+};
+
+export type IState = BaseGraphState;
+
+// export interface IState extends BaseGraphState {
+//   instructions?: string;
+//   additional_instructions?: string;
+// }
+
+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/index.d.ts

@@ -0,0 +1 @@
+export * from '../src/types';

package/index.ts

@@ -0,0 +1,6 @@
+// src/types/index.ts
+export * from './graph';
+export * from './llm';
+export * from './run';
+export * from './stream';
+export * from './tools';

package/llm.ts

@@ -0,0 +1,38 @@
+// src/types/llm.ts
+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/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "@librechat/agents-types",
+  "version": "1.4.1",
+  "description": "Type definitions for @librechat/agents",
+  "types": "index.d.ts",
+  "scripts": {
+    "build": "tsc"
+  },
+  "peerDependencies": {
+    "@librechat/agents": "^1.4.1"
+  }
+}

package/run.ts

@@ -0,0 +1,56 @@
+// src/types/run.ts
+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';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+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/stream.ts

@@ -0,0 +1,174 @@
+// src/types/stream.ts
+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 = {
+  // id: string;
+  // object: 'thread.run.step'; // Updated from 'run.step' # missing
+  // created_at: number;
+  // run_id: string;
+  // assistant_id: string;
+  // thread_id: string;
+  type: StepTypes;
+  // status: 'in_progress' | 'completed' | 'failed' | 'cancelled'; // Add other possible status values if needed
+  // cancelled_at: number | null;
+  // completed_at: number | null;
+  // expires_at: number;
+  // failed_at: number | null;
+  // last_error: string | null;
+  id: string; // #new
+  runId?: string; // #new
+  index: number; // #new
+  stepIndex?: number; // #new
+  stepDetails: StepDetails;
+  usage: null | {
+    // Define usage structure if it's ever non-null
+    // prompt_tokens: number; // #new
+    // completion_tokens: number; // #new
+    // total_tokens: number; // #new
+  };
+};
+
+/**
+ * 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[]; // #new
+};
+
+export type ToolCallDelta = {
+  type: StepTypes.TOOL_CALLS;
+  tool_calls: ToolCallChunk[]; // #new
+};
+
+export type AgentToolCall = {
+  id: string; // #new
+  type: 'function'; // #new
+  function: {
+    name: string; // #new
+    arguments: string | object; // JSON string // #new
+  };
+} | 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;
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type MessageContentComplex = (MessageContentText | MessageContentImageUrl | (Record<string, any> & {
+  type?: 'text' | 'image_url' | string;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+}) | (Record<string, any> & {
+  type?: never;
+})) & {
+  tool_call_ids?: string[];
+};
+// #new

package/tools.ts

@@ -0,0 +1,31 @@
+// src/types/tools.ts
+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;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  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/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "lib": ["es6"],
+    "noImplicitAny": true,
+    "noImplicitThis": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "types": [],
+    "noEmit": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["index.d.ts"]
+}