@librechat/agents 2.4.321 → 3.0.0-rc1

package/dist/esm/utils/tokens.mjs

@@ -48,15 +48,61 @@ function getTokenCountForMessage(message, getTokenCount) {
     processValue(message.content);
     return numTokens;
 }
+let encoderPromise;
+let tokenCounterPromise;
+async function getSharedEncoder() {
+    if (encoderPromise) {
+        return encoderPromise;
+    }
+    encoderPromise = (async () => {
+        const res = await fetch('https://tiktoken.pages.dev/js/o200k_base.json');
+        const o200k_base = await res.json();
+        return new Tiktoken(o200k_base);
+    })();
+    return encoderPromise;
+}
+/**
+ * Creates a singleton token counter function that reuses the same encoder instance.
+ * This avoids creating multiple function closures and prevents potential memory issues.
+ */
 const createTokenCounter = async () => {
-    const res = await fetch('https://tiktoken.pages.dev/js/o200k_base.json');
-    const o200k_base = await res.json();
-    const countTokens = (text) => {
-        const enc = new Tiktoken(o200k_base);
-        return enc.encode(text).length;
-    };
-    return (message) => getTokenCountForMessage(message, countTokens);
+    if (tokenCounterPromise) {
+        return tokenCounterPromise;
+    }
+    tokenCounterPromise = (async () => {
+        const enc = await getSharedEncoder();
+        const countTokens = (text) => enc.encode(text).length;
+        return (message) => getTokenCountForMessage(message, countTokens);
+    })();
+    return tokenCounterPromise;
+};
+/**
+ * Utility to manage the token encoder lifecycle explicitly.
+ * Useful for applications that need fine-grained control over resource management.
+ */
+const TokenEncoderManager = {
+    /**
+     * Pre-initializes the encoder. This can be called during app startup
+     * to avoid lazy loading delays later.
+     */
+    async initialize() {
+        await getSharedEncoder();
+    },
+    /**
+     * Clears the cached encoder and token counter.
+     * Useful for testing or when you need to force a fresh reload.
+     */
+    reset() {
+        encoderPromise = undefined;
+        tokenCounterPromise = undefined;
+    },
+    /**
+     * Checks if the encoder has been initialized.
+     */
+    isInitialized() {
+        return encoderPromise !== undefined;
+    },
 };
 
-export { createTokenCounter, getTokenCountForMessage };
+export { TokenEncoderManager, createTokenCounter, getTokenCountForMessage };
 //# sourceMappingURL=tokens.mjs.map

