@kortyx/react 0.0.1

package/dist/index.js

@@ -0,0 +1,679 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  buildAssistantMessage: () => buildAssistantMessage,
+  createBrowserChatStorage: () => createBrowserChatStorage,
+  createChatTransport: () => createChatTransport,
+  createLiveChatPieces: () => createLiveChatPieces,
+  createRouteChatTransport: () => createRouteChatTransport,
+  toHumanInputPiece: () => toHumanInputPiece,
+  useChat: () => useChat,
+  useChatStreamDebug: () => useChatStreamDebug,
+  useStructuredStreams: () => useStructuredStreams
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/build-assistant-message.ts
+function buildAssistantMessage(args) {
+  const plainTextContent = args.pieces.filter(
+    (piece) => piece.type === "text"
+  ).map((piece) => piece.content).join("");
+  const base = {
+    id: args.createId(),
+    role: "assistant",
+    content: plainTextContent,
+    debug: args.debug
+  };
+  return args.pieces.length > 0 ? { ...base, contentPieces: args.pieces } : base;
+}
+
+// src/chat-storage.ts
+var DEFAULT_STORAGE_KEYS = {
+  messages: "chat.messages.v1",
+  includeHistory: "chat.includeHistory.v1",
+  sessionId: "chat.sessionId",
+  workflowId: "chat.workflowId"
+};
+var getLocalStorage = () => {
+  const candidate = globalThis;
+  return candidate.localStorage;
+};
+var defaultParseMessage = (value) => value;
+var defaultSerializeMessage = (message) => message;
+function createBrowserChatStorage(options) {
+  const keys = {
+    ...DEFAULT_STORAGE_KEYS,
+    ...options?.keys ?? {}
+  };
+  const maxMessages = options?.maxMessages ?? 60;
+  const parseMessage = options?.parseMessage ?? defaultParseMessage;
+  const serializeMessage = options?.serializeMessage ?? defaultSerializeMessage;
+  return {
+    load() {
+      try {
+        const storage = getLocalStorage();
+        if (!storage) {
+          return {};
+        }
+        const sessionId = storage.getItem(keys.sessionId);
+        const workflowId = storage.getItem(keys.workflowId) ?? "";
+        const includeHistoryRaw = storage.getItem(keys.includeHistory);
+        const rawMessages = storage.getItem(keys.messages);
+        const parsedMessages = rawMessages ? JSON.parse(rawMessages) : [];
+        const messages = Array.isArray(parsedMessages) ? parsedMessages.map((item) => parseMessage(item)).filter((message) => message !== null) : [];
+        return {
+          sessionId,
+          workflowId,
+          includeHistory: includeHistoryRaw !== "0",
+          messages
+        };
+      } catch {
+        return {};
+      }
+    },
+    save(state) {
+      try {
+        const storage = getLocalStorage();
+        if (!storage) return;
+        if (state.sessionId) {
+          storage.setItem(keys.sessionId, state.sessionId);
+        } else {
+          storage.removeItem(keys.sessionId);
+        }
+        storage.setItem(keys.workflowId, state.workflowId);
+        storage.setItem(keys.includeHistory, state.includeHistory ? "1" : "0");
+        const trimmedMessages = state.messages.slice(-maxMessages).map((message) => serializeMessage(message));
+        storage.setItem(keys.messages, JSON.stringify(trimmedMessages));
+      } catch {
+      }
+    },
+    clearMessages() {
+      try {
+        const storage = getLocalStorage();
+        if (!storage) return;
+        storage.removeItem(keys.messages);
+      } catch {
+      }
+    }
+  };
+}
+
+// src/chat-transport.ts
+var import_browser = require("@kortyx/stream/browser");
+function createChatTransport(args) {
+  return {
+    async stream({ onChunk, ...context }) {
+      for await (const chunk of await args.stream(context)) {
+        const shouldContinue = await onChunk(chunk);
+        if (chunk.type === "done" || shouldContinue === false) {
+          break;
+        }
+      }
+    }
+  };
+}
+function createRouteChatTransport(args) {
+  return createChatTransport({
+    stream: (context) => {
+      const routeArgs = {
+        endpoint: args.endpoint,
+        body: args.getBody(context),
+        ...args.method ? { method: args.method } : {},
+        ...args.headers ? { headers: args.headers } : {},
+        ...args.fetchImpl ? { fetchImpl: args.fetchImpl } : {}
+      };
+      return (0, import_browser.streamFromRoute)({
+        ...routeArgs
+      });
+    }
+  });
+}
+
+// src/create-live-chat-pieces.ts
+var isNonEmptyTextPiece = (piece) => piece.type !== "text" || "content" in piece && typeof piece.content === "string" && piece.content.length > 0;
+function createLiveChatPieces(args) {
+  const keyedPieces = [];
+  let sawTextDelta = false;
+  const emit = () => {
+    args.onChange(
+      keyedPieces.map((entry) => entry.piece).filter((piece) => isNonEmptyTextPiece(piece))
+    );
+  };
+  const findPieceIndex = (key) => keyedPieces.findIndex((entry) => entry.key === key);
+  const upsertPiece = (key, piece) => {
+    const existingIndex = findPieceIndex(key);
+    if (existingIndex >= 0) {
+      keyedPieces[existingIndex] = { key, piece };
+    } else {
+      keyedPieces.push({ key, piece });
+    }
+    emit();
+  };
+  const pushPiece = (piece) => {
+    keyedPieces.push({
+      key: `${piece.type}:${piece.id}`,
+      piece
+    });
+    emit();
+  };
+  const resolveTextStreamKey = (chunk, fallbackNode) => {
+    if ("segmentId" in chunk && typeof chunk.segmentId === "string") {
+      const seg = chunk.segmentId.trim();
+      if (seg.length > 0) {
+        const op = "opId" in chunk && typeof chunk.opId === "string" ? chunk.opId.trim() : "";
+        return op.length > 0 ? `${op}:${seg}` : seg;
+      }
+    }
+    if ("opId" in chunk && typeof chunk.opId === "string") {
+      const op = chunk.opId.trim();
+      if (op.length > 0) {
+        const node = ("node" in chunk && typeof chunk.node === "string" ? chunk.node : fallbackNode) ?? "__unknown__";
+        return `${op}:${node}`;
+      }
+    }
+    return fallbackNode ?? "__unknown__";
+  };
+  const ensureTextPiece = (key) => {
+    const pieceKey = `text:${key || "__unknown__"}`;
+    const existingIndex = findPieceIndex(pieceKey);
+    if (existingIndex >= 0) {
+      return keyedPieces[existingIndex]?.piece;
+    }
+    const nextPiece = {
+      id: args.createId(),
+      type: "text",
+      content: ""
+    };
+    keyedPieces.push({ key: pieceKey, piece: nextPiece });
+    return nextPiece;
+  };
+  const processChunk = (chunk, _options) => {
+    if (chunk.type === "text-start") {
+      ensureTextPiece(resolveTextStreamKey(chunk, chunk.node));
+      emit();
+      return true;
+    }
+    if (chunk.type === "text-delta") {
+      sawTextDelta = true;
+      const streamKey = resolveTextStreamKey(chunk, chunk.node);
+      const current = ensureTextPiece(streamKey);
+      upsertPiece(`text:${streamKey}`, {
+        ...current,
+        content: current.content + chunk.delta
+      });
+      return true;
+    }
+    if (chunk.type === "text-end") {
+      emit();
+      return true;
+    }
+    if (chunk.type === "structured-data") {
+      const nextItem = args.structuredStreams.applyStreamChunk(chunk);
+      if (nextItem) {
+        upsertPiece(`structured:${nextItem.streamId}`, {
+          id: nextItem.id,
+          type: "structured",
+          data: nextItem.state
+        });
+      }
+      return true;
+    }
+    if (chunk.type === "interrupt") {
+      pushPiece(args.toHumanInputPiece(chunk));
+      return true;
+    }
+    if (chunk.type === "message") {
+      if (!sawTextDelta) {
+        pushPiece({
+          id: args.createId(),
+          type: "text",
+          content: chunk.content ?? ""
+        });
+      }
+      return true;
+    }
+    if (chunk.type === "error") {
+      pushPiece({
+        id: args.createId(),
+        type: "error",
+        content: chunk.message ?? "An error occurred"
+      });
+      return true;
+    }
+    if (chunk.type === "done") {
+      return false;
+    }
+    return true;
+  };
+  return {
+    processChunk,
+    getPieces: () => keyedPieces.map((entry) => entry.piece).filter((piece) => isNonEmptyTextPiece(piece))
+  };
+}
+
+// src/to-human-input-piece.ts
+function toHumanInputPiece(args) {
+  const hi = args.chunk;
+  const input = hi.input ?? {};
+  const kind = input.kind || (input.multiple ? "multi-choice" : "choice");
+  const isText = kind === "text";
+  const question = isText ? input.question : typeof input.question === "string" ? input.question : "Please choose";
+  const optionsSrc = Array.isArray(input.options) ? input.options : [];
+  const optionsArr = optionsSrc.map((option) => ({
+    id: String(option.id ?? ""),
+    label: String(option.label ?? ""),
+    ...typeof option.description === "string" && option.description ? { description: option.description } : {}
+  })).filter((option) => option.id && option.label);
+  return {
+    id: args.createId(),
+    type: "interrupt",
+    resumeToken: String(hi.resumeToken ?? ""),
+    requestId: String(hi.requestId ?? ""),
+    kind,
+    ...question !== void 0 ? { question } : {},
+    multiple: Boolean(input.multiple),
+    options: optionsArr
+  };
+}
+
+// src/use-chat.ts
+var import_react3 = require("react");
+
+// src/use-chat-stream-debug.ts
+var import_react = require("react");
+function useChatStreamDebug() {
+  const [streamDebug, setStreamDebug] = (0, import_react.useState)([]);
+  const clearStreamDebug = (0, import_react.useCallback)(() => {
+    setStreamDebug([]);
+  }, []);
+  const createRecorder = (0, import_react.useCallback)((initialMessage) => {
+    let seq = 0;
+    let lastTs = 0;
+    const accDebug = [];
+    const push = (chunk) => {
+      const ts = Date.now();
+      const withMeta = {
+        ...chunk,
+        _ts: ts,
+        _dt: lastTs ? ts - lastTs : 0,
+        _seq: seq++
+      };
+      lastTs = ts;
+      accDebug.push(withMeta);
+      setStreamDebug(
+        (current) => current.length > 1e3 ? [...current.slice(-1e3), withMeta] : [...current, withMeta]
+      );
+    };
+    push({
+      type: "status",
+      message: initialMessage
+    });
+    return {
+      push,
+      getAll: () => accDebug
+    };
+  }, []);
+  return {
+    streamDebug,
+    clearStreamDebug,
+    createRecorder
+  };
+}
+
+// src/use-structured-streams.ts
+var import_browser2 = require("@kortyx/stream/browser");
+var import_react2 = require("react");
+var defaultCreateId = () => {
+  try {
+    if (typeof crypto !== "undefined" && "randomUUID" in crypto) {
+      return crypto.randomUUID();
+    }
+  } catch {
+  }
+  return `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+};
+function useStructuredStreams(options) {
+  const createId = (0, import_react2.useRef)(options?.createId ?? defaultCreateId).current;
+  const initialChunks = (0, import_react2.useRef)(options?.initialChunks ?? []).current;
+  const accumulatorRef = (0, import_react2.useRef)(
+    (0, import_browser2.createStructuredStreamAccumulator)(initialChunks)
+  );
+  const initialItemsRef = (0, import_react2.useRef)(
+    void 0
+  );
+  if (initialItemsRef.current === void 0) {
+    initialItemsRef.current = accumulatorRef.current.entries().map(([streamId, state]) => ({
+      id: createId(),
+      streamId,
+      state
+    }));
+  }
+  const itemsRef = (0, import_react2.useRef)(initialItemsRef.current);
+  const [items, setItems] = (0, import_react2.useState)(initialItemsRef.current);
+  const setNextItems = (0, import_react2.useCallback)(
+    (nextItems) => {
+      itemsRef.current = nextItems;
+      setItems(nextItems);
+    },
+    []
+  );
+  const applyStreamChunk = (0, import_react2.useCallback)(
+    (chunk) => {
+      const nextState = accumulatorRef.current.applyStreamChunk(chunk);
+      if (!nextState) return void 0;
+      const currentItems = itemsRef.current;
+      const existingIndex = currentItems.findIndex(
+        (item) => item.streamId === nextState.streamId
+      );
+      const existingItem = existingIndex >= 0 ? currentItems[existingIndex] : void 0;
+      const nextItem = existingItem ? {
+        ...existingItem,
+        state: nextState
+      } : {
+        id: createId(),
+        streamId: nextState.streamId,
+        state: nextState
+      };
+      const nextItems = existingIndex >= 0 ? currentItems.map(
+        (item, index) => index === existingIndex ? nextItem : item
+      ) : [...currentItems, nextItem];
+      setNextItems(nextItems);
+      return nextItem;
+    },
+    [createId, setNextItems]
+  );
+  const clear = (0, import_react2.useCallback)(() => {
+    accumulatorRef.current = (0, import_browser2.createStructuredStreamAccumulator)();
+    setNextItems([]);
+  }, [setNextItems]);
+  const get = (0, import_react2.useCallback)((streamId) => {
+    return itemsRef.current.find((item) => item.streamId === streamId);
+  }, []);
+  const byStreamId = (0, import_react2.useMemo)(
+    () => Object.fromEntries(
+      items.map((item) => [item.streamId, item.state])
+    ),
+    [items]
+  );
+  return {
+    items,
+    byStreamId,
+    applyStreamChunk,
+    clear,
+    get
+  };
+}
+
+// src/use-chat.ts
+var defaultCreateId2 = () => {
+  try {
+    if (typeof crypto !== "undefined" && "randomUUID" in crypto) {
+      return crypto.randomUUID();
+    }
+  } catch {
+  }
+  return `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+};
+var defaultStorage = createBrowserChatStorage();
+function useInitialValue(value) {
+  const ref = (0, import_react3.useRef)(void 0);
+  if (ref.current === void 0) {
+    ref.current = value;
+  }
+  return ref.current;
+}
+function findActiveTextInterrupt(args) {
+  const liveInterrupt = args.streamContentPieces.find(
+    (piece) => piece.type === "interrupt" && piece.kind === "text"
+  );
+  if (liveInterrupt) return liveInterrupt;
+  for (let i = args.messages.length - 1; i >= 0; i -= 1) {
+    const message = args.messages[i];
+    if (!message) continue;
+    if (message.role !== "assistant" || !message.contentPieces) continue;
+    const messageInterrupt = [...message.contentPieces].reverse().find(
+      (piece) => piece.type === "interrupt" && piece.kind === "text"
+    );
+    if (messageInterrupt) return messageInterrupt;
+  }
+  return void 0;
+}
+function useChat(options) {
+  const transport = useInitialValue(options.transport);
+  const storage = useInitialValue(options.storage ?? defaultStorage);
+  const createId = useInitialValue(options.createId ?? defaultCreateId2);
+  const [messages, setMessages] = (0, import_react3.useState)([]);
+  const [isStreaming, setIsStreaming] = (0, import_react3.useState)(false);
+  const [streamContentPieces, setStreamContentPieces] = (0, import_react3.useState)([]);
+  const [lastAssistantId, setLastAssistantId] = (0, import_react3.useState)(null);
+  const [includeHistory, setIncludeHistory] = (0, import_react3.useState)(true);
+  const [workflowId, setWorkflowId] = (0, import_react3.useState)("");
+  const [sessionId, setSessionId] = (0, import_react3.useState)(null);
+  const [didHydrateStorage, setDidHydrateStorage] = (0, import_react3.useState)(false);
+  const { streamDebug, clearStreamDebug, createRecorder } = useChatStreamDebug();
+  const { applyStreamChunk, clear: clearStructuredStreams } = useStructuredStreams({
+    createId
+  });
+  (0, import_react3.useEffect)(() => {
+    let cancelled = false;
+    void Promise.resolve(storage.load()).then((storedState) => {
+      if (cancelled) return;
+      if (typeof storedState.sessionId === "string") {
+        setSessionId(storedState.sessionId);
+      }
+      if (typeof storedState.workflowId === "string") {
+        setWorkflowId(storedState.workflowId);
+      }
+      if (typeof storedState.includeHistory === "boolean") {
+        setIncludeHistory(storedState.includeHistory);
+      }
+      if (Array.isArray(storedState.messages) && storedState.messages.length > 0) {
+        setMessages(storedState.messages);
+      }
+      setDidHydrateStorage(true);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [storage]);
+  (0, import_react3.useEffect)(() => {
+    if (!didHydrateStorage) return;
+    void storage.save({
+      sessionId,
+      workflowId,
+      includeHistory,
+      messages
+    });
+  }, [
+    didHydrateStorage,
+    includeHistory,
+    messages,
+    sessionId,
+    storage,
+    workflowId
+  ]);
+  const clearChat = () => {
+    setMessages([]);
+    setStreamContentPieces([]);
+    clearStreamDebug();
+    clearStructuredStreams();
+    setLastAssistantId(null);
+    void storage.clearMessages();
+  };
+  const persistSessionId = (sid) => {
+    setSessionId(sid);
+  };
+  const resolveSessionId = () => {
+    const sid = sessionId ?? createId();
+    if (!sessionId) persistSessionId(sid);
+    return sid;
+  };
+  const streamAssistantResponse = async (args) => {
+    clearStructuredStreams();
+    setStreamContentPieces([]);
+    const debug = createRecorder(`${args.debugLabel} sessionId=${args.sid}`);
+    const pieces = createLiveChatPieces({
+      createId,
+      onChange: setStreamContentPieces,
+      structuredStreams: {
+        applyStreamChunk
+      },
+      toHumanInputPiece: (chunk) => toHumanInputPiece({
+        chunk,
+        createId
+      })
+    });
+    await transport.stream({
+      sessionId: args.sid,
+      workflowId,
+      messages: args.messagesToSend,
+      onChunk: (chunk) => {
+        debug.push(chunk);
+        if (chunk.type === "session") {
+          if (typeof chunk.sessionId === "string") {
+            persistSessionId(chunk.sessionId);
+          }
+          return;
+        }
+        return pieces.processChunk(chunk, {
+          openDebugOnInterrupt: args.openDebugOnInterrupt
+        });
+      }
+    });
+    const assistant = buildAssistantMessage({
+      createId,
+      pieces: pieces.getPieces(),
+      debug: debug.getAll()
+    });
+    setMessages((prev) => [...prev, assistant]);
+    setLastAssistantId(assistant.id);
+    clearStructuredStreams();
+    setStreamContentPieces([]);
+    clearStreamDebug();
+  };
+  const respondToHumanInput = async ({
+    resumeToken,
+    requestId,
+    selected,
+    text
+  }) => {
+    if (isStreaming) return;
+    const label = typeof text === "string" && text.length > 0 ? text : selected.length > 0 ? selected.length === 1 ? selected[0] : selected.join(", ") : "(selection)";
+    const userId = createId();
+    const userMsg = { id: userId, role: "user", content: label };
+    setMessages((prev) => [...prev, userMsg]);
+    setIsStreaming(true);
+    setStreamContentPieces([]);
+    clearStreamDebug();
+    clearStructuredStreams();
+    try {
+      const resumePayload = {
+        resume: { token: resumeToken, requestId, selected }
+      };
+      const outgoing = {
+        role: "user",
+        content: label,
+        metadata: resumePayload
+      };
+      const sid = resolveSessionId();
+      const history = includeHistory ? messages.map((message) => ({
+        role: message.role,
+        content: message.content
+      })) : [];
+      const messagesToSend = [...history, outgoing];
+      await streamAssistantResponse({
+        sid,
+        messagesToSend,
+        debugLabel: "runChat (resume)"
+      });
+    } finally {
+      setIsStreaming(false);
+    }
+  };
+  const send = async (text) => {
+    const content = text.trim();
+    if (!content || isStreaming) return;
+    const activeTextInterrupt = findActiveTextInterrupt({
+      messages,
+      streamContentPieces
+    });
+    if (activeTextInterrupt) {
+      await respondToHumanInput({
+        resumeToken: activeTextInterrupt.resumeToken,
+        requestId: activeTextInterrupt.requestId,
+        selected: [content],
+        text: content
+      });
+      return;
+    }
+    const userId = createId();
+    const userMsg = { id: userId, role: "user", content };
+    setMessages((prev) => [...prev, userMsg]);
+    setIsStreaming(true);
+    setStreamContentPieces([]);
+    clearStreamDebug();
+    clearStructuredStreams();
+    try {
+      const sid = resolveSessionId();
+      const history = includeHistory ? messages.map((message) => ({
+        role: message.role,
+        content: message.content
+      })) : [];
+      const messagesToSend = [...history, { role: "user", content }];
+      await streamAssistantResponse({
+        sid,
+        messagesToSend,
+        debugLabel: "runChat (send)",
+        openDebugOnInterrupt: true
+      });
+    } finally {
+      setIsStreaming(false);
+    }
+  };
+  return {
+    messages,
+    isStreaming,
+    streamContentPieces,
+    streamDebug,
+    lastAssistantId,
+    workflowId,
+    setWorkflowId,
+    send,
+    respondToHumanInput,
+    setMessages,
+    clearChat,
+    includeHistory,
+    setIncludeHistory
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildAssistantMessage,
+  createBrowserChatStorage,
+  createChatTransport,
+  createLiveChatPieces,
+  createRouteChatTransport,
+  toHumanInputPiece,
+  useChat,
+  useChatStreamDebug,
+  useStructuredStreams
+});
+//# sourceMappingURL=index.js.map