@copilotkit/sdk-js 1.56.4-canary.1777538870 → 1.56.5

package/dist/langgraph/types.d.mts

@@ -30,223 +30,280 @@ interface StandardSerializableSchema<Input, Output = Input> {
 }
 declare const CopilotKitPropertiesAnnotation: _langchain_langgraph0.AnnotationRoot<{
   actions: {
+    (annotation: _langchain_langgraph0.SingleReducer<any[], any[]>): _langchain_langgraph0.BaseChannel<any[], any[] | _langchain_langgraph0.OverwriteValue<any[]>, unknown>;
     (): _langchain_langgraph0.LastValue<any[]>;
-    (annotation: _langchain_langgraph0.SingleReducer<any[], any[]>): _langchain_langgraph0.BinaryOperatorAggregate<any[], any[]>;
     Root: <S extends _langchain_langgraph0.StateDefinition>(sd: S) => _langchain_langgraph0.AnnotationRoot<S>;
   };
   context: {
-    (): _langchain_langgraph0.LastValue<{
-      description: string;
-      value: string;
-    }[]>;
     (annotation: _langchain_langgraph0.SingleReducer<{
       description: string;
       value: string;
     }[], {
       description: string;
       value: string;
-    }[]>): _langchain_langgraph0.BinaryOperatorAggregate<{
+    }[]>): _langchain_langgraph0.BaseChannel<{
       description: string;
       value: string;
     }[], {
       description: string;
       value: string;
+    }[] | _langchain_langgraph0.OverwriteValue<{
+      description: string;
+      value: string;
+    }[]>, unknown>;
+    (): _langchain_langgraph0.LastValue<{
+      description: string;
+      value: string;
     }[]>;
     Root: <S extends _langchain_langgraph0.StateDefinition>(sd: S) => _langchain_langgraph0.AnnotationRoot<S>;
   };
   interceptedToolCalls: {
+    (annotation: _langchain_langgraph0.SingleReducer<any[], any[]>): _langchain_langgraph0.BaseChannel<any[], any[] | _langchain_langgraph0.OverwriteValue<any[]>, unknown>;
     (): _langchain_langgraph0.LastValue<any[]>;
-    (annotation: _langchain_langgraph0.SingleReducer<any[], any[]>): _langchain_langgraph0.BinaryOperatorAggregate<any[], any[]>;
     Root: <S extends _langchain_langgraph0.StateDefinition>(sd: S) => _langchain_langgraph0.AnnotationRoot<S>;
   };
   originalAIMessageId: {
+    (annotation: _langchain_langgraph0.SingleReducer<string, string>): _langchain_langgraph0.BaseChannel<string, string | _langchain_langgraph0.OverwriteValue<string>, unknown>;
     (): _langchain_langgraph0.LastValue<string>;
-    (annotation: _langchain_langgraph0.SingleReducer<string, string>): _langchain_langgraph0.BinaryOperatorAggregate<string, string>;
     Root: <S extends _langchain_langgraph0.StateDefinition>(sd: S) => _langchain_langgraph0.AnnotationRoot<S>;
   };
 }>;
 declare const CopilotKitStateAnnotation: _langchain_langgraph0.AnnotationRoot<{
-  messages: _langchain_langgraph0.BinaryOperatorAggregate<langchain.BaseMessage<_langchain_core_messages0.MessageStructure<_langchain_core_messages0.MessageToolSet>, _langchain_core_messages0.MessageType>[], _langchain_langgraph0.Messages>;
+  messages: _langchain_langgraph0.BaseChannel<langchain.BaseMessage<_langchain_core_messages0.MessageStructure<_langchain_core_messages0.MessageToolSet>, _langchain_core_messages0.MessageType>[], _langchain_langgraph0.OverwriteValue<langchain.BaseMessage<_langchain_core_messages0.MessageStructure<_langchain_core_messages0.MessageToolSet>, _langchain_core_messages0.MessageType>[]> | _langchain_langgraph0.Messages, unknown>;
   copilotkit: {
-    (): _langchain_langgraph0.LastValue<_langchain_langgraph0.StateType<{
+    (annotation: _langchain_langgraph0.SingleReducer<_langchain_langgraph0.StateType<{
       actions: {
+        (annotation: _langchain_langgraph0.SingleReducer<any[], any[]>): _langchain_langgraph0.BaseChannel<any[], any[] | _langchain_langgraph0.OverwriteValue<any[]>, unknown>;
         (): _langchain_langgraph0.LastValue<any[]>;
-        (annotation: _langchain_langgraph0.SingleReducer<any[], any[]>): _langchain_langgraph0.BinaryOperatorAggregate<any[], any[]>;
         Root: <S extends _langchain_langgraph0.StateDefinition>(sd: S) => _langchain_langgraph0.AnnotationRoot<S>;
       };
       context: {
-        (): _langchain_langgraph0.LastValue<{
-          description: string;
-          value: string;
-        }[]>;
         (annotation: _langchain_langgraph0.SingleReducer<{
           description: string;
           value: string;
         }[], {
           description: string;
           value: string;
-        }[]>): _langchain_langgraph0.BinaryOperatorAggregate<{
+        }[]>): _langchain_langgraph0.BaseChannel<{
           description: string;
           value: string;
         }[], {
           description: string;
           value: string;
+        }[] | _langchain_langgraph0.OverwriteValue<{
+          description: string;
+          value: string;
+        }[]>, unknown>;
+        (): _langchain_langgraph0.LastValue<{
+          description: string;
+          value: string;
         }[]>;
         Root: <S extends _langchain_langgraph0.StateDefinition>(sd: S) => _langchain_langgraph0.AnnotationRoot<S>;
       };
       interceptedToolCalls: {
+        (annotation: _langchain_langgraph0.SingleReducer<any[], any[]>): _langchain_langgraph0.BaseChannel<any[], any[] | _langchain_langgraph0.OverwriteValue<any[]>, unknown>;
         (): _langchain_langgraph0.LastValue<any[]>;
-        (annotation: _langchain_langgraph0.SingleReducer<any[], any[]>): _langchain_langgraph0.BinaryOperatorAggregate<any[], any[]>;
         Root: <S extends _langchain_langgraph0.StateDefinition>(sd: S) => _langchain_langgraph0.AnnotationRoot<S>;
       };
       originalAIMessageId: {
+        (annotation: _langchain_langgraph0.SingleReducer<string, string>): _langchain_langgraph0.BaseChannel<string, string | _langchain_langgraph0.OverwriteValue<string>, unknown>;
         (): _langchain_langgraph0.LastValue<string>;
-        (annotation: _langchain_langgraph0.SingleReducer<string, string>): _langchain_langgraph0.BinaryOperatorAggregate<string, string>;
         Root: <S extends _langchain_langgraph0.StateDefinition>(sd: S) => _langchain_langgraph0.AnnotationRoot<S>;
       };
-    }>>;
-    (annotation: _langchain_langgraph0.SingleReducer<_langchain_langgraph0.StateType<{
+    }>, _langchain_langgraph0.StateType<{
       actions: {
+        (annotation: _langchain_langgraph0.SingleReducer<any[], any[]>): _langchain_langgraph0.BaseChannel<any[], any[] | _langchain_langgraph0.OverwriteValue<any[]>, unknown>;
         (): _langchain_langgraph0.LastValue<any[]>;
-        (annotation: _langchain_langgraph0.SingleReducer<any[], any[]>): _langchain_langgraph0.BinaryOperatorAggregate<any[], any[]>;
         Root: <S extends _langchain_langgraph0.StateDefinition>(sd: S) => _langchain_langgraph0.AnnotationRoot<S>;
       };
       context: {
+        (annotation: _langchain_langgraph0.SingleReducer<{
+          description: string;
+          value: string;
+        }[], {
+          description: string;
+          value: string;
+        }[]>): _langchain_langgraph0.BaseChannel<{
+          description: string;
+          value: string;
+        }[], {
+          description: string;
+          value: string;
+        }[] | _langchain_langgraph0.OverwriteValue<{
+          description: string;
+          value: string;
+        }[]>, unknown>;
         (): _langchain_langgraph0.LastValue<{
           description: string;
           value: string;
         }[]>;
+        Root: <S extends _langchain_langgraph0.StateDefinition>(sd: S) => _langchain_langgraph0.AnnotationRoot<S>;
+      };
+      interceptedToolCalls: {
+        (annotation: _langchain_langgraph0.SingleReducer<any[], any[]>): _langchain_langgraph0.BaseChannel<any[], any[] | _langchain_langgraph0.OverwriteValue<any[]>, unknown>;
+        (): _langchain_langgraph0.LastValue<any[]>;
+        Root: <S extends _langchain_langgraph0.StateDefinition>(sd: S) => _langchain_langgraph0.AnnotationRoot<S>;
+      };
+      originalAIMessageId: {
+        (annotation: _langchain_langgraph0.SingleReducer<string, string>): _langchain_langgraph0.BaseChannel<string, string | _langchain_langgraph0.OverwriteValue<string>, unknown>;
+        (): _langchain_langgraph0.LastValue<string>;
+        Root: <S extends _langchain_langgraph0.StateDefinition>(sd: S) => _langchain_langgraph0.AnnotationRoot<S>;
+      };
+    }>>): _langchain_langgraph0.BaseChannel<_langchain_langgraph0.StateType<{
+      actions: {
+        (annotation: _langchain_langgraph0.SingleReducer<any[], any[]>): _langchain_langgraph0.BaseChannel<any[], any[] | _langchain_langgraph0.OverwriteValue<any[]>, unknown>;
+        (): _langchain_langgraph0.LastValue<any[]>;
+        Root: <S extends _langchain_langgraph0.StateDefinition>(sd: S) => _langchain_langgraph0.AnnotationRoot<S>;
+      };
+      context: {
         (annotation: _langchain_langgraph0.SingleReducer<{
           description: string;
           value: string;
         }[], {
           description: string;
           value: string;
-        }[]>): _langchain_langgraph0.BinaryOperatorAggregate<{
+        }[]>): _langchain_langgraph0.BaseChannel<{
           description: string;
           value: string;
         }[], {
           description: string;
           value: string;
+        }[] | _langchain_langgraph0.OverwriteValue<{
+          description: string;
+          value: string;
+        }[]>, unknown>;
+        (): _langchain_langgraph0.LastValue<{
+          description: string;
+          value: string;
         }[]>;
         Root: <S extends _langchain_langgraph0.StateDefinition>(sd: S) => _langchain_langgraph0.AnnotationRoot<S>;
       };
       interceptedToolCalls: {
+        (annotation: _langchain_langgraph0.SingleReducer<any[], any[]>): _langchain_langgraph0.BaseChannel<any[], any[] | _langchain_langgraph0.OverwriteValue<any[]>, unknown>;
         (): _langchain_langgraph0.LastValue<any[]>;
-        (annotation: _langchain_langgraph0.SingleReducer<any[], any[]>): _langchain_langgraph0.BinaryOperatorAggregate<any[], any[]>;
         Root: <S extends _langchain_langgraph0.StateDefinition>(sd: S) => _langchain_langgraph0.AnnotationRoot<S>;
       };
       originalAIMessageId: {
+        (annotation: _langchain_langgraph0.SingleReducer<string, string>): _langchain_langgraph0.BaseChannel<string, string | _langchain_langgraph0.OverwriteValue<string>, unknown>;
         (): _langchain_langgraph0.LastValue<string>;
-        (annotation: _langchain_langgraph0.SingleReducer<string, string>): _langchain_langgraph0.BinaryOperatorAggregate<string, string>;
         Root: <S extends _langchain_langgraph0.StateDefinition>(sd: S) => _langchain_langgraph0.AnnotationRoot<S>;
       };
     }>, _langchain_langgraph0.StateType<{
       actions: {
+        (annotation: _langchain_langgraph0.SingleReducer<any[], any[]>): _langchain_langgraph0.BaseChannel<any[], any[] | _langchain_langgraph0.OverwriteValue<any[]>, unknown>;
         (): _langchain_langgraph0.LastValue<any[]>;
-        (annotation: _langchain_langgraph0.SingleReducer<any[], any[]>): _langchain_langgraph0.BinaryOperatorAggregate<any[], any[]>;
         Root: <S extends _langchain_langgraph0.StateDefinition>(sd: S) => _langchain_langgraph0.AnnotationRoot<S>;
       };
       context: {
-        (): _langchain_langgraph0.LastValue<{
-          description: string;
-          value: string;
-        }[]>;
         (annotation: _langchain_langgraph0.SingleReducer<{
           description: string;
           value: string;
         }[], {
           description: string;
           value: string;
-        }[]>): _langchain_langgraph0.BinaryOperatorAggregate<{
+        }[]>): _langchain_langgraph0.BaseChannel<{
           description: string;
           value: string;
         }[], {
           description: string;
           value: string;
+        }[] | _langchain_langgraph0.OverwriteValue<{
+          description: string;
+          value: string;
+        }[]>, unknown>;
+        (): _langchain_langgraph0.LastValue<{
+          description: string;
+          value: string;
         }[]>;
         Root: <S extends _langchain_langgraph0.StateDefinition>(sd: S) => _langchain_langgraph0.AnnotationRoot<S>;
       };
       interceptedToolCalls: {
+        (annotation: _langchain_langgraph0.SingleReducer<any[], any[]>): _langchain_langgraph0.BaseChannel<any[], any[] | _langchain_langgraph0.OverwriteValue<any[]>, unknown>;
         (): _langchain_langgraph0.LastValue<any[]>;
-        (annotation: _langchain_langgraph0.SingleReducer<any[], any[]>): _langchain_langgraph0.BinaryOperatorAggregate<any[], any[]>;
         Root: <S extends _langchain_langgraph0.StateDefinition>(sd: S) => _langchain_langgraph0.AnnotationRoot<S>;
       };
       originalAIMessageId: {
+        (annotation: _langchain_langgraph0.SingleReducer<string, string>): _langchain_langgraph0.BaseChannel<string, string | _langchain_langgraph0.OverwriteValue<string>, unknown>;
         (): _langchain_langgraph0.LastValue<string>;
-        (annotation: _langchain_langgraph0.SingleReducer<string, string>): _langchain_langgraph0.BinaryOperatorAggregate<string, string>;
         Root: <S extends _langchain_langgraph0.StateDefinition>(sd: S) => _langchain_langgraph0.AnnotationRoot<S>;
       };
-    }>>): _langchain_langgraph0.BinaryOperatorAggregate<_langchain_langgraph0.StateType<{
+    }> | _langchain_langgraph0.OverwriteValue<_langchain_langgraph0.StateType<{
       actions: {
+        (annotation: _langchain_langgraph0.SingleReducer<any[], any[]>): _langchain_langgraph0.BaseChannel<any[], any[] | _langchain_langgraph0.OverwriteValue<any[]>, unknown>;
         (): _langchain_langgraph0.LastValue<any[]>;
-        (annotation: _langchain_langgraph0.SingleReducer<any[], any[]>): _langchain_langgraph0.BinaryOperatorAggregate<any[], any[]>;
         Root: <S extends _langchain_langgraph0.StateDefinition>(sd: S) => _langchain_langgraph0.AnnotationRoot<S>;
       };
       context: {
-        (): _langchain_langgraph0.LastValue<{
-          description: string;
-          value: string;
-        }[]>;
         (annotation: _langchain_langgraph0.SingleReducer<{
           description: string;
           value: string;
         }[], {
           description: string;
           value: string;
-        }[]>): _langchain_langgraph0.BinaryOperatorAggregate<{
+        }[]>): _langchain_langgraph0.BaseChannel<{
           description: string;
           value: string;
         }[], {
           description: string;
           value: string;
+        }[] | _langchain_langgraph0.OverwriteValue<{
+          description: string;
+          value: string;
+        }[]>, unknown>;
+        (): _langchain_langgraph0.LastValue<{
+          description: string;
+          value: string;
         }[]>;
         Root: <S extends _langchain_langgraph0.StateDefinition>(sd: S) => _langchain_langgraph0.AnnotationRoot<S>;
       };
       interceptedToolCalls: {
+        (annotation: _langchain_langgraph0.SingleReducer<any[], any[]>): _langchain_langgraph0.BaseChannel<any[], any[] | _langchain_langgraph0.OverwriteValue<any[]>, unknown>;
         (): _langchain_langgraph0.LastValue<any[]>;
-        (annotation: _langchain_langgraph0.SingleReducer<any[], any[]>): _langchain_langgraph0.BinaryOperatorAggregate<any[], any[]>;
         Root: <S extends _langchain_langgraph0.StateDefinition>(sd: S) => _langchain_langgraph0.AnnotationRoot<S>;
       };
       originalAIMessageId: {
+        (annotation: _langchain_langgraph0.SingleReducer<string, string>): _langchain_langgraph0.BaseChannel<string, string | _langchain_langgraph0.OverwriteValue<string>, unknown>;
         (): _langchain_langgraph0.LastValue<string>;
-        (annotation: _langchain_langgraph0.SingleReducer<string, string>): _langchain_langgraph0.BinaryOperatorAggregate<string, string>;
         Root: <S extends _langchain_langgraph0.StateDefinition>(sd: S) => _langchain_langgraph0.AnnotationRoot<S>;
       };
