@librechat/agents 2.4.322 → 3.0.0-rc1

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

@@ -1,25 +1,77 @@
-import type { StateGraphArgs, StateGraph, CompiledStateGraph } from '@langchain/langgraph';
-import type { BaseMessage, AIMessageChunk } from '@langchain/core/messages';
+import type { START, StateType, UpdateType, StateGraph, StateGraphArgs, StateDefinition, CompiledStateGraph, BinaryOperatorAggregate } from '@langchain/langgraph';
+import type { BindToolsInput } from '@langchain/core/language_models/chat_models';
+import type { BaseMessage, AIMessageChunk, SystemMessage } from '@langchain/core/messages';
+import type { RunnableConfig, Runnable } from '@langchain/core/runnables';
 import type { ChatGenerationChunk } from '@langchain/core/outputs';
-import type { RunnableConfig } from '@langchain/core/runnables';
-import type { ToolMap, GenericTool } from '@/types/tools';
+import type { GoogleAIToolType } from '@langchain/google-common';
+import type { ToolMap, ToolEndEvent, GenericTool } from '@/types/tools';
+import type { Providers, Callback, GraphNodeKeys } from '@/common';
+import type { StandardGraph, MultiAgentGraph } from '@/graphs';
 import type { ClientOptions } from '@/types/llm';
