@langchain/langgraph 1.1.1 → 1.1.2

package/dist/graph/state.d.ts

@@ -8,7 +8,7 @@ import { AddNodeOptions, Branch, CompiledGraph, Graph, NodeSpec } from "./graph.
 import { InferInterruptInputType, InferInterruptResumeType } from "../interrupt.js";
 import { InferWriterType } from "../writer.js";
 import { AnyStateSchema } from "../state/schema.js";
-import { ExtractStateType, ExtractUpdateType, StateDefinitionInit, ToStateDefinition } from "./types.js";
+import { ContextSchemaInit, ExtractStateType, ExtractUpdateType, StateDefinitionInit, StateGraphInit, StateGraphOptions, ToStateDefinition } from "./types.js";
 import { All, BaseCache, BaseCheckpointSaver, BaseStore } from "@langchain/langgraph-checkpoint";
 import { InteropZodObject } from "@langchain/core/utils/types";
 
@@ -26,10 +26,16 @@ type StateGraphNodeSpec<RunInput, RunOutput> = NodeSpec<RunInput, RunOutput> & {
   retryPolicy?: RetryPolicy;
   cachePolicy?: CachePolicy;
 };
-type StateGraphAddNodeOptions<Nodes extends string = string> = {
+/**
+ * Options for StateGraph.addNode() method.
+ *
+ * @template Nodes - Node name constraints
+ * @template InputSchema - Per-node input schema type (inferred from options.input)
+ */
+type StateGraphAddNodeOptions<Nodes extends string = string, InputSchema extends StateDefinitionInit | undefined = StateDefinitionInit | undefined> = {
   retryPolicy?: RetryPolicy;
   cachePolicy?: CachePolicy | boolean;
-  input?: AnnotationRoot<any> | InteropZodObject;
+  input?: InputSchema;
 } & AddNodeOptions<Nodes>;
 type StateGraphArgsWithStateSchema<SD extends StateDefinition, I extends StateDefinition, O extends StateDefinition> = {
   stateSchema: AnnotationRoot<SD>;
@@ -40,11 +46,6 @@ type StateGraphArgsWithInputOutputSchemas<SD extends StateDefinition, O extends
   input: AnnotationRoot<SD>;
   output: AnnotationRoot<O>;
 };
-type ZodStateGraphArgsWithStateSchema<SD extends InteropZodObject, I extends StateDefinitionInit, O extends StateDefinitionInit> = {
-  state: SD;
-  input?: I;
-  output?: O;
-};
 type ExtractStateDefinition<T> = T extends AnyStateSchema ? T : T extends StateDefinitionInit ? ToStateDefinition<T> : StateDefinition;
 type NodeAction<S, U, C extends StateDefinitionInit, InterruptType, WriterType> = RunnableLike<S, U extends object ? U & Record<string, any> : U, Runtime<StateType<ToStateDefinition<C>>, InterruptType, WriterType>>;
 type StrictNodeAction<S, U, C extends StateDefinitionInit, Nodes extends string, InterruptType, WriterType> = RunnableLike<Prettify<S>, U | Command<InferInterruptResumeType<InterruptType>, U & Record<string, any>, Nodes>, Runtime<StateType<ToStateDefinition<C>>, InterruptType, WriterType>>;
@@ -145,39 +146,71 @@ declare class StateGraph<SD extends StateDefinitionInit | unknown, S = ExtractSt
   /** @internal */
   _writer: WriterType;
   Node: StrictNodeAction<S, U, C, N, InterruptType, WriterType>;
-  constructor(state: SD extends StateDefinition ? AnnotationRoot<SD> : never, options?: {
-    context?: C | AnnotationRoot<ToStateDefinition<C>>;
-    input?: I | AnnotationRoot<ToStateDefinition<I>>;
-    output?: O | AnnotationRoot<ToStateDefinition<O>>;
-    interrupt?: InterruptType;
-    writer?: WriterType;
-    nodes?: N[];
-  });
-  constructor(state: SD extends AnyStateSchema ? SD : never, options?: {
-    context?: C | AnnotationRoot<ToStateDefinition<C>>;
-    input?: I | AnnotationRoot<ToStateDefinition<I>>;
-    output?: O | AnnotationRoot<ToStateDefinition<O>>;
-    interrupt?: InterruptType;
-    writer?: WriterType;
-    nodes?: N[];
-  });
-  constructor(state: SD extends InteropZodObject ? SD : never, options?: {
-    context?: C | AnnotationRoot<ToStateDefinition<C>>;
-    input?: I | AnnotationRoot<ToStateDefinition<I>>;
-    output?: O | AnnotationRoot<ToStateDefinition<O>>;
-    interrupt?: InterruptType;
-    writer?: WriterType;
-    nodes?: N[];
-  });
+  /**
+   * Create a new StateGraph for building stateful, multi-step workflows.
+   *
+   * Accepts state definitions via `Annotation.Root`, `StateSchema`, or Zod schemas.
+   *
+   * @example Direct schema
+   * ```ts
+   * const StateAnnotation = Annotation.Root({
+   *   messages: Annotation<string[]>({ reducer: (a, b) => [...a, ...b] }),
+   * });
+   * const graph = new StateGraph(StateAnnotation);
+   * ```
+   *
+   * @example Direct schema with input/output filtering
+   * ```ts
+   * const graph = new StateGraph(StateAnnotation, {
+   *   input: InputSchema,
+   *   output: OutputSchema,
+   * });
+   * ```
+   *
+   * @example Object pattern with state, input, output
+   * ```ts
+   * const graph = new StateGraph({
+   *   state: FullStateSchema,
+   *   input: InputSchema,
+   *   output: OutputSchema,
+   * });
+   * ```
+   *
+   * @example Input/output only (state inferred from input)
+   * ```ts
+   * const graph = new StateGraph({
+   *   input: InputAnnotation,
+   *   output: OutputAnnotation,
+   * });
+   * ```
+   */
+  constructor(state: SD extends StateDefinitionInit ? SD : never, options?: C | AnnotationRoot<ToStateDefinition<C>> | StateGraphOptions<I, O, C, N, InterruptType, WriterType>);
   constructor(fields: SD extends StateDefinition ? StateGraphArgsWithInputOutputSchemas<SD, ToStateDefinition<O>> : never, contextSchema?: C | AnnotationRoot<ToStateDefinition<C>>);
   constructor(fields: SD extends StateDefinition ? AnnotationRoot<SD> | StateGraphArgsWithStateSchema<SD, ToStateDefinition<I>, ToStateDefinition<O>> : never, contextSchema?: C | AnnotationRoot<ToStateDefinition<C>>);
-  /** @deprecated Use `Annotation.Root` or `zod` for state definition instead. */
-  constructor(fields: SD extends StateDefinition ? SD | StateGraphArgs<S> : StateGraphArgs<S>, contextSchema?: C | AnnotationRoot<ToStateDefinition<C>>);
-  constructor(fields: SD extends InteropZodObject ? SD | ZodStateGraphArgsWithStateSchema<SD, I, O> : never, contextSchema?: C | AnnotationRoot<ToStateDefinition<C>>);
+  constructor(init: Omit<StateGraphInit<SD extends StateDefinitionInit ? SD : StateDefinitionInit, SD extends StateDefinitionInit ? SD : StateDefinitionInit, O, C extends ContextSchemaInit ? C : undefined, N, InterruptType, WriterType>, "state" | "stateSchema" | "input"> & {
+    input: SD extends StateDefinitionInit ? SD : never;
+    state?: never;
+    stateSchema?: never;
+  }, contextSchema?: C | AnnotationRoot<ToStateDefinition<C>>);
+  constructor(init: StateGraphInit<SD extends StateDefinitionInit ? SD : StateDefinitionInit, I, O, C extends ContextSchemaInit ? C : undefined, N, InterruptType, WriterType>);
+  /** @deprecated Use `Annotation.Root`, `StateSchema`, or Zod schemas instead. */
+  constructor(fields: StateGraphArgs<S>, contextSchema?: C | AnnotationRoot<ToStateDefinition<C>>);
+  /**
+   * Normalize all constructor input patterns to a unified StateGraphInit object.
+   * @internal
+   */
+  private _normalizeToStateGraphInit;
+  /**
+   * Convert any supported schema type to a StateDefinition (channel map).
+   * @internal
+   */
+  private _getChannelsFromSchema;
   get allEdges(): Set<[string, string]>;
   _addSchema(stateDefinition: StateDefinitionInit): void;
   addNode<K extends string, NodeMap extends Record<K, NodeAction<S, U, C, InterruptType, WriterType>>>(nodes: NodeMap): StateGraph<SD, S, U, N | K, I, O, C, MergeReturnType<NodeReturnType, { [key in keyof NodeMap]: NodeMap[key] extends NodeAction<S, infer U, C, InterruptType, WriterType> ? U : never }>>;
   addNode<K extends string, NodeInput = S, NodeOutput extends U = U>(nodes: [key: K, action: NodeAction<NodeInput, NodeOutput, C, InterruptType, WriterType>, options?: StateGraphAddNodeOptions][]): StateGraph<SD, S, U, N | K, I, O, C, MergeReturnType<NodeReturnType, { [key in K]: NodeOutput }>>;
+  addNode<K extends string, InputSchema extends StateDefinitionInit, NodeOutput extends U = U>(key: K, action: NodeAction<ExtractStateType<InputSchema>, NodeOutput, C, InterruptType, WriterType>, options: StateGraphAddNodeOptions<N | K, InputSchema>): StateGraph<SD, S, U, N | K, I, O, C, MergeReturnType<NodeReturnType, { [key in K]: NodeOutput }>>;
+  addNode<K extends string, InputSchema extends StateDefinitionInit, NodeOutput extends U = U>(key: K, action: NodeAction<ExtractStateType<InputSchema>, NodeOutput, C, InterruptType, WriterType>, options: StateGraphAddNodeOptions<N | K, InputSchema>): StateGraph<SD, S, U, N | K, I, O, C, MergeReturnType<NodeReturnType, { [key in K]: NodeOutput }>>;
   addNode<K extends string, NodeInput = S, NodeOutput extends U = U>(key: K, action: NodeAction<NodeInput, NodeOutput, C, InterruptType, WriterType>, options?: StateGraphAddNodeOptions): StateGraph<SD, S, U, N | K, I, O, C, MergeReturnType<NodeReturnType, { [key in K]: NodeOutput }>>;
   addNode<K extends string, NodeInput = S>(key: K, action: NodeAction<NodeInput, U, C, InterruptType, WriterType>, options?: StateGraphAddNodeOptions): StateGraph<SD, S, U, N | K, I, O, C, NodeReturnType>;
   addEdge(startKey: typeof START | N | N[], endKey: N | typeof END): this;

package/dist/graph/state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"state.d.ts","names":["All","BaseCache","BaseCheckpointSaver","BaseStore","InteropZodObject","RunnableLike","Runtime","BaseChannel","CompiledGraph","Graph","Branch","AddNodeOptions","NodeSpec","Command","START","END","CommandInstance","Interrupt","INTERRUPT","AnnotationRoot","SingleReducer","StateDefinition","StateType","CachePolicy","RetryPolicy","SchemaMetaRegistry","InferInterruptResumeType","InferInterruptInputType","InferWriterType","AnyStateSchema","ExtractStateType","ExtractUpdateType","ToStateDefinition","StateDefinitionInit","ChannelReducers","Channels","K","StateGraphArgs","StateGraphNodeSpec","RunInput","RunOutput","StateGraphAddNodeOptions","Nodes","StateGraphArgsWithStateSchema","SD","I","O","StateGraphArgsWithInputOutputSchemas","ZodStateGraphArgsWithStateSchema","ExtractStateDefinition","T","NodeAction","S","U","Record","C","InterruptType","WriterType","StrictNodeAction","Prettify","PartialStateSchema","MergeReturnType","Prev","Curr","StateGraph","N","Set","Map","NodeMap","NodeReturnType","key","NodeInput","NodeOutput","checkpointer","store","cache","interruptBefore","interruptAfter","name","description","CompiledStateGraph","ConstructorParameters","Promise","Partial"],"sources":["../../src/graph/state.d.ts"],"sourcesContent":["import { All, type BaseCache, BaseCheckpointSaver, BaseStore } from \"@langchain/langgraph-checkpoint\";\nimport { type InteropZodObject } from \"@langchain/core/utils/types\";\nimport type { RunnableLike, Runtime } from \"../pregel/runnable_types.js\";\nimport { BaseChannel } from \"../channels/base.js\";\nimport { CompiledGraph, Graph, Branch, AddNodeOptions, NodeSpec } from \"./graph.js\";\nimport { Command, START, END, CommandInstance, Interrupt, INTERRUPT } from \"../constants.js\";\nimport { AnnotationRoot, SingleReducer, StateDefinition, StateType } from \"./annotation.js\";\nimport type { CachePolicy, RetryPolicy } from \"../pregel/utils/index.js\";\nimport { type SchemaMetaRegistry } from \"./zod/meta.js\";\nimport type { InferInterruptResumeType, InferInterruptInputType } from \"../interrupt.js\";\nimport type { InferWriterType } from \"../writer.js\";\nimport type { AnyStateSchema } from \"../state/schema.js\";\nimport { ExtractStateType, ExtractUpdateType, ToStateDefinition, type StateDefinitionInit } from \"./types.js\";\nexport type ChannelReducers<Channels extends object> = {\n    [K in keyof Channels]: SingleReducer<Channels[K], any>;\n};\nexport interface StateGraphArgs<Channels extends object | unknown> {\n    channels: Channels extends object ? Channels extends unknown[] ? ChannelReducers<{\n        __root__: Channels;\n    }> : ChannelReducers<Channels> : ChannelReducers<{\n        __root__: Channels;\n    }>;\n}\nexport type StateGraphNodeSpec<RunInput, RunOutput> = NodeSpec<RunInput, RunOutput> & {\n    input?: StateDefinition;\n    retryPolicy?: RetryPolicy;\n    cachePolicy?: CachePolicy;\n};\nexport type StateGraphAddNodeOptions<Nodes extends string = string> = {\n    retryPolicy?: RetryPolicy;\n    cachePolicy?: CachePolicy | boolean;\n    input?: AnnotationRoot<any> | InteropZodObject;\n} & AddNodeOptions<Nodes>;\nexport type StateGraphArgsWithStateSchema<SD extends StateDefinition, I extends StateDefinition, O extends StateDefinition> = {\n    stateSchema: AnnotationRoot<SD>;\n    input?: AnnotationRoot<I>;\n    output?: AnnotationRoot<O>;\n};\nexport type StateGraphArgsWithInputOutputSchemas<SD extends StateDefinition, O extends StateDefinition = SD> = {\n    input: AnnotationRoot<SD>;\n    output: AnnotationRoot<O>;\n};\ntype ZodStateGraphArgsWithStateSchema<SD extends InteropZodObject, I extends StateDefinitionInit, O extends StateDefinitionInit> = {\n    state: SD;\n    input?: I;\n    output?: O;\n};\ntype ExtractStateDefinition<T> = T extends AnyStateSchema ? T : T extends StateDefinitionInit ? ToStateDefinition<T> : StateDefinition;\ntype NodeAction<S, U, C extends StateDefinitionInit, InterruptType, WriterType> = RunnableLike<S, U extends object ? U & Record<string, any> : U, Runtime<StateType<ToStateDefinition<C>>, InterruptType, WriterType>>;\ntype StrictNodeAction<S, U, C extends StateDefinitionInit, Nodes extends string, InterruptType, WriterType> = RunnableLike<Prettify<S>, U | Command<InferInterruptResumeType<InterruptType>, U & Record<string, any>, Nodes>, Runtime<StateType<ToStateDefinition<C>>, InterruptType, WriterType>>;\ndeclare const PartialStateSchema: unique symbol;\ntype PartialStateSchema = typeof PartialStateSchema;\ntype MergeReturnType<Prev, Curr> = Prev & Curr extends infer T ? {\n    [K in keyof T]: T[K];\n} & unknown : never;\ntype Prettify<T> = {\n    [K in keyof T]: T[K];\n} & {};\n/**\n * A graph whose nodes communicate by reading and writing to a shared state.\n * Each node takes a defined `State` as input and returns a `Partial<State>`.\n *\n * Each state key can optionally be annotated with a reducer function that\n * will be used to aggregate the values of that key received from multiple nodes.\n * The signature of a reducer function is (left: Value, right: UpdateValue) => Value.\n *\n * See {@link Annotation} for more on defining state.\n *\n * After adding nodes and edges to your graph, you must call `.compile()` on it before\n * you can use it.\n *\n * @example\n * ```ts\n * import {\n *   type BaseMessage,\n *   AIMessage,\n *   HumanMessage,\n * } from \"@langchain/core/messages\";\n * import { StateGraph, Annotation } from \"@langchain/langgraph\";\n *\n * // Define a state with a single key named \"messages\" that will\n * // combine a returned BaseMessage or arrays of BaseMessages\n * const StateAnnotation = Annotation.Root({\n *   sentiment: Annotation<string>,\n *   messages: Annotation<BaseMessage[]>({\n *     reducer: (left: BaseMessage[], right: BaseMessage | BaseMessage[]) => {\n *       if (Array.isArray(right)) {\n *         return left.concat(right);\n *       }\n *       return left.concat([right]);\n *     },\n *     default: () => [],\n *   }),\n * });\n *\n * const graphBuilder = new StateGraph(StateAnnotation);\n *\n * // A node in the graph that returns an object with a \"messages\" key\n * // will update the state by combining the existing value with the returned one.\n * const myNode = (state: typeof StateAnnotation.State) => {\n *   return {\n *     messages: [new AIMessage(\"Some new response\")],\n *     sentiment: \"positive\",\n *   };\n * };\n *\n * const graph = graphBuilder\n *   .addNode(\"myNode\", myNode)\n *   .addEdge(\"__start__\", \"myNode\")\n *   .addEdge(\"myNode\", \"__end__\")\n *   .compile();\n *\n * await graph.invoke({ messages: [new HumanMessage(\"how are you?\")] });\n *\n * // {\n * //   messages: [HumanMessage(\"how are you?\"), AIMessage(\"Some new response\")],\n * //   sentiment: \"positive\",\n * // }\n * ```\n */\nexport declare class StateGraph<SD extends StateDefinitionInit | unknown, S = ExtractStateType<SD>, U = ExtractUpdateType<SD, S>, N extends string = typeof START, I extends StateDefinitionInit = ExtractStateDefinition<SD>, O extends StateDefinitionInit = ExtractStateDefinition<SD>, C extends StateDefinitionInit = StateDefinition, NodeReturnType = unknown, InterruptType = unknown, WriterType = unknown> extends Graph<N, S, U, StateGraphNodeSpec<S, U>, ToStateDefinition<C>> {\n    channels: Record<string, BaseChannel>;\n    waitingEdges: Set<[N[], N]>;\n    /** @internal */\n    _schemaDefinition: StateDefinition;\n    /** @internal */\n    _schemaRuntimeDefinition: InteropZodObject | AnyStateSchema | undefined;\n    /** @internal */\n    _inputDefinition: I;\n    /** @internal */\n    _inputRuntimeDefinition: InteropZodObject | AnyStateSchema | PartialStateSchema | undefined;\n    /** @internal */\n    _outputDefinition: O;\n    /** @internal */\n    _outputRuntimeDefinition: InteropZodObject | AnyStateSchema | undefined;\n    /**\n     * Map schemas to managed values\n     * @internal\n     */\n    _schemaDefinitions: Map<any, any>;\n    /** @internal */\n    _metaRegistry: SchemaMetaRegistry;\n    /** @internal Used only for typing. */\n    _configSchema: ToStateDefinition<C> | undefined;\n    /** @internal */\n    _configRuntimeSchema: InteropZodObject | undefined;\n    /** @internal */\n    _interrupt: InterruptType;\n    /** @internal */\n    _writer: WriterType;\n    Node: StrictNodeAction<S, U, C, N, InterruptType, WriterType>;\n    constructor(state: SD extends StateDefinition ? AnnotationRoot<SD> : never, options?: {\n        context?: C | AnnotationRoot<ToStateDefinition<C>>;\n        input?: I | AnnotationRoot<ToStateDefinition<I>>;\n        output?: O | AnnotationRoot<ToStateDefinition<O>>;\n        interrupt?: InterruptType;\n        writer?: WriterType;\n        nodes?: N[];\n    });\n    constructor(state: SD extends AnyStateSchema ? SD : never, options?: {\n        context?: C | AnnotationRoot<ToStateDefinition<C>>;\n        input?: I | AnnotationRoot<ToStateDefinition<I>>;\n        output?: O | AnnotationRoot<ToStateDefinition<O>>;\n        interrupt?: InterruptType;\n        writer?: WriterType;\n        nodes?: N[];\n    });\n    constructor(state: SD extends InteropZodObject ? SD : never, options?: {\n        context?: C | AnnotationRoot<ToStateDefinition<C>>;\n        input?: I | AnnotationRoot<ToStateDefinition<I>>;\n        output?: O | AnnotationRoot<ToStateDefinition<O>>;\n        interrupt?: InterruptType;\n        writer?: WriterType;\n        nodes?: N[];\n    });\n    constructor(fields: SD extends StateDefinition ? StateGraphArgsWithInputOutputSchemas<SD, ToStateDefinition<O>> : never, contextSchema?: C | AnnotationRoot<ToStateDefinition<C>>);\n    constructor(fields: SD extends StateDefinition ? AnnotationRoot<SD> | StateGraphArgsWithStateSchema<SD, ToStateDefinition<I>, ToStateDefinition<O>> : never, contextSchema?: C | AnnotationRoot<ToStateDefinition<C>>);\n    /** @deprecated Use `Annotation.Root` or `zod` for state definition instead. */\n    constructor(fields: SD extends StateDefinition ? SD | StateGraphArgs<S> : StateGraphArgs<S>, contextSchema?: C | AnnotationRoot<ToStateDefinition<C>>);\n    constructor(fields: SD extends InteropZodObject ? SD | ZodStateGraphArgsWithStateSchema<SD, I, O> : never, contextSchema?: C | AnnotationRoot<ToStateDefinition<C>>);\n    get allEdges(): Set<[string, string]>;\n    _addSchema(stateDefinition: StateDefinitionInit): void;\n    addNode<K extends string, NodeMap extends Record<K, NodeAction<S, U, C, InterruptType, WriterType>>>(nodes: NodeMap): StateGraph<SD, S, U, N | K, I, O, C, MergeReturnType<NodeReturnType, {\n        [key in keyof NodeMap]: NodeMap[key] extends NodeAction<S, infer U, C, InterruptType, WriterType> ? U : never;\n    }>>;\n    addNode<K extends string, NodeInput = S, NodeOutput extends U = U>(nodes: [\n        key: K,\n        action: NodeAction<NodeInput, NodeOutput, C, InterruptType, WriterType>,\n        options?: StateGraphAddNodeOptions\n    ][]): StateGraph<SD, S, U, N | K, I, O, C, MergeReturnType<NodeReturnType, {\n        [key in K]: NodeOutput;\n    }>>;\n    addNode<K extends string, NodeInput = S, NodeOutput extends U = U>(key: K, action: NodeAction<NodeInput, NodeOutput, C, InterruptType, WriterType>, options?: StateGraphAddNodeOptions): StateGraph<SD, S, U, N | K, I, O, C, MergeReturnType<NodeReturnType, {\n        [key in K]: NodeOutput;\n    }>>;\n    addNode<K extends string, NodeInput = S>(key: K, action: NodeAction<NodeInput, U, C, InterruptType, WriterType>, options?: StateGraphAddNodeOptions): StateGraph<SD, S, U, N | K, I, O, C, NodeReturnType>;\n    addEdge(startKey: typeof START | N | N[], endKey: N | typeof END): this;\n    addSequence<K extends string, NodeInput = S, NodeOutput extends U = U>(nodes: [\n        key: K,\n        action: NodeAction<NodeInput, NodeOutput, C, InterruptType, WriterType>,\n        options?: StateGraphAddNodeOptions\n    ][]): StateGraph<SD, S, U, N | K, I, O, C, MergeReturnType<NodeReturnType, {\n        [key in K]: NodeOutput;\n    }>>;\n    addSequence<K extends string, NodeMap extends Record<K, NodeAction<S, U, C, InterruptType, WriterType>>>(nodes: NodeMap): StateGraph<SD, S, U, N | K, I, O, C, MergeReturnType<NodeReturnType, {\n        [key in keyof NodeMap]: NodeMap[key] extends NodeAction<S, infer U, C, InterruptType, WriterType> ? U : never;\n    }>>;\n    compile({ checkpointer, store, cache, interruptBefore, interruptAfter, name, description }?: {\n        checkpointer?: BaseCheckpointSaver | boolean;\n        store?: BaseStore;\n        cache?: BaseCache;\n        interruptBefore?: N[] | All;\n        interruptAfter?: N[] | All;\n        name?: string;\n        description?: string;\n    }): CompiledStateGraph<Prettify<S>, Prettify<U>, N, I, O, C, NodeReturnType, InterruptType, WriterType>;\n}\n/**\n * Final result from building and compiling a {@link StateGraph}.\n * Should not be instantiated directly, only using the StateGraph `.compile()`\n * instance method.\n */\nexport declare class CompiledStateGraph<S, U, N extends string = typeof START, I extends StateDefinitionInit = StateDefinition, O extends StateDefinitionInit = StateDefinition, C extends StateDefinitionInit = StateDefinition, NodeReturnType = unknown, InterruptType = unknown, WriterType = unknown> extends CompiledGraph<N, S, U, ExtractStateType<C>, ExtractUpdateType<I, ExtractStateType<I>>, ExtractStateType<O>, NodeReturnType, CommandInstance<InferInterruptResumeType<InterruptType>, Prettify<U>, N>, InferWriterType<WriterType>> {\n    builder: StateGraph<unknown, S, U, N, I, O, C, NodeReturnType>;\n    /**\n     * The description of the compiled graph.\n     * This is used by the supervisor agent to describe the handoff to the agent.\n     */\n    description?: string;\n    /** @internal */\n    _metaRegistry: SchemaMetaRegistry;\n    constructor({ description, ...rest }: {\n        description?: string;\n    } & ConstructorParameters<typeof CompiledGraph<N, S, U, ExtractStateType<C>, ExtractUpdateType<I, ExtractStateType<I>>, ExtractStateType<O>, NodeReturnType, CommandInstance<InferInterruptResumeType<InterruptType>, Prettify<U>, N>, InferWriterType<WriterType>>>[0]);\n    attachNode(key: typeof START, node?: never): void;\n    attachNode(key: N, node: StateGraphNodeSpec<S, U>): void;\n    attachEdge(starts: N | N[] | \"__start__\", end: N | \"__end__\"): void;\n    attachBranch(start: N | typeof START, _: string, branch: Branch<S, N>, options?: {\n        withReader?: boolean;\n    }): void;\n    protected _validateInput(input: ExtractUpdateType<I, ExtractStateType<I>>): Promise<ExtractUpdateType<I, ExtractStateType<I>>>;\n    isInterrupted(input: unknown): input is {\n        [INTERRUPT]: Interrupt<InferInterruptInputType<InterruptType>>[];\n    };\n    protected _validateContext(config: Partial<Record<string, unknown>>): Promise<Partial<Record<string, unknown>>>;\n}\nexport {};\n"],"mappings":"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"}
+{"version":3,"file":"state.d.ts","names":["All","BaseCache","BaseCheckpointSaver","BaseStore","InteropZodObject","RunnableLike","Runtime","BaseChannel","CompiledGraph","Graph","Branch","AddNodeOptions","NodeSpec","Command","START","END","CommandInstance","Interrupt","INTERRUPT","AnnotationRoot","SingleReducer","StateDefinition","StateType","CachePolicy","RetryPolicy","SchemaMetaRegistry","InferInterruptResumeType","InferInterruptInputType","InferWriterType","AnyStateSchema","ContextSchemaInit","ExtractStateType","ExtractUpdateType","StateGraphInit","StateGraphOptions","ToStateDefinition","StateDefinitionInit","ChannelReducers","Channels","K","StateGraphArgs","StateGraphNodeSpec","RunInput","RunOutput","StateGraphAddNodeOptions","InputSchema","Nodes","StateGraphArgsWithStateSchema","SD","I","O","StateGraphArgsWithInputOutputSchemas","ExtractStateDefinition","T","NodeAction","S","U","Record","C","InterruptType","WriterType","StrictNodeAction","Prettify","PartialStateSchema","MergeReturnType","Prev","Curr","StateGraph","N","Set","Map","Omit","NodeMap","NodeReturnType","key","NodeInput","NodeOutput","checkpointer","store","cache","interruptBefore","interruptAfter","name","description","CompiledStateGraph","ConstructorParameters","Promise","Partial"],"sources":["../../src/graph/state.d.ts"],"sourcesContent":["import { All, type BaseCache, BaseCheckpointSaver, BaseStore } from \"@langchain/langgraph-checkpoint\";\nimport { type InteropZodObject } from \"@langchain/core/utils/types\";\nimport type { RunnableLike, Runtime } from \"../pregel/runnable_types.js\";\nimport { BaseChannel } from \"../channels/base.js\";\nimport { CompiledGraph, Graph, Branch, AddNodeOptions, NodeSpec } from \"./graph.js\";\nimport { Command, START, END, CommandInstance, Interrupt, INTERRUPT } from \"../constants.js\";\nimport { AnnotationRoot, SingleReducer, StateDefinition, StateType } from \"./annotation.js\";\nimport type { CachePolicy, RetryPolicy } from \"../pregel/utils/index.js\";\nimport { type SchemaMetaRegistry } from \"./zod/meta.js\";\nimport type { InferInterruptResumeType, InferInterruptInputType } from \"../interrupt.js\";\nimport type { InferWriterType } from \"../writer.js\";\nimport type { AnyStateSchema } from \"../state/schema.js\";\nimport { ContextSchemaInit, ExtractStateType, ExtractUpdateType, StateGraphInit, StateGraphOptions, ToStateDefinition, type StateDefinitionInit } from \"./types.js\";\nexport type ChannelReducers<Channels extends object> = {\n    [K in keyof Channels]: SingleReducer<Channels[K], any>;\n};\nexport interface StateGraphArgs<Channels extends object | unknown> {\n    channels: Channels extends object ? Channels extends unknown[] ? ChannelReducers<{\n        __root__: Channels;\n    }> : ChannelReducers<Channels> : ChannelReducers<{\n        __root__: Channels;\n    }>;\n}\nexport type StateGraphNodeSpec<RunInput, RunOutput> = NodeSpec<RunInput, RunOutput> & {\n    input?: StateDefinition;\n    retryPolicy?: RetryPolicy;\n    cachePolicy?: CachePolicy;\n};\n/**\n * Options for StateGraph.addNode() method.\n *\n * @template Nodes - Node name constraints\n * @template InputSchema - Per-node input schema type (inferred from options.input)\n */\nexport type StateGraphAddNodeOptions<Nodes extends string = string, InputSchema extends StateDefinitionInit | undefined = StateDefinitionInit | undefined> = {\n    retryPolicy?: RetryPolicy;\n    cachePolicy?: CachePolicy | boolean;\n    input?: InputSchema;\n} & AddNodeOptions<Nodes>;\nexport type StateGraphArgsWithStateSchema<SD extends StateDefinition, I extends StateDefinition, O extends StateDefinition> = {\n    stateSchema: AnnotationRoot<SD>;\n    input?: AnnotationRoot<I>;\n    output?: AnnotationRoot<O>;\n};\nexport type StateGraphArgsWithInputOutputSchemas<SD extends StateDefinition, O extends StateDefinition = SD> = {\n    input: AnnotationRoot<SD>;\n    output: AnnotationRoot<O>;\n};\ntype ExtractStateDefinition<T> = T extends AnyStateSchema ? T : T extends StateDefinitionInit ? ToStateDefinition<T> : StateDefinition;\ntype NodeAction<S, U, C extends StateDefinitionInit, InterruptType, WriterType> = RunnableLike<S, U extends object ? U & Record<string, any> : U, Runtime<StateType<ToStateDefinition<C>>, InterruptType, WriterType>>;\ntype StrictNodeAction<S, U, C extends StateDefinitionInit, Nodes extends string, InterruptType, WriterType> = RunnableLike<Prettify<S>, U | Command<InferInterruptResumeType<InterruptType>, U & Record<string, any>, Nodes>, Runtime<StateType<ToStateDefinition<C>>, InterruptType, WriterType>>;\ndeclare const PartialStateSchema: unique symbol;\ntype PartialStateSchema = typeof PartialStateSchema;\ntype MergeReturnType<Prev, Curr> = Prev & Curr extends infer T ? {\n    [K in keyof T]: T[K];\n} & unknown : never;\ntype Prettify<T> = {\n    [K in keyof T]: T[K];\n} & {};\n/**\n * A graph whose nodes communicate by reading and writing to a shared state.\n * Each node takes a defined `State` as input and returns a `Partial<State>`.\n *\n * Each state key can optionally be annotated with a reducer function that\n * will be used to aggregate the values of that key received from multiple nodes.\n * The signature of a reducer function is (left: Value, right: UpdateValue) => Value.\n *\n * See {@link Annotation} for more on defining state.\n *\n * After adding nodes and edges to your graph, you must call `.compile()` on it before\n * you can use it.\n *\n * @example\n * ```ts\n * import {\n *   type BaseMessage,\n *   AIMessage,\n *   HumanMessage,\n * } from \"@langchain/core/messages\";\n * import { StateGraph, Annotation } from \"@langchain/langgraph\";\n *\n * // Define a state with a single key named \"messages\" that will\n * // combine a returned BaseMessage or arrays of BaseMessages\n * const StateAnnotation = Annotation.Root({\n *   sentiment: Annotation<string>,\n *   messages: Annotation<BaseMessage[]>({\n *     reducer: (left: BaseMessage[], right: BaseMessage | BaseMessage[]) => {\n *       if (Array.isArray(right)) {\n *         return left.concat(right);\n *       }\n *       return left.concat([right]);\n *     },\n *     default: () => [],\n *   }),\n * });\n *\n * const graphBuilder = new StateGraph(StateAnnotation);\n *\n * // A node in the graph that returns an object with a \"messages\" key\n * // will update the state by combining the existing value with the returned one.\n * const myNode = (state: typeof StateAnnotation.State) => {\n *   return {\n *     messages: [new AIMessage(\"Some new response\")],\n *     sentiment: \"positive\",\n *   };\n * };\n *\n * const graph = graphBuilder\n *   .addNode(\"myNode\", myNode)\n *   .addEdge(\"__start__\", \"myNode\")\n *   .addEdge(\"myNode\", \"__end__\")\n *   .compile();\n *\n * await graph.invoke({ messages: [new HumanMessage(\"how are you?\")] });\n *\n * // {\n * //   messages: [HumanMessage(\"how are you?\"), AIMessage(\"Some new response\")],\n * //   sentiment: \"positive\",\n * // }\n * ```\n */\nexport declare class StateGraph<SD extends StateDefinitionInit | unknown, S = ExtractStateType<SD>, U = ExtractUpdateType<SD, S>, N extends string = typeof START, I extends StateDefinitionInit = ExtractStateDefinition<SD>, O extends StateDefinitionInit = ExtractStateDefinition<SD>, C extends StateDefinitionInit = StateDefinition, NodeReturnType = unknown, InterruptType = unknown, WriterType = unknown> extends Graph<N, S, U, StateGraphNodeSpec<S, U>, ToStateDefinition<C>> {\n    channels: Record<string, BaseChannel>;\n    waitingEdges: Set<[N[], N]>;\n    /** @internal */\n    _schemaDefinition: StateDefinition;\n    /** @internal */\n    _schemaRuntimeDefinition: InteropZodObject | AnyStateSchema | undefined;\n    /** @internal */\n    _inputDefinition: I;\n    /** @internal */\n    _inputRuntimeDefinition: InteropZodObject | AnyStateSchema | PartialStateSchema | undefined;\n    /** @internal */\n    _outputDefinition: O;\n    /** @internal */\n    _outputRuntimeDefinition: InteropZodObject | AnyStateSchema | undefined;\n    /**\n     * Map schemas to managed values\n     * @internal\n     */\n    _schemaDefinitions: Map<any, any>;\n    /** @internal */\n    _metaRegistry: SchemaMetaRegistry;\n    /** @internal Used only for typing. */\n    _configSchema: ToStateDefinition<C> | undefined;\n    /** @internal */\n    _configRuntimeSchema: InteropZodObject | undefined;\n    /** @internal */\n    _interrupt: InterruptType;\n    /** @internal */\n    _writer: WriterType;\n    Node: StrictNodeAction<S, U, C, N, InterruptType, WriterType>;\n    /**\n     * Create a new StateGraph for building stateful, multi-step workflows.\n     *\n     * Accepts state definitions via `Annotation.Root`, `StateSchema`, or Zod schemas.\n     *\n     * @example Direct schema\n     * ```ts\n     * const StateAnnotation = Annotation.Root({\n     *   messages: Annotation<string[]>({ reducer: (a, b) => [...a, ...b] }),\n     * });\n     * const graph = new StateGraph(StateAnnotation);\n     * ```\n     *\n     * @example Direct schema with input/output filtering\n     * ```ts\n     * const graph = new StateGraph(StateAnnotation, {\n     *   input: InputSchema,\n     *   output: OutputSchema,\n     * });\n     * ```\n     *\n     * @example Object pattern with state, input, output\n     * ```ts\n     * const graph = new StateGraph({\n     *   state: FullStateSchema,\n     *   input: InputSchema,\n     *   output: OutputSchema,\n     * });\n     * ```\n     *\n     * @example Input/output only (state inferred from input)\n     * ```ts\n     * const graph = new StateGraph({\n     *   input: InputAnnotation,\n     *   output: OutputAnnotation,\n     * });\n     * ```\n     */\n    constructor(state: SD extends StateDefinitionInit ? SD : never, options?: C | AnnotationRoot<ToStateDefinition<C>> | StateGraphOptions<I, O, C, N, InterruptType, WriterType>);\n    constructor(fields: SD extends StateDefinition ? StateGraphArgsWithInputOutputSchemas<SD, ToStateDefinition<O>> : never, contextSchema?: C | AnnotationRoot<ToStateDefinition<C>>);\n    constructor(fields: SD extends StateDefinition ? AnnotationRoot<SD> | StateGraphArgsWithStateSchema<SD, ToStateDefinition<I>, ToStateDefinition<O>> : never, contextSchema?: C | AnnotationRoot<ToStateDefinition<C>>);\n    constructor(init: Omit<StateGraphInit<SD extends StateDefinitionInit ? SD : StateDefinitionInit, SD extends StateDefinitionInit ? SD : StateDefinitionInit, O, C extends ContextSchemaInit ? C : undefined, N, InterruptType, WriterType>, \"state\" | \"stateSchema\" | \"input\"> & {\n        input: SD extends StateDefinitionInit ? SD : never;\n        state?: never;\n        stateSchema?: never;\n    }, contextSchema?: C | AnnotationRoot<ToStateDefinition<C>>);\n    constructor(init: StateGraphInit<SD extends StateDefinitionInit ? SD : StateDefinitionInit, I, O, C extends ContextSchemaInit ? C : undefined, N, InterruptType, WriterType>);\n    /** @deprecated Use `Annotation.Root`, `StateSchema`, or Zod schemas instead. */\n    constructor(fields: StateGraphArgs<S>, contextSchema?: C | AnnotationRoot<ToStateDefinition<C>>);\n    /**\n     * Normalize all constructor input patterns to a unified StateGraphInit object.\n     * @internal\n     */\n    private _normalizeToStateGraphInit;\n    /**\n     * Convert any supported schema type to a StateDefinition (channel map).\n     * @internal\n     */\n    private _getChannelsFromSchema;\n    get allEdges(): Set<[string, string]>;\n    _addSchema(stateDefinition: StateDefinitionInit): void;\n    addNode<K extends string, NodeMap extends Record<K, NodeAction<S, U, C, InterruptType, WriterType>>>(nodes: NodeMap): StateGraph<SD, S, U, N | K, I, O, C, MergeReturnType<NodeReturnType, {\n        [key in keyof NodeMap]: NodeMap[key] extends NodeAction<S, infer U, C, InterruptType, WriterType> ? U : never;\n    }>>;\n    addNode<K extends string, NodeInput = S, NodeOutput extends U = U>(nodes: [\n        key: K,\n        action: NodeAction<NodeInput, NodeOutput, C, InterruptType, WriterType>,\n        options?: StateGraphAddNodeOptions\n    ][]): StateGraph<SD, S, U, N | K, I, O, C, MergeReturnType<NodeReturnType, {\n        [key in K]: NodeOutput;\n    }>>;\n    addNode<K extends string, InputSchema extends StateDefinitionInit, NodeOutput extends U = U>(key: K, action: NodeAction<ExtractStateType<InputSchema>, NodeOutput, C, InterruptType, WriterType>, options: StateGraphAddNodeOptions<N | K, InputSchema>): StateGraph<SD, S, U, N | K, I, O, C, MergeReturnType<NodeReturnType, {\n        [key in K]: NodeOutput;\n    }>>;\n    addNode<K extends string, InputSchema extends StateDefinitionInit, NodeOutput extends U = U>(key: K, action: NodeAction<ExtractStateType<InputSchema>, NodeOutput, C, InterruptType, WriterType>, options: StateGraphAddNodeOptions<N | K, InputSchema>): StateGraph<SD, S, U, N | K, I, O, C, MergeReturnType<NodeReturnType, {\n        [key in K]: NodeOutput;\n    }>>;\n    addNode<K extends string, NodeInput = S, NodeOutput extends U = U>(key: K, action: NodeAction<NodeInput, NodeOutput, C, InterruptType, WriterType>, options?: StateGraphAddNodeOptions): StateGraph<SD, S, U, N | K, I, O, C, MergeReturnType<NodeReturnType, {\n        [key in K]: NodeOutput;\n    }>>;\n    addNode<K extends string, NodeInput = S>(key: K, action: NodeAction<NodeInput, U, C, InterruptType, WriterType>, options?: StateGraphAddNodeOptions): StateGraph<SD, S, U, N | K, I, O, C, NodeReturnType>;\n    addEdge(startKey: typeof START | N | N[], endKey: N | typeof END): this;\n    addSequence<K extends string, NodeInput = S, NodeOutput extends U = U>(nodes: [\n        key: K,\n        action: NodeAction<NodeInput, NodeOutput, C, InterruptType, WriterType>,\n        options?: StateGraphAddNodeOptions\n    ][]): StateGraph<SD, S, U, N | K, I, O, C, MergeReturnType<NodeReturnType, {\n        [key in K]: NodeOutput;\n    }>>;\n    addSequence<K extends string, NodeMap extends Record<K, NodeAction<S, U, C, InterruptType, WriterType>>>(nodes: NodeMap): StateGraph<SD, S, U, N | K, I, O, C, MergeReturnType<NodeReturnType, {\n        [key in keyof NodeMap]: NodeMap[key] extends NodeAction<S, infer U, C, InterruptType, WriterType> ? U : never;\n    }>>;\n    compile({ checkpointer, store, cache, interruptBefore, interruptAfter, name, description }?: {\n        checkpointer?: BaseCheckpointSaver | boolean;\n        store?: BaseStore;\n        cache?: BaseCache;\n        interruptBefore?: N[] | All;\n        interruptAfter?: N[] | All;\n        name?: string;\n        description?: string;\n    }): CompiledStateGraph<Prettify<S>, Prettify<U>, N, I, O, C, NodeReturnType, InterruptType, WriterType>;\n}\n/**\n * Final result from building and compiling a {@link StateGraph}.\n * Should not be instantiated directly, only using the StateGraph `.compile()`\n * instance method.\n */\nexport declare class CompiledStateGraph<S, U, N extends string = typeof START, I extends StateDefinitionInit = StateDefinition, O extends StateDefinitionInit = StateDefinition, C extends StateDefinitionInit = StateDefinition, NodeReturnType = unknown, InterruptType = unknown, WriterType = unknown> extends CompiledGraph<N, S, U, ExtractStateType<C>, ExtractUpdateType<I, ExtractStateType<I>>, ExtractStateType<O>, NodeReturnType, CommandInstance<InferInterruptResumeType<InterruptType>, Prettify<U>, N>, InferWriterType<WriterType>> {\n    builder: StateGraph<unknown, S, U, N, I, O, C, NodeReturnType>;\n    /**\n     * The description of the compiled graph.\n     * This is used by the supervisor agent to describe the handoff to the agent.\n     */\n    description?: string;\n    /** @internal */\n    _metaRegistry: SchemaMetaRegistry;\n    constructor({ description, ...rest }: {\n        description?: string;\n    } & ConstructorParameters<typeof CompiledGraph<N, S, U, ExtractStateType<C>, ExtractUpdateType<I, ExtractStateType<I>>, ExtractStateType<O>, NodeReturnType, CommandInstance<InferInterruptResumeType<InterruptType>, Prettify<U>, N>, InferWriterType<WriterType>>>[0]);\n    attachNode(key: typeof START, node?: never): void;\n    attachNode(key: N, node: StateGraphNodeSpec<S, U>): void;\n    attachEdge(starts: N | N[] | \"__start__\", end: N | \"__end__\"): void;\n    attachBranch(start: N | typeof START, _: string, branch: Branch<S, N>, options?: {\n        withReader?: boolean;\n    }): void;\n    protected _validateInput(input: ExtractUpdateType<I, ExtractStateType<I>>): Promise<ExtractUpdateType<I, ExtractStateType<I>>>;\n    isInterrupted(input: unknown): input is {\n        [INTERRUPT]: Interrupt<InferInterruptInputType<InterruptType>>[];\n    };\n    protected _validateContext(config: Partial<Record<string, unknown>>): Promise<Partial<Record<string, unknown>>>;\n}\nexport {};\n"],"mappings":"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"}

