@langgraph-js/sdk 1.6.4 → 1.7.0

package/src/tool/createTool.ts

@@ -1,102 +1,102 @@
-import { actionParametersToJsonSchema, convertJsonSchemaToZodRawShape } from "./utils.js";
-import { z, ZodRawShape, ZodTypeAny } from "zod";
-import { Action, Parameter } from "./copilotkit-actions.js";
-import { zodToJsonSchema } from "zod-to-json-schema";
-import { Message } from "@langchain/langgraph-sdk";
-import { ToolRenderData } from "./ToolUI.js";
-
-export interface UnionTool<Args extends ZodRawShape, Child extends Object = Object> {
-    name: string;
-    description: string;
-    parameters: Args;
-    /** 是否直接返回工具结果，而不是通过消息返回 */
-    returnDirect?: boolean;
-    execute: ToolCallback<Args>;
-    /** 工具执行成功后触发的附加消息 */
-    callbackMessage?: (result: CallToolResult) => Message[];
-    render?: <D>(tool: ToolRenderData<D>) => Child;
-    onlyRender?: boolean;
-    /** 只允许指定的 agent 使用该工具，如果未指定，则所有 agent 都可以使用 */
-    allowAgent?: string[];
-}
-export type ToolCallback<Args extends ZodRawShape> = (args: z.objectOutputType<Args, ZodTypeAny>, context?: any) => CallToolResult | Promise<CallToolResult>;
-
-export type CallToolResult = string | { type: "text"; text: string }[];
-
-/** 用于格式校验 */
-export const createTool = <Args extends ZodRawShape>(tool: UnionTool<Args>) => {
-    return tool;
-};
-
-/** 提供一种兼容 copilotkit 的定义方式，简化定义形式
- * 来自 copilotkit 的 frontend action
- */
-export const createFETool = <const T extends Parameter[], Args extends ZodRawShape>(
-    tool: Action<T> & {
-        allowAgent?: string[];
-    }
-): UnionTool<Args> => {
-    return {
-        name: tool.name,
-        description: tool.description || "",
-        parameters: convertJsonSchemaToZodRawShape(actionParametersToJsonSchema(tool.parameters || [])) as any,
-        returnDirect: tool.returnDirect,
-        callbackMessage: tool.callbackMessage,
-        allowAgent: tool.allowAgent,
-        async execute(args, context) {
-            try {
-                const result = await tool.handler?.(args, context);
-                if (typeof result === "string") {
-                    return [{ type: "text", text: result }];
-                }
-                return [{ type: "text", text: JSON.stringify(result) }];
-            } catch (error) {
-                return [{ type: "text", text: `Error: ${error}` }];
-            }
-        },
-    };
-};
-
-///======= UnionTool 到 各种工具的辅助函数
-export const createJSONDefineTool = <Args extends ZodRawShape>(tool: UnionTool<Args>) => {
-    return {
-        name: tool.name,
-        description: tool.description,
-        parameters: zodToJsonSchema(z.object(tool.parameters)),
-    };
-};
-
-export const createMCPTool = <Args extends ZodRawShape>(tool: UnionTool<Args>) => {
-    return [
-        tool.name,
-        tool.description,
-        tool.parameters,
-        async (args: z.objectOutputType<Args, ZodTypeAny>) => {
-            try {
-                const result = await tool.execute(args);
-                if (typeof result === "string") {
-                    return { content: [{ type: "text", text: result }] };
-                }
-                return {
-                    content: result,
-                };
-            } catch (error) {
-                return { content: [{ type: "text", text: `Error: ${error}` }], isError: true };
-            }
-        },
-    ];
-};
-
-export const createToolUI = <Args extends Parameter[] | [] = [], Child extends Object = {}>(
-    tool: Action<Args> & {
-        allowAgent?: string[];
-        render?: (tool: ToolRenderData<any>) => Child;
-        onlyRender?: boolean;
-    }
-) => {
-    return {
-        ...createFETool(tool),
-        render: tool.render,
-        onlyRender: tool.onlyRender,
-    };
-};
+import { actionParametersToJsonSchema, convertJsonSchemaToZodRawShape } from "./utils.js";
+import { z, ZodRawShape, ZodTypeAny } from "zod";
+import { Action, Parameter } from "./copilotkit-actions.js";
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { Message } from "@langchain/langgraph-sdk";
+import { ToolRenderData } from "./ToolUI.js";
+
+export interface UnionTool<Args extends ZodRawShape, Child extends Object = Object> {
+    name: string;
+    description: string;
+    parameters: Args;
+    /** 是否直接返回工具结果，而不是通过消息返回 */
+    returnDirect?: boolean;
+    execute: ToolCallback<Args>;
+    /** 工具执行成功后触发的附加消息 */
+    callbackMessage?: (result: CallToolResult) => Message[];
+    render?: <D>(tool: ToolRenderData<D>) => Child;
+    onlyRender?: boolean;
+    /** 只允许指定的 agent 使用该工具，如果未指定，则所有 agent 都可以使用 */
+    allowAgent?: string[];
+}
+export type ToolCallback<Args extends ZodRawShape> = (args: z.objectOutputType<Args, ZodTypeAny>, context?: any) => CallToolResult | Promise<CallToolResult>;
+
+export type CallToolResult = string | { type: "text"; text: string }[];
+
+/** 用于格式校验 */
+export const createTool = <Args extends ZodRawShape>(tool: UnionTool<Args>) => {
+    return tool;
+};
+
+/** 提供一种兼容 copilotkit 的定义方式，简化定义形式
+ * 来自 copilotkit 的 frontend action
+ */
+export const createFETool = <const T extends Parameter[], Args extends ZodRawShape>(
+    tool: Action<T> & {
+        allowAgent?: string[];
+    }
+): UnionTool<Args> => {
+    return {
+        name: tool.name,
+        description: tool.description || "",
+        parameters: convertJsonSchemaToZodRawShape(actionParametersToJsonSchema(tool.parameters || [])) as any,
+        returnDirect: tool.returnDirect,
+        callbackMessage: tool.callbackMessage,
+        allowAgent: tool.allowAgent,
+        async execute(args, context) {
+            try {
+                const result = await tool.handler?.(args, context);
+                if (typeof result === "string") {
+                    return [{ type: "text", text: result }];
+                }
+                return [{ type: "text", text: JSON.stringify(result) }];
+            } catch (error) {
+                return [{ type: "text", text: `Error: ${error}` }];
+            }
+        },
+    };
+};
+
+///======= UnionTool 到 各种工具的辅助函数
+export const createJSONDefineTool = <Args extends ZodRawShape>(tool: UnionTool<Args>) => {
+    return {
+        name: tool.name,
+        description: tool.description,
+        parameters: zodToJsonSchema(z.object(tool.parameters)),
+    };
+};
+
+export const createMCPTool = <Args extends ZodRawShape>(tool: UnionTool<Args>) => {
+    return [
+        tool.name,
+        tool.description,
+        tool.parameters,
+        async (args: z.objectOutputType<Args, ZodTypeAny>) => {
+            try {
+                const result = await tool.execute(args);
+                if (typeof result === "string") {
+                    return { content: [{ type: "text", text: result }] };
+                }
+                return {
+                    content: result,
+                };
+            } catch (error) {
+                return { content: [{ type: "text", text: `Error: ${error}` }], isError: true };
+            }
+        },
+    ];
+};
+
+export const createToolUI = <Args extends Parameter[] | [] = [], Child extends Object = {}>(
+    tool: Action<Args> & {
+        allowAgent?: string[];
+        render?: (tool: ToolRenderData<any>) => Child;
+        onlyRender?: boolean;
+    }
+) => {
+    return {
+        ...createFETool(tool),
+        render: tool.render,
+        onlyRender: tool.onlyRender,
+    };
+};

