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.jsonnew file mode 100644index 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 filediff --git a/frontend-sdk/packages/react-core/eslint.cjs b/frontend-sdk/packages/react-core/eslint.cjsnew file mode 100644index 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 filediff --git a/frontend-sdk/packages/react-core/package.json b/frontend-sdk/packages/react-core/package.jsonnew file mode 100644index 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.tsxnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.jsonnew file mode 100644index 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