@nocobase/portal-template-default 1.0.1 → 1.0.3

package/src/extensions/nocobase-ai/providers/chat-context.tsx

@@ -0,0 +1,109 @@
+import { createContext, useContext } from "react";
+import type {
+  AIChatAttachment,
+  AIChatMessage,
+  AIConversation,
+  AIEmployee,
+  AIEmployeeTask,
+  AIEmployeeTaskTrigger,
+  AIModel,
+  AIToolCallDecision,
+  AIWorkContextItem,
+} from "./types";
+
+export type AIChatContextValue = {
+  id: string;
+  messages: AIChatMessage[];
+  status: "submitted" | "streaming" | "ready" | "error";
+  error?: Error;
+  employees: AIEmployee[];
+  models: AIModel[];
+  currentEmployee: AIEmployee;
+  currentModel: AIModel;
+  activeConversation?: AIConversation;
+  activeConversationId: string;
+  conversations: AIConversation[];
+  conversationsLoading: boolean;
+  conversationSearch: string;
+  messagesLoading: boolean;
+  historyError?: Error;
+  interactionError?: Error;
+  conversationListOpen: boolean;
+  availableTasks: AIEmployeeTask[];
+  composerFocusRequest: number;
+  draft: string;
+  attachments: AIChatAttachment[];
+  uploadingAttachments: boolean;
+  workContext: AIWorkContextItem[];
+  editingMessageId?: string;
+  setDraft: (value: string) => void;
+  uploadFiles: (files: File[]) => Promise<void>;
+  removeAttachment: (uid: string) => void;
+  addWorkContext: (item: AIWorkContextItem) => void;
+  removeWorkContext: (item: AIWorkContextItem) => void;
+  send: () => Promise<void>;
+  stop: () => Promise<void>;
+  regenerate: () => Promise<void>;
+  retryMessage: (message: AIChatMessage) => Promise<void>;
+  decideToolCall: (decision: AIToolCallDecision) => Promise<void>;
+  startNewConversation: () => void;
+  selectConversation: (conversationId: string) => void;
+  renameConversation: (conversationId: string, title: string) => Promise<void>;
+  removeConversation: (conversationId: string) => Promise<void>;
+  searchConversations: (keyword: string) => Promise<void>;
+  setConversationListOpen: (open: boolean) => void;
+  selectEmployee: (username: string) => void;
+  selectModel: (model: string) => void;
+  startEditingMessage: (message: AIChatMessage) => Promise<void>;
+  cancelEditingMessage: () => void;
+  saveUserPrompt: (prompt: string) => Promise<void>;
+  triggerTask: (options: AIEmployeeTaskTrigger) => Promise<void>;
+  runTask: (task: AIEmployeeTask) => void;
+  focusComposer: () => void;
+};
+
+export type AIChatMessagesContextValue = Pick<AIChatContextValue, "messages">;
+export type AIChatStatusContextValue = Pick<
+  AIChatContextValue,
+  "status" | "error"
+>;
+export type AIChatBaseContextValue = Omit<
+  AIChatContextValue,
+  keyof AIChatMessagesContextValue | keyof AIChatStatusContextValue
+>;
+
+export const AIChatContext = createContext<AIChatBaseContextValue | null>(null);
+export const AIChatMessagesContext =
+  createContext<AIChatMessagesContextValue | null>(null);
+export const AIChatStatusContext =
+  createContext<AIChatStatusContextValue | null>(null);
+
+export function useAIChatBase() {
+  const value = useContext(AIChatContext);
+  if (!value) throw new Error("useAIChatBase must be used inside AIChatProvider");
+  return value;
+}
+
+export function useAIChatMessages() {
+  const value = useContext(AIChatMessagesContext);
+  if (!value) {
+    throw new Error("useAIChatMessages must be used inside AIChatProvider");
+  }
+  return value;
+}
+
+export function useAIChatStatus() {
+  const value = useContext(AIChatStatusContext);
+  if (!value) {
+    throw new Error("useAIChatStatus must be used inside AIChatProvider");
+  }
+  return value;
+}
+
+export function useAIChat() {
+  return {
+    ...useAIChatBase(),
+    ...useAIChatMessages(),
+    ...useAIChatStatus(),
+  };
+}

package/src/extensions/nocobase-ai/providers/chat-controller.ts