-    }>, _langchain_langgraph0.StateType<{
+    }>>, unknown>;
+    (): _langchain_langgraph0.LastValue<_langchain_langgraph0.StateType<{
       actions: {
+        (annotation: _langchain_langgraph0.SingleReducer<any[], any[]>): _langchain_langgraph0.BaseChannel<any[], any[] | _langchain_langgraph0.OverwriteValue<any[]>, unknown>;
         (): _langchain_langgraph0.LastValue<any[]>;
-        (annotation: _langchain_langgraph0.SingleReducer<any[], any[]>): _langchain_langgraph0.BinaryOperatorAggregate<any[], any[]>;
         Root: <S extends _langchain_langgraph0.StateDefinition>(sd: S) => _langchain_langgraph0.AnnotationRoot<S>;
       };
       context: {
-        (): _langchain_langgraph0.LastValue<{
-          description: string;
-          value: string;
-        }[]>;
         (annotation: _langchain_langgraph0.SingleReducer<{
           description: string;
           value: string;
         }[], {
           description: string;
           value: string;
-        }[]>): _langchain_langgraph0.BinaryOperatorAggregate<{
+        }[]>): _langchain_langgraph0.BaseChannel<{
           description: string;
           value: string;
         }[], {
           description: string;
           value: string;
+        }[] | _langchain_langgraph0.OverwriteValue<{
+          description: string;
+          value: string;
+        }[]>, unknown>;
+        (): _langchain_langgraph0.LastValue<{
+          description: string;
+          value: string;
         }[]>;
         Root: <S extends _langchain_langgraph0.StateDefinition>(sd: S) => _langchain_langgraph0.AnnotationRoot<S>;
       };
       interceptedToolCalls: {
+        (annotation: _langchain_langgraph0.SingleReducer<any[], any[]>): _langchain_langgraph0.BaseChannel<any[], any[] | _langchain_langgraph0.OverwriteValue<any[]>, unknown>;
         (): _langchain_langgraph0.LastValue<any[]>;
-        (annotation: _langchain_langgraph0.SingleReducer<any[], any[]>): _langchain_langgraph0.BinaryOperatorAggregate<any[], any[]>;
         Root: <S extends _langchain_langgraph0.StateDefinition>(sd: S) => _langchain_langgraph0.AnnotationRoot<S>;
       };
       originalAIMessageId: {
+        (annotation: _langchain_langgraph0.SingleReducer<string, string>): _langchain_langgraph0.BaseChannel<string, string | _langchain_langgraph0.OverwriteValue<string>, unknown>;
         (): _langchain_langgraph0.LastValue<string>;
-        (annotation: _langchain_langgraph0.SingleReducer<string, string>): _langchain_langgraph0.BinaryOperatorAggregate<string, string>;
         Root: <S extends _langchain_langgraph0.StateDefinition>(sd: S) => _langchain_langgraph0.AnnotationRoot<S>;
       };
     }>>;

