@langgraph-js/sdk 1.6.4 → 1.7.0

package/dist/server/tools/sequential-thinking.d.ts

@@ -0,0 +1,52 @@
+import { z } from "zod";
+export declare const SequentialThinkingTool: import("@langchain/core/tools").DynamicStructuredTool<z.ZodObject<{
+    thought: z.ZodString;
+    nextThoughtNeeded: z.ZodBoolean;
+    thoughtNumber: z.ZodNumber;
+    totalThoughts: z.ZodNumber;
+    isRevision: z.ZodOptional<z.ZodBoolean>;
+    revisesThought: z.ZodOptional<z.ZodNumber>;
+    branchFromThought: z.ZodOptional<z.ZodNumber>;
+    branchId: z.ZodOptional<z.ZodString>;
+    needsMoreThoughts: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    thought: string;
+    nextThoughtNeeded: boolean;
+    thoughtNumber: number;
+    totalThoughts: number;
+    isRevision?: boolean | undefined;
+    revisesThought?: number | undefined;
+    branchFromThought?: number | undefined;
+    branchId?: string | undefined;
+    needsMoreThoughts?: boolean | undefined;
+}, {
+    thought: string;
+    nextThoughtNeeded: boolean;
+    thoughtNumber: number;
+    totalThoughts: number;
+    isRevision?: boolean | undefined;
+    revisesThought?: number | undefined;
+    branchFromThought?: number | undefined;
+    branchId?: string | undefined;
+    needsMoreThoughts?: boolean | undefined;
+}>, {
+    thought: string;
+    nextThoughtNeeded: boolean;
+    thoughtNumber: number;
+    totalThoughts: number;
+    isRevision?: boolean | undefined;
+    revisesThought?: number | undefined;
+    branchFromThought?: number | undefined;
+    branchId?: string | undefined;
+    needsMoreThoughts?: boolean | undefined;
+}, {
+    thought: string;
+    nextThoughtNeeded: boolean;
+    thoughtNumber: number;
+    totalThoughts: number;
+    isRevision?: boolean | undefined;
+    revisesThought?: number | undefined;
+    branchFromThought?: number | undefined;
+    branchId?: string | undefined;
+    needsMoreThoughts?: boolean | undefined;
+}, string>;

package/dist/server/tools/sequential-thinking.js

@@ -0,0 +1,69 @@
+import { tool } from "@langchain/core/tools";
+import { z } from "zod";
+const schema = z.object({
+    thought: z.string().describe("Your current thinking step"),
+    nextThoughtNeeded: z.boolean().describe("Whether another thought step is needed"),
+    thoughtNumber: z.number().min(1).describe("Current thought number"),
+    totalThoughts: z.number().min(1).describe("Estimated total thoughts needed"),
+    isRevision: z.boolean().optional().describe("Whether this revises previous thinking"),
+    revisesThought: z.number().min(1).optional().describe("Which thought is being reconsidered"),
+    branchFromThought: z.number().min(1).optional().describe("Branching point thought number"),
+    branchId: z.string().optional().describe("Branch identifier"),
+    needsMoreThoughts: z.boolean().optional().describe("If more thoughts are needed"),
+});
+// 存储思考历史
+const thoughtHistory = [];
+const branches = {};
+export const SequentialThinkingTool = tool(async (args) => {
+    try {
+        if (args.thoughtNumber > args.totalThoughts) {
+            args.totalThoughts = args.thoughtNumber;
+        }
+        thoughtHistory.push(args);
+        if (args.branchFromThought && args.branchId) {
+            if (!branches[args.branchId]) {
+                branches[args.branchId] = [];
+            }
+            branches[args.branchId].push(args);
+        }
+        return JSON.stringify({
+            thoughtNumber: args.thoughtNumber,
+            totalThoughts: args.totalThoughts,
+            nextThoughtNeeded: args.nextThoughtNeeded,
+            branches: Object.keys(branches),
+            thoughtHistoryLength: thoughtHistory.length,
+        }, null, 2);
+    }
+    catch (error) {
+        return JSON.stringify({
+            error: error instanceof Error ? error.message : String(error),
+            status: "failed",
+        }, null, 2);
+    }
+}, {
+    name: "sequential-thinking",
+    description: `A detailed tool for dynamic and reflective problem-solving through thoughts.
+This tool helps analyze problems through a flexible thinking process that can adapt and evolve.
+Each thought can build on, question, or revise previous insights as understanding deepens.
+
+When to use this tool:
+- Breaking down complex problems into steps
+- Planning and design with room for revision
+- Analysis that might need course correction
+- Problems where the full scope might not be clear initially
+- Problems that require a multi-step solution
+- Tasks that need to maintain context over multiple steps
+- Situations where irrelevant information needs to be filtered out
+
+Key features:
+- You can adjust total_thoughts up or down as you progress
+- You can question or revise previous thoughts
+- You can add more thoughts even after reaching what seemed like the end
+- You can express uncertainty and explore alternative approaches
+- Not every thought needs to build linearly - you can branch or backtrack
+- Generates a solution hypothesis
+- Verifies the hypothesis based on the Chain of Thought steps
+- Repeats the process until satisfied
+- Provides a correct answer`,
+    schema,
+});

package/dist/server/utils.d.ts

@@ -0,0 +1,3 @@
+import { BaseMessage, HumanMessage } from "@langchain/core/messages";
+export declare const getTextMessageContent: (message: BaseMessage) => string;
+export declare function getLastHumanMessage(messages: BaseMessage[]): HumanMessage | undefined;

package/dist/server/utils.js

@@ -0,0 +1,24 @@
+import { isHumanMessage } from "@langchain/core/messages";
+export const getTextMessageContent = (message) => {
+    if (typeof message.content === "string") {
+        return message.content;
+    }
+    else {
+        return message.content
+            .filter((i) => i.type === "text")
+            .map((i) => i.text)
+            .join("\n");
+    }
+};
+export function getLastHumanMessage(messages) {
+    // 从后往前遍历消息列表
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const message = messages[i];
+        // 检查消息是否是 HumanMessage 的实例
+        if (isHumanMessage(message)) {
+            return message;
+        }
+    }
+    // 如果没有找到 HumanMessage，则返回 undefined
+    return undefined;
+}

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

@@ -47,6 +47,7 @@ export declare const createChatStore: (initClientName: string, config: LangGraph
         currentNodeName: import("nanostores").PreinitializedWritableAtom<string> & object;
     };
     mutations: {
+        isFELocking(): boolean | undefined;
         initClient: () => Promise<LangGraphClient>;
         sendMessage: (message?: Message[], extraData?: SendMessageOptions) => Promise<void>;
         stopGeneration: () => void;

package/dist/ui-store/createChatStore.js

@@ -215,6 +215,10 @@ export const createChatStore = (initClientName, config, context = {}) => {
             currentNodeName,
         },
         mutations: {
+            isFELocking() {
+                var _a;
+                return (_a = client.get()) === null || _a === void 0 ? void 0 : _a.isFELocking(renderMessages.get());
+            },
             initClient,
             sendMessage,
             stopGeneration,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langgraph-js/sdk",
-  "version": "1.6.4",
+  "version": "1.7.0",
   "description": "The UI SDK for LangGraph - seamlessly integrate your AI agents with frontend interfaces",
   "main": "dist/index.js",
   "type": "module",