@@ -0,0 +1,84 @@
+import { useRef, useSyncExternalStore } from "react";
+import type { AIEmployeeTaskTrigger } from "./types";
+
+export type AIChatControllerSnapshot = {
+  open: boolean;
+};
+
+export type AIChatController = {
+  getSnapshot: () => AIChatControllerSnapshot;
+  subscribe: (listener: () => void) => () => void;
+  setOpen: (open: boolean) => void;
+  open: () => void;
+  close: () => void;
+  triggerTask: (options: AIEmployeeTaskTrigger) => void;
+  bindTaskHandler: (
+    handler: (options: AIEmployeeTaskTrigger) => void | Promise<void>
+  ) => () => void;
+};
+
+export function createAIChatController(): AIChatController {
+  let snapshot: AIChatControllerSnapshot = { open: false };
+  let taskHandler:
+    | ((options: AIEmployeeTaskTrigger) => void | Promise<void>)
+    | undefined;
+  const listeners = new Set<() => void>();
+  const pendingTasks: AIEmployeeTaskTrigger[] = [];
+
+  const setOpen = (open: boolean) => {
+    if (snapshot.open === open) return;
+    snapshot = { open };
+    listeners.forEach((listener) => listener());
+  };
+
+  return {
+    getSnapshot: () => snapshot,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    setOpen,
+    open: () => setOpen(true),
+    close: () => setOpen(false),
+    triggerTask: (options) => {
+      if (taskHandler) {
+        void taskHandler(options);
+        return;
+      }
+      pendingTasks.push(options);
+      if (pendingTasks.length > 20) pendingTasks.shift();
+    },
+    bindTaskHandler: (handler) => {
+      if (taskHandler && taskHandler !== handler) {
+        console.warn(
+          "An AIChatController should be bound to only one AIChatProvider at a time."
+        );
+      }
+      taskHandler = handler;
+      pendingTasks.splice(0).forEach((task) => void handler(task));
+      return () => {
+        if (taskHandler === handler) taskHandler = undefined;
+      };
+    },
+  };
+}
+
+export function useAIChatController() {
+  const controllerRef = useRef<AIChatController | null>(null);
+  if (!controllerRef.current) {
+    controllerRef.current = createAIChatController();
+  }
+  return controllerRef.current;
+}
+
+const visibleControllerSnapshot: AIChatControllerSnapshot = { open: true };
+const subscribeToVisibleController = () => () => undefined;
+const getVisibleControllerSnapshot = () => visibleControllerSnapshot;
+
+export function useAIChatControllerState(controller?: AIChatController) {
+  return useSyncExternalStore(
+    controller?.subscribe ?? subscribeToVisibleController,
+    controller?.getSnapshot ?? getVisibleControllerSnapshot,
+    controller?.getSnapshot ?? getVisibleControllerSnapshot
+  );
+}

package/src/extensions/nocobase-ai/providers/chat-message-utils.ts