package/dist/langgraph/types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.mts","names":[],"sources":["../../src/langgraph/types.ts"],"mappings":";;;;;UAEiB,0BAAA,iBAA2C,KAAA;EAAA,SACjD,WAAA;IAAA,SACE,OAAA;IAAA,SACA,MAAA;IAAA,SACA,QAAA,GACP,KAAA;MACK,KAAA,EAAO,MAAA;IAAA;MAAa,MAAA,EAAQ,aAAA;QAAgB,OAAA;MAAA;IAAA;IAAA,SAC1C,KAAA;MAAA,SAAmB,KAAA,EAAO,KAAA;MAAA,SAAgB,MAAA,EAAQ,MAAA;IAAA;IAAA,SAClD,UAAA;MAAA,SACE,KAAA,GAAQ,OAAA;QAAW,MAAA;MAAA,MAAqB,MAAA;MAAA,SACxC,MAAA,GAAS,OAAA;QAAW,MAAA;MAAA,MAAqB,MAAA;IAAA;EAAA;AAAA;AAAA,cAK3C,8BAAA,wBAA8B,cAAA;;QAKzC,qBAAA,CAAA,SAAA;IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAEW,yBAAA,wBAAyB,cAAA;2HAGpC,yBAAA,CAAA,cAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA4BW,0BAAA,EAA4B,0BAAA,QAChC,8BAAA,CAA+B,KAAA;AAAA,UAevB,uBAAA;EACf,QAAA;EACA,IAAA;EACA,YAAA;AAAA;AAAA,UAGe,aAAA;EACf,aAAA;EACA,YAAA;EACA,OAAA;EACA,qBAAA,GAAwB,uBAAA;AAAA;AAAA,KAGd,eAAA,UAAyB,yBAAA,CAA0B,KAAA;AAAA,KACnD,oBAAA,UAA8B,8BAAA,CAA+B,KAAA"}
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../src/langgraph/types.ts"],"mappings":";;;;;UAEiB,0BAAA,iBAA2C,KAAA;EAAA,SACjD,WAAA;IAAA,SACE,OAAA;IAAA,SACA,MAAA;IAAA,SACA,QAAA,GACP,KAAA;MACK,KAAA,EAAO,MAAA;IAAA;MAAa,MAAA,EAAQ,aAAA;QAAgB,OAAA;MAAA;IAAA;IAAA,SAC1C,KAAA;MAAA,SAAmB,KAAA,EAAO,KAAA;MAAA,SAAgB,MAAA,EAAQ,MAAA;IAAA;IAAA,SAClD,UAAA;MAAA,SACE,KAAA,GAAQ,OAAA;QAAW,MAAA;MAAA,MAAqB,MAAA;MAAA,SACxC,MAAA,GAAS,OAAA;QAAW,MAAA;MAAA,MAAqB,MAAA;IAAA;EAAA;AAAA;AAAA,cAK3C,8BAAA,wBAA8B,cAAA;;iBAKzC,qBAAA,CAAA,aAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAEW,yBAAA,wBAAyB,cAAA;+GAGpC,yBAAA,CAAA,cAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA4BW,0BAAA,EAA4B,0BAAA,QAChC,8BAAA,CAA+B,KAAA;AAAA,UAevB,uBAAA;EACf,QAAA;EACA,IAAA;EACA,YAAA;AAAA;AAAA,UAGe,aAAA;EACf,aAAA;EACA,YAAA;EACA,OAAA;EACA,qBAAA,GAAwB,uBAAA;AAAA;AAAA,KAGd,eAAA,UAAyB,yBAAA,CAA0B,KAAA;AAAA,KACnD,oBAAA,UAA8B,8BAAA,CAA+B,KAAA"}

