@nocobase/portal-template-default 1.0.0 → 1.0.2

package/registry/nocobase-ai/providers/chat-reducer.ts

@@ -0,0 +1,147 @@
+import { AI_DRAFT_CONVERSATION_ID, type AIConversation } from "./types";
+
+export type AIChatState = {
+  activeConversationId: string;
+  conversations: AIConversation[];
+  conversationListOpen: boolean;
+  drafts: Record<string, string>;
+  selectedEmployeeUsername: string;
+  selectedModel: string;
+};
+
+export type AIChatAction =
+  | { type: "reset"; state: AIChatState }
+  | { type: "set-active-conversation"; conversationId: string }
+  | { type: "set-conversation-list-open"; open: boolean }
+  | { type: "set-draft"; conversationId: string; value: string }
+  | { type: "select-employee"; username: string }
+  | { type: "select-model"; model: string }
+  | { type: "start-new-conversation" }
+  | { type: "add-conversation"; conversation: AIConversation }
+  | { type: "set-conversations"; conversations: AIConversation[] }
+  | { type: "remove-conversation"; conversationId: string }
+  | { type: "mark-conversation-read"; conversationId: string }
+  | { type: "rename-conversation"; conversationId: string; title: string }
+  | { type: "replace-conversation-id"; from: string; to: string };
+
+export function createAIChatState({
+  conversations,
+  employeeUsername,
+  model,
+}: {
+  conversations: AIConversation[];
+  employeeUsername: string;
+  model: string;
+}): AIChatState {
+  return {
+    activeConversationId: conversations[0]?.id ?? AI_DRAFT_CONVERSATION_ID,
+    conversations,
+    conversationListOpen: false,
+    drafts: {},
+    selectedEmployeeUsername: employeeUsername,
+    selectedModel: model,
+  };
+}
+
+export function aiChatReducer(
+  state: AIChatState,
+  action: AIChatAction
+): AIChatState {
+  switch (action.type) {
+    case "reset":
+      return action.state;
+    case "set-active-conversation":
+      return {
+        ...state,
+        activeConversationId: action.conversationId,
+        conversationListOpen: false,
+        conversations: state.conversations.map((conversation) =>
+          conversation.id === action.conversationId
+            ? { ...conversation, unread: false }
+            : conversation
+        ),
+      };
+    case "set-conversation-list-open":
+      return { ...state, conversationListOpen: action.open };
+    case "set-draft":
+      return {
+        ...state,
+        drafts: { ...state.drafts, [action.conversationId]: action.value },
+      };
+    case "select-employee":
+      return { ...state, selectedEmployeeUsername: action.username };
+    case "select-model":
+      return { ...state, selectedModel: action.model };
+    case "start-new-conversation":
+      return {
+        ...state,
+        activeConversationId: AI_DRAFT_CONVERSATION_ID,
+        conversationListOpen: false,
+        drafts: { ...state.drafts, [AI_DRAFT_CONVERSATION_ID]: "" },
+      };
+    case "add-conversation":
+      return {
+        ...state,
+        activeConversationId: action.conversation.id,
+        conversations: [
+          action.conversation,
+          ...state.conversations.filter(
+            (conversation) => conversation.id !== action.conversation.id
+          ),
+        ],
+        drafts: {
+          ...state.drafts,
+          [action.conversation.id]:
+            state.drafts[AI_DRAFT_CONVERSATION_ID] ?? "",
+        },
+      };
+    case "set-conversations":
+      return {
+        ...state,
+        conversations: action.conversations,
+      };
+    case "mark-conversation-read":
+      return {
+        ...state,
+        conversations: state.conversations.map((conversation) =>
+          conversation.id === action.conversationId
+            ? { ...conversation, unread: false }
+            : conversation
+        ),
+      };
+    case "remove-conversation": {
+      const conversations = state.conversations.filter(
+        (conversation) => conversation.id !== action.conversationId
+      );
+      return { ...state, conversations };
+    }
+    case "rename-conversation":
+      return {
+        ...state,
+        conversations: state.conversations.map((conversation) =>
+          conversation.id === action.conversationId
+            ? { ...conversation, title: action.title }
+            : conversation
+        ),
+      };
+    case "replace-conversation-id":
+      return {
+        ...state,
+        activeConversationId:
+          state.activeConversationId === action.from
+            ? action.to
+            : state.activeConversationId,
+        conversations: state.conversations.map((conversation) =>
+          conversation.id === action.from
+            ? { ...conversation, id: action.to }
+            : conversation
+        ),
+        drafts: {
+          ...state.drafts,
+          [action.to]: state.drafts[action.from] ?? "",
+        },
+      };
+    default:
+      return state;
+  }
+}

package/registry/nocobase-ai/providers/chat-task-utils.ts

@@ -0,0 +1,105 @@
+import { getAIWorkContextRequiredTools, mergeAIRequiredTools } from "./page-context";
+import type {
+  AIChatTaskRuntime,
+  AIEmployee,
+  AIEmployeeTask,
+  AIEmployeeTasks,
+  AIEmployeeTaskTrigger,
+  AIModel,
+  AIWorkContextItem,
+} from "./types";
+
+const EMPTY_TASKS: AIEmployeeTask[] = [];
+
+export type AIChatTaskSet = {
+  employeeUsername: string;
+  tasks: AIEmployeeTask[];
+  context?: AIWorkContextItem[];
+};
+
+export function getConfiguredAIChatTaskSet({
+  employeeUsername,
+  defaultEmployeeUsername,
+  defaultTasks,
+  employeeTasks,
+  inheritedContext,
+}: {
+  employeeUsername: string;
+  defaultEmployeeUsername: string;
+  defaultTasks: AIEmployeeTask[];
+  employeeTasks: AIEmployeeTasks;
+  inheritedContext: AIWorkContextItem[];
+}): AIChatTaskSet | undefined {
+  const tasks =
+    employeeTasks[employeeUsername] ??
+    (employeeUsername === defaultEmployeeUsername
+      ? defaultTasks
+      : EMPTY_TASKS);
+  return tasks.length
+    ? { employeeUsername, tasks, context: inheritedContext }
+    : undefined;
+}
+
+export function findTriggeredAIEmployee(
+  employees: AIEmployee[],
+  requested: AIEmployeeTaskTrigger["aiEmployee"]
+) {
+  return typeof requested === "string"
+    ? employees.find((item) => item.username === requested)
+    : employees.find((item) => item.username === requested.username) ??
+        requested;
+}
+
+export function getTriggeredAIEmployeeTask(options: AIEmployeeTaskTrigger) {
+  return (
+    options.task ??
+    (options.tasks?.length === 1 && options.auto !== false
+      ? options.tasks[0]
+      : undefined)
+  );
+}
+
+export function getTriggeredAIWorkContext(
+  options: AIEmployeeTaskTrigger,
+  task: AIEmployeeTask | undefined,
+  inheritedContext: AIWorkContextItem[]
+) {
+  const taskContext = task?.message?.workContext ?? [];
+  return taskContext.length
+    ? taskContext
+    : options.context?.length
+    ? options.context
+    : inheritedContext;
+}
+
+export function createAIChatTaskRuntime(
+  task: AIEmployeeTask | undefined,
+  workContext: AIWorkContextItem[]
+): AIChatTaskRuntime {
+  const requiredTools = getAIWorkContextRequiredTools(workContext);
+  return task
+    ? {
+        systemMessage: task.message?.system,
+        workContext: [],
+        skillSettings: mergeAIRequiredTools(task.skillSettings, requiredTools),
+        webSearch: task.webSearch,
+      }
+    : {
+        workContext: [],
+        skillSettings: mergeAIRequiredTools(undefined, requiredTools),
+      };
+}
+
+export function findAIChatTaskModel(
+  models: AIModel[],
+  task: AIEmployeeTask | undefined
+) {
+  return task?.model
+    ? models.find(
+        (item) =>
+          item.value === task.model?.model &&
+          (!task.model.llmService ||
+            item.llmService === task.model.llmService)
+      )
+    : undefined;
+}

package/registry/nocobase-ai/providers/chat-transport.ts