@@ -0,0 +1,198 @@
+import type { AIChatMessage, AISubAgentConversation } from "./types";
+
+export type AIToolPart = Extract<
+  AIChatMessage["parts"][number],
+  { type: `tool-${string}` | "dynamic-tool" }
+>;
+
+export type AISubAgentPart = Extract<
+  AIChatMessage["parts"][number],
+  { type: "data-subAgent" }
+>;
+
+export const isAIToolPart = (
+  part: AIChatMessage["parts"][number]
+): part is AIToolPart =>
+  part.type === "dynamic-tool" || part.type.startsWith("tool-");
+
+export const isAISubAgentPart = (
+  part: AIChatMessage["parts"][number]
+): part is AISubAgentPart => part.type === "data-subAgent";
+
+export const getNocoBaseToolMetadata = (part: AIToolPart) => {
+  if (!("callProviderMetadata" in part)) return undefined;
+  const metadata = part.callProviderMetadata?.nocobase;
+  return metadata && typeof metadata === "object"
+    ? (metadata as { autoApprove?: unknown })
+    : undefined;
+};
+
+const getMessageToolCallIds = (message: AIChatMessage) =>
+  new Set(
+    message.parts
+      .filter(isAIToolPart)
+      .map((part) => part.toolCallId)
+      .filter(Boolean)
+  );
+
+const getMessageText = (message: AIChatMessage) =>
+  message.parts
+    .filter((part) => part.type === "text")
+    .map((part) => part.text)
+    .join("\n");
+
+const getSubAgentSessionIds = (message: AIChatMessage) =>
+  new Set(
+    message.parts
+      .filter(isAISubAgentPart)
+      .map((part) => part.data.sessionId)
+      .filter(Boolean)
+  );
+
+const reconcileConversation = (
+  current: AISubAgentConversation,
+  refreshed: AISubAgentConversation
+): AISubAgentConversation => ({
+  ...refreshed,
+  messages: reconcileRefreshedMessages(current.messages, refreshed.messages),
+});
+
+const reconcileSubAgents = (
+  currentMessage: AIChatMessage,
+  refreshedMessage: AIChatMessage
+) => {
+  const current = currentMessage.parts.filter(isAISubAgentPart);
+  return refreshedMessage.parts.map((part) => {
+    if (!isAISubAgentPart(part)) return part;
+    const currentPart = current.find(
+      (item) => item.data.sessionId === part.data.sessionId
+    );
+    return currentPart
+      ? {
+          ...part,
+          data: reconcileConversation(currentPart.data, part.data),
+        }
+      : part;
+  });
+};
+
+export const reconcileRefreshedMessages = (
+  current: AIChatMessage[],
+  refreshed: AIChatMessage[]
+) => {
+  const usedCurrentIds = new Set<string>();
+  const byServerMessageId = new Map<string, AIChatMessage>();
+  const bySubAgentSessionId = new Map<string, AIChatMessage[]>();
+  const byToolCallId = new Map<string, AIChatMessage[]>();
+  const byRoleAndText = new Map<string, AIChatMessage[]>();
+  const addToIndex = (
+    index: Map<string, AIChatMessage[]>,
+    key: string,
+    message: AIChatMessage
+  ) => {
+    const messages = index.get(key);
+    if (messages) messages.push(message);
+    else index.set(key, [message]);
+  };
+  for (const message of current) {
+    const serverMessageId = message.metadata?.serverMessageId;
+    if (serverMessageId) byServerMessageId.set(serverMessageId, message);
+    for (const sessionId of getSubAgentSessionIds(message)) {
+      addToIndex(bySubAgentSessionId, sessionId, message);
+    }
+    for (const toolCallId of getMessageToolCallIds(message)) {
+      addToIndex(byToolCallId, toolCallId, message);
+    }
+    const text = getMessageText(message);
+    if (text) addToIndex(byRoleAndText, `${message.role}\0${text}`, message);
+  }
+  const firstUnused = (messages: AIChatMessage[] | undefined) =>
+    messages?.find((message) => !usedCurrentIds.has(message.id));
+
+  return refreshed.map((serverMessage) => {
+    const serverToolCallIds = getMessageToolCallIds(serverMessage);
+    const serverMessageId = serverMessage.metadata?.serverMessageId;
+    let match = serverMessageId
+      ? byServerMessageId.get(serverMessageId)
+      : undefined;
+    if (match && usedCurrentIds.has(match.id)) match = undefined;
+    const serverSubAgentSessionIds = getSubAgentSessionIds(serverMessage);
+    if (!match && serverSubAgentSessionIds.size) {
+      for (const sessionId of serverSubAgentSessionIds) {
+        match = firstUnused(bySubAgentSessionId.get(sessionId));
+        if (match?.role === serverMessage.role) break;
+        match = undefined;
+      }
+    }
+    if (!match && !serverSubAgentSessionIds.size && serverToolCallIds.size) {
+      for (const toolCallId of serverToolCallIds) {
+        match = firstUnused(byToolCallId.get(toolCallId));
+        if (match?.role === serverMessage.role) break;
+        match = undefined;
+      }
+    }
+    if (!match && !serverSubAgentSessionIds.size && !serverToolCallIds.size) {
+      const serverText = getMessageText(serverMessage);
+      if (serverText) {
+        match = firstUnused(
+          byRoleAndText.get(`${serverMessage.role}\0${serverText}`)
+        );
+      }
+    }
+    if (!match) return serverMessage;
+    usedCurrentIds.add(match.id);
+    return {
+      ...serverMessage,
+      id: match.id,
+      parts: reconcileSubAgents(match, serverMessage),
+    };
+  });
+};
+
+export type ResolvedChatMessage = {
+  rootMessage: AIChatMessage;
+  targetMessage: AIChatMessage;
+  rootIndex: number;
+};
+
+export const findChatMessage = (
+  messages: AIChatMessage[],
+  messageId: string
+): ResolvedChatMessage | undefined => {
+  const findNestedMessage = (
+    message: AIChatMessage
+  ): AIChatMessage | undefined => {
+    if (message.id === messageId) return message;
+    for (const part of message.parts) {
+      if (!isAISubAgentPart(part)) continue;
+      for (const nestedMessage of part.data.messages) {
+        const match = findNestedMessage(nestedMessage);
+        if (match) return match;
+      }
+    }
+    return undefined;
+  };
+
+  for (const [rootIndex, rootMessage] of messages.entries()) {
+    const targetMessage = findNestedMessage(rootMessage);
+    if (targetMessage) return { rootMessage, targetMessage, rootIndex };
+  }
+  return undefined;
+};
+
+export const getChatToolParts = (messages: AIChatMessage[]) => {
+  const result: Array<{ message: AIChatMessage; part: AIToolPart }> = [];
+  const visit = (items: AIChatMessage[]) => {
+    for (const message of items) {
+      for (const part of message.parts) {
+        if (isAIToolPart(part)) {
+          result.push({ message, part });
+        } else if (isAISubAgentPart(part)) {
+          visit(part.data.messages);
+        }
+      }
+    }
+  };
+  visit(messages);
+  return result;
+};