@langgraph-js/sdk 1.0.0 → 1.1.1

package/dist/SpendTime.js

@@ -0,0 +1,32 @@
+export class SpendTime {
+    constructor() {
+        this.timeCounter = new Map();
+    }
+    start(key) {
+        this.timeCounter.set(key, [new Date()]);
+    }
+    end(key) {
+        var _a;
+        this.timeCounter.set(key, [((_a = this.timeCounter.get(key)) === null || _a === void 0 ? void 0 : _a[0]) || new Date(), new Date()]);
+    }
+    setSpendTime(key) {
+        if (this.timeCounter.has(key)) {
+            this.end(key);
+        }
+        else {
+            this.start(key);
+        }
+    }
+    getStartTime(key) {
+        var _a;
+        return ((_a = this.timeCounter.get(key)) === null || _a === void 0 ? void 0 : _a[0]) || new Date();
+    }
+    getEndTime(key) {
+        var _a;
+        return ((_a = this.timeCounter.get(key)) === null || _a === void 0 ? void 0 : _a[1]) || new Date();
+    }
+    getSpendTime(key) {
+        const [start, end = new Date()] = this.timeCounter.get(key) || [new Date(), new Date()];
+        return end.getTime() - start.getTime();
+    }
+}

package/dist/ToolManager.d.ts

@@ -0,0 +1,63 @@
+import { ToolMessage } from "@langchain/langgraph-sdk";
+import { LangGraphClient } from "./LangGraphClient";
+import { CallToolResult, UnionTool } from "./tool/createTool";
+export declare class ToolManager {
+    private tools;
+    /**
+     * 注册一个工具
+     * @param tool 要注册的工具
+     */
+    bindTool(tool: UnionTool<any>): void;
+    /**
+     * 注册多个工具
+     * @param tools 要注册的工具数组
+     */
+    bindTools(tools: UnionTool<any>[]): void;
+    /**
+     * 获取所有已注册的工具
+     * @returns 工具数组
+     */
+    getAllTools(): UnionTool<any>[];
+    /**
+     * 获取指定名称的工具
+     * @param name 工具名称
+     * @returns 工具实例或 undefined
+     */
+    getTool(name: string): UnionTool<any> | undefined;
+    /**
+     * 移除指定名称的工具
+     * @param name 工具名称
+     * @returns 是否成功移除
+     */
+    removeTool(name: string): boolean;
+    /**
+     * 清空所有工具
+     */
+    clearTools(): void;
+    callTool(name: string, args: any, context: {
+        client: LangGraphClient;
+        message: ToolMessage;
+    }): Promise<CallToolResult>;
+    toJSON(): {
+        name: string;
+        description: string;
+        parameters: import("zod-to-json-schema").JsonSchema7Type & {
+            $schema?: string | undefined;
+            definitions?: {
+                [key: string]: import("zod-to-json-schema").JsonSchema7Type;
+            } | undefined;
+        };
+    }[];
+    private waitingMap;
+    doneWaiting(id: string, value: CallToolResult): boolean;
+    waitForDone(id: string): Promise<unknown> | ((value: CallToolResult) => void) | undefined;
+    /** 等待用户输入
+     * @example
+     * // 继续 chat 流
+     * client.tools.doneWaiting(message.id!, (e.target as any).value);
+     */
+    static waitForUIDone<T>(_: T, context: {
+        client: LangGraphClient;
+        message: ToolMessage;
+    }): Promise<unknown> | ((value: CallToolResult) => void) | undefined;
+}

package/dist/ToolManager.js

