The Open Standard for Generative UI
init
abhishek8618a5cc5392
diff --git a/frontend-sdk/packages/chatbot/package.json b/frontend-sdk/packages/chatbot/package.jsonindex 0c9b74439..1e6d45c22 100644--- a/frontend-sdk/packages/chatbot/package.json+++ b/frontend-sdk/packages/chatbot/package.json@@ -10,13 +10,23 @@"format": "prettier --write src","prepare": "pnpm run build"},+ "peerDependencies": {+ "ai": "^4.0.3",+ "react": "19.0.0-rc-66855b96-20241106",+ "react-dom": "19.0.0-rc-66855b96-20241106",+ "tailwind-merge": "^2.5.4",+ "tailwindcss-animate": "^1.0.7",+ "tiny-invariant": "^1.3.3",+ "zustand": "^5.0.2"+ },"devDependencies": {+ "@types/react": "^19.0.2","@typescript-eslint/eslint-plugin": "^8.18.0",+ "eslint": "^9.17.0",+ "eslint-config-prettier": "^9.1.0","eslint-plugin-prettier": "^5.2.1","eslint-plugin-react-hooks": "^5.1.0","eslint-plugin-react-refresh": "^0.4.16",- "eslint": "^8.56.0",- "eslint-config-prettier": "^9.1.0","eslint-plugin-unused-imports": "^3.1.0","prettier-plugin-organize-imports": "^3.2.4"},diff --git a/frontend-sdk/packages/chatbot/src/chat/ChatProvider.tsx b/frontend-sdk/packages/chatbot/src/chat/ChatProvider.tsxnew file mode 100644index 000000000..b62e84dc9--- /dev/null+++ b/frontend-sdk/packages/chatbot/src/chat/ChatProvider.tsx@@ -0,0 +1,28 @@+import { useMemo } from "react";+import { ChatContext } from "./internal/ChatContext";+import { ChatManager } from "./types";+import { useThreadListManagerStore } from "./internal/useThreadListManagerStore";+import { useThreadManagerStore } from "./internal/useThreadManagerStore";++export const ChatProvider = ({+ threadManager: inputThreadManager,+ threadListManager: inputThreadListManager,+ children,+}: React.PropsWithChildren<ChatManager>) => {+ const threadManagerStore = useThreadManagerStore(inputThreadManager);+ const threadListManagerStore = useThreadListManagerStore(+ inputThreadListManager+ );++ const ctxValue = useMemo(+ () => ({+ threadListManager: threadListManagerStore,+ threadManager: threadManagerStore,+ }),+ [threadListManagerStore, threadManagerStore]+ );++ return (+ <ChatContext.Provider value={ctxValue}>{children}</ChatContext.Provider>+ );+};diff --git a/frontend-sdk/packages/chatbot/src/chat/hooks/useThreadActions.ts b/frontend-sdk/packages/chatbot/src/chat/hooks/useThreadActions.tsnew file mode 100644index 000000000..7173b086f--- /dev/null+++ b/frontend-sdk/packages/chatbot/src/chat/hooks/useThreadActions.ts@@ -0,0 +1,15 @@+import { useStore } from "zustand";+import { useChatContext } from "../internal/ChatContext";+import { ThreadActions } from "../types";++export const useThreadActions = (): ThreadActions => {+ const { threadManager } = useChatContext();++ return {+ onNew: useStore(threadManager, (store) => store.onNew),+ onReload: useStore(threadManager, (store) => store.onReload),+ onCancel: useStore(threadManager, (store) => store.onCancel),+ onAddToolResult: useStore(threadManager, (store) => store.onAddToolResult),+ convertMessage: useStore(threadManager, (store) => store.convertMessage),+ };+};diff --git a/frontend-sdk/packages/chatbot/src/chat/hooks/useThreadListActions.ts b/frontend-sdk/packages/chatbot/src/chat/hooks/useThreadListActions.tsnew file mode 100644index 000000000..473870e08--- /dev/null+++ b/frontend-sdk/packages/chatbot/src/chat/hooks/useThreadListActions.ts@@ -0,0 +1,13 @@+import { useStore } from "zustand";+import { useChatContext } from "../internal/ChatContext";+import { ThreadListActions } from "../types";++export const useThreadListState = (): ThreadListActions => {+ const { threadListManager } = useChatContext();+ return {+ load: useStore(threadListManager, (store) => store.load),+ switchToNew: useStore(threadListManager, (store) => store.switchToNew),+ deleteThread: useStore(threadListManager, (store) => store.deleteThread),+ updateThread: useStore(threadListManager, (store) => store.updateThread),+ };+};diff --git a/frontend-sdk/packages/chatbot/src/chat/hooks/useThreadListState.ts b/frontend-sdk/packages/chatbot/src/chat/hooks/useThreadListState.tsnew file mode 100644index 000000000..464ba3c6a--- /dev/null+++ b/frontend-sdk/packages/chatbot/src/chat/hooks/useThreadListState.ts@@ -0,0 +1,12 @@+import { useStore } from "zustand";+import { useChatContext } from "../internal/ChatContext";+import { ThreadListState } from "../types";++export const useThreadListState = (): ThreadListState => {+ const { threadListManager } = useChatContext();+ return {+ isLoading: useStore(threadListManager, (store) => store.isLoading),+ threads: useStore(threadListManager, (store) => store.threads),+ error: useStore(threadListManager, (store) => store.error),+ };+};diff --git a/frontend-sdk/packages/chatbot/src/chat/hooks/useThreadState.ts b/frontend-sdk/packages/chatbot/src/chat/hooks/useThreadState.tsnew file mode 100644index 000000000..a32fae974--- /dev/null+++ b/frontend-sdk/packages/chatbot/src/chat/hooks/useThreadState.ts@@ -0,0 +1,14 @@+import { useStore } from "zustand";+import { useChatContext } from "../internal/ChatContext";+import { ThreadState } from "../types";++export const useThreadState = (): ThreadState => {+ const { threadManager } = useChatContext();++ return {+ isRunning: useStore(threadManager, (store) => store.isRunning),+ isDisabled: useStore(threadManager, (store) => store.isDisabled),+ messages: useStore(threadManager, (store) => store.messages),+ error: useStore(threadManager, (store) => store.error),+ };+};diff --git a/frontend-sdk/packages/chatbot/src/chat/internal/ChatContext.ts b/frontend-sdk/packages/chatbot/src/chat/internal/ChatContext.tsnew file mode 100644index 000000000..6de67a572--- /dev/null+++ b/frontend-sdk/packages/chatbot/src/chat/internal/ChatContext.ts@@ -0,0 +1,16 @@+import { createContext, useContext } from "react";+import { ThreadListManager, ThreadManager } from "../types";+import { StoreApi } from "zustand";+import invariant from "tiny-invariant";++export const ChatContext = createContext<{+ threadListManager: StoreApi<ThreadListManager>;+ threadManager: StoreApi<ThreadManager>;+} | null>(null);++export const useChatContext = () => {+ const chatCtxValue = useContext(ChatContext);+ invariant(chatCtxValue, "chat context not found");++ return chatCtxValue;+};diff --git a/frontend-sdk/packages/chatbot/src/chat/internal/useThreadListManagerStore.ts b/frontend-sdk/packages/chatbot/src/chat/internal/useThreadListManagerStore.tsnew file mode 100644index 000000000..41a1d947b--- /dev/null+++ b/frontend-sdk/packages/chatbot/src/chat/internal/useThreadListManagerStore.ts@@ -0,0 +1,38 @@+import { createStore } from "zustand";+import { ThreadListManager } from "../types";+import { useEffect, useRef, useState } from "react";++// this is to create zustand store on top of input thread list manager,+// it enables us to expose dev friendly api using context and not give up on optimisations+export const useThreadListManagerStore = (+ inputThreadListManager: ThreadListManager+) => {+ const inputThreadListManagerRef = useRef(inputThreadListManager);+ inputThreadListManagerRef.current = inputThreadListManager;++ const [threadListManagerStore] = useState(() =>+ createStore<ThreadListManager>(() => ({+ threads: inputThreadListManager.threads,+ isLoading: inputThreadListManager.isLoading,+ error: inputThreadListManager.error,++ switchToNew: () => inputThreadListManagerRef.current.switchToNew(),+ load: () => inputThreadListManagerRef.current.load(),+ updateThread: (...props) =>+ inputThreadListManagerRef.current.updateThread(...props),+ deleteThread: (...props) =>+ inputThreadListManagerRef.current.deleteThread(...props),+ }))+ );++ useEffect(() => {+ threadListManagerStore.setState({+ threads: inputThreadListManager.threads,+ isLoading: inputThreadListManager.isLoading,+ error: inputThreadListManager.error,+ });+ // no dependency array, since we want to update these values on each render+ });++ return threadListManagerStore;+};diff --git a/frontend-sdk/packages/chatbot/src/chat/internal/useThreadManagerStore.ts b/frontend-sdk/packages/chatbot/src/chat/internal/useThreadManagerStore.tsnew file mode 100644index 000000000..8c05e52d0--- /dev/null+++ b/frontend-sdk/packages/chatbot/src/chat/internal/useThreadManagerStore.ts@@ -0,0 +1,37 @@+import { useEffect, useRef, useState } from "react";+import { create } from "zustand";+import { ThreadManager } from "../types";++// this is to create zustand store on top of input thread manager,+// it enables us to expose dev friendly api using context and not give up on optimisations+export const useThreadManagerStore = (inputThreadManager: ThreadManager) => {+ const inputThreadManagerRef = useRef(inputThreadManager);+ inputThreadManagerRef.current = inputThreadManager;++ const [threadManagerStore] = useState(() =>+ create<ThreadManager>(() => ({+ isDisabled: inputThreadManager.isDisabled,+ isRunning: inputThreadManager.isRunning,+ messages: inputThreadManager.messages,+ error: inputThreadManager.error,++ onNew: (...props) => inputThreadManagerRef.current.onNew(...props),+ onCancel: () => inputThreadManagerRef.current.onCancel?.(),+ convertMessage: (message) =>+ inputThreadManagerRef.current.convertMessage?.(message) || message,+ onAddToolResult: (props) => inputThreadManagerRef.current.onAddToolResult?.(props),+ })),+ );++ useEffect(() => {+ threadManagerStore.setState({+ isDisabled: inputThreadManager.isDisabled,+ isRunning: inputThreadManager.isRunning,+ messages: inputThreadManager.messages,+ error: inputThreadManager.error,+ });+ // no dependency array, since we want to update these values on each rerender+ });++ return threadManagerStore;+};diff --git a/frontend-sdk/packages/chatbot/src/chat/types.ts b/frontend-sdk/packages/chatbot/src/chat/types.tsnew file mode 100644index 000000000..e58559942--- /dev/null+++ b/frontend-sdk/packages/chatbot/src/chat/types.ts@@ -0,0 +1,61 @@+import { Message as VercelMessage } from "ai";++export type Message = VercelMessage;++export type CreateMessage = Omit<Message, "id"> & {+ id?: Message["id"];+};++export type MessageConverter<T = Message> = (message: T) => Message;++export type Thread = {+ threadId: string;+ title: string;+ createdAt: Date;+ isRunning: boolean;+};++export type ThreadActions<T = Message> = {+ // add new message+ onNew: (message: CreateMessage) => void;+ // reload current chat message+ onReload?: (messageId: string) => undefined;+ // stop current processing+ onCancel?: () => void;+ onAddToolResult?:+ | ((props: { toolCallId: string; result: any }) => Promise<void> | void)+ | undefined;+ // convert message to message renderes message type+ convertMessage: T extends Message ? MessageConverter<T> | undefined : MessageConverter<T>;+};++export type ThreadState<T = Message> = {+ isDisabled?: boolean | undefined;+ isRunning?: boolean | undefined;+ messages: T[];+ error: Error | null | undefined;+};++export type ThreadManager<T = Message> = ThreadState<T> & ThreadActions<T>;++export type ThreadListState = {+ threads: Thread[];+ isLoading: boolean;+ error: Error | null | undefined;+};++export type ThreadListActions = {+ // trigger load thread+ load: () => void;+ // switch to new thread+ switchToNew: () => void;+ updateThread: (thread: Thread) => void;+ deleteThread: (threadId: string) => void;+};++export type ThreadListManager = ThreadListState & ThreadListActions;++export type ChatManager = {+ threadListManager: ThreadListManager;+ threadManager: ThreadManager;+};diff --git a/frontend-sdk/packages/chatbot/src/chat/useDefaultThreadListManager.ts b/frontend-sdk/packages/chatbot/src/chat/useDefaultThreadListManager.tsnew file mode 100644index 000000000..5fc29c8ff--- /dev/null+++ b/frontend-sdk/packages/chatbot/src/chat/useDefaultThreadListManager.ts@@ -0,0 +1,88 @@+import { useMemo, useRef } from "react";+import { Thread, ThreadListManager } from "./types";+import { createStore, useStore } from "zustand";++type Props = {+ fetchThreadList: () => Promise<Thread[]>;+ deleteThread: (id: string) => Promise<void>;+ updateThread: (updated: Thread) => Promise<Thread>;+ // allows user to clear chat state when switched to new thread+ onSwitchToNew: () => void;+};++type DefaultManager = ThreadListManager & {+ addNew: (thread: Thread) => void;+};++export const useDefaultThreadListManager = (props: Props): DefaultManager => {+ const propsRef = useRef(props);+ propsRef.current = props;++ const store = useMemo(() => {+ return createStore<DefaultManager>((set) => {+ const updateThreadRunningStatus = (id: string, isRunning: boolean) => {+ set((state) => ({+ threads: state.threads.map((t) => {+ if (t.threadId !== id) {+ return t;+ }+ return {+ ...t,+ isRunning,+ };+ }),+ }));+ };++ return {+ threads: [] as Thread[],+ error: null,+ isLoading: true,+ switchToNew: () => propsRef.current.onSwitchToNew(),+ load: () => {+ set({ isLoading: true });+ propsRef.current+ .fetchThreadList()+ .then((threads) => {+ set({ isLoading: false, threads });+ })+ .catch((e) => {+ set({ isLoading: false, error: e });+ });+ },+ deleteThread: (id) => {+ updateThreadRunningStatus(id, true);+ propsRef.current+ .deleteThread(id)+ .then(() => {+ set((state) => ({+ threads: state.threads.filter((t) => t.threadId !== id),+ }));+ })+ .catch(() => {+ updateThreadRunningStatus(id, false);+ });+ },+ updateThread: (thread) => {+ updateThreadRunningStatus(thread.threadId, true);++ propsRef.current+ .updateThread(thread)+ .then((thread) =>+ set((state) => ({+ threads: state.threads.map((t) =>+ t.threadId === thread.threadId ? thread : t+ ),+ }))+ )+ .catch(() => {+ updateThreadRunningStatus(thread.threadId, false);+ });+ },+ addNew: (thread: Thread) => {},+ };+ });+ }, []);++ return useStore(store);+};diff --git a/frontend-sdk/packages/chatbot/src/chat/vercel-sdk/useVercelChatManager.ts b/frontend-sdk/packages/chatbot/src/chat/vercel-sdk/useVercelChatManager.tsnew file mode 100644index 000000000..d702ad8ef--- /dev/null+++ b/frontend-sdk/packages/chatbot/src/chat/vercel-sdk/useVercelChatManager.ts@@ -0,0 +1,27 @@+import { useChat } from "ai/react";+import { ThreadManager } from "../types";++type UseChatParams = Parameters<typeof useChat>[0] & { id?: never };+type UseChatReturn = ReturnType<typeof useChat>;++export const useVercelChatManager = (+ params: UseChatParams+): ThreadManager & { useChatState: UseChatReturn } => {+ const vercelChatReturn = useChat(params);+ const { messages, isLoading, addToolResult, append, reload, stop, error } =+ vercelChatReturn;++ return {+ messages,+ isRunning: isLoading,+ error,+ onNew: append,+ onReload: () => {+ reload();+ },+ onCancel: stop,+ onAddToolResult: addToolResult,+ convertMessage: undefined,+ useChatState: vercelChatReturn,+ };+};diff --git a/frontend-sdk/packages/chatbot/tsconfig.json b/frontend-sdk/packages/chatbot/tsconfig.jsonindex 93b743eb7..6f6d2d112 100644--- a/frontend-sdk/packages/chatbot/tsconfig.json+++ b/frontend-sdk/packages/chatbot/tsconfig.json@@ -3,13 +3,13 @@"compilerOptions": {/* Type Checking */"allowUnreachableCode": false,- "exactOptionalPropertyTypes": true,"noFallthroughCasesInSwitch": true,"noImplicitOverride": true,"noImplicitReturns": true,"noPropertyAccessFromIndexSignature": true,"noUncheckedIndexedAccess": true,"strict": true,+ "jsx": "react-jsx",/* Emit */"declaration": true,