package/dist/langgraph.cjs

@@ -17,4 +17,5 @@ exports.copilotkitEmitState = require_utils.copilotkitEmitState;
 exports.copilotkitEmitToolCall = require_utils.copilotkitEmitToolCall;
 exports.copilotkitExit = require_utils.copilotkitExit;
 exports.copilotkitMiddleware = require_middleware.copilotkitMiddleware;
-exports.createCopilotkitMiddleware = require_middleware.createCopilotkitMiddleware;
+exports.createCopilotkitMiddleware = require_middleware.createCopilotkitMiddleware;
+exports.zodState = require_middleware.zodState;

package/dist/langgraph.d.cts

@@ -1,5 +1,5 @@
 import { CopilotKitProperties, CopilotKitPropertiesAnnotation, CopilotKitPropertiesSchema, CopilotKitState, CopilotKitStateAnnotation, IntermediateStateConfig, OptionsConfig, StandardSerializableSchema } from "./langgraph/types.cjs";
 import { convertActionToDynamicStructuredTool, convertActionsToDynamicStructuredTools, copilotKitInterrupt, copilotkitCustomizeConfig, copilotkitEmitMessage, copilotkitEmitState, copilotkitEmitToolCall, copilotkitExit } from "./langgraph/utils.cjs";
-import { ExposeStateOption, copilotkitMiddleware, createCopilotkitMiddleware } from "./langgraph/middleware.cjs";
+import { ExposeStateOption, copilotkitMiddleware, createCopilotkitMiddleware, zodState } from "./langgraph/middleware.cjs";
 import { CopilotKitSchemaState, CopilotKitSchemaUpdate, CopilotKitStateSchema } from "./langgraph/state-schema.cjs";
