@librechat/agents-types 2.4.321 → 3.0.0

package/graph.ts

@@ -1,77 +1,241 @@
 // src/types/graph.ts
-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 { RunnableConfig } from '@langchain/core/runnables';
+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[];
-  // [key: string]: unknown;
 };
 
-export type IState = BaseGraphState;
+export type MultiAgentGraphState = BaseGraphState & {
+  agentMessages?: BaseMessage[];
+};
 
-// export interface IState extends BaseGraphState {
-//   instructions?: string;
-//   additional_instructions?: string;
-// }
+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 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 CompiledMultiAgentWorkflow = CompiledStateGraph<
+  StateType<{
+    messages: BinaryOperatorAggregate<BaseMessage[], BaseMessage[]>;
+    agentMessages: BinaryOperatorAggregate<BaseMessage[], BaseMessage[]>;
+  }>,
+  UpdateType<{
+    messages: BinaryOperatorAggregate<BaseMessage[], BaseMessage[]>;
+    agentMessages: BinaryOperatorAggregate<BaseMessage[], BaseMessage[]>;
+  }>,
+  string,
+  {
+    messages: BinaryOperatorAggregate<BaseMessage[], BaseMessage[]>;
+    agentMessages: BinaryOperatorAggregate<BaseMessage[], BaseMessage[]>;
+  },
+  {
+    messages: BinaryOperatorAggregate<BaseMessage[], BaseMessage[]>;
+    agentMessages: BinaryOperatorAggregate<BaseMessage[], BaseMessage[]>;
+  },
+  StateDefinition
+>;
 
-export type Workflow<T extends BaseGraphState = BaseGraphState, U extends Partial<T> = Partial<T>, N extends string = string> = StateGraph<T, U, N>;
+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>;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    [x: `tools=${string}`]: any;
+  }
+>;
 
-export type CompiledWorkflow<T extends BaseGraphState = BaseGraphState, U extends Partial<T> = Partial<T>, N extends string = string> = CompiledStateGraph<T, U, N>;
+export type SystemRunnable =
+  | Runnable<
+      BaseMessage[],
+      (BaseMessage | SystemMessage)[],
+      RunnableConfig<Record<string, unknown>>
+    >
+  | undefined;
 
-export type EventStreamCallbackHandlerInput = Parameters<CompiledWorkflow['streamEvents']>[2] extends Omit<infer T, 'autoClose'> ? T : never;
+/**
+ * Optional compile options passed to workflow.compile().
+ * These are intentionally untyped to avoid coupling to library internals.
+ */
+export type CompileOptions = {
+  // A checkpointer instance (e.g., MemorySaver, SQL saver)
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  checkpointer?: any;
+  interruptBefore?: string[];
+  interruptAfter?: string[];
+};
+
+export type EventStreamCallbackHandlerInput =
+  Parameters<CompiledWorkflow['streamEvents']>[2] extends Omit<
+    infer T,
+    'autoClose'
+  >
+    ? T
+    : never;
 
-export type StreamChunk = ChatGenerationChunk & {
-  message: AIMessageChunk;
-} | AIMessageChunk;
+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;
+  /**
+   * 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;
+  /**
+   * Custom field to indicate the event was manually emitted, and may have been handled already
+   */
+  emitted?: boolean;
 };
 
 /**
@@ -80,54 +244,54 @@ export type StreamEventData = {
  * 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;
+  /**
+   * 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;
-    run_id?: string;
+  provider: string;
+  thread_id?: string;
+  run_id?: string;
 };
 
 export type PartMetadata = {
@@ -138,18 +302,71 @@ export type PartMetadata = {
   output?: string;
 };
 
-export type ModelEndData = StreamEventData & { output: AIMessageChunk | undefined } | undefined;
-
+export type ModelEndData =
+  | (StreamEventData & { output: AIMessageChunk | 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 = {
+  /** Agent ID, use a list for multiple sources */
+  from: string | string[];
+  /** Agent ID, 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';
+  /**
+   * For direct edges: Optional prompt to add when transitioning through this edge.
+   * String prompts can include variables like {results} which will be replaced with
+   * messages from startIndex onwards. When {results} is used, excludeResults defaults to true.
+   *
+   * For handoff edges: Description for the input parameter that the handoff tool accepts,
+   * allowing the supervisor to pass specific instructions/context to the transferred agent.
+   */
+  prompt?:
+    | string
+    | ((
+        messages: BaseMessage[],
+        runStartIndex: number
+      ) => string | Promise<string> | undefined);
+  /**
+   * When true, excludes messages from startIndex when adding prompt.
+   * Automatically set to true when {results} variable is used in prompt.
+   */
+  excludeResults?: boolean;
+  /**
+   * For handoff edges: Customizes the parameter name for the handoff input.
+   * Defaults to "instructions" if not specified.
+   * Only applies when prompt is provided for handoff edges.
+   */
+  promptKey?: string;
+};
+
+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';
-};
+  /** Format content blocks as strings (for legacy compatibility i.e. Ollama/Azure Serverless) */
+  useLegacyContent?: boolean;
+}

package/llm.ts

@@ -1,10 +1,7 @@
 // src/types/llm.ts
 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,
@@ -18,11 +15,13 @@ import type {
 } 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';
