@nocobase/portal-template-default 1.0.3 → 1.0.4

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

@@ -1,210 +0,0 @@
-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

@@ -1,93 +0,0 @@
-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

@@ -1,108 +0,0 @@
-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

@@ -1,178 +0,0 @@
-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

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