-export { CopilotKitProperties, CopilotKitPropertiesAnnotation, CopilotKitPropertiesSchema, CopilotKitSchemaState, CopilotKitSchemaUpdate, CopilotKitState, CopilotKitStateAnnotation, CopilotKitStateSchema, ExposeStateOption, IntermediateStateConfig, OptionsConfig, StandardSerializableSchema, convertActionToDynamicStructuredTool, convertActionsToDynamicStructuredTools, copilotKitInterrupt, copilotkitCustomizeConfig, copilotkitEmitMessage, copilotkitEmitState, copilotkitEmitToolCall, copilotkitExit, copilotkitMiddleware, createCopilotkitMiddleware };
+export { CopilotKitProperties, CopilotKitPropertiesAnnotation, CopilotKitPropertiesSchema, CopilotKitSchemaState, CopilotKitSchemaUpdate, CopilotKitState, CopilotKitStateAnnotation, CopilotKitStateSchema, ExposeStateOption, IntermediateStateConfig, OptionsConfig, StandardSerializableSchema, convertActionToDynamicStructuredTool, convertActionsToDynamicStructuredTools, copilotKitInterrupt, copilotkitCustomizeConfig, copilotkitEmitMessage, copilotkitEmitState, copilotkitEmitToolCall, copilotkitExit, copilotkitMiddleware, createCopilotkitMiddleware, zodState };

