v4.6.2-alpah (#511)

packages/global/core/app/api.d.ts

@@ -1,5 +1,6 @@
+import type { ChatModelItemType } from '../ai/model.d';
 import { AppTypeEnum } from './constants';
-import { AppSchema } from './type';
+import { AppSchema, AppSimpleEditFormType } from './type';
 
 export type CreateAppParams = {
   name?: string;
@@ -11,8 +12,15 @@ export type CreateAppParams = {
 export interface AppUpdateParams {
   name?: string;
   type?: `${AppTypeEnum}`;
+  simpleTemplateId?: string;
   avatar?: string;
   intro?: string;
   modules?: AppSchema['modules'];
   permission?: AppSchema['permission'];
 }
+
+export type FormatForm2ModulesProps = {
+  formData: AppSimpleEditFormType;
+  chatModelMaxToken: number;
+  chatModelList: ChatModelItemType[];
+};

packages/global/core/app/constants.ts

@@ -1,4 +1,12 @@
 export enum AppTypeEnum {
-  basic = 'basic',
+  simple = 'simple',
   advanced = 'advanced'
 }
+export const AppTypeMap = {
+  [AppTypeEnum.simple]: {
+    label: 'simple'
+  },
+  [AppTypeEnum.advanced]: {
+    label: 'advanced'
+  }
+};

packages/global/core/app/type.d.ts

@@ -1,6 +1,9 @@
-import { ModuleItemType } from '../module/type';
+import type { AppTTSConfigType, ModuleItemType, VariableItemType } from '../module/type.d';
 import { AppTypeEnum } from './constants';
 import { PermissionTypeEnum } from '../../support/permission/constant';
+import type { AIChatModuleProps, DatasetModuleProps } from '../module/node/type.d';
+import { VariableInputEnum } from '../module/constants';
+import { SelectedDatasetType } from '../module/api';
 
 export interface AppSchema {
   _id: string;
@@ -9,6 +12,7 @@ export interface AppSchema {
   tmbId: string;
   name: string;
   type: `${AppTypeEnum}`;
+  simpleTemplateId: string;
   avatar: string;
   intro: string;
   updateTime: number;
@@ -29,3 +33,87 @@ export type AppDetailType = AppSchema & {
   isOwner: boolean;
   canWrite: boolean;
 };
+
+// export type AppSimpleEditFormType = {
+//   aiSettings: AIChatModuleProps;
+//   dataset: DatasetModuleProps & {
+//     searchEmptyText: string;
+//   };
+//   userGuide: {
+//     welcomeText: string;
+//     variables: VariableItemType[];
+//     questionGuide: boolean;
+//     tts: AppTTSConfigType;
+//   };
+// };
+// Since useform cannot infer enumeration types, all enumeration keys can only be undone manually
+export type AppSimpleEditFormType = {
+  templateId: string;
+  aiSettings: {
+    model: string;
+    systemPrompt?: string | undefined;
+    temperature: number;
+    maxToken: number;
+    isResponseAnswerText: boolean;
+    quoteTemplate?: string | undefined;
+    quotePrompt?: string | undefined;
+  };
+  dataset: {
+    datasets: SelectedDatasetType;
+    similarity: number;
+    limit: number;
+    rerank: boolean;
+    searchEmptyText: string;
+  };
+  userGuide: {
+    welcomeText: string;
+    variables: {
+      id: string;
+      key: string;
+      label: string;
+      type: `${VariableInputEnum}`;
+      required: boolean;
+      maxLen: number;
+      enums: {
+        value: string;
+      }[];
+    }[];
+    questionGuide: boolean;
+    tts: {
+      type: 'none' | 'web' | 'model';
+      model?: string | undefined;
+      voice?: string | undefined;
+      speed?: number | undefined;
+    };
+  };
+};
+
+/* simple mode template*/
+export type AppSimpleEditConfigTemplateType = {
+  id: string;
+  name: string;
+  desc: string;
+  systemForm: {
+    aiSettings?: {
+      model?: boolean;
+      systemPrompt?: boolean;
+      temperature?: boolean;
+      maxToken?: boolean;
+      quoteTemplate?: boolean;
+      quotePrompt?: boolean;
+    };
+    dataset?: {
+      datasets?: boolean;
+      similarity?: boolean;
+      limit?: boolean;
+      rerank?: boolean;
+      searchEmptyText?: boolean;
+    };
+    userGuide?: {
+      welcomeText?: boolean;
+      variables?: boolean;
+      questionGuide?: boolean;
+      tts?: boolean;
+    };
+  };
+};

packages/global/core/app/utils.ts

@@ -0,0 +1,123 @@
+import type { AppSimpleEditFormType } from '../app/type';
+import { FlowNodeTypeEnum } from '../module/node/constant';
+import { ModuleOutputKeyEnum, ModuleInputKeyEnum } from '../module/constants';
+import type { FlowNodeInputItemType } from '../module/node/type.d';
+import { getGuideModule, splitGuideModule } from '../module/utils';
+import { defaultChatModels } from '../ai/model';
+import { ModuleItemType } from '../module/type.d';
+
+export const getDefaultAppForm = (templateId = 'fastgpt-universal'): AppSimpleEditFormType => {
+  const defaultChatModel = defaultChatModels[0];
+
+  return {
+    templateId,
+    aiSettings: {
+      model: defaultChatModel?.model,
+      systemPrompt: '',
+      temperature: 0,
+      isResponseAnswerText: true,
+      quotePrompt: '',
+      quoteTemplate: '',
+      maxToken: defaultChatModel ? defaultChatModel.maxResponse / 2 : 4000
+    },
+    dataset: {
+      datasets: [],
+      similarity: 0.4,
+      limit: 5,
+      searchEmptyText: '',
+      rerank: false
+    },
+    userGuide: {
+      welcomeText: '',
+      variables: [],
+      questionGuide: false,
+      tts: {
+        type: 'web'
+      }
+    }
+  };
+};
+
+/* format app modules to edit form */
+export const appModules2Form = ({
+  templateId,
+  modules
+}: {
+  modules: ModuleItemType[];
+  templateId: string;
+}) => {
+  const defaultAppForm = getDefaultAppForm(templateId);
+
+  const findInputValueByKey = (inputs: FlowNodeInputItemType[], key: string) => {
+    return inputs.find((item) => item.key === key)?.value;
+  };
+
+  modules.forEach((module) => {
+    if (module.flowType === FlowNodeTypeEnum.chatNode) {
+      defaultAppForm.aiSettings.model = findInputValueByKey(
+        module.inputs,
+        ModuleInputKeyEnum.aiModel
+      );
+      defaultAppForm.aiSettings.systemPrompt = findInputValueByKey(
+        module.inputs,
+        ModuleInputKeyEnum.aiSystemPrompt
+      );
+      defaultAppForm.aiSettings.temperature = findInputValueByKey(
+        module.inputs,
+        ModuleInputKeyEnum.aiChatTemperature
+      );
+      defaultAppForm.aiSettings.maxToken = findInputValueByKey(
+        module.inputs,
+        ModuleInputKeyEnum.aiChatMaxToken
+      );
+      defaultAppForm.aiSettings.quoteTemplate = findInputValueByKey(
+        module.inputs,
+        ModuleInputKeyEnum.aiChatQuoteTemplate
+      );
+      defaultAppForm.aiSettings.quotePrompt = findInputValueByKey(
+        module.inputs,
+        ModuleInputKeyEnum.aiChatQuoteTemplate
+      );
+    } else if (module.flowType === FlowNodeTypeEnum.datasetSearchNode) {
+      defaultAppForm.dataset.datasets = findInputValueByKey(
+        module.inputs,
+        ModuleInputKeyEnum.datasetSelectList
+      );
+      defaultAppForm.dataset.similarity = findInputValueByKey(
+        module.inputs,
+        ModuleInputKeyEnum.datasetSimilarity
+      );
+      defaultAppForm.dataset.limit = findInputValueByKey(
+        module.inputs,
+        ModuleInputKeyEnum.datasetLimit
+      );
+      defaultAppForm.dataset.rerank = findInputValueByKey(
+        module.inputs,
+        ModuleInputKeyEnum.datasetStartReRank
+      );
+
+      // empty text
+      const emptyOutputs =
+        module.outputs.find((item) => item.key === ModuleOutputKeyEnum.datasetIsEmpty)?.targets ||
+        [];
+      const emptyOutput = emptyOutputs[0];
+      if (emptyOutput) {
+        const target = modules.find((item) => item.moduleId === emptyOutput.moduleId);
+        defaultAppForm.dataset.searchEmptyText =
+          target?.inputs?.find((item) => item.key === ModuleInputKeyEnum.answerText)?.value || '';
+      }
+    } else if (module.flowType === FlowNodeTypeEnum.userGuide) {
+      const { welcomeText, variableModules, questionGuide, ttsConfig } = splitGuideModule(
+        getGuideModule(modules)
+      );
+      defaultAppForm.userGuide = {
+        welcomeText: welcomeText,
+        variables: variableModules,
+        questionGuide: questionGuide,
+        tts: ttsConfig
+      };
+    }
+  });
+
+  return defaultAppForm;
+};