@nocobase/portal-template-default 1.0.3 → 1.0.5

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

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

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

@@ -1,198 +0,0 @@
-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;
-};