@langchain/langgraph 1.1.0 → 1.1.2

package/dist/graph/types.d.ts

@@ -1,9 +1,10 @@
 import { InteropZodToStateDefinition } from "./zod/meta.js";
-import { Runtime } from "../pregel/runnable_types.js";
+import { LangGraphRunnableConfig } from "../pregel/runnable_types.js";
 import { AnnotationRoot, StateDefinition, StateType, UpdateType } from "./annotation.js";
 import { CommandInstance, END, Send } from "../constants.js";
 import { AnyStateSchema, StateSchema, StateSchemaFieldsToStateDefinition } from "../state/schema.js";
 import { InteropZodObject } from "@langchain/core/utils/types";
+import { StandardSchemaV1 } from "@standard-schema/spec";
 
 //#region src/graph/types.d.ts
 
@@ -12,13 +13,72 @@ import { InteropZodObject } from "@langchain/core/utils/types";
  *
  * @internal
  */
-type ToStateDefinition<T> = T extends StateSchema<infer TInit> ? StateSchemaFieldsToStateDefinition<TInit> : T extends InteropZodObject ? InteropZodToStateDefinition<T> : T extends StateDefinition ? T : never;
+type ToStateDefinition<T> = T extends StateSchema<infer TInit> ? StateSchemaFieldsToStateDefinition<TInit> : T extends AnnotationRoot<infer SD> ? SD : T extends InteropZodObject ? InteropZodToStateDefinition<T> : T extends StateDefinition ? T : never;
 /**
  * Type for schema types that can be used to initialize state.
+ * Supports all valid schema types: StateDefinition, Zod objects, StateSchema, and AnnotationRoot.
  *
  * @internal
  */
-type StateDefinitionInit = StateDefinition | InteropZodObject | AnyStateSchema;
+type StateDefinitionInit = StateDefinition | InteropZodObject | AnyStateSchema | AnnotationRoot<any>;
+/**
+ * Check if a value is a valid StateDefinitionInit type.
+ * Supports: StateSchema, InteropZodObject (Zod), AnnotationRoot, StateDefinition
+ *
+ * @internal
+ */
+
+/**
+ * Valid types for context schema.
+ * Context doesn't have channels/reducers, so StateSchema is NOT supported.
+ * Supports StandardSchemaV1 (Zod, Valibot, etc.) and AnnotationRoot (backward compat).
+ *
+ * @internal
+ */
+type ContextSchemaInit = StandardSchemaV1 | AnnotationRoot<StateDefinition>;
+/**
+ * Initialization options for StateGraph.
+ * Accepts any combination of schema types for state/input/output.
+ *
+ * Supports both `state` and `stateSchema` as aliases for backward compatibility.
+ * If only `input` is provided (no state/stateSchema), `input` is used as the state schema.
+ *
+ * @template SD - State definition type
+ * @template I - Input definition type (defaults to undefined)
+ * @template O - Output definition type (defaults to undefined)
+ * @template C - Context schema type (defaults to undefined)
+ * @template N - Node name union type (defaults to string)
+ * @template InterruptType - Interrupt type (defaults to unknown)
+ * @template WriterType - Writer type (defaults to unknown)
+ */
+type StateGraphInit<SD extends StateDefinitionInit = StateDefinitionInit, I extends StateDefinitionInit | undefined = undefined, O extends StateDefinitionInit | undefined = undefined, C extends StateDefinitionInit | undefined = undefined, N extends string = string, InterruptType = unknown, WriterType = unknown> = {
+  /** Primary key for state schema */
+  state?: SD;
+  /**
+   * @deprecated Use `state` instead. Will be removed in a future version.
+   */
+  stateSchema?: SD;
+  input?: I;
+  output?: O;
+  /** Context schema for runtime configuration validation. Does not support StateSchema. */
+  context?: C;
+  interrupt?: InterruptType;
+  writer?: WriterType;
+  nodes?: N[];
+};
+/**
+ * Options for the second argument when passing a direct schema.
+ * Excludes `state` and `stateSchema` since those come from the first arg.
+ *
+ * @internal
+ */
+type StateGraphOptions<I extends StateDefinitionInit | undefined = undefined, O extends StateDefinitionInit | undefined = undefined, C extends StateDefinitionInit | undefined = undefined, N extends string = string, InterruptType = unknown, WriterType = unknown> = Omit<StateGraphInit<StateDefinitionInit, I, O, C, N, InterruptType, WriterType>, "state" | "stateSchema">;
+/**
+ * Check if a value is a StateGraphInit object (has state, stateSchema, or input with valid schema).
+ *
+ * @internal
+ */
+
 /**
  * Extract the State type from any supported schema type.
  *
@@ -48,9 +108,88 @@ type ExtractStateType<Schema, Fallback = Schema> = Schema extends AnnotationRoot
  * @template FallbackBase - Base type for fallback (will be partialized), defaults to Schema
  */
 type ExtractUpdateType<Schema, FallbackBase = Schema> = Schema extends AnnotationRoot<infer SD> ? UpdateType<SD> : UpdateType<ToStateDefinition<Schema>> extends infer U ? [U] extends [never] ? Partial<FallbackBase> : U : Partial<FallbackBase>;
+/**
+ * Extract the input type from a type bag, using ExtractStateType on the InputSchema.
+ * Falls back to Default if InputSchema is not provided.
+ * @internal
+ */
+type ExtractBagInput<Bag, Default> = Bag extends {
+  InputSchema: infer I;
+} ? ExtractStateType<I> : Default;
+/**
+ * Extract the output type from a type bag, using ExtractUpdateType on the OutputSchema.
+ * Falls back to Default if OutputSchema is not provided.
+ * @internal
+ */
+type ExtractBagOutput<Bag, Default> = Bag extends {
+  OutputSchema: infer O;
+} ? ExtractUpdateType<O> : Default;
+/**
+ * Extract the context type from a type bag, using ExtractStateType on the ContextSchema.
+ * Falls back to Default if ContextSchema is not provided.
+ * Ensures result extends Record<string, unknown> for LangGraphRunnableConfig compatibility.
+ * @internal
+ */
+type ExtractBagContext<Bag, Default extends Record<string, unknown>> = Bag extends {
+  ContextSchema: infer C;
+} ? ExtractStateType<C> extends infer Ctx ? Ctx extends Record<string, unknown> ? Ctx : Default : Default : Default;
+/**
+ * Extract the Nodes type from a type bag.
+ * Falls back to Default if Nodes is not provided.
+ * @internal
+ */
+type ExtractBagNodes<Bag, Default extends string> = Bag extends {
+  Nodes: infer N extends string;
+} ? N : Default;
+/**
+ * Type bag for GraphNode that accepts schema types.
+ * All fields are optional - unspecified fields use defaults.
+ *
+ * This enables separate input/output schemas for nodes, which is useful when
+ * a node receives a subset of state fields and returns different fields.
+ *
+ * @example
+ * ```typescript
+ * const node: GraphNode<{
+ *   InputSchema: typeof NodeInputSchema;
+ *   OutputSchema: typeof NodeOutputSchema;
+ *   ContextSchema: typeof ContextSchema;
+ *   Nodes: "agent" | "tool";
+ * }> = (state, runtime) => {
+ *   return { answer: `Response to: ${state.query}` };
+ * };
+ * ```
+ */
+interface GraphNodeTypes<InputSchema = unknown, OutputSchema = unknown, ContextSchema = unknown, Nodes extends string = string> {
+  /** Schema for node input state (uses ExtractStateType) */
+  InputSchema?: InputSchema;
+  /** Schema for node output/update (uses ExtractUpdateType) */
+  OutputSchema?: OutputSchema;
+  /** Schema for runtime context (uses ExtractStateType) */
+  ContextSchema?: ContextSchema;
+  /** Union of valid node names for Command.goto */
+  Nodes?: Nodes;
+}
+/**
+ * Detect if T is a type bag (has InputSchema or OutputSchema) or a direct schema.
+ * @internal
+ */
+type IsGraphNodeTypeBag<T> = T extends {
+  InputSchema: unknown;
+} ? true : T extends {
+  OutputSchema: unknown;
+} ? true : false;
+/**
+ * Return value type for GraphNode functions.
+ * Nodes can return an update object, a Command, or a Promise of either.
+ *
+ * @template Update - The update type (what fields can be returned)
+ * @template Nodes - Union of valid node names for Command.goto
+ */
+type GraphNodeReturnValue<Update, Nodes extends string = string> = Update | CommandInstance<unknown, Update, Nodes> | Promise<Update | CommandInstance<unknown, Update, Nodes>>;
 /**
  * Strongly-typed utility for authoring graph nodes outside of the StateGraph builder,
- * supporting inference for both state (from Schema) and runtime context (from ContextType).
+ * supporting inference for both state (from Schema) and config context (from Context type).
  *
  * This type enables you to define graph node functions with full type safety—both
  * for the evolving state and for additional context that may be passed in at runtime.
@@ -59,11 +198,19 @@ type ExtractUpdateType<Schema, FallbackBase = Schema> = Schema extends Annotatio
  * Works with StateSchema, AnnotationRoot, and Zod object schemas for state, and
  * with a user-defined object shape for context.
  *
- * @template Schema - The state schema type (StateSchema, AnnotationRoot, or InteropZodObject)
- * @template Context - The type of the runtime context injected into this node (default: Record<string, unknown>)
+ * **Supports two patterns:**
+ *
+ * 1. **Single schema usage** - Single schema for both input and output:
+ *    `GraphNode<Schema, Context, Nodes>`
+ *
+ * 2. **Type bag pattern** - Separate schemas for input, output, context:
+ *    `GraphNode<{ InputSchema; OutputSchema; ContextSchema; Nodes }>`
+ *
+ * @template Schema - The state schema type (StateSchema, AnnotationRoot, InteropZodObject) OR a type bag
+ * @template Context - The type of the context passed into this node (default: Record<string, unknown>)
  * @template Nodes - An optional union of valid node names for Command.goto, used for type-safe routing (default: string)
  *
- * @example
+ * @example Single schema usage
  * ```typescript
  * import { StateSchema, GraphNode } from "@langchain/langgraph";
  * import { z } from "zod/v4";
@@ -76,14 +223,14 @@ type ExtractUpdateType<Schema, FallbackBase = Schema> = Schema extends Annotatio
  * // Context shape for custom node logic (optional)
  * type MyContext = { userId: string };
  *
- * // Node receiving state and context
- * const processNode: GraphNode<typeof AgentState, MyContext> = (state, runtime) => {
- *   const { userId } = runtime; // type-safe context access
+ * // Node receiving state and config
+ * const processNode: GraphNode<typeof AgentState, MyContext> = (state, config) => {
+ *   const userId = config.configurable?.userId; // type-safe context access
  *   return { step: state.step + 1 };
  * };
  *
  * // Node with type-safe graph routing
- * const routerNode: GraphNode<typeof AgentState, MyContext, "agent" | "tool"> = (state, runtime) => {
+ * const routerNode: GraphNode<typeof AgentState, MyContext, "agent" | "tool"> = (state, config) => {
  *   if (state.needsTool) {
  *     return new Command({ goto: "tool", update: { step: state.step + 1 } });
  *   }
@@ -96,32 +243,114 @@ type ExtractUpdateType<Schema, FallbackBase = Schema> = Schema extends Annotatio
  *   .addNode("router", routerNode)
  *   .compile();
  * ```
+ *
+ * @example Type bag pattern - separate input/output schemas
+ * ```typescript
+ * const InputSchema = new StateSchema({
+ *   messages: z.array(z.string()),
+ *   query: z.string(),
+ * });
+ *
+ * const OutputSchema = new StateSchema({
+ *   answer: z.string(),
+ * });
+ *
+ * const ContextSchema = z.object({ userId: z.string() });
+ *
+ * const node: GraphNode<{
+ *   InputSchema: typeof InputSchema;
+ *   OutputSchema: typeof OutputSchema;
+ *   ContextSchema: typeof ContextSchema;
+ *   Nodes: "agent" | "tool";
+ * }> = (state, config) => {
+ *   // state is { messages: string[]; query: string }
+ *   // config.configurable is { userId: string } | undefined
+ *   return { answer: `Response to: ${state.query}` };
+ * };
+ * ```
  */
