Skip to content

The Open Standard for Generative UI

init

abhishek8618a5cc5392
diff --git a/frontend-sdk/packages/chatbot/package.json b/frontend-sdk/packages/chatbot/package.json
index 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.tsx
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.json
index 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,