package/dist/langgraph.d.mts

@@ -1,5 +1,5 @@
 import { CopilotKitProperties, CopilotKitPropertiesAnnotation, CopilotKitPropertiesSchema, CopilotKitState, CopilotKitStateAnnotation, IntermediateStateConfig, OptionsConfig, StandardSerializableSchema } from "./langgraph/types.mjs";
 import { convertActionToDynamicStructuredTool, convertActionsToDynamicStructuredTools, copilotKitInterrupt, copilotkitCustomizeConfig, copilotkitEmitMessage, copilotkitEmitState, copilotkitEmitToolCall, copilotkitExit } from "./langgraph/utils.mjs";
-import { ExposeStateOption, copilotkitMiddleware, createCopilotkitMiddleware } from "./langgraph/middleware.mjs";
+import { ExposeStateOption, copilotkitMiddleware, createCopilotkitMiddleware, zodState } from "./langgraph/middleware.mjs";
 import { CopilotKitSchemaState, CopilotKitSchemaUpdate, CopilotKitStateSchema } from "./langgraph/state-schema.mjs";
-export { CopilotKitProperties, CopilotKitPropertiesAnnotation, CopilotKitPropertiesSchema, CopilotKitSchemaState, CopilotKitSchemaUpdate, CopilotKitState, CopilotKitStateAnnotation, CopilotKitStateSchema, ExposeStateOption, IntermediateStateConfig, OptionsConfig, StandardSerializableSchema, convertActionToDynamicStructuredTool, convertActionsToDynamicStructuredTools, copilotKitInterrupt, copilotkitCustomizeConfig, copilotkitEmitMessage, copilotkitEmitState, copilotkitEmitToolCall, copilotkitExit, copilotkitMiddleware, createCopilotkitMiddleware };
+export { CopilotKitProperties, CopilotKitPropertiesAnnotation, CopilotKitPropertiesSchema, CopilotKitSchemaState, CopilotKitSchemaUpdate, CopilotKitState, CopilotKitStateAnnotation, CopilotKitStateSchema, ExposeStateOption, IntermediateStateConfig, OptionsConfig, StandardSerializableSchema, convertActionToDynamicStructuredTool, convertActionsToDynamicStructuredTools, copilotKitInterrupt, copilotkitCustomizeConfig, copilotkitEmitMessage, copilotkitEmitState, copilotkitEmitToolCall, copilotkitExit, copilotkitMiddleware, createCopilotkitMiddleware, zodState };

package/dist/langgraph.mjs

@@ -1,6 +1,6 @@
 import { CopilotKitPropertiesAnnotation, CopilotKitPropertiesSchema, CopilotKitStateAnnotation } from "./langgraph/types.mjs";
 import { convertActionToDynamicStructuredTool, convertActionsToDynamicStructuredTools, copilotKitInterrupt, copilotkitCustomizeConfig, copilotkitEmitMessage, copilotkitEmitState, copilotkitEmitToolCall, copilotkitExit } from "./langgraph/utils.mjs";
-import { copilotkitMiddleware, createCopilotkitMiddleware } from "./langgraph/middleware.mjs";
+import { copilotkitMiddleware, createCopilotkitMiddleware, zodState } from "./langgraph/middleware.mjs";
 import { CopilotKitStateSchema } from "./langgraph/state-schema.mjs";
 
