@langgraph-js/sdk 1.1.0 → 1.1.1

package/dist/LangGraphClient.d.ts

@@ -0,0 +1,101 @@
+import { Client, Thread, Message, Assistant, HumanMessage, ToolMessage, Command } from "@langchain/langgraph-sdk";
+import { ToolManager } from "./ToolManager";
+import { CallToolResult } from "./tool";
+import { AsyncCallerParams } from "@langchain/langgraph-sdk/dist/utils/async_caller";
+export type RenderMessage = Message & {
+    /** 工具入参 ，聚合而来*/
+    tool_input?: string;
+    additional_kwargs?: {
+        done?: boolean;
+        tool_calls?: {
+            function: {
+                arguments: string;
+            };
+        }[];
+    };
+    usage_metadata?: {
+        total_tokens: number;
+        input_tokens: number;
+        output_tokens: number;
+    };
+    response_metadata?: {
+        create_time: string;
+    };
+    /** 耗时 */
+    spend_time?: number;
+    /** 渲染时的唯一 id，聚合而来*/
+    unique_id?: string;
+};
+export interface LangGraphClientConfig {
+    apiUrl?: string;
+    apiKey?: string;
+    callerOptions?: AsyncCallerParams;
+    timeoutMs?: number;
+    defaultHeaders?: Record<string, string | null | undefined>;
+}
+export declare class StreamingMessageType {
+    static isUser(m: Message): m is HumanMessage;
+    static isTool(m: Message): m is ToolMessage;
+    static isAssistant(m: Message): boolean;
+    static isToolAssistant(m: Message): any;
+}
+type StreamingUpdateEvent = {
+    type: "message" | "value" | "update" | "error" | "thread" | "done";
+    data: any;
+};
+type StreamingUpdateCallback = (event: StreamingUpdateEvent) => void;
+export declare class LangGraphClient extends Client {
+    private currentAssistant;
+    private currentThread;
+    private streamingCallbacks;
+    tools: ToolManager;
+    stopController: AbortController | null;
+    constructor(config: LangGraphClientConfig);
+    availableAssistants: Assistant[];
+    private listAssistants;
+    initAssistant(agentName: string): Promise<void>;
+    createThread({ threadId, }?: {
+        threadId?: string;
+    }): Promise<Thread<import("@langchain/langgraph-sdk").DefaultValues>>;
+    listThreads<T>(): Promise<Thread<T>[]>;
+    /** 从历史中恢复数据 */
+    resetThread(agent: string, threadId: string): Promise<void>;
+    streamingMessage: RenderMessage[];
+    /** 图发过来的更新信息 */
+    graphMessages: RenderMessage[];
+    cloneMessage(message: Message): Message;
+    private replaceMessageWithValuesMessage;
+    /** 用于 UI 中的流式渲染中的消息 */
+    get renderMessage(): RenderMessage[];
+    attachInfoForMessage(result: RenderMessage[]): RenderMessage[];
+    composeToolMessages(messages: RenderMessage[]): RenderMessage[];
+    get tokenCounter(): {
+        total_tokens: number;
+        input_tokens: number;
+        output_tokens: number;
+    };
+    onStreamingUpdate(callback: StreamingUpdateCallback): () => void;
+    private emitStreamingUpdate;
+    graphState: any;
+    currentRun?: {
+        run_id: string;
+    };
+    cancelRun(): void;
+    sendMessage(input: string | Message[], { extraParams, _debug, command }?: {
+        extraParams?: Record<string, any>;
+        _debug?: {
+            streamResponse?: any;
+        };
+        command?: Command;
+    }): Promise<any[]>;
+    private runFETool;
+    private callFETool;
+    /** 恢复消息，当中断流时使用 */
+    resume(result: CallToolResult): Promise<any[]>;
+    /** 完成工具等待 */
+    doneFEToolWaiting(id: string, result: CallToolResult): void;
+    getCurrentThread(): Thread<import("@langchain/langgraph-sdk").DefaultValues> | null;
+    getCurrentAssistant(): Assistant | null;
+    reset(): Promise<void>;
+}
+export {};

package/dist/LangGraphClient.js