package/src/tool/index.ts

@@ -1,3 +1,3 @@
-export * from "./createTool.js";
-export * from "./copilotkit-actions.js";
-export * from "./ToolUI.js";
+export * from "./createTool.js";
+export * from "./copilotkit-actions.js";
+export * from "./ToolUI.js";

package/src/tool/utils.ts

@@ -1,158 +1,158 @@
-/**
- * copy and modify from copilotkit
- * https://github.com/copilotkit/copilotkit
- *
- * MIT License
- */
-import { z, ZodRawShape } from "zod";
-import { Parameter } from "./copilotkit-actions.js";
-
-export type JSONSchemaString = {
-    type: "string";
-    description?: string;
-    enum?: string[];
-};
-
-export type JSONSchemaNumber = {
-    type: "number";
-    description?: string;
-};
-
-export type JSONSchemaBoolean = {
-    type: "boolean";
-    description?: string;
-};
-
-export type JSONSchemaObject = {
-    type: "object";
-    properties?: Record<string, JSONSchema>;
-    required?: string[];
-    description?: string;
-};
-
-export type JSONSchemaArray = {
-    type: "array";
-    items: JSONSchema;
-    description?: string;
-};
-
-export type JSONSchema = JSONSchemaString | JSONSchemaNumber | JSONSchemaBoolean | JSONSchemaObject | JSONSchemaArray;
-
-export function actionParametersToJsonSchema(actionParameters: Parameter[]): JSONSchema {
-    // Create the parameters object based on the argumentAnnotations
-    let parameters: { [key: string]: any } = {};
-    for (let parameter of actionParameters || []) {
-        parameters[parameter.name] = convertAttribute(parameter);
-    }
-
-    let requiredParameterNames: string[] = [];
-    for (let arg of actionParameters || []) {
-        if (arg.required !== false) {
-            requiredParameterNames.push(arg.name);
-        }
-    }
-
-    // Create the ChatCompletionFunctions object
-    return {
-        type: "object",
-        properties: parameters,
-        required: requiredParameterNames,
-    };
-}
-
-function convertAttribute(attribute: Parameter): JSONSchema {
-    switch (attribute.type) {
-        case "string":
-            return {
-                type: "string",
-                description: attribute.description,
-                ...(attribute.enum && { enum: attribute.enum }),
-            };
-        case "number":
-        case "boolean":
-            return {
-                type: attribute.type,
-                description: attribute.description,
-            };
-        case "object":
-        case "object[]":
-            const properties = attribute.attributes?.reduce(
-                (acc, attr) => {
-                    acc[attr.name] = convertAttribute(attr);
-                    return acc;
-                },
-                {} as Record<string, any>
-            );
-            const required = attribute.attributes?.filter((attr) => attr.required !== false).map((attr) => attr.name);
-            if (attribute.type === "object[]") {
-                return {
-                    type: "array",
-                    items: {
-                        type: "object",
-                        ...(properties && { properties }),
-                        ...(required && required.length > 0 && { required }),
-                    },
-                    description: attribute.description,
-                };
-            }
-            return {
-                type: "object",
-                description: attribute.description,
-                ...(properties && { properties }),
-                ...(required && required.length > 0 && { required }),
-            };
-        default:
-            // Handle arrays of primitive types and undefined attribute.type
-            if (attribute.type?.endsWith("[]")) {
-                const itemType = attribute.type.slice(0, -2);
-                return {
-                    type: "array",
-                    items: { type: itemType as any },
-                    description: attribute.description,
-                };
-            }
-            // Fallback for undefined type or any other unexpected type
-            return {
-                type: "string",
-                description: attribute.description,
-            };
-    }
-}
-
-export function convertJsonSchemaToZodRawShape(jsonSchema: any): ZodRawShape {
-    const spec: { [key: string]: z.ZodSchema } = {};
-    for (const [key, value] of Object.entries(jsonSchema.properties)) {
-        spec[key] = convertJsonSchemaToZodSchema(value, jsonSchema.required ? jsonSchema.required.includes(key) : false);
-    }
-    return spec;
-}
-
-export function convertJsonSchemaToZodSchema(jsonSchema: any, required: boolean): z.ZodSchema {
-    if (jsonSchema.type === "object") {
-        const spec: { [key: string]: z.ZodSchema } = {};
-
-        if (!jsonSchema.properties || !Object.keys(jsonSchema.properties).length) {
-            return !required ? z.object(spec).optional() : z.object(spec);
-        }
-
-        for (const [key, value] of Object.entries(jsonSchema.properties)) {
-            spec[key] = convertJsonSchemaToZodSchema(value, jsonSchema.required ? jsonSchema.required.includes(key) : false);
-        }
-        let schema = z.object(spec).describe(jsonSchema.description);
-        return required ? schema : schema.optional();
-    } else if (jsonSchema.type === "string") {
-        let schema = z.string().describe(jsonSchema.description);
-        return required ? schema : schema.optional();
-    } else if (jsonSchema.type === "number") {
-        let schema = z.number().describe(jsonSchema.description);
-        return required ? schema : schema.optional();
-    } else if (jsonSchema.type === "boolean") {
-        let schema = z.boolean().describe(jsonSchema.description);
-        return required ? schema : schema.optional();
-    } else if (jsonSchema.type === "array") {
-        let itemSchema = convertJsonSchemaToZodSchema(jsonSchema.items, true);
-        let schema = z.array(itemSchema).describe(jsonSchema.description);
-        return required ? schema : schema.optional();
-    }
-    throw new Error("Invalid JSON schema");
-}
+/**
+ * copy and modify from copilotkit
+ * https://github.com/copilotkit/copilotkit
+ *
+ * MIT License
+ */
+import { z, ZodRawShape } from "zod";
+import { Parameter } from "./copilotkit-actions.js";
+
+export type JSONSchemaString = {
+    type: "string";
+    description?: string;
+    enum?: string[];
+};
+
+export type JSONSchemaNumber = {
+    type: "number";
+    description?: string;
+};
+
+export type JSONSchemaBoolean = {
+    type: "boolean";
+    description?: string;
+};
+
+export type JSONSchemaObject = {
+    type: "object";
+    properties?: Record<string, JSONSchema>;
+    required?: string[];
+    description?: string;
+};
+
+export type JSONSchemaArray = {
+    type: "array";
+    items: JSONSchema;
+    description?: string;
+};
+
+export type JSONSchema = JSONSchemaString | JSONSchemaNumber | JSONSchemaBoolean | JSONSchemaObject | JSONSchemaArray;
+
+export function actionParametersToJsonSchema(actionParameters: Parameter[]): JSONSchema {
+    // Create the parameters object based on the argumentAnnotations
+    let parameters: { [key: string]: any } = {};
+    for (let parameter of actionParameters || []) {
+        parameters[parameter.name] = convertAttribute(parameter);
+    }
+
+    let requiredParameterNames: string[] = [];
+    for (let arg of actionParameters || []) {
+        if (arg.required !== false) {
+            requiredParameterNames.push(arg.name);
+        }
+    }
+
+    // Create the ChatCompletionFunctions object
+    return {
+        type: "object",
+        properties: parameters,
+        required: requiredParameterNames,
+    };
+}
+
+function convertAttribute(attribute: Parameter): JSONSchema {
+    switch (attribute.type) {
+        case "string":
+            return {
+                type: "string",
+                description: attribute.description,
+                ...(attribute.enum && { enum: attribute.enum }),
+            };
+        case "number":
+        case "boolean":
+            return {
+                type: attribute.type,
+                description: attribute.description,
+            };
+        case "object":
+        case "object[]":
+            const properties = attribute.attributes?.reduce(
+                (acc, attr) => {
+                    acc[attr.name] = convertAttribute(attr);
+                    return acc;
+                },
+                {} as Record<string, any>
+            );
+            const required = attribute.attributes?.filter((attr) => attr.required !== false).map((attr) => attr.name);
+            if (attribute.type === "object[]") {
+                return {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        ...(properties && { properties }),
+                        ...(required && required.length > 0 && { required }),
+                    },
+                    description: attribute.description,
+                };
+            }
+            return {
+                type: "object",
+                description: attribute.description,
+                ...(properties && { properties }),
+                ...(required && required.length > 0 && { required }),
+            };
+        default:
+            // Handle arrays of primitive types and undefined attribute.type
+            if (attribute.type?.endsWith("[]")) {
+                const itemType = attribute.type.slice(0, -2);
+                return {
+                    type: "array",
+                    items: { type: itemType as any },
+                    description: attribute.description,
+                };
+            }
+            // Fallback for undefined type or any other unexpected type
+            return {
+                type: "string",
+                description: attribute.description,
+            };
+    }
+}
+
+export function convertJsonSchemaToZodRawShape(jsonSchema: any): ZodRawShape {
+    const spec: { [key: string]: z.ZodSchema } = {};
+    for (const [key, value] of Object.entries(jsonSchema.properties)) {
+        spec[key] = convertJsonSchemaToZodSchema(value, jsonSchema.required ? jsonSchema.required.includes(key) : false);
+    }
+    return spec;
+}
+
+export function convertJsonSchemaToZodSchema(jsonSchema: any, required: boolean): z.ZodSchema {
+    if (jsonSchema.type === "object") {
+        const spec: { [key: string]: z.ZodSchema } = {};
+
+        if (!jsonSchema.properties || !Object.keys(jsonSchema.properties).length) {
+            return !required ? z.object(spec).optional() : z.object(spec);
+        }
+
+        for (const [key, value] of Object.entries(jsonSchema.properties)) {
+            spec[key] = convertJsonSchemaToZodSchema(value, jsonSchema.required ? jsonSchema.required.includes(key) : false);
+        }
+        let schema = z.object(spec).describe(jsonSchema.description);
+        return required ? schema : schema.optional();
+    } else if (jsonSchema.type === "string") {
+        let schema = z.string().describe(jsonSchema.description);
+        return required ? schema : schema.optional();
+    } else if (jsonSchema.type === "number") {
+        let schema = z.number().describe(jsonSchema.description);
+        return required ? schema : schema.optional();
+    } else if (jsonSchema.type === "boolean") {
+        let schema = z.boolean().describe(jsonSchema.description);
+        return required ? schema : schema.optional();
+    } else if (jsonSchema.type === "array") {
+        let itemSchema = convertJsonSchemaToZodSchema(jsonSchema.items, true);
+        let schema = z.array(itemSchema).describe(jsonSchema.description);
+        return required ? schema : schema.optional();
+    }
+    throw new Error("Invalid JSON schema");
+}

