Skip to content

The Open Standard for Generative UI

restructure

abhishek9f8c8d23f8cd
diff --git a/frontend-sdk/packages/react-core/.prettierrc.json b/frontend-sdk/packages/react-core/.prettierrc.json
new file mode 100644
index 000000000..f94891b0a
--- /dev/null
+++ b/frontend-sdk/packages/react-core/.prettierrc.json
@@ -0,0 +1,8 @@
+{
+ "semi": true,
+ "trailingComma": "all",
+ "singleQuote": false,
+ "printWidth": 100,
+ "tabWidth": 2,
+ "plugins": ["prettier-plugin-organize-imports"]
+}
\ No newline at end of file
diff --git a/frontend-sdk/packages/react-core/eslint.cjs b/frontend-sdk/packages/react-core/eslint.cjs
new file mode 100644
index 000000000..7a4893755
--- /dev/null
+++ b/frontend-sdk/packages/react-core/eslint.cjs
@@ -0,0 +1,47 @@
+/** @type {import("eslint").ESLint.ConfigData} */
+module.exports = {
+ parser: "@typescript-eslint/parser",
+ parserOptions: {
+ project: "tsconfig.json",
+ sourceType: "module",
+ },
+ plugins: ["@typescript-eslint/eslint-plugin", "unused-imports"],
+ extends: [
+ "eslint:recommended",
+ "plugin:@typescript-eslint/recommended",
+ "plugin:prettier/recommended",
+ ],
+ root: true,
+ env: {
+ node: true,
+ jest: true,
+ },
+ ignorePatterns: [".eslintrc.cjs"],
+ rules: {
+ "@typescript-eslint/interface-name-prefix": "off",
+ "@typescript-eslint/explicit-function-return-type": "off",
+ "@typescript-eslint/explicit-module-boundary-types": "off",
+ "@typescript-eslint/no-explicit-any": "off",
+ "no-undefined": "off",
+ "@typescript-eslint/no-unused-vars": [
+ "error",
+ {
+ vars: "all",
+ varsIgnorePattern: "^_",
+ args: "after-used",
+ argsIgnorePattern: "^_",
+ },
+ ],
+ "@typescript-eslint/no-use-before-define": [
+ "error",
+ {
+ functions: false,
+ classes: false,
+ variables: true,
+ },
+ ],
+ "unused-imports/no-unused-imports": "error",
+ "no-console": "error",
+ "prettier/prettier": ["warn"],
+ },
+};
\ No newline at end of file
diff --git a/frontend-sdk/packages/react-core/package.json b/frontend-sdk/packages/react-core/package.json
new file mode 100644
index 000000000..4934cac81
--- /dev/null
+++ b/frontend-sdk/packages/react-core/package.json
@@ -0,0 +1,36 @@
+{
+ "name": "@clay/react-core",
+ "version": "1.0.0",
+ "description": "",
+ "main": "index.js",
+ "scripts": {
+ "test": "echo \"Error: no test specified\" && exit 1",
+ "build": "tsc -p .",
+ "lint": "eslint src --ext .ts,.tsx",
+ "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-plugin-unused-imports": "^3.1.0",
+ "prettier-plugin-organize-imports": "^3.2.4"
+ },
+ "keywords": [],
+ "author": "",
+ "license": "ISC"
+}
diff --git a/frontend-sdk/packages/react-core/src/ChatProvider.tsx b/frontend-sdk/packages/react-core/src/ChatProvider.tsx
new file mode 100644
index 000000000..b62e84dc9
--- /dev/null
+++ b/frontend-sdk/packages/react-core/src/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/react-core/src/hooks/useThreadActions.ts b/frontend-sdk/packages/react-core/src/hooks/useThreadActions.ts
new file mode 100644
index 000000000..d21517115
--- /dev/null
+++ b/frontend-sdk/packages/react-core/src/hooks/useThreadActions.ts
@@ -0,0 +1,15 @@
+import { useStore } from "zustand";
+import { ThreadActions } from "../chat/types";
+import { useChatContext } from "../internal/ChatContext";
+
+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/react-core/src/hooks/useThreadListActions.ts b/frontend-sdk/packages/react-core/src/hooks/useThreadListActions.ts
new file mode 100644
index 000000000..e56a4caa5
--- /dev/null
+++ b/frontend-sdk/packages/react-core/src/hooks/useThreadListActions.ts
@@ -0,0 +1,13 @@
+import { useStore } from "zustand";
+import { useChatContext } from "../internal/ChatContext";
+import { ThreadListActions } from "../types";
+
+export const useThreadListActions = (): 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/react-core/src/hooks/useThreadListState.ts b/frontend-sdk/packages/react-core/src/hooks/useThreadListState.ts
new file mode 100644
index 000000000..c39344268
--- /dev/null
+++ b/frontend-sdk/packages/react-core/src/hooks/useThreadListState.ts
@@ -0,0 +1,12 @@
+import { useStore } from "zustand";
+import { ThreadListState } from "../chat/types";
+import { useChatContext } from "../internal/ChatContext";
+
+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/react-core/src/hooks/useThreadState.ts b/frontend-sdk/packages/react-core/src/hooks/useThreadState.ts
new file mode 100644
index 000000000..c5b2f2ac4
--- /dev/null
+++ b/frontend-sdk/packages/react-core/src/hooks/useThreadState.ts
@@ -0,0 +1,14 @@
+import { useStore } from "zustand";
+import { ThreadState } from "../chat/types";
+import { useChatContext } from "../internal/ChatContext";
+
+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/react-core/src/index.ts b/frontend-sdk/packages/react-core/src/index.ts
new file mode 100644
index 000000000..8f82c8699
--- /dev/null
+++ b/frontend-sdk/packages/react-core/src/index.ts
@@ -0,0 +1,6 @@
+export { ChatProvider } from "./ChatProvider";
+// Re-export hooks from react-core
+export { useThreadActions } from "./hooks/useThreadActions";
+export { useThreadListActions } from "./hooks/useThreadListActions";
+export { useThreadListState } from "./hooks/useThreadListState";
+export { useThreadState } from "./hooks/useThreadState";
diff --git a/frontend-sdk/packages/react-core/src/internal/ChatContext.ts b/frontend-sdk/packages/react-core/src/internal/ChatContext.ts
new file mode 100644
index 000000000..6de67a572
--- /dev/null
+++ b/frontend-sdk/packages/react-core/src/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/react-core/src/internal/useThreadListManagerStore.ts b/frontend-sdk/packages/react-core/src/internal/useThreadListManagerStore.ts
new file mode 100644
index 000000000..41a1d947b
--- /dev/null
+++ b/frontend-sdk/packages/react-core/src/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/react-core/src/internal/useThreadManagerStore.ts b/frontend-sdk/packages/react-core/src/internal/useThreadManagerStore.ts
new file mode 100644
index 000000000..8c05e52d0
--- /dev/null
+++ b/frontend-sdk/packages/react-core/src/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/react-core/src/types.ts b/frontend-sdk/packages/react-core/src/types.ts
new file mode 100644
index 000000000..e58559942
--- /dev/null
+++ b/frontend-sdk/packages/react-core/src/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/react-core/src/useDefaultThreadListManager.ts b/frontend-sdk/packages/react-core/src/useDefaultThreadListManager.ts
new file mode 100644
index 000000000..5fc29c8ff
--- /dev/null
+++ b/frontend-sdk/packages/react-core/src/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/react-core/src/vercel-sdk/useVercelChatManager.ts b/frontend-sdk/packages/react-core/src/vercel-sdk/useVercelChatManager.ts
new file mode 100644
index 000000000..d702ad8ef
--- /dev/null
+++ b/frontend-sdk/packages/react-core/src/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/react-core/tsconfig.json b/frontend-sdk/packages/react-core/tsconfig.json
new file mode 100644
index 000000000..6f6d2d112
--- /dev/null
+++ b/frontend-sdk/packages/react-core/tsconfig.json
@@ -0,0 +1,44 @@
+{
+ "$schema": "https://json.schemastore.org/tsconfig",
+ "compilerOptions": {
+ /* Type Checking */
+ "allowUnreachableCode": false,
+ "noFallthroughCasesInSwitch": true,
+ "noImplicitOverride": true,
+ "noImplicitReturns": true,
+ "noPropertyAccessFromIndexSignature": true,
+ "noUncheckedIndexedAccess": true,
+ "strict": true,
+ "jsx": "react-jsx",
+
+ /* Emit */
+ "declaration": true,
+ "declarationMap": true,
+ "outDir": "dist",
+ "sourceMap": true,
+
+ /* Language and Environment */
+ "target": "es2022",
+
+ /* Projects */
+ "incremental": false,
+ "composite": false,
+
+ /* Modules */
+ "module": "NodeNext",
+ "moduleResolution": "NodeNext",
+
+ /* Language and Environment */
+ "experimentalDecorators": true,
+ "emitDecoratorMetadata": true,
+
+ /* Completeness */
+ "skipLibCheck": true,
+
+ /* Interop Constraints */
+ "esModuleInterop": true
+ },
+ "ts-node": {
+ "esm": true
+ }
+}
\ No newline at end of file