-type GraphNode<Schema, Context = Record<string, unknown>, Nodes extends string = string> = (state: ExtractStateType<Schema>, runtime: Runtime<Context>) => ExtractUpdateType<Schema> | CommandInstance<unknown, ExtractUpdateType<Schema>, Nodes> | Promise<ExtractUpdateType<Schema> | CommandInstance<unknown, ExtractUpdateType<Schema>, Nodes>>;
+type GraphNode<Schema, Context extends Record<string, any> = Record<string, any>, Nodes extends string = string> = IsGraphNodeTypeBag<Schema> extends true ? (state: ExtractBagInput<Schema, unknown>, config: LangGraphRunnableConfig<ExtractBagContext<Schema, Record<string, unknown>>>) => GraphNodeReturnValue<ExtractBagOutput<Schema, Partial<ExtractBagInput<Schema, unknown>>>, ExtractBagNodes<Schema, string>> : (state: ExtractStateType<Schema>, config: LangGraphRunnableConfig<Context>) => GraphNodeReturnValue<ExtractUpdateType<Schema>, Nodes>;
+/**
+ * Type bag for ConditionalEdgeRouter that accepts schema types.
+ * Unlike GraphNodeTypes, conditional edges don't have separate input/output -
+ * they just read state and return routing decisions.
+ *
+ * @example
+ * ```typescript
+ * const router: ConditionalEdgeRouter<{
+ *   Schema: typeof StateSchema;
+ *   ContextSchema: typeof ContextSchema;
+ *   Nodes: "agent" | "tool";
+ * }> = (state, config) => {
+ *   return state.done ? END : "agent";
+ * };
+ * ```
+ */
+interface ConditionalEdgeRouterTypes<InputSchema = unknown, ContextSchema = unknown, Nodes extends string = string> {
+  /** Schema for router state (uses ExtractStateType) */
+  InputSchema?: InputSchema;
+  /** Schema for runtime context (uses ExtractStateType) */
+  ContextSchema?: ContextSchema;
+  /** Union of valid node names that can be routed to */
+  Nodes?: Nodes;
+}
+/**
+ * Detect if T is a ConditionalEdgeRouterTypes bag.
+ * @internal
+ */
+type IsConditionalEdgeRouterTypeBag<T> = T extends {
+  InputSchema: unknown;
+} ? true : T extends {
+  ContextSchema: unknown;
+} ? true : false;
+/**
+ * Return type for conditional edge routing functions.
+ */
+type ConditionalEdgeRouterReturnValue<Nodes extends string, State> = Nodes | typeof END | Send<Nodes, State> | Array<Nodes | Send<Nodes, State>>;
 /**
  * Type for conditional edge routing functions.
  *
  * Use this to type functions passed to `addConditionalEdges` for
  * full type safety on state, runtime context, and return values.
  *
- * @template Schema - The state schema type
+ * **Supports two patterns:**
+ *
+ * 1. **Single schema pattern** - Single schema:
+ *    `ConditionalEdgeRouter<Schema, Context, Nodes>`
+ *
+ * 2. **Type bag pattern** - Separate schemas for state, context:
+ *    `ConditionalEdgeRouter<{ Schema; ContextSchema; Nodes }>`
+ *
+ * @template Schema - The state schema type OR a type bag
  * @template Context - The runtime context type available to node logic
  * @template Nodes - Union of valid node names that can be routed to
  *
- * @example
+ * @example Single schema pattern
  * ```typescript
  * type MyContext = { userId: string };
  * const router: ConditionalEdgeRouter<typeof AgentState, MyContext, "agent" | "tool"> =
- *   (state, runtime) => {
- *     // Access runtime context as type-safe: runtime.userId
+ *   (state, config) => {
+ *     const userId = config.context?.userId;
  *     if (state.done) return END;
  *     return state.needsTool ? "tool" : "agent";
  *   };
  *
  * graph.addConditionalEdges("router", router, ["agent", "tool"]);
  * ```
+ *
+ * @example Type bag pattern
+ * ```typescript
+ * const router: ConditionalEdgeRouter<{
+ *   Schema: typeof StateSchema;
+ *   ContextSchema: typeof ContextSchema;
+ *   Nodes: "agent" | "tool";
+ * }> = (state, config) => {
+ *   if (state.done) return END;
+ *   return "agent";
+ * };
+ * ```
  */
-type ConditionalEdgeRouter<Schema, Context = Record<string, unknown>, Nodes extends string = string> = (state: ExtractStateType<Schema>, runtime: Runtime<Context>) => Nodes | typeof END | Send<Nodes, ExtractStateType<Schema>> | Array<Nodes | Send<Nodes, ExtractStateType<Schema>>>;
+type ConditionalEdgeRouter<Schema, Context extends Record<string, any> = Record<string, any>, Nodes extends string = string> = IsConditionalEdgeRouterTypeBag<Schema> extends true ? (state: ExtractBagInput<Schema, unknown>, config: LangGraphRunnableConfig<ExtractBagContext<Schema, Record<string, unknown>>>) => ConditionalEdgeRouterReturnValue<ExtractBagNodes<Schema, string>, ExtractBagInput<Schema, unknown>> | Promise<ConditionalEdgeRouterReturnValue<ExtractBagNodes<Schema, string>, ExtractBagInput<Schema, unknown>>> : (state: ExtractStateType<Schema>, config: LangGraphRunnableConfig<Context>) => ConditionalEdgeRouterReturnValue<Nodes, ExtractStateType<Schema>> | Promise<ConditionalEdgeRouterReturnValue<Nodes, ExtractStateType<Schema>>>;
 //#endregion
-export { ConditionalEdgeRouter, ExtractStateType, ExtractUpdateType, GraphNode, StateDefinitionInit, ToStateDefinition };
+export { ConditionalEdgeRouter, ConditionalEdgeRouterTypes, ContextSchemaInit, ExtractStateType, ExtractUpdateType, GraphNode, GraphNodeReturnValue, GraphNodeTypes, StateDefinitionInit, StateGraphInit, StateGraphOptions, ToStateDefinition };
 //# sourceMappingURL=types.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":["InteropZodObject","Runtime","CommandInstance","Send","END","AnnotationRoot","StateDefinition","StateType","UpdateType","AnnotationUpdateType","AnyStateSchema","StateSchema","StateSchemaFieldsToStateDefinition","InteropZodToStateDefinition","ToStateDefinition","T","TInit","StateDefinitionInit","ExtractStateType","Schema","SD","S","Fallback","ExtractUpdateType","U","FallbackBase","Partial","GraphNode","Record","Context","Nodes","Promise","ConditionalEdgeRouter","Array"],"sources":["../../src/graph/types.d.ts"],"sourcesContent":["import type { InteropZodObject } from \"@langchain/core/utils/types\";\nimport type { Runtime } from \"../pregel/runnable_types.js\";\nimport type { CommandInstance, Send } from \"../constants.js\";\nimport { END } from \"../constants.js\";\nimport type { AnnotationRoot, StateDefinition, StateType, UpdateType as AnnotationUpdateType } from \"./annotation.js\";\nimport type { AnyStateSchema, StateSchema, StateSchemaFieldsToStateDefinition } from \"../state/schema.js\";\nimport type { InteropZodToStateDefinition } from \"./zod/meta.js\";\nexport { END };\n/**\n * Convert any supported schema type to a StateDefinition.\n *\n * @internal\n */\nexport type ToStateDefinition<T> = T extends StateSchema<infer TInit> ? StateSchemaFieldsToStateDefinition<TInit> : T extends InteropZodObject ? InteropZodToStateDefinition<T> : T extends StateDefinition ? T : never;\n/**\n * Type for schema types that can be used to initialize state.\n *\n * @internal\n */\nexport type StateDefinitionInit = StateDefinition | InteropZodObject | AnyStateSchema;\n/**\n * Extract the State type from any supported schema type.\n *\n * Supports:\n * - StateSchema\n * - AnnotationRoot\n * - StateDefinition (internal channel definitions)\n * - InteropZodObject (Zod v3/v4 object schemas)\n *\n * @template Schema - The schema type to extract state from\n * @template Fallback - Type to return if schema doesn't match (default: never)\n */\nexport type ExtractStateType<Schema, Fallback = Schema> = Schema extends AnnotationRoot<infer SD> ? StateType<SD> : StateType<ToStateDefinition<Schema>> extends infer S ? [S] extends [never] ? Fallback : S : Fallback;\n/**\n * Extract the Update type from any supported schema type.\n *\n * The Update type represents what a node can return to update the state.\n * All fields are optional since nodes only need to return the fields they modify.\n *\n * Supports:\n * - StateSchema\n * - AnnotationRoot\n * - StateDefinition (internal channel definitions)\n * - InteropZodObject (Zod v3/v4 object schemas)\n *\n * @template Schema - The schema type to extract update type from\n * @template FallbackBase - Base type for fallback (will be partialized), defaults to Schema\n */\nexport type ExtractUpdateType<Schema, FallbackBase = Schema> = Schema extends AnnotationRoot<infer SD> ? AnnotationUpdateType<SD> : AnnotationUpdateType<ToStateDefinition<Schema>> extends infer U ? [U] extends [never] ? Partial<FallbackBase> : U : Partial<FallbackBase>;\n/**\n * Strongly-typed utility for authoring graph nodes outside of the StateGraph builder,\n * supporting inference for both state (from Schema) and runtime context (from ContextType).\n *\n * This type enables you to define graph node functions with full type safety—both\n * for the evolving state and for additional context that may be passed in at runtime.\n * Typing the context parameter allows for better code organization and precise editor support.\n *\n * Works with StateSchema, AnnotationRoot, and Zod object schemas for state, and\n * with a user-defined object shape for context.\n *\n * @template Schema - The state schema type (StateSchema, AnnotationRoot, or InteropZodObject)\n * @template Context - The type of the runtime context injected into this node (default: Record<string, unknown>)\n * @template Nodes - An optional union of valid node names for Command.goto, used for type-safe routing (default: string)\n *\n * @example\n * ```typescript\n * import { StateSchema, GraphNode } from \"@langchain/langgraph\";\n * import { z } from \"zod/v4\";\n *\n * const AgentState = new StateSchema({\n *   messages: MessagesValue,\n *   step: z.number().default(0),\n * });\n *\n * // Context shape for custom node logic (optional)\n * type MyContext = { userId: string };\n *\n * // Node receiving state and context\n * const processNode: GraphNode<typeof AgentState, MyContext> = (state, runtime) => {\n *   const { userId } = runtime; // type-safe context access\n *   return { step: state.step + 1 };\n * };\n *\n * // Node with type-safe graph routing\n * const routerNode: GraphNode<typeof AgentState, MyContext, \"agent\" | \"tool\"> = (state, runtime) => {\n *   if (state.needsTool) {\n *     return new Command({ goto: \"tool\", update: { step: state.step + 1 } });\n *   }\n *   return new Command({ goto: \"agent\" });\n * };\n *\n * // Use in graph\n * const graph = new StateGraph(AgentState)\n *   .addNode(\"process\", processNode)\n *   .addNode(\"router\", routerNode)\n *   .compile();\n * ```\n */\nexport type GraphNode<Schema, Context = Record<string, unknown>, Nodes extends string = string> = (state: ExtractStateType<Schema>, runtime: Runtime<Context>) => ExtractUpdateType<Schema> | CommandInstance<unknown, ExtractUpdateType<Schema>, Nodes> | Promise<ExtractUpdateType<Schema> | CommandInstance<unknown, ExtractUpdateType<Schema>, Nodes>>;\n/**\n * Type for conditional edge routing functions.\n *\n * Use this to type functions passed to `addConditionalEdges` for\n * full type safety on state, runtime context, and return values.\n *\n * @template Schema - The state schema type\n * @template Context - The runtime context type available to node logic\n * @template Nodes - Union of valid node names that can be routed to\n *\n * @example\n * ```typescript\n * type MyContext = { userId: string };\n * const router: ConditionalEdgeRouter<typeof AgentState, MyContext, \"agent\" | \"tool\"> =\n *   (state, runtime) => {\n *     // Access runtime context as type-safe: runtime.userId\n *     if (state.done) return END;\n *     return state.needsTool ? \"tool\" : \"agent\";\n *   };\n *\n * graph.addConditionalEdges(\"router\", router, [\"agent\", \"tool\"]);\n * ```\n */\nexport type ConditionalEdgeRouter<Schema, Context = Record<string, unknown>, Nodes extends string = string> = (state: ExtractStateType<Schema>, runtime: Runtime<Context>) => Nodes | typeof END | Send<Nodes, ExtractStateType<Schema>> | Array<Nodes | Send<Nodes, ExtractStateType<Schema>>>;\n"],"mappings":";;;;;;;;;AAaA;;;;;AAAwEY,KAA5DE,iBAA4DF,CAAAA,CAAAA,CAAAA,GAArCG,CAAqCH,SAA3BD,WAA2BC,CAAAA,KAAAA,MAAAA,CAAAA,GAAAA,kCAAAA,CAAmCI,KAAnCJ,CAAAA,GAA4CG,CAA5CH,SAAsDZ,gBAAtDY,GAAyEC,2BAAzED,CAAqGG,CAArGH,CAAAA,GAA0GG,CAA1GH,SAAoHN,eAApHM,GAAsIG,CAAtIH,GAAAA,KAAAA;;;;;;AAAoHN,KAMhLW,mBAAAA,GAAsBX,eAN0JA,GAMxIN,gBANwIM,GAMrHI,cANqHJ;;;AAM5L;;;;;;AAaA;;;;AAAyED,KAA7Da,gBAA6Db,CAAAA,MAAAA,EAAAA,WAAzBc,MAAyBd,CAAAA,GAAfc,MAAed,SAAAA,cAAAA,CAAAA,KAAAA,GAAAA,CAAAA,GAA2BE,SAA3BF,CAAqCe,EAArCf,CAAAA,GAA2CE,SAA3CF,CAAqDS,iBAArDT,CAAuEc,MAAvEd,CAAAA,CAAAA,SAAAA,KAAAA,EAAAA,GAAAA,CAAmGgB,CAAnGhB,CAAAA,SAAAA,CAAAA,KAAAA,CAAAA,GAAwHiB,QAAxHjB,GAAmIgB,CAAnIhB,GAAuIiB,QAAvIjB;;;;;;;;;;;AAgBzE;;;;;AAA8He,KAAlHG,iBAAkHH,CAAAA,MAAAA,EAAAA,eAAzED,MAAyEC,CAAAA,GAA/DD,MAA+DC,SAAhDf,cAAgDe,CAAAA,KAAAA,GAAAA,CAAAA,GAArBX,UAAqBW,CAAAA,EAAAA,CAAAA,GAAMX,UAANW,CAA2BN,iBAA3BM,CAA6CD,MAA7CC,CAAAA,CAAAA,SAAAA,KAAAA,EAAAA,GAAAA,CAAyEI,CAAzEJ,CAAAA,SAAAA,CAAAA,KAAAA,CAAAA,GAA8FM,OAA9FN,CAAsGK,YAAtGL,CAAAA,GAAsHI,CAAtHJ,GAA0HM,OAA1HN,CAAkIK,YAAlIL,CAAAA;;;;;;;;;;;;AAkD9H;;;;;;;;;;;;;;;;;;;;;AAwBA;;;;;;;;;;;;;;;;;AAAyPjB,KAxB7OwB,SAwB6OxB,CAAAA,MAAAA,EAAAA,UAxBjNyB,MAwBiNzB,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,EAAAA,cAAAA,MAAAA,GAAAA,MAAAA,CAAAA,GAAAA,CAAAA,KAAAA,EAxB/Ie,gBAwB+If,CAxB9HgB,MAwB8HhB,CAAAA,EAAAA,OAAAA,EAxB5GF,OAwB4GE,CAxBpG0B,OAwBoG1B,CAAAA,EAAAA,GAxBvFoB,iBAwBuFpB,CAxBrEgB,MAwBqEhB,CAAAA,GAxB3DD,eAwB2DC,CAAAA,OAAAA,EAxBlCoB,iBAwBkCpB,CAxBhBgB,MAwBgBhB,CAAAA,EAxBP2B,KAwBO3B,CAAAA,GAxBE4B,OAwBF5B,CAxBUoB,iBAwBVpB,CAxB4BgB,MAwB5BhB,CAAAA,GAxBsCD,eAwBtCC,CAAAA,OAAAA,EAxB+DoB,iBAwB/DpB,CAxBiFgB,MAwBjFhB,CAAAA,EAxB0F2B,KAwB1F3B,CAAAA,CAAAA;;;;;;;;;;;;;;;;;;;;;;;;KAA7O6B,wCAAwCJ,kEAAkEV,iBAAiBC,kBAAkBlB,QAAQ4B,aAAaC,eAAe1B,MAAMD,KAAK2B,OAAOZ,iBAAiBC,WAAWc,MAAMH,QAAQ3B,KAAK2B,OAAOZ,iBAAiBC"}