@@ -30,12 +29,15 @@ import type { ChatOllamaInput } from '@langchain/ollama';
 import type { OpenAI as OpenAIClient } from 'openai';
 import type { ChatXAIInput } from '@langchain/xai';
 import {
-  ChatXAI,
-  ChatOpenAI,
-  ChatDeepSeek,
   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> &
@@ -60,14 +62,19 @@ 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;
 
@@ -84,9 +91,16 @@ export type ClientOptions =
   | DeepSeekClientOptions
   | XAIClientOptions;
 
-export type LLMConfig = {
+export type SharedLLMConfig = {
   provider: Providers;
-} & ClientOptions;
+  _lc_stream_delay?: number;
+};
+
+export type LLMConfig = SharedLLMConfig &
+  ClientOptions & {
+    /** Optional provider fallbacks in order of attempt */
+    fallbacks?: Array<{ provider: Providers; clientOptions?: ClientOptions }>;
+  };
 
 export type ProviderOptionsMap = {
   [Providers.AZURE]: AzureClientOptions;
@@ -111,13 +125,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 = {

package/messages.ts

@@ -0,0 +1,4 @@
+import type Anthropic from '@anthropic-ai/sdk';
+import type { BaseMessage } from '@langchain/core/messages';
+export type AnthropicMessages = Array<AnthropicMessage | BaseMessage>;
+export type AnthropicMessage = Anthropic.MessageParam;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@librechat/agents-types",
-  "version": "2.4.321",
+  "version": "3.0.00",
   "description": "Type definitions for @librechat/agents",
   "types": "index.d.ts",
   "scripts": {

package/run.ts

@@ -7,7 +7,6 @@ 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';
@@ -16,21 +15,58 @@ 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 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'>;
+
+/* Supervised graph (opt-in) */
+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 {
@@ -60,14 +96,25 @@ export type TaskManagerGraphConfig = {
   supervisorConfig: { systemPrompt?: string; llmConfig: l.LLMConfig };
 };
 
+export type MultiAgentGraphConfig = {
+  type: 'multi-agent';
+  compileOptions?: g.CompileOptions;
+  agents: g.AgentInputs[];
+  edges: g.GraphEdge[];
+};
+
+export type StandardGraphConfig = Omit<
+  MultiAgentGraphConfig,
+  'edges' | 'type'
+> & { type?: 'standard'; signal?: AbortSignal };
+
 export type RunConfig = {
   runId: string;
-  graphConfig:
-    | StandardGraphConfig
-    | CollaborativeGraphConfig
-    | TaskManagerGraphConfig;
+  graphConfig: LegacyGraphConfig | StandardGraphConfig | MultiAgentGraphConfig;
   customHandlers?: Record<string, g.EventHandler>;
   returnContent?: boolean;
+  tokenCounter?: TokenCounter;
+  indexTokenCountMap?: Record<string, number>;
 };
 
 export type ProvidedCallbacks =
@@ -76,10 +123,6 @@ export type ProvidedCallbacks =
 
 export type TokenCounter = (message: BaseMessage) => number;
 export type EventStreamOptions = {
-  callbacks?: graph.ClientCallbacks;
+  callbacks?: g.ClientCallbacks;
   keepContent?: boolean;
-  /* Context Management */
-  maxContextTokens?: number;
-  tokenCounter?: TokenCounter;
-  indexTokenCountMap?: Record<string, number>;
 };

package/stream.ts

@@ -8,6 +8,8 @@ import type {
 } 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';
 
@@ -103,7 +105,7 @@ export type MessageCreationDetails = {
 
 export type ToolEndData = {
   input: string | Record<string, unknown>;
-  output?: ToolMessage;
+  output?: ToolMessage | Command;
 };
 export type ToolErrorData = {
   id: string;
@@ -251,6 +253,12 @@ export type ReasoningContentText = {
   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;
@@ -293,7 +301,20 @@ export type ToolCallContent = {
   tool_call?: ToolCallPart;
 };
 
+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

package/tools.ts

@@ -1,6 +1,6 @@
 // src/types/tools.ts
-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';
@@ -13,9 +13,10 @@ export type CustomToolCall = {
   id?: string;
   type?: 'tool_call';
   output?: string;
-}
+};
 
 export type GenericTool = StructuredToolInterface | RunnableToolLike;
+
 export type ToolMap = Map<string, GenericTool>;
 export type ToolRefs = {
   tools: GenericTool[];
@@ -30,7 +31,10 @@ export type ToolNodeOptions = {
   handleToolErrors?: boolean;
   loadRuntimeTools?: ToolRefGenerator;
   toolCallStepIds?: Map<string, string>;
-  errorHandler?: (data: ToolErrorData, metadata?: Record<string, unknown>) => void
+  errorHandler?: (
+    data: ToolErrorData,
+    metadata?: Record<string, unknown>
+  ) => void;
 };
 
 export type ToolNodeConstructorParams = ToolRefs & ToolNodeOptions;
@@ -50,13 +54,15 @@ export type CodeEnvFile = {
   session_id: string;
 };
 
-export type CodeExecutionToolParams = undefined | {
-  session_id?: string;
-  user_id?: string;
-  apiKey?: string;
-  files?: CodeEnvFile[];
-  [EnvVar.CODE_API_KEY]?: string;
-}
+export type CodeExecutionToolParams =
+  | undefined
+  | {
+      session_id?: string;
+      user_id?: string;
+      apiKey?: string;
+      files?: CodeEnvFile[];
+      [EnvVar.CODE_API_KEY]?: string;
+    };
 
 export type FileRef = {
   id: string;