@nocobase/portal-template-default 1.0.1 → 1.0.3

package/src/extensions/nocobase-ai/providers/use-chat-runtime.ts

@@ -0,0 +1,210 @@
+import { Chat } from "@ai-sdk/react";
+import {
+  useCallback,
+  useRef,
+  type Dispatch,
+  type MutableRefObject,
+} from "react";
+import type { AIChatAction, AIChatState } from "./chat-reducer";
+import { NocoBaseChatTransport } from "./chat-transport";
+import { findAIModel, getAIModelKey } from "./model";
+import type { useAI } from "./ai-provider";
+import {
+  AI_DRAFT_CONVERSATION_ID,
+  type AIChatMessage,
+  type AIChatTaskRuntime,
+} from "./types";
+
+type AIContextValue = ReturnType<typeof useAI>;
+
+export type AIConversationRuntimeContext = {
+  employeeUsername: string;
+  model: string;
+  task?: AIChatTaskRuntime;
+};
+
+export function useChatRuntime({
+  id,
+  ai,
+  stateRef,
+  taskRuntimeRef,
+  webSearchRef,
+  conversationFinishedHandlerRef,
+  moveAttachments,
+  moveWorkContext,
+  dispatch,
+}: {
+  id: string;
+  ai: AIContextValue;
+  stateRef: MutableRefObject<AIChatState>;
+  taskRuntimeRef: MutableRefObject<AIChatTaskRuntime | undefined>;
+  webSearchRef: MutableRefObject<boolean>;
+  conversationFinishedHandlerRef: MutableRefObject<
+    | ((conversationId: string, chat: Chat<AIChatMessage>) => Promise<void>)
+    | undefined
+  >;
+  moveAttachments: (from: string, to: string) => void;
+  moveWorkContext: (from: string, to: string) => void;
+  dispatch: Dispatch<AIChatAction>;
+}) {
+  const chatsRef = useRef(new Map<string, Chat<AIChatMessage>>());
+  const transportsRef = useRef(new Map<string, NocoBaseChatTransport>());
+  const runtimeContextsRef = useRef(
+    new Map<string, AIConversationRuntimeContext>()
+  );
+
+  const getRuntimeContext = useCallback(
+    (conversationId: string): AIConversationRuntimeContext => {
+      const existing = runtimeContextsRef.current.get(conversationId);
+      if (existing) return existing;
+
+      const latestState = stateRef.current;
+      const conversation = latestState.conversations.find(
+        (item) => item.id === conversationId
+      );
+      const conversationModel = conversation?.model
+        ? ai.models.find(
+            (item) =>
+              item.value === conversation.model?.model &&
+              (!conversation.model.llmService ||
+                item.llmService === conversation.model.llmService)
+          )
+        : undefined;
+      const context = {
+        employeeUsername:
+          conversation?.employeeUsername ??
+          latestState.selectedEmployeeUsername,
+        model: conversationModel
+          ? getAIModelKey(conversationModel)
+          : latestState.selectedModel,
+        task:
+          conversationId === AI_DRAFT_CONVERSATION_ID
+            ? taskRuntimeRef.current
+            : undefined,
+      };
+      runtimeContextsRef.current.set(conversationId, context);
+      return context;
+    },
+    [ai.models, stateRef, taskRuntimeRef]
+  );
+
+  const getChat = useCallback(
+    (conversationId: string) => {
+      const existing = chatsRef.current.get(conversationId);
+      if (existing) return existing;
+
+      let runtimeConversationId = conversationId;
+      const transport = ai.createTransport({
+        chatId: `${id}:${conversationId}`,
+        getContext: () => {
+          const runtimeContext = getRuntimeContext(runtimeConversationId);
+          const employee =
+            ai.employees.find(
+              (item) => item.username === runtimeContext.employeeUsername
+            ) ?? ai.employees[0];
+          const model =
+            findAIModel(ai.models, runtimeContext.model) ?? ai.models[0];
+          if (!employee || !model) {
+            throw new Error(
+              "AIProvider requires at least one employee and model"
+            );
+          }
+          const task = runtimeContext.task;
+          return {
+            sessionId:
+              runtimeConversationId === AI_DRAFT_CONVERSATION_ID
+                ? undefined
+                : runtimeConversationId,
+            employee,
+            model,
+            task: task
+              ? {
+                  ...task,
+                  webSearch: task.webSearch ?? webSearchRef.current,
+                }
+              : webSearchRef.current
+              ? { workContext: [], webSearch: true }
+              : undefined,
+          };
+        },
+        onSessionCreated: (sessionId) => {
+          const previousConversationId = runtimeConversationId;
+          chatsRef.current.delete(runtimeConversationId);
+          chatsRef.current.set(sessionId, chat);
+          if (transport instanceof NocoBaseChatTransport) {
+            transportsRef.current.delete(previousConversationId);
+            transportsRef.current.set(sessionId, transport);
+          }
+          const runtimeContext = runtimeContextsRef.current.get(
+            previousConversationId
+          );
+          if (runtimeContext) {
+            runtimeContextsRef.current.delete(previousConversationId);
+            runtimeContextsRef.current.set(sessionId, runtimeContext);
+          }
+          moveAttachments(previousConversationId, sessionId);
+          moveWorkContext(previousConversationId, sessionId);
+          dispatch({
+            type: "replace-conversation-id",
+            from: runtimeConversationId,
+            to: sessionId,
+          });
+          runtimeConversationId = sessionId;
+        },
+      });
+      const chat = new Chat<AIChatMessage>({
+        id: `${id}:${conversationId}`,
+        messages: [],
+        onFinish: () => {
+          const finishedConversationId = runtimeConversationId;
+          if (finishedConversationId === AI_DRAFT_CONVERSATION_ID) {
+            return;
+          }
+          queueMicrotask(() => {
+            void conversationFinishedHandlerRef.current?.(
+              finishedConversationId,
+              chat
+            );
+          });
+        },
+        transport,
+      });
+      chatsRef.current.set(conversationId, chat);
+      if (transport instanceof NocoBaseChatTransport) {
+        transportsRef.current.set(conversationId, transport);
+      }
+      return chat;
+    },
+    [
+      ai,
+      conversationFinishedHandlerRef,
+      dispatch,
+      getRuntimeContext,
+      id,
+      moveAttachments,
+      moveWorkContext,
+      webSearchRef,
+    ]
+  );
+
+  const getTransport = useCallback(
+    (conversationId: string) => transportsRef.current.get(conversationId),
+    []
+  );
+
+  const remove = useCallback((conversationId: string) => {
+    chatsRef.current.delete(conversationId);
+    transportsRef.current.delete(conversationId);
+    runtimeContextsRef.current.delete(conversationId);
+  }, []);
+
+  return {
+    chatsRef,
+    transportsRef,
+    runtimeContextsRef,
+    getRuntimeContext,
+    getChat,
+    getTransport,
+    remove,
+  };
+}

package/src/extensions/nocobase-ai/providers/use-chat-work-context.ts

@@ -0,0 +1,93 @@
+import { useCallback, useRef, useState } from "react";
+import type { AIWorkContextItem } from "./types";
+
+const EMPTY_CONTEXT: AIWorkContextItem[] = [];
+
+const contextItemKey = (item: AIWorkContextItem) =>
+  `${item.type}:${item.id ?? item.title ?? "context"}`;
+
+export function useChatWorkContext(activeConversationId: string) {
+  const [drafts, setDrafts] = useState<Record<string, AIWorkContextItem[]>>({});
+  const draftsRef = useRef(drafts);
+  draftsRef.current = drafts;
+
+  const setConversationWorkContext = useCallback(
+    (
+      conversationId: string,
+      value:
+        | AIWorkContextItem[]
+        | ((current: AIWorkContextItem[]) => AIWorkContextItem[])
+    ) => {
+      setDrafts((current) => ({
+        ...current,
+        [conversationId]:
+          typeof value === "function"
+            ? value(current[conversationId] ?? [])
+            : value,
+      }));
+    },
+    []
+  );
+
+  const addWorkContext = useCallback(
+    (item: AIWorkContextItem) => {
+      setConversationWorkContext(activeConversationId, (current) => {
+        const key = contextItemKey(item);
+        return [
+          ...current.filter((entry) => contextItemKey(entry) !== key),
+          item,
+        ];
+      });
+    },
+    [activeConversationId, setConversationWorkContext]
+  );
+
+  const removeWorkContext = useCallback(
+    (item: AIWorkContextItem) => {
+      const key = contextItemKey(item);
+      setConversationWorkContext(activeConversationId, (current) =>
+        current.filter((entry) => contextItemKey(entry) !== key)
+      );
+    },
+    [activeConversationId, setConversationWorkContext]
+  );
+
+  const moveWorkContext = useCallback((from: string, to: string) => {
+    setDrafts((current) => {
+      if (!current[from]) return current;
+      const next = { ...current, [to]: current[from] };
+      delete next[from];
+      return next;
+    });
+  }, []);
+
+  const removeConversationWorkContext = useCallback(
+    (conversationId: string) => {
+      setDrafts((current) => {
+        if (!current[conversationId]) return current;
+        const next = { ...current };
+        delete next[conversationId];
+        return next;
+      });
+    },
+    []
+  );
+
+  const clearWorkContext = useCallback(() => setDrafts({}), []);
+  const getConversationWorkContext = useCallback(
+    (conversationId: string) => draftsRef.current[conversationId] ?? [],
+    []
+  );
+  const workContext = drafts[activeConversationId] ?? EMPTY_CONTEXT;
+
+  return {
+    workContext,
+    addWorkContext,
+    removeWorkContext,
+    setConversationWorkContext,
+    moveWorkContext,
+    removeConversationWorkContext,
+    clearWorkContext,
+    getConversationWorkContext,
+  };
+}