package/dist/esm/utils/tokens.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"tokens.mjs","sources":["../../../src/utils/tokens.ts"],"sourcesContent":["import { Tiktoken } from 'js-tiktoken/lite';\nimport type { BaseMessage } from '@langchain/core/messages';\nimport { ContentTypes } from '@/common/enum';\n\nexport function getTokenCountForMessage(message: BaseMessage, getTokenCount: (text: string) => number): number {\n  const tokensPerMessage = 3;\n\n  const processValue = (value: unknown): void => {\n    if (Array.isArray(value)) {\n      for (const item of value) {\n        if (\n          !item ||\n          !item.type ||\n          item.type === ContentTypes.ERROR ||\n          item.type === ContentTypes.IMAGE_URL\n        ) {\n          continue;\n        }\n\n        if (item.type === ContentTypes.TOOL_CALL && item.tool_call != null) {\n          const toolName = item.tool_call?.name || '';\n          if (toolName != null && toolName && typeof toolName === 'string') {\n            numTokens += getTokenCount(toolName);\n          }\n\n          const args = item.tool_call?.args || '';\n          if (args != null && args && typeof args === 'string') {\n            numTokens += getTokenCount(args);\n          }\n\n          const output = item.tool_call?.output || '';\n          if (output != null && output && typeof output === 'string') {\n            numTokens += getTokenCount(output);\n          }\n          continue;\n        }\n\n        const nestedValue = item[item.type];\n\n        if (!nestedValue) {\n          continue;\n        }\n\n        processValue(nestedValue);\n      }\n    } else if (typeof value === 'string') {\n      numTokens += getTokenCount(value);\n    } else if (typeof value === 'number') {\n      numTokens += getTokenCount(value.toString());\n    } else if (typeof value === 'boolean') {\n      numTokens += getTokenCount(value.toString());\n    }\n  };\n\n  let numTokens = tokensPerMessage;\n  processValue(message.content);\n  return numTokens;\n}\n\nexport const createTokenCounter = async () => {\n  const res = await fetch('https://tiktoken.pages.dev/js/o200k_base.json');\n  const o200k_base = await res.json();\n\n  const countTokens = (text: string): number => {\n    const enc = new Tiktoken(o200k_base);\n    return enc.encode(text).length;\n  };\n\n  return (message: BaseMessage): number => getTokenCountForMessage(message, countTokens);\n};"],"names":[],"mappings":";;;AAIgB,SAAA,uBAAuB,CAAC,OAAoB,EAAE,aAAuC,EAAA;IACnG,MAAM,gBAAgB,GAAG,CAAC;AAE1B,IAAA,MAAM,YAAY,GAAG,CAAC,KAAc,KAAU;AAC5C,QAAA,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;AACxB,YAAA,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE;AACxB,gBAAA,IACE,CAAC,IAAI;oBACL,CAAC,IAAI,CAAC,IAAI;AACV,oBAAA,IAAI,CAAC,IAAI,KAAK,YAAY,CAAC,KAAK;AAChC,oBAAA,IAAI,CAAC,IAAI,KAAK,YAAY,CAAC,SAAS,EACpC;oBACA;;AAGF,gBAAA,IAAI,IAAI,CAAC,IAAI,KAAK,YAAY,CAAC,SAAS,IAAI,IAAI,CAAC,SAAS,IAAI,IAAI,EAAE;oBAClE,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,EAAE,IAAI,IAAI,EAAE;oBAC3C,IAAI,QAAQ,IAAI,IAAI,IAAI,QAAQ,IAAI,OAAO,QAAQ,KAAK,QAAQ,EAAE;AAChE,wBAAA,SAAS,IAAI,aAAa,CAAC,QAAQ,CAAC;;oBAGtC,MAAM,IAAI,GAAG,IAAI,CAAC,SAAS,EAAE,IAAI,IAAI,EAAE;oBACvC,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE;AACpD,wBAAA,SAAS,IAAI,aAAa,CAAC,IAAI,CAAC;;oBAGlC,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,EAAE,MAAM,IAAI,EAAE;oBAC3C,IAAI,MAAM,IAAI,IAAI,IAAI,MAAM,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE;AAC1D,wBAAA,SAAS,IAAI,aAAa,CAAC,MAAM,CAAC;;oBAEpC;;gBAGF,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC;gBAEnC,IAAI,CAAC,WAAW,EAAE;oBAChB;;gBAGF,YAAY,CAAC,WAAW,CAAC;;;AAEtB,aAAA,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;AACpC,YAAA,SAAS,IAAI,aAAa,CAAC,KAAK,CAAC;;AAC5B,aAAA,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;YACpC,SAAS,IAAI,aAAa,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC;;AACvC,aAAA,IAAI,OAAO,KAAK,KAAK,SAAS,EAAE;YACrC,SAAS,IAAI,aAAa,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC;;AAEhD,KAAC;IAED,IAAI,SAAS,GAAG,gBAAgB;AAChC,IAAA,YAAY,CAAC,OAAO,CAAC,OAAO,CAAC;AAC7B,IAAA,OAAO,SAAS;AAClB;AAEa,MAAA,kBAAkB,GAAG,YAAW;AAC3C,IAAA,MAAM,GAAG,GAAG,MAAM,KAAK,CAAC,+CAA+C,CAAC;AACxE,IAAA,MAAM,UAAU,GAAG,MAAM,GAAG,CAAC,IAAI,EAAE;AAEnC,IAAA,MAAM,WAAW,GAAG,CAAC,IAAY,KAAY;AAC3C,QAAA,MAAM,GAAG,GAAG,IAAI,QAAQ,CAAC,UAAU,CAAC;QACpC,OAAO,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM;AAChC,KAAC;IAED,OAAO,CAAC,OAAoB,KAAa,uBAAuB,CAAC,OAAO,EAAE,WAAW,CAAC;AACxF;;;;"}
+{"version":3,"file":"tokens.mjs","sources":["../../../src/utils/tokens.ts"],"sourcesContent":["import { Tiktoken } from 'js-tiktoken/lite';\nimport type { BaseMessage } from '@langchain/core/messages';\nimport { ContentTypes } from '@/common/enum';\n\nexport function getTokenCountForMessage(\n  message: BaseMessage,\n  getTokenCount: (text: string) => number\n): number {\n  const tokensPerMessage = 3;\n\n  const processValue = (value: unknown): void => {\n    if (Array.isArray(value)) {\n      for (const item of value) {\n        if (\n          !item ||\n          !item.type ||\n          item.type === ContentTypes.ERROR ||\n          item.type === ContentTypes.IMAGE_URL\n        ) {\n          continue;\n        }\n\n        if (item.type === ContentTypes.TOOL_CALL && item.tool_call != null) {\n          const toolName = item.tool_call?.name || '';\n          if (toolName != null && toolName && typeof toolName === 'string') {\n            numTokens += getTokenCount(toolName);\n          }\n\n          const args = item.tool_call?.args || '';\n          if (args != null && args && typeof args === 'string') {\n            numTokens += getTokenCount(args);\n          }\n\n          const output = item.tool_call?.output || '';\n          if (output != null && output && typeof output === 'string') {\n            numTokens += getTokenCount(output);\n          }\n          continue;\n        }\n\n        const nestedValue = item[item.type];\n\n        if (!nestedValue) {\n          continue;\n        }\n\n        processValue(nestedValue);\n      }\n    } else if (typeof value === 'string') {\n      numTokens += getTokenCount(value);\n    } else if (typeof value === 'number') {\n      numTokens += getTokenCount(value.toString());\n    } else if (typeof value === 'boolean') {\n      numTokens += getTokenCount(value.toString());\n    }\n  };\n\n  let numTokens = tokensPerMessage;\n  processValue(message.content);\n  return numTokens;\n}\n\nlet encoderPromise: Promise<Tiktoken> | undefined;\nlet tokenCounterPromise: Promise<(message: BaseMessage) => number> | undefined;\n\nasync function getSharedEncoder(): Promise<Tiktoken> {\n  if (encoderPromise) {\n    return encoderPromise;\n  }\n  encoderPromise = (async (): Promise<Tiktoken> => {\n    const res = await fetch('https://tiktoken.pages.dev/js/o200k_base.json');\n    const o200k_base = await res.json();\n    return new Tiktoken(o200k_base);\n  })();\n  return encoderPromise;\n}\n\n/**\n * Creates a singleton token counter function that reuses the same encoder instance.\n * This avoids creating multiple function closures and prevents potential memory issues.\n */\nexport const createTokenCounter = async (): Promise<\n  (message: BaseMessage) => number\n> => {\n  if (tokenCounterPromise) {\n    return tokenCounterPromise;\n  }\n\n  tokenCounterPromise = (async (): Promise<\n    (message: BaseMessage) => number\n  > => {\n    const enc = await getSharedEncoder();\n    const countTokens = (text: string): number => enc.encode(text).length;\n    return (message: BaseMessage): number =>\n      getTokenCountForMessage(message, countTokens);\n  })();\n\n  return tokenCounterPromise;\n};\n\n/**\n * Utility to manage the token encoder lifecycle explicitly.\n * Useful for applications that need fine-grained control over resource management.\n */\nexport const TokenEncoderManager = {\n  /**\n   * Pre-initializes the encoder. This can be called during app startup\n   * to avoid lazy loading delays later.\n   */\n  async initialize(): Promise<void> {\n    await getSharedEncoder();\n  },\n\n  /**\n   * Clears the cached encoder and token counter.\n   * Useful for testing or when you need to force a fresh reload.\n   */\n  reset(): void {\n    encoderPromise = undefined;\n    tokenCounterPromise = undefined;\n  },\n\n  /**\n   * Checks if the encoder has been initialized.\n   */\n  isInitialized(): boolean {\n    return encoderPromise !== undefined;\n  },\n};\n"],"names":[],"mappings":"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"}