package/dist/graph/state.js

@@ -1,7 +1,6 @@
 import { InvalidUpdateError, ParentCommand, StateGraphInputError } from "../errors.js";
-import { isBaseChannel } from "../channels/base.js";
 import { LastValueAfterFinish } from "../channels/last_value.js";
-import { getChannel } from "./annotation.js";
+import { AnnotationRoot, getChannel } from "./annotation.js";
 import { CHECKPOINT_NAMESPACE_END, CHECKPOINT_NAMESPACE_SEPARATOR, Command, END, SELF, START, TAG_HIDDEN, _isSend, isCommand, isInterrupted } from "../constants.js";
 import { RunnableCallable } from "../utils.js";
 import { ChannelWrite, PASSTHROUGH } from "../pregel/write.js";
@@ -13,6 +12,7 @@ import { NamedBarrierValue, NamedBarrierValueAfterFinish } from "../channels/nam
 import { StateSchema } from "../state/schema.js";
 import "../state/index.js";
 import { schemaMetaRegistry } from "./zod/meta.js";
+import { isStateDefinitionInit, isStateGraphInit } from "./types.js";
 import { Runnable, _coerceToRunnable } from "@langchain/core/runnables";
 import { interopParse, interopZodObjectPartial, isInteropZodObject } from "@langchain/core/utils/types";
 