@@ -0,0 +1,93 @@
+import { createJSONDefineTool } from "./tool/createTool";
+export class ToolManager {
+    constructor() {
+        this.tools = new Map();
+        // === 专门为前端设计的异步触发结构
+        this.waitingMap = new Map();
+    }
+    /**
+     * 注册一个工具
+     * @param tool 要注册的工具
+     */
+    bindTool(tool) {
+        if (this.tools.has(tool.name)) {
+            throw new Error(`Tool with name ${tool.name} already exists`);
+        }
+        this.tools.set(tool.name, tool);
+    }
+    /**
+     * 注册多个工具
+     * @param tools 要注册的工具数组
+     */
+    bindTools(tools) {
+        tools.forEach((tool) => this.bindTool(tool));
+    }
+    /**
+     * 获取所有已注册的工具
+     * @returns 工具数组
+     */
+    getAllTools() {
+        return Array.from(this.tools.values());
+    }
+    /**
+     * 获取指定名称的工具
+     * @param name 工具名称
+     * @returns 工具实例或 undefined
+     */
+    getTool(name) {
+        return this.tools.get(name);
+    }
+    /**
+     * 移除指定名称的工具
+     * @param name 工具名称
+     * @returns 是否成功移除
+     */
+    removeTool(name) {
+        return this.tools.delete(name);
+    }
+    /**
+     * 清空所有工具
+     */
+    clearTools() {
+        this.tools.clear();
+    }
+    async callTool(name, args, context) {
+        const tool = this.getTool(name);
+        if (!tool) {
+            throw new Error(`Tool with name ${name} not found`);
+        }
+        return await tool.execute(args, context);
+    }
+    toJSON() {
+        return Array.from(this.tools.values()).map((i) => createJSONDefineTool(i));
+    }
+    doneWaiting(id, value) {
+        if (this.waitingMap.has(id)) {
+            this.waitingMap.get(id)(value);
+            this.waitingMap.delete(id);
+            return true;
+        }
+        else {
+            console.warn(`Waiting for tool ${id} not found`);
+            return false;
+        }
+    }
+    waitForDone(id) {
+        if (this.waitingMap.has(id)) {
+            return this.waitingMap.get(id);
+        }
+        const promise = new Promise((resolve, reject) => {
+            this.waitingMap.set(id, resolve);
+        });
+        return promise;
+    }
+    /** 等待用户输入
+     * @example
+     * // 继续 chat 流
+     * client.tools.doneWaiting(message.id!, (e.target as any).value);
+     */
+    static waitForUIDone(_, context) {
+        // console.log(context.message);
+        return context.client.tools.waitForDone(context.message.id);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./LangGraphClient";
+export * from "./tool";
+export * from "@langchain/langgraph-sdk";
+export * from "./ui-store";
+export * from "./ToolManager";

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from "./LangGraphClient";
+export * from "./tool";
+export * from "@langchain/langgraph-sdk";
+export * from "./ui-store";
+export * from "./ToolManager";

package/dist/tool/copilotkit-actions.d.ts

@@ -0,0 +1,66 @@
+import { Message } from "@langchain/langgraph-sdk";
+/**
+ * copy and modify from copilotkit
+ * https://github.com/copilotkit/copilotkit
+ *
+ * MIT License
+ */
+type TypeMap = {
+    string: string;
+    number: number;
+    boolean: boolean;
+    object: object;
+    "string[]": string[];
+    "number[]": number[];
+    "boolean[]": boolean[];
+    "object[]": object[];
+};
+type AbstractParameter = {
+    name: string;
+    type?: keyof TypeMap;
+    description?: string;
+    required?: boolean;
+};
+interface StringParameter extends AbstractParameter {
+    type: "string";
+    enum?: string[];
+}
+interface ObjectParameter extends AbstractParameter {
+    type: "object";
+    attributes?: Parameter[];
+}
+interface ObjectArrayParameter extends AbstractParameter {
+    type: "object[]";
+    attributes?: Parameter[];
+}
+type SpecialParameters = StringParameter | ObjectParameter | ObjectArrayParameter;
+interface BaseParameter extends AbstractParameter {
+    type?: Exclude<AbstractParameter["type"], SpecialParameters["type"]>;
+}
+export type Parameter = BaseParameter | SpecialParameters;
+type OptionalParameterType<P extends AbstractParameter> = P["required"] extends false ? undefined : never;
+type StringParameterType<P> = P extends StringParameter ? (P extends {
+    enum?: Array<infer E>;
+} ? E : string) : never;
+type ObjectParameterType<P> = P extends ObjectParameter ? (P extends {
+    attributes?: infer Attributes extends Parameter[];
+} ? MappedParameterTypes<Attributes> : object) : never;
+type ObjectArrayParameterType<P> = P extends ObjectArrayParameter ? (P extends {
+    attributes?: infer Attributes extends Parameter[];
+} ? MappedParameterTypes<Attributes>[] : any[]) : never;
+type MappedTypeOrString<T> = T extends keyof TypeMap ? TypeMap[T] : string;
+type BaseParameterType<P extends AbstractParameter> = P extends {
+    type: infer T;
+} ? (T extends BaseParameter["type"] ? MappedTypeOrString<T> : never) : string;
+export type MappedParameterTypes<T extends Parameter[] | [] = []> = T extends [] ? Record<string, any> : {
+    [P in T[number] as P["name"]]: OptionalParameterType<P> | StringParameterType<P> | ObjectParameterType<P> | ObjectArrayParameterType<P> | BaseParameterType<P>;
+};
+export type Action<T extends Parameter[] | [] = []> = {
+    name: string;
+    description?: string;
+    parameters?: T;
+    handler?: T extends [] ? () => any | Promise<any> : (args: MappedParameterTypes<T>, context?: any) => any | Promise<any>;
+    returnDirect?: boolean;
+    callbackMessage?: () => Message[];
+};
+export {};

package/dist/tool/copilotkit-actions.js

@@ -0,0 +1 @@
+export {};

package/dist/tool/createTool.d.ts

@@ -0,0 +1,47 @@
+import { z, ZodRawShape, ZodTypeAny } from "zod";
+import { Action, Parameter } from "./copilotkit-actions";
+import { Message } from "@langchain/langgraph-sdk";
+export interface UnionTool<Args extends ZodRawShape> {
+    name: string;
+    description: string;
+    parameters: Args;
+    /** 是否直接返回工具结果，而不是通过消息返回 */
+    returnDirect?: boolean;
+    execute: ToolCallback<Args>;
+    /** 工具执行成功后触发的附加消息 */
+    callbackMessage?: (result: CallToolResult) => Message[];
+}
+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 declare const createTool: <Args extends ZodRawShape>(tool: UnionTool<Args>) => UnionTool<Args>;
+/** 提供一种兼容 copilotkit 的定义方式，简化定义形式
+ * 来自 copilotkit 的 frontend action
+ */
+export declare const createFETool: <const T extends Parameter[], Args extends ZodRawShape>(tool: Action<T>) => UnionTool<Args>;
+export declare const createJSONDefineTool: <Args extends ZodRawShape>(tool: UnionTool<Args>) => {
+    name: string;
+    description: string;
+    parameters: import("zod-to-json-schema").JsonSchema7Type & {
+        $schema?: string | undefined;
+        definitions?: {
+            [key: string]: import("zod-to-json-schema").JsonSchema7Type;
+        } | undefined;
+    };
+};
+export declare const createMCPTool: <Args extends ZodRawShape>(tool: UnionTool<Args>) => (string | Args | ((args: z.objectOutputType<Args, ZodTypeAny>) => Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+    isError?: undefined;
+} | {
+    content: {
+        type: string;
+        text: string;
+    }[];
+    isError: boolean;
+}>))[];

package/dist/tool/createTool.js

@@ -0,0 +1,61 @@
+import { actionParametersToJsonSchema, convertJsonSchemaToZodRawShape } from "./utils";
+import { z } from "zod";
+import { zodToJsonSchema } from "zod-to-json-schema";
+/** 用于格式校验 */
+export const createTool = (tool) => {
+    return tool;
+};
+/** 提供一种兼容 copilotkit 的定义方式，简化定义形式
+ * 来自 copilotkit 的 frontend action
+ */
+export const createFETool = (tool) => {
+    return {
+        name: tool.name,
+        description: tool.description || "",
+        parameters: convertJsonSchemaToZodRawShape(actionParametersToJsonSchema(tool.parameters || [])),
+        returnDirect: tool.returnDirect,
+        callbackMessage: tool.callbackMessage,
+        async execute(args, context) {
+            var _a;
+            try {
+                const result = await ((_a = tool.handler) === null || _a === void 0 ? void 0 : _a.call(tool, 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 = (tool) => {
+    return {
+        name: tool.name,
+        description: tool.description,
+        parameters: zodToJsonSchema(z.object(tool.parameters)),
+    };
+};
+export const createMCPTool = (tool) => {
+    return [
+        tool.name,
+        tool.description,
+        tool.parameters,
+        async (args) => {
+            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 };
+            }
+        },
+    ];
+};

package/dist/tool/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./createTool";
+export * from "./copilotkit-actions";

package/dist/tool/index.js

@@ -0,0 +1,2 @@
+export * from "./createTool";
+export * from "./copilotkit-actions";

package/dist/tool/utils.d.ts

@@ -0,0 +1,36 @@
+/**
+ * copy and modify from copilotkit
+ * https://github.com/copilotkit/copilotkit
+ *
+ * MIT License
+ */
+import { z, ZodRawShape } from "zod";
+import { Parameter } from "./copilotkit-actions";
+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 declare function actionParametersToJsonSchema(actionParameters: Parameter[]): JSONSchema;
+export declare function convertJsonSchemaToZodRawShape(jsonSchema: any): ZodRawShape;
+export declare function convertJsonSchemaToZodSchema(jsonSchema: any, required: boolean): z.ZodSchema;

package/dist/tool/utils.js

@@ -0,0 +1,120 @@
+/**
+ * copy and modify from copilotkit
+ * https://github.com/copilotkit/copilotkit
+ *
+ * MIT License
+ */
+import { z } from "zod";
+export function actionParametersToJsonSchema(actionParameters) {
+    // Create the parameters object based on the argumentAnnotations
+    let parameters = {};
+    for (let parameter of actionParameters || []) {
+        parameters[parameter.name] = convertAttribute(parameter);
+    }
+    let requiredParameterNames = [];
+    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) {
+    var _a, _b, _c;
+    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 = (_a = attribute.attributes) === null || _a === void 0 ? void 0 : _a.reduce((acc, attr) => {
+                acc[attr.name] = convertAttribute(attr);
+                return acc;
+            }, {});
+            const required = (_b = attribute.attributes) === null || _b === void 0 ? void 0 : _b.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 ((_c = attribute.type) === null || _c === void 0 ? void 0 : _c.endsWith("[]")) {
+                const itemType = attribute.type.slice(0, -2);
+                return {
+                    type: "array",
+                    items: { type: itemType },
+                    description: attribute.description,
+                };
+            }
+            // Fallback for undefined type or any other unexpected type
+            return {
+                type: "string",
+                description: attribute.description,
+            };
+    }
+}
+export function convertJsonSchemaToZodRawShape(jsonSchema) {
+    const spec = {};
+    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, required) {
+    if (jsonSchema.type === "object") {
+        const spec = {};
+        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/dist/ui-store/UnionStore.d.ts

@@ -0,0 +1,11 @@
+import { PreinitializedWritableAtom, StoreValue } from "nanostores";
+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"];
+export declare 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>;

package/dist/ui-store/UnionStore.js

@@ -0,0 +1,9 @@
+export const useUnionStore = (store, useStore) => {
+    const data = Object.fromEntries(Object.entries(store.data).map(([key, value]) => {
+        return [key, useStore(value)];
+    }));
+    return {
+        ...data,
+        ...store.mutations,
+    };
+};

package/dist/ui-store/createChatStore.d.ts

@@ -0,0 +1,43 @@
+import { LangGraphClient, LangGraphClientConfig, RenderMessage } from "../LangGraphClient";
+import { Message, Thread } from "@langchain/langgraph-sdk";
+export declare const formatTime: (date: Date) => string;
+export declare const formatTokens: (tokens: number) => string;
+export declare const getMessageContent: (content: any) => string;
+export declare const createChatStore: (initClientName: string, config: LangGraphClientConfig, context?: {
+    onInit?: (client: LangGraphClient) => void;
+}) => {
+    data: {
+        client: import("nanostores").PreinitializedWritableAtom<LangGraphClient | null> & object;
+        renderMessages: import("nanostores").PreinitializedWritableAtom<RenderMessage[]> & object;
+        userInput: import("nanostores").PreinitializedWritableAtom<string> & object;
+        loading: import("nanostores").PreinitializedWritableAtom<boolean> & object;
+        inChatError: import("nanostores").PreinitializedWritableAtom<string | null> & object;
+        currentAgent: import("nanostores").PreinitializedWritableAtom<string> & object;
+        collapsedTools: import("nanostores").PreinitializedWritableAtom<string[]> & object;
+        showHistory: import("nanostores").PreinitializedWritableAtom<boolean> & object;
+        historyList: import("nanostores").PreinitializedWritableAtom<Thread<{
+            messages: Message[];
+        }>[]> & object;
+        currentChatId: import("nanostores").PreinitializedWritableAtom<string | null> & object;
+    };
+    mutations: {
+        initClient: () => Promise<void>;
+        sendMessage: () => Promise<void>;
+        interruptMessage: () => void;
+        toggleToolCollapse: (toolId: string) => void;
+        toggleHistoryVisible: () => void;
+        refreshHistoryList: () => Promise<void>;
+        addToHistory: (thread: Thread<{
+            messages: Message[];
+        }>) => void;
+        setUserInput(input: string): void;
+        setCurrentAgent(agent: string): Promise<void>;
+        createNewChat(): void;
+        toHistoryChat(thread: Thread<{
+            messages: Message[];
+        }>): void;
+        deleteHistoryChat(thread: Thread<{
+            messages: Message[];
+        }>): Promise<void>;
+    };
+};