package/dist/types/agents/AgentContext.d.ts

@@ -0,0 +1,91 @@
+import { SystemMessage } from '@langchain/core/messages';
+import type { UsageMetadata, BaseMessage } from '@langchain/core/messages';
+import type { RunnableConfig, Runnable } from '@langchain/core/runnables';
+import type * as t from '@/types';
+import type { createPruneMessages } from '@/messages';
+import { ContentTypes, Providers } from '@/common';
+/**
+ * Encapsulates agent-specific state that can vary between agents in a multi-agent system
+ */
+export declare class AgentContext {
+    /**
+     * Create an AgentContext from configuration with token accounting initialization
+     */
+    static fromConfig(agentConfig: t.AgentInputs, tokenCounter?: t.TokenCounter, indexTokenCountMap?: Record<string, number>): AgentContext;
+    /** Agent identifier */
+    agentId: string;
+    /** Provider for this specific agent */
+    provider: Providers;
+    /** Client options for this agent */
+    clientOptions?: t.ClientOptions;
+    /** Token count map indexed by message position */
+    indexTokenCountMap: Record<string, number | undefined>;
+    /** Maximum context tokens for this agent */
+    maxContextTokens?: number;
+    /** Current usage metadata for this agent */
+    currentUsage?: Partial<UsageMetadata>;
+    /** Prune messages function configured for this agent */
+    pruneMessages?: ReturnType<typeof createPruneMessages>;
+    /** Token counter function for this agent */
+    tokenCounter?: t.TokenCounter;
+    /** Instructions/system message token count */
+    instructionTokens: number;
+    /** The amount of time that should pass before another consecutive API call */
+    streamBuffer?: number;
+    /** Last stream call timestamp for rate limiting */
+    lastStreamCall?: number;
+    /** Tools available to this agent */
+    tools?: t.GraphTools;
+    /** Tool map for this agent */
+    toolMap?: t.ToolMap;
+    /** Instructions for this agent */
+    instructions?: string;
+    /** Additional instructions for this agent */
+    additionalInstructions?: string;
+    /** Reasoning key for this agent */
+    reasoningKey: 'reasoning_content' | 'reasoning';
+    /** Last token for reasoning detection */
+    lastToken?: string;
+    /** Token type switch state */
+    tokenTypeSwitch?: 'reasoning' | 'content';
+    /** Current token type being processed */
+    currentTokenType: ContentTypes.TEXT | ContentTypes.THINK | 'think_and_text';
+    /** Whether tools should end the workflow */
+    toolEnd: boolean;
+    /** System runnable for this agent */
+    systemRunnable?: Runnable<BaseMessage[], (BaseMessage | SystemMessage)[], RunnableConfig<Record<string, unknown>>>;
+    /** Promise for token calculation initialization */
+    tokenCalculationPromise?: Promise<void>;
+    constructor({ agentId, provider, clientOptions, maxContextTokens, streamBuffer, tokenCounter, tools, toolMap, instructions, additionalInstructions, reasoningKey, toolEnd, instructionTokens, }: {
+        agentId: string;
+        provider: Providers;
+        clientOptions?: t.ClientOptions;
+        maxContextTokens?: number;
+        streamBuffer?: number;
+        tokenCounter?: t.TokenCounter;
+        tools?: t.GraphTools;
+        toolMap?: t.ToolMap;
+        instructions?: string;
+        additionalInstructions?: string;
+        reasoningKey?: 'reasoning_content' | 'reasoning';
+        toolEnd?: boolean;
+        instructionTokens?: number;
+    });
+    /**
+     * Create system runnable from instructions and calculate tokens if tokenCounter is available
+     */
+    private createSystemRunnable;
+    /**
+     * Reset context for a new run
+     */
+    reset(): void;
+    /**
+     * Update the token count map with instruction tokens
+     */
+    updateTokenMapWithInstructions(baseTokenMap: Record<string, number>): void;
+    /**
+     * Calculate tool tokens and add to instruction tokens
+     * Note: System message tokens are calculated during systemRunnable creation
+     */
+    calculateInstructionTokens(tokenCounter: t.TokenCounter): Promise<void>;
+}