+{"version":3,"file":"types.d.ts","names":["InteropZodObject","StandardSchemaV1","LangGraphRunnableConfig","CommandInstance","Send","END","AnnotationRoot","StateDefinition","StateType","UpdateType","AnnotationUpdateType","AnyStateSchema","StateSchema","StateSchemaFieldsToStateDefinition","InteropZodToStateDefinition","ToStateDefinition","T","TInit","SD","StateDefinitionInit","isStateDefinitionInit","ContextSchemaInit","StateGraphInit","I","O","C","InterruptType","WriterType","N","StateGraphOptions","Omit","isStateGraphInit","ExtractStateType","Schema","S","Fallback","ExtractUpdateType","U","FallbackBase","Partial","ExtractBagInput","Bag","Default","ExtractBagOutput","ExtractBagContext","Record","Ctx","ExtractBagNodes","GraphNodeTypes","InputSchema","OutputSchema","ContextSchema","Nodes","IsGraphNodeTypeBag","GraphNodeReturnValue","Update","Promise","GraphNode","Context","ConditionalEdgeRouterTypes","IsConditionalEdgeRouterTypeBag","ConditionalEdgeRouterReturnValue","State","Array","ConditionalEdgeRouter"],"sources":["../../src/graph/types.d.ts"],"sourcesContent":["import { type InteropZodObject } from \"@langchain/core/utils/types\";\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport type { LangGraphRunnableConfig } from \"../pregel/runnable_types.js\";\nimport type { CommandInstance, Send } from \"../constants.js\";\nimport { END } from \"../constants.js\";\nimport type { AnnotationRoot, StateDefinition, StateType, UpdateType as AnnotationUpdateType } from \"./annotation.js\";\nimport { AnyStateSchema, StateSchema, StateSchemaFieldsToStateDefinition } from \"../state/schema.js\";\nimport type { InteropZodToStateDefinition } from \"./zod/meta.js\";\nexport { END };\n/**\n * Convert any supported schema type to a StateDefinition.\n *\n * @internal\n */\nexport type ToStateDefinition<T> = T extends StateSchema<infer TInit> ? StateSchemaFieldsToStateDefinition<TInit> : T extends AnnotationRoot<infer SD> ? SD : T extends InteropZodObject ? InteropZodToStateDefinition<T> : T extends StateDefinition ? T : never;\n/**\n * Type for schema types that can be used to initialize state.\n * Supports all valid schema types: StateDefinition, Zod objects, StateSchema, and AnnotationRoot.\n *\n * @internal\n */\nexport type StateDefinitionInit = StateDefinition | InteropZodObject | AnyStateSchema | AnnotationRoot<any>;\n/**\n * Check if a value is a valid StateDefinitionInit type.\n * Supports: StateSchema, InteropZodObject (Zod), AnnotationRoot, StateDefinition\n *\n * @internal\n */\nexport declare function isStateDefinitionInit(value: unknown): value is StateDefinitionInit;\n/**\n * Valid types for context schema.\n * Context doesn't have channels/reducers, so StateSchema is NOT supported.\n * Supports StandardSchemaV1 (Zod, Valibot, etc.) and AnnotationRoot (backward compat).\n *\n * @internal\n */\nexport type ContextSchemaInit = StandardSchemaV1 | AnnotationRoot<StateDefinition>;\n/**\n * Initialization options for StateGraph.\n * Accepts any combination of schema types for state/input/output.\n *\n * Supports both `state` and `stateSchema` as aliases for backward compatibility.\n * If only `input` is provided (no state/stateSchema), `input` is used as the state schema.\n *\n * @template SD - State definition type\n * @template I - Input definition type (defaults to undefined)\n * @template O - Output definition type (defaults to undefined)\n * @template C - Context schema type (defaults to undefined)\n * @template N - Node name union type (defaults to string)\n * @template InterruptType - Interrupt type (defaults to unknown)\n * @template WriterType - Writer type (defaults to unknown)\n */\nexport type StateGraphInit<SD extends StateDefinitionInit = StateDefinitionInit, I extends StateDefinitionInit | undefined = undefined, O extends StateDefinitionInit | undefined = undefined, C extends StateDefinitionInit | undefined = undefined, N extends string = string, InterruptType = unknown, WriterType = unknown> = {\n    /** Primary key for state schema */\n    state?: SD;\n    /**\n     * @deprecated Use `state` instead. Will be removed in a future version.\n     */\n    stateSchema?: SD;\n    input?: I;\n    output?: O;\n    /** Context schema for runtime configuration validation. Does not support StateSchema. */\n    context?: C;\n    interrupt?: InterruptType;\n    writer?: WriterType;\n    nodes?: N[];\n};\n/**\n * Options for the second argument when passing a direct schema.\n * Excludes `state` and `stateSchema` since those come from the first arg.\n *\n * @internal\n */\nexport type StateGraphOptions<I extends StateDefinitionInit | undefined = undefined, O extends StateDefinitionInit | undefined = undefined, C extends StateDefinitionInit | undefined = undefined, N extends string = string, InterruptType = unknown, WriterType = unknown> = Omit<StateGraphInit<StateDefinitionInit, I, O, C, N, InterruptType, WriterType>, \"state\" | \"stateSchema\">;\n/**\n * Check if a value is a StateGraphInit object (has state, stateSchema, or input with valid schema).\n *\n * @internal\n */\nexport declare function isStateGraphInit(value: unknown): value is StateGraphInit<StateDefinitionInit>;\n/**\n * Extract the State type from any supported schema type.\n *\n * Supports:\n * - StateSchema\n * - AnnotationRoot\n * - StateDefinition (internal channel definitions)\n * - InteropZodObject (Zod v3/v4 object schemas)\n *\n * @template Schema - The schema type to extract state from\n * @template Fallback - Type to return if schema doesn't match (default: never)\n */\nexport type ExtractStateType<Schema, Fallback = Schema> = Schema extends AnnotationRoot<infer SD> ? StateType<SD> : StateType<ToStateDefinition<Schema>> extends infer S ? [S] extends [never] ? Fallback : S : Fallback;\n/**\n * Extract the Update type from any supported schema type.\n *\n * The Update type represents what a node can return to update the state.\n * All fields are optional since nodes only need to return the fields they modify.\n *\n * Supports:\n * - StateSchema\n * - AnnotationRoot\n * - StateDefinition (internal channel definitions)\n * - InteropZodObject (Zod v3/v4 object schemas)\n *\n * @template Schema - The schema type to extract update type from\n * @template FallbackBase - Base type for fallback (will be partialized), defaults to Schema\n */\nexport type ExtractUpdateType<Schema, FallbackBase = Schema> = Schema extends AnnotationRoot<infer SD> ? AnnotationUpdateType<SD> : AnnotationUpdateType<ToStateDefinition<Schema>> extends infer U ? [U] extends [never] ? Partial<FallbackBase> : U : Partial<FallbackBase>;\n/**\n * Extract the input type from a type bag, using ExtractStateType on the InputSchema.\n * Falls back to Default if InputSchema is not provided.\n * @internal\n */\ntype ExtractBagInput<Bag, Default> = Bag extends {\n    InputSchema: infer I;\n} ? ExtractStateType<I> : Default;\n/**\n * Extract the output type from a type bag, using ExtractUpdateType on the OutputSchema.\n * Falls back to Default if OutputSchema is not provided.\n * @internal\n */\ntype ExtractBagOutput<Bag, Default> = Bag extends {\n    OutputSchema: infer O;\n} ? ExtractUpdateType<O> : Default;\n/**\n * Extract the context type from a type bag, using ExtractStateType on the ContextSchema.\n * Falls back to Default if ContextSchema is not provided.\n * Ensures result extends Record<string, unknown> for LangGraphRunnableConfig compatibility.\n * @internal\n */\ntype ExtractBagContext<Bag, Default extends Record<string, unknown>> = Bag extends {\n    ContextSchema: infer C;\n} ? ExtractStateType<C> extends infer Ctx ? Ctx extends Record<string, unknown> ? Ctx : Default : Default : Default;\n/**\n * Extract the Nodes type from a type bag.\n * Falls back to Default if Nodes is not provided.\n * @internal\n */\ntype ExtractBagNodes<Bag, Default extends string> = Bag extends {\n    Nodes: infer N extends string;\n} ? N : Default;\n/**\n * Type bag for GraphNode that accepts schema types.\n * All fields are optional - unspecified fields use defaults.\n *\n * This enables separate input/output schemas for nodes, which is useful when\n * a node receives a subset of state fields and returns different fields.\n *\n * @example\n * ```typescript\n * const node: GraphNode<{\n *   InputSchema: typeof NodeInputSchema;\n *   OutputSchema: typeof NodeOutputSchema;\n *   ContextSchema: typeof ContextSchema;\n *   Nodes: \"agent\" | \"tool\";\n * }> = (state, runtime) => {\n *   return { answer: `Response to: ${state.query}` };\n * };\n * ```\n */\nexport interface GraphNodeTypes<InputSchema = unknown, OutputSchema = unknown, ContextSchema = unknown, Nodes extends string = string> {\n    /** Schema for node input state (uses ExtractStateType) */\n    InputSchema?: InputSchema;\n    /** Schema for node output/update (uses ExtractUpdateType) */\n    OutputSchema?: OutputSchema;\n    /** Schema for runtime context (uses ExtractStateType) */\n    ContextSchema?: ContextSchema;\n    /** Union of valid node names for Command.goto */\n    Nodes?: Nodes;\n}\n/**\n * Detect if T is a type bag (has InputSchema or OutputSchema) or a direct schema.\n * @internal\n */\ntype IsGraphNodeTypeBag<T> = T extends {\n    InputSchema: unknown;\n} ? true : T extends {\n    OutputSchema: unknown;\n} ? true : false;\n/**\n * Return value type for GraphNode functions.\n * Nodes can return an update object, a Command, or a Promise of either.\n *\n * @template Update - The update type (what fields can be returned)\n * @template Nodes - Union of valid node names for Command.goto\n */\nexport type GraphNodeReturnValue<Update, Nodes extends string = string> = Update | CommandInstance<unknown, Update, Nodes> | Promise<Update | CommandInstance<unknown, Update, Nodes>>;\n/**\n * Strongly-typed utility for authoring graph nodes outside of the StateGraph builder,\n * supporting inference for both state (from Schema) and config context (from Context type).\n *\n * This type enables you to define graph node functions with full type safety—both\n * for the evolving state and for additional context that may be passed in at runtime.\n * Typing the context parameter allows for better code organization and precise editor support.\n *\n * Works with StateSchema, AnnotationRoot, and Zod object schemas for state, and\n * with a user-defined object shape for context.\n *\n * **Supports two patterns:**\n *\n * 1. **Single schema usage** - Single schema for both input and output:\n *    `GraphNode<Schema, Context, Nodes>`\n *\n * 2. **Type bag pattern** - Separate schemas for input, output, context:\n *    `GraphNode<{ InputSchema; OutputSchema; ContextSchema; Nodes }>`\n *\n * @template Schema - The state schema type (StateSchema, AnnotationRoot, InteropZodObject) OR a type bag\n * @template Context - The type of the context passed into this node (default: Record<string, unknown>)\n * @template Nodes - An optional union of valid node names for Command.goto, used for type-safe routing (default: string)\n *\n * @example Single schema usage\n * ```typescript\n * import { StateSchema, GraphNode } from \"@langchain/langgraph\";\n * import { z } from \"zod/v4\";\n *\n * const AgentState = new StateSchema({\n *   messages: MessagesValue,\n *   step: z.number().default(0),\n * });\n *\n * // Context shape for custom node logic (optional)\n * type MyContext = { userId: string };\n *\n * // Node receiving state and config\n * const processNode: GraphNode<typeof AgentState, MyContext> = (state, config) => {\n *   const userId = config.configurable?.userId; // type-safe context access\n *   return { step: state.step + 1 };\n * };\n *\n * // Node with type-safe graph routing\n * const routerNode: GraphNode<typeof AgentState, MyContext, \"agent\" | \"tool\"> = (state, config) => {\n *   if (state.needsTool) {\n *     return new Command({ goto: \"tool\", update: { step: state.step + 1 } });\n *   }\n *   return new Command({ goto: \"agent\" });\n * };\n *\n * // Use in graph\n * const graph = new StateGraph(AgentState)\n *   .addNode(\"process\", processNode)\n *   .addNode(\"router\", routerNode)\n *   .compile();\n * ```\n *\n * @example Type bag pattern - separate input/output schemas\n * ```typescript\n * const InputSchema = new StateSchema({\n *   messages: z.array(z.string()),\n *   query: z.string(),\n * });\n *\n * const OutputSchema = new StateSchema({\n *   answer: z.string(),\n * });\n *\n * const ContextSchema = z.object({ userId: z.string() });\n *\n * const node: GraphNode<{\n *   InputSchema: typeof InputSchema;\n *   OutputSchema: typeof OutputSchema;\n *   ContextSchema: typeof ContextSchema;\n *   Nodes: \"agent\" | \"tool\";\n * }> = (state, config) => {\n *   // state is { messages: string[]; query: string }\n *   // config.configurable is { userId: string } | undefined\n *   return { answer: `Response to: ${state.query}` };\n * };\n * ```\n */\nexport type GraphNode<Schema, Context extends Record<string, any> = Record<string, any>, Nodes extends string = string> = IsGraphNodeTypeBag<Schema> extends true ? (state: ExtractBagInput<Schema, unknown>, config: LangGraphRunnableConfig<ExtractBagContext<Schema, Record<string, unknown>>>) => GraphNodeReturnValue<ExtractBagOutput<Schema, Partial<ExtractBagInput<Schema, unknown>>>, ExtractBagNodes<Schema, string>> : (state: ExtractStateType<Schema>, config: LangGraphRunnableConfig<Context>) => GraphNodeReturnValue<ExtractUpdateType<Schema>, Nodes>;\n/**\n * Type bag for ConditionalEdgeRouter that accepts schema types.\n * Unlike GraphNodeTypes, conditional edges don't have separate input/output -\n * they just read state and return routing decisions.\n *\n * @example\n * ```typescript\n * const router: ConditionalEdgeRouter<{\n *   Schema: typeof StateSchema;\n *   ContextSchema: typeof ContextSchema;\n *   Nodes: \"agent\" | \"tool\";\n * }> = (state, config) => {\n *   return state.done ? END : \"agent\";\n * };\n * ```\n */\nexport interface ConditionalEdgeRouterTypes<InputSchema = unknown, ContextSchema = unknown, Nodes extends string = string> {\n    /** Schema for router state (uses ExtractStateType) */\n    InputSchema?: InputSchema;\n    /** Schema for runtime context (uses ExtractStateType) */\n    ContextSchema?: ContextSchema;\n    /** Union of valid node names that can be routed to */\n    Nodes?: Nodes;\n}\n/**\n * Detect if T is a ConditionalEdgeRouterTypes bag.\n * @internal\n */\ntype IsConditionalEdgeRouterTypeBag<T> = T extends {\n    InputSchema: unknown;\n} ? true : T extends {\n    ContextSchema: unknown;\n} ? true : false;\n/**\n * Return type for conditional edge routing functions.\n */\ntype ConditionalEdgeRouterReturnValue<Nodes extends string, State> = Nodes | typeof END | Send<Nodes, State> | Array<Nodes | Send<Nodes, State>>;\n/**\n * Type for conditional edge routing functions.\n *\n * Use this to type functions passed to `addConditionalEdges` for\n * full type safety on state, runtime context, and return values.\n *\n * **Supports two patterns:**\n *\n * 1. **Single schema pattern** - Single schema:\n *    `ConditionalEdgeRouter<Schema, Context, Nodes>`\n *\n * 2. **Type bag pattern** - Separate schemas for state, context:\n *    `ConditionalEdgeRouter<{ Schema; ContextSchema; Nodes }>`\n *\n * @template Schema - The state schema type OR a type bag\n * @template Context - The runtime context type available to node logic\n * @template Nodes - Union of valid node names that can be routed to\n *\n * @example Single schema pattern\n * ```typescript\n * type MyContext = { userId: string };\n * const router: ConditionalEdgeRouter<typeof AgentState, MyContext, \"agent\" | \"tool\"> =\n *   (state, config) => {\n *     const userId = config.context?.userId;\n *     if (state.done) return END;\n *     return state.needsTool ? \"tool\" : \"agent\";\n *   };\n *\n * graph.addConditionalEdges(\"router\", router, [\"agent\", \"tool\"]);\n * ```\n *\n * @example Type bag pattern\n * ```typescript\n * const router: ConditionalEdgeRouter<{\n *   Schema: typeof StateSchema;\n *   ContextSchema: typeof ContextSchema;\n *   Nodes: \"agent\" | \"tool\";\n * }> = (state, config) => {\n *   if (state.done) return END;\n *   return \"agent\";\n * };\n * ```\n */\nexport type ConditionalEdgeRouter<Schema, Context extends Record<string, any> = Record<string, any>, Nodes extends string = string> = IsConditionalEdgeRouterTypeBag<Schema> extends true ? (state: ExtractBagInput<Schema, unknown>, config: LangGraphRunnableConfig<ExtractBagContext<Schema, Record<string, unknown>>>) => ConditionalEdgeRouterReturnValue<ExtractBagNodes<Schema, string>, ExtractBagInput<Schema, unknown>> | Promise<ConditionalEdgeRouterReturnValue<ExtractBagNodes<Schema, string>, ExtractBagInput<Schema, unknown>>> : (state: ExtractStateType<Schema>, config: LangGraphRunnableConfig<Context>) => ConditionalEdgeRouterReturnValue<Nodes, ExtractStateType<Schema>> | Promise<ConditionalEdgeRouterReturnValue<Nodes, ExtractStateType<Schema>>>;\n"],"mappings":"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"}