-import type { Providers } from '@/common';
-import type { Graph } from '@/graphs';
+import type { RunStep, RunStepDeltaEvent, MessageDeltaEvent, ReasoningDeltaEvent } from '@/types/stream';
+import type { TokenCounter } from '@/types/run';
+/** Interface for bound model with stream and invoke methods */
+export interface ChatModel {
+    stream?: (messages: BaseMessage[], config?: RunnableConfig) => Promise<AsyncIterable<AIMessageChunk>>;
+    invoke: (messages: BaseMessage[], config?: RunnableConfig) => Promise<AIMessageChunk>;
+}
+export type GraphNode = GraphNodeKeys | typeof START;
+export type ClientCallback<T extends unknown[]> = (graph: StandardGraph, ...args: T) => void;
+export type ClientCallbacks = {
+    [Callback.TOOL_ERROR]?: ClientCallback<[Error, string]>;
+    [Callback.TOOL_START]?: ClientCallback<unknown[]>;
+    [Callback.TOOL_END]?: ClientCallback<unknown[]>;
+};
+export type SystemCallbacks = {
+    [K in keyof ClientCallbacks]: ClientCallbacks[K] extends ClientCallback<infer Args> ? (...args: Args) => void : never;
+};
 export type BaseGraphState = {
     messages: BaseMessage[];
 };
 export type IState = BaseGraphState;
 export interface EventHandler {
-    handle(event: string, data: StreamEventData | ModelEndData, metadata?: Record<string, unknown>, graph?: Graph): void;
+    handle(event: string, data: StreamEventData | ModelEndData | RunStep | RunStepDeltaEvent | MessageDeltaEvent | ReasoningDeltaEvent | {
+        result: ToolEndEvent;
+    }, metadata?: Record<string, unknown>, graph?: StandardGraph | MultiAgentGraph): void | Promise<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 CompiledStateWorkflow = CompiledStateGraph<StateType<{
+    messages: BinaryOperatorAggregate<BaseMessage[], BaseMessage[]>;
+}>, UpdateType<{
+    messages: BinaryOperatorAggregate<BaseMessage[], BaseMessage[]>;
+}>, string, {
+    messages: BinaryOperatorAggregate<BaseMessage[], BaseMessage[]>;
+}, {
+    messages: BinaryOperatorAggregate<BaseMessage[], BaseMessage[]>;
+}, StateDefinition>;
+export type CompiledAgentWorfklow = CompiledStateGraph<{
+    messages: BaseMessage[];
+}, {
+    messages?: BaseMessage[] | undefined;
+}, '__start__' | `agent=${string}` | `tools=${string}`, {
+    messages: BinaryOperatorAggregate<BaseMessage[], BaseMessage[]>;
+}, {
+    messages: BinaryOperatorAggregate<BaseMessage[], BaseMessage[]>;
+}, StateDefinition, {
+    [x: `agent=${string}`]: Partial<BaseGraphState>;
+    [x: `tools=${string}`]: any;
+}>;
+export type SystemRunnable = Runnable<BaseMessage[], (BaseMessage | SystemMessage)[], RunnableConfig<Record<string, unknown>>> | undefined;
+/**
+ * Optional compile options passed to workflow.compile().
+ * These are intentionally untyped to avoid coupling to library internals.
+ */
+export type CompileOptions = {
+    checkpointer?: any;
+    interruptBefore?: string[];
+    interruptAfter?: string[];
+};
 export type EventStreamCallbackHandlerInput = Parameters<CompiledWorkflow['streamEvents']>[2] extends Omit<infer T, 'autoClose'> ? T : never;
-export type StreamChunk = ChatGenerationChunk & {
+export type StreamChunk = (ChatGenerationChunk & {
     message: AIMessageChunk;
-} | AIMessageChunk;
+}) | AIMessageChunk;
 /**
  * Data associated with a StreamEvent.
  */
@@ -55,6 +107,10 @@ export type StreamEventData = {
      * Custom result from the runnable that generated the event.
      */
     result?: unknown;
+    /**
+     * Custom field to indicate the event was manually emitted, and may have been handled already
+     */
+    emitted?: boolean;
 };
 /**
  * A streaming event.
@@ -117,19 +173,43 @@ export type PartMetadata = {
     action?: boolean;
     output?: string;
 };
-export type ModelEndData = StreamEventData & {
+export type ModelEndData = (StreamEventData & {
     output: AIMessageChunk | undefined;
-} | undefined;
+}) | undefined;
+export type GraphTools = GenericTool[] | BindToolsInput[] | GoogleAIToolType[];
 export type StandardGraphInput = {
     runId?: string;
+    signal?: AbortSignal;
+    agents: AgentInputs[];
+    tokenCounter?: TokenCounter;
+    indexTokenCountMap?: Record<string, number>;
+};
+export type GraphEdge = {
+    /** Use a list for multiple sources */
+    from: string | string[];
+    /** Use a list for multiple destinations */
+    to: string | string[];
+    description?: string;
+    /** Can return boolean or specific destination(s) */
+    condition?: (state: BaseGraphState) => boolean | string | string[];
+    /** 'handoff' creates tools for dynamic routing, 'direct' creates direct edges, which also allow parallel execution */
+    edgeType?: 'handoff' | 'direct';
+    /** Optional prompt to add when transitioning through this edge */
+    promptInstructions?: string | ((messages: BaseMessage[]) => string | undefined);
+};
+export type MultiAgentGraphInput = StandardGraphInput & {
+    edges: GraphEdge[];
+};
+export interface AgentInputs {
+    agentId: string;
     toolEnd?: boolean;
     toolMap?: ToolMap;
+    tools?: GraphTools;
     provider: Providers;
-    signal?: AbortSignal;
     instructions?: string;
     streamBuffer?: number;
-    tools?: GenericTool[];
-    clientOptions: ClientOptions;
+    maxContextTokens?: number;
+    clientOptions?: ClientOptions;
     additional_instructions?: string;
     reasoningKey?: 'reasoning_content' | 'reasoning';
-};
+}

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

@@ -1,27 +1,29 @@
 import { ChatOllama } from '@langchain/ollama';
-import { ChatAnthropic } from '@langchain/anthropic';
 import { ChatMistralAI } from '@langchain/mistralai';
 import { ChatBedrockConverse } from '@langchain/aws';