package/dist/types/common/enum.d.ts

@@ -66,8 +66,9 @@ export declare enum Providers {
     XAI = "xai"
 }
 export declare enum GraphNodeKeys {
-    TOOLS = "tools",
-    AGENT = "agent",
+    TOOLS = "tools=",
+    AGENT = "agent=",
+    ROUTER = "router",
     PRE_TOOLS = "pre_tools",
     POST_TOOLS = "post_tools"
 }
@@ -92,10 +93,12 @@ export declare enum ContentTypes {
     IMAGE_FILE = "image_file",
     /** Anthropic */
     THINKING = "thinking",
-    /** Bedrock */
-    REASONING_CONTENT = "reasoning_content",
+    /** Vertex AI / Google Common */
+    REASONING = "reasoning",
     /** Multi-Agent Switch */
-    AGENT_UPDATE = "agent_update"
+    AGENT_UPDATE = "agent_update",
+    /** Bedrock */
+    REASONING_CONTENT = "reasoning_content"
 }
 export declare enum ToolCallTypes {
     FUNCTION = "function",
@@ -107,7 +110,8 @@ export declare enum ToolCallTypes {
 export declare enum Callback {
     TOOL_ERROR = "handleToolError",
     TOOL_START = "handleToolStart",
-    TOOL_END = "handleToolEnd"
+    TOOL_END = "handleToolEnd",
+    CUSTOM_EVENT = "handleCustomEvent"
 }
 export declare enum Constants {
     OFFICIAL_CODE_BASEURL = "https://api.librechat.ai/v1",
@@ -115,6 +119,11 @@ export declare enum Constants {
     WEB_SEARCH = "web_search",
     CONTENT_AND_ARTIFACT = "content_and_artifact"
 }
+export declare enum TitleMethod {
+    STRUCTURED = "structured",
+    FUNCTIONS = "functions",
+    COMPLETION = "completion"
+}
 export declare enum EnvVar {
     CODE_API_KEY = "LIBRECHAT_CODE_API_KEY",
     CODE_BASEURL = "LIBRECHAT_CODE_BASEURL"

package/dist/types/events.d.ts

@@ -1,5 +1,5 @@
 import type { UsageMetadata, BaseMessageFields } from '@langchain/core/messages';
-import type { Graph } from '@/graphs';
+import type { MultiAgentGraph, StandardGraph } from '@/graphs';
 import type * as t from '@/types';
 export declare class HandlerRegistry {
     private handlers;
@@ -9,12 +9,13 @@ export declare class HandlerRegistry {
 export declare class ModelEndHandler implements t.EventHandler {
     collectedUsage?: UsageMetadata[];
     constructor(collectedUsage?: UsageMetadata[]);
-    handle(event: string, data: t.ModelEndData, metadata?: Record<string, unknown>, graph?: Graph): void;
+    handle(event: string, data: t.ModelEndData, metadata?: Record<string, unknown>, graph?: StandardGraph | MultiAgentGraph): Promise<void>;
 }
 export declare class ToolEndHandler implements t.EventHandler {
     private callback?;
-    constructor(callback?: t.ToolEndCallback);
-    handle(event: string, data: t.StreamEventData | undefined, metadata?: Record<string, unknown>, graph?: Graph): void;
+    private omitOutput?;
+    constructor(callback?: t.ToolEndCallback, omitOutput?: (name?: string) => boolean);
+    handle(event: string, data: t.StreamEventData | undefined, metadata?: Record<string, unknown>, graph?: StandardGraph | MultiAgentGraph): Promise<void>;
 }
 export declare class TestLLMStreamHandler implements t.EventHandler {
     handle(event: string, data: t.StreamEventData | undefined): void;

package/dist/types/graphs/Graph.d.ts

@@ -1,29 +1,23 @@
 import { ToolNode } from '@langchain/langgraph/prebuilt';
-import { START } from '@langchain/langgraph';
 import { Runnable, RunnableConfig } from '@langchain/core/runnables';
-import { SystemMessage } from '@langchain/core/messages';
-import type { BaseMessage, UsageMetadata } from '@langchain/core/messages';
-import type * as t from '@/types';
-import { Providers, GraphNodeKeys, Callback, ContentTypes } from '@/common';
+import type { UsageMetadata, BaseMessage } from '@langchain/core/messages';
 import type { ToolCall } from '@langchain/core/messages/tool';
+import type * as t from '@/types';
+import { Providers } from '@/common';
 import { ToolNode as CustomToolNode } from '@/tools/ToolNode';
-import { createPruneMessages } from '@/messages';
+import { AgentContext } from '@/agents/AgentContext';
 import { HandlerRegistry } from '@/events';
-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 declare abstract class Graph<T extends t.BaseGraphState = t.BaseGraphState, TNodeName extends string = string> {
+export declare abstract class Graph<T extends t.BaseGraphState = t.BaseGraphState, _TNodeName extends string = string> {
     abstract resetValues(): void;
-    abstract createGraphState(): t.GraphStateChannels<T>;
-    abstract initializeTools(): CustomToolNode<T> | ToolNode<T>;
-    abstract initializeModel(): Runnable;
+    abstract initializeTools({ currentTools, currentToolMap, }: {
+        currentTools?: t.GraphTools;
+        currentToolMap?: t.ToolMap;
+    }): CustomToolNode<T> | ToolNode<T>;
+    abstract initializeModel({ currentModel, tools, clientOptions, }: {
+        currentModel?: t.ChatModel;
+        tools?: t.GraphTools;
+        clientOptions?: t.ClientOptions;
+    }): Runnable;
     abstract getRunMessages(): BaseMessage[] | undefined;
     abstract getContentParts(): t.MessageContentComplex[] | undefined;
     abstract generateStepId(stepKey: string): [string, number];
@@ -32,17 +26,12 @@ export declare abstract class Graph<T extends t.BaseGraphState = t.BaseGraphStat
     abstract checkKeyList(keyList: (string | number | undefined)[]): boolean;
     abstract getStepIdByKey(stepKey: string, index?: number): string;
     abstract getRunStep(stepId: string): t.RunStep | undefined;
-    abstract dispatchRunStep(stepKey: string, stepDetails: t.StepDetails): string;
-    abstract dispatchRunStepDelta(id: string, delta: t.ToolCallDelta): void;
-    abstract dispatchMessageDelta(id: string, delta: t.MessageDelta): void;
-    abstract dispatchReasoningDelta(stepId: string, delta: t.ReasoningDelta): void;
-    abstract handleToolCallCompleted(data: t.ToolEndData, metadata?: Record<string, unknown>): void;
-    abstract createCallModel(): (state: T, config?: RunnableConfig) => Promise<Partial<T>>;
-    abstract createWorkflow(): t.CompiledWorkflow<T>;
-    lastToken?: string;
-    tokenTypeSwitch?: 'reasoning' | 'content';
-    reasoningKey: 'reasoning_content' | 'reasoning';
-    currentTokenType: ContentTypes.TEXT | ContentTypes.THINK | 'think_and_text';
+    abstract dispatchRunStep(stepKey: string, stepDetails: t.StepDetails): Promise<string>;
+    abstract dispatchRunStepDelta(id: string, delta: t.ToolCallDelta): Promise<void>;
+    abstract dispatchMessageDelta(id: string, delta: t.MessageDelta): Promise<void>;
+    abstract dispatchReasoningDelta(stepId: string, delta: t.ReasoningDelta): Promise<void>;
+    abstract handleToolCallCompleted(data: t.ToolEndData, metadata?: Record<string, unknown>, omitOutput?: boolean): Promise<void>;
+    abstract createCallModel(agentId?: string, currentModel?: t.ChatModel): (state: T, config?: RunnableConfig) => Promise<Partial<T>>;
     messageStepHasToolCalls: Map<string, boolean>;
     messageIdsByStepKey: Map<string, string>;
     prelimMessageIdsByStepKey: Map<string, string>;
@@ -51,34 +40,27 @@ export declare abstract class Graph<T extends t.BaseGraphState = t.BaseGraphStat
     stepKeyIds: Map<string, string[]>;
     contentIndexMap: Map<string, number>;
     toolCallStepIds: Map<string, string>;
-    currentUsage: Partial<UsageMetadata> | undefined;
-    indexTokenCountMap: Record<string, number | undefined>;
-    maxContextTokens: number | undefined;
-    pruneMessages?: ReturnType<typeof createPruneMessages>;
-    /** The amount of time that should pass before another consecutive API call */
-    streamBuffer: number | undefined;
-    tokenCounter?: t.TokenCounter;
     signal?: AbortSignal;
-}
-export declare class StandardGraph extends Graph<t.BaseGraphState, GraphNode> {
-    private graphState;
-    clientOptions: t.ClientOptions;
-    boundModel?: Runnable;
-    /** The last recorded timestamp that a stream API call was invoked */
-    lastStreamCall: number | undefined;
+    /** Set of invoked tool call IDs from non-message run steps completed mid-run, if any */
+    invokedToolIds?: Set<string>;
     handlerRegistry: HandlerRegistry | undefined;
-    systemMessage: SystemMessage | undefined;
+}
+export declare class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
+    overrideModel?: t.ChatModel;
+    /** Optional compile options passed into workflow.compile() */
+    compileOptions?: t.CompileOptions | undefined;
     messages: BaseMessage[];
     runId: string | undefined;
-    tools?: t.GenericTool[];
-    toolMap?: t.ToolMap;
     startIndex: number;
-    provider: Providers;
-    toolEnd: boolean;
     signal?: AbortSignal;
-    constructor({ runId, tools, signal, toolMap, provider, streamBuffer, instructions, reasoningKey, clientOptions, toolEnd, additional_instructions, }: t.StandardGraphInput);
+    /** Map of agent contexts by agent ID */
+    agentContexts: Map<string, AgentContext>;
+    /** Default agent ID to use */
+    defaultAgentId: string;
+    constructor({ runId, signal, agents, tokenCounter, indexTokenCountMap, }: t.StandardGraphInput);
     resetValues(keepContent?: boolean): void;
     getRunStep(stepId: string): t.RunStep | undefined;
+    getAgentContext(metadata: Record<string, unknown> | undefined): AgentContext;
     getStepKey(metadata: Record<string, unknown> | undefined): string;
     getStepIdByKey(stepKey: string, index?: number): string;
     generateStepId(stepKey: string): [string, number];
@@ -86,34 +68,49 @@ export declare class StandardGraph extends Graph<t.BaseGraphState, GraphNode> {
     checkKeyList(keyList: (string | number | undefined)[]): boolean;
     getRunMessages(): BaseMessage[] | undefined;
     getContentParts(): t.MessageContentComplex[] | undefined;
-    createGraphState(): t.GraphStateChannels<t.BaseGraphState>;
-    initializeTools(): CustomToolNode<t.BaseGraphState> | ToolNode<t.BaseGraphState>;
-    initializeModel(): Runnable;
+    createSystemRunnable({ provider, clientOptions, instructions, additional_instructions, }: {
+        provider?: Providers;
+        clientOptions?: t.ClientOptions;
+        instructions?: string;
+        additional_instructions?: string;
+    }): t.SystemRunnable | undefined;
+    initializeTools({ currentTools, currentToolMap, }: {
+        currentTools?: t.GraphTools;
+        currentToolMap?: t.ToolMap;
+    }): CustomToolNode<t.BaseGraphState> | ToolNode<t.BaseGraphState>;
+    initializeModel({ provider, tools, clientOptions, }: {
+        provider: Providers;
+        tools?: t.GraphTools;
+        clientOptions?: t.ClientOptions;
+    }): Runnable;
     overrideTestModel(responses: string[], sleep?: number, toolCalls?: ToolCall[]): void;
-    getNewModel({ clientOptions, omitOriginalOptions, }: {
+    getNewModel({ provider, clientOptions, }: {
+        provider: Providers;
         clientOptions?: t.ClientOptions;
-        omitOriginalOptions?: Set<string>;
     }): t.ChatModelInstance;
-    storeUsageMetadata(finalMessage?: BaseMessage): void;
-    cleanupSignalListener(): void;
-    createCallModel(): (state: t.BaseGraphState, config?: RunnableConfig) => Promise<Partial<t.BaseGraphState>>;
-    createWorkflow(): t.CompiledWorkflow<t.BaseGraphState>;
+    getUsageMetadata(finalMessage?: BaseMessage): Partial<UsageMetadata> | undefined;
+    /** Execute model invocation with streaming support */
+    private attemptInvoke;
+    cleanupSignalListener(currentModel?: t.ChatModel): void;
+    createCallModel(agentId?: string, currentModel?: t.ChatModel): (state: t.BaseGraphState, config?: RunnableConfig) => Promise<Partial<t.BaseGraphState>>;
+    createAgentNode(agentId: string): t.CompiledAgentWorfklow;
+    createWorkflow(): t.CompiledStateWorkflow;
     /**
      * Dispatches a run step to the client, returns the step ID
      */
-    dispatchRunStep(stepKey: string, stepDetails: t.StepDetails): string;
-    handleToolCallCompleted(data: t.ToolEndData, metadata?: Record<string, unknown>): void;
+    dispatchRunStep(stepKey: string, stepDetails: t.StepDetails): Promise<string>;
+    handleToolCallCompleted(data: t.ToolEndData, metadata?: Record<string, unknown>, omitOutput?: boolean): Promise<void>;
     /**
      * Static version of handleToolCallError to avoid creating strong references
      * that prevent garbage collection
      */
-    static handleToolCallErrorStatic(graph: StandardGraph, data: t.ToolErrorData, metadata?: Record<string, unknown>): void;
+    static handleToolCallErrorStatic(graph: StandardGraph, data: t.ToolErrorData, metadata?: Record<string, unknown>): Promise<void>;
     /**
      * Instance method that delegates to the static method
      * Kept for backward compatibility
      */
-    handleToolCallError(data: t.ToolErrorData, metadata?: Record<string, unknown>): void;
-    dispatchRunStepDelta(id: string, delta: t.ToolCallDelta): void;
-    dispatchMessageDelta(id: string, delta: t.MessageDelta): void;
-    dispatchReasoningDelta: (stepId: string, delta: t.ReasoningDelta) => void;
+    handleToolCallError(data: t.ToolErrorData, metadata?: Record<string, unknown>): Promise<void>;
+    dispatchRunStepDelta(id: string, delta: t.ToolCallDelta): Promise<void>;
+    dispatchMessageDelta(id: string, delta: t.MessageDelta): Promise<void>;
+    dispatchReasoningDelta: (stepId: string, delta: t.ReasoningDelta) => Promise<void>;
 }

package/dist/types/graphs/MultiAgentGraph.d.ts

@@ -0,0 +1,37 @@
+import type * as t from '@/types';
+import { StandardGraph } from './Graph';
+/**
+ * MultiAgentGraph extends StandardGraph to support dynamic multi-agent workflows
+ * with handoffs, fan-in/fan-out, and other composable patterns
+ */
+export declare class MultiAgentGraph extends StandardGraph {
+    private edges;
+    private startingNodes;
+    private directEdges;
+    private handoffEdges;
+    constructor(input: t.MultiAgentGraphInput);
+    /**
+     * Categorize edges into handoff and direct types
+     */
+    private categorizeEdges;
+    /**
+     * Analyze graph structure to determine starting nodes and connections
+     */
+    private analyzeGraph;
+    /**
+     * Create handoff tools for agents based on handoff edges only
+     */
+    private createHandoffTools;
+    /**
+     * Create handoff tools for an edge (handles multiple destinations)
+     */
+    private createHandoffToolsForEdge;
+    /**
+     * Create a complete agent subgraph (similar to createReactAgent)
+     */
+    private createAgentSubgraph;
+    /**
+     * Create the multi-agent workflow with dynamic handoffs
+     */
+    createWorkflow(): t.CompiledStateWorkflow;
+}

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

@@ -1 +1,2 @@
 export * from './Graph';
+export * from './MultiAgentGraph';

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

@@ -4,9 +4,15 @@ import type { BaseChatModelParams } from '@langchain/core/language_models/chat_m
 import type { BaseMessage, UsageMetadata } from '@langchain/core/messages';
 import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
 import type { AnthropicInput } from '@langchain/anthropic';
+import type { AnthropicMessageCreateParams, AnthropicStreamingMessageCreateParams } from '@/llm/anthropic/types';
 export type CustomAnthropicInput = AnthropicInput & {
     _lc_stream_delay?: number;
 } & BaseChatModelParams;
+/**
+ * A type representing additional parameters that can be passed to the
+ * Anthropic API.
+ */
+type Kwargs = Record<string, any>;
 export declare class CustomAnthropic extends ChatAnthropicMessages {
     _lc_stream_delay: number;
     private message_start;
@@ -14,6 +20,10 @@ export declare class CustomAnthropic extends ChatAnthropicMessages {
     private tools_in_params?;
     private emitted_usage?;
     constructor(fields?: CustomAnthropicInput);
+    /**
+     * Get the parameters used to invoke the model
+     */
+    invocationParams(options?: this['ParsedCallOptions']): Omit<AnthropicMessageCreateParams | AnthropicStreamingMessageCreateParams, 'messages'> & Kwargs;
     /**
      * Get stream usage as returned by this client's API response.
      * @returns The stream usage object.
@@ -23,3 +33,4 @@ export declare class CustomAnthropic extends ChatAnthropicMessages {
     private createGenerationChunk;
     _streamResponseChunks(messages: BaseMessage[], options: this['ParsedCallOptions'], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
 }
+export {};

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

@@ -1,15 +1,15 @@
 import Anthropic from '@anthropic-ai/sdk';
 import { BindToolsInput } from '@langchain/core/language_models/chat_models';
+export type AnthropicStreamUsage = Anthropic.Usage;
+export type AnthropicMessageDeltaEvent = Anthropic.MessageDeltaEvent;
+export type AnthropicMessageStartEvent = Anthropic.MessageStartEvent;
 export type AnthropicToolResponse = {
     type: 'tool_use';
     id: string;
     name: string;
     input: Record<string, any>;
 };
-export type AnthropicStreamUsage = Anthropic.Usage;
 export type AnthropicMessageParam = Anthropic.MessageParam;
-export type AnthropicMessageDeltaEvent = Anthropic.MessageDeltaEvent;
-export type AnthropicMessageStartEvent = Anthropic.MessageStartEvent;
 export type AnthropicMessageResponse = Anthropic.ContentBlock | AnthropicToolResponse;
 export type AnthropicMessageCreateParams = Anthropic.MessageCreateParamsNonStreaming;
 export type AnthropicStreamingMessageCreateParams = Anthropic.MessageCreateParamsStreaming;
@@ -28,4 +28,10 @@ export type AnthropicToolResultBlockParam = Anthropic.Messages.ToolResultBlockPa
 export type AnthropicDocumentBlockParam = Anthropic.Messages.DocumentBlockParam;
 export type AnthropicThinkingBlockParam = Anthropic.Messages.ThinkingBlockParam;
 export type AnthropicRedactedThinkingBlockParam = Anthropic.Messages.RedactedThinkingBlockParam;
+export type AnthropicServerToolUseBlockParam = Anthropic.Messages.ServerToolUseBlockParam;
+export type AnthropicWebSearchToolResultBlockParam = Anthropic.Messages.WebSearchToolResultBlockParam;
+export type AnthropicWebSearchResultBlockParam = Anthropic.Messages.WebSearchResultBlockParam;
+export type AnthropicSearchResultBlockParam = Anthropic.Beta.BetaSearchResultBlockParam;
+export type AnthropicContentBlock = AnthropicTextBlockParam | AnthropicImageBlockParam | AnthropicToolUseBlockParam | AnthropicToolResultBlockParam | AnthropicDocumentBlockParam | AnthropicThinkingBlockParam | AnthropicRedactedThinkingBlockParam | AnthropicServerToolUseBlockParam | AnthropicWebSearchToolResultBlockParam | AnthropicWebSearchResultBlockParam;
+export type ChatAnthropicContentBlock = AnthropicTextBlockParam | AnthropicImageBlockParam | AnthropicToolUseBlockParam | AnthropicToolResultBlockParam | AnthropicDocumentBlockParam | AnthropicThinkingBlockParam | AnthropicRedactedThinkingBlockParam | AnthropicServerToolUseBlockParam | AnthropicWebSearchToolResultBlockParam | AnthropicWebSearchResultBlockParam | AnthropicSearchResultBlockParam;
 export declare function isAnthropicImageBlockParam(block: unknown): block is AnthropicImageBlockParam;

package/dist/types/llm/anthropic/utils/message_inputs.d.ts

@@ -3,7 +3,7 @@
  */
 import { type BaseMessage } from '@langchain/core/messages';
 import { ToolCall } from '@langchain/core/messages/tool';
-import type { AnthropicMessageCreateParams, AnthropicToolResponse } from '@/llm/anthropic/types';
+import { AnthropicMessageCreateParams, AnthropicToolResponse } from '../types';
 export declare function _convertLangChainToolCallToAnthropic(toolCall: ToolCall): AnthropicToolResponse;
 /**
  * Formats messages as a prompt for the model.

package/dist/types/llm/anthropic/utils/output_parsers.d.ts

@@ -1,9 +1,9 @@
-import { z } from 'zod';
 import { BaseLLMOutputParser } from '@langchain/core/output_parsers';
-import { JsonOutputKeyToolsParserParams } from '@langchain/core/output_parsers/openai_tools';
+import { JsonOutputKeyToolsParserParamsInterop } from '@langchain/core/output_parsers/openai_tools';
 import { ChatGeneration } from '@langchain/core/outputs';
 import { ToolCall } from '@langchain/core/messages/tool';
-interface AnthropicToolsOutputParserParams<T extends Record<string, any>> extends JsonOutputKeyToolsParserParams<T> {
+import { InteropZodType } from '@langchain/core/utils/types';
+interface AnthropicToolsOutputParserParams<T extends Record<string, any>> extends JsonOutputKeyToolsParserParamsInterop<T> {
 }
 export declare class AnthropicToolsOutputParser<T extends Record<string, any> = Record<string, any>> extends BaseLLMOutputParser<T> {
     static lc_name(): string;
@@ -13,7 +13,7 @@ export declare class AnthropicToolsOutputParser<T extends Record<string, any> =
     keyName: string;
     /** Whether to return only the first tool call. */
     returnSingle: boolean;
-    zodSchema?: z.ZodType<T>;
+    zodSchema?: InteropZodType<T>;
     constructor(params: AnthropicToolsOutputParserParams<T>);
     protected _validateResult(result: unknown): Promise<T>;
     parseResult(generations: ChatGeneration[]): Promise<T>;

package/dist/types/llm/anthropic/utils/tools.d.ts

@@ -0,0 +1,3 @@
+import type { Anthropic } from '@anthropic-ai/sdk';
+import { AnthropicToolChoice } from '../types.js';
+export declare function handleToolChoice(toolChoice?: AnthropicToolChoice): Anthropic.Messages.ToolChoiceAuto | Anthropic.Messages.ToolChoiceAny | Anthropic.Messages.ToolChoiceTool | undefined;

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

@@ -0,0 +1,13 @@
+import { ChatGenerationChunk } from '@langchain/core/outputs';
+import { ChatGoogleGenerativeAI } from '@langchain/google-genai';
+import type { GenerateContentRequest } from '@google/generative-ai';
+import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
+import type { BaseMessage } from '@langchain/core/messages';
+import type { GeminiGenerationConfig } from '@langchain/google-common';
+import type { GoogleClientOptions } from '@/types';
+export declare class CustomChatGoogleGenerativeAI extends ChatGoogleGenerativeAI {
+    thinkingConfig?: GeminiGenerationConfig['thinkingConfig'];
+    constructor(fields: GoogleClientOptions);
+    invocationParams(options?: this['ParsedCallOptions']): Omit<GenerateContentRequest, 'contents'>;
+    _streamResponseChunks(messages: BaseMessage[], options: this['ParsedCallOptions'], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
+}

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

@@ -0,0 +1,32 @@
+import { CodeExecutionTool, FunctionDeclarationsTool as GoogleGenerativeAIFunctionDeclarationsTool, GoogleSearchRetrievalTool } from '@google/generative-ai';
+import { BindToolsInput } from '@langchain/core/language_models/chat_models';
+export type GoogleGenerativeAIToolType = BindToolsInput | GoogleGenerativeAIFunctionDeclarationsTool | CodeExecutionTool | GoogleSearchRetrievalTool;
+/** Enum for content modality types */
+declare enum Modality {
+    MODALITY_UNSPECIFIED = "MODALITY_UNSPECIFIED",
+    TEXT = "TEXT",
+    IMAGE = "IMAGE",
+    VIDEO = "VIDEO",
+    AUDIO = "AUDIO",
+    DOCUMENT = "DOCUMENT"
+}
+/** Interface for modality token count */
+interface ModalityTokenCount {
+    modality: Modality;
+    tokenCount: number;
+}
+/** Main interface for Gemini API usage metadata */
+export interface GeminiApiUsageMetadata {
+    promptTokenCount?: number;
+    totalTokenCount?: number;
+    thoughtsTokenCount?: number;
+    candidatesTokenCount?: number;
+    toolUsePromptTokenCount?: number;
+    cachedContentTokenCount?: number;
+    promptTokensDetails: ModalityTokenCount[];
+    candidatesTokensDetails?: ModalityTokenCount[];
+    cacheTokensDetails?: ModalityTokenCount[];
+    toolUsePromptTokensDetails?: ModalityTokenCount[];
+    trafficType?: string;
+}
+export {};