@copilotkit/sdk-js 1.56.3 → 1.56.4

package/dist/langchain.cjs

@@ -1,13 +1,16 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_types = require('./langgraph/types.cjs');
 const require_utils = require('./langgraph/utils.cjs');
+const require_state_schema = require('./langgraph/state-schema.cjs');
 
 //#region src/langchain.ts
 console.warn("Warning: '@copilotkit/sdk-js/langchain' is deprecated and will be removed in a future release. Please use '@copilotkit/sdk-js/langgraph' instead.");
 
 //#endregion
 exports.CopilotKitPropertiesAnnotation = require_types.CopilotKitPropertiesAnnotation;
+exports.CopilotKitPropertiesSchema = require_types.CopilotKitPropertiesSchema;
 exports.CopilotKitStateAnnotation = require_types.CopilotKitStateAnnotation;
+exports.CopilotKitStateSchema = require_state_schema.CopilotKitStateSchema;
 exports.convertActionToDynamicStructuredTool = require_utils.convertActionToDynamicStructuredTool;
 exports.convertActionsToDynamicStructuredTools = require_utils.convertActionsToDynamicStructuredTools;
 exports.copilotKitCustomizeConfig = require_utils.copilotkitCustomizeConfig;

package/dist/langchain.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"langchain.cjs","names":[],"sources":["../src/langchain.ts"],"sourcesContent":["console.warn(\n  \"Warning: '@copilotkit/sdk-js/langchain' is deprecated and will be removed in a future release. Please use '@copilotkit/sdk-js/langgraph' instead.\",\n);\n\nexport {\n  CopilotKitPropertiesAnnotation,\n  CopilotKitStateAnnotation,\n  type CopilotKitState,\n  type CopilotKitProperties,\n  copilotkitCustomizeConfig as copilotKitCustomizeConfig,\n  copilotkitExit as copilotKitExit,\n  copilotkitEmitState as copilotKitEmitState,\n  copilotkitEmitMessage as copilotKitEmitMessage,\n  copilotkitEmitToolCall as copilotKitEmitToolCall,\n  convertActionToDynamicStructuredTool,\n  convertActionsToDynamicStructuredTools,\n} from \"./langgraph\";\n"],"mappings":";;;;;AAAA,QAAQ,KACN,oJACD"}
+{"version":3,"file":"langchain.cjs","names":[],"sources":["../src/langchain.ts"],"sourcesContent":["console.warn(\n  \"Warning: '@copilotkit/sdk-js/langchain' is deprecated and will be removed in a future release. Please use '@copilotkit/sdk-js/langgraph' instead.\",\n);\n\nexport {\n  CopilotKitPropertiesAnnotation,\n  CopilotKitPropertiesSchema,\n  CopilotKitStateAnnotation,\n  CopilotKitStateSchema,\n  type CopilotKitState,\n  type CopilotKitSchemaState,\n  type CopilotKitSchemaUpdate,\n  type CopilotKitProperties,\n  copilotkitCustomizeConfig as copilotKitCustomizeConfig,\n  copilotkitExit as copilotKitExit,\n  copilotkitEmitState as copilotKitEmitState,\n  copilotkitEmitMessage as copilotKitEmitMessage,\n  copilotkitEmitToolCall as copilotKitEmitToolCall,\n  convertActionToDynamicStructuredTool,\n  convertActionsToDynamicStructuredTools,\n} from \"./langgraph\";\n"],"mappings":";;;;;;AAAA,QAAQ,KACN,oJACD"}

package/dist/langchain.d.cts

@@ -1,3 +1,4 @@
-import { CopilotKitProperties, CopilotKitPropertiesAnnotation, CopilotKitState, CopilotKitStateAnnotation } from "./langgraph/types.cjs";
+import { CopilotKitProperties, CopilotKitPropertiesAnnotation, CopilotKitPropertiesSchema, CopilotKitState, CopilotKitStateAnnotation } from "./langgraph/types.cjs";
 import { convertActionToDynamicStructuredTool, convertActionsToDynamicStructuredTools, copilotkitCustomizeConfig, copilotkitEmitMessage, copilotkitEmitState, copilotkitEmitToolCall, copilotkitExit } from "./langgraph/utils.cjs";
-export { type CopilotKitProperties, CopilotKitPropertiesAnnotation, type CopilotKitState, CopilotKitStateAnnotation, convertActionToDynamicStructuredTool, convertActionsToDynamicStructuredTools, copilotkitCustomizeConfig as copilotKitCustomizeConfig, copilotkitEmitMessage as copilotKitEmitMessage, copilotkitEmitState as copilotKitEmitState, copilotkitEmitToolCall as copilotKitEmitToolCall, copilotkitExit as copilotKitExit };
+import { CopilotKitSchemaState, CopilotKitSchemaUpdate, CopilotKitStateSchema } from "./langgraph/state-schema.cjs";
+export { type CopilotKitProperties, CopilotKitPropertiesAnnotation, CopilotKitPropertiesSchema, type CopilotKitSchemaState, type CopilotKitSchemaUpdate, type CopilotKitState, CopilotKitStateAnnotation, CopilotKitStateSchema, convertActionToDynamicStructuredTool, convertActionsToDynamicStructuredTools, copilotkitCustomizeConfig as copilotKitCustomizeConfig, copilotkitEmitMessage as copilotKitEmitMessage, copilotkitEmitState as copilotKitEmitState, copilotkitEmitToolCall as copilotKitEmitToolCall, copilotkitExit as copilotKitExit };

package/dist/langchain.d.mts

@@ -1,4 +1,5 @@
-import { CopilotKitProperties, CopilotKitPropertiesAnnotation, CopilotKitState, CopilotKitStateAnnotation } from "./langgraph/types.mjs";
+import { CopilotKitProperties, CopilotKitPropertiesAnnotation, CopilotKitPropertiesSchema, CopilotKitState, CopilotKitStateAnnotation } from "./langgraph/types.mjs";
 import { convertActionToDynamicStructuredTool, convertActionsToDynamicStructuredTools, copilotkitCustomizeConfig, copilotkitEmitMessage, copilotkitEmitState, copilotkitEmitToolCall, copilotkitExit } from "./langgraph/utils.mjs";
+import { CopilotKitSchemaState, CopilotKitSchemaUpdate, CopilotKitStateSchema } from "./langgraph/state-schema.mjs";
 import "./langgraph.mjs";
-export { type CopilotKitProperties, CopilotKitPropertiesAnnotation, type CopilotKitState, CopilotKitStateAnnotation, convertActionToDynamicStructuredTool, convertActionsToDynamicStructuredTools, copilotkitCustomizeConfig as copilotKitCustomizeConfig, copilotkitEmitMessage as copilotKitEmitMessage, copilotkitEmitState as copilotKitEmitState, copilotkitEmitToolCall as copilotKitEmitToolCall, copilotkitExit as copilotKitExit };
+export { type CopilotKitProperties, CopilotKitPropertiesAnnotation, CopilotKitPropertiesSchema, type CopilotKitSchemaState, type CopilotKitSchemaUpdate, type CopilotKitState, CopilotKitStateAnnotation, CopilotKitStateSchema, convertActionToDynamicStructuredTool, convertActionsToDynamicStructuredTools, copilotkitCustomizeConfig as copilotKitCustomizeConfig, copilotkitEmitMessage as copilotKitEmitMessage, copilotkitEmitState as copilotKitEmitState, copilotkitEmitToolCall as copilotKitEmitToolCall, copilotkitExit as copilotKitExit };