-export { CopilotKitPropertiesAnnotation, CopilotKitPropertiesSchema, CopilotKitStateAnnotation, CopilotKitStateSchema, convertActionToDynamicStructuredTool, convertActionsToDynamicStructuredTools, copilotKitInterrupt, copilotkitCustomizeConfig, copilotkitEmitMessage, copilotkitEmitState, copilotkitEmitToolCall, copilotkitExit, copilotkitMiddleware, createCopilotkitMiddleware };
+export { CopilotKitPropertiesAnnotation, CopilotKitPropertiesSchema, CopilotKitStateAnnotation, CopilotKitStateSchema, convertActionToDynamicStructuredTool, convertActionsToDynamicStructuredTools, copilotKitInterrupt, copilotkitCustomizeConfig, copilotkitEmitMessage, copilotkitEmitState, copilotkitEmitToolCall, copilotkitExit, copilotkitMiddleware, createCopilotkitMiddleware, zodState };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@copilotkit/sdk-js",
-  "version": "1.56.4-canary.1777538870",
+  "version": "1.56.5",
   "private": false,
   "keywords": [
     "ai",
@@ -48,18 +48,18 @@
     "access": "public"
   },
   "dependencies": {
-    "@ag-ui/langgraph": "0.0.29",
-    "@copilotkit/shared": "1.56.4-canary.1777538870"
+    "@ag-ui/langgraph": "0.0.31",
+    "@copilotkit/shared": "1.56.5"
   },
   "devDependencies": {
-    "@langchain/core": "^1.1.8",
-    "@langchain/langgraph": "^1.0.7",
+    "@langchain/core": "^1.1.41",
+    "@langchain/langgraph": "^1.2.9",
     "@swc/core": "1.5.28",
     "@types/express": "^4.17.21",
     "@types/node": "^18.11.17",
     "@whatwg-node/server": "^0.9.34",
     "eslint": "^8.56.0",
-    "langchain": "^1.2.3",
+    "langchain": "^1.3.4",
     "nodemon": "^3.1.3",
     "ts-node": "^10.9.2",
     "tsdown": "^0.20.3",

package/src/langgraph/__tests__/middleware.test.ts

@@ -18,6 +18,7 @@
  */
 
 import { describe, it, expect } from "vitest";
+import * as z from "zod";
 import {
   AIMessage,
   HumanMessage,
@@ -27,6 +28,7 @@ import {
 import {
   copilotkitMiddleware,
   createCopilotkitMiddleware,
+  zodState,
 } from "../middleware";
 
 // ---------------------------------------------------------------------------
@@ -495,3 +497,115 @@ describe("afterAgent", () => {
     expect(result!.copilotkit.originalAIMessageId).toBeUndefined();
   });
 });
+
+// ---------------------------------------------------------------------------
+// zodState — Standard-Schema JSON-schema augmentation
+// ---------------------------------------------------------------------------
+//
+// Contract: a Zod v4 schema only carries `~standard.validate` + `vendor`, so
+// LangGraph's `isStandardJSONSchema()` returns false and the field is dropped
+// from `output_schema`. `zodState` patches `~standard.jsonSchema.input` onto
+// the schema so the field survives serialization and reaches the frontend
+// via AG-UI `STATE_SNAPSHOT` events.
+
+type JsonSchema = {
+  type?: string;
+  properties?: Record<string, unknown>;
+};
+type StdJson = { jsonSchema?: { input: () => JsonSchema } };
+const standardOf = (s: object): StdJson | undefined =>
+  (s as { "~standard"?: StdJson })["~standard"];
+const hasZodV4ToJsonSchema = (): boolean =>
+  typeof (z as { toJSONSchema?: unknown }).toJSONSchema === "function";
+
+describe("zodState", () => {
+  it("attaches a ~standard.jsonSchema.input hook to a Zod schema", () => {
+    const schema = z.object({ name: z.string() });
+    expect(standardOf(schema)?.jsonSchema).toBeUndefined();
+
+    const wrapped = zodState(schema);
+
+    const std = standardOf(wrapped);
+    expect(std?.jsonSchema).toBeDefined();
+    expect(typeof std?.jsonSchema?.input).toBe("function");
+  });
+
+  it("returns a plain object from input() (real JSON Schema when zod v4 is available, else `{}`)", () => {
+    // The contract langgraph cares about is just "input() returns an
+    // object" — `isStandardJSONSchema()` doesn't introspect the shape.
+    // When zod v4's `toJSONSchema` is present we get the real schema;
+    // otherwise we get `{}`, which is still enough for the field to
+    // appear in `output_schema` (langgraph-api treats it as opaque).
+    const schema = z.object({ todos: z.array(z.string()) });
+    const wrapped = zodState(schema);
+
+    const json = standardOf(wrapped)?.jsonSchema?.input();
+
+    expect(json).toBeTypeOf("object");
+    expect(json).not.toBeNull();
+    if (hasZodV4ToJsonSchema()) {
+      expect(json?.type).toBe("object");
+      expect(json?.properties?.todos).toBeDefined();
+    }
+  });
+
+  it("caches the JSON Schema across calls (input() returns the same object)", () => {
+    const schema = z.object({ x: z.string() });
+    const wrapped = zodState(schema);
+    const std = standardOf(wrapped);
+
+    const a = std?.jsonSchema?.input();
+    const b = std?.jsonSchema?.input();
+
+    expect(a).toBe(b);
+  });
+
+  it("does not overwrite an existing jsonSchema hook", () => {
+    const schema = z.object({ x: z.string() });
+    const preset: StdJson["jsonSchema"] = { input: () => ({}) };
+    const std = standardOf(schema);
+    expect(std).toBeDefined();
+    std!.jsonSchema = preset;
+
+    zodState(schema);
+
+    expect(standardOf(schema)?.jsonSchema).toBe(preset);
+  });
+
+  it("returns the same reference (mutates rather than copies)", () => {
+    const schema = z.object({ x: z.string() });
+    expect(zodState(schema)).toBe(schema);
+  });
+
+  it("is a no-op for a value without ~standard metadata", () => {
+    const plain = { foo: "bar" };
+    expect(() => zodState(plain)).not.toThrow();
+    expect(zodState(plain)).toBe(plain);
+  });
+
+  it("works on optional / array / default-wrapped schemas (state-field shapes)", () => {
+    const todos = zodState(
+      z.array(z.object({ id: z.string(), text: z.string() })).default(() => []),
+    );
+
+    const std = standardOf(todos);
+    expect(std).toBeDefined();
+    expect(std?.jsonSchema).toBeDefined();
+    const json = std?.jsonSchema?.input();
+    expect(json).toBeTypeOf("object");
+    if (hasZodV4ToJsonSchema()) {
+      expect(json?.type).toBe("array");
+    }
+  });
+
+  it("makes the wrapped field pass a StandardJSONSchemaV1-style probe", () => {
+    // Mirrors what LangGraph's isStandardJSONSchema() looks for: an `input`
+    // function on `~standard.jsonSchema` that returns a plain object.
+    const schema = zodState(z.object({ liked: z.array(z.string()) }));
+    const std = standardOf(schema);
+
+    expect(std?.jsonSchema).toBeDefined();
+    expect(typeof std?.jsonSchema?.input).toBe("function");
+    expect(typeof std?.jsonSchema?.input()).toBe("object");
+  });
+});

package/src/langgraph/middleware.ts

@@ -1,7 +1,77 @@
 import { createMiddleware, AIMessage, SystemMessage } from "langchain";
 import type { InteropZodObject } from "@langchain/core/utils/types";
+import type {
+  StandardJSONSchemaV1,
+  StandardSchemaV1,
+} from "@standard-schema/spec";
 import * as z from "zod";
 
+type WithJsonSchema<T> = T extends { "~standard": infer S }
+  ? Omit<T, "~standard"> & {
+      "~standard": S &
+        StandardJSONSchemaV1.Props<
+          S extends StandardSchemaV1.Props<infer I, any> ? I : unknown,
+          S extends StandardSchemaV1.Props<any, infer O> ? O : unknown
+        >;
+    }
+  : T;
+
+/**
+ * Augment a Standard-Schema–compatible schema (e.g. Zod) with a
+ * `~standard.jsonSchema.input` hook so LangGraph's
+ * `getJsonSchemaFromSchema` (called from `StateSchema.getJsonSchema`)
+ * can serialize the field.
+ *
+ * Without this, Zod v4 fields carry `~standard.validate` + `vendor` only,
+ * and `isStandardJSONSchema()` returns false, so the field is silently
+ * dropped from the graph's `output_schema`. That makes AG-UI
+ * `STATE_SNAPSHOT` events filter the field out of the payload sent to
+ * the frontend even though the underlying thread state has the value.
+ *
+ * Use this on any custom state field you want visible to the frontend
+ * via `useAgent().state.*`.
+ *
+ * @example
+ * ```ts
+ * import { zodState } from "@copilotkit/sdk-js/langgraph";
+ *
+ * const stateSchema = z.object({
+ *   todos: zodState(z.array(TodoSchema).default(() => [])),
+ * });
+ * ```
+ */
+export function zodState<T extends object>(schema: T): WithJsonSchema<T> {
+  const std = (schema as { "~standard"?: { jsonSchema?: unknown } })[
+    "~standard"
+  ];
+  if (std && typeof std === "object" && !("jsonSchema" in std)) {
+    let cached: Record<string, unknown> | undefined;
+    std.jsonSchema = {
+      input: () => {
+        if (cached) return cached;
+        // Prefer zod-v4's native `toJSONSchema` when available. Falls back to
+        // an empty object, which is sufficient for the field to appear in the
+        // graph's output_schema (langgraph-api treats it as an opaque field).
+        try {
+          const maybeV4ToJsonSchema = (
+            z as unknown as {
+              toJSONSchema?: (s: unknown) => Record<string, unknown>;
+            }
+          ).toJSONSchema;
+          cached =
+            typeof maybeV4ToJsonSchema === "function"
+              ? maybeV4ToJsonSchema(schema)
+              : {};
+        } catch {
+          cached = {};
+        }
+        return cached;
+      },
+    };
+  }
+  return schema as WithJsonSchema<T>;
+}
+
 /**
  * Internal/framework state keys that should never be auto-surfaced to the
  * LLM as user-facing state. These are reducer-managed message buckets,
@@ -215,14 +285,16 @@ const createAppContextBeforeAgent = (state, runtime) => {
  * ```
  */
 const copilotKitStateSchema = z.object({
-  copilotkit: z
-    .object({
-      actions: z.array(z.any()),
-      context: z.any().optional(),
-      interceptedToolCalls: z.array(z.any()).optional(),
-      originalAIMessageId: z.string().optional(),
-    })
-    .optional(),
+  copilotkit: zodState(
+    z
+      .object({
+        actions: z.array(z.any()),
+        context: z.any().optional(),
+        interceptedToolCalls: z.array(z.any()).optional(),
+        originalAIMessageId: z.string().optional(),
+      })
+      .optional(),
+  ),
 });
 
 const buildMiddlewareInput = (exposeState: ExposeStateOption) => ({