Skip to content

The Open Standard for Generative UI

9.4 KB
Raw Blame
import { observability } from "@openuidev/observability";
import { createStore } from "zustand";
import { subscribeWithSelector } from "zustand/middleware";
import { getResponseErrorMessage } from "../adapters/httpError";
import type { ChatLLM, ChatStorage } from "../adapters/types";
import { processStreamedMessage } from "../stream/processStreamedMessage";
import { buildObservabilityErrorDetail, levelForStatus } from "./observability";
import type { ChatStore, Message, Thread, UserMessage } from "./types";

export interface CreateChatStoreConfig {
  storage: ChatStorage;
  llm: ChatLLM;
}

const mergeThreadList = (existing: Thread[], incoming: Thread[]): Thread[] =>
  Array.from(new Map([...existing, ...incoming].map((t) => [t.id, t])).values()).sort(
    (a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime(),
  );

// Takes the ref itself and reads `current` at call time, so the caller
// (ChatProvider) can refresh `llm` by mutating or replacing `current`.
export const createChatStore = (configRef: React.RefObject<CreateChatStoreConfig>) => {
  const { storage } = configRef.current;
  const { thread: threadStorage } = storage;

  const store = createStore<ChatStore>()(
    subscribeWithSelector((set, get) => ({
      // Thread List State
      threads: [],
      isLoadingThreads: false,
      threadListError: null,
      selectedThreadId: null,
      hasMoreThreads: false,
      _nextCursor: undefined,

      // Thread State
      messages: [],
      isRunning: false,
      isLoadingMessages: false,
      threadError: null,
      executingToolCallIds: new Set<string>(),
      _abortController: null,

      // ── Thread List Actions ──

      loadThreads: () => {
        set({ isLoadingThreads: true, threadListError: null });
        threadStorage
          .listThreads(undefined)
          .then(({ threads = [], nextCursor }) => {
            set({
              threads,
              isLoadingThreads: false,
              _nextCursor: nextCursor,
              hasMoreThreads: nextCursor !== undefined,
            });
          })
          .catch((e) => {
            set({ isLoadingThreads: false, threadListError: e });
          });
      },

      loadMoreThreads: () => {
        const cursor = get()._nextCursor;
        if (cursor === undefined) return;
        threadStorage
          .listThreads(cursor)
          .then(({ threads = [], nextCursor }) => {
            set((s) => ({
              threads: mergeThreadList(s.threads, threads),
              _nextCursor: nextCursor,
              hasMoreThreads: nextCursor !== undefined,
            }));
          })
          .catch((e) => {
            set({ threadListError: e });
          });
      },

      switchToNewThread: () => {
        get().cancelMessage();
        set({
          selectedThreadId: null,
          messages: [],
          threadError: null,
          executingToolCallIds: new Set<string>(),
        });
      },

      createThread: async (firstMessage: UserMessage) => {
        const thread = await threadStorage.createThread(firstMessage);
        set((s) => ({ threads: mergeThreadList(s.threads, [thread]) }));
        return thread;
      },

      selectThread: (threadId: string) => {
        // Re-selecting the active thread is a no-op — don't wipe and refetch.
        if (get().selectedThreadId === threadId) return;
        get().cancelMessage();
        set({
          selectedThreadId: threadId,
          messages: [],
          isLoadingMessages: true,
          threadError: null,
          executingToolCallIds: new Set<string>(),
        });
        threadStorage
          .getMessages(threadId)
          .then((messages) => set({ messages, isLoadingMessages: false }))
          .catch((e) => set({ threadError: e, isLoadingMessages: false }));
      },

      updateThread: (thread: Thread) => {
        const setPending = (id: string, isPending: boolean) =>
          set((s) => ({ threads: s.threads.map((t) => (t.id === id ? { ...t, isPending } : t)) }));
        setPending(thread.id, true);
        threadStorage
          .updateThread(thread)
          .then((updated) => {
            set((s) => ({
              threads: s.threads.map((t) => (t.id === updated.id ? updated : t)),
            }));
          })
          .catch(() => setPending(thread.id, false));
      },

      deleteThread: (threadId: string) => {
        const setPending = (id: string, isPending: boolean) =>
          set((s) => ({ threads: s.threads.map((t) => (t.id === id ? { ...t, isPending } : t)) }));
        setPending(threadId, true);
        threadStorage
          .deleteThread(threadId)
          .then(() => {
            const state = get();
            set({ threads: state.threads.filter((t) => t.id !== threadId) });
            if (state.selectedThreadId === threadId) {
              state.switchToNewThread();
            }
          })
          .catch(() => setPending(threadId, false));
      },

      // ── Thread Actions ──

      processMessage: async (message) => {
        const state = get();
        if (state.isRunning) return;

        const abortController = new AbortController();
        const optimisticMessage: UserMessage = {
          ...message,
          id: crypto.randomUUID(),
          role: "user",
        };

        set({
          _abortController: abortController,
          isRunning: true,
          threadError: null,
          executingToolCallIds: new Set<string>(),
        });
        set((s) => ({ messages: [...s.messages, optimisticMessage] }));

        abortController.signal.addEventListener("abort", () => {
          set({ _abortController: null, isRunning: false });
        });

        try {
          let threadId = get().selectedThreadId;

          if (!threadId) {
            const created = await get().createThread(optimisticMessage);
            threadId = created.id;
            set({ selectedThreadId: threadId });
          }

          const runId = crypto.randomUUID();

          observability.info({
            kind: "LLM:request",
            threadId,
            runId,
            // message is a reserved keyword for the observability library expecting string
            userMessage: optimisticMessage,
          });

          let response: Response | null = null;
          try {
            response = await configRef.current.llm.send({
              threadId,
              messages: get().messages,
              signal: abortController.signal,
            });

            observability(levelForStatus(response.status), {
              kind: response.ok ? "LLM:response" : "LLM:error",
              threadId,
              status: response.status,
              ok: response.ok,
              runId,
              ...(await buildObservabilityErrorDetail(response)),
            });

            if (!response.ok) {
              throw new Error(await getResponseErrorMessage(response));
            }
          } catch (e) {
            observability.error({
              kind: "LLM:error",
              threadId,
              runId,
              error: e instanceof Error ? e : new Error(String(e)),
            });
            throw e;
          }

          await processStreamedMessage({
            response,
            createMessage: (msg) => set((s) => ({ messages: [...s.messages, msg] })),
            updateMessage: (msg) =>
              set((s) => ({
                messages: s.messages.map((m) => (m.id === msg.id ? msg : m)),
              })),
            // A tool's args have closed (TOOL_CALL_END) → it is now executing.
            markToolExecuting: (id) =>
              set((s) =>
                s.executingToolCallIds.has(id)
                  ? s
                  : { executingToolCallIds: new Set(s.executingToolCallIds).add(id) },
              ),
            // Its result landed (or it errored) → no longer executing.
            clearToolExecuting: (id) =>
              set((s) => {
                if (!s.executingToolCallIds.has(id)) return s;
                const next = new Set(s.executingToolCallIds);
                next.delete(id);
                return { executingToolCallIds: next };
              }),
            adapter: configRef.current.llm.streamProtocol,
          });
        } catch (e) {
          if (!abortController.signal.aborted) {
            set({ threadError: e instanceof Error ? e : new Error(String(e)) });
          }
        } finally {
          // Clear any tool calls still flagged "executing" — adapters that emit
          // TOOL_CALL_END without a matching TOOL_CALL_RESULT (e.g. client-side
          // tool calls in the OpenAI adapters) would otherwise leave them stuck
          // in the executing set after the run ends.
          set({
            _abortController: null,
            isRunning: false,
            executingToolCallIds: new Set<string>(),
          });
        }
      },

      appendMessages: (...newMessages: Message[]) => {
        set((s) => ({ messages: [...s.messages, ...newMessages] }));
      },

      updateMessage: (message: Message) => {
        set((s) => ({
          messages: s.messages.map((m) => (m.id === message.id ? message : m)),
        }));
      },

      setMessages: (messages: Message[]) => {
        set({ messages });
      },

      deleteMessage: (messageId: string) => {
        set((s) => ({ messages: s.messages.filter((m) => m.id !== messageId) }));
      },

      cancelMessage: () => {
        get()._abortController?.abort();
      },
    })),
  );

  return store;
};