package/dist/graph/types.js

@@ -0,0 +1,40 @@
+import { isBaseChannel } from "../channels/base.js";
+import { END } from "../constants.js";
+import { StateSchema } from "../state/schema.js";
+import { isInteropZodObject } from "@langchain/core/utils/types";
+
+//#region src/graph/types.ts
+/**
+* Check if a value is a valid StateDefinitionInit type.
+* Supports: StateSchema, InteropZodObject (Zod), AnnotationRoot, StateDefinition
+*
+* @internal
+*/
+function isStateDefinitionInit(value) {
+	if (value == null) return false;
+	if (StateSchema.isInstance(value)) return true;
+	if (isInteropZodObject(value)) return true;
+	if (typeof value === "object" && "lc_graph_name" in value && value.lc_graph_name === "AnnotationRoot") return true;
+	if (typeof value === "object" && !Array.isArray(value) && Object.keys(value).length > 0 && Object.values(value).every((v) => typeof v === "function" || isBaseChannel(v))) return true;
+	return false;
+}
+/**
+* Check if a value is a StateGraphInit object (has state, stateSchema, or input with valid schema).
+*
+* @internal
+*/
+function isStateGraphInit(value) {
+	if (typeof value !== "object" || value == null) return false;
+	const obj = value;
+	const hasState = "state" in obj && isStateDefinitionInit(obj.state);
+	const hasStateSchema = "stateSchema" in obj && isStateDefinitionInit(obj.stateSchema);
+	const hasInput = "input" in obj && isStateDefinitionInit(obj.input);
+	if (!hasState && !hasStateSchema && !hasInput) return false;
+	if ("input" in obj && obj.input != null && !isStateDefinitionInit(obj.input)) return false;
+	if ("output" in obj && obj.output != null && !isStateDefinitionInit(obj.output)) return false;
+	return true;
+}
+
+//#endregion
+export { isStateDefinitionInit, isStateGraphInit };
+//# sourceMappingURL=types.js.map

