@assistant-ui/react-langgraph 0.2.5 → 0.2.6

package/dist/index.mjs

@@ -1,3 +1,133 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/.pnpm/secure-json-parse@3.0.2/node_modules/secure-json-parse/index.js
+var require_secure_json_parse = __commonJS({
+  "../../node_modules/.pnpm/secure-json-parse@3.0.2/node_modules/secure-json-parse/index.js"(exports, module) {
+    "use strict";
+    var hasBuffer = typeof Buffer !== "undefined";
+    var suspectProtoRx = /"(?:_|\\u005[Ff])(?:_|\\u005[Ff])(?:p|\\u0070)(?:r|\\u0072)(?:o|\\u006[Ff])(?:t|\\u0074)(?:o|\\u006[Ff])(?:_|\\u005[Ff])(?:_|\\u005[Ff])"\s*:/;
+    var suspectConstructorRx = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/;
+    function _parse(text, reviver, options) {
+      if (options == null) {
+        if (reviver !== null && typeof reviver === "object") {
+          options = reviver;
+          reviver = void 0;
+        }
+      }
+      if (hasBuffer && Buffer.isBuffer(text)) {
+        text = text.toString();
+      }
+      if (text && text.charCodeAt(0) === 65279) {
+        text = text.slice(1);
+      }
+      const obj = JSON.parse(text, reviver);
+      if (obj === null || typeof obj !== "object") {
+        return obj;
+      }
+      const protoAction = options && options.protoAction || "error";
+      const constructorAction = options && options.constructorAction || "error";
+      if (protoAction === "ignore" && constructorAction === "ignore") {
+        return obj;
+      }
+      if (protoAction !== "ignore" && constructorAction !== "ignore") {
+        if (suspectProtoRx.test(text) === false && suspectConstructorRx.test(text) === false) {
+          return obj;
+        }
+      } else if (protoAction !== "ignore" && constructorAction === "ignore") {
+        if (suspectProtoRx.test(text) === false) {
+          return obj;
+        }
+      } else {
+        if (suspectConstructorRx.test(text) === false) {
+          return obj;
+        }
+      }
+      return filter(obj, { protoAction, constructorAction, safe: options && options.safe });
+    }
+    function filter(obj, { protoAction = "error", constructorAction = "error", safe } = {}) {
+      let next = [obj];
+      while (next.length) {
+        const nodes = next;
+        next = [];
+        for (const node of nodes) {
+          if (protoAction !== "ignore" && Object.prototype.hasOwnProperty.call(node, "__proto__")) {
+            if (safe === true) {
+              return null;
+            } else if (protoAction === "error") {
+              throw new SyntaxError("Object contains forbidden prototype property");
+            }
+            delete node.__proto__;
+          }
+          if (constructorAction !== "ignore" && Object.prototype.hasOwnProperty.call(node, "constructor") && Object.prototype.hasOwnProperty.call(node.constructor, "prototype")) {
+            if (safe === true) {
+              return null;
+            } else if (constructorAction === "error") {
+              throw new SyntaxError("Object contains forbidden prototype property");
+            }
+            delete node.constructor;
+          }
+          for (const key in node) {
+            const value = node[key];
+            if (value && typeof value === "object") {
+              next.push(value);
+            }
+          }
+        }
+      }
+      return obj;
+    }
+    function parse(text, reviver, options) {
+      const { stackTraceLimit } = Error;
+      Error.stackTraceLimit = 0;
+      try {
+        return _parse(text, reviver, options);
+      } finally {
+        Error.stackTraceLimit = stackTraceLimit;
+      }
+    }
+    function safeParse(text, reviver) {
+      const { stackTraceLimit } = Error;
+      Error.stackTraceLimit = 0;
+      try {
+        return _parse(text, reviver, { safe: true });
+      } catch (_e) {
+        return null;
+      } finally {
+        Error.stackTraceLimit = stackTraceLimit;
+      }
+    }
+    module.exports = parse;
+    module.exports.default = parse;
+    module.exports.parse = parse;
+    module.exports.safeParse = safeParse;
+    module.exports.scan = filter;
+  }
+});
+
 // src/useLangGraphRuntime.ts
 import { useEffect, useRef as useRef2, useState as useState2 } from "react";
 import {
@@ -7,7 +137,7 @@ import {
   useThreadListItemRuntime
 } from "@assistant-ui/react";
 
-// src/convertLangchainMessages.ts
+// src/convertLangChainMessages.ts
 var contentToParts = (content) => {
   if (typeof content === "string")
     return [{ type: "text", text: content }];
@@ -33,7 +163,7 @@ var contentToParts = (content) => {
     }
   }).filter((a) => a !== null);
 };
