v4.5.2 (#439)

projects/app/src/pages/api/admin/initv445.ts

@@ -2,7 +2,7 @@ import type { NextApiRequest, NextApiResponse } from 'next';
 import { jsonRes } from '@/service/response';
 import { authUser } from '@fastgpt/service/support/user/auth';
 import { connectToDatabase, App } from '@/service/mongo';
-import { FlowInputItemTypeEnum, FlowModuleTypeEnum } from '@/constants/flow';
+import { FlowNodeInputTypeEnum, FlowNodeTypeEnum } from '@fastgpt/global/core/module/node/constant';
 import { SystemInputEnum } from '@/constants/app';
 
 const limit = 300;
@@ -46,19 +46,19 @@ async function initVariable(): Promise<any> {
         const modules = jsonAPP.modules;
 
         // 找到 variable
-        const variable = modules.find((item) => item.flowType === FlowModuleTypeEnum.variable);
+        const variable = modules.find((item) => item.flowType === FlowNodeTypeEnum.variable);
         if (!variable) return await app.save();
 
         // 找到 guide 模块
         const userGuideModule = modules.find(
-          (item) => item.flowType === FlowModuleTypeEnum.userGuide
+          (item) => item.flowType === FlowNodeTypeEnum.userGuide
         );
         if (userGuideModule) {
           userGuideModule.inputs = [
             userGuideModule.inputs[0],
             {
               key: SystemInputEnum.variables,
-              type: FlowInputItemTypeEnum.systemInput,
+              type: FlowNodeInputTypeEnum.systemInput,
               label: '对话框变量',
               value: variable.inputs[0]?.value
             }
@@ -66,7 +66,7 @@ async function initVariable(): Promise<any> {
         } else {
           modules.unshift({
             moduleId: 'userGuide',
-            flowType: FlowModuleTypeEnum.userGuide,
+            flowType: FlowNodeTypeEnum.userGuide,
             name: '用户引导',
             position: {
               x: 447.98520778293346,
@@ -75,12 +75,12 @@ async function initVariable(): Promise<any> {
             inputs: [
               {
                 key: SystemInputEnum.welcomeText,
-                type: FlowInputItemTypeEnum.input,
+                type: FlowNodeInputTypeEnum.input,
                 label: '开场白'
               },
               {
                 key: SystemInputEnum.variables,
-                type: FlowInputItemTypeEnum.systemInput,
+                type: FlowNodeInputTypeEnum.systemInput,
                 label: '对话框变量',
                 value: variable.inputs[0]?.value
               }
@@ -90,7 +90,7 @@ async function initVariable(): Promise<any> {
         }
 
         jsonAPP.modules = jsonAPP.modules.filter(
-          (item) => item.flowType !== FlowModuleTypeEnum.variable
+          (item) => item.flowType !== FlowNodeTypeEnum.variable
         );
 
         app.modules = JSON.parse(JSON.stringify(jsonAPP.modules));

projects/app/src/pages/api/admin/initv451.ts

@@ -4,7 +4,7 @@ import { App, connectToDatabase } from '@/service/mongo';
 import { PgClient } from '@/service/pg';
 import { connectionMongo } from '@fastgpt/service/common/mongo';
 import { PgDatasetTableName } from '@/constants/plugin';
-import { FlowModuleTypeEnum } from '@/constants/flow';
+import { FlowNodeTypeEnum } from '@fastgpt/global/core/module/node/constant';
 import { delay } from '@/utils/tools';
 import { MongoDatasetCollection } from '@fastgpt/service/core/dataset/collection/schema';
 import { DatasetCollectionTypeEnum } from '@fastgpt/global/core/dataset/constant';
@@ -98,7 +98,7 @@ async function initMongo(limit: number) {
   let success = 0;
 
   async function initApp(limit = 100): Promise<any> {
-    // 遍历所有 app，更新 app modules 里的 FlowModuleTypeEnum.kbSearchNode
+    // 遍历所有 app，更新 app modules 里的 FlowNodeTypeEnum.kbSearchNode
     const apps = await App.find({ inited: false }).limit(limit);
 
     if (apps.length === 0) return;
@@ -113,7 +113,7 @@ async function initMongo(limit: number) {
           modules.forEach((module) => {
             // @ts-ignore
             if (module.flowType === 'kbSearchNode') {
-              module.flowType = FlowModuleTypeEnum.datasetSearchNode;
+              module.flowType = FlowNodeTypeEnum.datasetSearchNode;
               module.inputs.forEach((input) => {
                 if (input.key === 'kbList') {
                   input.key = 'datasets';

projects/app/src/pages/api/app/del.ts

@@ -1,6 +1,6 @@
 import type { NextApiRequest, NextApiResponse } from 'next';
 import { jsonRes } from '@/service/response';
-import { Chat, App, connectToDatabase, Collection } from '@/service/mongo';
+import { Chat, App, connectToDatabase } from '@/service/mongo';
 import { MongoOutLink } from '@fastgpt/service/support/outLink/schema';
 import { authUser } from '@fastgpt/service/support/user/auth';
 import { authApp } from '@/service/utils/auth';
@@ -29,11 +29,6 @@ export default async function handler(req: NextApiRequest, res: NextApiResponse<
       appId
     });
 
-    // 删除收藏列表
-    await Collection.deleteMany({
-      modelId: appId
-    });
-
     // 删除分享链接
     await MongoOutLink.deleteMany({
       appId

projects/app/src/pages/api/app/share/collection.ts

@@ -1,43 +0,0 @@
-import type { NextApiRequest, NextApiResponse } from 'next';
-import { jsonRes } from '@/service/response';
-import { connectToDatabase, Collection, App } from '@/service/mongo';
-import { authUser } from '@fastgpt/service/support/user/auth';
-
-/* 模型收藏切换 */
-export default async function handler(req: NextApiRequest, res: NextApiResponse<any>) {
-  try {
-    await connectToDatabase();
-    const { appId } = req.query as { appId: string };
-
-    if (!appId) {
-      throw new Error('缺少参数');
-    }
-    // 凭证校验
-    const { userId } = await authUser({ req, authToken: true });
-
-    const collectionRecord = await Collection.findOne({
-      userId,
-      modelId: appId
-    });
-
-    if (collectionRecord) {
-      await Collection.findByIdAndRemove(collectionRecord._id);
-    } else {
-      await Collection.create({
-        userId,
-        modelId: appId
-      });
-    }
-
-    await App.findByIdAndUpdate(appId, {
-      'share.collection': await Collection.countDocuments({ modelId: appId })
-    });
-
-    jsonRes(res);
-  } catch (err) {
-    jsonRes(res, {
-      code: 500,
-      error: err
-    });
-  }
-}

projects/app/src/pages/api/app/share/getModels.ts

@@ -1,105 +0,0 @@
-import type { NextApiRequest, NextApiResponse } from 'next';
-import { jsonRes } from '@/service/response';
-import { connectToDatabase, App } from '@/service/mongo';
-import type { PagingData } from '@/types';
-import type { ShareAppItem } from '@/types/app';
-import { authUser } from '@fastgpt/service/support/user/auth';
-import { Types } from '@fastgpt/service/common/mongo';
-
-/* 获取模型列表 */
-export default async function handler(req: NextApiRequest, res: NextApiResponse<any>) {
-  try {
-    await connectToDatabase();
-    const {
-      searchText = '',
-      pageNum = 1,
-      pageSize = 20
-    } = req.body as { searchText: string; pageNum: number; pageSize: number };
-
-    const { userId } = await authUser({ req, authToken: true });
-
-    const regex = new RegExp(searchText, 'i');
-
-    const where = {
-      $and: [
-        { 'share.isShare': true },
-        {
-          $or: [{ name: { $regex: regex } }, { intro: { $regex: regex } }]
-        }
-      ]
-    };
-    const pipeline = [
-      {
-        $match: where
-      },
-      {
-        $lookup: {
-          from: 'collections',
-          let: { modelId: '$_id' },
-          pipeline: [
-            {
-              $match: {
-                $expr: {
-                  $and: [
-                    { $eq: ['$modelId', '$$modelId'] },
-                    {
-                      $eq: ['$userId', userId ? new Types.ObjectId(userId) : new Types.ObjectId()]
-                    }
-                  ]
-                }
-              }
-            }
-          ],
-          as: 'collections'
-        }
-      },
-      {
-        $project: {
-          _id: 1,
-          avatar: { $ifNull: ['$avatar', '/icon/logo.svg'] },
-          name: 1,
-          userId: 1,
-          intro: 1,
-          share: 1,
-          isCollection: {
-            $cond: {
-              if: { $gt: [{ $size: '$collections' }, 0] },
-              then: true,
-              else: false
-            }
-          }
-        }
-      },
-      {
-        $sort: { 'share.topNum': -1, 'share.collection': -1 }
-      },
-      {
-        $skip: (pageNum - 1) * pageSize
-      },
-      {
-        $limit: pageSize
-      }
-    ];
-
-    // 获取被分享的模型
-    const [models, total] = await Promise.all([
-      // @ts-ignore
-      App.aggregate(pipeline),
-      App.countDocuments(where)
-    ]);
-
-    jsonRes<PagingData<ShareAppItem>>(res, {
-      data: {
-        pageNum,
-        pageSize,
-        data: models,
-        total
-      }
-    });
-  } catch (err) {
-    jsonRes(res, {
-      code: 500,
-      error: err
-    });
-  }
-}

projects/app/src/pages/api/chat/chatTest.ts

@@ -4,7 +4,7 @@ import { authUser } from '@fastgpt/service/support/user/auth';
 import { sseErrRes } from '@/service/response';
 import { sseResponseEventEnum } from '@/constants/chat';
 import { responseWrite } from '@fastgpt/service/common/response';
-import { AppModuleItemType } from '@/types/app';
+import type { ModuleItemType } from '@fastgpt/global/core/module/type.d';
 import { dispatchModules } from '@/pages/api/v1/chat/completions';
 import { pushChatBill } from '@/service/common/bill/push';
 import { BillSourceEnum } from '@/constants/user';
@@ -13,7 +13,7 @@ import { ChatItemType } from '@/types/chat';
 export type Props = {
   history: ChatItemType[];
   prompt: string;
-  modules: AppModuleItemType[];
+  modules: ModuleItemType[];
   variables: Record<string, any>;
   appId: string;
   appName: string;

projects/app/src/pages/api/core/plugin/create.ts

@@ -0,0 +1,24 @@
+import type { NextApiRequest, NextApiResponse } from 'next';
+import { jsonRes } from '@/service/response';
+import { connectToDatabase } from '@/service/mongo';
+import { authUser } from '@fastgpt/service/support/user/auth';
+import { createOnePlugin } from '@fastgpt/service/core/plugin/controller';
+import type { CreateOnePluginParams } from '@fastgpt/global/core/plugin/controller';
+import { defaultModules } from '@fastgpt/global/core/plugin/constants';
+
+export default async function handler(req: NextApiRequest, res: NextApiResponse<any>) {
+  try {
+    await connectToDatabase();
+    const { userId } = await authUser({ req, authToken: true });
+    const body = req.body as CreateOnePluginParams;
+
+    jsonRes(res, {
+      data: await createOnePlugin({ userId, modules: defaultModules, ...body })
+    });
+  } catch (err) {
+    jsonRes(res, {
+      code: 500,
+      error: err
+    });
+  }
+}

projects/app/src/pages/api/core/plugin/delete.ts

@@ -0,0 +1,22 @@
+import type { NextApiRequest, NextApiResponse } from 'next';
+import { jsonRes } from '@/service/response';
+import { connectToDatabase } from '@/service/mongo';
+import { authUser } from '@fastgpt/service/support/user/auth';
+import { deleteOnePlugin } from '@fastgpt/service/core/plugin/controller';
+
+export default async function handler(req: NextApiRequest, res: NextApiResponse<any>) {
+  try {
+    const { id } = req.query as { id: string };
+    await connectToDatabase();
+    const { userId } = await authUser({ req, authToken: true });
+
+    jsonRes(res, {
+      data: await deleteOnePlugin({ id, userId })
+    });
+  } catch (err) {
+    jsonRes(res, {
+      code: 500,
+      error: err
+    });
+  }
+}

projects/app/src/pages/api/core/plugin/detail.ts

@@ -0,0 +1,22 @@
+import type { NextApiRequest, NextApiResponse } from 'next';
+import { jsonRes } from '@/service/response';
+import { connectToDatabase } from '@/service/mongo';
+import { authUser } from '@fastgpt/service/support/user/auth';
+import { getOnePluginDetail } from '@fastgpt/service/core/plugin/controller';
+
+export default async function handler(req: NextApiRequest, res: NextApiResponse<any>) {
+  try {
+    const { id } = req.query as { id: string };
+    await connectToDatabase();
+    const { userId } = await authUser({ req, authToken: true });
+
+    jsonRes(res, {
+      data: await getOnePluginDetail({ id, userId })
+    });
+  } catch (err) {
+    jsonRes(res, {
+      code: 500,
+      error: err
+    });
+  }
+}

projects/app/src/pages/api/core/plugin/list.ts

@@ -0,0 +1,21 @@
+import type { NextApiRequest, NextApiResponse } from 'next';
+import { jsonRes } from '@/service/response';
+import { connectToDatabase } from '@/service/mongo';
+import { authUser } from '@fastgpt/service/support/user/auth';
+import { getUserPlugins } from '@fastgpt/service/core/plugin/controller';
+
+export default async function handler(req: NextApiRequest, res: NextApiResponse<any>) {
+  try {
+    await connectToDatabase();
+    const { userId } = await authUser({ req, authToken: true });
+
+    jsonRes(res, {
+      data: await getUserPlugins({ userId })
+    });
+  } catch (err) {
+    jsonRes(res, {
+      code: 500,
+      error: err
+    });
+  }
+}

projects/app/src/pages/api/core/plugin/moduleDetail.ts

@@ -0,0 +1,22 @@
+import type { NextApiRequest, NextApiResponse } from 'next';
+import { jsonRes } from '@/service/response';
+import { connectToDatabase } from '@/service/mongo';
+import { authUser } from '@fastgpt/service/support/user/auth';
+import { getPluginModuleDetail } from '@fastgpt/service/core/plugin/controller';
+
+export default async function handler(req: NextApiRequest, res: NextApiResponse<any>) {
+  try {
+    const { id } = req.query as { id: string };
+    await connectToDatabase();
+    const { userId } = await authUser({ req, authToken: true });
+
+    jsonRes(res, {
+      data: await getPluginModuleDetail({ id, userId })
+    });
+  } catch (err) {
+    jsonRes(res, {
+      code: 500,
+      error: err
+    });
+  }
+}

projects/app/src/pages/api/core/plugin/templateList.ts

@@ -0,0 +1,21 @@
+import type { NextApiRequest, NextApiResponse } from 'next';
+import { jsonRes } from '@/service/response';
+import { connectToDatabase } from '@/service/mongo';
+import { authUser } from '@fastgpt/service/support/user/auth';
+import { getUserPlugins2Templates } from '@fastgpt/service/core/plugin/controller';
+
+export default async function handler(req: NextApiRequest, res: NextApiResponse<any>) {
+  try {
+    await connectToDatabase();
+    const { userId } = await authUser({ req, authToken: true });
+
+    jsonRes(res, {
+      data: await getUserPlugins2Templates({ userId })
+    });
+  } catch (err) {
+    jsonRes(res, {
+      code: 500,
+      error: err
+    });
+  }
+}

projects/app/src/pages/api/core/plugin/update.ts

@@ -0,0 +1,23 @@
+import type { NextApiRequest, NextApiResponse } from 'next';
+import { jsonRes } from '@/service/response';
+import { connectToDatabase } from '@/service/mongo';
+import { authUser } from '@fastgpt/service/support/user/auth';
+import { updateOnePlugin } from '@fastgpt/service/core/plugin/controller';
+import type { UpdatePluginParams } from '@fastgpt/global/core/plugin/controller';
+
+export default async function handler(req: NextApiRequest, res: NextApiResponse<any>) {
+  try {
+    await connectToDatabase();
+    const { userId } = await authUser({ req, authToken: true });
+    const body = req.body as UpdatePluginParams;
+
+    jsonRes(res, {
+      data: await updateOnePlugin({ userId, ...body })
+    });
+  } catch (err) {
+    jsonRes(res, {
+      code: 500,
+      error: err
+    });
+  }
+}

projects/app/src/pages/api/system/file/upload.ts

@@ -22,7 +22,7 @@ type FileType = {
 /**
  * Creates the multer uploader
  */
-const maxSize = 50 * 1024 * 1024;
+const maxSize = 500 * 1024 * 1024;
 class UploadModel {
   uploader = multer({
     limits: {

projects/app/src/pages/api/system/file/uploadImage.ts

@@ -1,7 +1,8 @@
 import type { NextApiRequest, NextApiResponse } from 'next';
 import { jsonRes } from '@/service/response';
-import { connectToDatabase, Image } from '@/service/mongo';
+import { connectToDatabase } from '@/service/mongo';
 import { authUser } from '@fastgpt/service/support/user/auth';
+import { uploadMongoImg } from '@fastgpt/service/common/file/image/controller';
 
 type Props = { base64Img: string };
 
@@ -11,7 +12,7 @@ export default async function handler(req: NextApiRequest, res: NextApiResponse)
     const { userId } = await authUser({ req, authToken: true });
     const { base64Img } = req.body as Props;
 
-    const data = await uploadImg({
+    const data = await uploadMongoImg({
       userId,
       base64Img
     });
@@ -24,14 +25,3 @@ export default async function handler(req: NextApiRequest, res: NextApiResponse)
     });
   }
 }
-
-export async function uploadImg({ base64Img, userId }: Props & { userId: string }) {
-  const base64Data = base64Img.split(',')[1];
-
-  const { _id } = await Image.create({
-    userId,
-    binary: Buffer.from(base64Data, 'base64')
-  });
-
-  return `/api/system/img/${_id}`;
-}

projects/app/src/pages/api/system/img/[id].ts

@@ -1,21 +1,17 @@
 import type { NextApiRequest, NextApiResponse } from 'next';
 import { jsonRes } from '@/service/response';
-import { connectToDatabase, Image } from '@/service/mongo';
+import { connectToDatabase } from '@/service/mongo';
+import { readMongoImg } from '@fastgpt/service/common/file/image/controller';
 
 // get the models available to the system
 export default async function handler(req: NextApiRequest, res: NextApiResponse) {
   try {
     await connectToDatabase();
-    const { id } = req.query;
+    const { id } = req.query as { id: string };
 
-    const data = await Image.findById(id);
-
-    if (!data) {
-      throw new Error('no image');
-    }
     res.setHeader('Content-Type', 'image/jpeg');
 
-    res.send(data.binary);
+    res.send(await readMongoImg({ id }));
   } catch (error) {
     jsonRes(res, {
       code: 500,

projects/app/src/pages/api/user/getPayOrders.ts

@@ -1,14 +1,15 @@
 import type { NextApiRequest, NextApiResponse } from 'next';
 import { jsonRes } from '@/service/response';
 import { authUser } from '@fastgpt/service/support/user/auth';
-import { Pay, connectToDatabase } from '@/service/mongo';
+import { connectToDatabase } from '@/service/mongo';
+import { MongoPay } from '@fastgpt/service/support/wallet/pay/schema';
 
 export default async function handler(req: NextApiRequest, res: NextApiResponse) {
   try {
     await connectToDatabase();
     const { userId } = await authUser({ req, authToken: true });
 
-    const records = await Pay.find({
+    const records = await MongoPay.find({
       userId,
       status: { $ne: 'CLOSED' }
     })

projects/app/src/pages/api/user/inform/countUnread.ts

@@ -1,7 +1,8 @@
 // Next.js API route support: https://nextjs.org/docs/api-routes/introduction
 import type { NextApiRequest, NextApiResponse } from 'next';
 import { jsonRes } from '@/service/response';
-import { Inform, connectToDatabase } from '@/service/mongo';
+import { connectToDatabase } from '@/service/mongo';
+import { MongoUserInform } from '@fastgpt/service/support/user/inform/schema';
 import { authUser } from '@fastgpt/service/support/user/auth';
 
 export default async function handler(req: NextApiRequest, res: NextApiResponse) {
@@ -14,7 +15,7 @@ export default async function handler(req: NextApiRequest, res: NextApiResponse)
     }
     const { userId } = await authUser({ req, authToken: true });
 
-    const data = await Inform.countDocuments({
+    const data = await MongoUserInform.countDocuments({
       userId,
       read: false
     });

projects/app/src/pages/api/user/inform/list.ts

@@ -1,8 +1,9 @@
 // Next.js API route support: https://nextjs.org/docs/api-routes/introduction
 import type { NextApiRequest, NextApiResponse } from 'next';
 import { jsonRes } from '@/service/response';
-import { Inform, connectToDatabase } from '@/service/mongo';
+import { connectToDatabase } from '@/service/mongo';
 import { authUser } from '@fastgpt/service/support/user/auth';
+import { MongoUserInform } from '@fastgpt/service/support/user/inform/schema';
 
 export default async function handler(req: NextApiRequest, res: NextApiResponse) {
   try {
@@ -15,11 +16,11 @@ export default async function handler(req: NextApiRequest, res: NextApiResponse)
     };
 
     const [informs, total] = await Promise.all([
-      Inform.find({ userId })
+      MongoUserInform.find({ userId })
         .sort({ time: -1 }) // 按照创建时间倒序排列
         .skip((pageNum - 1) * pageSize)
         .limit(pageSize),
-      Inform.countDocuments({ userId })
+      MongoUserInform.countDocuments({ userId })
     ]);
 
     jsonRes(res, {

projects/app/src/pages/api/user/inform/read.ts

@@ -1,8 +1,9 @@
 // Next.js API route support: https://nextjs.org/docs/api-routes/introduction
 import type { NextApiRequest, NextApiResponse } from 'next';
 import { jsonRes } from '@/service/response';
-import { Inform, connectToDatabase } from '@/service/mongo';
+import { connectToDatabase } from '@/service/mongo';
 import { authUser } from '@fastgpt/service/support/user/auth';
+import { MongoUserInform } from '@fastgpt/service/support/user/inform/schema';
 
 export default async function handler(req: NextApiRequest, res: NextApiResponse) {
   try {
@@ -11,7 +12,7 @@ export default async function handler(req: NextApiRequest, res: NextApiResponse)
 
     const { id } = req.query as { id: string };
 
-    await Inform.findOneAndUpdate(
+    await MongoUserInform.findOneAndUpdate(
       {
         _id: id,
         userId

projects/app/src/pages/api/user/inform/send.ts

@@ -1,11 +1,15 @@
 // Next.js API route support: https://nextjs.org/docs/api-routes/introduction
 import type { NextApiRequest, NextApiResponse } from 'next';
 import { jsonRes } from '@/service/response';
-import { Inform, connectToDatabase } from '@/service/mongo';
+import { connectToDatabase } from '@/service/mongo';
 import { authUser } from '@fastgpt/service/support/user/auth';
-import { InformTypeEnum } from '@/constants/user';
 import { startSendInform } from '@/service/events/sendInform';
-import { MongoUser } from '@fastgpt/service/support/user/schema';
+import { MongoUserInform } from '@fastgpt/service/support/user/inform/schema';
+import { InformTypeEnum } from '@fastgpt/global/support/user/constant';
+import {
+  sendInform2AllUser,
+  sendInform2OneUser
+} from '@fastgpt/service/support/user/inform/controller';
 
 export type Props = {
   type: `${InformTypeEnum}`;
@@ -38,39 +42,13 @@ export async function sendInform({ type, title, content, userId }: Props) {
 
   try {
     if (userId) {
-      global.sendInformQueue.push(async () => {
-        // skip it if have same inform within 5 minutes
-        const inform = await Inform.findOne({
-          type,
-          title,
-          content,
-          userId,
-          time: { $gte: new Date(Date.now() - 5 * 60 * 1000) }
-        });
-
-        if (inform) return;
-
-        await Inform.create({
-          type,
-          title,
-          content,
-          userId
-        });
-      });
+      global.sendInformQueue.push(async () => sendInform2OneUser({ type, title, content, userId }));
       startSendInform();
       return;
     }
 
     // send to all user
-    const users = await MongoUser.find({}, '_id');
-    await Inform.insertMany(
-      users.map(({ _id }) => ({
-        type,
-        title,
-        content,
-        userId: _id
-      }))
-    );
+    sendInform2AllUser({ type, title, content });
   } catch (error) {
     console.log('send inform error', error);
   }

projects/app/src/pages/api/user/promotion/getPromotionData.ts

@@ -1,7 +1,8 @@
 // Next.js API route support: https://nextjs.org/docs/api-routes/introduction
 import type { NextApiRequest, NextApiResponse } from 'next';
 import { jsonRes } from '@/service/response';
-import { connectToDatabase, promotionRecord } from '@/service/mongo';
+import { connectToDatabase } from '@/service/mongo';
+import { MongoPromotionRecord } from '@fastgpt/service/support/activity/promotion/schema';
 import { authUser } from '@fastgpt/service/support/user/auth';
 import mongoose from '@fastgpt/service/common/mongo';
 import { MongoUser } from '@fastgpt/service/support/user/schema';
@@ -16,7 +17,7 @@ export default async function handler(req: NextApiRequest, res: NextApiResponse)
     });
 
     // 计算累计合
-    const countHistory: { totalAmount: number }[] = await promotionRecord.aggregate([
+    const countHistory: { totalAmount: number }[] = await MongoPromotionRecord.aggregate([
       {
         $match: {
           userId: new mongoose.Types.ObjectId(userId),

projects/app/src/pages/api/user/promotion/getPromotions.ts

@@ -1,7 +1,8 @@
 import type { NextApiRequest, NextApiResponse } from 'next';
 import { jsonRes } from '@/service/response';
-import { connectToDatabase, promotionRecord } from '@/service/mongo';
+import { connectToDatabase } from '@/service/mongo';
 import { authUser } from '@fastgpt/service/support/user/auth';
+import { MongoPromotionRecord } from '@fastgpt/service/support/activity/promotion/schema';
 
 export default async function handler(req: NextApiRequest, res: NextApiResponse) {
   try {
@@ -13,13 +14,12 @@ export default async function handler(req: NextApiRequest, res: NextApiResponse)
 
     const { userId } = await authUser({ req, authToken: true });
 
-    const data = await promotionRecord
-      .find(
-        {
-          userId
-        },
-        '_id createTime type amount'
-      )
+    const data = await MongoPromotionRecord.find(
+      {
+        userId
+      },
+      '_id createTime type amount'
+    )
       .sort({ _id: -1 })
       .skip((pageNum - 1) * pageSize)
       .limit(pageSize);
@@ -29,7 +29,7 @@ export default async function handler(req: NextApiRequest, res: NextApiResponse)
         pageNum,
         pageSize,
         data,
-        total: await promotionRecord.countDocuments({
+        total: await MongoPromotionRecord.countDocuments({
           userId
         })
       }

projects/app/src/pages/api/v1/chat/completions.ts

@@ -9,12 +9,15 @@ import {
   dispatchHistory,
   dispatchChatInput,
   dispatchChatCompletion,
-  dispatchKBSearch,
+  dispatchDatasetSearch,
   dispatchAnswer,
   dispatchClassifyQuestion,
   dispatchContentExtract,
   dispatchHttpRequest,
-  dispatchAppRequest
+  dispatchAppRequest,
+  dispatchRunPlugin,
+  dispatchPluginInput,
+  dispatchPluginOutput
 } from '@/service/moduleDispatch';
 import type { CreateChatCompletionRequest } from '@fastgpt/global/core/ai/type.d';
 import type { MessageItemType } from '@/types/core/chat/type';
@@ -23,8 +26,10 @@ import { getChatHistory } from './getHistory';
 import { saveChat } from '@/service/utils/chat/saveChat';
 import { responseWrite } from '@fastgpt/service/common/response';
 import { TaskResponseKeyEnum } from '@/constants/chat';
-import { FlowModuleTypeEnum, initModuleType } from '@/constants/flow';
-import { AppModuleItemType, RunningModuleItemType } from '@/types/app';
+import { initModuleType } from '@/constants/flow';
+import { FlowNodeTypeEnum } from '@fastgpt/global/core/module/node/constant';
+import { RunningModuleItemType } from '@/types/app';
+import type { ModuleItemType } from '@fastgpt/global/core/module/type';
 import { pushChatBill } from '@/service/common/bill/push';
 import { BillSourceEnum } from '@/constants/user';
 import { ChatHistoryItemResType } from '@/types/chat';
@@ -305,7 +310,7 @@ export async function dispatchModules({
   detail = false
 }: {
   res: NextApiResponse;
-  modules: AppModuleItemType[];
+  modules: ModuleItemType[];
   user: UserModelSchema;
   params?: Record<string, any>;
   variables?: Record<string, any>;
@@ -425,7 +430,6 @@ export async function dispatchModules({
       stream,
       detail,
       variables,
-      moduleName: module.name,
       outputs: module.outputs,
       user,
       inputs: params
@@ -433,15 +437,18 @@ export async function dispatchModules({
 
     const dispatchRes: Record<string, any> = await (async () => {
       const callbackMap: Record<string, Function> = {
-        [FlowModuleTypeEnum.historyNode]: dispatchHistory,
-        [FlowModuleTypeEnum.questionInput]: dispatchChatInput,
-        [FlowModuleTypeEnum.answerNode]: dispatchAnswer,
-        [FlowModuleTypeEnum.chatNode]: dispatchChatCompletion,
-        [FlowModuleTypeEnum.datasetSearchNode]: dispatchKBSearch,
-        [FlowModuleTypeEnum.classifyQuestion]: dispatchClassifyQuestion,
-        [FlowModuleTypeEnum.contentExtract]: dispatchContentExtract,
-        [FlowModuleTypeEnum.httpRequest]: dispatchHttpRequest,
-        [FlowModuleTypeEnum.app]: dispatchAppRequest
+        [FlowNodeTypeEnum.historyNode]: dispatchHistory,
+        [FlowNodeTypeEnum.questionInput]: dispatchChatInput,
+        [FlowNodeTypeEnum.answerNode]: dispatchAnswer,
+        [FlowNodeTypeEnum.chatNode]: dispatchChatCompletion,
+        [FlowNodeTypeEnum.datasetSearchNode]: dispatchDatasetSearch,
+        [FlowNodeTypeEnum.classifyQuestion]: dispatchClassifyQuestion,
+        [FlowNodeTypeEnum.contentExtract]: dispatchContentExtract,
+        [FlowNodeTypeEnum.httpRequest]: dispatchHttpRequest,
+        [FlowNodeTypeEnum.runApp]: dispatchAppRequest,
+        [FlowNodeTypeEnum.pluginModule]: dispatchRunPlugin,
+        [FlowNodeTypeEnum.pluginInput]: dispatchPluginInput,
+        [FlowNodeTypeEnum.pluginOutput]: dispatchPluginOutput
       };
       if (callbackMap[module.flowType]) {
         return callbackMap[module.flowType](props);
@@ -449,9 +456,21 @@ export async function dispatchModules({
       return {};
     })();
 
+    const formatResponseData = (() => {
+      if (!dispatchRes[TaskResponseKeyEnum.responseData]) return undefined;
+      if (Array.isArray(dispatchRes[TaskResponseKeyEnum.responseData]))
+        return dispatchRes[TaskResponseKeyEnum.responseData];
+      return {
+        ...dispatchRes[TaskResponseKeyEnum.responseData],
+        moduleName: module.name,
+        moduleType: module.flowType
+      };
+    })();
+
     return moduleOutput(module, {
       [SystemOutputEnum.finish]: true,
-      ...dispatchRes
+      ...dispatchRes,
+      [TaskResponseKeyEnum.responseData]: formatResponseData
     });
   }
 
@@ -468,7 +487,7 @@ export async function dispatchModules({
 
 /* init store modules to running modules */
 function loadModules(
-  modules: AppModuleItemType[],
+  modules: ModuleItemType[],
   variables: Record<string, any>
 ): RunningModuleItemType[] {
   return modules.map((module) => {
@@ -495,12 +514,19 @@ function loadModules(
             value: replacedVal
           };
         }),
-      outputs: module.outputs.map((item) => ({
-        key: item.key,
-        answer: item.key === TaskResponseKeyEnum.answerText,
-        value: undefined,
-        targets: item.targets
-      }))
+      outputs: module.outputs
+        .map((item) => ({
+          key: item.key,
+          answer: item.key === TaskResponseKeyEnum.answerText,
+          value: undefined,
+          targets: item.targets
+        }))
+        .sort((a, b) => {
+          // finish output always at last
+          if (a.key === SystemOutputEnum.finish) return 1;
+          if (b.key === SystemOutputEnum.finish) return -1;
+          return 0;
+        })
     };
   });
 }