-import { ChatVertexAI } from '@langchain/google-vertexai';
-import { ChatGoogleGenerativeAI } from '@langchain/google-genai';
 import { BedrockChat } from '@langchain/community/chat_models/bedrock/web';
 import type { BindToolsInput, BaseChatModelParams } from '@langchain/core/language_models/chat_models';
 import type { OpenAIChatInput, ChatOpenAIFields, AzureOpenAIInput, ClientOptions as OAIClientOptions } from '@langchain/openai';
 import type { BedrockChatFields } from '@langchain/community/chat_models/bedrock/web';
 import type { GoogleGenerativeAIChatInput } from '@langchain/google-genai';
+import type { GeminiGenerationConfig } from '@langchain/google-common';
 import type { ChatVertexAIInput } from '@langchain/google-vertexai';
 import type { ChatDeepSeekCallOptions } from '@langchain/deepseek';
 import type { ChatOpenRouterCallOptions } from '@/llm/openrouter';
 import type { ChatBedrockConverseInput } from '@langchain/aws';
 import type { ChatMistralAIInput } from '@langchain/mistralai';
+import type { RequestOptions } from '@google/generative-ai';
 import type { StructuredTool } from '@langchain/core/tools';
 import type { AnthropicInput } from '@langchain/anthropic';
 import type { Runnable } from '@langchain/core/runnables';
 import type { ChatOllamaInput } from '@langchain/ollama';
 import type { OpenAI as OpenAIClient } from 'openai';
 import type { ChatXAIInput } from '@langchain/xai';
-import { ChatXAI, ChatOpenAI, ChatDeepSeek, AzureChatOpenAI } from '@/llm/openai';
+import { AzureChatOpenAI, ChatDeepSeek, ChatOpenAI, ChatXAI } from '@/llm/openai';
+import { CustomChatGoogleGenerativeAI } from '@/llm/google';
+import { CustomAnthropic } from '@/llm/anthropic';
 import { ChatOpenRouter } from '@/llm/openrouter';