-var convertLangchainMessages = (message) => {
+var convertLangChainMessages = (message) => {
   switch (message.type) {
     case "system":
       return {
@@ -76,25 +206,59 @@ var convertLangchainMessages = (message) => {
 
 // src/useLangGraphMessages.ts
 import { useState, useCallback, useRef } from "react";
+import { v4 as uuidv42 } from "uuid";
+
+// src/LangGraphMessageAccumulator.ts
 import { v4 as uuidv4 } from "uuid";
+var LangGraphMessageAccumulator = class {
+  messagesMap = /* @__PURE__ */ new Map();
+  appendMessage;
+  constructor({
+    initialMessages = [],
+    appendMessage = (_, curr) => curr
+  } = {}) {
+    this.appendMessage = appendMessage;
+    this.addMessages(initialMessages);
+  }
+  ensureMessageId(message) {
+    return message.id ? message : { ...message, id: uuidv4() };
+  }
+  addMessages(newMessages) {
+    if (newMessages.length === 0) return this.getMessages();
+    for (const message of newMessages.map(this.ensureMessageId)) {
+      const previous = message.id ? this.messagesMap.get(message.id) : void 0;
+      this.messagesMap.set(
+        message.id ?? uuidv4(),
+        this.appendMessage(previous, message)
+      );
+    }
+    return this.getMessages();
+  }
+  getMessages() {
+    return [...this.messagesMap.values()];
+  }
+  clear() {
+    this.messagesMap.clear();
+  }
+};
+
+// src/useLangGraphMessages.ts
+var DEFAULT_APPEND_MESSAGE = (_, curr) => curr;
 var useLangGraphMessages = ({
-  stream
+  stream,
+  appendMessage = DEFAULT_APPEND_MESSAGE
 }) => {
   const [interrupt, setInterrupt] = useState();
   const [messages, setMessages] = useState([]);
   const abortControllerRef = useRef(null);
   const sendMessage = useCallback(
     async (newMessages, config) => {
-      newMessages = newMessages.map((m) => m.id ? m : { ...m, id: uuidv4() });
-      const messagesMap = /* @__PURE__ */ new Map();
-      const addMessages = (newMessages2) => {
-        if (newMessages2.length === 0) return;
-        for (const message of newMessages2) {
-          messagesMap.set(message.id ?? uuidv4(), message);
-        }
-        setMessages([...messagesMap.values()]);
-      };
-      addMessages([...messages, ...newMessages]);
+      newMessages = newMessages.map((m) => m.id ? m : { ...m, id: uuidv42() });
+      const accumulator = new LangGraphMessageAccumulator({
+        initialMessages: messages,
+        appendMessage
+      });
+      setMessages(accumulator.addMessages(newMessages));
       const abortController = new AbortController();
       abortControllerRef.current = abortController;
       const response = await stream(newMessages, {
@@ -103,13 +267,13 @@ var useLangGraphMessages = ({
       });
       for await (const chunk of response) {
         if (chunk.event === "messages/partial" || chunk.event === "messages/complete") {
-          addMessages(chunk.data);
+          setMessages(accumulator.addMessages(chunk.data));
         } else if (chunk.event === "updates") {
           setInterrupt(chunk.data.__interrupt__?.[0]);
         }
       }
     },
-    [messages, stream]
+    [messages, stream, appendMessage]
   );
   const cancel = useCallback(() => {
     if (abortControllerRef.current) {
@@ -128,6 +292,392 @@ var useLangGraphMessages = ({
 
 // src/useLangGraphRuntime.ts
 import { SimpleImageAttachmentAdapter } from "@assistant-ui/react";
+
+// ../react/src/utils/json/parse-partial-json.ts
+var import_secure_json_parse = __toESM(require_secure_json_parse());
+
+// ../react/src/utils/json/fix-json.ts
+function fixJson(input) {
+  const stack = ["ROOT"];
+  let lastValidIndex = -1;
+  let literalStart = null;
+  function processValueStart(char, i, swapState) {
+    {
+      switch (char) {
+        case '"': {
+          lastValidIndex = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_STRING");
+          break;
+        }
+        case "f":
+        case "t":
+        case "n": {
+          lastValidIndex = i;
+          literalStart = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_LITERAL");
+          break;
+        }
+        case "-": {
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_NUMBER");
+          break;
+        }
+        case "0":
+        case "1":
+        case "2":
+        case "3":
+        case "4":
+        case "5":
+        case "6":
+        case "7":
+        case "8":
+        case "9": {
+          lastValidIndex = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_NUMBER");
+          break;
+        }
+        case "{": {
+          lastValidIndex = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_OBJECT_START");
+          break;
+        }
+        case "[": {
+          lastValidIndex = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_ARRAY_START");
+          break;
+        }
+      }
+    }
+  }
+  function processAfterObjectValue(char, i) {
+    switch (char) {
+      case ",": {
+        stack.pop();
+        stack.push("INSIDE_OBJECT_AFTER_COMMA");
+        break;
+      }
+      case "}": {
+        lastValidIndex = i;
+        stack.pop();
+        break;
+      }
+    }
+  }
+  function processAfterArrayValue(char, i) {
+    switch (char) {
+      case ",": {
+        stack.pop();
+        stack.push("INSIDE_ARRAY_AFTER_COMMA");
+        break;
+      }
+      case "]": {
+        lastValidIndex = i;
+        stack.pop();
+        break;
+      }
+    }
+  }
+  for (let i = 0; i < input.length; i++) {
+    const char = input[i];
+    const currentState = stack[stack.length - 1];
+    switch (currentState) {
+      case "ROOT":
+        processValueStart(char, i, "FINISH");
+        break;
+      case "INSIDE_OBJECT_START": {
+        switch (char) {
+          case '"': {
+            stack.pop();
+            stack.push("INSIDE_OBJECT_KEY");
+            break;
+          }
+          case "}": {
+            lastValidIndex = i;
+            stack.pop();
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_OBJECT_AFTER_COMMA": {
+        switch (char) {
+          case '"': {
+            stack.pop();
+            stack.push("INSIDE_OBJECT_KEY");
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_OBJECT_KEY": {
+        switch (char) {
+          case '"': {
+            stack.pop();
+            stack.push("INSIDE_OBJECT_AFTER_KEY");
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_OBJECT_AFTER_KEY": {
+        switch (char) {
+          case ":": {
+            stack.pop();
+            stack.push("INSIDE_OBJECT_BEFORE_VALUE");
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_OBJECT_BEFORE_VALUE": {
+        processValueStart(char, i, "INSIDE_OBJECT_AFTER_VALUE");
+        break;
+      }
+      case "INSIDE_OBJECT_AFTER_VALUE": {
+        processAfterObjectValue(char, i);
+        break;
+      }
+      case "INSIDE_STRING": {
+        switch (char) {
+          case '"': {
+            stack.pop();
+            lastValidIndex = i;
+            break;
+          }
+          case "\\": {
+            stack.push("INSIDE_STRING_ESCAPE");
+            break;
+          }
+          default: {
+            lastValidIndex = i;
+          }
+        }
+        break;
+      }
+      case "INSIDE_ARRAY_START": {
+        switch (char) {
+          case "]": {
+            lastValidIndex = i;
+            stack.pop();
+            break;
+          }
+          default: {
+            lastValidIndex = i;
+            processValueStart(char, i, "INSIDE_ARRAY_AFTER_VALUE");
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_ARRAY_AFTER_VALUE": {
+        switch (char) {
+          case ",": {
+            stack.pop();
+            stack.push("INSIDE_ARRAY_AFTER_COMMA");
+            break;
+          }
+          case "]": {
+            lastValidIndex = i;
+            stack.pop();
+            break;
+          }
+          default: {
+            lastValidIndex = i;
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_ARRAY_AFTER_COMMA": {
+        processValueStart(char, i, "INSIDE_ARRAY_AFTER_VALUE");
+        break;
+      }
+      case "INSIDE_STRING_ESCAPE": {
+        stack.pop();
+        lastValidIndex = i;
+        break;
+      }
+      case "INSIDE_NUMBER": {
+        switch (char) {
+          case "0":
+          case "1":
+          case "2":
+          case "3":
+          case "4":
+          case "5":
+          case "6":
+          case "7":
+          case "8":
+          case "9": {
+            lastValidIndex = i;
+            break;
+          }
+          case "e":
+          case "E":
+          case "-":
+          case ".": {
+            break;
+          }
+          case ",": {
+            stack.pop();
+            if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") {
+              processAfterArrayValue(char, i);
+            }
+            if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") {
+              processAfterObjectValue(char, i);
+            }
+            break;
+          }
+          case "}": {
+            stack.pop();
+            if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") {
+              processAfterObjectValue(char, i);
+            }
+            break;
+          }
+          case "]": {
+            stack.pop();
+            if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") {
+              processAfterArrayValue(char, i);
+            }
+            break;
+          }
+          default: {
+            stack.pop();
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_LITERAL": {
+        const partialLiteral = input.substring(literalStart, i + 1);
+        if (!"false".startsWith(partialLiteral) && !"true".startsWith(partialLiteral) && !"null".startsWith(partialLiteral)) {
+          stack.pop();
+          if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") {
+            processAfterObjectValue(char, i);
+          } else if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") {
+            processAfterArrayValue(char, i);
+          }
+        } else {
+          lastValidIndex = i;
+        }
+        break;
+      }
+    }
+  }
+  let result = input.slice(0, lastValidIndex + 1);
+  let partialCount = 0;
+  for (let i = stack.length - 1; i >= 0; i--) {
+    const state = stack[i];
+    switch (state) {
+      case "INSIDE_STRING": {
+        result += '"';
+        partialCount++;
+        break;
+      }
+      case "INSIDE_OBJECT_KEY":
+      case "INSIDE_OBJECT_AFTER_KEY":
+      case "INSIDE_OBJECT_AFTER_COMMA":
+      case "INSIDE_OBJECT_START":
+      case "INSIDE_OBJECT_BEFORE_VALUE":
+      case "INSIDE_OBJECT_AFTER_VALUE": {
+        result += "}";
+        partialCount++;
+        break;
+      }
+      case "INSIDE_ARRAY_START":
+      case "INSIDE_ARRAY_AFTER_COMMA":
+      case "INSIDE_ARRAY_AFTER_VALUE": {
+        result += "]";
+        partialCount++;
+        break;
+      }
+      case "INSIDE_LITERAL": {
+        const partialLiteral = input.substring(literalStart, input.length);
+        if ("true".startsWith(partialLiteral)) {
+          result += "true".slice(partialLiteral.length);
+        } else if ("false".startsWith(partialLiteral)) {
+          result += "false".slice(partialLiteral.length);
+        } else if ("null".startsWith(partialLiteral)) {
+          result += "null".slice(partialLiteral.length);
+        }
+      }
+    }
+  }
+  return [result, partialCount];
+}
+
+// ../react/src/utils/json/parse-partial-json.ts
+var PARTIAL_JSON_COUNT_SYMBOL = Symbol("partial-json-count");
+var parsePartialJson = (json) => {
+  try {
+    return import_secure_json_parse.default.parse(json);
+  } catch {
+    try {
+      const [fixedJson, partialCount] = fixJson(json);
+      const res = import_secure_json_parse.default.parse(fixedJson);
+      res[PARTIAL_JSON_COUNT_SYMBOL] = partialCount;
+      return res;
+    } catch {
+      return void 0;
+    }
+  }
+};
+var COMPLETE_STATUS = Object.freeze({ type: "complete" });
+
+// src/appendLangChainChunk.ts
+var appendLangChainChunk = (prev, curr) => {
+  if (curr.type !== "AIMessageChunk") {
+    return curr;
+  }
+  if (!prev || prev.type !== "ai") {
+    return {
+      ...curr,
+      type: curr.type.replace("MessageChunk", "").toLowerCase()
+    };
+  }
+  const newContent = typeof prev.content === "string" ? [{ type: "text", text: prev.content }] : [...prev.content];
+  for (const chunk of curr.content) {
+    if (chunk.type === "text") {
+      const existing = newContent[chunk.index] ?? { type: "text", text: "" };
+      if (existing.type !== "text") throw new Error("");
+      newContent[chunk.index] = {
+        ...existing,
+        ...chunk,
+        text: existing.text + chunk.text
+      };
+    }
+  }
+  const newToolCalls = [...prev.tool_calls ?? []];
+  for (const chunk of curr.tool_call_chunks) {
+    const existing = newToolCalls[chunk.index - 1] ?? { argsText: "" };
+    const newArgsText = existing.argsText + chunk.args;
+    newToolCalls[chunk.index - 1] = {
+      ...chunk,
+      ...existing,
+      argsText: newArgsText,
+      args: parsePartialJson(newArgsText)
+    };
+  }
+  return {
+    ...prev,
+    content: newContent,
+    tool_calls: newToolCalls
+  };
+};
+
+// src/useLangGraphRuntime.ts
 var getPendingToolCalls = (messages) => {
   const pendingToolCalls = /* @__PURE__ */ new Map();
   for (const message of messages) {
@@ -206,6 +756,7 @@ var useLangGraphRuntime = ({
     cancel,
     setMessages
   } = useLangGraphMessages({
+    appendMessage: appendLangChainChunk,
     stream
   });
   const [isRunning, setIsRunning] = useState2(false);
@@ -220,7 +771,7 @@ var useLangGraphRuntime = ({
     }
   };
   const threadMessages = useExternalMessageConverter({
-    callback: convertLangchainMessages,
+    callback: convertLangChainMessages,
     messages,
     isRunning
   });
@@ -311,7 +862,10 @@ var useLangGraphRuntime = ({
   });
 };
 export {
-  convertLangchainMessages,
+  LangGraphMessageAccumulator,
+  appendLangChainChunk,
+  convertLangChainMessages,
+  convertLangChainMessages as convertLangchainMessages,
   useLangGraphInterruptState,
   useLangGraphMessages,
   useLangGraphRuntime,