@illuma-ai/agents 1.0.81

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

@@ -0,0 +1,399 @@
+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 { GoogleAIToolType } from '@langchain/google-common';
+import type { ToolMap, ToolEndEvent, GenericTool, LCTool } from '@/types/tools';
+import type { Providers, Callback, GraphNodeKeys } from '@/common';
+import type { StandardGraph, MultiAgentGraph } from '@/graphs';
+import type { ClientOptions } from '@/types/llm';
+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[];
+    /**
+     * Structured response when using structured output mode.
+     * Contains the validated JSON response conforming to the configured schema.
+     */
+    structuredResponse?: Record<string, unknown>;
+};
+export type MultiAgentGraphState = BaseGraphState & {
+    agentMessages?: BaseMessage[];
+};
+export type IState = BaseGraphState;
+export interface EventHandler {
+    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 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 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 & {
+    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;
+    /**
+     * Custom field to indicate the event was manually emitted, and may have been handled already
+     */
+    emitted?: boolean;
+};
+/**
+ * A streaming event.
+ *
+ * Schema of a streaming event which is produced from the streamEvents method.
+ */
+export type StreamEvent = {
+    /**
+     * Event names are of the format: on_[runnable_type]_(start|stream|end).
+     *
+     * Runnable types are one of:
+     * - llm - used by non chat models
+     * - chat_model - used by chat models
+     * - prompt --  e.g., ChatPromptTemplate
+     * - tool -- LangChain tools
+     * - chain - most Runnables are of this type
+     *
+     * Further, the events are categorized as one of:
+     * - start - when the runnable starts
+     * - stream - when the runnable is streaming
+     * - end - when the runnable ends
+     *
+     * start, stream and end are associated with slightly different `data` payload.
+     *
+     * Please see the documentation for `EventData` for more details.
+     */
+    event: string;
+    /** The name of the runnable that generated the event. */
+    name: string;
+    /**
+     * An randomly generated ID to keep track of the execution of the given runnable.
+     *
+     * Each child runnable that gets invoked as part of the execution of a parent runnable
+     * is assigned its own unique ID.
+     */
+    run_id: string;
+    /**
+     * Tags associated with the runnable that generated this event.
+     * Tags are always inherited from parent runnables.
+     */
+    tags?: string[];
+    /** Metadata associated with the runnable that generated this event. */
+    metadata: Record<string, unknown>;
+    /**
+     * Event data.
+     *
+     * The contents of the event data depend on the event type.
+     */
+    data: StreamEventData;
+};
+export type GraphConfig = {
+    provider: string;
+    thread_id?: string;
+    run_id?: string;
+};
+export type PartMetadata = {
+    progress?: number;
+    asset_pointer?: string;
+    status?: string;
+    action?: boolean;
+    output?: string;
+};
+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[];
+};
+/**
+ * Structured output mode determines how the agent returns structured data.
+ * - 'tool': Uses tool calling to return structured output (works with all tool-calling models)
+ * - 'provider': Uses provider-native structured output via LangChain's jsonMode (OpenAI, Anthropic, etc.)
+ * - 'native': Uses provider's constrained decoding API directly for guaranteed schema compliance
+ *   (Anthropic output_config.format, OpenAI response_format.json_schema). Falls back to 'tool' for unsupported providers.
+ * - 'auto': Automatically selects the best strategy — 'native' for supported providers, 'tool' for others
+ */
+export type StructuredOutputMode = 'tool' | 'provider' | 'native' | 'auto';
+/**
+ * Resolved method used internally after mode resolution.
+ * Maps to LangChain's withStructuredOutput method parameter plus our native path.
+ */
+export type ResolvedStructuredOutputMethod = 'functionCalling' | 'jsonMode' | 'jsonSchema' | 'native' | undefined;
+/**
+ * Error thrown when the model refuses to produce structured output due to safety policies.
+ */
+export declare class StructuredOutputRefusalError extends Error {
+    refusalText: string;
+    constructor(refusalText: string);
+}
+/**
+ * Error thrown when the structured output response was truncated due to max_tokens.
+ */
+export declare class StructuredOutputTruncatedError extends Error {
+    stopReason: string;
+    constructor(stopReason: string);
+}
+/**
+ * Configuration for structured JSON output from agents.
+ * When configured, the agent will return a validated JSON response
+ * instead of streaming text.
+ */
+export interface StructuredOutputConfig {
+    /**
+     * JSON Schema defining the output structure.
+     * The model will be forced to return data conforming to this schema.
+     */
+    schema: Record<string, unknown>;
+    /**
+     * Name for the structured output format (used in tool mode).
+     * @default 'StructuredResponse'
+     */
+    name?: string;
+    /**
+     * Description of what the structured output represents.
+     * Helps the model understand the expected format.
+     */
+    description?: string;
+    /**
+     * Output mode strategy.
+     * @default 'auto'
+     */
+    mode?: StructuredOutputMode;
+    /**
+     * Enable strict schema validation.
+     * When true, the response must exactly match the schema.
+     * @default true
+     */
+    strict?: boolean;
+    /**
+     * Error handling configuration.
+     * - true: Auto-retry on validation errors (default)
+     * - false: Throw error on validation failure
+     * - string: Custom error message for retry
+     */
+    handleErrors?: boolean | string;
+    /**
+     * Maximum number of retry attempts on validation failure.
+     * @default 2
+     */
+    maxRetries?: number;
+    /**
+     * Include the raw AI message along with structured response.
+     * Useful for debugging.
+     * @default false
+     */
+    includeRaw?: boolean;
+}
+/**
+ * Database/API structured output format (snake_case with enabled flag).
+ * This matches the format stored in MongoDB and sent from frontends.
+ */
+export interface StructuredOutputInput {
+    /** Whether structured output is enabled */
+    enabled?: boolean;
+    /** JSON Schema defining the expected response structure */
+    schema?: Record<string, unknown>;
+    /** Name identifier for the structured output */
+    name?: string;
+    /** Description of what the structured output represents */
+    description?: string;
+    /** Mode for structured output: 'tool' | 'provider' | 'native' | 'auto' */
+    mode?: StructuredOutputMode;
+    /** Whether to enforce strict schema validation */
+    strict?: boolean;
+}
+export interface AgentInputs {
+    agentId: string;
+    /** Human-readable name for the agent (used in handoff context). Defaults to agentId if not provided. */
+    name?: string;
+    toolEnd?: boolean;
+    toolMap?: ToolMap;
+    tools?: GraphTools;
+    provider: Providers;
+    instructions?: string;
+    streamBuffer?: number;
+    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;
+    /**
+     * Tool definitions for all tools, including deferred and programmatic.
+     * Used for tool search and programmatic tool calling.
+     * Maps tool name to LCTool definition.
+     */
+    toolRegistry?: Map<string, LCTool>;
+    /**
+     * Dynamic context that changes per-request (e.g., current time, user info).
+     * This is injected as a user message rather than system prompt to preserve cache.
+     * Keeping this separate from instructions ensures the system message stays static
+     * and can be cached by Bedrock/Anthropic prompt caching.
+     */
+    dynamicContext?: string;
+    /**
+     * Structured output configuration (camelCase).
+     * When set, disables streaming and returns a validated JSON response
+     * conforming to the specified schema.
+     */
+    structuredOutput?: StructuredOutputConfig;
+    /**
+     * Structured output configuration (snake_case - database/API format).
+     * Alternative to structuredOutput for compatibility with MongoDB/frontend.
+     * Uses an `enabled` flag to control activation.
+     * @deprecated Use structuredOutput instead when possible
+     */
+    structured_output?: StructuredOutputInput;
+    /**
+     * Serializable tool definitions for event-driven execution.
+     * When provided, ToolNode operates in event-driven mode, dispatching
+     * ON_TOOL_EXECUTE events instead of invoking tools directly.
+     */
+    toolDefinitions?: LCTool[];
+    /**
+     * Tool names discovered from previous conversation history.
+     * These tools will be pre-marked as discovered so they're included
+     * in tool binding without requiring tool_search.
+     */
+    discoveredTools?: string[];
+    /**
+     * Optional callback for summarizing messages that were pruned from context.
+     * When provided, discarded messages are summarized by the caller (e.g., Ranger)
+     * using a cheap LLM call, and the summary is prepended to the context.
+     */
+    summarizeCallback?: (messagesToRefine: import('@langchain/core/messages').BaseMessage[]) => Promise<string | undefined>;
+}

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