@@ -11,20 +11,25 @@ export class StreamingMessageType {
         return m.type === "ai" && !this.isToolAssistant(m);
     }
     static isToolAssistant(m) {
+        var _a, _b;
         /** @ts-ignore */
-        return m.type === "ai" && (m.tool_calls?.length || m.tool_call_chunks?.length);
+        return m.type === "ai" && (((_a = m.tool_calls) === null || _a === void 0 ? void 0 : _a.length) || ((_b = m.tool_call_chunks) === null || _b === void 0 ? void 0 : _b.length));
     }
 }
 export class LangGraphClient extends Client {
-    currentAssistant = null;
-    currentThread = null;
-    streamingCallbacks = new Set();
-    tools = new ToolManager();
-    stopController = null;
     constructor(config) {
         super(config);
+        this.currentAssistant = null;
+        this.currentThread = null;
+        this.streamingCallbacks = new Set();
+        this.tools = new ToolManager();
+        this.stopController = null;
+        this.availableAssistants = [];
+        this.streamingMessage = [];
+        /** 图发过来的更新信息 */
+        this.graphMessages = [];
+        this.graphState = {};
     }
-    availableAssistants = [];
     listAssistants() {
         return this.assistants.search({
             metadata: null,
@@ -84,9 +89,6 @@ export class LangGraphClient extends Client {
             },
         });
     }
-    streamingMessage = [];
-    /** 图发过来的更新信息 */
-    graphMessages = [];
     cloneMessage(message) {
         return JSON.parse(JSON.stringify(message));
     }
@@ -104,6 +106,7 @@ export class LangGraphClient extends Client {
     }
     /** 用于 UI 中的流式渲染中的消息 */
     get renderMessage() {
+        var _a;
         const previousMessage = new Map();
         const result = [];
         const inputMessages = [...this.graphMessages, ...this.streamingMessage];
@@ -123,13 +126,14 @@ export class LangGraphClient extends Client {
                 // 记录这个 id 的消息，并添加到结果中
                 previousMessage.set(message.id, m);
                 /** @ts-ignore */
-                const tool_calls = m.tool_calls?.length ? m.tool_calls : m.tool_call_chunks;
+                const tool_calls = ((_a = m.tool_calls) === null || _a === void 0 ? void 0 : _a.length) ? m.tool_calls : m.tool_call_chunks;
                 const new_tool_calls = tool_calls.map((tool, index) => {
+                    var _a;
                     return this.replaceMessageWithValuesMessage({
                         type: "tool",
                         additional_kwargs: {},
                         /** @ts-ignore */
-                        tool_input: m.additional_kwargs?.tool_calls[index].function.arguments,
+                        tool_input: (_a = m.additional_kwargs) === null || _a === void 0 ? void 0 : _a.tool_calls[index].function.arguments,
                         id: tool.id,
                         name: tool.name,
                         response_metadata: {},
@@ -154,13 +158,14 @@ export class LangGraphClient extends Client {
         return this.attachInfoForMessage(this.composeToolMessages(result));
     }
     attachInfoForMessage(result) {
+        var _a, _b, _c;
         let lastMessage = null;
         for (const message of result) {
-            const createTime = message.response_metadata?.create_time || "";
+            const createTime = ((_a = message.response_metadata) === null || _a === void 0 ? void 0 : _a.create_time) || "";
             // 用长度作为渲染 id，长度变了就要重新渲染
             message.unique_id = message.id + JSON.stringify(message.content).length;
-            message.spend_time = new Date(createTime).getTime() - new Date(lastMessage?.response_metadata?.create_time || createTime).getTime();
-            if (!message.usage_metadata && message.response_metadata?.usage) {
+            message.spend_time = new Date(createTime).getTime() - new Date(((_b = lastMessage === null || lastMessage === void 0 ? void 0 : lastMessage.response_metadata) === null || _b === void 0 ? void 0 : _b.create_time) || createTime).getTime();
+            if (!message.usage_metadata && ((_c = message.response_metadata) === null || _c === void 0 ? void 0 : _c.usage)) {
                 const usage = message.response_metadata.usage;
                 message.usage_metadata = {
                     input_tokens: usage.prompt_tokens,
@@ -173,13 +178,14 @@ export class LangGraphClient extends Client {
         return result;
     }
     composeToolMessages(messages) {
+        var _a;
         const result = [];
         const assistantToolMessages = new Map();
         const toolParentMessage = new Map();
         for (const message of messages) {
             if (StreamingMessageType.isToolAssistant(message)) {
                 /** @ts-ignore 只有 tool_call_chunks 的 args 才是文本 */
-                message.tool_call_chunks?.forEach((element) => {
+                (_a = message.tool_call_chunks) === null || _a === void 0 ? void 0 : _a.forEach((element) => {
                     assistantToolMessages.set(element.id, element);
                     toolParentMessage.set(element.id, message);
                 });
@@ -210,13 +216,14 @@ export class LangGraphClient extends Client {
     }
     get tokenCounter() {
         return this.graphMessages.reduce((acc, message) => {
+            var _a, _b, _c, _d, _e;
             if (message.usage_metadata) {
-                acc.total_tokens += message.usage_metadata?.total_tokens || 0;
-                acc.input_tokens += message.usage_metadata?.input_tokens || 0;
-                acc.output_tokens += message.usage_metadata?.output_tokens || 0;
+                acc.total_tokens += ((_a = message.usage_metadata) === null || _a === void 0 ? void 0 : _a.total_tokens) || 0;
+                acc.input_tokens += ((_b = message.usage_metadata) === null || _b === void 0 ? void 0 : _b.input_tokens) || 0;
+                acc.output_tokens += ((_c = message.usage_metadata) === null || _c === void 0 ? void 0 : _c.output_tokens) || 0;
             }
-            else if (message.response_metadata?.usage) {
-                const usage = message.response_metadata?.usage;
+            else if ((_d = message.response_metadata) === null || _d === void 0 ? void 0 : _d.usage) {
+                const usage = (_e = message.response_metadata) === null || _e === void 0 ? void 0 : _e.usage;
                 acc.total_tokens += usage.total_tokens || 0;
                 acc.input_tokens += usage.prompt_tokens || 0;
                 acc.output_tokens += usage.completion_tokens || 0;
@@ -237,10 +244,9 @@ export class LangGraphClient extends Client {
     emitStreamingUpdate(event) {
         this.streamingCallbacks.forEach((callback) => callback(event));
     }
-    graphState = {};
-    currentRun;
     cancelRun() {
-        if (this.currentThread?.thread_id && this.currentRun?.run_id) {
+        var _a, _b;
+        if (((_a = this.currentThread) === null || _a === void 0 ? void 0 : _a.thread_id) && ((_b = this.currentRun) === null || _b === void 0 ? void 0 : _b.run_id)) {
             this.runs.cancel(this.currentThread.thread_id, this.currentRun.run_id);
         }
     }
@@ -268,7 +274,7 @@ export class LangGraphClient extends Client {
                     content: input,
                 },
             ];
-        const streamResponse = _debug?.streamResponse ||
+        const streamResponse = (_debug === null || _debug === void 0 ? void 0 : _debug.streamResponse) ||
             this.runs.stream(this.currentThread.thread_id, this.currentAssistant.assistant_id, {
                 input: { ...this.graphState, ...(extraParams || {}), messages: messagesToSend, fe_tools: this.tools.toJSON() },
                 streamMode: ["messages", "values"],
@@ -300,7 +306,7 @@ export class LangGraphClient extends Client {
             else if (chunk.event.startsWith("values")) {
                 const data = chunk.data;
                 if (data.messages) {
-                    const isResume = !!command?.resume;
+                    const isResume = !!(command === null || command === void 0 ? void 0 : command.resume);
                     const isLongerThanLocal = data.messages.length >= this.graphMessages.length;
                     // resume 情况下，长度低于前端 message 的统统不接受
                     if (!isResume || (isResume && isLongerThanLocal)) {
@@ -329,10 +335,11 @@ export class LangGraphClient extends Client {
         return streamRecord;
     }
     runFETool() {
+        var _a;
         const data = this.graphMessages;
         const lastMessage = data[data.length - 1];
         // 如果最后一条消息是前端工具消息，则调用工具
-        if (lastMessage.type === "ai" && lastMessage.tool_calls?.length) {
+        if (lastMessage.type === "ai" && ((_a = lastMessage.tool_calls) === null || _a === void 0 ? void 0 : _a.length)) {
             const result = lastMessage.tool_calls.map((tool) => {
                 if (this.tools.getTool(tool.name)) {
                     const toolMessage = {
@@ -364,8 +371,9 @@ export class LangGraphClient extends Client {
     }
     /** 完成工具等待 */
     doneFEToolWaiting(id, result) {
+        var _a;
         const done = this.tools.doneWaiting(id, result);
-        if (!done && this.currentThread?.status === "interrupted") {
+        if (!done && ((_a = this.currentThread) === null || _a === void 0 ? void 0 : _a.status) === "interrupted") {
             this.resume(result);
         }
     }
@@ -376,7 +384,8 @@ export class LangGraphClient extends Client {
         return this.currentAssistant;
     }
     async reset() {
-        await this.initAssistant(this.currentAssistant?.name);
+        var _a;
+        await this.initAssistant((_a = this.currentAssistant) === null || _a === void 0 ? void 0 : _a.name);
         this.currentThread = null;
         this.graphState = {};
         this.graphMessages = [];

package/dist/SpendTime.d.ts

@@ -0,0 +1,9 @@
+export declare class SpendTime {
+    private timeCounter;
+    start(key: string): void;
+    end(key: string): void;
+    setSpendTime(key: string): void;
+    getStartTime(key: string): Date;
+    getEndTime(key: string): Date;
+    getSpendTime(key: string): number;
+}

package/dist/SpendTime.js

@@ -1,10 +1,13 @@
 export class SpendTime {
-    timeCounter = new Map();
+    constructor() {
+        this.timeCounter = new Map();
+    }
     start(key) {
         this.timeCounter.set(key, [new Date()]);
     }
     end(key) {
-        this.timeCounter.set(key, [this.timeCounter.get(key)?.[0] || new Date(), new Date()]);
+        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)) {
@@ -15,10 +18,12 @@ export class SpendTime {
         }
     }
     getStartTime(key) {
-        return this.timeCounter.get(key)?.[0] || new Date();
+        var _a;
+        return ((_a = this.timeCounter.get(key)) === null || _a === void 0 ? void 0 : _a[0]) || new Date();
     }
     getEndTime(key) {
-        return this.timeCounter.get(key)?.[1] || new Date();
+        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()];

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

@@ -1,6 +1,10 @@
 import { createJSONDefineTool } from "./tool/createTool";
 export class ToolManager {
-    tools = new Map();
+    constructor() {
+        this.tools = new Map();
+        // === 专门为前端设计的异步触发结构
+        this.waitingMap = new Map();
+    }
     /**
      * 注册一个工具
      * @param tool 要注册的工具
@@ -57,8 +61,6 @@ export class ToolManager {
     toJSON() {
         return Array.from(this.tools.values()).map((i) => createJSONDefineTool(i));
     }
-    // === 专门为前端设计的异步触发结构
-    waitingMap = new Map();
     doneWaiting(id, value) {
         if (this.waitingMap.has(id)) {
             this.waitingMap.get(id)(value);

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/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/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

@@ -16,8 +16,9 @@ export const createFETool = (tool) => {
         returnDirect: tool.returnDirect,
         callbackMessage: tool.callbackMessage,
         async execute(args, context) {
+            var _a;
             try {
-                const result = await tool.handler?.(args, context);
+                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 }];
                 }

package/dist/tool/index.d.ts

@@ -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

@@ -25,6 +25,7 @@ export function actionParametersToJsonSchema(actionParameters) {
     };
 }
 function convertAttribute(attribute) {
+    var _a, _b, _c;
     switch (attribute.type) {
         case "string":
             return {
@@ -40,11 +41,11 @@ function convertAttribute(attribute) {
             };
         case "object":
         case "object[]":
-            const properties = attribute.attributes?.reduce((acc, attr) => {
+            const properties = (_a = attribute.attributes) === null || _a === void 0 ? void 0 : _a.reduce((acc, attr) => {
                 acc[attr.name] = convertAttribute(attr);
                 return acc;
             }, {});
-            const required = attribute.attributes?.filter((attr) => attr.required !== false).map((attr) => attr.name);
+            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",
@@ -64,7 +65,7 @@ function convertAttribute(attribute) {
             };
         default:
             // Handle arrays of primitive types and undefined attribute.type
-            if (attribute.type?.endsWith("[]")) {
+            if ((_c = attribute.type) === null || _c === void 0 ? void 0 : _c.endsWith("[]")) {
                 const itemType = attribute.type.slice(0, -2);
                 return {
                     type: "array",

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/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>;
+    };
+};

package/dist/ui-store/createChatStore.js

@@ -35,11 +35,13 @@ export const createChatStore = (initClientName, config, context = {}) => {
     const currentAgent = atom(initClientName);
     const currentChatId = atom(null);
     const initClient = async () => {
+        var _a;
         const newClient = new LangGraphClient(config);
         await newClient.initAssistant(currentAgent.get());
         // 不再需要创建，sendMessage 会自动创建
         // await newClient.createThread();
         newClient.onStreamingUpdate((event) => {
+            var _a;
             if (event.type === "thread" || event.type === "done") {
                 // console.log(event.data);
                 // 创建新会话时，需要自动刷新历史面板
@@ -47,27 +49,29 @@ export const createChatStore = (initClientName, config, context = {}) => {
             }
             if (event.type === "error") {
                 loading.set(false);
-                inChatError.set(event.data?.message || "发生错误");
+                inChatError.set(((_a = event.data) === null || _a === void 0 ? void 0 : _a.message) || "发生错误");
             }
             console.log(newClient.renderMessage);
             renderMessages.set(newClient.renderMessage);
         });
-        context.onInit?.(newClient);
+        (_a = context.onInit) === null || _a === void 0 ? void 0 : _a.call(context, newClient);
         // newClient.tools.bindTools([fileTool, askUserTool]);
         newClient.graphState = {};
         client.set(newClient);
     };
     const sendMessage = async () => {
+        var _a;
         if (!userInput.get().trim() || loading.get() || !client.get())
             return;
         loading.set(true);
         inChatError.set(null);
-        await client.get()?.sendMessage(userInput.get());
+        await ((_a = client.get()) === null || _a === void 0 ? void 0 : _a.sendMessage(userInput.get()));
         userInput.set("");
         loading.set(false);
     };
     const interruptMessage = () => {
-        client.get()?.cancelRun();
+        var _a;
+        (_a = client.get()) === null || _a === void 0 ? void 0 : _a.cancelRun();
     };
     const toggleToolCollapse = (toolId) => {
         const prev = collapsedTools.get();
@@ -78,10 +82,11 @@ export const createChatStore = (initClientName, config, context = {}) => {
     };
     const historyList = atom([]);
     const refreshHistoryList = async () => {
+        var _a;
         if (!client.get())
             return;
         try {
-            const response = await client.get()?.listThreads();
+            const response = await ((_a = client.get()) === null || _a === void 0 ? void 0 : _a.listThreads());
             historyList.set(response || []);
         }
         catch (error) {
@@ -123,13 +128,16 @@ export const createChatStore = (initClientName, config, context = {}) => {
                 });
             },
             createNewChat() {
-                client.get()?.reset();
+                var _a;
+                (_a = client.get()) === null || _a === void 0 ? void 0 : _a.reset();
             },
             toHistoryChat(thread) {
-                client.get()?.resetThread(thread.metadata?.graph_id, thread.thread_id);
+                var _a, _b;
+                (_a = client.get()) === null || _a === void 0 ? void 0 : _a.resetThread((_b = thread.metadata) === null || _b === void 0 ? void 0 : _b.graph_id, thread.thread_id);
             },
             async deleteHistoryChat(thread) {
-                await client.get()?.threads.delete(thread.thread_id);
+                var _a;
+                await ((_a = client.get()) === null || _a === void 0 ? void 0 : _a.threads.delete(thread.thread_id));
                 await refreshHistoryList();
             },
         },

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

@@ -0,0 +1,2 @@
+export * from "./createChatStore";
+export * from "./UnionStore";

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@langgraph-js/sdk",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "The UI SDK for LangGraph - seamlessly integrate your AI agents with frontend interfaces",
-  "main": "src/index.ts",
+  "main": "dist/index.js",
   "type": "module",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",

package/tsconfig.json

@@ -11,7 +11,7 @@
         // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
 
         /* Language and Environment */
-        "target": "ESNext" /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */,
+        "target": "ES2019" /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */,
         // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
         // "jsx": "preserve",                                /* Specify what JSX code is generated. */
         // "experimentalDecorators": true,                   /* Enable experimental support for legacy experimental decorators. */
@@ -51,7 +51,7 @@
         // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
 
         /* Emit */
-        // "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
+        "declaration": true /* Generate .d.ts files from TypeScript and JavaScript files in your project. */,
         // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
         // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
         // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */