@nocobase/portal-template-default 1.0.3 → 1.0.5

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

@@ -1,147 +0,0 @@
-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/src/extensions/nocobase-ai/providers/chat-task-utils.ts

@@ -1,105 +0,0 @@
-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/src/extensions/nocobase-ai/providers/chat-transport.ts

@@ -1,184 +0,0 @@
-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/src/extensions/nocobase-ai/providers/form-registry.tsx

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