+import { ChatVertexAI } from '@/llm/vertexai';
 import { Providers } from '@/common';
 export type AzureClientOptions = Partial<OpenAIChatInput> & Partial<AzureOpenAIInput> & {
     openAIApiKey?: string;
@@ -42,19 +44,31 @@ export type OpenAIClientOptions = ChatOpenAIFields;
 export type OllamaClientOptions = ChatOllamaInput;
 export type AnthropicClientOptions = AnthropicInput;
 export type MistralAIClientOptions = ChatMistralAIInput;
-export type VertexAIClientOptions = ChatVertexAIInput;
+export type VertexAIClientOptions = ChatVertexAIInput & {
+    includeThoughts?: boolean;
+};
 export type BedrockClientOptions = BedrockChatFields;
 export type BedrockAnthropicInput = ChatBedrockConverseInput & {
     additionalModelRequestFields?: ChatBedrockConverseInput['additionalModelRequestFields'] & AnthropicReasoning;
 };
 export type BedrockConverseClientOptions = ChatBedrockConverseInput;
-export type GoogleClientOptions = GoogleGenerativeAIChatInput;
+export type GoogleClientOptions = GoogleGenerativeAIChatInput & {
+    customHeaders?: RequestOptions['customHeaders'];
+    thinkingConfig?: GeminiGenerationConfig['thinkingConfig'];
+};
 export type DeepSeekClientOptions = ChatDeepSeekCallOptions;
 export type XAIClientOptions = ChatXAIInput;
 export type ClientOptions = OpenAIClientOptions | AzureClientOptions | OllamaClientOptions | AnthropicClientOptions | MistralAIClientOptions | VertexAIClientOptions | BedrockClientOptions | BedrockConverseClientOptions | GoogleClientOptions | DeepSeekClientOptions | XAIClientOptions;
-export type LLMConfig = {
+export type SharedLLMConfig = {
     provider: Providers;
-} & ClientOptions;
+};
+export type LLMConfig = SharedLLMConfig & ClientOptions & {
+    /** Optional provider fallbacks in order of attempt */
+    fallbacks?: Array<{
+        provider: Providers;
+        clientOptions?: ClientOptions;
+    }>;
+};
 export type ProviderOptionsMap = {
     [Providers.AZURE]: AzureClientOptions;
     [Providers.OPENAI]: OpenAIClientOptions;
@@ -77,13 +91,13 @@ export type ChatModelMap = {
     [Providers.AZURE]: AzureChatOpenAI;
     [Providers.DEEPSEEK]: ChatDeepSeek;
     [Providers.VERTEXAI]: ChatVertexAI;
-    [Providers.ANTHROPIC]: ChatAnthropic;
+    [Providers.ANTHROPIC]: CustomAnthropic;
     [Providers.MISTRALAI]: ChatMistralAI;
     [Providers.MISTRAL]: ChatMistralAI;
     [Providers.OPENROUTER]: ChatOpenRouter;
     [Providers.BEDROCK_LEGACY]: BedrockChat;
     [Providers.BEDROCK]: ChatBedrockConverse;
-    [Providers.GOOGLE]: ChatGoogleGenerativeAI;
+    [Providers.GOOGLE]: CustomChatGoogleGenerativeAI;
 };
 export type ChatModelConstructorMap = {
     [P in Providers]: new (config: ProviderOptionsMap[P]) => ChatModelMap[P];

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

@@ -3,26 +3,59 @@ import type { BaseMessage } from '@langchain/core/messages';
 import type { StructuredTool } from '@langchain/core/tools';
 import type { RunnableConfig } from '@langchain/core/runnables';
 import type { BaseCallbackHandler, CallbackHandlerMethods } from '@langchain/core/callbacks/base';
-import type * as graph from '@/graphs/Graph';
 import type * as s from '@/types/stream';
 import type * as e from '@/common/enum';
 import type * as g from '@/types/graph';
 import type * as l from '@/types/llm';
 export type ZodObjectAny = z.ZodObject<any, any, any, any>;
 export type BaseGraphConfig = {
-    type?: 'standard';
     llmConfig: l.LLMConfig;
     provider?: e.Providers;
     clientOptions?: l.ClientOptions;
+    /** Optional compile options for workflow.compile() */
+    compileOptions?: g.CompileOptions;
 };
-export type StandardGraphConfig = BaseGraphConfig & Omit<g.StandardGraphInput, 'provider' | 'clientOptions'>;
+export type LegacyGraphConfig = BaseGraphConfig & {
+    type?: 'standard';
+} & Omit<g.StandardGraphInput, 'provider' | 'clientOptions' | 'agents'> & Omit<g.AgentInputs, 'provider' | 'clientOptions' | 'agentId'>;
+export type SupervisedGraphConfig = BaseGraphConfig & {
+    type: 'supervised';
+    /** Enable supervised router; when false, fall back to standard loop */
+    routerEnabled?: boolean;
+    /** Table-driven routing policy per stage */
+    routingPolicies?: Array<{
+        stage: string;
+        agents?: string[];
+        model?: e.Providers;
+        parallel?: boolean;
+        /** Optional simple condition on content/tools */
+        when?: 'always' | 'has_tools' | 'no_tools' | {
+            includes?: string[];
+            excludes?: string[];
+        };
+    }>;
+    /** Opt-in feature flags */
+    featureFlags?: {
+        multi_model_routing?: boolean;
+        fan_out?: boolean;
+        fan_out_retries?: number;
+        fan_out_backoff_ms?: number;
+        fan_out_concurrency?: number;
+    };
+    /** Optional per-stage model configs */
+    models?: Record<string, l.LLMConfig>;
+} & Omit<g.StandardGraphInput, 'provider' | 'clientOptions'>;
 export type RunTitleOptions = {
     inputText: string;
+    provider: e.Providers;
     contentParts: (s.MessageContentComplex | undefined)[];
     titlePrompt?: string;
     skipLanguage?: boolean;
     clientOptions?: l.ClientOptions;
     chainOptions?: Partial<RunnableConfig> | undefined;
+    omitOptions?: Set<string>;
+    titleMethod?: e.TitleMethod;
+    titlePromptTemplate?: string;
 };
 export interface AgentStateChannels {
     messages: BaseMessage[];
@@ -53,18 +86,23 @@ export type TaskManagerGraphConfig = {
         llmConfig: l.LLMConfig;
     };
 };
+export type MultiAgentGraphConfig = {
+    type: 'multi-agent';
+    compileOptions?: g.CompileOptions;
+    agents: g.AgentInputs[];
+    edges: g.GraphEdge[];
+};
 export type RunConfig = {
     runId: string;
-    graphConfig: StandardGraphConfig | CollaborativeGraphConfig | TaskManagerGraphConfig;
+    graphConfig: LegacyGraphConfig | MultiAgentGraphConfig;
     customHandlers?: Record<string, g.EventHandler>;
     returnContent?: boolean;
+    tokenCounter?: TokenCounter;
+    indexTokenCountMap?: Record<string, number>;
 };
 export type ProvidedCallbacks = (BaseCallbackHandler | CallbackHandlerMethods)[] | undefined;
 export type TokenCounter = (message: BaseMessage) => number;
 export type EventStreamOptions = {
-    callbacks?: graph.ClientCallbacks;
+    callbacks?: g.ClientCallbacks;
     keepContent?: boolean;
-    maxContextTokens?: number;
-    tokenCounter?: TokenCounter;
-    indexTokenCountMap?: Record<string, number>;
 };

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

@@ -2,6 +2,8 @@ import type OpenAITypes from 'openai';
 import type { MessageContentImageUrl, MessageContentText, ToolMessage, BaseMessage } from '@langchain/core/messages';
 import type { ToolCall, ToolCallChunk } from '@langchain/core/messages/tool';
 import type { LLMResult, Generation } from '@langchain/core/outputs';
+import type { AnthropicContentBlock } from '@/llm/anthropic/types';
+import type { Command } from '@langchain/langgraph';
 import type { ToolEndEvent } from '@/types/tools';
 import { StepTypes, ContentTypes, GraphEvents } from '@/common/enum';
 export type HandleLLMEnd = (output: LLMResult, runId: string, parentRunId?: string, tags?: string[]) => void;
@@ -64,7 +66,7 @@ export type MessageCreationDetails = {
 };
 export type ToolEndData = {
     input: string | Record<string, unknown>;
-    output?: ToolMessage;
+    output?: ToolMessage | Command;
 };
 export type ToolErrorData = {
     id: string;
@@ -191,6 +193,11 @@ export type ReasoningContentText = {
     type: ContentTypes.THINK;
     think: string;
 };
+/** Vertex AI / Google Common - Reasoning Content Block Format */
+export type GoogleReasoningContentText = {
+    type: ContentTypes.REASONING;
+    reasoning: string;
+};
 /** Anthropic's Reasoning Content Block Format */
 export type ThinkingContentText = {
     type: ContentTypes.THINKING;
@@ -230,7 +237,14 @@ export type ToolCallContent = {
     type: ContentTypes.TOOL_CALL;
     tool_call?: ToolCallPart;
 };
-export type MessageContentComplex = (ThinkingContentText | AgentUpdate | ToolCallContent | ReasoningContentText | MessageContentText | MessageContentImageUrl | (Record<string, any> & {
+export type ToolResultContent = {
+    content: string | Record<string, unknown> | Array<string | Record<string, unknown>> | AnthropicContentBlock[];
+    type: 'tool_result' | 'web_search_result' | 'web_search_tool_result';
+    tool_use_id?: string;
+    input?: string | Record<string, unknown>;
+    index?: number;
+};
+export type MessageContentComplex = (ToolResultContent | ThinkingContentText | AgentUpdate | ToolCallContent | ReasoningContentText | MessageContentText | MessageContentImageUrl | (Record<string, any> & {
     type?: 'text' | 'image_url' | 'think' | 'thinking' | string;
 }) | (Record<string, any> & {
     type?: never;

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

@@ -1,5 +1,5 @@
-import type { RunnableToolLike } from '@langchain/core/runnables';
 import type { StructuredToolInterface } from '@langchain/core/tools';
+import type { RunnableToolLike } from '@langchain/core/runnables';
 import type { ToolCall } from '@langchain/core/messages/tool';
 import type { ToolErrorData } from './stream';
 import { EnvVar } from '@/common';

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

@@ -0,0 +1,6 @@
+import type { RunnableConfig } from '@langchain/core/runnables';
+/**
+ * Safely dispatches a custom event and properly awaits it to avoid
+ * race conditions where events are dispatched after run cleanup.
+ */
+export declare function safeDispatchCustomEvent(event: string, payload: unknown, config?: RunnableConfig): Promise<void>;

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

@@ -1,3 +1,4 @@
 import type { Runnable } from '@langchain/core/runnables';
-import * as t from '@/types';
+import type * as t from '@/types';
 export declare const createTitleRunnable: (model: t.ChatModelInstance, _titlePrompt?: string) => Promise<Runnable>;
+export declare const createCompletionTitleRunnable: (model: t.ChatModelInstance, titlePrompt?: string) => Promise<Runnable>;

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

@@ -1,3 +1,27 @@
 import type { BaseMessage } from '@langchain/core/messages';
 export declare function getTokenCountForMessage(message: BaseMessage, getTokenCount: (text: string) => number): number;
+/**
+ * Creates a singleton token counter function that reuses the same encoder instance.
+ * This avoids creating multiple function closures and prevents potential memory issues.
+ */
 export declare const createTokenCounter: () => Promise<(message: BaseMessage) => number>;
+/**
+ * Utility to manage the token encoder lifecycle explicitly.
+ * Useful for applications that need fine-grained control over resource management.
+ */
+export declare const TokenEncoderManager: {
+    /**
+     * Pre-initializes the encoder. This can be called during app startup
+     * to avoid lazy loading delays later.
+     */
+    initialize(): Promise<void>;
+    /**
+     * Clears the cached encoder and token counter.
+     * Useful for testing or when you need to force a fresh reload.
+     */
+    reset(): void;
+    /**
+     * Checks if the encoder has been initialized.
+     */
+    isInitialized(): boolean;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@librechat/agents",
-  "version": "2.4.322",
+  "version": "3.0.00-rc1",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/esm/main.mjs",
   "types": "./dist/types/index.d.ts",
@@ -47,14 +47,19 @@
     "image": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/image.ts --provider 'google' --name 'Jo' --location 'New York, NY'",
     "code_exec_files": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/code_exec_files.ts --provider 'openAI' --name 'Jo' --location 'New York, NY'",
     "code_exec_simple": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/code_exec_simple.ts --provider 'google' --name 'Jo' --location 'New York, NY'",
-    "simple": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/simple.ts --provider 'xai' --name 'Jo' --location 'New York, NY'",
+    "simple": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/simple.ts --provider 'anthropic' --name 'Jo' --location 'New York, NY'",
     "caching": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/caching.ts --name 'Jo' --location 'New York, NY'",
     "thinking": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/thinking.ts --name 'Jo' --location 'New York, NY'",
     "memory": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/memory.ts --provider 'openAI' --name 'Jo' --location 'New York, NY'",
-    "tool-test": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/tools.ts --provider 'alibaba' --name 'Jo' --location 'New York, NY'",
+    "tool-test": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/tools.ts --provider 'bedrock' --name 'Jo' --location 'New York, NY'",
     "search": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/search.ts --provider 'anthropic' --name 'Jo' --location 'New York, NY'",
+    "ant_web_search": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/ant_web_search.ts --name 'Jo' --location 'New York, NY'",
     "abort": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/abort.ts --provider 'openAI' --name 'Jo' --location 'New York, NY'",
     "start:cli2": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/cli2.ts --provider 'anthropic' --name 'Jo' --location 'New York, NY'",
+    "multi-agent-test": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/multi-agent-test.ts",
+    "multi-agent-parallel": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/multi-agent-parallel.ts",
+    "multi-agent-sequence": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/multi-agent-sequence.ts",
+    "multi-agent-conditional": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/multi-agent-conditional.ts",
     "script2": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/proto/example_test.ts",
     "script3": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/proto/example_test_anthropic.ts",
     "script4": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/cli4.ts --name 'Jo' --location 'New York, NY'",
@@ -65,35 +70,46 @@
     "start:collab": "node --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/main.ts",
     "start:collab5": "node --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/collab_design_v5.ts",
     "start:dev": "node --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/main.ts",
+    "supervised": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/supervised.ts --provider anthropic --name Jo --location \"New York, NY\"",
     "test": "jest",
+    "test:memory": "NODE_OPTIONS='--expose-gc' npx jest src/specs/title.memory-leak.test.ts",
+    "test:all": "npm test -- --testPathIgnorePatterns=title.memory-leak.test.ts && npm run test:memory",
     "reinstall": "npm run clean && npm ci && rm -rf ./dist && npm run build",
     "re": "bun run clean && bun install && rm -rf ./dist && turbo build",
     "lint": "eslint \"{,!(node_modules|venv)/**/}*.{js,jsx,ts,tsx}\" --fix",
     "format": "prettier --write ."
   },
+  "overrides": {
+    "@langchain/openai": "0.5.18",
+    "@browserbasehq/stagehand": {
+      "openai": "$openai"
+    }
+  },
   "dependencies": {
-    "@langchain/anthropic": "^0.3.20",
-    "@langchain/aws": "0.1.8",
-    "@langchain/community": "^0.3.42",
-    "@langchain/core": "^0.3.55",
-    "@langchain/deepseek": "^0.0.1",
-    "@langchain/google-genai": "^0.2.8",
-    "@langchain/google-vertexai": "^0.2.8",
-    "@langchain/langgraph": "^0.2.72",
-    "@langchain/mistralai": "^0.2.0",
-    "@langchain/ollama": "^0.2.0",
-    "@langchain/openai": "^0.5.10",
-    "@langchain/xai": "^0.0.2",
+    "@langchain/anthropic": "^0.3.26",
+    "@langchain/aws": "^0.1.12",
+    "@langchain/community": "^0.3.47",
+    "@langchain/core": "^0.3.72",
+    "@langchain/deepseek": "^0.0.2",
+    "@langchain/google-genai": "^0.2.13",
+    "@langchain/google-vertexai": "^0.2.13",
+    "@langchain/langgraph": "^0.4.9",
+    "@langchain/mistralai": "^0.2.1",
+    "@langchain/ollama": "^0.2.3",
+    "@langchain/openai": "0.5.18",
+    "@langchain/xai": "^0.0.3",
     "cheerio": "^1.0.0",
     "dotenv": "^16.4.7",
     "https-proxy-agent": "^7.0.6",
-    "nanoid": "^3.3.7"
+    "nanoid": "^3.3.7",
+    "openai": "^5.10.1"
   },
   "imports": {
     "@/*": "./src/*",
     "~/*": "./*"
   },
   "devDependencies": {
+    "@anthropic-ai/vertex-sdk": "^0.12.0",
     "@eslint/compat": "^1.2.7",
     "@rollup/plugin-alias": "^5.1.0",
     "@rollup/plugin-commonjs": "^28.0.3",
@@ -107,7 +123,7 @@
     "@types/yargs-parser": "^21.0.3",
     "@typescript-eslint/eslint-plugin": "^8.24.0",
     "@typescript-eslint/parser": "^8.24.0",
-    "eslint": "^9.22.0",
+    "eslint": "^9.31.0",
     "eslint-import-resolver-typescript": "^3.7.0",
     "eslint-plugin-import": "^2.31.0",
     "husky": "^9.1.7",