@@ -0,0 +1,184 @@
+import type { ChatTransport } from "ai";
+import type { AIService } from "../services";
+import type { AIChatMessage, AIChatRequestContext } from "./types";
+import { createNocoBaseUIMessageStream } from "./ui-message-stream";
+
+const messageText = (message?: AIChatMessage) =>
+  message?.parts
+    .filter((part) => part.type === "text")
+    .map((part) => part.text)
+    .join("\n") ?? "";
+
+export class NocoBaseChatTransport implements ChatTransport<AIChatMessage> {
+  private pendingResend?: { messageId: string };
+  private pendingConversationResume?: { message?: AIChatMessage };
+  private pendingToolResume?: {
+    messageId: string;
+    responseMessageId: string;
+    toolCallIds: string[];
+    toolCallResults: Array<{ id: string; result: unknown }>;
+  };
+
+  constructor(
+    private readonly options: {
+      service: AIService;
+      getContext: () => AIChatRequestContext;
+      onSessionCreated?: (sessionId: string) => void;
+    }
+  ) {}
+
+  prepareResend(messageId: string) {
+    this.pendingResend = { messageId };
+  }
+
+  cancelResend(messageId: string) {
+    if (this.pendingResend?.messageId === messageId) {
+      this.pendingResend = undefined;
+    }
+  }
+
+  prepareConversationResume(messages: AIChatMessage[]) {
+    this.pendingConversationResume = {
+      message: [...messages]
+        .reverse()
+        .find((message) => message.role === "assistant"),
+    };
+  }
+
+  prepareToolResume(
+    messageId: string,
+    responseMessageId: string,
+    toolCallIds: string[],
+    toolCallResults: Array<{ id: string; result: unknown }>
+  ) {
+    this.pendingToolResume = {
+      messageId,
+      responseMessageId,
+      toolCallIds,
+      toolCallResults,
+    };
+  }
+
+  cancelToolResume(messageId: string) {
+    if (this.pendingToolResume?.messageId === messageId) {
+      this.pendingToolResume = undefined;
+    }
+  }
+
+  async sendMessages({
+    messages,
+    abortSignal,
+  }: Parameters<ChatTransport<AIChatMessage>["sendMessages"]>[0]) {
+    const context = this.options.getContext();
+    if (context.model.configured === false) {
+      throw new Error(
+        "No enabled LLM model is configured in NocoBase. Configure and enable an LLM service before starting a conversation."
+      );
+    }
+    let sessionId = context.sessionId;
+
+    const pendingResend = this.pendingResend;
+    this.pendingResend = undefined;
+    if (pendingResend) {
+      if (!sessionId) {
+        throw new Error("A conversation is required to retry a message.");
+      }
+      const stream = await this.options.service.resendMessagesStream(
+        {
+          sessionId,
+          messageId: pendingResend.messageId,
+          model: {
+            llmService: context.model.llmService,
+            model: context.model.value,
+          },
+          webSearch: context.task?.webSearch,
+        },
+        abortSignal
+      );
+      return createNocoBaseUIMessageStream(stream);
+    }
+
+    if (!sessionId) {
+      sessionId = await this.options.service.createConversation({
+        employee: context.employee,
+        model: context.model,
+        systemMessage: context.task?.systemMessage,
+        skillSettings: context.task?.skillSettings,
+      });
+      this.options.onSessionCreated?.(sessionId);
+    }
+
+    const lastMessage = messages.at(-1);
+    const attachments = lastMessage?.metadata?.attachments?.filter(
+      (attachment) => attachment.status === "done"
+    );
+    const workContext = [
+      ...(context.task?.workContext ?? []),
+      ...(lastMessage?.metadata?.workContext ?? []),
+    ];
+    const stream = await this.options.service.sendMessagesStream(
+      {
+        sessionId,
+        aiEmployee: context.employee.username,
+        model: {
+          llmService: context.model.llmService,
+          model: context.model.value,
+        },
+        systemMessage: context.task?.systemMessage,
+        skillSettings: context.task?.skillSettings,
+        webSearch: context.task?.webSearch,
+        editingMessageId: lastMessage?.metadata?.editingMessageId,
+        messages: [
+          {
+            key: lastMessage?.id ?? crypto.randomUUID(),
+            role: "user",
+            content: { type: "text", content: messageText(lastMessage) },
+            attachments: attachments?.length ? attachments : undefined,
+            workContext: workContext.length ? workContext : undefined,
+          },
+        ],
+      },
+      abortSignal
+    );
+
+    return createNocoBaseUIMessageStream(stream);
+  }
+
+  async reconnectToStream() {
+    const pendingToolResume = this.pendingToolResume;
+    this.pendingToolResume = undefined;
+    const pendingConversationResume = this.pendingConversationResume;
+    this.pendingConversationResume = undefined;
+    const context = this.options.getContext();
+    if (!context.sessionId) {
+      throw new Error("A conversation is required to resume a stream.");
+    }
+
+    if (!pendingToolResume) {
+      const stream = await this.options.service.resumeConversationStream(
+        context.sessionId
+      );
+      return createNocoBaseUIMessageStream(stream, null, {
+        seedMessage: pendingConversationResume?.message,
+      });
+    }
+    const stream = await this.options.service.resumeToolCallStream({
+      sessionId: context.sessionId,
+      messageId: pendingToolResume.messageId,
+      toolCallIds: pendingToolResume.toolCallIds,
+      toolCallResults: pendingToolResume.toolCallResults,
+      model: {
+        llmService: context.model.llmService,
+        model: context.model.value,
+      },
+      webSearch: context.task?.webSearch,
+    });
+    return createNocoBaseUIMessageStream(
+      stream,
+      pendingToolResume.responseMessageId,
+      {
+        waitForNewMessage: true,
+      }
+    );
+  }
+}