package/dist/langchain.mjs

@@ -1,9 +1,10 @@
-import { CopilotKitPropertiesAnnotation, CopilotKitStateAnnotation } from "./langgraph/types.mjs";
+import { CopilotKitPropertiesAnnotation, CopilotKitPropertiesSchema, CopilotKitStateAnnotation } from "./langgraph/types.mjs";
 import { convertActionToDynamicStructuredTool, convertActionsToDynamicStructuredTools, copilotkitCustomizeConfig, copilotkitEmitMessage, copilotkitEmitState, copilotkitEmitToolCall, copilotkitExit } from "./langgraph/utils.mjs";
+import { CopilotKitStateSchema } from "./langgraph/state-schema.mjs";
 
 //#region src/langchain.ts
 console.warn("Warning: '@copilotkit/sdk-js/langchain' is deprecated and will be removed in a future release. Please use '@copilotkit/sdk-js/langgraph' instead.");
 
 //#endregion
-export { CopilotKitPropertiesAnnotation, CopilotKitStateAnnotation, convertActionToDynamicStructuredTool, convertActionsToDynamicStructuredTools, copilotkitCustomizeConfig as copilotKitCustomizeConfig, copilotkitEmitMessage as copilotKitEmitMessage, copilotkitEmitState as copilotKitEmitState, copilotkitEmitToolCall as copilotKitEmitToolCall, copilotkitExit as copilotKitExit };
+export { CopilotKitPropertiesAnnotation, CopilotKitPropertiesSchema, CopilotKitStateAnnotation, CopilotKitStateSchema, convertActionToDynamicStructuredTool, convertActionsToDynamicStructuredTools, copilotkitCustomizeConfig as copilotKitCustomizeConfig, copilotkitEmitMessage as copilotKitEmitMessage, copilotkitEmitState as copilotKitEmitState, copilotkitEmitToolCall as copilotKitEmitToolCall, copilotkitExit as copilotKitExit };
 //# sourceMappingURL=langchain.mjs.map

package/dist/langchain.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"langchain.mjs","names":[],"sources":["../src/langchain.ts"],"sourcesContent":["console.warn(\n  \"Warning: '@copilotkit/sdk-js/langchain' is deprecated and will be removed in a future release. Please use '@copilotkit/sdk-js/langgraph' instead.\",\n);\n\nexport {\n  CopilotKitPropertiesAnnotation,\n  CopilotKitStateAnnotation,\n  type CopilotKitState,\n  type CopilotKitProperties,\n  copilotkitCustomizeConfig as copilotKitCustomizeConfig,\n  copilotkitExit as copilotKitExit,\n  copilotkitEmitState as copilotKitEmitState,\n  copilotkitEmitMessage as copilotKitEmitMessage,\n  copilotkitEmitToolCall as copilotKitEmitToolCall,\n  convertActionToDynamicStructuredTool,\n  convertActionsToDynamicStructuredTools,\n} from \"./langgraph\";\n"],"mappings":";;;;AAAA,QAAQ,KACN,oJACD"}
+{"version":3,"file":"langchain.mjs","names":[],"sources":["../src/langchain.ts"],"sourcesContent":["console.warn(\n  \"Warning: '@copilotkit/sdk-js/langchain' is deprecated and will be removed in a future release. Please use '@copilotkit/sdk-js/langgraph' instead.\",\n);\n\nexport {\n  CopilotKitPropertiesAnnotation,\n  CopilotKitPropertiesSchema,\n  CopilotKitStateAnnotation,\n  CopilotKitStateSchema,\n  type CopilotKitState,\n  type CopilotKitSchemaState,\n  type CopilotKitSchemaUpdate,\n  type CopilotKitProperties,\n  copilotkitCustomizeConfig as copilotKitCustomizeConfig,\n  copilotkitExit as copilotKitExit,\n  copilotkitEmitState as copilotKitEmitState,\n  copilotkitEmitMessage as copilotKitEmitMessage,\n  copilotkitEmitToolCall as copilotKitEmitToolCall,\n  convertActionToDynamicStructuredTool,\n  convertActionsToDynamicStructuredTools,\n} from \"./langgraph\";\n"],"mappings":";;;;;AAAA,QAAQ,KACN,oJACD"}

package/dist/langgraph/state-schema.cjs

@@ -0,0 +1,37 @@
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+const require_types = require('./types.cjs');
+let _langchain_langgraph = require("@langchain/langgraph");
+
+//#region src/langgraph/state-schema.ts
+/**
+* CopilotKit agent state defined with LangGraph's modern
+* [`StateSchema`](https://docs.langchain.com/oss/javascript/langgraph/graph-api)
+* API.
+*
+* Prefer this over `CopilotKitStateAnnotation` when starting a new
+* TypeScript agent. `Annotation.Root` is still supported by LangGraph but
+* `StateSchema` is the recommended API going forward.
+*
+* ### Example
+*
+* ```typescript
+* import { StateSchema } from "@langchain/langgraph";
+* import { CopilotKitStateSchema } from "@copilotkit/sdk-js/langgraph";
+* import { z } from "zod";
+*
+* export const AgentStateSchema = new StateSchema({
+*   language: z.enum(["english", "spanish"]),
+*   ...CopilotKitStateSchema.fields,
+* });
+*
+* export type AgentState = typeof AgentStateSchema.State;
+* ```
+*/
+const CopilotKitStateSchema = new _langchain_langgraph.StateSchema({
+	copilotkit: require_types.CopilotKitPropertiesSchema,
+	messages: _langchain_langgraph.MessagesValue
+});
+
+//#endregion
+exports.CopilotKitStateSchema = CopilotKitStateSchema;
+//# sourceMappingURL=state-schema.cjs.map

package/dist/langgraph/state-schema.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-schema.cjs","names":["StateSchema","CopilotKitPropertiesSchema","MessagesValue"],"sources":["../../src/langgraph/state-schema.ts"],"sourcesContent":["import { MessagesValue, StateSchema } from \"@langchain/langgraph\";\nimport { CopilotKitPropertiesSchema } from \"./types\";\n\n/**\n * CopilotKit agent state defined with LangGraph's modern\n * [`StateSchema`](https://docs.langchain.com/oss/javascript/langgraph/graph-api)\n * API.\n *\n * Prefer this over `CopilotKitStateAnnotation` when starting a new\n * TypeScript agent. `Annotation.Root` is still supported by LangGraph but\n * `StateSchema` is the recommended API going forward.\n *\n * ### Example\n *\n * ```typescript\n * import { StateSchema } from \"@langchain/langgraph\";\n * import { CopilotKitStateSchema } from \"@copilotkit/sdk-js/langgraph\";\n * import { z } from \"zod\";\n *\n * export const AgentStateSchema = new StateSchema({\n *   language: z.enum([\"english\", \"spanish\"]),\n *   ...CopilotKitStateSchema.fields,\n * });\n *\n * export type AgentState = typeof AgentStateSchema.State;\n * ```\n */\nexport const CopilotKitStateSchema = new StateSchema({\n  copilotkit: CopilotKitPropertiesSchema,\n  messages: MessagesValue,\n});\n\nexport type CopilotKitSchemaState = typeof CopilotKitStateSchema.State;\nexport type CopilotKitSchemaUpdate = typeof CopilotKitStateSchema.Update;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,MAAa,wBAAwB,IAAIA,iCAAY;CACnD,YAAYC;CACZ,UAAUC;CACX,CAAC"}