@@ -111,57 +111,86 @@ var StateGraph = class extends Graph {
 	_interrupt;
 	/** @internal */
 	_writer;
-	constructor(fields, contextSchema) {
+	constructor(stateOrInit, options) {
 		super();
-		if (StateSchema.isInstance(fields)) {
-			const channels = fields.getChannels();
-			this._schemaDefinition = channels;
-			this.channels = channels;
-			this._schemaRuntimeDefinition = fields;
-			this._inputRuntimeDefinition = PartialStateSchema;
-			this._outputRuntimeDefinition = fields;
-		} else if (isZodStateGraphArgsWithStateSchema(fields)) {
-			const stateDef = this._metaRegistry.getChannelsForSchema(fields.state);
-			const inputDef = fields.input != null ? this._metaRegistry.getChannelsForSchema(fields.input) : stateDef;
-			const outputDef = fields.output != null ? this._metaRegistry.getChannelsForSchema(fields.output) : stateDef;
-			this._schemaDefinition = stateDef;
-			this._schemaRuntimeDefinition = fields.state;
-			this._inputDefinition = inputDef;
-			this._inputRuntimeDefinition = fields.input ?? PartialStateSchema;
-			this._outputDefinition = outputDef;
-			this._outputRuntimeDefinition = fields.output ?? fields.state;
-		} else if (isInteropZodObject(fields)) {
-			const stateDef = this._metaRegistry.getChannelsForSchema(fields);
-			this._schemaDefinition = stateDef;
-			this._schemaRuntimeDefinition = fields;
-			this._inputDefinition = stateDef;
-			this._inputRuntimeDefinition = PartialStateSchema;
-			this._outputDefinition = stateDef;
-			this._outputRuntimeDefinition = fields;
-		} else if (isStateGraphArgsWithInputOutputSchemas(fields)) {
-			this._schemaDefinition = fields.input.spec;
-			this._inputDefinition = fields.input.spec;
-			this._outputDefinition = fields.output.spec;
-		} else if (isStateGraphArgsWithStateSchema(fields)) {
-			this._schemaDefinition = fields.stateSchema.spec;
-			this._inputDefinition = fields.input?.spec ?? this._schemaDefinition;
-			this._outputDefinition = fields.output?.spec ?? this._schemaDefinition;
-		} else if (isStateDefinition(fields) || isAnnotationRoot(fields)) this._schemaDefinition = isAnnotationRoot(fields) ? fields.spec : fields;
-		else if (isStateGraphArgs(fields)) this._schemaDefinition = _getChannels(fields.channels);
-		else throw new StateGraphInputError();
-		this._inputDefinition ??= this._schemaDefinition;
-		this._outputDefinition ??= this._schemaDefinition;
+		const init = this._normalizeToStateGraphInit(stateOrInit, options);
+		const stateSchema = init.state ?? init.stateSchema ?? init.input;
+		if (!stateSchema) throw new StateGraphInputError();
+		const stateChannelDef = this._getChannelsFromSchema(stateSchema);
+		this._schemaDefinition = stateChannelDef;
+		if (StateSchema.isInstance(stateSchema)) this._schemaRuntimeDefinition = stateSchema;
+		else if (isInteropZodObject(stateSchema)) this._schemaRuntimeDefinition = stateSchema;
+		if (init.input) if (StateSchema.isInstance(init.input)) this._inputRuntimeDefinition = init.input;
+		else if (isInteropZodObject(init.input)) this._inputRuntimeDefinition = init.input;
+		else this._inputRuntimeDefinition = PartialStateSchema;
+		else this._inputRuntimeDefinition = PartialStateSchema;
+		if (init.output) if (StateSchema.isInstance(init.output)) this._outputRuntimeDefinition = init.output;
+		else if (isInteropZodObject(init.output)) this._outputRuntimeDefinition = init.output;
+		else this._outputRuntimeDefinition = this._schemaRuntimeDefinition;
+		else this._outputRuntimeDefinition = this._schemaRuntimeDefinition;
+		const inputChannelDef = init.input ? this._getChannelsFromSchema(init.input) : stateChannelDef;
+		const outputChannelDef = init.output ? this._getChannelsFromSchema(init.output) : stateChannelDef;
+		this._inputDefinition = inputChannelDef;
+		this._outputDefinition = outputChannelDef;
 		this._addSchema(this._schemaDefinition);
 		this._addSchema(this._inputDefinition);
 		this._addSchema(this._outputDefinition);
-		function isOptions(options) {
-			return typeof options === "object" && options != null && !("spec" in options) && !isInteropZodObject(options);
+		if (init.context) {
+			if (isInteropZodObject(init.context)) this._configRuntimeSchema = init.context;
 		}
-		if (isOptions(contextSchema)) {
-			if (isInteropZodObject(contextSchema.context)) this._configRuntimeSchema = contextSchema.context;
-			this._interrupt = contextSchema.interrupt;
-			this._writer = contextSchema.writer;
-		} else if (isInteropZodObject(contextSchema)) this._configRuntimeSchema = contextSchema;
+		this._interrupt = init.interrupt;
+		this._writer = init.writer;
+	}
+	/**
+	* Normalize all constructor input patterns to a unified StateGraphInit object.
+	* @internal
+	*/
+	_normalizeToStateGraphInit(stateOrInit, options) {
+		if (isStateGraphInit(stateOrInit)) {
+			if (isInteropZodObject(options) || AnnotationRoot.isInstance(options)) return {
+				...stateOrInit,
+				context: options
+			};
+			const opts = options;
+			return {
+				...stateOrInit,
+				input: stateOrInit.input ?? opts?.input,
+				output: stateOrInit.output ?? opts?.output,
+				context: stateOrInit.context ?? opts?.context,
+				interrupt: stateOrInit.interrupt ?? opts?.interrupt,
+				writer: stateOrInit.writer ?? opts?.writer,
+				nodes: stateOrInit.nodes ?? opts?.nodes
+			};
+		}
+		if (isStateDefinitionInit(stateOrInit)) {
+			if (isInteropZodObject(options) || AnnotationRoot.isInstance(options)) return {
+				state: stateOrInit,
+				context: options
+			};
+			const opts = options;
+			return {
+				state: stateOrInit,
+				input: opts?.input,
+				output: opts?.output,
+				context: opts?.context,
+				interrupt: opts?.interrupt,
+				writer: opts?.writer,
+				nodes: opts?.nodes
+			};
+		}
+		if (isStateGraphArgs(stateOrInit)) return { state: _getChannels(stateOrInit.channels) };
+		throw new StateGraphInputError();
+	}
+	/**
+	* Convert any supported schema type to a StateDefinition (channel map).
+	* @internal
+	*/
+	_getChannelsFromSchema(schema) {
+		if (StateSchema.isInstance(schema)) return schema.getChannels();
+		if (isInteropZodObject(schema)) return this._metaRegistry.getChannelsForSchema(schema);
+		if (typeof schema === "object" && "lc_graph_name" in schema && schema.lc_graph_name === "AnnotationRoot") return schema.spec;
+		if (typeof schema === "object" && !Array.isArray(schema) && Object.keys(schema).length > 0) return schema;
+		throw new StateGraphInputError("Invalid schema type. Expected StateSchema, Zod object, AnnotationRoot, or StateDefinition.");
 	}
 	get allEdges() {
 		return new Set([...this.edges, ...Array.from(this.waitingEdges).flatMap(([starts, end]) => starts.map((start) => [start, end]))]);
@@ -181,8 +210,8 @@ var StateGraph = class extends Graph {
 		}
 	}
 	addNode(...args) {
-		function isMultipleNodes(args$1) {
-			return args$1.length >= 1 && typeof args$1[0] !== "string";
+		function isMultipleNodes(args) {
+			return args.length >= 1 && typeof args[0] !== "string";
 		}
 		const nodes = isMultipleNodes(args) ? Array.isArray(args[0]) ? args[0] : Object.entries(args[0]).map(([key, action]) => [key, action]) : [[
 			args[0],
@@ -197,11 +226,8 @@ var StateGraph = class extends Graph {
 			if (key in this.nodes) throw new Error(`Node \`${key}\` already present.`);
 			if (key === END || key === START) throw new Error(`Node \`${key}\` is reserved.`);
 			let inputSpec = this._schemaDefinition;
-			if (options?.input !== void 0) {
-				if (isInteropZodObject(options.input)) inputSpec = this._metaRegistry.getChannelsForSchema(options.input);
-				else if (options.input.spec !== void 0) inputSpec = options.input.spec;
-			}
-			if (inputSpec !== void 0) this._addSchema(inputSpec);
+			if (options?.input !== void 0) inputSpec = this._getChannelsFromSchema(options.input);
+			this._addSchema(inputSpec);
 			let runnable;
 			if (Runnable.isRunnable(action)) runnable = action;
 			else if (typeof action === "function") runnable = new RunnableCallable({
@@ -285,7 +311,7 @@ var StateGraph = class extends Graph {
 		for (const [key] of Object.entries(this.nodes)) compiled.attachBranch(key, SELF, _getControlBranch(), { withReader: false });
 		for (const [start, end] of this.edges) compiled.attachEdge(start, end);
 		for (const [starts, end] of this.waitingEdges) compiled.attachEdge(starts, end);
-		for (const [start, branches] of Object.entries(this.branches)) for (const [name$1, branch] of Object.entries(branches)) compiled.attachBranch(start, name$1, branch);
+		for (const [start, branches] of Object.entries(this.branches)) for (const [name, branch] of Object.entries(branches)) compiled.attachBranch(start, name, branch);
 		return compiled.validate();
 	}
 };
@@ -426,7 +452,15 @@ var CompiledStateGraph = class extends CompiledGraph {
 		if (input == null) return input;
 		const inputDef = this.builder._inputRuntimeDefinition;
 		const schemaDef = this.builder._schemaRuntimeDefinition;
-		if (StateSchema.isInstance(schemaDef)) {
+		if (StateSchema.isInstance(inputDef)) {
+			if (isCommand(input)) {
+				const parsedInput = input;
+				if (input.update) parsedInput.update = await inputDef.validateInput(Array.isArray(input.update) ? Object.fromEntries(input.update) : input.update);
+				return parsedInput;
+			}
+			return await inputDef.validateInput(input);
+		}
+		if (inputDef === PartialStateSchema && StateSchema.isInstance(schemaDef)) {
 			if (isCommand(input)) {
 				const parsedInput = input;
 				if (input.update) parsedInput.update = await schemaDef.validateInput(Array.isArray(input.update) ? Object.fromEntries(input.update) : input.update);
@@ -435,9 +469,9 @@ var CompiledStateGraph = class extends CompiledGraph {
 			return await schemaDef.validateInput(input);
 		}
 		const schema = (() => {
-			const apply = (schema$1) => {
-				if (schema$1 == null) return void 0;
-				return this._metaRegistry.getExtendedChannelSchemas(schema$1, { withReducerSchema: true });
+			const apply = (schema) => {
+				if (schema == null) return void 0;
+				return this._metaRegistry.getExtendedChannelSchemas(schema, { withReducerSchema: true });
 			};
 			if (isInteropZodObject(inputDef)) return apply(inputDef);
 			if (inputDef === PartialStateSchema) {
@@ -462,28 +496,14 @@ var CompiledStateGraph = class extends CompiledGraph {
 		return config;
 	}
 };
-function isStateDefinition(obj) {
-	return typeof obj === "object" && obj !== null && !Array.isArray(obj) && Object.keys(obj).length > 0 && Object.values(obj).every((v) => typeof v === "function" || isBaseChannel(v));
-}
-function isAnnotationRoot(obj) {
-	return typeof obj === "object" && obj !== null && "lc_graph_name" in obj && obj.lc_graph_name === "AnnotationRoot";
-}
+/**
+* Check if value is a legacy StateGraphArgs with channels.
+* @internal
+* @deprecated Use StateGraphInit instead
+*/
 function isStateGraphArgs(obj) {
 	return typeof obj === "object" && obj !== null && obj.channels !== void 0;
 }
-function isStateGraphArgsWithStateSchema(obj) {
-	return typeof obj === "object" && obj !== null && obj.stateSchema !== void 0;
-}
-function isStateGraphArgsWithInputOutputSchemas(obj) {
-	return typeof obj === "object" && obj !== null && obj.stateSchema === void 0 && obj.input !== void 0 && obj.output !== void 0;
-}
-function isZodStateGraphArgsWithStateSchema(value) {
-	if (typeof value !== "object" || value == null) return false;
-	if (!("state" in value) || !isInteropZodObject(value.state)) return false;
-	if ("input" in value && !isInteropZodObject(value.input)) return false;
-	if ("output" in value && !isInteropZodObject(value.output)) return false;
-	return true;
-}
 function _controlBranch(value) {
 	if (_isSend(value)) return [value];
 	const commands = [];