package/src/ui-store/UnionStore.ts

@@ -1,29 +1,29 @@
-import { PreinitializedWritableAtom, StoreValue } from "nanostores";
-
-/**
- * @zh UnionStore 类型用于合并 store 的 data 和 mutations，使其可以直接访问。
- * @en The UnionStore type is used to merge the data and mutations of a store, allowing direct access.
- */
-export type UnionStore<T extends { data: Record<string, PreinitializedWritableAtom<any>>; mutations: Record<string, any> }> = {
-    [k in keyof T["data"]]: StoreValue<T["data"][k]>;
-} & T["mutations"];
-
-/**
- * @zh useUnionStore Hook 用于将 nanostores 的 store 结构转换为更易于在 UI 组件中使用的扁平结构。
- * @en The useUnionStore Hook is used to transform the nanostores store structure into a flatter structure that is easier to use in UI components.
- */
-export const useUnionStore = <T extends { data: Record<string, any>; mutations: Record<string, any> }>(
-    store: T,
-    useStore: (store: PreinitializedWritableAtom<any>) => StoreValue<T["data"][keyof T["data"]]>
-): UnionStore<T> => {
-    const data: any = Object.fromEntries(
-        Object.entries(store.data as any).map(([key, value]) => {
-            return [key, useStore(value as any)];
-        })
-    );
-
-    return {
-        ...data,
-        ...store.mutations,
-    };
-};
+import { PreinitializedWritableAtom, StoreValue } from "nanostores";
+
+/**
+ * @zh UnionStore 类型用于合并 store 的 data 和 mutations，使其可以直接访问。
+ * @en The UnionStore type is used to merge the data and mutations of a store, allowing direct access.
+ */
+export type UnionStore<T extends { data: Record<string, PreinitializedWritableAtom<any>>; mutations: Record<string, any> }> = {
+    [k in keyof T["data"]]: StoreValue<T["data"][k]>;
+} & T["mutations"];
+
+/**
+ * @zh useUnionStore Hook 用于将 nanostores 的 store 结构转换为更易于在 UI 组件中使用的扁平结构。
+ * @en The useUnionStore Hook is used to transform the nanostores store structure into a flatter structure that is easier to use in UI components.
+ */
+export const useUnionStore = <T extends { data: Record<string, any>; mutations: Record<string, any> }>(
+    store: T,
+    useStore: (store: PreinitializedWritableAtom<any>) => StoreValue<T["data"][keyof T["data"]]>
+): UnionStore<T> => {
+    const data: any = Object.fromEntries(
+        Object.entries(store.data as any).map(([key, value]) => {
+            return [key, useStore(value as any)];
+        })
+    );
+
+    return {
+        ...data,
+        ...store.mutations,
+    };
+};