package/dist/langgraph/state-schema.d.cts

@@ -0,0 +1,112 @@
+import { StandardSerializableSchema } from "./types.cjs";
+import * as _langchain_langgraph0 from "@langchain/langgraph";
+import { StateSchema } from "@langchain/langgraph";
+import * as _langchain_core_messages0 from "@langchain/core/messages";
+import * as langchain from "langchain";
+
+//#region src/langgraph/state-schema.d.ts
+/**
+ * CopilotKit agent state defined with LangGraph's modern
+ * [`StateSchema`](https://docs.langchain.com/oss/javascript/langgraph/graph-api)
+ * API.
+ *
+ * Prefer this over `CopilotKitStateAnnotation` when starting a new
+ * TypeScript agent. `Annotation.Root` is still supported by LangGraph but
+ * `StateSchema` is the recommended API going forward.
+ *
+ * ### Example
+ *
+ * ```typescript
+ * import { StateSchema } from "@langchain/langgraph";
+ * import { CopilotKitStateSchema } from "@copilotkit/sdk-js/langgraph";
+ * import { z } from "zod";
+ *
+ * export const AgentStateSchema = new StateSchema({
+ *   language: z.enum(["english", "spanish"]),
+ *   ...CopilotKitStateSchema.fields,
+ * });
+ *
+ * export type AgentState = typeof AgentStateSchema.State;
+ * ```
+ */
+declare const CopilotKitStateSchema: StateSchema<{
+  copilotkit: StandardSerializableSchema<_langchain_langgraph0.StateType<{
+    actions: {
+      (): _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<{
+        description: string;
+        value: string;
+      }[], {
+        description: string;
+        value: string;
+      }[]>;
+      Root: <S extends _langchain_langgraph0.StateDefinition>(sd: S) => _langchain_langgraph0.AnnotationRoot<S>;
+    };
+    interceptedToolCalls: {
+      (): _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: {
+      (): _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: {
+      (): _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<{
+        description: string;
+        value: string;
+      }[], {
+        description: string;
+        value: string;
+      }[]>;
+      Root: <S extends _langchain_langgraph0.StateDefinition>(sd: S) => _langchain_langgraph0.AnnotationRoot<S>;
+    };
+    interceptedToolCalls: {
+      (): _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: {
+      (): _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>;
+    };
+  }>>;
+  messages: _langchain_langgraph0.ReducedValue<langchain.BaseMessage<_langchain_core_messages0.MessageStructure<_langchain_core_messages0.MessageToolSet>, _langchain_core_messages0.MessageType>[], _langchain_langgraph0.Messages>;
+}>;
+type CopilotKitSchemaState = typeof CopilotKitStateSchema.State;
+type CopilotKitSchemaUpdate = typeof CopilotKitStateSchema.Update;
+//#endregion
+export { CopilotKitSchemaState, CopilotKitSchemaUpdate, CopilotKitStateSchema };
+//# sourceMappingURL=state-schema.d.cts.map

package/dist/langgraph/state-schema.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-schema.d.cts","names":[],"sources":["../../src/langgraph/state-schema.ts"],"mappings":";;;;;;;;;;;;;AA2BA;;;;;;;;;;;;;;;;;;cAAa,qBAAA,EAAqB,WAAA;;;UAGhC,qBAAA,CAAA,SAAA;MAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEU,qBAAA,UAA+B,qBAAA,CAAsB,KAAA;AAAA,KACrD,sBAAA,UAAgC,qBAAA,CAAsB,MAAA"}

package/dist/langgraph/state-schema.d.mts

@@ -0,0 +1,112 @@
+import { StandardSerializableSchema } from "./types.mjs";
+import * as _langchain_langgraph0 from "@langchain/langgraph";
+import { StateSchema } from "@langchain/langgraph";
+import * as _langchain_core_messages0 from "@langchain/core/messages";
+import * as langchain from "langchain";
+
+//#region src/langgraph/state-schema.d.ts
+/**
+ * CopilotKit agent state defined with LangGraph's modern
+ * [`StateSchema`](https://docs.langchain.com/oss/javascript/langgraph/graph-api)
+ * API.
+ *
+ * Prefer this over `CopilotKitStateAnnotation` when starting a new
+ * TypeScript agent. `Annotation.Root` is still supported by LangGraph but
+ * `StateSchema` is the recommended API going forward.
+ *
+ * ### Example
+ *
+ * ```typescript
+ * import { StateSchema } from "@langchain/langgraph";
+ * import { CopilotKitStateSchema } from "@copilotkit/sdk-js/langgraph";
+ * import { z } from "zod";
+ *
+ * export const AgentStateSchema = new StateSchema({
+ *   language: z.enum(["english", "spanish"]),
+ *   ...CopilotKitStateSchema.fields,
+ * });
+ *
+ * export type AgentState = typeof AgentStateSchema.State;
+ * ```
+ */
+declare const CopilotKitStateSchema: StateSchema<{
+  copilotkit: StandardSerializableSchema<_langchain_langgraph0.StateType<{
+    actions: {
+      (): _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<{
+        description: string;
+        value: string;
+      }[], {
+        description: string;
+        value: string;
+      }[]>;
+      Root: <S extends _langchain_langgraph0.StateDefinition>(sd: S) => _langchain_langgraph0.AnnotationRoot<S>;
+    };
+    interceptedToolCalls: {
+      (): _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: {
+      (): _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: {
+      (): _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<{
+        description: string;
+        value: string;
+      }[], {
+        description: string;
+        value: string;
+      }[]>;
+      Root: <S extends _langchain_langgraph0.StateDefinition>(sd: S) => _langchain_langgraph0.AnnotationRoot<S>;
+    };
+    interceptedToolCalls: {
+      (): _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: {
+      (): _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>;
+    };
+  }>>;
+  messages: _langchain_langgraph0.ReducedValue<langchain.BaseMessage<_langchain_core_messages0.MessageStructure<_langchain_core_messages0.MessageToolSet>, _langchain_core_messages0.MessageType>[], _langchain_langgraph0.Messages>;
+}>;
+type CopilotKitSchemaState = typeof CopilotKitStateSchema.State;
+type CopilotKitSchemaUpdate = typeof CopilotKitStateSchema.Update;
+//#endregion
+export { CopilotKitSchemaState, CopilotKitSchemaUpdate, CopilotKitStateSchema };
+//# sourceMappingURL=state-schema.d.mts.map

package/dist/langgraph/state-schema.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-schema.d.mts","names":[],"sources":["../../src/langgraph/state-schema.ts"],"mappings":";;;;;;;;;;;;;AA2BA;;;;;;;;;;;;;;;;;;cAAa,qBAAA,EAAqB,WAAA;;;UAGhC,qBAAA,CAAA,SAAA;MAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEU,qBAAA,UAA+B,qBAAA,CAAsB,KAAA;AAAA,KACrD,sBAAA,UAAgC,qBAAA,CAAsB,MAAA"}

package/dist/langgraph/state-schema.mjs

@@ -0,0 +1,36 @@
+import { CopilotKitPropertiesSchema } from "./types.mjs";
+import { MessagesValue, StateSchema } from "@langchain/langgraph";
+
+//#region src/langgraph/state-schema.ts
+/**
+* CopilotKit agent state defined with LangGraph's modern
+* [`StateSchema`](https://docs.langchain.com/oss/javascript/langgraph/graph-api)
+* API.
+*
+* Prefer this over `CopilotKitStateAnnotation` when starting a new
+* TypeScript agent. `Annotation.Root` is still supported by LangGraph but
+* `StateSchema` is the recommended API going forward.
+*
+* ### Example
+*
+* ```typescript
+* import { StateSchema } from "@langchain/langgraph";
+* import { CopilotKitStateSchema } from "@copilotkit/sdk-js/langgraph";
+* import { z } from "zod";
+*
+* export const AgentStateSchema = new StateSchema({
+*   language: z.enum(["english", "spanish"]),
+*   ...CopilotKitStateSchema.fields,
+* });
+*
+* export type AgentState = typeof AgentStateSchema.State;
+* ```
+*/
+const CopilotKitStateSchema = new StateSchema({
+	copilotkit: CopilotKitPropertiesSchema,
+	messages: MessagesValue
+});
+
+//#endregion
+export { CopilotKitStateSchema };
+//# sourceMappingURL=state-schema.mjs.map

package/dist/langgraph/state-schema.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-schema.mjs","names":[],"sources":["../../src/langgraph/state-schema.ts"],"sourcesContent":["import { MessagesValue, StateSchema } from \"@langchain/langgraph\";\nimport { CopilotKitPropertiesSchema } from \"./types\";\n\n/**\n * CopilotKit agent state defined with LangGraph's modern\n * [`StateSchema`](https://docs.langchain.com/oss/javascript/langgraph/graph-api)\n * API.\n *\n * Prefer this over `CopilotKitStateAnnotation` when starting a new\n * TypeScript agent. `Annotation.Root` is still supported by LangGraph but\n * `StateSchema` is the recommended API going forward.\n *\n * ### Example\n *\n * ```typescript\n * import { StateSchema } from \"@langchain/langgraph\";\n * import { CopilotKitStateSchema } from \"@copilotkit/sdk-js/langgraph\";\n * import { z } from \"zod\";\n *\n * export const AgentStateSchema = new StateSchema({\n *   language: z.enum([\"english\", \"spanish\"]),\n *   ...CopilotKitStateSchema.fields,\n * });\n *\n * export type AgentState = typeof AgentStateSchema.State;\n * ```\n */\nexport const CopilotKitStateSchema = new StateSchema({\n  copilotkit: CopilotKitPropertiesSchema,\n  messages: MessagesValue,\n});\n\nexport type CopilotKitSchemaState = typeof CopilotKitStateSchema.State;\nexport type CopilotKitSchemaUpdate = typeof CopilotKitStateSchema.Update;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,MAAa,wBAAwB,IAAI,YAAY;CACnD,YAAY;CACZ,UAAU;CACX,CAAC"}

package/dist/langgraph/types.cjs

@@ -12,8 +12,49 @@ const CopilotKitStateAnnotation = _langchain_langgraph.Annotation.Root({
 	copilotkit: _langchain_langgraph.Annotation,
 	..._langchain_langgraph.MessagesAnnotation.spec
 });
+const COPILOTKIT_PROPERTIES_JSON_SCHEMA = {
+	type: "object",
+	properties: {
+		actions: {
+			type: "array",
+			items: {}
+		},
+		context: {
+			type: "array",
+			items: {
+				type: "object",
+				properties: {
+					description: { type: "string" },
+					value: { type: "string" }
+				},
+				required: ["description", "value"]
+			}
+		},
+		interceptedToolCalls: {
+			type: "array",
+			items: {}
+		},
+		originalAIMessageId: { type: "string" }
+	}
+};
+/**
+* Standard Schema describing the `copilotkit` field on agent state.
+*
+* CopilotKit populates these fields at runtime, so the schema accepts any
+* input shape. Use it with `new StateSchema({ ...CopilotKitStateSchema.fields })`.
+*/
+const CopilotKitPropertiesSchema = { "~standard": {
+	version: 1,
+	vendor: "@copilotkit/sdk-js",
+	validate: (value) => ({ value }),
+	jsonSchema: {
+		input: () => COPILOTKIT_PROPERTIES_JSON_SCHEMA,
+		output: () => COPILOTKIT_PROPERTIES_JSON_SCHEMA
+	}
+} };
 
 //#endregion
 exports.CopilotKitPropertiesAnnotation = CopilotKitPropertiesAnnotation;
+exports.CopilotKitPropertiesSchema = CopilotKitPropertiesSchema;
 exports.CopilotKitStateAnnotation = CopilotKitStateAnnotation;
 //# sourceMappingURL=types.cjs.map

package/dist/langgraph/types.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"types.cjs","names":["Annotation","MessagesAnnotation"],"sources":["../../src/langgraph/types.ts"],"sourcesContent":["import { Annotation, MessagesAnnotation } from \"@langchain/langgraph\";\n\nexport const CopilotKitPropertiesAnnotation = Annotation.Root({\n  actions: Annotation<any[]>,\n  context: Annotation<{ description: string; value: string }[]>,\n  interceptedToolCalls: Annotation<any[]>,\n  originalAIMessageId: Annotation<string>,\n});\n\nexport const CopilotKitStateAnnotation = Annotation.Root({\n  copilotkit: Annotation<typeof CopilotKitPropertiesAnnotation.State>,\n  ...MessagesAnnotation.spec,\n});\n\nexport interface IntermediateStateConfig {\n  stateKey: string;\n  tool: string;\n  toolArgument?: string;\n}\n\nexport interface OptionsConfig {\n  emitToolCalls?: boolean | string | string[];\n  emitMessages?: boolean;\n  emitAll?: boolean;\n  emitIntermediateState?: IntermediateStateConfig[];\n}\n\nexport type CopilotKitState = typeof CopilotKitStateAnnotation.State;\nexport type CopilotKitProperties = typeof CopilotKitPropertiesAnnotation.State;\n"],"mappings":";;;;AAEA,MAAa,iCAAiCA,gCAAW,KAAK;CAC5D,SAASA;CACT,SAASA;CACT,sBAAsBA;CACtB,qBAAqBA;CACtB,CAAC;AAEF,MAAa,4BAA4BA,gCAAW,KAAK;CACvD,YAAYA;CACZ,GAAGC,wCAAmB;CACvB,CAAC"}
+{"version":3,"file":"types.cjs","names":["Annotation","MessagesAnnotation"],"sources":["../../src/langgraph/types.ts"],"sourcesContent":["import { Annotation, MessagesAnnotation } from \"@langchain/langgraph\";\n\nexport interface StandardSerializableSchema<Input, Output = Input> {\n  readonly \"~standard\": {\n    readonly version: 1;\n    readonly vendor: string;\n    readonly validate: (\n      value: unknown,\n    ) => { value: Output } | { issues: ReadonlyArray<{ message: string }> };\n    readonly types?: { readonly input: Input; readonly output: Output };\n    readonly jsonSchema: {\n      readonly input: (options: { target: string }) => Record<string, unknown>;\n      readonly output: (options: { target: string }) => Record<string, unknown>;\n    };\n  };\n}\n\nexport const CopilotKitPropertiesAnnotation = Annotation.Root({\n  actions: Annotation<any[]>,\n  context: Annotation<{ description: string; value: string }[]>,\n  interceptedToolCalls: Annotation<any[]>,\n  originalAIMessageId: Annotation<string>,\n});\n\nexport const CopilotKitStateAnnotation = Annotation.Root({\n  copilotkit: Annotation<typeof CopilotKitPropertiesAnnotation.State>,\n  ...MessagesAnnotation.spec,\n});\n\nconst COPILOTKIT_PROPERTIES_JSON_SCHEMA = {\n  type: \"object\",\n  properties: {\n    actions: { type: \"array\", items: {} },\n    context: {\n      type: \"array\",\n      items: {\n        type: \"object\",\n        properties: {\n          description: { type: \"string\" },\n          value: { type: \"string\" },\n        },\n        required: [\"description\", \"value\"],\n      },\n    },\n    interceptedToolCalls: { type: \"array\", items: {} },\n    originalAIMessageId: { type: \"string\" },\n  },\n};\n\n/**\n * Standard Schema describing the `copilotkit` field on agent state.\n *\n * CopilotKit populates these fields at runtime, so the schema accepts any\n * input shape. Use it with `new StateSchema({ ...CopilotKitStateSchema.fields })`.\n */\nexport const CopilotKitPropertiesSchema: StandardSerializableSchema<\n  typeof CopilotKitPropertiesAnnotation.State\n> = {\n  \"~standard\": {\n    version: 1,\n    vendor: \"@copilotkit/sdk-js\",\n    validate: (value) => ({\n      value: value as typeof CopilotKitPropertiesAnnotation.State,\n    }),\n    jsonSchema: {\n      input: () => COPILOTKIT_PROPERTIES_JSON_SCHEMA,\n      output: () => COPILOTKIT_PROPERTIES_JSON_SCHEMA,\n    },\n  },\n};\n\nexport interface IntermediateStateConfig {\n  stateKey: string;\n  tool: string;\n  toolArgument?: string;\n}\n\nexport interface OptionsConfig {\n  emitToolCalls?: boolean | string | string[];\n  emitMessages?: boolean;\n  emitAll?: boolean;\n  emitIntermediateState?: IntermediateStateConfig[];\n}\n\nexport type CopilotKitState = typeof CopilotKitStateAnnotation.State;\nexport type CopilotKitProperties = typeof CopilotKitPropertiesAnnotation.State;\n"],"mappings":";;;;AAiBA,MAAa,iCAAiCA,gCAAW,KAAK;CAC5D,SAASA;CACT,SAASA;CACT,sBAAsBA;CACtB,qBAAqBA;CACtB,CAAC;AAEF,MAAa,4BAA4BA,gCAAW,KAAK;CACvD,YAAYA;CACZ,GAAGC,wCAAmB;CACvB,CAAC;AAEF,MAAM,oCAAoC;CACxC,MAAM;CACN,YAAY;EACV,SAAS;GAAE,MAAM;GAAS,OAAO,EAAE;GAAE;EACrC,SAAS;GACP,MAAM;GACN,OAAO;IACL,MAAM;IACN,YAAY;KACV,aAAa,EAAE,MAAM,UAAU;KAC/B,OAAO,EAAE,MAAM,UAAU;KAC1B;IACD,UAAU,CAAC,eAAe,QAAQ;IACnC;GACF;EACD,sBAAsB;GAAE,MAAM;GAAS,OAAO,EAAE;GAAE;EAClD,qBAAqB,EAAE,MAAM,UAAU;EACxC;CACF;;;;;;;AAQD,MAAa,6BAET,EACF,aAAa;CACX,SAAS;CACT,QAAQ;CACR,WAAW,WAAW,EACb,OACR;CACD,YAAY;EACV,aAAa;EACb,cAAc;EACf;CACF,EACF"}

package/dist/langgraph/types.d.cts

@@ -3,6 +3,31 @@ import * as _langchain_core_messages0 from "@langchain/core/messages";
 import * as langchain from "langchain";
 
 //#region src/langgraph/types.d.ts
+interface StandardSerializableSchema<Input, Output = Input> {
+  readonly "~standard": {
+    readonly version: 1;
+    readonly vendor: string;
+    readonly validate: (value: unknown) => {
+      value: Output;
+    } | {
+      issues: ReadonlyArray<{
+        message: string;
+      }>;
+    };
+    readonly types?: {
+      readonly input: Input;
+      readonly output: Output;
+    };
+    readonly jsonSchema: {
+      readonly input: (options: {
+        target: string;
+      }) => Record<string, unknown>;
+      readonly output: (options: {
+        target: string;
+      }) => Record<string, unknown>;
+    };
+  };
+}
 declare const CopilotKitPropertiesAnnotation: _langchain_langgraph0.AnnotationRoot<{
   actions: {
     (): _langchain_langgraph0.LastValue<any[]>;
@@ -228,6 +253,13 @@ declare const CopilotKitStateAnnotation: _langchain_langgraph0.AnnotationRoot<{
     Root: <S extends _langchain_langgraph0.StateDefinition>(sd: S) => _langchain_langgraph0.AnnotationRoot<S>;
   };
 }>;
+/**
+ * Standard Schema describing the `copilotkit` field on agent state.
+ *
+ * CopilotKit populates these fields at runtime, so the schema accepts any
+ * input shape. Use it with `new StateSchema({ ...CopilotKitStateSchema.fields })`.
+ */
+declare const CopilotKitPropertiesSchema: StandardSerializableSchema<typeof CopilotKitPropertiesAnnotation.State>;
 interface IntermediateStateConfig {
   stateKey: string;
   tool: string;
@@ -242,5 +274,5 @@ interface OptionsConfig {
 type CopilotKitState = typeof CopilotKitStateAnnotation.State;
 type CopilotKitProperties = typeof CopilotKitPropertiesAnnotation.State;
 //#endregion
-export { CopilotKitProperties, CopilotKitPropertiesAnnotation, CopilotKitState, CopilotKitStateAnnotation, IntermediateStateConfig, OptionsConfig };
+export { CopilotKitProperties, CopilotKitPropertiesAnnotation, CopilotKitPropertiesSchema, CopilotKitState, CopilotKitStateAnnotation, IntermediateStateConfig, OptionsConfig, StandardSerializableSchema };
 //# sourceMappingURL=types.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.cts","names":[],"sources":["../../src/langgraph/types.ts"],"mappings":";;;;;cAEa,8BAAA,wBAA8B,cAAA;;QAKzC,qBAAA,CAAA,SAAA;IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAEW,yBAAA,wBAAyB,cAAA;2HAGpC,yBAAA,CAAA,cAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAEe,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.cts","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"}

package/dist/langgraph/types.d.mts

@@ -3,6 +3,31 @@ import * as _langchain_core_messages0 from "@langchain/core/messages";
 import * as langchain from "langchain";
 
 //#region src/langgraph/types.d.ts
+interface StandardSerializableSchema<Input, Output = Input> {
+  readonly "~standard": {
+    readonly version: 1;
+    readonly vendor: string;
+    readonly validate: (value: unknown) => {
+      value: Output;
+    } | {
+      issues: ReadonlyArray<{
+        message: string;
+      }>;
+    };
+    readonly types?: {
+      readonly input: Input;
+      readonly output: Output;
+    };
+    readonly jsonSchema: {
+      readonly input: (options: {
+        target: string;
+      }) => Record<string, unknown>;
+      readonly output: (options: {
+        target: string;
+      }) => Record<string, unknown>;
+    };
+  };
+}
 declare const CopilotKitPropertiesAnnotation: _langchain_langgraph0.AnnotationRoot<{
   actions: {
     (): _langchain_langgraph0.LastValue<any[]>;
@@ -228,6 +253,13 @@ declare const CopilotKitStateAnnotation: _langchain_langgraph0.AnnotationRoot<{
     Root: <S extends _langchain_langgraph0.StateDefinition>(sd: S) => _langchain_langgraph0.AnnotationRoot<S>;
   };
 }>;
+/**
+ * Standard Schema describing the `copilotkit` field on agent state.
+ *
+ * CopilotKit populates these fields at runtime, so the schema accepts any
+ * input shape. Use it with `new StateSchema({ ...CopilotKitStateSchema.fields })`.
+ */
+declare const CopilotKitPropertiesSchema: StandardSerializableSchema<typeof CopilotKitPropertiesAnnotation.State>;
 interface IntermediateStateConfig {
   stateKey: string;
   tool: string;
@@ -242,5 +274,5 @@ interface OptionsConfig {
 type CopilotKitState = typeof CopilotKitStateAnnotation.State;
 type CopilotKitProperties = typeof CopilotKitPropertiesAnnotation.State;
 //#endregion
-export { CopilotKitProperties, CopilotKitPropertiesAnnotation, CopilotKitState, CopilotKitStateAnnotation, IntermediateStateConfig, OptionsConfig };
+export { CopilotKitProperties, CopilotKitPropertiesAnnotation, CopilotKitPropertiesSchema, CopilotKitState, CopilotKitStateAnnotation, IntermediateStateConfig, OptionsConfig, StandardSerializableSchema };
 //# sourceMappingURL=types.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.mts","names":[],"sources":["../../src/langgraph/types.ts"],"mappings":";;;;;cAEa,8BAAA,wBAA8B,cAAA;;QAKzC,qBAAA,CAAA,SAAA;IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAEW,yBAAA,wBAAyB,cAAA;2HAGpC,yBAAA,CAAA,cAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAEe,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;;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"}

package/dist/langgraph/types.mjs

@@ -11,7 +11,47 @@ const CopilotKitStateAnnotation = Annotation.Root({
 	copilotkit: Annotation,
 	...MessagesAnnotation.spec
 });
+const COPILOTKIT_PROPERTIES_JSON_SCHEMA = {
+	type: "object",
+	properties: {
+		actions: {
+			type: "array",
+			items: {}
+		},
+		context: {
+			type: "array",
+			items: {
+				type: "object",
+				properties: {
+					description: { type: "string" },
+					value: { type: "string" }
+				},
+				required: ["description", "value"]
+			}
+		},
+		interceptedToolCalls: {
+			type: "array",
+			items: {}
+		},
+		originalAIMessageId: { type: "string" }
+	}
+};
+/**
+* Standard Schema describing the `copilotkit` field on agent state.
+*
+* CopilotKit populates these fields at runtime, so the schema accepts any
+* input shape. Use it with `new StateSchema({ ...CopilotKitStateSchema.fields })`.
+*/
+const CopilotKitPropertiesSchema = { "~standard": {
+	version: 1,
+	vendor: "@copilotkit/sdk-js",
+	validate: (value) => ({ value }),
+	jsonSchema: {
+		input: () => COPILOTKIT_PROPERTIES_JSON_SCHEMA,
+		output: () => COPILOTKIT_PROPERTIES_JSON_SCHEMA
+	}
+} };
 
 //#endregion
-export { CopilotKitPropertiesAnnotation, CopilotKitStateAnnotation };
+export { CopilotKitPropertiesAnnotation, CopilotKitPropertiesSchema, CopilotKitStateAnnotation };
 //# sourceMappingURL=types.mjs.map

package/dist/langgraph/types.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"types.mjs","names":[],"sources":["../../src/langgraph/types.ts"],"sourcesContent":["import { Annotation, MessagesAnnotation } from \"@langchain/langgraph\";\n\nexport const CopilotKitPropertiesAnnotation = Annotation.Root({\n  actions: Annotation<any[]>,\n  context: Annotation<{ description: string; value: string }[]>,\n  interceptedToolCalls: Annotation<any[]>,\n  originalAIMessageId: Annotation<string>,\n});\n\nexport const CopilotKitStateAnnotation = Annotation.Root({\n  copilotkit: Annotation<typeof CopilotKitPropertiesAnnotation.State>,\n  ...MessagesAnnotation.spec,\n});\n\nexport interface IntermediateStateConfig {\n  stateKey: string;\n  tool: string;\n  toolArgument?: string;\n}\n\nexport interface OptionsConfig {\n  emitToolCalls?: boolean | string | string[];\n  emitMessages?: boolean;\n  emitAll?: boolean;\n  emitIntermediateState?: IntermediateStateConfig[];\n}\n\nexport type CopilotKitState = typeof CopilotKitStateAnnotation.State;\nexport type CopilotKitProperties = typeof CopilotKitPropertiesAnnotation.State;\n"],"mappings":";;;AAEA,MAAa,iCAAiC,WAAW,KAAK;CAC5D,SAAS;CACT,SAAS;CACT,sBAAsB;CACtB,qBAAqB;CACtB,CAAC;AAEF,MAAa,4BAA4B,WAAW,KAAK;CACvD,YAAY;CACZ,GAAG,mBAAmB;CACvB,CAAC"}
+{"version":3,"file":"types.mjs","names":[],"sources":["../../src/langgraph/types.ts"],"sourcesContent":["import { Annotation, MessagesAnnotation } from \"@langchain/langgraph\";\n\nexport interface StandardSerializableSchema<Input, Output = Input> {\n  readonly \"~standard\": {\n    readonly version: 1;\n    readonly vendor: string;\n    readonly validate: (\n      value: unknown,\n    ) => { value: Output } | { issues: ReadonlyArray<{ message: string }> };\n    readonly types?: { readonly input: Input; readonly output: Output };\n    readonly jsonSchema: {\n      readonly input: (options: { target: string }) => Record<string, unknown>;\n      readonly output: (options: { target: string }) => Record<string, unknown>;\n    };\n  };\n}\n\nexport const CopilotKitPropertiesAnnotation = Annotation.Root({\n  actions: Annotation<any[]>,\n  context: Annotation<{ description: string; value: string }[]>,\n  interceptedToolCalls: Annotation<any[]>,\n  originalAIMessageId: Annotation<string>,\n});\n\nexport const CopilotKitStateAnnotation = Annotation.Root({\n  copilotkit: Annotation<typeof CopilotKitPropertiesAnnotation.State>,\n  ...MessagesAnnotation.spec,\n});\n\nconst COPILOTKIT_PROPERTIES_JSON_SCHEMA = {\n  type: \"object\",\n  properties: {\n    actions: { type: \"array\", items: {} },\n    context: {\n      type: \"array\",\n      items: {\n        type: \"object\",\n        properties: {\n          description: { type: \"string\" },\n          value: { type: \"string\" },\n        },\n        required: [\"description\", \"value\"],\n      },\n    },\n    interceptedToolCalls: { type: \"array\", items: {} },\n    originalAIMessageId: { type: \"string\" },\n  },\n};\n\n/**\n * Standard Schema describing the `copilotkit` field on agent state.\n *\n * CopilotKit populates these fields at runtime, so the schema accepts any\n * input shape. Use it with `new StateSchema({ ...CopilotKitStateSchema.fields })`.\n */\nexport const CopilotKitPropertiesSchema: StandardSerializableSchema<\n  typeof CopilotKitPropertiesAnnotation.State\n> = {\n  \"~standard\": {\n    version: 1,\n    vendor: \"@copilotkit/sdk-js\",\n    validate: (value) => ({\n      value: value as typeof CopilotKitPropertiesAnnotation.State,\n    }),\n    jsonSchema: {\n      input: () => COPILOTKIT_PROPERTIES_JSON_SCHEMA,\n      output: () => COPILOTKIT_PROPERTIES_JSON_SCHEMA,\n    },\n  },\n};\n\nexport interface IntermediateStateConfig {\n  stateKey: string;\n  tool: string;\n  toolArgument?: string;\n}\n\nexport interface OptionsConfig {\n  emitToolCalls?: boolean | string | string[];\n  emitMessages?: boolean;\n  emitAll?: boolean;\n  emitIntermediateState?: IntermediateStateConfig[];\n}\n\nexport type CopilotKitState = typeof CopilotKitStateAnnotation.State;\nexport type CopilotKitProperties = typeof CopilotKitPropertiesAnnotation.State;\n"],"mappings":";;;AAiBA,MAAa,iCAAiC,WAAW,KAAK;CAC5D,SAAS;CACT,SAAS;CACT,sBAAsB;CACtB,qBAAqB;CACtB,CAAC;AAEF,MAAa,4BAA4B,WAAW,KAAK;CACvD,YAAY;CACZ,GAAG,mBAAmB;CACvB,CAAC;AAEF,MAAM,oCAAoC;CACxC,MAAM;CACN,YAAY;EACV,SAAS;GAAE,MAAM;GAAS,OAAO,EAAE;GAAE;EACrC,SAAS;GACP,MAAM;GACN,OAAO;IACL,MAAM;IACN,YAAY;KACV,aAAa,EAAE,MAAM,UAAU;KAC/B,OAAO,EAAE,MAAM,UAAU;KAC1B;IACD,UAAU,CAAC,eAAe,QAAQ;IACnC;GACF;EACD,sBAAsB;GAAE,MAAM;GAAS,OAAO,EAAE;GAAE;EAClD,qBAAqB,EAAE,MAAM,UAAU;EACxC;CACF;;;;;;;AAQD,MAAa,6BAET,EACF,aAAa;CACX,SAAS;CACT,QAAQ;CACR,WAAW,WAAW,EACb,OACR;CACD,YAAY;EACV,aAAa;EACb,cAAc;EACf;CACF,EACF"}

package/dist/langgraph.cjs

@@ -2,9 +2,12 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_types = require('./langgraph/types.cjs');
 const require_utils = require('./langgraph/utils.cjs');
 const require_middleware = require('./langgraph/middleware.cjs');
+const require_state_schema = require('./langgraph/state-schema.cjs');
 
 exports.CopilotKitPropertiesAnnotation = require_types.CopilotKitPropertiesAnnotation;
+exports.CopilotKitPropertiesSchema = require_types.CopilotKitPropertiesSchema;
 exports.CopilotKitStateAnnotation = require_types.CopilotKitStateAnnotation;
+exports.CopilotKitStateSchema = require_state_schema.CopilotKitStateSchema;
 exports.convertActionToDynamicStructuredTool = require_utils.convertActionToDynamicStructuredTool;
 exports.convertActionsToDynamicStructuredTools = require_utils.convertActionsToDynamicStructuredTools;
 exports.copilotKitInterrupt = require_utils.copilotKitInterrupt;

package/dist/langgraph.d.cts

@@ -1,4 +1,5 @@
-import { CopilotKitProperties, CopilotKitPropertiesAnnotation, CopilotKitState, CopilotKitStateAnnotation, IntermediateStateConfig, OptionsConfig } from "./langgraph/types.cjs";
+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 { copilotkitMiddleware } from "./langgraph/middleware.cjs";
-export { CopilotKitProperties, CopilotKitPropertiesAnnotation, CopilotKitState, CopilotKitStateAnnotation, IntermediateStateConfig, OptionsConfig, convertActionToDynamicStructuredTool, convertActionsToDynamicStructuredTools, copilotKitInterrupt, copilotkitCustomizeConfig, copilotkitEmitMessage, copilotkitEmitState, copilotkitEmitToolCall, copilotkitExit, copilotkitMiddleware };
+import { CopilotKitSchemaState, CopilotKitSchemaUpdate, CopilotKitStateSchema } from "./langgraph/state-schema.cjs";
+export { CopilotKitProperties, CopilotKitPropertiesAnnotation, CopilotKitPropertiesSchema, CopilotKitSchemaState, CopilotKitSchemaUpdate, CopilotKitState, CopilotKitStateAnnotation, CopilotKitStateSchema, IntermediateStateConfig, OptionsConfig, StandardSerializableSchema, convertActionToDynamicStructuredTool, convertActionsToDynamicStructuredTools, copilotKitInterrupt, copilotkitCustomizeConfig, copilotkitEmitMessage, copilotkitEmitState, copilotkitEmitToolCall, copilotkitExit, copilotkitMiddleware };

package/dist/langgraph.d.mts

@@ -1,4 +1,5 @@
-import { CopilotKitProperties, CopilotKitPropertiesAnnotation, CopilotKitState, CopilotKitStateAnnotation, IntermediateStateConfig, OptionsConfig } from "./langgraph/types.mjs";
+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 { copilotkitMiddleware } from "./langgraph/middleware.mjs";
-export { CopilotKitProperties, CopilotKitPropertiesAnnotation, CopilotKitState, CopilotKitStateAnnotation, IntermediateStateConfig, OptionsConfig, convertActionToDynamicStructuredTool, convertActionsToDynamicStructuredTools, copilotKitInterrupt, copilotkitCustomizeConfig, copilotkitEmitMessage, copilotkitEmitState, copilotkitEmitToolCall, copilotkitExit, copilotkitMiddleware };
+import { CopilotKitSchemaState, CopilotKitSchemaUpdate, CopilotKitStateSchema } from "./langgraph/state-schema.mjs";
+export { CopilotKitProperties, CopilotKitPropertiesAnnotation, CopilotKitPropertiesSchema, CopilotKitSchemaState, CopilotKitSchemaUpdate, CopilotKitState, CopilotKitStateAnnotation, CopilotKitStateSchema, IntermediateStateConfig, OptionsConfig, StandardSerializableSchema, convertActionToDynamicStructuredTool, convertActionsToDynamicStructuredTools, copilotKitInterrupt, copilotkitCustomizeConfig, copilotkitEmitMessage, copilotkitEmitState, copilotkitEmitToolCall, copilotkitExit, copilotkitMiddleware };

package/dist/langgraph.mjs

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@copilotkit/sdk-js",
-  "version": "1.56.3",
+  "version": "1.56.4",
   "private": false,
   "keywords": [
     "ai",
@@ -49,7 +49,7 @@
   },
   "dependencies": {
     "@ag-ui/langgraph": "0.0.29",
-    "@copilotkit/shared": "1.56.3"
+    "@copilotkit/shared": "1.56.4"
   },
   "devDependencies": {
     "@langchain/core": "^1.1.8",

package/src/langchain.ts

@@ -4,8 +4,12 @@ console.warn(
 
 export {
   CopilotKitPropertiesAnnotation,
+  CopilotKitPropertiesSchema,
   CopilotKitStateAnnotation,
+  CopilotKitStateSchema,
   type CopilotKitState,
+  type CopilotKitSchemaState,
+  type CopilotKitSchemaUpdate,
   type CopilotKitProperties,
   copilotkitCustomizeConfig as copilotKitCustomizeConfig,
   copilotkitExit as copilotKitExit,

package/src/langgraph/__tests__/state-schema.test.ts

@@ -0,0 +1,85 @@
+import { StateGraph, END, START, StateSchema } from "@langchain/langgraph";
+import { HumanMessage } from "@langchain/core/messages";
+import * as z from "zod";
+
+import { CopilotKitStateSchema } from "../state-schema";
+import { CopilotKitPropertiesSchema } from "../types";
+
+describe("CopilotKitStateSchema", () => {
+  it("exposes `copilotkit` and `messages` fields for composition", () => {
+    expect(Object.keys(CopilotKitStateSchema.fields).sort()).toEqual([
+      "copilotkit",
+      "messages",
+    ]);
+  });
+
+  it("can be used directly as a StateGraph schema", async () => {
+    const graph = new StateGraph(CopilotKitStateSchema)
+      .addNode("echo", (state) => ({ messages: state.messages }))
+      .addEdge(START, "echo")
+      .addEdge("echo", END)
+      .compile();
+
+    const result = await graph.invoke({
+      messages: [new HumanMessage("hello")],
+    });
+
+    expect(result.messages).toHaveLength(1);
+    expect(result.messages[0].content).toBe("hello");
+  });
+
+  it("can be extended with user fields via spread", async () => {
+    const AgentStateSchema = new StateSchema({
+      language: z.enum(["english", "spanish"]).default("english"),
+      ...CopilotKitStateSchema.fields,
+    });
+
+    const graph = new StateGraph(AgentStateSchema)
+      .addNode("chat", (state) => ({ language: state.language }))
+      .addEdge(START, "chat")
+      .addEdge("chat", END)
+      .compile();
+
+    const result = await graph.invoke({
+      language: "spanish",
+      messages: [new HumanMessage("hola")],
+    });
+
+    expect(result.language).toBe("spanish");
+    expect(result.messages).toHaveLength(1);
+  });
+
+  it("preserves copilotkit runtime state across nodes", async () => {
+    const graph = new StateGraph(CopilotKitStateSchema)
+      .addNode("noop", (state) => ({ copilotkit: state.copilotkit }))
+      .addEdge(START, "noop")
+      .addEdge("noop", END)
+      .compile();
+
+    const result = await graph.invoke({
+      copilotkit: {
+        actions: [{ name: "doThing" }],
+        context: [{ description: "user", value: "alice" }],
+        interceptedToolCalls: [],
+        originalAIMessageId: "msg-1",
+      },
+      messages: [],
+    });
+
+    expect(result.copilotkit.actions).toEqual([{ name: "doThing" }]);
+    expect(result.copilotkit.context).toEqual([
+      { description: "user", value: "alice" },
+    ]);
+    expect(result.copilotkit.originalAIMessageId).toBe("msg-1");
+  });
+
+  it("exposes a standard schema shape for copilotkit properties", () => {
+    expect(CopilotKitPropertiesSchema["~standard"].version).toBe(1);
+    expect(CopilotKitPropertiesSchema["~standard"].vendor).toBe(
+      "@copilotkit/sdk-js",
+    );
+    expect(
+      typeof CopilotKitPropertiesSchema["~standard"].jsonSchema.input,
+    ).toBe("function");
+  });
+});

package/src/langgraph/index.ts

@@ -1,3 +1,4 @@
 export * from "./types";
 export * from "./utils";
 export * from "./middleware";
+export * from "./state-schema";

package/src/langgraph/state-schema.ts

@@ -0,0 +1,34 @@
+import { MessagesValue, StateSchema } from "@langchain/langgraph";
+import { CopilotKitPropertiesSchema } from "./types";
+
+/**
+ * CopilotKit agent state defined with LangGraph's modern
+ * [`StateSchema`](https://docs.langchain.com/oss/javascript/langgraph/graph-api)
+ * API.
+ *
+ * Prefer this over `CopilotKitStateAnnotation` when starting a new
+ * TypeScript agent. `Annotation.Root` is still supported by LangGraph but
+ * `StateSchema` is the recommended API going forward.
+ *
+ * ### Example
+ *
+ * ```typescript
+ * import { StateSchema } from "@langchain/langgraph";
+ * import { CopilotKitStateSchema } from "@copilotkit/sdk-js/langgraph";
+ * import { z } from "zod";
+ *
+ * export const AgentStateSchema = new StateSchema({
+ *   language: z.enum(["english", "spanish"]),
+ *   ...CopilotKitStateSchema.fields,
+ * });
+ *
+ * export type AgentState = typeof AgentStateSchema.State;
+ * ```
+ */
+export const CopilotKitStateSchema = new StateSchema({
+  copilotkit: CopilotKitPropertiesSchema,
+  messages: MessagesValue,
+});
+
+export type CopilotKitSchemaState = typeof CopilotKitStateSchema.State;
+export type CopilotKitSchemaUpdate = typeof CopilotKitStateSchema.Update;

package/src/langgraph/types.ts

@@ -1,5 +1,20 @@
 import { Annotation, MessagesAnnotation } from "@langchain/langgraph";
 
+export interface StandardSerializableSchema<Input, Output = Input> {
+  readonly "~standard": {
+    readonly version: 1;
+    readonly vendor: string;
+    readonly validate: (
+      value: unknown,
+    ) => { value: Output } | { issues: ReadonlyArray<{ message: string }> };
+    readonly types?: { readonly input: Input; readonly output: Output };
+    readonly jsonSchema: {
+      readonly input: (options: { target: string }) => Record<string, unknown>;
+      readonly output: (options: { target: string }) => Record<string, unknown>;
+    };
+  };
+}
+
 export const CopilotKitPropertiesAnnotation = Annotation.Root({
   actions: Annotation<any[]>,
   context: Annotation<{ description: string; value: string }[]>,
@@ -12,6 +27,48 @@ export const CopilotKitStateAnnotation = Annotation.Root({
   ...MessagesAnnotation.spec,
 });
 
+const COPILOTKIT_PROPERTIES_JSON_SCHEMA = {
+  type: "object",
+  properties: {
+    actions: { type: "array", items: {} },
+    context: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          description: { type: "string" },
+          value: { type: "string" },
+        },
+        required: ["description", "value"],
+      },
+    },
+    interceptedToolCalls: { type: "array", items: {} },
+    originalAIMessageId: { type: "string" },
+  },
+};
+
+/**
+ * Standard Schema describing the `copilotkit` field on agent state.
+ *
+ * CopilotKit populates these fields at runtime, so the schema accepts any
+ * input shape. Use it with `new StateSchema({ ...CopilotKitStateSchema.fields })`.
+ */
+export const CopilotKitPropertiesSchema: StandardSerializableSchema<
+  typeof CopilotKitPropertiesAnnotation.State
+> = {
+  "~standard": {
+    version: 1,
+    vendor: "@copilotkit/sdk-js",
+    validate: (value) => ({
+      value: value as typeof CopilotKitPropertiesAnnotation.State,
+    }),
+    jsonSchema: {
+      input: () => COPILOTKIT_PROPERTIES_JSON_SCHEMA,
+      output: () => COPILOTKIT_PROPERTIES_JSON_SCHEMA,
+    },
+  },
+};
+
 export interface IntermediateStateConfig {
   stateKey: string;
   tool: string;