package/src/extensions/nocobase-ai/providers/use-conversation-catalog.ts

@@ -0,0 +1,108 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import type { AIConfigurationStatus, AIConversation } from "./types";
+
+export function useConversationCatalog({
+  configurationStatus,
+  listConversations,
+  onChange,
+  onError,
+}: {
+  configurationStatus: AIConfigurationStatus;
+  listConversations: (keyword?: string) => Promise<AIConversation[]>;
+  onChange: (conversations: AIConversation[]) => void;
+  onError: (error?: Error) => void;
+}) {
+  const [loading, setLoading] = useState(false);
+  const [search, setSearch] = useState("");
+  const searchRef = useRef("");
+  const requestRef = useRef(0);
+  const catalogRef = useRef<AIConversation[]>([]);
+
+  const apply = useCallback(
+    (conversations: AIConversation[], keyword = searchRef.current) => {
+      if (!keyword) catalogRef.current = conversations;
+      onChange(conversations);
+    },
+    [onChange]
+  );
+
+  const refresh = useCallback(async () => {
+    const requestId = requestRef.current + 1;
+    requestRef.current = requestId;
+    const keyword = searchRef.current;
+    const conversations = await listConversations(keyword);
+    if (requestRef.current === requestId) apply(conversations, keyword);
+    return conversations;
+  }, [apply, listConversations]);
+
+  useEffect(() => {
+    if (configurationStatus !== "ready") return;
+    let active = true;
+    setLoading(true);
+    onError(undefined);
+    void listConversations()
+      .then((conversations) => {
+        if (!active || searchRef.current) return;
+        apply(conversations, "");
+      })
+      .catch((error: unknown) => {
+        if (!active) return;
+        onError(
+          error instanceof Error
+            ? error
+            : new Error("Unable to load conversations")
+        );
+      })
+      .finally(() => {
+        if (active) setLoading(false);
+      });
+    return () => {
+      active = false;
+    };
+  }, [apply, configurationStatus, listConversations, onError]);
+
+  const searchConversations = useCallback(
+    async (keyword: string) => {
+      const normalizedKeyword = keyword.trim();
+      setSearch(keyword);
+      searchRef.current = normalizedKeyword;
+
+      const requestId = requestRef.current + 1;
+      requestRef.current = requestId;
+      setLoading(true);
+      onError(undefined);
+      try {
+        const conversations = await listConversations(normalizedKeyword);
+        if (requestRef.current !== requestId) return;
+        apply(conversations, normalizedKeyword);
+      } catch (error) {
+        if (requestRef.current !== requestId) return;
+        const resolvedError =
+          error instanceof Error
+            ? error
+            : new Error("Unable to search conversations");
+        onError(resolvedError);
+        throw resolvedError;
+      } finally {
+        if (requestRef.current === requestId) setLoading(false);
+      }
+    },
+    [apply, listConversations, onError]
+  );
+
+  const updateCatalog = useCallback(
+    (updater: (conversations: AIConversation[]) => AIConversation[]) => {
+      catalogRef.current = updater(catalogRef.current);
+    },
+    []
+  );
+
+  return {
+    loading,
+    search,
+    searchRef,
+    refresh,
+    searchConversations,
+    updateCatalog,
+  };
+}

package/src/extensions/nocobase-ai/providers/use-conversation-history.ts