package/dist/graph/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../../src/graph/types.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport {\n  isInteropZodObject,\n  type InteropZodObject,\n} from \"@langchain/core/utils/types\";\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport type { LangGraphRunnableConfig } from \"../pregel/runnable_types.js\";\nimport type { CommandInstance, Send } from \"../constants.js\";\nimport { END } from \"../constants.js\";\nimport type {\n  AnnotationRoot,\n  StateDefinition,\n  StateType,\n  UpdateType as AnnotationUpdateType,\n} from \"./annotation.js\";\nimport {\n  AnyStateSchema,\n  StateSchema,\n  StateSchemaFieldsToStateDefinition,\n} from \"../state/schema.js\";\nimport type { InteropZodToStateDefinition } from \"./zod/meta.js\";\nimport { isBaseChannel } from \"../channels/base.js\";\n\n// Re-export END for use in ConditionalEdgeRouter return types\nexport { END };\n\n/**\n * Convert any supported schema type to a StateDefinition.\n *\n * @internal\n */\nexport type ToStateDefinition<T> = T extends StateSchema<infer TInit>\n  ? StateSchemaFieldsToStateDefinition<TInit>\n  : T extends AnnotationRoot<infer SD>\n  ? SD\n  : T extends InteropZodObject\n  ? InteropZodToStateDefinition<T>\n  : T extends StateDefinition\n  ? T\n  : never;\n\n/**\n * Type for schema types that can be used to initialize state.\n * Supports all valid schema types: StateDefinition, Zod objects, StateSchema, and AnnotationRoot.\n *\n * @internal\n */\nexport type StateDefinitionInit =\n  | StateDefinition\n  | InteropZodObject\n  | AnyStateSchema\n  | AnnotationRoot<any>;\n\n/**\n * Check if a value is a valid StateDefinitionInit type.\n * Supports: StateSchema, InteropZodObject (Zod), AnnotationRoot, StateDefinition\n *\n * @internal\n */\nexport function isStateDefinitionInit(\n  value: unknown\n): value is StateDefinitionInit {\n  if (value == null) return false;\n\n  // StateSchema\n  if (StateSchema.isInstance(value)) return true;\n\n  // InteropZodObject (Zod v3/v4 object schemas)\n  if (isInteropZodObject(value)) return true;\n\n  // AnnotationRoot\n  if (\n    typeof value === \"object\" &&\n    \"lc_graph_name\" in value &&\n    (value as { lc_graph_name: unknown }).lc_graph_name === \"AnnotationRoot\"\n  ) {\n    return true;\n  }\n\n  // StateDefinition (raw channel map)\n  if (\n    typeof value === \"object\" &&\n    !Array.isArray(value) &&\n    Object.keys(value).length > 0 &&\n    Object.values(value).every(\n      (v) => typeof v === \"function\" || isBaseChannel(v)\n    )\n  ) {\n    return true;\n  }\n\n  return false;\n}\n\n/**\n * Valid types for context schema.\n * Context doesn't have channels/reducers, so StateSchema is NOT supported.\n * Supports StandardSchemaV1 (Zod, Valibot, etc.) and AnnotationRoot (backward compat).\n *\n * @internal\n */\nexport type ContextSchemaInit =\n  | StandardSchemaV1\n  | AnnotationRoot<StateDefinition>;\n\n/**\n * Initialization options for StateGraph.\n * Accepts any combination of schema types for state/input/output.\n *\n * Supports both `state` and `stateSchema` as aliases for backward compatibility.\n * If only `input` is provided (no state/stateSchema), `input` is used as the state schema.\n *\n * @template SD - State definition type\n * @template I - Input definition type (defaults to undefined)\n * @template O - Output definition type (defaults to undefined)\n * @template C - Context schema type (defaults to undefined)\n * @template N - Node name union type (defaults to string)\n * @template InterruptType - Interrupt type (defaults to unknown)\n * @template WriterType - Writer type (defaults to unknown)\n */\nexport type StateGraphInit<\n  SD extends StateDefinitionInit = StateDefinitionInit,\n  I extends StateDefinitionInit | undefined = undefined,\n  O extends StateDefinitionInit | undefined = undefined,\n  C extends StateDefinitionInit | undefined = undefined,\n  N extends string = string,\n  InterruptType = unknown,\n  WriterType = unknown\n> = {\n  /** Primary key for state schema */\n  state?: SD;\n\n  /**\n   * @deprecated Use `state` instead. Will be removed in a future version.\n   */\n  stateSchema?: SD;\n\n  input?: I;\n  output?: O;\n\n  /** Context schema for runtime configuration validation. Does not support StateSchema. */\n  context?: C;\n\n  interrupt?: InterruptType;\n  writer?: WriterType;\n  nodes?: N[];\n};\n\n/**\n * Options for the second argument when passing a direct schema.\n * Excludes `state` and `stateSchema` since those come from the first arg.\n *\n * @internal\n */\nexport type StateGraphOptions<\n  I extends StateDefinitionInit | undefined = undefined,\n  O extends StateDefinitionInit | undefined = undefined,\n  C extends StateDefinitionInit | undefined = undefined,\n  N extends string = string,\n  InterruptType = unknown,\n  WriterType = unknown\n> = Omit<\n  StateGraphInit<StateDefinitionInit, I, O, C, N, InterruptType, WriterType>,\n  \"state\" | \"stateSchema\"\n>;\n\n/**\n * Check if a value is a StateGraphInit object (has state, stateSchema, or input with valid schema).\n *\n * @internal\n */\nexport function isStateGraphInit(\n  value: unknown\n): value is StateGraphInit<StateDefinitionInit> {\n  if (typeof value !== \"object\" || value == null) return false;\n\n  const obj = value as Record<string, unknown>;\n\n  // Must have at least one of: state, stateSchema, or input\n  const hasState = \"state\" in obj && isStateDefinitionInit(obj.state);\n  const hasStateSchema =\n    \"stateSchema\" in obj && isStateDefinitionInit(obj.stateSchema);\n  const hasInput = \"input\" in obj && isStateDefinitionInit(obj.input);\n\n  if (!hasState && !hasStateSchema && !hasInput) return false;\n\n  // Validate input/output if provided\n  if (\"input\" in obj && obj.input != null && !isStateDefinitionInit(obj.input))\n    return false;\n  if (\n    \"output\" in obj &&\n    obj.output != null &&\n    !isStateDefinitionInit(obj.output)\n  )\n    return false;\n\n  return true;\n}\n\n/**\n * Extract the State type from any supported schema type.\n *\n * Supports:\n * - StateSchema\n * - AnnotationRoot\n * - StateDefinition (internal channel definitions)\n * - InteropZodObject (Zod v3/v4 object schemas)\n *\n * @template Schema - The schema type to extract state from\n * @template Fallback - Type to return if schema doesn't match (default: never)\n */\nexport type ExtractStateType<\n  Schema,\n  Fallback = Schema\n> = Schema extends AnnotationRoot<infer SD>\n  ? StateType<SD>\n  : StateType<ToStateDefinition<Schema>> extends infer S\n  ? [S] extends [never]\n    ? Fallback\n    : S\n  : Fallback;\n\n/**\n * Extract the Update type from any supported schema type.\n *\n * The Update type represents what a node can return to update the state.\n * All fields are optional since nodes only need to return the fields they modify.\n *\n * Supports:\n * - StateSchema\n * - AnnotationRoot\n * - StateDefinition (internal channel definitions)\n * - InteropZodObject (Zod v3/v4 object schemas)\n *\n * @template Schema - The schema type to extract update type from\n * @template FallbackBase - Base type for fallback (will be partialized), defaults to Schema\n */\nexport type ExtractUpdateType<\n  Schema,\n  FallbackBase = Schema\n> = Schema extends AnnotationRoot<infer SD>\n  ? AnnotationUpdateType<SD>\n  : AnnotationUpdateType<ToStateDefinition<Schema>> extends infer U\n  ? [U] extends [never]\n    ? Partial<FallbackBase>\n    : U\n  : Partial<FallbackBase>;\n\n/**\n * Extract the input type from a type bag, using ExtractStateType on the InputSchema.\n * Falls back to Default if InputSchema is not provided.\n * @internal\n */\ntype ExtractBagInput<Bag, Default> = Bag extends {\n  InputSchema: infer I;\n}\n  ? ExtractStateType<I>\n  : Default;\n\n/**\n * Extract the output type from a type bag, using ExtractUpdateType on the OutputSchema.\n * Falls back to Default if OutputSchema is not provided.\n * @internal\n */\ntype ExtractBagOutput<Bag, Default> = Bag extends {\n  OutputSchema: infer O;\n}\n  ? ExtractUpdateType<O>\n  : Default;\n\n/**\n * Extract the context type from a type bag, using ExtractStateType on the ContextSchema.\n * Falls back to Default if ContextSchema is not provided.\n * Ensures result extends Record<string, unknown> for LangGraphRunnableConfig compatibility.\n * @internal\n */\ntype ExtractBagContext<\n  Bag,\n  Default extends Record<string, unknown>\n> = Bag extends {\n  ContextSchema: infer C;\n}\n  ? ExtractStateType<C> extends infer Ctx\n    ? Ctx extends Record<string, unknown>\n      ? Ctx\n      : Default\n    : Default\n  : Default;\n\n/**\n * Extract the Nodes type from a type bag.\n * Falls back to Default if Nodes is not provided.\n * @internal\n */\ntype ExtractBagNodes<Bag, Default extends string> = Bag extends {\n  Nodes: infer N extends string;\n}\n  ? N\n  : Default;\n\n/**\n * Type bag for GraphNode that accepts schema types.\n * All fields are optional - unspecified fields use defaults.\n *\n * This enables separate input/output schemas for nodes, which is useful when\n * a node receives a subset of state fields and returns different fields.\n *\n * @example\n * ```typescript\n * const node: GraphNode<{\n *   InputSchema: typeof NodeInputSchema;\n *   OutputSchema: typeof NodeOutputSchema;\n *   ContextSchema: typeof ContextSchema;\n *   Nodes: \"agent\" | \"tool\";\n * }> = (state, runtime) => {\n *   return { answer: `Response to: ${state.query}` };\n * };\n * ```\n */\nexport interface GraphNodeTypes<\n  InputSchema = unknown,\n  OutputSchema = unknown,\n  ContextSchema = unknown,\n  Nodes extends string = string\n> {\n  /** Schema for node input state (uses ExtractStateType) */\n  InputSchema?: InputSchema;\n  /** Schema for node output/update (uses ExtractUpdateType) */\n  OutputSchema?: OutputSchema;\n  /** Schema for runtime context (uses ExtractStateType) */\n  ContextSchema?: ContextSchema;\n  /** Union of valid node names for Command.goto */\n  Nodes?: Nodes;\n}\n\n/**\n * Detect if T is a type bag (has InputSchema or OutputSchema) or a direct schema.\n * @internal\n */\ntype IsGraphNodeTypeBag<T> = T extends { InputSchema: unknown }\n  ? true\n  : T extends { OutputSchema: unknown }\n  ? true\n  : false;\n\n/**\n * Return value type for GraphNode functions.\n * Nodes can return an update object, a Command, or a Promise of either.\n *\n * @template Update - The update type (what fields can be returned)\n * @template Nodes - Union of valid node names for Command.goto\n */\nexport type GraphNodeReturnValue<Update, Nodes extends string = string> =\n  | Update\n  | CommandInstance<unknown, Update, Nodes>\n  | Promise<Update | CommandInstance<unknown, Update, Nodes>>;\n\n/**\n * Strongly-typed utility for authoring graph nodes outside of the StateGraph builder,\n * supporting inference for both state (from Schema) and config context (from Context type).\n *\n * This type enables you to define graph node functions with full type safety—both\n * for the evolving state and for additional context that may be passed in at runtime.\n * Typing the context parameter allows for better code organization and precise editor support.\n *\n * Works with StateSchema, AnnotationRoot, and Zod object schemas for state, and\n * with a user-defined object shape for context.\n *\n * **Supports two patterns:**\n *\n * 1. **Single schema usage** - Single schema for both input and output:\n *    `GraphNode<Schema, Context, Nodes>`\n *\n * 2. **Type bag pattern** - Separate schemas for input, output, context:\n *    `GraphNode<{ InputSchema; OutputSchema; ContextSchema; Nodes }>`\n *\n * @template Schema - The state schema type (StateSchema, AnnotationRoot, InteropZodObject) OR a type bag\n * @template Context - The type of the context passed into this node (default: Record<string, unknown>)\n * @template Nodes - An optional union of valid node names for Command.goto, used for type-safe routing (default: string)\n *\n * @example Single schema usage\n * ```typescript\n * import { StateSchema, GraphNode } from \"@langchain/langgraph\";\n * import { z } from \"zod/v4\";\n *\n * const AgentState = new StateSchema({\n *   messages: MessagesValue,\n *   step: z.number().default(0),\n * });\n *\n * // Context shape for custom node logic (optional)\n * type MyContext = { userId: string };\n *\n * // Node receiving state and config\n * const processNode: GraphNode<typeof AgentState, MyContext> = (state, config) => {\n *   const userId = config.configurable?.userId; // type-safe context access\n *   return { step: state.step + 1 };\n * };\n *\n * // Node with type-safe graph routing\n * const routerNode: GraphNode<typeof AgentState, MyContext, \"agent\" | \"tool\"> = (state, config) => {\n *   if (state.needsTool) {\n *     return new Command({ goto: \"tool\", update: { step: state.step + 1 } });\n *   }\n *   return new Command({ goto: \"agent\" });\n * };\n *\n * // Use in graph\n * const graph = new StateGraph(AgentState)\n *   .addNode(\"process\", processNode)\n *   .addNode(\"router\", routerNode)\n *   .compile();\n * ```\n *\n * @example Type bag pattern - separate input/output schemas\n * ```typescript\n * const InputSchema = new StateSchema({\n *   messages: z.array(z.string()),\n *   query: z.string(),\n * });\n *\n * const OutputSchema = new StateSchema({\n *   answer: z.string(),\n * });\n *\n * const ContextSchema = z.object({ userId: z.string() });\n *\n * const node: GraphNode<{\n *   InputSchema: typeof InputSchema;\n *   OutputSchema: typeof OutputSchema;\n *   ContextSchema: typeof ContextSchema;\n *   Nodes: \"agent\" | \"tool\";\n * }> = (state, config) => {\n *   // state is { messages: string[]; query: string }\n *   // config.configurable is { userId: string } | undefined\n *   return { answer: `Response to: ${state.query}` };\n * };\n * ```\n */\nexport type GraphNode<\n  Schema,\n  Context extends Record<string, any> = Record<string, any>,\n  Nodes extends string = string\n> = IsGraphNodeTypeBag<Schema> extends true\n  ? // Type bag pattern - extract types from schemas\n    (\n      state: ExtractBagInput<Schema, unknown>,\n      config: LangGraphRunnableConfig<\n        ExtractBagContext<Schema, Record<string, unknown>>\n      >\n    ) => GraphNodeReturnValue<\n      ExtractBagOutput<Schema, Partial<ExtractBagInput<Schema, unknown>>>,\n      ExtractBagNodes<Schema, string>\n    >\n  : // Single schema pattern (backward compatible)\n    (\n      state: ExtractStateType<Schema>,\n      config: LangGraphRunnableConfig<Context>\n    ) => GraphNodeReturnValue<ExtractUpdateType<Schema>, Nodes>;\n\n/**\n * Type bag for ConditionalEdgeRouter that accepts schema types.\n * Unlike GraphNodeTypes, conditional edges don't have separate input/output -\n * they just read state and return routing decisions.\n *\n * @example\n * ```typescript\n * const router: ConditionalEdgeRouter<{\n *   Schema: typeof StateSchema;\n *   ContextSchema: typeof ContextSchema;\n *   Nodes: \"agent\" | \"tool\";\n * }> = (state, config) => {\n *   return state.done ? END : \"agent\";\n * };\n * ```\n */\nexport interface ConditionalEdgeRouterTypes<\n  InputSchema = unknown,\n  ContextSchema = unknown,\n  Nodes extends string = string\n> {\n  /** Schema for router state (uses ExtractStateType) */\n  InputSchema?: InputSchema;\n  /** Schema for runtime context (uses ExtractStateType) */\n  ContextSchema?: ContextSchema;\n  /** Union of valid node names that can be routed to */\n  Nodes?: Nodes;\n}\n\n/**\n * Detect if T is a ConditionalEdgeRouterTypes bag.\n * @internal\n */\ntype IsConditionalEdgeRouterTypeBag<T> = T extends { InputSchema: unknown }\n  ? true\n  : T extends { ContextSchema: unknown }\n  ? true\n  : false;\n\n/**\n * Return type for conditional edge routing functions.\n */\ntype ConditionalEdgeRouterReturnValue<Nodes extends string, State> =\n  | Nodes\n  | typeof END\n  | Send<Nodes, State>\n  | Array<Nodes | Send<Nodes, State>>;\n\n/**\n * Type for conditional edge routing functions.\n *\n * Use this to type functions passed to `addConditionalEdges` for\n * full type safety on state, runtime context, and return values.\n *\n * **Supports two patterns:**\n *\n * 1. **Single schema pattern** - Single schema:\n *    `ConditionalEdgeRouter<Schema, Context, Nodes>`\n *\n * 2. **Type bag pattern** - Separate schemas for state, context:\n *    `ConditionalEdgeRouter<{ Schema; ContextSchema; Nodes }>`\n *\n * @template Schema - The state schema type OR a type bag\n * @template Context - The runtime context type available to node logic\n * @template Nodes - Union of valid node names that can be routed to\n *\n * @example Single schema pattern\n * ```typescript\n * type MyContext = { userId: string };\n * const router: ConditionalEdgeRouter<typeof AgentState, MyContext, \"agent\" | \"tool\"> =\n *   (state, config) => {\n *     const userId = config.context?.userId;\n *     if (state.done) return END;\n *     return state.needsTool ? \"tool\" : \"agent\";\n *   };\n *\n * graph.addConditionalEdges(\"router\", router, [\"agent\", \"tool\"]);\n * ```\n *\n * @example Type bag pattern\n * ```typescript\n * const router: ConditionalEdgeRouter<{\n *   Schema: typeof StateSchema;\n *   ContextSchema: typeof ContextSchema;\n *   Nodes: \"agent\" | \"tool\";\n * }> = (state, config) => {\n *   if (state.done) return END;\n *   return \"agent\";\n * };\n * ```\n */\nexport type ConditionalEdgeRouter<\n  Schema,\n  Context extends Record<string, any> = Record<string, any>,\n  Nodes extends string = string\n> = IsConditionalEdgeRouterTypeBag<Schema> extends true\n  ? // Type bag pattern - extract types from schemas\n    (\n      state: ExtractBagInput<Schema, unknown>,\n      config: LangGraphRunnableConfig<\n        ExtractBagContext<Schema, Record<string, unknown>>\n      >\n    ) =>\n      | ConditionalEdgeRouterReturnValue<\n          ExtractBagNodes<Schema, string>,\n          ExtractBagInput<Schema, unknown>\n        >\n      | Promise<\n          ConditionalEdgeRouterReturnValue<\n            ExtractBagNodes<Schema, string>,\n            ExtractBagInput<Schema, unknown>\n          >\n        >\n  : // Single schema pattern (backward compatible)\n    (\n      state: ExtractStateType<Schema>,\n      config: LangGraphRunnableConfig<Context>\n    ) =>\n      | ConditionalEdgeRouterReturnValue<Nodes, ExtractStateType<Schema>>\n      | Promise<\n          ConditionalEdgeRouterReturnValue<Nodes, ExtractStateType<Schema>>\n        >;\n"],"mappings":";;;;;;;;;;;;AA2DA,SAAgB,sBACd,OAC8B;AAC9B,KAAI,SAAS,KAAM,QAAO;AAG1B,KAAI,YAAY,WAAW,MAAM,CAAE,QAAO;AAG1C,KAAI,mBAAmB,MAAM,CAAE,QAAO;AAGtC,KACE,OAAO,UAAU,YACjB,mBAAmB,SAClB,MAAqC,kBAAkB,iBAExD,QAAO;AAIT,KACE,OAAO,UAAU,YACjB,CAAC,MAAM,QAAQ,MAAM,IACrB,OAAO,KAAK,MAAM,CAAC,SAAS,KAC5B,OAAO,OAAO,MAAM,CAAC,OAClB,MAAM,OAAO,MAAM,cAAc,cAAc,EAAE,CACnD,CAED,QAAO;AAGT,QAAO;;;;;;;AAgFT,SAAgB,iBACd,OAC8C;AAC9C,KAAI,OAAO,UAAU,YAAY,SAAS,KAAM,QAAO;CAEvD,MAAM,MAAM;CAGZ,MAAM,WAAW,WAAW,OAAO,sBAAsB,IAAI,MAAM;CACnE,MAAM,iBACJ,iBAAiB,OAAO,sBAAsB,IAAI,YAAY;CAChE,MAAM,WAAW,WAAW,OAAO,sBAAsB,IAAI,MAAM;AAEnE,KAAI,CAAC,YAAY,CAAC,kBAAkB,CAAC,SAAU,QAAO;AAGtD,KAAI,WAAW,OAAO,IAAI,SAAS,QAAQ,CAAC,sBAAsB,IAAI,MAAM,CAC1E,QAAO;AACT,KACE,YAAY,OACZ,IAAI,UAAU,QACd,CAAC,sBAAsB,IAAI,OAAO,CAElC,QAAO;AAET,QAAO"}

