@librechat/agents 2.4.321 → 3.0.0-rc1

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

@@ -0,0 +1,16 @@
+import type { AnthropicTextBlockParam, AnthropicWebSearchResultBlockParam } from '@/llm/anthropic/types';
+import type { SearchResultData } from './types';
+/**
+ * Coerces Anthropic web search results to the SearchResultData format
+ * @param results - Array of Anthropic web search results
+ * @param turn - The turn number to associate with these results
+ * @returns SearchResultData with minimal ProcessedOrganic items
+ */
+export declare function coerceAnthropicSearchResults({ results, turn, }: {
+    results: (AnthropicTextBlockParam | AnthropicWebSearchResultBlockParam)[];
+    turn?: number;
+}): SearchResultData;
+/**
+ * Helper function to check if an object is an Anthropic web search result
+ */
+export declare function isAnthropicWebSearchResult(obj: unknown): obj is AnthropicWebSearchResultBlockParam;

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

@@ -8,6 +8,22 @@ export declare class FirecrawlScraper {
     private apiUrl;
     private defaultFormats;
     private timeout;
+    private logger;
+    private includeTags?;
+    private excludeTags?;
+    private waitFor?;
+    private maxAge?;
+    private mobile?;
+    private skipTlsVerification?;
+    private blockAds?;
+    private removeBase64Images?;
+    private parsePDF?;
+    private storeInCache?;
+    private zeroDataRetention?;
+    private headers?;
+    private location?;
+    private onlyMainContent?;
+    private changeTrackingOptions?;
     constructor(config?: t.FirecrawlScraperConfig);
     /**
      * Scrape a single URL

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

@@ -1,25 +1,27 @@
 import type * as t from './types';
 export declare abstract class BaseReranker {
     protected apiKey: string | undefined;
-    constructor();
+    protected logger: t.Logger;
+    constructor(logger?: t.Logger);
     abstract rerank(query: string, documents: string[], topK?: number): Promise<t.Highlight[]>;
     protected getDefaultRanking(documents: string[], topK: number): t.Highlight[];
-    protected logDocumentSamples(documents: string[]): void;
 }
 export declare class JinaReranker extends BaseReranker {
-    constructor({ apiKey }: {
+    constructor({ apiKey, logger, }: {
         apiKey?: string;
+        logger?: t.Logger;
     });
     rerank(query: string, documents: string[], topK?: number): Promise<t.Highlight[]>;
 }
 export declare class CohereReranker extends BaseReranker {
-    constructor({ apiKey }: {
+    constructor({ apiKey, logger, }: {
         apiKey?: string;
+        logger?: t.Logger;
     });
     rerank(query: string, documents: string[], topK?: number): Promise<t.Highlight[]>;
 }
 export declare class InfinityReranker extends BaseReranker {
-    constructor();
+    constructor(logger?: t.Logger);
     rerank(query: string, documents: string[], topK?: number): Promise<t.Highlight[]>;
 }
 /**
@@ -29,4 +31,5 @@ export declare const createReranker: (config: {
     rerankerType: t.RerankerType;
     jinaApiKey?: string;
     cohereApiKey?: string;
+    logger?: t.Logger;
 }) => BaseReranker | undefined;

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

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+export declare enum DATE_RANGE {
+    PAST_HOUR = "h",
+    PAST_24_HOURS = "d",
+    PAST_WEEK = "w",
+    PAST_MONTH = "m",
+    PAST_YEAR = "y"
+}
+export declare const DEFAULT_QUERY_DESCRIPTION: string;
+export declare const DEFAULT_COUNTRY_DESCRIPTION: string;
+export declare const querySchema: z.ZodString;
+export declare const dateSchema: z.ZodOptional<z.ZodNativeEnum<typeof DATE_RANGE>>;
+export declare const countrySchema: z.ZodOptional<z.ZodString>;
+export declare const imagesSchema: z.ZodOptional<z.ZodBoolean>;
+export declare const videosSchema: z.ZodOptional<z.ZodBoolean>;
+export declare const newsSchema: z.ZodOptional<z.ZodBoolean>;

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

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { DynamicStructuredTool } from '@langchain/core/tools';
 import type * as t from './types';
+import { DATE_RANGE } from './schema';
 /**
  * Creates a search tool with a schema that dynamically includes the country field
  * only when the searchProvider is 'serper'.
@@ -10,11 +11,23 @@ import type * as t from './types';
  */
 export declare const createSearchTool: (config?: t.SearchToolConfig) => DynamicStructuredTool<z.ZodObject<{
     query: z.ZodString;
+    date: z.ZodOptional<z.ZodNativeEnum<typeof DATE_RANGE>>;
     country?: z.ZodOptional<z.ZodString>;
+    images: z.ZodOptional<z.ZodBoolean>;
+    videos: z.ZodOptional<z.ZodBoolean>;
+    news: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     query: string;
+    date?: DATE_RANGE | undefined;
+    images?: boolean | undefined;
+    videos?: boolean | undefined;
+    news?: boolean | undefined;
     country?: unknown;
 }, {
     query: string;
+    date?: DATE_RANGE | undefined;
+    images?: boolean | undefined;
+    videos?: boolean | undefined;
+    news?: boolean | undefined;
     country?: unknown;
 }>>;

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

@@ -1,6 +1,8 @@
 import { z } from 'zod';
+import type { Logger as WinstonLogger } from 'winston';
 import type { RunnableConfig } from '@langchain/core/runnables';
 import type { BaseReranker } from './rerankers';
+import { DATE_RANGE } from './schema';
 export type SearchProvider = 'serper' | 'searxng';
 export type RerankerType = 'infinity' | 'jina' | 'cohere' | 'none';
 export interface Highlight {
@@ -78,11 +80,12 @@ export interface ProcessSourcesConfig {
     strategies?: string[];
     filterContent?: boolean;
     reranker?: BaseReranker;
+    logger?: Logger;
 }
 export interface FirecrawlConfig {
     firecrawlApiKey?: string;
     firecrawlApiUrl?: string;
-    firecrawlFormats?: string[];
+    firecrawlOptions?: FirecrawlScraperConfig;
 }
 export interface ScraperContentResult {
     content: string;
@@ -121,10 +124,15 @@ export interface CohereRerankerResponse {
         };
     };
 }
+export type SafeSearchLevel = 0 | 1 | 2;
+export type Logger = WinstonLogger;
 export interface SearchToolConfig extends SearchConfig, ProcessSourcesConfig, FirecrawlConfig {
+    logger?: Logger;
+    safeSearch?: SafeSearchLevel;
     jinaApiKey?: string;
     cohereApiKey?: string;
     rerankerType?: RerankerType;
+    scraperTimeout?: number;
     onSearchResults?: (results: SearchResult, runnableConfig?: RunnableConfig) => void;
     onGetHighlights?: (link: string) => void;
 }
@@ -139,14 +147,7 @@ export type UsedReferences = {
     reference: MediaReference;
 }[];
 /** Firecrawl */
-export interface FirecrawlScrapeOptions {
-    formats?: string[];
-    includeTags?: string[];
-    excludeTags?: string[];
-    headers?: Record<string, string>;
-    waitFor?: number;
-    timeout?: number;
-}
+export type FirecrawlScrapeOptions = Omit<FirecrawlScraperConfig, 'apiKey' | 'apiUrl' | 'logger'>;
 export interface ScrapeMetadata {
     sourceURL?: string;
     url?: string;
@@ -217,11 +218,36 @@ export interface FirecrawlScraperConfig {
     apiUrl?: string;
     formats?: string[];
     timeout?: number;
+    logger?: Logger;
+    includeTags?: string[];
+    excludeTags?: string[];
+    waitFor?: number;
+    maxAge?: number;
+    mobile?: boolean;
+    skipTlsVerification?: boolean;
+    blockAds?: boolean;
+    removeBase64Images?: boolean;
+    parsePDF?: boolean;
+    storeInCache?: boolean;
+    zeroDataRetention?: boolean;
+    headers?: Record<string, string>;
+    location?: {
+        country?: string;
+        languages?: string[];
+    };
+    onlyMainContent?: boolean;
+    changeTrackingOptions?: object;
 }
 export type GetSourcesParams = {
     query: string;
+    date?: DATE_RANGE;
     country?: string;
     numResults?: number;
+    safeSearch?: SearchToolConfig['safeSearch'];
+    images?: boolean;
+    videos?: boolean;
+    news?: boolean;
+    type?: 'search' | 'images' | 'videos' | 'news';
 };
 /** Serper API */
 export interface VideoResult {
@@ -382,6 +408,13 @@ export interface SerperSearchInput {
      */
     autocorrect?: boolean;
     page?: number;
+    /**
+     * Date range for search results
+     * Options: "h" (past hour), "d" (past 24 hours), "w" (past week),
+     * "m" (past month), "y" (past year)
+     * `qdr:${DATE_RANGE}`
+     */
+    tbs?: string;
 }
 export type SerperResultData = {
     searchParameters: SerperSearchPayload;
@@ -486,21 +519,43 @@ export interface SearXNGResult {
     content?: string;
     publishedDate?: string;
     img_src?: string;
+    score?: number;
+    engine?: string;
+    category?: string;
+    thumbnail?: string;
+    priority?: string;
+    engines?: string[];
+    positions?: number[];
+    template?: string;
+    parsed_url?: string[];
 }
 export type ProcessSourcesFields = {
     result: SearchResult;
     numElements: number;
     query: string;
+    news: boolean;
     proMode: boolean;
     onGetHighlights: SearchToolConfig['onGetHighlights'];
 };
 export type SearchToolSchema = z.ZodObject<{
     query: z.ZodString;
+    date: z.ZodOptional<z.ZodNativeEnum<typeof DATE_RANGE>>;
     country?: z.ZodOptional<z.ZodString>;
+    images: z.ZodOptional<z.ZodBoolean>;
+    videos: z.ZodOptional<z.ZodBoolean>;
+    news: z.ZodOptional<z.ZodBoolean>;
 }, 'strip', z.ZodTypeAny, {
     query: string;
+    date?: DATE_RANGE;
     country?: unknown;
+    images?: boolean;
+    videos?: boolean;
+    news?: boolean;
 }, {
     query: string;
+    date?: DATE_RANGE;
     country?: unknown;
+    images?: boolean;
+    videos?: boolean;
+    news?: boolean;
 }>;

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

@@ -1,3 +1,10 @@
 import type * as t from './types';
-export declare const getDomainName: (link: string, metadata?: t.ScrapeMetadata) => string | undefined;
-export declare function getAttribution(link: string, metadata?: t.ScrapeMetadata): string | undefined;
+/**
+ * Creates a default logger that maps to console methods
+ * Uses a singleton pattern to avoid creating multiple instances
+ * @returns A default logger that implements the Logger interface
+ */
+export declare const createDefaultLogger: () => t.Logger;
+export declare const fileExtRegex: RegExp;
+export declare const getDomainName: (link: string, metadata?: t.ScrapeMetadata, logger?: t.Logger) => string | undefined;
+export declare function getAttribution(link: string, metadata?: t.ScrapeMetadata, logger?: t.Logger): string | undefined;

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';