@@ -0,0 +1,178 @@
+import type { Chat } from "@ai-sdk/react";
+import { useCallback, useEffect, useRef, useState } from "react";
+import type { NocoBaseChatTransport } from "./chat-transport";
+import { reconcileRefreshedMessages } from "./chat-message-utils";
+import { AI_DRAFT_CONVERSATION_ID, type AIChatMessage } from "./types";
+
+const isChatRunning = (chat: Chat<AIChatMessage>) =>
+  chat.status === "streaming" || chat.status === "submitted";
+
+export function useConversationHistory({
+  chatSurfaceOpen,
+  activeConversationId,
+  getActiveConversationId,
+  getChat,
+  getTransport,
+  getConversationMessages,
+  getConversationActiveState,
+  onMarkRead,
+  onError,
+}: {
+  chatSurfaceOpen: boolean;
+  activeConversationId: string;
+  getActiveConversationId: () => string;
+  getChat: (conversationId: string) => Chat<AIChatMessage>;
+  getTransport: (conversationId: string) => NocoBaseChatTransport | undefined;
+  getConversationMessages: (
+    conversationId: string,
+    options?: { updateRead?: boolean }
+  ) => Promise<AIChatMessage[]>;
+  getConversationActiveState: (
+    conversationId: string
+  ) => Promise<string | undefined>;
+  onMarkRead: (conversationId: string) => void;
+  onError: (error?: Error) => void;
+}) {
+  const surfaceOpenRef = useRef(chatSurfaceOpen);
+  const openVersionRef = useRef(0);
+  const pendingRequestsRef = useRef(
+    new Map<string, Promise<AIChatMessage[]>>()
+  );
+  const [loadingId, setLoadingId] = useState<string>();
+  surfaceOpenRef.current = chatSurfaceOpen;
+
+  const refresh = useCallback(
+    (
+      conversationId: string,
+      targetChat: Chat<AIChatMessage>,
+      options: { updateRead?: boolean } = {}
+    ) => {
+      const updateRead = options.updateRead === true;
+      const requestKey = `${conversationId}:${updateRead ? "read" : "peek"}`;
+      const pending = pendingRequestsRef.current.get(requestKey);
+      if (pending) return pending;
+
+      const request = getConversationMessages(conversationId, { updateRead })
+        .then((messages) => {
+          const reconciled = reconcileRefreshedMessages(
+            targetChat.messages,
+            messages
+          );
+          targetChat.messages = reconciled;
+          return reconciled;
+        })
+        .finally(() => pendingRequestsRef.current.delete(requestKey));
+      pendingRequestsRef.current.set(requestKey, request);
+      return request;
+    },
+    [getConversationMessages]
+  );
+
+  const load = useCallback(
+    async (conversationId: string) => {
+      const targetChat = getChat(conversationId);
+      if (isChatRunning(targetChat)) return;
+
+      const openVersion = openVersionRef.current + 1;
+      openVersionRef.current = openVersion;
+      setLoadingId(conversationId);
+      onError(undefined);
+      try {
+        await refresh(conversationId, targetChat, { updateRead: true });
+        onMarkRead(conversationId);
+      } catch (error) {
+        onError(
+          error instanceof Error
+            ? error
+            : new Error("Unable to load conversation messages")
+        );
+        return;
+      } finally {
+        setLoadingId((current) =>
+          current === conversationId ? undefined : current
+        );
+      }
+
+      if (
+        openVersionRef.current !== openVersion ||
+        getActiveConversationId() !== conversationId ||
+        isChatRunning(targetChat)
+      ) {
+        return;
+      }
+
+      try {
+        const activeState = await getConversationActiveState(conversationId);
+        if (
+          openVersionRef.current !== openVersion ||
+          getActiveConversationId() !== conversationId ||
+          isChatRunning(targetChat) ||
+          activeState !== "streaming"
+        ) {
+          return;
+        }
+        getTransport(conversationId)?.prepareConversationResume(
+          targetChat.messages
+        );
+        await targetChat.resumeStream();
+      } catch (error) {
+        onError(
+          error instanceof Error
+            ? error
+            : new Error("Unable to resume the conversation stream")
+        );
+      }
+    },
+    [
+      getActiveConversationId,
+      getChat,
+      getConversationActiveState,
+      getTransport,
+      onError,
+      onMarkRead,
+      refresh,
+    ]
+  );
+
+  useEffect(() => {
+    if (
+      !chatSurfaceOpen ||
+      activeConversationId === AI_DRAFT_CONVERSATION_ID
+    ) {
+      return;
+    }
+    const targetChat = getChat(activeConversationId);
+    if (isChatRunning(targetChat)) return;
+
+    void refresh(activeConversationId, targetChat, { updateRead: true })
+      .then(() => {
+        if (
+          surfaceOpenRef.current &&
+          getActiveConversationId() === activeConversationId
+        ) {
+          onMarkRead(activeConversationId);
+        }
+      })
+      .catch((error: unknown) => {
+        onError(
+          error instanceof Error
+            ? error
+            : new Error("Unable to mark the conversation as read")
+        );
+      });
+  }, [
+    activeConversationId,
+    chatSurfaceOpen,
+    getActiveConversationId,
+    getChat,
+    onError,
+    onMarkRead,
+    refresh,
+  ]);
+
+  const invalidate = useCallback(() => {
+    openVersionRef.current += 1;
+  }, []);
+
+  return { invalidate, load, loadingId, refresh };
+}

package/src/extensions/nocobase-ai/services/index.ts

@@ -0,0 +1,7 @@
+export { NocoBaseAIService, nocobaseAIService } from "./nocobase-ai-service";
+export type {
+  AIService,
+  CreateAIConversationOptions,
+  UpdateToolCallDecisionOptions,
+  UpdatedToolCall,
+} from "./types";