package/registry/nocobase-ai/providers/form-registry.tsx

@@ -0,0 +1,271 @@
+import {
+  createContext,
+  useContext,
+  useMemo,
+  type PropsWithChildren,
+} from "react";
+import type { AIToolInvoker } from "./types";
+
+export type AIFormField = {
+  name: string;
+  title?: string;
+  type?: string;
+  description?: string;
+  readonly?: boolean;
+  required?: boolean;
+  enum?: unknown;
+  [key: string]: unknown;
+};
+
+export type AIFormTarget = {
+  id: string;
+  title: string;
+  fields: AIFormField[];
+  getValues: () => unknown | Promise<unknown>;
+  setValues: (values: Record<string, unknown>) => void | Promise<void>;
+};
+
+export type AIFormFillSkippedField = {
+  name: string;
+  reason: "undeclared" | "readonly" | "invalid";
+  message: string;
+};
+
+export type AIFormFillResult = {
+  status: "success" | "error";
+  content: string;
+  appliedFields: string[];
+  skippedFields: AIFormFillSkippedField[];
+};
+
+export class AIFormRegistry {
+  private readonly targets = new Map<
+    string,
+    { token: symbol; target: AIFormTarget }
+  >();
+
+  register(target: AIFormTarget) {
+    if (!target.id.trim()) throw new Error("AI Form id is required");
+    if (!target.title.trim()) throw new Error("AI Form title is required");
+    if (!Array.isArray(target.fields)) {
+      throw new Error("AI Form fields must be an array");
+    }
+    if (typeof target.getValues !== "function") {
+      throw new Error("AI Form getValues must be a function");
+    }
+    if (typeof target.setValues !== "function") {
+      throw new Error("AI Form setValues must be a function");
+    }
+    const fieldNames = new Set<string>();
+    for (const field of target.fields) {
+      if (!field.name?.trim()) throw new Error("AI Form field name is required");
+      if (fieldNames.has(field.name)) {
+        throw new Error(
+          `AI Form field "${field.name}" is declared more than once`
+        );
+      }
+      fieldNames.add(field.name);
+    }
+    if (this.targets.has(target.id)) {
+      throw new Error(`AI Form "${target.id}" is already registered`);
+    }
+    const token = Symbol(target.id);
+    this.targets.set(target.id, { token, target });
+    return () => {
+      if (this.targets.get(target.id)?.token === token) {
+        this.targets.delete(target.id);
+      }
+    };
+  }
+
+  get(formId: string) {
+    return this.targets.get(formId)?.target;
+  }
+}
+
+const AIFormRegistryContext = createContext<AIFormRegistry | null>(null);
+
+export function AIFormRegistryProvider({ children }: PropsWithChildren) {
+  const registry = useMemo(() => new AIFormRegistry(), []);
+  return (
+    <AIFormRegistryContext.Provider value={registry}>
+      {children}
+    </AIFormRegistryContext.Provider>
+  );
+}
+
+export function useAIFormRegistry() {
+  const registry = useContext(AIFormRegistryContext);
+  if (!registry) {
+    throw new Error(
+      "useAIFormRegistry must be used inside AIFormRegistryProvider"
+    );
+  }
+  return registry;
+}
+
+const getErrorMessage = (error: unknown) =>
+  error instanceof Error ? error.message : String(error);
+
+const getEnumValues = (definition: unknown) => {
+  if (!Array.isArray(definition)) return undefined;
+  return definition.map((item) => {
+    if (item && typeof item === "object" && !Array.isArray(item)) {
+      return (item as { value?: unknown }).value;
+    }
+    return item;
+  });
+};
+
+const validateFieldValue = (field: AIFormField, value: unknown) => {
+  const enumValues = getEnumValues(field.enum);
+  if (enumValues?.length && !enumValues.some((item) => Object.is(item, value))) {
+    return "The value is not one of the declared options.";
+  }
+
+  switch (field.type?.toLowerCase()) {
+    case "string":
+    case "text":
+    case "textarea":
+    case "email":
+    case "url":
+    case "date":
+    case "datetime":
+      return typeof value === "string" ? undefined : "Expected a string.";
+    case "number":
+    case "percent":
+      return typeof value === "number" && Number.isFinite(value)
+        ? undefined
+        : "Expected a finite number.";
+    case "integer":
+      return typeof value === "number" && Number.isInteger(value)
+        ? undefined
+        : "Expected an integer.";
+    case "boolean":
+    case "checkbox":
+      return typeof value === "boolean" ? undefined : "Expected a boolean.";
+    case "array":
+      return Array.isArray(value) ? undefined : "Expected an array.";
+    case "object":
+      return value && typeof value === "object" && !Array.isArray(value)
+        ? undefined
+        : "Expected an object.";
+    default:
+      return undefined;
+  }
+};
+
+export function createFormFillerInvoker(
+  registry: AIFormRegistry
+): AIToolInvoker {
+  return async (input, context) => {
+    if (!input || typeof input !== "object" || Array.isArray(input)) {
+      return {
+        status: "error",
+        content: "Form filler requires a form identifier and field data.",
+        appliedFields: [],
+        skippedFields: [],
+      };
+    }
+
+    const { form, data } = input as { form?: unknown; data?: unknown };
+    if (typeof form !== "string" || !form) {
+      return {
+        status: "error",
+        content: "The target form identifier is missing.",
+        appliedFields: [],
+        skippedFields: [],
+      };
+    }
+    if (context.allowedFormIds?.includes(form) !== true) {
+      return {
+        status: "error",
+        content: `The target form "${form}" is not available in this conversation context.`,
+        appliedFields: [],
+        skippedFields: [],
+      };
+    }
+    if (!data || typeof data !== "object" || Array.isArray(data)) {
+      return {
+        status: "error",
+        content: "Form filler data must be an object.",
+        appliedFields: [],
+        skippedFields: [],
+      };
+    }
+
+    const target = registry.get(form);
+    if (!target) {
+      return {
+        status: "error",
+        content: `The target form "${form}" is not available on this page.`,
+        appliedFields: [],
+        skippedFields: [],
+      };
+    }
+
+    try {
+      const fields = new Map(target.fields.map((field) => [field.name, field]));
+      const accepted: Record<string, unknown> = {};
+      const skippedFields: AIFormFillSkippedField[] = [];
+      for (const [name, value] of Object.entries(
+        data as Record<string, unknown>
+      )) {
+        const field = fields.get(name);
+        if (!field) {
+          skippedFields.push({
+            name,
+            reason: "undeclared",
+            message: "This field is not declared by the target form.",
+          });
+          continue;
+        }
+        if (field.readonly) {
+          skippedFields.push({
+            name,
+            reason: "readonly",
+            message: "This field is read-only.",
+          });
+          continue;
+        }
+        const validationError = validateFieldValue(field, value);
+        if (validationError) {
+          skippedFields.push({
+            name,
+            reason: "invalid",
+            message: validationError,
+          });
+          continue;
+        }
+        accepted[name] = value;
+      }
+
+      const appliedFields = Object.keys(accepted);
+      if (!appliedFields.length) {
+        return {
+          status: "error",
+          content: `No valid editable fields were provided for "${target.title}".`,
+          appliedFields,
+          skippedFields,
+        } satisfies AIFormFillResult;
+      }
+
+      await target.setValues(accepted);
+      return {
+        status: "success",
+        content: skippedFields.length
+          ? `Filled ${appliedFields.length} field(s) in "${target.title}" and skipped ${skippedFields.length}. Please review the values and submit the form manually.`
+          : `Filled "${target.title}". Please review the values and submit the form manually.`,
+        appliedFields,
+        skippedFields,
+      } satisfies AIFormFillResult;
+    } catch (error) {
+      return {
+        status: "error",
+        content: `Unable to fill "${target.title}": ${getErrorMessage(error)}`,
+        appliedFields: [],
+        skippedFields: [],
+      } satisfies AIFormFillResult;
+    }
+  };
+}