package/dist/graph/zod/meta.cjs

@@ -98,11 +98,11 @@ var SchemaMetaRegistry = class {
 		if (cache.has(schema)) return cache.get(schema);
 		let modifiedSchema = schema;
 		if (effects.withReducerSchema || effects.withJsonSchemaExtrasAsDescription) {
-			const newShapeEntries = Object.entries((0, _langchain_core_utils_types.getInteropZodObjectShape)(schema)).map(([key, schema$1]) => {
-				const meta = this.get(schema$1);
-				let outputSchema = effects.withReducerSchema ? meta?.reducer?.schema ?? schema$1 : schema$1;
+			const newShapeEntries = Object.entries((0, _langchain_core_utils_types.getInteropZodObjectShape)(schema)).map(([key, schema]) => {
+				const meta = this.get(schema);
+				let outputSchema = effects.withReducerSchema ? meta?.reducer?.schema ?? schema : schema;
 				if (effects.withJsonSchemaExtrasAsDescription && meta?.jsonSchemaExtra) {
-					const description = (0, _langchain_core_utils_types.getSchemaDescription)(outputSchema) ?? (0, _langchain_core_utils_types.getSchemaDescription)(schema$1);
+					const description = (0, _langchain_core_utils_types.getSchemaDescription)(outputSchema) ?? (0, _langchain_core_utils_types.getSchemaDescription)(schema);
 					const strExtras = JSON.stringify({
 						...meta.jsonSchemaExtra,
 						description

package/dist/graph/zod/meta.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"meta.cjs","names":["BinaryOperatorAggregate","LastValue","schema"],"sources":["../../../src/graph/zod/meta.ts"],"sourcesContent":["import {\n  InferInteropZodOutput,\n  InteropZodObject,\n  InteropZodType,\n  getInteropZodObjectShape,\n  extendInteropZodObject,\n  getInteropZodDefaultGetter,\n  interopZodObjectPartial,\n  InteropZodObjectShape,\n  isZodSchemaV3,\n  getSchemaDescription,\n} from \"@langchain/core/utils/types\";\nimport { BaseChannel } from \"../../channels/base.js\";\nimport { BinaryOperatorAggregate } from \"../../channels/binop.js\";\nimport { LastValue } from \"../../channels/last_value.js\";\n\nexport const META_EXTRAS_DESCRIPTION_PREFIX = \"lg:\";\n\n/** @internal */\nexport type ReducedZodChannel<\n  T extends InteropZodType,\n  TReducerSchema extends InteropZodType\n> = T & {\n  lg_reducer_schema: TReducerSchema;\n};\n\n/** @internal */\nexport type InteropZodToStateDefinition<\n  T extends InteropZodObject,\n  TShape = InteropZodObjectShape<T>\n> = {\n  [key in keyof TShape]: TShape[key] extends ReducedZodChannel<\n    infer Schema,\n    infer ReducerSchema\n  >\n    ? Schema extends InteropZodType<infer V>\n      ? ReducerSchema extends InteropZodType<infer U>\n        ? BaseChannel<V, U>\n        : never\n      : never\n    : TShape[key] extends InteropZodType<infer V, infer U>\n    ? BaseChannel<V, U>\n    : never;\n};\n\nexport type UpdateType<\n  T extends InteropZodObject,\n  TShape = InteropZodObjectShape<T>\n> = {\n  [key in keyof TShape]?: TShape[key] extends ReducedZodChannel<\n    infer Schema,\n    infer ReducerSchema\n  >\n    ? Schema extends InteropZodType<unknown>\n      ? ReducerSchema extends InteropZodType<infer U>\n        ? U\n        : never\n      : never\n    : TShape[key] extends InteropZodType<unknown, infer U>\n    ? U\n    : never;\n};\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport interface SchemaMeta<TValue = any, TUpdate = TValue> {\n  jsonSchemaExtra?: {\n    langgraph_nodes?: string[];\n    langgraph_type?: \"prompt\" | \"messages\";\n    [key: string]: unknown;\n  };\n  reducer?: {\n    schema?: InteropZodType<TUpdate>;\n    fn: (a: TValue, b: TUpdate) => TValue;\n  };\n  default?: () => TValue;\n}\n\n/**\n * A registry for storing and managing metadata associated with schemas.\n * This class provides methods to get, extend, remove, and check metadata for a given schema.\n */\nexport class SchemaMetaRegistry {\n  /**\n   * Internal map storing schema metadata.\n   * @internal\n   */\n  _map = new WeakMap<InteropZodType, SchemaMeta>();\n\n  /**\n   * Cache for extended schfemas.\n   * @internal\n   */\n  _extensionCache = new Map<string, WeakMap<InteropZodType, InteropZodType>>();\n\n  /**\n   * Retrieves the metadata associated with a given schema.\n   * @template TValue The value type of the schema.\n   * @template TUpdate The update type of the schema (defaults to TValue).\n   * @param schema The schema to retrieve metadata for.\n   * @returns The associated SchemaMeta, or undefined if not present.\n   */\n  get<TValue, TUpdate = TValue>(\n    schema: InteropZodType<TValue>\n  ): SchemaMeta<TValue, TUpdate> | undefined {\n    return this._map.get(schema);\n  }\n\n  /**\n   * Extends or sets the metadata for a given schema.\n   * @template TValue The value type of the schema.\n   * @template TUpdate The update type of the schema (defaults to TValue).\n   * @param schema The schema to extend metadata for.\n   * @param predicate A function that receives the existing metadata (or undefined) and returns the new metadata.\n   */\n  extend<TValue, TUpdate>(\n    schema: InteropZodType<TValue>,\n    predicate: (\n      meta: SchemaMeta<TValue, TUpdate> | undefined\n    ) => SchemaMeta<TValue, TUpdate>\n  ) {\n    const existingMeta = this.get<TValue, TUpdate>(schema);\n    this._map.set(schema, predicate(existingMeta));\n  }\n\n  /**\n   * Removes the metadata associated with a given schema.\n   * @param schema The schema to remove metadata for.\n   * @returns The SchemaMetaRegistry instance (for chaining).\n   */\n  remove(schema: InteropZodType): this {\n    this._map.delete(schema);\n    return this;\n  }\n\n  /**\n   * Checks if metadata exists for a given schema.\n   * @param schema The schema to check.\n   * @returns True if metadata exists, false otherwise.\n   */\n  has(schema: InteropZodType): boolean {\n    return this._map.has(schema);\n  }\n\n  /**\n   * Returns a mapping of channel instances for each property in the schema\n   * using the associated metadata in the registry.\n   *\n   * This is used to create the `channels` object that's passed to the `Graph` constructor.\n   *\n   * @template T The shape of the schema.\n   * @param schema The schema to extract channels from.\n   * @returns A mapping from property names to channel instances.\n   */\n  getChannelsForSchema<T extends InteropZodObject>(\n    schema: T\n  ): InteropZodToStateDefinition<T> {\n    const channels = {} as Record<string, BaseChannel>;\n    const shape = getInteropZodObjectShape(schema);\n    for (const [key, channelSchema] of Object.entries(shape)) {\n      const meta = this.get(channelSchema);\n      if (meta?.reducer) {\n        channels[key] = new BinaryOperatorAggregate<\n          InferInteropZodOutput<typeof channelSchema>\n        >(meta.reducer.fn, meta.default);\n      } else {\n        channels[key] = new LastValue(meta?.default);\n      }\n    }\n    return channels as InteropZodToStateDefinition<T>;\n  }\n\n  /**\n   * Returns a modified schema that introspectively looks at all keys of the provided\n   * object schema, and applies the augmentations based on meta provided with those keys\n   * in the registry and the selectors provided in the `effects` parameter.\n   *\n   * This assumes that the passed in schema is the \"root\" schema object for a graph where\n   * the keys of the schema are the channels of the graph. Because we need to represent\n   * the input of a graph in a couple of different ways, the `effects` parameter allows\n   * us to apply those augmentations based on pre determined conditions.\n   *\n   * @param schema The root schema object to extend.\n   * @param effects The effects that are being applied.\n   * @returns The extended schema.\n   */\n  getExtendedChannelSchemas<T extends InteropZodObject>(\n    schema: T,\n    effects: {\n      /**\n       * Augments the shape by using the reducer's schema if it exists\n       */\n      withReducerSchema?: boolean;\n      /**\n       * Applies the stringified jsonSchemaExtra as a description to the schema.\n       */\n      withJsonSchemaExtrasAsDescription?: boolean;\n      /**\n       * Applies the `.partial()` modifier to the schema.\n       */\n      asPartial?: boolean;\n    }\n  ): InteropZodObject {\n    // If no effects are being applied, return the schema unchanged\n    if (Object.keys(effects).length === 0) {\n      return schema;\n    }\n\n    // Cache key is determined by looking at the effects that are being applied\n    const cacheKey = Object.entries(effects)\n      .filter(([, v]) => v === true)\n      .sort(([a], [b]) => a.localeCompare(b))\n      .map(([k, v]) => `${k}:${v}`)\n      .join(\"|\");\n\n    const cache = this._extensionCache.get(cacheKey) ?? new WeakMap();\n    if (cache.has(schema)) return cache.get(schema)! as T;\n\n    let modifiedSchema: InteropZodObject = schema;\n\n    if (\n      effects.withReducerSchema ||\n      effects.withJsonSchemaExtrasAsDescription\n    ) {\n      const newShapeEntries = Object.entries(\n        getInteropZodObjectShape(schema)\n      ).map(([key, schema]) => {\n        const meta = this.get(schema);\n        let outputSchema = effects.withReducerSchema\n          ? meta?.reducer?.schema ?? schema\n          : schema;\n        if (\n          effects.withJsonSchemaExtrasAsDescription &&\n          meta?.jsonSchemaExtra\n        ) {\n          const description =\n            getSchemaDescription(outputSchema) ?? getSchemaDescription(schema);\n          const strExtras = JSON.stringify({\n            ...meta.jsonSchemaExtra,\n            description,\n          });\n          outputSchema = outputSchema.describe(\n            `${META_EXTRAS_DESCRIPTION_PREFIX}${strExtras}`\n          );\n        }\n        return [key, outputSchema];\n      });\n      modifiedSchema = extendInteropZodObject(\n        schema,\n        Object.fromEntries(newShapeEntries)\n      );\n      if (isZodSchemaV3(modifiedSchema)) {\n        modifiedSchema._def.unknownKeys = \"strip\";\n      }\n    }\n    if (effects.asPartial) {\n      modifiedSchema = interopZodObjectPartial(modifiedSchema);\n    }\n\n    cache.set(schema, modifiedSchema);\n    this._extensionCache.set(cacheKey, cache);\n    return modifiedSchema;\n  }\n}\n\nexport const schemaMetaRegistry = new SchemaMetaRegistry();\n\nexport function withLangGraph<\n  TValue,\n  TUpdate,\n  TSchema extends InteropZodType<TValue>\n>(\n  schema: TSchema,\n  meta: SchemaMeta<TValue, TUpdate> & { reducer?: undefined }\n): TSchema;\nexport function withLangGraph<\n  TValue,\n  TUpdate,\n  TSchema extends InteropZodType<TValue>\n>(\n  schema: TSchema,\n  meta: SchemaMeta<TValue, TUpdate>\n): ReducedZodChannel<TSchema, InteropZodType<TUpdate>>;\nexport function withLangGraph<\n  TValue,\n  TUpdate,\n  TSchema extends InteropZodType<TValue>\n>(\n  schema: TSchema,\n  meta: SchemaMeta<TValue, TUpdate>\n): ReducedZodChannel<TSchema, InteropZodType<TUpdate>> | TSchema {\n  if (meta.reducer && !meta.default) {\n    const defaultValueGetter = getInteropZodDefaultGetter(schema);\n    if (defaultValueGetter != null) {\n      // eslint-disable-next-line no-param-reassign\n      meta.default = defaultValueGetter;\n    }\n  }\n  if (meta.reducer) {\n    const schemaWithReducer = Object.assign(schema, {\n      lg_reducer_schema: meta.reducer?.schema ?? schema,\n    });\n    schemaMetaRegistry.extend(schemaWithReducer, () => meta);\n    return schemaWithReducer;\n  } else {\n    schemaMetaRegistry.extend(schema, () => meta);\n    return schema;\n  }\n}\n"],"mappings":";;;;;AAgBA,MAAa,iCAAiC;;;;;AAiE9C,IAAa,qBAAb,MAAgC;;;;;CAK9B,uBAAO,IAAI,SAAqC;;;;;CAMhD,kCAAkB,IAAI,KAAsD;;;;;;;;CAS5E,IACE,QACyC;AACzC,SAAO,KAAK,KAAK,IAAI,OAAO;;;;;;;;;CAU9B,OACE,QACA,WAGA;EACA,MAAM,eAAe,KAAK,IAAqB,OAAO;AACtD,OAAK,KAAK,IAAI,QAAQ,UAAU,aAAa,CAAC;;;;;;;CAQhD,OAAO,QAA8B;AACnC,OAAK,KAAK,OAAO,OAAO;AACxB,SAAO;;;;;;;CAQT,IAAI,QAAiC;AACnC,SAAO,KAAK,KAAK,IAAI,OAAO;;;;;;;;;;;;CAa9B,qBACE,QACgC;EAChC,MAAM,WAAW,EAAE;EACnB,MAAM,kEAAiC,OAAO;AAC9C,OAAK,MAAM,CAAC,KAAK,kBAAkB,OAAO,QAAQ,MAAM,EAAE;GACxD,MAAM,OAAO,KAAK,IAAI,cAAc;AACpC,OAAI,MAAM,QACR,UAAS,OAAO,IAAIA,sCAElB,KAAK,QAAQ,IAAI,KAAK,QAAQ;OAEhC,UAAS,OAAO,IAAIC,6BAAU,MAAM,QAAQ;;AAGhD,SAAO;;;;;;;;;;;;;;;;CAiBT,0BACE,QACA,SAckB;AAElB,MAAI,OAAO,KAAK,QAAQ,CAAC,WAAW,EAClC,QAAO;EAIT,MAAM,WAAW,OAAO,QAAQ,QAAQ,CACrC,QAAQ,GAAG,OAAO,MAAM,KAAK,CAC7B,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,cAAc,EAAE,CAAC,CACtC,KAAK,CAAC,GAAG,OAAO,GAAG,EAAE,GAAG,IAAI,CAC5B,KAAK,IAAI;EAEZ,MAAM,QAAQ,KAAK,gBAAgB,IAAI,SAAS,oBAAI,IAAI,SAAS;AACjE,MAAI,MAAM,IAAI,OAAO,CAAE,QAAO,MAAM,IAAI,OAAO;EAE/C,IAAI,iBAAmC;AAEvC,MACE,QAAQ,qBACR,QAAQ,mCACR;GACA,MAAM,kBAAkB,OAAO,kEACJ,OAAO,CACjC,CAAC,KAAK,CAAC,KAAKC,cAAY;IACvB,MAAM,OAAO,KAAK,IAAIA,SAAO;IAC7B,IAAI,eAAe,QAAQ,oBACvB,MAAM,SAAS,UAAUA,WACzBA;AACJ,QACE,QAAQ,qCACR,MAAM,iBACN;KACA,MAAM,oEACiB,aAAa,0DAAyBA,SAAO;KACpE,MAAM,YAAY,KAAK,UAAU;MAC/B,GAAG,KAAK;MACR;MACD,CAAC;AACF,oBAAe,aAAa,SAC1B,GAAG,iCAAiC,YACrC;;AAEH,WAAO,CAAC,KAAK,aAAa;KAC1B;AACF,4EACE,QACA,OAAO,YAAY,gBAAgB,CACpC;AACD,sDAAkB,eAAe,CAC/B,gBAAe,KAAK,cAAc;;AAGtC,MAAI,QAAQ,UACV,2EAAyC,eAAe;AAG1D,QAAM,IAAI,QAAQ,eAAe;AACjC,OAAK,gBAAgB,IAAI,UAAU,MAAM;AACzC,SAAO;;;AAIX,MAAa,qBAAqB,IAAI,oBAAoB;AAkB1D,SAAgB,cAKd,QACA,MAC+D;AAC/D,KAAI,KAAK,WAAW,CAAC,KAAK,SAAS;EACjC,MAAM,iFAAgD,OAAO;AAC7D,MAAI,sBAAsB,KAExB,MAAK,UAAU;;AAGnB,KAAI,KAAK,SAAS;EAChB,MAAM,oBAAoB,OAAO,OAAO,QAAQ,EAC9C,mBAAmB,KAAK,SAAS,UAAU,QAC5C,CAAC;AACF,qBAAmB,OAAO,yBAAyB,KAAK;AACxD,SAAO;QACF;AACL,qBAAmB,OAAO,cAAc,KAAK;AAC7C,SAAO"}
+{"version":3,"file":"meta.cjs","names":["BinaryOperatorAggregate","LastValue"],"sources":["../../../src/graph/zod/meta.ts"],"sourcesContent":["import {\n  InferInteropZodOutput,\n  InteropZodObject,\n  InteropZodType,\n  getInteropZodObjectShape,\n  extendInteropZodObject,\n  getInteropZodDefaultGetter,\n  interopZodObjectPartial,\n  InteropZodObjectShape,\n  isZodSchemaV3,\n  getSchemaDescription,\n} from \"@langchain/core/utils/types\";\nimport { BaseChannel } from \"../../channels/base.js\";\nimport { BinaryOperatorAggregate } from \"../../channels/binop.js\";\nimport { LastValue } from \"../../channels/last_value.js\";\n\nexport const META_EXTRAS_DESCRIPTION_PREFIX = \"lg:\";\n\n/** @internal */\nexport type ReducedZodChannel<\n  T extends InteropZodType,\n  TReducerSchema extends InteropZodType\n> = T & {\n  lg_reducer_schema: TReducerSchema;\n};\n\n/** @internal */\nexport type InteropZodToStateDefinition<\n  T extends InteropZodObject,\n  TShape = InteropZodObjectShape<T>\n> = {\n  [key in keyof TShape]: TShape[key] extends ReducedZodChannel<\n    infer Schema,\n    infer ReducerSchema\n  >\n    ? Schema extends InteropZodType<infer V>\n      ? ReducerSchema extends InteropZodType<infer U>\n        ? BaseChannel<V, U>\n        : never\n      : never\n    : TShape[key] extends InteropZodType<infer V, infer U>\n    ? BaseChannel<V, U>\n    : never;\n};\n\nexport type UpdateType<\n  T extends InteropZodObject,\n  TShape = InteropZodObjectShape<T>\n> = {\n  [key in keyof TShape]?: TShape[key] extends ReducedZodChannel<\n    infer Schema,\n    infer ReducerSchema\n  >\n    ? Schema extends InteropZodType<unknown>\n      ? ReducerSchema extends InteropZodType<infer U>\n        ? U\n        : never\n      : never\n    : TShape[key] extends InteropZodType<unknown, infer U>\n    ? U\n    : never;\n};\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport interface SchemaMeta<TValue = any, TUpdate = TValue> {\n  jsonSchemaExtra?: {\n    langgraph_nodes?: string[];\n    langgraph_type?: \"prompt\" | \"messages\";\n    [key: string]: unknown;\n  };\n  reducer?: {\n    schema?: InteropZodType<TUpdate>;\n    fn: (a: TValue, b: TUpdate) => TValue;\n  };\n  default?: () => TValue;\n}\n\n/**\n * A registry for storing and managing metadata associated with schemas.\n * This class provides methods to get, extend, remove, and check metadata for a given schema.\n */\nexport class SchemaMetaRegistry {\n  /**\n   * Internal map storing schema metadata.\n   * @internal\n   */\n  _map = new WeakMap<InteropZodType, SchemaMeta>();\n\n  /**\n   * Cache for extended schfemas.\n   * @internal\n   */\n  _extensionCache = new Map<string, WeakMap<InteropZodType, InteropZodType>>();\n\n  /**\n   * Retrieves the metadata associated with a given schema.\n   * @template TValue The value type of the schema.\n   * @template TUpdate The update type of the schema (defaults to TValue).\n   * @param schema The schema to retrieve metadata for.\n   * @returns The associated SchemaMeta, or undefined if not present.\n   */\n  get<TValue, TUpdate = TValue>(\n    schema: InteropZodType<TValue>\n  ): SchemaMeta<TValue, TUpdate> | undefined {\n    return this._map.get(schema);\n  }\n\n  /**\n   * Extends or sets the metadata for a given schema.\n   * @template TValue The value type of the schema.\n   * @template TUpdate The update type of the schema (defaults to TValue).\n   * @param schema The schema to extend metadata for.\n   * @param predicate A function that receives the existing metadata (or undefined) and returns the new metadata.\n   */\n  extend<TValue, TUpdate>(\n    schema: InteropZodType<TValue>,\n    predicate: (\n      meta: SchemaMeta<TValue, TUpdate> | undefined\n    ) => SchemaMeta<TValue, TUpdate>\n  ) {\n    const existingMeta = this.get<TValue, TUpdate>(schema);\n    this._map.set(schema, predicate(existingMeta));\n  }\n\n  /**\n   * Removes the metadata associated with a given schema.\n   * @param schema The schema to remove metadata for.\n   * @returns The SchemaMetaRegistry instance (for chaining).\n   */\n  remove(schema: InteropZodType): this {\n    this._map.delete(schema);\n    return this;\n  }\n\n  /**\n   * Checks if metadata exists for a given schema.\n   * @param schema The schema to check.\n   * @returns True if metadata exists, false otherwise.\n   */\n  has(schema: InteropZodType): boolean {\n    return this._map.has(schema);\n  }\n\n  /**\n   * Returns a mapping of channel instances for each property in the schema\n   * using the associated metadata in the registry.\n   *\n   * This is used to create the `channels` object that's passed to the `Graph` constructor.\n   *\n   * @template T The shape of the schema.\n   * @param schema The schema to extract channels from.\n   * @returns A mapping from property names to channel instances.\n   */\n  getChannelsForSchema<T extends InteropZodObject>(\n    schema: T\n  ): InteropZodToStateDefinition<T> {\n    const channels = {} as Record<string, BaseChannel>;\n    const shape = getInteropZodObjectShape(schema);\n    for (const [key, channelSchema] of Object.entries(shape)) {\n      const meta = this.get(channelSchema);\n      if (meta?.reducer) {\n        channels[key] = new BinaryOperatorAggregate<\n          InferInteropZodOutput<typeof channelSchema>\n        >(meta.reducer.fn, meta.default);\n      } else {\n        channels[key] = new LastValue(meta?.default);\n      }\n    }\n    return channels as InteropZodToStateDefinition<T>;\n  }\n\n  /**\n   * Returns a modified schema that introspectively looks at all keys of the provided\n   * object schema, and applies the augmentations based on meta provided with those keys\n   * in the registry and the selectors provided in the `effects` parameter.\n   *\n   * This assumes that the passed in schema is the \"root\" schema object for a graph where\n   * the keys of the schema are the channels of the graph. Because we need to represent\n   * the input of a graph in a couple of different ways, the `effects` parameter allows\n   * us to apply those augmentations based on pre determined conditions.\n   *\n   * @param schema The root schema object to extend.\n   * @param effects The effects that are being applied.\n   * @returns The extended schema.\n   */\n  getExtendedChannelSchemas<T extends InteropZodObject>(\n    schema: T,\n    effects: {\n      /**\n       * Augments the shape by using the reducer's schema if it exists\n       */\n      withReducerSchema?: boolean;\n      /**\n       * Applies the stringified jsonSchemaExtra as a description to the schema.\n       */\n      withJsonSchemaExtrasAsDescription?: boolean;\n      /**\n       * Applies the `.partial()` modifier to the schema.\n       */\n      asPartial?: boolean;\n    }\n  ): InteropZodObject {\n    // If no effects are being applied, return the schema unchanged\n    if (Object.keys(effects).length === 0) {\n      return schema;\n    }\n\n    // Cache key is determined by looking at the effects that are being applied\n    const cacheKey = Object.entries(effects)\n      .filter(([, v]) => v === true)\n      .sort(([a], [b]) => a.localeCompare(b))\n      .map(([k, v]) => `${k}:${v}`)\n      .join(\"|\");\n\n    const cache = this._extensionCache.get(cacheKey) ?? new WeakMap();\n    if (cache.has(schema)) return cache.get(schema)! as T;\n\n    let modifiedSchema: InteropZodObject = schema;\n\n    if (\n      effects.withReducerSchema ||\n      effects.withJsonSchemaExtrasAsDescription\n    ) {\n      const newShapeEntries = Object.entries(\n        getInteropZodObjectShape(schema)\n      ).map(([key, schema]) => {\n        const meta = this.get(schema);\n        let outputSchema = effects.withReducerSchema\n          ? meta?.reducer?.schema ?? schema\n          : schema;\n        if (\n          effects.withJsonSchemaExtrasAsDescription &&\n          meta?.jsonSchemaExtra\n        ) {\n          const description =\n            getSchemaDescription(outputSchema) ?? getSchemaDescription(schema);\n          const strExtras = JSON.stringify({\n            ...meta.jsonSchemaExtra,\n            description,\n          });\n          outputSchema = outputSchema.describe(\n            `${META_EXTRAS_DESCRIPTION_PREFIX}${strExtras}`\n          );\n        }\n        return [key, outputSchema];\n      });\n      modifiedSchema = extendInteropZodObject(\n        schema,\n        Object.fromEntries(newShapeEntries)\n      );\n      if (isZodSchemaV3(modifiedSchema)) {\n        modifiedSchema._def.unknownKeys = \"strip\";\n      }\n    }\n    if (effects.asPartial) {\n      modifiedSchema = interopZodObjectPartial(modifiedSchema);\n    }\n\n    cache.set(schema, modifiedSchema);\n    this._extensionCache.set(cacheKey, cache);\n    return modifiedSchema;\n  }\n}\n\nexport const schemaMetaRegistry = new SchemaMetaRegistry();\n\nexport function withLangGraph<\n  TValue,\n  TUpdate,\n  TSchema extends InteropZodType<TValue>\n>(\n  schema: TSchema,\n  meta: SchemaMeta<TValue, TUpdate> & { reducer?: undefined }\n): TSchema;\nexport function withLangGraph<\n  TValue,\n  TUpdate,\n  TSchema extends InteropZodType<TValue>\n>(\n  schema: TSchema,\n  meta: SchemaMeta<TValue, TUpdate>\n): ReducedZodChannel<TSchema, InteropZodType<TUpdate>>;\nexport function withLangGraph<\n  TValue,\n  TUpdate,\n  TSchema extends InteropZodType<TValue>\n>(\n  schema: TSchema,\n  meta: SchemaMeta<TValue, TUpdate>\n): ReducedZodChannel<TSchema, InteropZodType<TUpdate>> | TSchema {\n  if (meta.reducer && !meta.default) {\n    const defaultValueGetter = getInteropZodDefaultGetter(schema);\n    if (defaultValueGetter != null) {\n      // eslint-disable-next-line no-param-reassign\n      meta.default = defaultValueGetter;\n    }\n  }\n  if (meta.reducer) {\n    const schemaWithReducer = Object.assign(schema, {\n      lg_reducer_schema: meta.reducer?.schema ?? schema,\n    });\n    schemaMetaRegistry.extend(schemaWithReducer, () => meta);\n    return schemaWithReducer;\n  } else {\n    schemaMetaRegistry.extend(schema, () => meta);\n    return schema;\n  }\n}\n"],"mappings":";;;;;AAgBA,MAAa,iCAAiC;;;;;AAiE9C,IAAa,qBAAb,MAAgC;;;;;CAK9B,uBAAO,IAAI,SAAqC;;;;;CAMhD,kCAAkB,IAAI,KAAsD;;;;;;;;CAS5E,IACE,QACyC;AACzC,SAAO,KAAK,KAAK,IAAI,OAAO;;;;;;;;;CAU9B,OACE,QACA,WAGA;EACA,MAAM,eAAe,KAAK,IAAqB,OAAO;AACtD,OAAK,KAAK,IAAI,QAAQ,UAAU,aAAa,CAAC;;;;;;;CAQhD,OAAO,QAA8B;AACnC,OAAK,KAAK,OAAO,OAAO;AACxB,SAAO;;;;;;;CAQT,IAAI,QAAiC;AACnC,SAAO,KAAK,KAAK,IAAI,OAAO;;;;;;;;;;;;CAa9B,qBACE,QACgC;EAChC,MAAM,WAAW,EAAE;EACnB,MAAM,kEAAiC,OAAO;AAC9C,OAAK,MAAM,CAAC,KAAK,kBAAkB,OAAO,QAAQ,MAAM,EAAE;GACxD,MAAM,OAAO,KAAK,IAAI,cAAc;AACpC,OAAI,MAAM,QACR,UAAS,OAAO,IAAIA,sCAElB,KAAK,QAAQ,IAAI,KAAK,QAAQ;OAEhC,UAAS,OAAO,IAAIC,6BAAU,MAAM,QAAQ;;AAGhD,SAAO;;;;;;;;;;;;;;;;CAiBT,0BACE,QACA,SAckB;AAElB,MAAI,OAAO,KAAK,QAAQ,CAAC,WAAW,EAClC,QAAO;EAIT,MAAM,WAAW,OAAO,QAAQ,QAAQ,CACrC,QAAQ,GAAG,OAAO,MAAM,KAAK,CAC7B,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,cAAc,EAAE,CAAC,CACtC,KAAK,CAAC,GAAG,OAAO,GAAG,EAAE,GAAG,IAAI,CAC5B,KAAK,IAAI;EAEZ,MAAM,QAAQ,KAAK,gBAAgB,IAAI,SAAS,oBAAI,IAAI,SAAS;AACjE,MAAI,MAAM,IAAI,OAAO,CAAE,QAAO,MAAM,IAAI,OAAO;EAE/C,IAAI,iBAAmC;AAEvC,MACE,QAAQ,qBACR,QAAQ,mCACR;GACA,MAAM,kBAAkB,OAAO,kEACJ,OAAO,CACjC,CAAC,KAAK,CAAC,KAAK,YAAY;IACvB,MAAM,OAAO,KAAK,IAAI,OAAO;IAC7B,IAAI,eAAe,QAAQ,oBACvB,MAAM,SAAS,UAAU,SACzB;AACJ,QACE,QAAQ,qCACR,MAAM,iBACN;KACA,MAAM,oEACiB,aAAa,0DAAyB,OAAO;KACpE,MAAM,YAAY,KAAK,UAAU;MAC/B,GAAG,KAAK;MACR;MACD,CAAC;AACF,oBAAe,aAAa,SAC1B,GAAG,iCAAiC,YACrC;;AAEH,WAAO,CAAC,KAAK,aAAa;KAC1B;AACF,4EACE,QACA,OAAO,YAAY,gBAAgB,CACpC;AACD,sDAAkB,eAAe,CAC/B,gBAAe,KAAK,cAAc;;AAGtC,MAAI,QAAQ,UACV,2EAAyC,eAAe;AAG1D,QAAM,IAAI,QAAQ,eAAe;AACjC,OAAK,gBAAgB,IAAI,UAAU,MAAM;AACzC,SAAO;;;AAIX,MAAa,qBAAqB,IAAI,oBAAoB;AAkB1D,SAAgB,cAKd,QACA,MAC+D;AAC/D,KAAI,KAAK,WAAW,CAAC,KAAK,SAAS;EACjC,MAAM,iFAAgD,OAAO;AAC7D,MAAI,sBAAsB,KAExB,MAAK,UAAU;;AAGnB,KAAI,KAAK,SAAS;EAChB,MAAM,oBAAoB,OAAO,OAAO,QAAQ,EAC9C,mBAAmB,KAAK,SAAS,UAAU,QAC5C,CAAC;AACF,qBAAmB,OAAO,yBAAyB,KAAK;AACxD,SAAO;QACF;AACL,qBAAmB,OAAO,cAAc,KAAK;AAC7C,SAAO"}

package/dist/graph/zod/meta.js

@@ -98,11 +98,11 @@ var SchemaMetaRegistry = class {
 		if (cache.has(schema)) return cache.get(schema);
 		let modifiedSchema = schema;
 		if (effects.withReducerSchema || effects.withJsonSchemaExtrasAsDescription) {
-			const newShapeEntries = Object.entries(getInteropZodObjectShape(schema)).map(([key, schema$1]) => {
-				const meta = this.get(schema$1);
-				let outputSchema = effects.withReducerSchema ? meta?.reducer?.schema ?? schema$1 : schema$1;
+			const newShapeEntries = Object.entries(getInteropZodObjectShape(schema)).map(([key, schema]) => {
+				const meta = this.get(schema);
+				let outputSchema = effects.withReducerSchema ? meta?.reducer?.schema ?? schema : schema;
 				if (effects.withJsonSchemaExtrasAsDescription && meta?.jsonSchemaExtra) {
-					const description = getSchemaDescription(outputSchema) ?? getSchemaDescription(schema$1);
+					const description = getSchemaDescription(outputSchema) ?? getSchemaDescription(schema);
 					const strExtras = JSON.stringify({
 						...meta.jsonSchemaExtra,
 						description