@@ -0,0 +1,5 @@
+export * from './graph';
+export * from './llm';
+export * from './run';
+export * from './stream';
+export * from './tools';

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

@@ -0,0 +1,105 @@
+import { ChatMistralAI } from '@langchain/mistralai';
+import type { BindToolsInput, BaseChatModelParams } from '@langchain/core/language_models/chat_models';
+import type { OpenAIChatInput, ChatOpenAIFields, AzureOpenAIInput, ClientOptions as OAIClientOptions } from '@langchain/openai';
+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 { OpenAI as OpenAIClient } from 'openai';
+import type { ChatXAIInput } from '@langchain/xai';
+import { AzureChatOpenAI, ChatDeepSeek, ChatMoonshot, ChatOpenAI, ChatXAI } from '@/llm/openai';
+import { CustomChatGoogleGenerativeAI } from '@/llm/google';
+import { CustomChatBedrockConverse } from '@/llm/bedrock';
+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;
+    openAIApiVersion?: string;
+    openAIBasePath?: string;
+    deploymentName?: string;
+} & BaseChatModelParams & {
+    configuration?: OAIClientOptions;
+};
+export type ThinkingConfig = AnthropicInput['thinking'];
+export type ChatOpenAIToolType = BindToolsInput | OpenAIClient.ChatCompletionTool;
+export type CommonToolType = StructuredTool | ChatOpenAIToolType;
+export type AnthropicReasoning = {
+    thinking?: ThinkingConfig | boolean;
+    thinkingBudget?: number;
+};
+export type OpenAIClientOptions = ChatOpenAIFields;
+export type AnthropicClientOptions = AnthropicInput & {
+    promptCache?: boolean;
+};
+export type MistralAIClientOptions = ChatMistralAIInput;
+export type VertexAIClientOptions = ChatVertexAIInput & {
+    includeThoughts?: boolean;
+};
+export type BedrockAnthropicInput = ChatBedrockConverseInput & {
+    additionalModelRequestFields?: ChatBedrockConverseInput['additionalModelRequestFields'] & AnthropicReasoning;
+    promptCache?: boolean;
+};
+export type BedrockConverseClientOptions = ChatBedrockConverseInput;
+export type BedrockAnthropicClientOptions = BedrockAnthropicInput;
+export type GoogleClientOptions = GoogleGenerativeAIChatInput & {
+    customHeaders?: RequestOptions['customHeaders'];
+    thinkingConfig?: GeminiGenerationConfig['thinkingConfig'];
+};
+export type DeepSeekClientOptions = ChatDeepSeekCallOptions;
+export type XAIClientOptions = ChatXAIInput;
+export type ClientOptions = OpenAIClientOptions | AzureClientOptions | AnthropicClientOptions | MistralAIClientOptions | VertexAIClientOptions | BedrockConverseClientOptions | GoogleClientOptions | DeepSeekClientOptions | XAIClientOptions;
+export type SharedLLMConfig = {
+    provider: Providers;
+    _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;
+    [Providers.OPENAI]: OpenAIClientOptions;
+    [Providers.GOOGLE]: GoogleClientOptions;
+    [Providers.VERTEXAI]: VertexAIClientOptions;
+    [Providers.DEEPSEEK]: DeepSeekClientOptions;
+    [Providers.ANTHROPIC]: AnthropicClientOptions;
+    [Providers.MISTRALAI]: MistralAIClientOptions;
+    [Providers.MISTRAL]: MistralAIClientOptions;
+    [Providers.OPENROUTER]: ChatOpenRouterCallOptions;
+    [Providers.BEDROCK]: BedrockConverseClientOptions;
+    [Providers.XAI]: XAIClientOptions;
+    [Providers.MOONSHOT]: OpenAIClientOptions;
+};
+export type ChatModelMap = {
+    [Providers.XAI]: ChatXAI;
+    [Providers.OPENAI]: ChatOpenAI;
+    [Providers.AZURE]: AzureChatOpenAI;
+    [Providers.DEEPSEEK]: ChatDeepSeek;
+    [Providers.VERTEXAI]: ChatVertexAI;
+    [Providers.ANTHROPIC]: CustomAnthropic;
+    [Providers.MISTRALAI]: ChatMistralAI;
+    [Providers.MISTRAL]: ChatMistralAI;
+    [Providers.OPENROUTER]: ChatOpenRouter;
+    [Providers.BEDROCK]: CustomChatBedrockConverse;
+    [Providers.GOOGLE]: CustomChatGoogleGenerativeAI;
+    [Providers.MOONSHOT]: ChatMoonshot;
+};
+export type ChatModelConstructorMap = {
+    [P in Providers]: new (config: ProviderOptionsMap[P]) => ChatModelMap[P];
+};
+export type ChatModelInstance = ChatModelMap[Providers];
+export type ModelWithTools = ChatModelInstance & {
+    bindTools(tools: CommonToolType[]): Runnable;
+};

package/dist/types/types/messages.d.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/dist/types/types/run.d.ts

@@ -0,0 +1,112 @@
+import type * as z from 'zod';
+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 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 = {
+    llmConfig: l.LLMConfig;
+    provider?: e.Providers;
+    clientOptions?: l.ClientOptions;
+    /** Optional compile options for workflow.compile() */
+    compileOptions?: g.CompileOptions;
+};
+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[];
+    next: string;
+    [key: string]: unknown;
+    instructions?: string;
+    additional_instructions?: string;
+}
+export interface Member {
+    name: string;
+    systemPrompt: string;
+    tools: StructuredTool[];
+    llmConfig: l.LLMConfig;
+}
+export type CollaborativeGraphConfig = {
+    type: 'collaborative';
+    members: Member[];
+    supervisorConfig: {
+        systemPrompt?: string;
+        llmConfig: l.LLMConfig;
+    };
+};
+export type TaskManagerGraphConfig = {
+    type: 'taskmanager';
+    members: Member[];
+    supervisorConfig: {
+        systemPrompt?: string;
+        llmConfig: l.LLMConfig;
+    };
+};
+export type 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: LegacyGraphConfig | StandardGraphConfig | 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?: g.ClientCallbacks;
+    keepContent?: boolean;
+};