fix: http (#3596)

* fix lexical editor space

* delete console

.github/workflows/fastgpt-image.yml

@@ -173,3 +173,86 @@ jobs:
           -t ${Docker_Hub_Tag} \
           -t ${Docker_Hub_Latest} \
           .
+  build-fastgpt-images-sub-route-gchat:
+    runs-on: ubuntu-20.04
+    steps:
+      # install env
+      - name: Checkout
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 1
+      - name: Install Dependencies
+        run: |
+          sudo apt update && sudo apt install -y nodejs npm
+      - name: Set up QEMU (optional)
+        uses: docker/setup-qemu-action@v2
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2
+        with:
+          driver-opts: network=host
+      - name: Cache Docker layers
+        uses: actions/cache@v2
+        with:
+          path: /tmp/.buildx-cache
+          key: ${{ runner.os }}-buildx-${{ github.sha }}
+          restore-keys: |
+            ${{ runner.os }}-buildx-
+
+      # login docker
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@v2
+        with:
+          registry: ghcr.io
+          username: ${{ github.repository_owner }}
+          password: ${{ secrets.GH_PAT }}
+      - name: Login to Ali Hub
+        uses: docker/login-action@v2
+        with:
+          registry: registry.cn-hangzhou.aliyuncs.com
+          username: ${{ secrets.ALI_HUB_USERNAME }}
+          password: ${{ secrets.ALI_HUB_PASSWORD }}
+      - name: Login to Docker Hub
+        uses: docker/login-action@v2
+        with:
+          username: ${{ secrets.DOCKER_HUB_NAME }}
+          password: ${{ secrets.DOCKER_HUB_PASSWORD }}
+
+      # Set tag
+      - name: Set image name and tag
+        run: |
+          if [[ "${{ github.ref_name }}" == "main" ]]; then
+            echo "Git_Tag=ghcr.io/${{ github.repository_owner }}/fastgpt-sub-route-gchat:latest" >> $GITHUB_ENV
+            echo "Git_Latest=ghcr.io/${{ github.repository_owner }}/fastgpt-sub-route-gchat:latest" >> $GITHUB_ENV
+            echo "Ali_Tag=${{ secrets.ALI_IMAGE_NAME }}/fastgpt-sub-route-gchat:latest" >> $GITHUB_ENV
+            echo "Ali_Latest=${{ secrets.ALI_IMAGE_NAME }}/fastgpt-sub-route-gchat:latest" >> $GITHUB_ENV
+            echo "Docker_Hub_Tag=${{ secrets.DOCKER_IMAGE_NAME }}/fastgpt-sub-route-gchat:latest" >> $GITHUB_ENV
+            echo "Docker_Hub_Latest=${{ secrets.DOCKER_IMAGE_NAME }}/fastgpt-sub-route-gchat:latest" >> $GITHUB_ENV
+          else
+            echo "Git_Tag=ghcr.io/${{ github.repository_owner }}/fastgpt-sub-route-gchat:${{ github.ref_name }}" >> $GITHUB_ENV
+            echo "Git_Latest=ghcr.io/${{ github.repository_owner }}/fastgpt-sub-route-gchat:latest" >> $GITHUB_ENV
+            echo "Ali_Tag=${{ secrets.ALI_IMAGE_NAME }}/fastgpt-sub-route-gchat:${{ github.ref_name }}" >> $GITHUB_ENV
+            echo "Ali_Latest=${{ secrets.ALI_IMAGE_NAME }}/fastgpt-sub-route-gchat:latest" >> $GITHUB_ENV
+            echo "Docker_Hub_Tag=${{ secrets.DOCKER_IMAGE_NAME }}/fastgpt-sub-route-gchat:${{ github.ref_name }}" >> $GITHUB_ENV
+            echo "Docker_Hub_Latest=${{ secrets.DOCKER_IMAGE_NAME }}/fastgpt-sub-route-gchat:latest" >> $GITHUB_ENV
+          fi
+
+      - name: Build and publish image for main branch or tag push event
+        env:
+          DOCKER_REPO_TAGGED: ${{ env.DOCKER_REPO_TAGGED }}
+        run: |
+          docker buildx build \
+          -f projects/app/Dockerfile \
+          --platform linux/amd64,linux/arm64 \
+          --build-arg base_url=/gchat \
+          --label "org.opencontainers.image.source=https://github.com/${{ github.repository_owner }}/FastGPT" \
+          --label "org.opencontainers.image.description=fastgpt-sub-route-gchat image" \
+          --push \
+          --cache-from=type=local,src=/tmp/.buildx-cache \
+          --cache-to=type=local,dest=/tmp/.buildx-cache \
+          -t ${Git_Tag} \
+          -t ${Git_Latest} \
+          -t ${Ali_Tag} \
+          -t ${Ali_Latest} \
+          -t ${Docker_Hub_Tag} \
+          -t ${Docker_Hub_Latest} \
+          .

.github/workflows/preview-fastgpt-image.yml

@@ -36,7 +36,7 @@ jobs:
           password: ${{ secrets.GH_PAT }}
       - name: Set DOCKER_REPO_TAGGED based on branch or tag
         run: |
-          echo "DOCKER_REPO_TAGGED=ghcr.io/${{ github.repository_owner }}/fastgpt-pr:${{ github.event.pull_request.number }}" >> $GITHUB_ENV
+          echo "DOCKER_REPO_TAGGED=ghcr.io/${{ github.repository_owner }}/fastgpt-pr:${{ github.event.pull_request.head.sha }}" >> $GITHUB_ENV
       - name: Build image for PR
         env:
           DOCKER_REPO_TAGGED: ${{ env.DOCKER_REPO_TAGGED }}
@@ -44,13 +44,30 @@ jobs:
           docker buildx build \
           -f projects/app/Dockerfile \
           --label "org.opencontainers.image.source=https://github.com/${{ github.repository_owner }}/FastGPT" \
-          --label "org.opencontainers.image.description=fastgpt-pr imae" \
+          --label "org.opencontainers.image.description=fastgpt-pr image" \
           --label "org.opencontainers.image.licenses=Apache" \
           --push \
           --cache-from=type=local,src=/tmp/.buildx-cache \
           --cache-to=type=local,dest=/tmp/.buildx-cache \
           -t ${DOCKER_REPO_TAGGED} \
           .
+      # Add write md step after build
+      - name: Write md
+        run: |
+          echo "# 🤖 Generated by deploy action" > report.md
+          echo "📦 Preview Image: \`${DOCKER_REPO_TAGGED}\`" >> report.md
+          cat report.md
+
+      - name: Gh Rebot for Sealos
+        uses: labring/gh-rebot@v0.0.6
+        if: ${{ (github.event_name == 'pull_request_target') }}
+        with:
+          version: v0.0.6
+        env:
+          GH_TOKEN: '${{ secrets.GH_PAT }}'
+          SEALOS_TYPE: 'pr_comment'
+          SEALOS_FILENAME: 'report.md'
+          SEALOS_REPLACE_TAG: 'DEFAULT_REPLACE_DEPLOY'
 
   helm-check:
     runs-on: ubuntu-20.04

dev.md

@@ -1,6 +1,6 @@
 ## Premise
 
-Since FastGPT is managed in the same way as monorepo, it is recommended to install 'make' first during development.
+Since FastGPT is managed in the same way as monorepo, it is recommended to install ‘make’ first during development.
 
 monorepo Project Name:
 

docSite/content/zh-cn/docs/agreement/open-source.md

@@ -7,7 +7,7 @@ toc: true
 weight: 1210
 ---
 
-FastGPT 项目在 Apache License 2.0 许可下开源，同时包含以下附加条件：
+FastGPT 项目在 Apache License 2.0 许可下开源，但包含以下附加条件：
 
 + FastGPT 允许被用于商业化，例如作为其他应用的“后端即服务”使用，或者作为应用开发平台提供给企业。然而，当满足以下条件时，必须联系作者获得商业许可：
    

docSite/content/zh-cn/docs/development/configuration.md

@@ -9,9 +9,9 @@ weight: 707
 
 由于环境变量不利于配置复杂的内容，新版 FastGPT 采用了 ConfigMap 的形式挂载配置文件，你可以在 `projects/app/data/config.json` 看到默认的配置文件。可以参考 [docker-compose 快速部署](/docs/development/docker/) 来挂载配置文件。
 
-**开发环境下**，你需要将示例配置文件 `config.json` 复制成 `config.local.json` 文件才会生效。
+**开发环境下**，你需要将示例配置文件 `config.json` 复制成 `config.local.json` 文件才会生效。  
 
-这个配置文件中包含了系统参数和各个模型配置：
+下面配置文件示例中包含了系统参数和各个模型配置：
 
 ## 4.6.8+ 版本新配置文件示例
 

docSite/content/zh-cn/docs/development/faq.md

@@ -19,6 +19,10 @@ images: []
 
 ## 二、通用问题
 
+### 本地部署的限制
+
+具体内容参考https://fael3z0zfze.feishu.cn/wiki/OFpAw8XzAi36Guk8dfucrCKUnjg。
+
 ### 能否纯本地运行
 
 可以。需要准备好向量模型和LLM模型。
@@ -41,31 +45,6 @@ images: []
 1. 问题补全需要经过一轮AI生成。
 2. 会进行3~5轮的查询，如果数据库性能不足，会有明显影响。
 
-### 对话接口报错或返回为空(core.chat.Chat API is error or undefined)
-
-1. 检查 AI 的 key 问题：通过 curl 请求看是否正常。务必用 stream=true 模式。并且 maxToken 等相关参数尽量一致。
-2. 如果是国内模型，可能是命中风控了。
-3. 查看模型请求日志，检查出入参数是否异常。
-
-```sh
-# curl 例子。
-curl --location --request POST 'https://xxx.cn/v1/chat/completions' \
---header 'Authorization: Bearer sk-xxxx' \
---header 'Content-Type: application/json' \
---data-raw '{
-  "model": "gpt-3.5-turbo",
-  "stream": true,
-  "temperature": 1,
-  "max_tokens": 3000,
-  "messages": [
-    {
-      "role": "user",
-      "content": "你是谁"
-    }
-  ]
-}'
-```
-
 ### 页面中可以正常回复，API 报错
 
 页面中是用 stream=true 模式，所以API也需要设置 stream=true 来进行测试。部分模型接口（国产居多）非 Stream 的兼容有点垃圾。
@@ -111,6 +90,13 @@ FastGPT 模型配置文件中的 model 必须与 OneAPI 渠道中的模型对应
 
 如果OneAPI中，没有配置对应的模型，`config.json`中也不要配置，否则容易报错。
 
+### 点击模型测试失败
+
+OneAPI 只会测试渠道的第一个模型，并且只会测试对话模型，向量模型无法自动测试，需要手动发起请求进行测试。[查看测试模型命令示例](/docs/development/faq/#如何检查模型问题)
+### get request url failed: Post "https://xxx dial tcp: xxxx
+
+OneAPI 与模型网络不通，需要检查网络配置。
+
 ### Incorrect API key provided: sk-xxxx.You can find your api Key at xxx
 
 OneAPI 的 API Key 配置错误，需要修改`OPENAI_API_KEY`环境变量，并重启容器（先 docker-compose down 然后再 docker-compose up -d 运行一次）。
@@ -126,6 +112,112 @@ OneAPI 的 API Key 配置错误，需要修改`OPENAI_API_KEY`环境变量，并
 
 ## 四、常见模型问题
 
+### 如何检查模型问题
+
+1. 私有部署模型，先确认部署的模型是否正常。
+2. 通过 CURL 请求，直接测试上游模型是否正常运行（云端模型或私有模型均进行测试）
+3. 通过 CURL 请求，请求 OneAPI 去测试模型是否正常。
+4. 在 FastGPT 中使用该模型进行测试。
+
+下面是几个测试 CURL 示例：
+
+{{< tabs tabTotal="5" >}}
+{{< tab tabName="LLM模型" >}}
+{{< markdownify >}}
+
+```bash
+curl https://api.openai.com/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer $OPENAI_API_KEY" \
+  -d '{
+    "model": "gpt-4o",
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are a helpful assistant."
+      },
+      {
+        "role": "user",
+        "content": "Hello!"
+      }
+    ]
+  }'
+
+```
+
+{{< /markdownify >}}
+{{< /tab >}}
+
+{{< tab tabName="Embedding模型" >}}
+{{< markdownify >}}
+
+```bash
+curl https://api.openai.com/v1/embeddings \
+  -H "Authorization: Bearer $OPENAI_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "input": "The food was delicious and the waiter...",
+    "model": "text-embedding-ada-002",
+    "encoding_format": "float"
+  }'
+```
+
+{{< /markdownify >}}
+{{< /tab >}}
+
+{{< tab tabName="Rerank 模型" >}}
+{{< markdownify >}}
+
+```bash
+curl --location --request POST 'https://xxxx.com/api/v1/rerank' \
+--header 'Authorization: Bearer {{ACCESS_TOKEN}}' \
+--header 'Content-Type: application/json' \
+--data-raw '{
+  "model": "bge-rerank-m3",
+  "query": "导演是谁",
+  "documents": [
+    "你是谁？\n我是电影《铃芽之旅》助手"
+  ]
+}'
+```
+
+{{< /markdownify >}}
+{{< /tab >}}
+
+{{< tab tabName="TTS 模型" >}}
+{{< markdownify >}}
+
+```bash
+curl https://api.openai.com/v1/audio/speech \
+  -H "Authorization: Bearer $OPENAI_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "tts-1",
+    "input": "The quick brown fox jumped over the lazy dog.",
+    "voice": "alloy"
+  }' \
+  --output speech.mp3
+```
+
+{{< /markdownify >}}
+{{< /tab >}}
+
+{{< tab tabName="Whisper 模型" >}}
+{{< markdownify >}}
+
+```bash
+curl https://api.openai.com/v1/audio/transcriptions \
+  -H "Authorization: Bearer $OPENAI_API_KEY" \
+  -H "Content-Type: multipart/form-data" \
+  -F file="@/path/to/file/audio.mp3" \
+  -F model="whisper-1"
+```
+
+{{< /markdownify >}}
+{{< /tab >}}
+
+{{< /tabs >}}
+
 ### 报错 - 模型响应为空/模型报错
 
 该错误是由于 stream 模式下，oneapi 直接结束了流请求，并且未返回任何内容导致。
@@ -165,7 +257,7 @@ curl --location --request POST 'https://api.openai.com/v1/chat/completions' \
 
 需要模型提供商和 oneapi 同时支持工具调用才可使用，测试方法如下：
 
-1. 通过 `curl` 向 `oneapi` 发起第一轮 stream 模式的 tool 测试。
+##### 1. 通过 `curl` 向 `oneapi` 发起第一轮 stream 模式的 tool 测试。
 
 ```bash
 curl --location --request POST 'https://oneapi.xxx/v1/chat/completions' \
@@ -200,7 +292,7 @@ curl --location --request POST 'https://oneapi.xxx/v1/chat/completions' \
 }'
 ```
 
-2. 检查响应参数
+##### 2. 检查响应参数
 
 如果能正常调用工具，会返回对应 `tool_calls` 参数。
 
@@ -238,7 +330,7 @@ curl --location --request POST 'https://oneapi.xxx/v1/chat/completions' \
 }
 ```
 
-3. 通过 `curl` 向 `oneapi` 发起第二轮 stream 模式的 tool 测试。
+##### 3. 通过 `curl` 向 `oneapi` 发起第二轮 stream 模式的 tool 测试。
 
 第二轮请求是把工具结果发送给模型。发起后会得到模型回答的结果。
 

docSite/content/zh-cn/docs/development/intro.md

@@ -148,7 +148,7 @@ FastGPT 在`pnpm i`后会执行`postinstall`脚本，用于自动生成`ChakraUI
 
 ## 加入社区
 
-遇到困难了吗？有任何问题吗? 加入微信群与开发者和用户保持沟通。
+遇到困难了吗？有任何问题吗? 加入飞书群与开发者和用户保持沟通。
 
 <img width="400px" src="https://oss.laf.run/otnvvf-imgs/fastgpt-feishu1.png" class="medium-zoom-image" />
 

docSite/content/zh-cn/docs/development/openapi/dataset.md

@@ -1175,7 +1175,7 @@ curl --location --request POST 'http://localhost:3000/api/core/dataset/data/v2/l
 }'
 ```
 
-**4.6.7+**
+**4.6.7-(即将弃用)**
 
 ```bash
 curl --location --request POST 'http://localhost:3000/api/core/dataset/data/list' \
@@ -1197,8 +1197,7 @@ curl --location --request POST 'http://localhost:3000/api/core/dataset/data/list
 
 {{% alert icon=" " context="success" %}}
 
-- pageNum: 偏移量（选填）
-- pageNum: 页码（选填）
+- offset: 偏移量（选填）
 - pageSize: 每页数量，最大30（选填）
 - collectionId: 集合的ID（必填）
 - searchText: 模糊搜索词（选填）
@@ -1218,9 +1217,7 @@ curl --location --request POST 'http://localhost:3000/api/core/dataset/data/list
     "statusText": "",
     "message": "",
     "data": {
-        "pageNum": 1,
-        "pageSize": 10,
-        "data": [
+        "list": [
             {
                 "_id": "65abd4b29d1448617cba61db",
                 "datasetId": "65abc9bd9d1448617cba5e6c",

docSite/content/zh-cn/docs/development/upgrading/4817.md

@@ -11,7 +11,7 @@ weight: 807
 
 ### 1. 更新镜像：
 
-- 更新 fastgpt 镜像 tag: v4.8.17
+- 更新 fastgpt 镜像 tag: v4.8.17-fix-title
 - 更新 fastgpt-pro 商业版镜像 tag: v4.8.17
 - Sandbox 镜像无需更新
 
@@ -49,4 +49,4 @@ curl --location --request POST 'https://{{host}}/api/admin/initv4817' \
 12. 修复 - 文件返回接口缺少 Content-Length 头，导致通过非同源文件上传时，阿里 vision 模型无法识别图片。
 13. 修复 - 去除判断器两端字符串隐藏换行符，避免判断器失效。
 14. 修复 - 变量更新节点，手动输入更新内容时候，非字符串类型数据类型无法自动转化。
-15. 修复 - 豆包模型无法工具调用。
+15. 修复 - 豆包模型无法工具调用。

docSite/content/zh-cn/docs/development/upgrading/4818.md

@@ -0,0 +1,47 @@
+---
+title: 'V4.8.18'
+description: 'FastGPT V4.8.18 更新说明'
+icon: 'upgrade'
+draft: false
+toc: true
+weight: 806
+---
+
+## 更新指南
+
+### 1. 更新镜像：
+
+- 更新 fastgpt 镜像 tag: v4.8.18-fix
+- 更新 fastgpt-pro 商业版镜像 tag: v4.8.18-fix
+- Sandbox 镜像无需更新
+
+### 2. 运行升级脚本
+
+从任意终端，发起 1 个 HTTP 请求。其中 {{rootkey}} 替换成环境变量里的 `rootkey`；{{host}} 替换成**FastGPT 域名**。
+
+```bash
+curl --location --request POST 'https://{{host}}/api/admin/initv4818' \
+--header 'rootkey: {{rootkey}}' \
+--header 'Content-Type: application/json'
+```
+
+会迁移全文检索表，时间较长，迁移期间全文检索会失效，日志中会打印已经迁移的数据长度。
+
+
+## 完整更新内容
+
+1. 新增 - 支持通过 JSON 配置直接创建应用。
+2. 新增 - 支持通过 CURL 脚本快速创建 HTTP 插件。
+3. 新增 - 商业版支持部门架构权限模式。
+4. 新增 - 支持配置自定跨域安全策略，默认全开。
+5. 新增 - 补充私有部署，模型问题排查文档。
+6. 优化 - HTTP Body 增加特殊处理，解决字符串变量带换行时无法解析问题。
+7. 优化 - 分享链接随机生成用户头像。
+8. 优化 - 图片上传安全校验。并增加头像图片唯一存储，确保不会累计存储。
+9. 优化 - Mongo 全文索引表分离。
+10. 优化 - 知识库检索查询语句合并，同时减少查库数量。
+11. 优化 - 文件编码检测，减少 CSV 文件乱码概率。
+12. 优化 - 异步读取文件内容，减少进程阻塞。
+13. 优化 - 文件阅读，HTML 直接下载，不允许在线阅读。
+14. 修复 - HTML 文件上传，base64 图片无法自动转图片链接。
+15. 修复 - 插件计费错误。

docSite/content/zh-cn/docs/faq/app.md

@@ -7,10 +7,34 @@ toc: true
 weight: 908
 ---
 
-## 工作流中多轮对话场景中如何使连续问题被问题分类节点正确的归类
+## 多轮对话中如何使连续问题被问题分类节点正确的归类
 
 问题分类节点具有获取上下文信息的能力，当处理两个关联性较大的问题时，模型的判断准确性往往依赖于这两个问题之间的联系和模型的能力。例如，当用户先问“我该如何使用这个功能？”接着又询问“这个功能有什么限制？”时，模型借助上下文信息，就能够更精准地理解并响应。
 
 但是，当连续问题之间的关联性较小，模型判断的准确度可能会受到限制。在这种情况下，我们可以引入全局变量的概念来记录分类结果。在后续的问题分类阶段，首先检查全局变量是否存有分类结果。如果有，那么直接沿用该结果；若没有，则让模型自行判断。
 
-建议：构建批量运行脚本进行测试，评估问题分类的准确性。
+建议：构建批量运行脚本进行测试，评估问题分类的准确性。
+
+## 定时执行的时机问题
+
+系统编排配置中的定时执行，如果用户打开分享的连接，停留在那个页面，定时执行触发问题：
+
+定时执行会在应用发布后生效，会在后台生效。
+
+## AI对话回答要求中的Markdown语法取消
+
+修改知识库默认提示词, 默认用的是标准模板提示词，会要求按 Markdown 输出，可以去除该要求：
+
+| | |
+| --- | --- |
+| ![](/imgs/image-83.png) | ![](/imgs/image-84.png) |
+
+## 应用在不同来源效果不一致
+
+Q: 应用在调试和正式发布后，效果不一致；在 API 调用时，效果不一致。
+
+A: 通常是由于上下文不一致导致，可以在对话日志中，找到对应的记录，并查看运行详情来进行比对。
+
+| | | |
+| --- | --- | --- |
+| ![](/imgs/image-85.png) | ![](/imgs/image-86.png) | ![](/imgs/image-87.png) |

docSite/content/zh-cn/docs/faq/dataset.md

@@ -14,4 +14,51 @@ weight: 910
 ## 知识库配置里的文件处理模型是什么？与索引模型有什么区别？
 
 * **文件处理模型**：用于数据处理的【增强处理】和【问答拆分】。在【增强处理】中，生成相关问题和摘要，在【问答拆分】中执行问答对生成。
-* **索引模型**：用于向量化，即通过对文本数据进行处理和组织，构建出一个能够快速查询的数据结构。
+* **索引模型**：用于向量化，即通过对文本数据进行处理和组织，构建出一个能够快速查询的数据结构。
+
+## 基于知识库的查询，但是问题相关的答案过多。ai回答到一半就不继续回答。
+
+FastGPT回复长度计算公式:
+
+最大回复=min(配置的最大回复（内置的限制），最大上下文（输入和输出的总和）-历史记录)
+
+18K模型->输入与输出的和
+
+输出增多->输入减小
+
+所以可以：
+
+1. 检查配置的最大回复（回复上限）
+2. 减小输入来增大输出，即减小历史记录，在工作流其实也就是“聊天记录”
+
+配置的最大回复：
+
+![](/imgs/dataset1.png)
+
+![](/imgs/dataset2.png)
+
+1. 私有化部署的时候，后台配模型参数，可以在配置最大上文时候，预留一些空间，比如 128000 的模型，可以只配置 120000, 剩余的空间后续会被安排给输出
+
+
+## 受到模型上下文的限制，有时候达不到聊天记录的轮次，连续对话字数过多就会报上下文不够的错误。
+
+FastGPT回复长度计算公式:
+
+最大回复=min(配置的最大回复（内置的限制），最大上下文（输入和输出的总和）-历史记录)
+
+18K模型->输入与输出的和
+
+输出增多->输入减小
+
+所以可以：
+
+1. 检查配置的最大回复（回复上限）
+2. 减小输入来增大输出，即减小历史记录，在工作流其实也就是“聊天记录”
+
+配置的最大回复：
+
+![](/imgs/dataset1.png)
+
+![](/imgs/dataset2.png)
+
+1. 私有化部署的时候，后台配模型参数，可以在配置最大上文时候，预留一些空间，比如 128000 的模型，可以只配置 120000, 剩余的空间后续会被安排给输出

docSite/content/zh-cn/docs/guide/plugins/searxng_plugin_guide.md

@@ -160,6 +160,18 @@ default_doi_resolver: 'oadoi.org'
 }
 ```
 
+* 搜索结果为空时会返回友好提示：
+
+```Bash
+{
+  "result": "[]",
+  "error": {
+    "message": "No search results",
+    "code": 500
+  }
+}
+```
+
 * 失败时通过 Promise.reject 可能返回错误信息：
 
 ```Bash

docSite/content/zh-cn/docs/intro.md

@@ -54,7 +54,7 @@ FastGPT 对外的 API 接口对齐了 OpenAI 官方接口，可以直接接入
 
 1. **项目开源**
 
-   FastGPT 遵循附加条件 Apache License 2.0 开源协议，你可以 [Fork](https://github.com/labring/FastGPT/fork) 之后进行二次开发和发布。FastGPT 社区版将保留核心功能，商业版仅在社区版基础上使用 API 的形式进行扩展，不影响学习使用。
+   FastGPT 遵循**附加条件 Apache License 2.0 开源协议**，你可以 [Fork](https://github.com/labring/FastGPT/fork) 之后进行二次开发和发布。FastGPT 社区版将保留核心功能，商业版仅在社区版基础上使用 API 的形式进行扩展，不影响学习使用。
 
 2. **独特的 QA 结构**
 

docSite/content/zh-cn/docs/shopping_cart/intro.md

@@ -53,8 +53,9 @@ FastGPT 商业版软件根据不同的部署方式，分为 3 类收费模式。
 {{< table "table-hover table-striped-columns" >}}
 | 部署方式 | 特有服务 | 上线时长 | 标品价格 |
 | ---- | ---- | ---- | ---- |
-| Sealos全托管 |  1. 有效期内免费升级。<br>2. 免运维服务&数据库。 |  半天  | 6000元起/月（3个月起）<br>或<br>60000元起/年  |
-| 自有服务器部署 |  1. 6个版本免费升级支持。 | 14天内 |  具体价格可[联系咨询](https://fael3z0zfze.feishu.cn/share/base/form/shrcnRxj3utrzjywsom96Px4sud) |
+| Sealos全托管 |  1. 有效期内免费升级。<br>2. 免运维服务&数据库。 |  半天  | 10000元起/月（3个月起）<br>或<br>120000元起/年<br>8C32G 资源，额外资源另外收费。  |
+| Sealos全托管（多节点） |  1. 有效期内免费升级。<br>2. 免运维服务&数据库。 |  半天  | 22000元起/月（3个月起）<br>或<br>264000元起/年<br>32C128G 资源，额外资源另外收费。  |
+| 自有服务器部署 |  1. 6个版本免费升级支持。 | 14天内 | 具体价格和优惠可[联系咨询](https://fael3z0zfze.feishu.cn/share/base/form/shrcnRxj3utrzjywsom96Px4sud) |
 {{< /table >}}
 
 {{% alert icon="🤖 " context="success" %}}

docSite/content/zh-cn/docs/shopping_cart/saas.md

@@ -5,8 +5,9 @@ icon: 'currency_yen'
 draft: false
 toc: true
 weight: 1102
-type: redirect
-target: https://cloud.tryfastgpt.ai/price
 ---
 
-线上版价格请查看：[https://cloud.tryfastgpt.ai/price](https://cloud.tryfastgpt.ai/price)
+线上版价格按套餐订阅模式，具体价格和计费请查看（请正确选择版本，账号不互通）：
+
+- [海外版](https://cloud.tryfastgpt.ai/price)
+- [国内版](https://cloud.fastgpt.cn/price)

docSite/content/zh-cn/docs/use-cases/app-cases/submit_application_template.md

@@ -32,11 +32,11 @@ weight: 602
 
 1. ### 创建应用模板
 
-应用模板配置以及相关资源，都会在 **projects/app/public/appMarketTemplates** 目录下。
+应用模板配置以及相关资源，都会在 **packages/templates/src** 目录下。
 
 ![](/imgs/template_submission2.png)
 
-1. 在 **projects/app/public/appMarketTemplates** 目录下，创建一个文件夹，名称为模板对应的 id。
+1. 在**packages/templates/src** 目录下，创建一个文件夹，名称为模板对应的 id。
 2. 在刚刚创建的文件夹中，再创建一个 **template.json** 文件，复制粘贴并填写如下配置：
 
 ```JSON
@@ -83,4 +83,4 @@ weight: 602
 
 - 写清楚模板的介绍和功能
 - 配上模板运行的效果图
-- 模板参数填写说明，需要在 PR 中写清楚。例如，有些模板需要去某个提供商申请 key，需要附上对应的地址和教程，后续我们会加入到文档中。
+- 模板参数填写说明，需要在 PR 中写清楚。例如，有些模板需要去某个提供商申请 key，需要附上对应的地址和教程，后续我们会加入到文档中。

files/docker/docker-compose-milvus.yml

@@ -159,6 +159,14 @@ services:
       # 日志等级: debug, info, warn, error
       - LOG_LEVEL=info
       - STORE_LOG_LEVEL=warn
+      # 工作流最大运行次数
+      - WORKFLOW_MAX_RUN_TIMES=1000
+      # 批量执行节点，最大输入长度
+      - WORKFLOW_MAX_LOOP_TIMES=100
+      # 自定义跨域，不配置时，默认都允许跨域（多个域名通过逗号分割）
+      - ALLOWED_ORIGINS=
+      # 是否开启IP限制，默认不开启
+      - USE_IP_LIMIT=false
     volumes:
       - ./config.json:/app/data/config.json
 

files/docker/docker-compose-pgvector.yml

@@ -116,6 +116,14 @@ services:
       # 日志等级: debug, info, warn, error
       - LOG_LEVEL=info
       - STORE_LOG_LEVEL=warn
+      # 工作流最大运行次数
+      - WORKFLOW_MAX_RUN_TIMES=1000
+      # 批量执行节点，最大输入长度
+      - WORKFLOW_MAX_LOOP_TIMES=100
+      # 自定义跨域，不配置时，默认都允许跨域（多个域名通过逗号分割）
+      - ALLOWED_ORIGINS=
+      # 是否开启IP限制，默认不开启
+      - USE_IP_LIMIT=false
     volumes:
       - ./config.json:/app/data/config.json
 

files/docker/docker-compose-zilliz.yml

@@ -97,6 +97,14 @@ services:
       # 日志等级: debug, info, warn, error
       - LOG_LEVEL=info
       - STORE_LOG_LEVEL=warn
+      # 工作流最大运行次数
+      - WORKFLOW_MAX_RUN_TIMES=1000
+      # 批量执行节点，最大输入长度
+      - WORKFLOW_MAX_LOOP_TIMES=100
+      # 自定义跨域，不配置时，默认都允许跨域（多个域名通过逗号分割）
+      - ALLOWED_ORIGINS=
+      # 是否开启IP限制，默认不开启
+      - USE_IP_LIMIT=false
     volumes:
       - ./config.json:/app/data/config.json
 

packages/global/common/error/code/common.ts

@@ -1,14 +1,20 @@
+import { i18nT } from '../../../../web/i18n/utils';
 import { ErrType } from '../errorCode';
 
 /* dataset: 507000 */
 const startCode = 507000;
 export enum CommonErrEnum {
+  invalidParams = 'invalidParams',
   fileNotFound = 'fileNotFound',
   unAuthFile = 'unAuthFile',
   missingParams = 'missingParams',
   inheritPermissionError = 'inheritPermissionError'
 }
 const datasetErr = [
+  {
+    statusText: CommonErrEnum.fileNotFound,
+    message: i18nT('common:error.invalid_params')
+  },
   {
     statusText: CommonErrEnum.fileNotFound,
     message: 'error.fileNotFound'

packages/global/common/error/code/team.ts

@@ -1,9 +1,11 @@
-import { ErrType } from '../errorCode';
 import { i18nT } from '../../../../web/i18n/utils';
+import type { ErrType } from '../errorCode';
 /* team: 500000 */
 export enum TeamErrEnum {
+  notUser = 'notUser',
   teamOverSize = 'teamOverSize',
   unAuthTeam = 'unAuthTeam',
+  teamMemberOverSize = 'teamMemberOverSize',
   aiPointsNotEnough = 'aiPointsNotEnough',
   datasetSizeNotEnough = 'datasetSizeNotEnough',
   datasetAmountNotEnough = 'datasetAmountNotEnough',
@@ -14,11 +16,22 @@ export enum TeamErrEnum {
   groupNameEmpty = 'groupNameEmpty',
   groupNameDuplicate = 'groupNameDuplicate',
   groupNotExist = 'groupNotExist',
+  orgMemberNotExist = 'orgMemberNotExist',
+  orgMemberDuplicated = 'orgMemberDuplicated',
+  orgNotExist = 'orgNotExist',
+  orgParentNotExist = 'orgParentNotExist',
+  cannotMoveToSubPath = 'cannotMoveToSubPath',
+  cannotModifyRootOrg = 'cannotModifyRootOrg',
+  cannotDeleteNonEmptyOrg = 'cannotDeleteNonEmptyOrg',
   cannotDeleteDefaultGroup = 'cannotDeleteDefaultGroup',
   userNotActive = 'userNotActive'
 }
 
 const teamErr = [
+  {
+    statusText: TeamErrEnum.notUser,
+    message: i18nT('common:code_error.team_error.not_user')
+  },
   {
     statusText: TeamErrEnum.teamOverSize,
     message: i18nT('common:code_error.team_error.over_size')
@@ -71,6 +84,34 @@ const teamErr = [
   {
     statusText: TeamErrEnum.userNotActive,
     message: i18nT('common:code_error.team_error.user_not_active')
+  },
+  {
+    statusText: TeamErrEnum.orgMemberNotExist,
+    message: i18nT('common:code_error.team_error.org_member_not_exist')
+  },
+  {
+    statusText: TeamErrEnum.orgMemberDuplicated,
+    message: i18nT('common:code_error.team_error.org_member_duplicated')
+  },
+  {
+    statusText: TeamErrEnum.orgNotExist,
+    message: i18nT('common:code_error.team_error.org_not_exist')
+  },
+  {
+    statusText: TeamErrEnum.orgParentNotExist,
+    message: i18nT('common:code_error.team_error.org_parent_not_exist')
+  },
+  {
+    statusText: TeamErrEnum.cannotMoveToSubPath,
+    message: i18nT('common:code_error.team_error.cannot_move_to_sub_path')
+  },
+  {
+    statusText: TeamErrEnum.cannotModifyRootOrg,
+    message: i18nT('common:code_error.team_error.cannot_modify_root_org')
+  },
+  {
+    statusText: TeamErrEnum.cannotDeleteNonEmptyOrg,
+    message: i18nT('common:code_error.team_error.cannot_delete_non_empty_org')
   }
 ];
 

packages/global/common/error/code/user.ts

@@ -2,25 +2,16 @@ import { ErrType } from '../errorCode';
 import { i18nT } from '../../../../web/i18n/utils';
 /* team: 503000 */
 export enum UserErrEnum {
-  unAuthUser = 'unAuthUser',
   unAuthRole = 'unAuthRole',
-  binVisitor = 'binVisitor',
+  account_psw_error = 'account_psw_error',
   balanceNotEnough = 'balanceNotEnough',
   unAuthSso = 'unAuthSso'
 }
 const errList = [
   {
-    statusText: UserErrEnum.unAuthUser,
-    message: i18nT('common:code_error.user_error.un_auth_user')
+    statusText: UserErrEnum.account_psw_error,
+    message: i18nT('common:code_error.account_error')
   },
-  {
-    statusText: UserErrEnum.binVisitor,
-    message: i18nT('common:code_error.user_error.bin_visitor')
-  }, // 身份校验未通过
-  {
-    statusText: UserErrEnum.binVisitor,
-    message: i18nT('common:code_error.user_error.bin_visitor_guest')
-  }, // 游客身份
   {
     statusText: UserErrEnum.balanceNotEnough,
     message: i18nT('common:code_error.user_error.balance_not_enough')

packages/global/common/error/utils.ts

@@ -5,6 +5,6 @@ export const getErrText = (err: any, def = ''): any => {
     typeof err === 'string'
       ? err
       : err?.response?.data?.message || err?.response?.message || err?.message || def;
-  msg && console.log('error =>', msg);
+  // msg && console.log('error =>', msg);
   return replaceSensitiveText(msg);
 };

packages/global/common/file/api.d.ts

@@ -1,10 +1,7 @@
-import { MongoImageTypeEnum } from './image/constants';
 import { OutLinkChatAuthProps } from '../../support/permission/chat.d';
 
 export type preUploadImgProps = OutLinkChatAuthProps & {
-  type: `${MongoImageTypeEnum}`;
-
-  expiredTime?: Date;
+  // expiredTime?: Date;
   metadata?: Record<string, any>;
 };
 export type UploadImgProps = preUploadImgProps & {

packages/global/common/file/image/constants.ts

@@ -1,61 +1,5 @@
 export const imageBaseUrl = '/api/system/img/';
 
-export enum MongoImageTypeEnum {
-  systemAvatar = 'systemAvatar',
-  appAvatar = 'appAvatar',
-  pluginAvatar = 'pluginAvatar',
-  datasetAvatar = 'datasetAvatar',
-  userAvatar = 'userAvatar',
-  teamAvatar = 'teamAvatar',
-  groupAvatar = 'groupAvatar',
-
-  chatImage = 'chatImage',
-  collectionImage = 'collectionImage'
-}
-export const mongoImageTypeMap = {
-  [MongoImageTypeEnum.systemAvatar]: {
-    label: 'appAvatar',
-    unique: true
-  },
-  [MongoImageTypeEnum.appAvatar]: {
-    label: 'appAvatar',
-    unique: true
-  },
-  [MongoImageTypeEnum.pluginAvatar]: {
-    label: 'pluginAvatar',
-    unique: true
-  },
-  [MongoImageTypeEnum.datasetAvatar]: {
-    label: 'datasetAvatar',
-    unique: true
-  },
-  [MongoImageTypeEnum.userAvatar]: {
-    label: 'userAvatar',
-    unique: true
-  },
-  [MongoImageTypeEnum.teamAvatar]: {
-    label: 'teamAvatar',
-    unique: true
-  },
-  [MongoImageTypeEnum.groupAvatar]: {
-    label: 'groupAvatar',
-    unique: true
-  },
-
-  [MongoImageTypeEnum.chatImage]: {
-    label: 'chatImage',
-    unique: false
-  },
-  [MongoImageTypeEnum.collectionImage]: {
-    label: 'collectionImage',
-    unique: false
-  }
-};
-
-export const uniqueImageTypeList = Object.entries(mongoImageTypeMap)
-  .filter(([key, value]) => value.unique)
-  .map(([key]) => key as `${MongoImageTypeEnum}`);
-
 export const FolderIcon = 'file/fill/folder';
 export const FolderImgUrl = '/imgs/files/folder.svg';
 export const HttpPluginImgUrl = '/imgs/app/httpPluginFill.svg';

packages/global/common/file/image/type.d.ts

@@ -1,12 +1,8 @@
-import { MongoImageTypeEnum } from './constants';
-
 export type MongoImageSchemaType = {
   _id: string;
   teamId: string;
   binary: Buffer;
-  createTime: Date;
   expiredTime?: Date;
-  type: `${MongoImageTypeEnum}`;
 
   metadata?: {
     mime?: string; // image mime type.

packages/global/common/file/tools.ts

@@ -2,6 +2,7 @@ import { detect } from 'jschardet';
 import { documentFileType, imageFileType } from './constants';
 import { ChatFileTypeEnum } from '../../core/chat/constants';
 import { UserChatItemValueItemType } from '../../core/chat/type';
+import * as fs from 'fs';
 
 export const formatFileSize = (bytes: number): string => {
   if (bytes === 0) return '0 B';
@@ -16,6 +17,22 @@ export const formatFileSize = (bytes: number): string => {
 export const detectFileEncoding = (buffer: Buffer) => {
   return detect(buffer.slice(0, 200))?.encoding?.toLocaleLowerCase();
 };
+export const detectFileEncodingByPath = async (path: string) => {
+  // Get 64KB file head
+  const MAX_BYTES = 64 * 1024;
+  const buffer = Buffer.alloc(MAX_BYTES);
+
+  const fd = await fs.promises.open(path, 'r');
+  try {
+    // Read file head
+    const { bytesRead } = await fd.read(buffer, 0, MAX_BYTES, 0);
+    const actualBuffer = buffer.slice(0, bytesRead);
+
+    return detect(actualBuffer)?.encoding?.toLocaleLowerCase();
+  } finally {
+    await fd.close();
+  }
+};
 
 // Url => user upload file type
 export const parseUrlToFileType = (url: string): UserChatItemValueItemType['file'] | undefined => {

packages/global/common/string/http.ts

@@ -0,0 +1,44 @@
+import parse from '@bany/curl-to-json';
+
+type RequestMethod = 'get' | 'post' | 'put' | 'delete' | 'patch';
+const methodMap: { [K in RequestMethod]: string } = {
+  get: 'GET',
+  post: 'POST',
+  put: 'PUT',
+  delete: 'DELETE',
+  patch: 'PATCH'
+};
+
+export const parseCurl = (curlContent: string) => {
+  const parsed = parse(curlContent);
+
+  if (!parsed.url) {
+    throw new Error('url not found');
+  }
+
+  const newParams = Object.keys(parsed.params || {}).map((key) => ({
+    key,
+    value: parsed.params?.[key],
+    type: 'string'
+  }));
+  const newHeaders = Object.keys(parsed.header || {}).map((key) => ({
+    key,
+    value: parsed.header?.[key],
+    type: 'string'
+  }));
+  const newBody = JSON.stringify(parsed.data, null, 2);
+  const bodyArray = Object.keys(parsed.data || {}).map((key) => ({
+    key,
+    value: parsed.data?.[key],
+    type: 'string'
+  }));
+
+  return {
+    url: parsed.url,
+    method: methodMap[parsed.method?.toLowerCase() as RequestMethod] || 'GET',
+    params: newParams,
+    headers: newHeaders,
+    body: newBody,
+    bodyArray
+  };
+};

packages/global/common/string/tools.ts

@@ -25,17 +25,22 @@ export const simpleText = (text = '') => {
   return text;
 };
 
-/* 
-  replace {{variable}} to value
-*/
+export const valToStr = (val: any) => {
+  if (val === undefined) return 'undefined';
+  if (val === null) return 'null';
+
+  if (typeof val === 'object') return JSON.stringify(val);
+  return String(val);
+};
+
+// replace {{variable}} to value
 export function replaceVariable(text: any, obj: Record<string, string | number>) {
   if (typeof text !== 'string') return text;
 
   for (const key in obj) {
     const val = obj[key];
-    const formatVal = typeof val === 'object' ? JSON.stringify(val) : String(val);
-
-    text = text.replace(new RegExp(`{{(${key})}}`, 'g'), formatVal);
+    const formatVal = valToStr(val);
+    text = text.replace(new RegExp(`{{(${key})}}`, 'g'), () => formatVal);
   }
   return text || '';
 }

packages/global/common/system/constants.ts

@@ -1,6 +1,9 @@
 export const HUMAN_ICON = `/icon/human.svg`;
 export const LOGO_ICON = `/icon/logo.svg`;
 export const HUGGING_FACE_ICON = `/imgs/model/huggingface.svg`;
+
 export const DEFAULT_TEAM_AVATAR = `/imgs/avatar/defaultTeamAvatar.svg`;
+export const DEFAULT_ORG_AVATAR = '/imgs/avatar/defaultOrgAvatar.svg';
+export const DEFAULT_USER_AVATAR = '/imgs/avatar/BlueAvatar.svg';
 
 export const isProduction = process.env.NODE_ENV === 'production';

packages/global/common/system/types/index.d.ts

@@ -73,6 +73,11 @@ export type FastGPTFeConfigsType = {
     google?: string;
     wechat?: string;
     dingtalk?: string;
+    wecom?: {
+      corpid?: string;
+      agentid?: string;
+      secret?: string;
+    };
     microsoft?: {
       clientId?: string;
       tenantId?: string;

packages/global/core/ai/model.d.ts

@@ -53,6 +53,7 @@ export type VectorModelItemType = PriceType & {
 };
 
 export type ReRankModelItemType = PriceType & {
+  provider: ModelProviderIdType;
   model: string;
   name: string;
   requestUrl: string;

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

@@ -1,6 +1,6 @@
-import { RequireOnlyOne } from '../../common/type/utils';
+import type { RequireOnlyOne } from '../../common/type/utils';
 import {
-  UpdateClbPermissionProps,
+  type UpdateClbPermissionProps,
   UpdatePermissionBody
 } from '../../support/permission/collaborator';
 import { PermissionValueType } from '../../support/permission/type';
@@ -14,4 +14,5 @@ export type AppCollaboratorDeleteParams = {
 } & RequireOnlyOne<{
   tmbId: string;
   groupId: string;
+  orgId: string;
 }>;

packages/global/core/app/utils.ts

@@ -5,6 +5,8 @@ import type { FlowNodeInputItemType } from '../workflow/type/io.d';
 import { getAppChatConfig } from '../workflow/utils';
 import { StoreNodeItemType } from '../workflow/type/node';
 import { DatasetSearchModeEnum } from '../dataset/constants';
+import { WorkflowTemplateBasicType } from '../workflow/type';
+import { AppTypeEnum } from './constants';
 
 export const getDefaultAppForm = (): AppSimpleEditFormType => {
   return {
@@ -127,3 +129,20 @@ export const appWorkflow2Form = ({
 
   return defaultAppForm;
 };
+
+export const getAppType = (config?: WorkflowTemplateBasicType | AppSimpleEditFormType) => {
+  if (!config) return '';
+
+  if ('aiSettings' in config) {
+    return AppTypeEnum.simple;
+  }
+
+  if (!('nodes' in config)) return '';
+  if (config.nodes.some((node) => node.flowNodeType === 'workflowStart')) {
+    return AppTypeEnum.workflow;
+  }
+  if (config.nodes.some((node) => node.flowNodeType === 'pluginInput')) {
+    return AppTypeEnum.plugin;
+  }
+  return '';
+};

packages/global/core/dataset/collaborator.d.ts

@@ -11,4 +11,5 @@ export type DatasetCollaboratorDeleteParams = {
 } & RequireOnlyOne<{
   tmbId: string;
   groupId: string;
+  orgId: string;
 }>;

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

@@ -112,6 +112,15 @@ export type DatasetDataSchemaType = {
   rebuilding?: boolean;
 };
 
+export type DatasetDataTextSchemaType = {
+  _id: string;
+  teamId: string;
+  datasetId: string;
+  collectionId: string;
+  dataId: string;
+  fullTextToken: string;
+};
+
 export type DatasetTrainingSchemaType = {
   _id: string;
   userId: string;

packages/global/core/workflow/runtime/utils.ts

@@ -9,7 +9,7 @@ import { isValidReferenceValueFormat } from '../utils';
 import { FlowNodeOutputItemType, ReferenceValueType } from '../type/io';
 import { ChatItemType, NodeOutputItemType } from '../../../core/chat/type';
 import { ChatItemValueTypeEnum, ChatRoleEnum } from '../../../core/chat/constants';
-import { replaceVariable } from '../../../common/string/tools';
+import { replaceVariable, valToStr } from '../../../common/string/tools';
 
 export const getMaxHistoryLimitFromNodes = (nodes: StoreNodeItemType[]): number => {
   let limit = 10;
@@ -339,15 +339,12 @@ export function replaceEditorVariable({
       const output = node.outputs.find((output) => output.id === id);
       if (output) return formatVariableValByType(output.value, output.valueType);
 
+      // Use the node's input as the variable value(Example: HTTP data will reference its own dynamic input)
       const input = node.inputs.find((input) => input.key === id);
       if (input) return getReferenceVariableValue({ value: input.value, nodes, variables });
     })();
 
-    const formatVal = (() => {
-      if (variableVal === undefined) return 'undefined';
-      if (variableVal === null) return 'null';
-      return typeof variableVal === 'object' ? JSON.stringify(variableVal) : String(variableVal);
-    })();
+    const formatVal = valToStr(variableVal);
 
     const regex = new RegExp(`\\{\\{\\$(${nodeId}\\.${id})\\$\\}\\}`, 'g');
     text = text.replace(regex, () => formatVal);

packages/global/core/workflow/type/io.d.ts

@@ -49,9 +49,10 @@ export type FlowNodeInputItemType = InputComponentPropsType & {
   debugLabel?: string;
   description?: string; // field desc
   required?: boolean;
-  toolDescription?: string; // If this field is not empty, it is entered as a tool
   enum?: string;
 
+  toolDescription?: string; // If this field is not empty, it is entered as a tool
+
   // render components params
   canEdit?: boolean; // dynamic inputs
   isPro?: boolean; // Pro version field

packages/global/package.json

@@ -13,7 +13,9 @@
     "next": "14.2.5",
     "openai": "4.61.0",
     "openapi-types": "^12.1.3",
-    "timezones-list": "^3.0.2"
+    "json5": "^2.2.3",
+    "timezones-list": "^3.0.2",
+    "@bany/curl-to-json": "^1.2.8"
   },
   "devDependencies": {
     "@types/js-yaml": "^4.0.9",

packages/global/support/permission/collaborator.d.ts

@@ -10,22 +10,18 @@ export type CollaboratorItemType = {
 } & RequireOnlyOne<{
   tmbId: string;
   groupId: string;
+  orgId: string;
 }>;
 
 export type UpdateClbPermissionProps = {
   members?: string[];
   groups?: string[];
+  orgs?: string[];
   permission: PermissionValueType;
 };
 
-export type DeleteClbPermissionProps = RequireOnlyOne<{
-  tmbId: string;
-  groupId: string;
-}>;
-
-export type UpdatePermissionBody = {
-  permission: PermissionValueType;
-} & RequireOnlyOne<{
-  memberId: string;
-  groupId: string;
+export type DeletePermissionQuery = RequireOnlyOne<{
+  tmbId?: string;
+  groupId?: string;
+  orgId?: string;
 }>;

packages/global/support/permission/type.d.ts

@@ -1,8 +1,9 @@
 import { UserModelSchema } from '../user/type';
 import { RequireOnlyOne } from '../../common/type/utils';
 import { TeamMemberSchema } from '../user/team/type';
-import { AuthUserTypeEnum, PermissionKeyEnum, PerResourceTypeEnum } from './constant';
 import { MemberGroupSchemaType } from './memberGroup/type';
+import type { TeamMemberWithUserSchema } from '../user/team/type';
+import { AuthUserTypeEnum, type PermissionKeyEnum, type PerResourceTypeEnum } from './constant';
 
 // PermissionValueType, the type of permission's value is a number, which is a bit field actually.
 // It is spired by the permission system in Linux.
@@ -29,6 +30,7 @@ export type ResourcePermissionType = {
 } & RequireOnlyOne<{
   tmbId: string;
   groupId: string;
+  orgId: string;
 }>;
 
 export type ResourcePerWithTmbWithUser = Omit<ResourcePermissionType, 'tmbId'> & {

packages/global/support/user/constant.ts

@@ -17,5 +17,6 @@ export enum OAuthEnum {
   wechat = 'wechat',
   microsoft = 'microsoft',
   dingtalk = 'dingtalk',
+  wecom = 'wecom',
   sso = 'sso'
 }

packages/global/support/user/login/constants.ts

@@ -0,0 +1,3 @@
+export function checkIsWecomTerminal() {
+  return /wxwork/i.test(navigator.userAgent);
+}

packages/global/support/user/team/org/api.d.ts

@@ -0,0 +1,32 @@
+export type postCreateOrgData = {
+  name: string;
+  parentId: string;
+  description?: string;
+  avatar?: string;
+};
+
+export type putUpdateOrgMembersData = {
+  orgId: string;
+  members: {
+    tmbId: string;
+    // role: `${OrgMemberRole}`;
+  }[];
+};
+
+export type putUpdateOrgData = {
+  orgId: string;
+  name?: string;
+  avatar?: string;
+  description?: string;
+};
+
+export type putMoveOrgType = {
+  orgId: string;
+  targetOrgId: string;
+};
+
+// type putChnageOrgOwnerData = {
+//   orgId: string;
+//   tmbId: string;
+//   toAdmin?: boolean;
+// };

packages/global/support/user/team/org/constant.ts

@@ -0,0 +1,12 @@
+import { OrgSchemaType } from './type';
+
+export const OrgCollectionName = 'team_orgs';
+export const OrgMemberCollectionName = 'team_org_members';
+
+export const getOrgChildrenPath = (org: OrgSchemaType) => `${org.path}/${org.pathId}`;
+
+// export enum OrgMemberRole {
+//   owner = 'owner',
+//   admin = 'admin',
+//   member = 'member'
+// }

packages/global/support/user/team/org/type.d.ts

@@ -0,0 +1,25 @@
+import type { TeamPermission } from 'support/permission/user/controller';
+import { ResourcePermissionType } from '../type';
+
+type OrgSchemaType = {
+  _id: string;
+  teamId: string;
+  pathId: string;
+  path: string;
+  name: string;
+  avatar?: string;
+  description?: string;
+  updateTime: Date;
+};
+
+type OrgMemberSchemaType = {
+  teamId: string;
+  orgId: string;
+  tmbId: string;
+};
+
+type OrgType = Omit<OrgSchemaType, 'avatar'> & {
+  avatar: string;
+  members: OrgMemberSchemaType[];
+  permission: TeamPermission;
+};

packages/global/support/user/team/type.d.ts

@@ -55,10 +55,11 @@ export type TeamMemberWithTeamAndUserSchema = TeamMemberSchema & {
 export type TeamTmbItemType = {
   userId: string;
   teamId: string;
+  teamAvatar?: string;
   teamName: string;
   memberName: string;
   avatar: string;
-  balance: number;
+  balance?: number;
   tmbId: string;
   teamDomain: string;
   defaultTeam: boolean;

packages/global/support/user/utils.ts

@@ -0,0 +1,16 @@
+export const getRandomUserAvatar = () => {
+  const defaultAvatars = [
+    '/imgs/avatar/RoyalBlueAvatar.svg',
+    '/imgs/avatar/PurpleAvatar.svg',
+    '/imgs/avatar/AdoraAvatar.svg',
+    '/imgs/avatar/OrangeAvatar.svg',
+    '/imgs/avatar/RedAvatar.svg',
+    '/imgs/avatar/GrayModernAvatar.svg',
+    '/imgs/avatar/TealAvatar.svg',
+    '/imgs/avatar/GreenAvatar.svg',
+    '/imgs/avatar/BrightBlueAvatar.svg',
+    '/imgs/avatar/BlueAvatar.svg'
+  ];
+
+  return defaultAvatars[Math.floor(Math.random() * defaultAvatars.length)];
+};

packages/plugins/register.ts

@@ -35,24 +35,26 @@ export const list = [...staticPluginList, ...packagePluginList];
 
 /* Get plugins */
 export const getCommunityPlugins = () => {
-  return list.map<SystemPluginTemplateItemType>((name) => {
-    const config = require(`./src/${name}/template.json`);
+  return Promise.all(
+    list.map<Promise<SystemPluginTemplateItemType>>(async (name) => {
+      const config = (await import(`./src/${name}/template.json`))?.default;
 
-    const isFolder = list.find((item) => item.startsWith(`${name}/`));
+      const isFolder = list.find((item) => item.startsWith(`${name}/`));
 
-    const parentIdList = name.split('/').slice(0, -1);
-    const parentId =
-      parentIdList.length > 0 ? `${PluginSourceEnum.community}-${parentIdList.join('/')}` : null;
+      const parentIdList = name.split('/').slice(0, -1);
+      const parentId =
+        parentIdList.length > 0 ? `${PluginSourceEnum.community}-${parentIdList.join('/')}` : null;
 
-    return {
-      ...config,
-      id: `${PluginSourceEnum.community}-${name}`,
-      isFolder,
-      parentId,
-      isActive: true,
-      isOfficial: true
-    };
-  });
+      return {
+        ...config,
+        id: `${PluginSourceEnum.community}-${name}`,
+        isFolder,
+        parentId,
+        isActive: true,
+        isOfficial: true
+      };
+    })
+  );
 };
 
 export const getSystemPluginTemplates = () => {

packages/plugins/src/drawing/baseChart/index.ts

@@ -4,8 +4,8 @@ import { SystemPluginSpecialResponse } from '../../../type.d';
 
 type Props = {
   title: string;
-  xAxis: string;
-  yAxis: string;
+  xAxis: string[];
+  yAxis: string[];
   chartType: string;
 };
 
@@ -27,7 +27,12 @@ type Option = {
   series: SeriesData[]; // 使用定义的类型
 };
 
-const generateChart = async (title: string, xAxis: string, yAxis: string, chartType: string) => {
+const generateChart = async (
+  title: string,
+  xAxis: string[],
+  yAxis: string[],
+  chartType: string
+) => {
   // @ts-ignore  无法使用dom，如使用jsdom会出现生成图片无法正常展示，有高手可以帮忙解决
   const chart = echarts.init(undefined, undefined, {
     renderer: 'svg', // 必须使用 SVG 模式
@@ -36,21 +41,11 @@ const generateChart = async (title: string, xAxis: string, yAxis: string, chartT
     height: 300
   });
 
-  let parsedXAxis: string[] = [];
-  let parsedYAxis: number[] = [];
-  try {
-    parsedXAxis = json5.parse(xAxis);
-    parsedYAxis = json5.parse(yAxis);
-  } catch (error: any) {
-    console.error('解析数据时出错:', error);
-    return Promise.reject('Data error');
-  }
-
   const option: Option = {
     backgroundColor: '#f5f5f5',
     title: { text: title },
     tooltip: {},
-    xAxis: { data: parsedXAxis },
+    xAxis: { data: xAxis },
     yAxis: {},
     series: [] // 初始化为空数组
   };
@@ -58,18 +53,18 @@ const generateChart = async (title: string, xAxis: string, yAxis: string, chartT
   // 根据 chartType 生成不同的图表
   switch (chartType) {
     case '柱状图':
-      option.series.push({ name: 'Sample', type: 'bar', data: parsedYAxis });
+      option.series.push({ name: 'Sample', type: 'bar', data: yAxis.map(Number) });
       break;
     case '折线图':
-      option.series.push({ name: 'Sample', type: 'line', data: parsedYAxis });
+      option.series.push({ name: 'Sample', type: 'line', data: yAxis.map(Number) });
       break;
     case '饼图':
       option.series.push({
         name: 'Sample',
         type: 'pie',
-        data: parsedYAxis.map((value, index) => ({
-          value,
-          name: parsedXAxis[index] // 使用 xAxis 作为饼图的名称
+        data: yAxis.map((value, index) => ({
+          value: Number(value),
+          name: xAxis[index] // 使用 xAxis 作为饼图的名称
         }))
       });
       break;

packages/plugins/src/drawing/baseChart/template.json

@@ -1,6 +1,6 @@
 {
   "author": "silencezhang",
-  "version": "4812",
+  "version": "4817",
   "name": "基础图表",
   "avatar": "core/workflow/template/baseChart",
   "intro": "根据数据生成图表，可根据chartType生成柱状图，折线图，饼图",
@@ -68,7 +68,7 @@
             "canEdit": true,
             "key": "yAxis",
             "label": "yAxis",
-            "description": "y轴数据，例如：['1', '2', '3']",
+            "description": "y轴数据，例如：[1,2,3]",
             "defaultValue": "",
             "list": [
               {
@@ -77,7 +77,7 @@
               }
             ],
             "required": true,
-            "toolDescription": "y轴数据，例如：['1', '2', '3']"
+            "toolDescription": "y轴数据，例如：[1,2,3]"
           },
           {
             "renderTypeList": ["select", "reference"],
@@ -145,8 +145,8 @@
         "flowNodeType": "pluginOutput",
         "showStatus": false,
         "position": {
-          "x": 2122.252754006148,
-          "y": -63.5218674613718
+          "x": 2128.8138851197145,
+          "y": -63.52186746137181
         },
         "version": "481",
         "inputs": [
@@ -154,10 +154,12 @@
             "renderTypeList": ["reference"],
             "valueType": "string",
             "canEdit": true,
-            "key": "相对路径URL",
-            "label": "相对路径URL",
+            "key": "图表 url",
+            "label": "图表 url",
             "description": "可用使用markdown格式展示图片，如：![图片](url)",
-            "value": ["ws0DFKJnCPhk", "bzaYjKyQFOw2"]
+            "value": ["ws0DFKJnCPhk", "bzaYjKyQFOw2"],
+            "isToolOutput": true,
+            "required": true
           }
         ],
         "outputs": []
@@ -170,8 +172,8 @@
         "flowNodeType": "httpRequest468",
         "showStatus": true,
         "position": {
-          "x": 1216.5166647574395,
-          "y": -206.30162946606856
+          "x": 1264.2009472531117,
+          "y": -455.0773486762623
         },
         "version": "481",
         "inputs": [
@@ -275,7 +277,7 @@
             "key": "system_httpJsonBody",
             "renderTypeList": ["hidden"],
             "valueType": "any",
-            "value": "{\r\n  \"title\": \"{{title-plugin}}\",\r\n  \"xAxis\": \"{{xAxis-plugin}}\",\r\n  \"yAxis\": \"{{yAxis-plugin}}\",\r\n  \"chartType\": \"{{chartType-plugin}}\"\r\n}",
+            "value": "{\r\n  \"title\": \"{{$pluginInput.title$}}\",\r\n  \"xAxis\": {{$pluginInput.xAxis$}},\r\n  \"yAxis\": {{$pluginInput.yAxis$}},\r\n  \"chartType\": \"{{$pluginInput.chartType$}}\"\r\n}",
             "label": "",
             "required": false,
             "valueDesc": "",
@@ -306,126 +308,6 @@
             "description": "",
             "debugLabel": "",
             "toolDescription": ""
-          },
-          {
-            "renderTypeList": ["reference"],
-            "valueType": "string",
-            "canEdit": true,
-            "key": "title-plugin",
-            "label": "title-plugin",
-            "customInputConfig": {
-              "selectValueTypeList": [
-                "string",
-                "number",
-                "boolean",
-                "object",
-                "arrayString",
-                "arrayNumber",
-                "arrayBoolean",
-                "arrayObject",
-                "arrayAny",
-                "any",
-                "chatHistory",
-                "datasetQuote",
-                "dynamic",
-                "selectApp",
-                "selectDataset"
-              ],
-              "showDescription": false,
-              "showDefaultValue": true
-            },
-            "required": true,
-            "value": ["pluginInput", "title"]
-          },
-          {
-            "renderTypeList": ["reference"],
-            "valueType": "string",
-            "canEdit": true,
-            "key": "xAxis-plugin",
-            "label": "xAxis-plugin",
-            "customInputConfig": {
-              "selectValueTypeList": [
-                "string",
-                "number",
-                "boolean",
-                "object",
-                "arrayString",
-                "arrayNumber",
-                "arrayBoolean",
-                "arrayObject",
-                "arrayAny",
-                "any",
-                "chatHistory",
-                "datasetQuote",
-                "dynamic",
-                "selectApp",
-                "selectDataset"
-              ],
-              "showDescription": false,
-              "showDefaultValue": true
-            },
-            "required": true,
-            "value": ["pluginInput", "xAxis"]
-          },
-          {
-            "renderTypeList": ["reference"],
-            "valueType": "string",
-            "canEdit": true,
-            "key": "yAxis-plugin",
-            "label": "yAxis-plugin",
-            "customInputConfig": {
-              "selectValueTypeList": [
-                "string",
-                "number",
-                "boolean",
-                "object",
-                "arrayString",
-                "arrayNumber",
-                "arrayBoolean",
-                "arrayObject",
-                "arrayAny",
-                "any",
-                "chatHistory",
-                "datasetQuote",
-                "dynamic",
-                "selectApp",
-                "selectDataset"
-              ],
-              "showDescription": false,
-              "showDefaultValue": true
-            },
-            "required": true,
-            "value": ["pluginInput", "yAxis"]
-          },
-          {
-            "renderTypeList": ["reference"],
-            "valueType": "string",
-            "canEdit": true,
-            "key": "chartType-plugin",
-            "label": "chartType-plugin",
-            "customInputConfig": {
-              "selectValueTypeList": [
-                "string",
-                "number",
-                "boolean",
-                "object",
-                "arrayString",
-                "arrayNumber",
-                "arrayBoolean",
-                "arrayObject",
-                "arrayAny",
-                "any",
-                "chatHistory",
-                "datasetQuote",
-                "dynamic",
-                "selectApp",
-                "selectDataset"
-              ],
-              "showDescription": false,
-              "showDefaultValue": true
-            },
-            "required": true,
-            "value": ["pluginInput", "chartType"]
           }
         ],
         "outputs": [

packages/plugins/src/searchXNG/index.ts

@@ -48,6 +48,16 @@ const main = async (props: Props, retry = 3): Response => {
       });
     });
 
+    if (results.length === 0) {
+      return {
+        result: JSON.stringify([]),
+        error: {
+          message: 'No search results',
+          code: 500
+        }
+      };
+    }
+
     return {
       result: JSON.stringify(results.slice(0, 10))
     };

packages/service/common/file/gridfs/controller.ts

@@ -4,7 +4,7 @@ import fsp from 'fs/promises';
 import fs from 'fs';
 import { DatasetFileSchema } from '@fastgpt/global/core/dataset/type';
 import { MongoChatFileSchema, MongoDatasetFileSchema } from './schema';
-import { detectFileEncoding } from '@fastgpt/global/common/file/tools';
+import { detectFileEncoding, detectFileEncodingByPath } from '@fastgpt/global/common/file/tools';
 import { CommonErrEnum } from '@fastgpt/global/common/error/code/common';
 import { MongoRawTextBuffer } from '../../buffer/rawText/schema';
 import { readRawContentByFileBuffer } from '../read/utils';
@@ -36,7 +36,6 @@ export async function uploadFile({
   path,
   filename,
   contentType,
-  encoding,
   metadata = {}
 }: {
   bucketName: `${BucketNameEnum}`;
@@ -45,7 +44,6 @@ export async function uploadFile({
   path: string;
   filename: string;
   contentType?: string;
-  encoding: string;
   metadata?: Record<string, any>;
 }) {
   if (!path) return Promise.reject(`filePath is empty`);
@@ -59,7 +57,7 @@ export async function uploadFile({
   // Add default metadata
   metadata.teamId = teamId;
   metadata.uid = uid;
-  metadata.encoding = encoding;
+  metadata.encoding = await detectFileEncodingByPath(path);
 
   // create a gridfs bucket
   const bucket = getGridBucket(bucketName);

packages/service/common/file/image/controller.ts

@@ -1,43 +1,92 @@
 import { UploadImgProps } from '@fastgpt/global/common/file/api';
 import { imageBaseUrl } from '@fastgpt/global/common/file/image/constants';
 import { MongoImage } from './schema';
-import { ClientSession } from '../../../common/mongo';
+import { ClientSession, Types } from '../../../common/mongo';
 import { guessBase64ImageType } from '../utils';
 import { readFromSecondary } from '../../mongo/utils';
+import { addHours } from 'date-fns';
 
 export const maxImgSize = 1024 * 1024 * 12;
 const base64MimeRegex = /data:image\/([^\)]+);base64/;
 export async function uploadMongoImg({
-  type,
   base64Img,
   teamId,
-  expiredTime,
   metadata,
-  shareId
+  shareId,
+  forever = false
 }: UploadImgProps & {
   teamId: string;
+  forever?: Boolean;
 }) {
   if (base64Img.length > maxImgSize) {
     return Promise.reject('Image too large');
   }
 
   const [base64Mime, base64Data] = base64Img.split(',');
+  // Check if mime type is valid
+  if (!base64MimeRegex.test(base64Mime)) {
+    return Promise.reject('Invalid image mime type');
+  }
+
   const mime = `image/${base64Mime.match(base64MimeRegex)?.[1] ?? 'image/jpeg'}`;
   const binary = Buffer.from(base64Data, 'base64');
   const extension = mime.split('/')[1];
 
   const { _id } = await MongoImage.create({
-    type,
     teamId,
     binary,
-    expiredTime,
     metadata: Object.assign({ mime }, metadata),
-    shareId
+    shareId,
+    expiredTime: forever ? undefined : addHours(new Date(), 1)
   });
 
   return `${process.env.FE_DOMAIN || ''}${process.env.NEXT_PUBLIC_BASE_URL || ''}${imageBaseUrl}${String(_id)}.${extension}`;
 }
 
+const getIdFromPath = (path?: string) => {
+  if (!path) return;
+
+  const paths = path.split('/');
+  const name = paths[paths.length - 1];
+
+  if (!name) return;
+
+  const id = name.split('.')[0];
+  if (!id || !Types.ObjectId.isValid(id)) return;
+
+  return id;
+};
+// 删除旧的头像，新的头像去除过期时间
+export const refreshSourceAvatar = async (
+  path?: string,
+  oldPath?: string,
+  session?: ClientSession
+) => {
+  const newId = getIdFromPath(path);
+  const oldId = getIdFromPath(oldPath);
+
+  if (!newId) return;
+
+  await MongoImage.updateOne({ _id: newId }, { $unset: { expiredTime: 1 } }, { session });
+
+  if (oldId) {
+    await MongoImage.deleteOne({ _id: oldId }, { session });
+  }
+};
+export const removeImageByPath = (path?: string, session?: ClientSession) => {
+  if (!path) return;
+
+  const paths = path.split('/');
+  const name = paths[paths.length - 1];
+
+  if (!name) return;
+
+  const id = name.split('.')[0];
+  if (!id || !Types.ObjectId.isValid(id)) return;
+
+  return MongoImage.deleteOne({ _id: id }, { session });
+};
+
 export async function readMongoImg({ id }: { id: string }) {
   const formatId = id.replace(/\.[^/.]+$/, '');
 

packages/service/common/file/image/schema.ts

@@ -1,8 +1,7 @@
 import { TeamCollectionName } from '@fastgpt/global/support/user/team/constant';
-import { connectionMongo, getMongoModel, type Model } from '../../mongo';
+import { connectionMongo, getMongoModel } from '../../mongo';
 import { MongoImageSchemaType } from '@fastgpt/global/common/file/image/type.d';
-import { mongoImageTypeMap } from '@fastgpt/global/common/file/image/constants';
-const { Schema, model, models } = connectionMongo;
+const { Schema } = connectionMongo;
 
 const ImageSchema = new Schema({
   teamId: {
@@ -14,27 +13,15 @@ const ImageSchema = new Schema({
     type: Date,
     default: () => new Date()
   },
-  expiredTime: {
-    type: Date
-  },
-  binary: {
-    type: Buffer
-  },
-  type: {
-    type: String,
-    enum: Object.keys(mongoImageTypeMap),
-    required: true
-  },
-  metadata: {
-    type: Object
-  }
+  expiredTime: Date,
+  binary: Buffer,
+  metadata: Object
 });
 
 try {
   // tts expired（60 Minutes）
   ImageSchema.index({ expiredTime: 1 }, { expireAfterSeconds: 60 * 60 });
   ImageSchema.index({ type: 1 });
-  ImageSchema.index({ createTime: 1 });
   // delete related img
   ImageSchema.index({ teamId: 1, 'metadata.relatedId': 1 });
 } catch (error) {

packages/service/common/file/read/utils.ts

@@ -1,5 +1,4 @@
 import { uploadMongoImg } from '../image/controller';
-import { MongoImageTypeEnum } from '@fastgpt/global/common/file/image/constants';
 import FormData from 'form-data';
 
 import { WorkerNameEnum, runWorker } from '../../../worker/utils';
@@ -8,7 +7,6 @@ import type { ReadFileResponse } from '../../../worker/readFile/type';
 import axios from 'axios';
 import { addLog } from '../../system/log';
 import { batchRun } from '@fastgpt/global/common/fn/utils';
-import { addHours } from 'date-fns';
 import { matchMdImgTextAndUpload } from '@fastgpt/global/common/string/markdown';
 
 export type readRawTextByLocalFileParams = {
@@ -22,7 +20,7 @@ export const readRawTextByLocalFile = async (params: readRawTextByLocalFileParam
 
   const extension = path?.split('.')?.pop()?.toLowerCase() || '';
 
-  const buffer = fs.readFileSync(path);
+  const buffer = await fs.promises.readFile(path);
 
   const { rawText } = await readRawContentByFileBuffer({
     extension,
@@ -114,10 +112,9 @@ export const readRawContentByFileBuffer = async ({
   if (imageList) {
     await batchRun(imageList, async (item) => {
       const src = await uploadMongoImg({
-        type: MongoImageTypeEnum.collectionImage,
         base64Img: `data:${item.mime};base64,${item.base64}`,
         teamId,
-        expiredTime: addHours(new Date(), 1),
+        // expiredTime: addHours(new Date(), 1),
         metadata: {
           ...metadata,
           mime: item.mime

packages/service/common/middle/cors.ts

@@ -3,10 +3,13 @@ import NextCors from 'nextjs-cors';
 
 export async function withNextCors(req: NextApiRequest, res: NextApiResponse) {
   const methods = ['GET', 'eHEAD', 'PUT', 'PATCH', 'POST', 'DELETE'];
+
+  const allowedOrigins = process.env.ALLOWED_ORIGINS?.split(',');
   const origin = req.headers.origin;
+
   await NextCors(req, res, {
     methods,
-    origin: origin,
+    origin: allowedOrigins || origin,
     optionsSuccessStatus: 200
   });
 }

packages/service/common/middle/reqFrequencyLimit.ts

@@ -9,10 +9,10 @@ import { jsonRes } from '../response';
 // unit: times/s
 // how to use?
 // export default NextAPI(useQPSLimit(10), handler); // limit 10 times per second for a ip
-export function useReqFrequencyLimit(seconds: number, limit: number) {
+export function useReqFrequencyLimit(seconds: number, limit: number, force = false) {
   return async (req: ApiRequestProps, res: NextApiResponse) => {
     const ip = requestIp.getClientIp(req);
-    if (!ip || process.env.USE_IP_LIMIT !== 'true') {
+    if (!ip || (process.env.USE_IP_LIMIT !== 'true' && !force)) {
       return;
     }
     try {
@@ -22,10 +22,9 @@ export function useReqFrequencyLimit(seconds: number, limit: number) {
         expiredTime: addSeconds(new Date(), seconds)
       });
     } catch (_) {
-      res.status(429);
       jsonRes(res, {
         code: 429,
-        message: ERROR_ENUM.tooManyRequest
+        error: ERROR_ENUM.tooManyRequest
       });
     }
   };

packages/service/common/response/index.ts

@@ -33,7 +33,7 @@ export const jsonRes = <T = any>(
 
     addLog.error(`Api response error: ${url}`, ERROR_RESPONSE[errResponseKey]);
 
-    return res.json(ERROR_RESPONSE[errResponseKey]);
+    return res.status(code).json(ERROR_RESPONSE[errResponseKey]);
   }
 
   // another error

packages/service/core/ai/config/embedding/text-embedding-ada-002.json

@@ -0,0 +1,11 @@
+{
+  "provider": "OpenAI",
+  "model": "text-embedding-ada-002",
+  "name": "text-embedding-ada-002",
+
+  "defaultToken": 512, // 默认分块 token
+  "maxToken": 3000, // 最大分块 token
+  "weight": 0, // 权重
+
+  "charsPointsPrice": 0 // 积分/1k token
+}

packages/service/core/ai/config/llm/gpt-4o-mini.json

@@ -0,0 +1,33 @@
+{
+  "provider": "OpenAI",
+  "model": "gpt-4o-mini",
+  "name": "GPT-4o-mini", // alias
+
+  "maxContext": 125000, // 最大上下文
+  "maxResponse": 16000, // 最大回复
+  "quoteMaxToken": 60000, // 最大引用
+  "maxTemperature": 1.2, // 最大温度
+  "presencePenaltyRange": [-2, 2], // 惩罚系数范围
+  "frequencyPenaltyRange": [-2, 2], // 频率惩罚系数范围
+  "responseFormatList": ["text", "json_object", "json_schema"], // 响应格式
+  "showStopSign": true, // 是否显示停止符号
+
+  "vision": true, // 是否支持图片识别
+  "toolChoice": true, // 是否支持工具调用
+  "functionCall": false, // 是否支持函数调用（一般都可以 false 了，基本不用了）
+  "defaultSystemChatPrompt": "", // 默认系统提示
+
+  "datasetProcess": true, // 用于知识库文本处理
+  "usedInClassify": true, // 用于问题分类
+  "customCQPrompt": "", // 自定义问题分类提示
+  "usedInExtractFields": true, // 用于提取字段
+  "customExtractPrompt": "", // 自定义提取提示
+  "usedInToolCall": true, // 用于工具调用
+  "usedInQueryExtension": true, // 用于问题优化
+
+  "defaultConfig": {}, // 额外的自定义 body
+  "fieldMap": {}, // body 字段映射
+
+  "censor": false, // 是否开启敏感词过滤
+  "charsPointsPrice": 0 // n 积分/1k token
+}

packages/service/core/ai/config/rerank/bge-reranker-v2-m3.json

@@ -0,0 +1,6 @@
+{
+  "provider": "BAAI",
+  "model": "bge-reranker-v2-m3",
+  "name": "bge-reranker-v2-m3",
+  "charsPointsPrice": 0
+}

packages/service/core/ai/config/stt/whisper-1.json

@@ -0,0 +1,6 @@
+{
+  "provider": "OpenAI",
+  "model": "whisper-1",
+  "name": "whisper-1",
+  "charsPointsPrice": 0
+}

packages/service/core/ai/config/tts/tts-1.json

@@ -0,0 +1,32 @@
+{
+  "provider": "OpenAI",
+  "model": "tts-1",
+  "name": "TTS1",
+  "charsPointsPrice": 0,
+  "voices": [
+    {
+      "label": "Alloy",
+      "value": "alloy"
+    },
+    {
+      "label": "Echo",
+      "value": "echo"
+    },
+    {
+      "label": "Fable",
+      "value": "fable"
+    },
+    {
+      "label": "Onyx",
+      "value": "onyx"
+    },
+    {
+      "label": "Nova",
+      "value": "nova"
+    },
+    {
+      "label": "Shimmer",
+      "value": "shimmer"
+    }
+  ]
+}

packages/service/core/app/plugin/utils.ts

@@ -1,11 +1,15 @@
 import { ChatNodeUsageType } from '@fastgpt/global/support/wallet/bill/type';
 import { PluginRuntimeType } from '@fastgpt/global/core/plugin/type';
+import { splitCombinePluginId } from './controller';
+import { PluginSourceEnum } from '@fastgpt/global/core/plugin/constants';
 
 /* 
   Plugin points calculation:
-  1. Return 0 if error
-  2. Add configured points if commercial plugin
-  3. Add sum of child nodes points
+  1. 系统插件/商业版插件：
+    - 有错误：返回 0
+    - 无错误：返回 单次积分 + 子流程积分（可配置）
+  2. 个人插件
+    - 返回 子流程积分
 */
 export const computedPluginUsage = async ({
   plugin,
@@ -16,13 +20,16 @@ export const computedPluginUsage = async ({
   childrenUsage: ChatNodeUsageType[];
   error?: boolean;
 }) => {
-  if (error) {
-    return 0;
+  const { source } = await splitCombinePluginId(plugin.id);
+  const childrenUsages = childrenUsage.reduce((sum, item) => sum + (item.totalPoints || 0), 0);
+
+  if (source !== PluginSourceEnum.personal) {
+    if (error) return 0;
+
+    const pluginCurrentCost = plugin.currentCost ?? 0;
+
+    return plugin.hasTokenFee ? pluginCurrentCost + childrenUsages : pluginCurrentCost;
   }
 
-  const childrenIUsages = childrenUsage.reduce((sum, item) => sum + (item.totalPoints || 0), 0);
-
-  const pluginCurrentCose = plugin.currentCost ?? 0;
-
-  return plugin.hasTokenFee ? pluginCurrentCose + childrenIUsages : pluginCurrentCose;
+  return childrenUsages;
 };

packages/service/core/chat/chatItemSchema.ts

@@ -86,24 +86,21 @@ const ChatItemSchema = new Schema({
 });
 
 try {
-  ChatItemSchema.index({ dataId: 1 }, { background: true });
+  ChatItemSchema.index({ dataId: 1 });
   /* delete by app; 
      delete by chat id;
      get chat list; 
      get chat logs; 
      close custom feedback; 
   */
-  ChatItemSchema.index({ appId: 1, chatId: 1, dataId: 1 }, { background: true });
+  ChatItemSchema.index({ appId: 1, chatId: 1, dataId: 1 });
   // admin charts
-  ChatItemSchema.index({ time: -1, obj: 1 }, { background: true });
+  ChatItemSchema.index({ time: -1, obj: 1 });
   // timer, clear history
-  ChatItemSchema.index({ teamId: 1, time: -1 }, { background: true });
+  ChatItemSchema.index({ teamId: 1, time: -1 });
 
   // Admin charts
-  ChatItemSchema.index(
-    { obj: 1, time: -1 },
-    { background: true, partialFilterExpression: { obj: 'Human' } }
-  );
+  ChatItemSchema.index({ obj: 1, time: -1 }, { partialFilterExpression: { obj: 'Human' } });
 } catch (error) {
   console.log(error);
 }

packages/service/core/chat/chatSchema.ts

@@ -81,19 +81,19 @@ const ChatSchema = new Schema({
 });
 
 try {
-  ChatSchema.index({ chatId: 1 }, { background: true });
+  ChatSchema.index({ chatId: 1 });
   // get user history
-  ChatSchema.index({ tmbId: 1, appId: 1, top: -1, updateTime: -1 }, { background: true });
+  ChatSchema.index({ tmbId: 1, appId: 1, top: -1, updateTime: -1 });
   // delete by appid; clear history; init chat; update chat; auth chat; get chat;
-  ChatSchema.index({ appId: 1, chatId: 1 }, { background: true });
+  ChatSchema.index({ appId: 1, chatId: 1 });
 
   // get chat logs;
-  ChatSchema.index({ teamId: 1, appId: 1, updateTime: -1 }, { background: true });
+  ChatSchema.index({ teamId: 1, appId: 1, updateTime: -1 });
   // get share chat history
-  ChatSchema.index({ shareId: 1, outLinkUid: 1, updateTime: -1 }, { background: true });
+  ChatSchema.index({ shareId: 1, outLinkUid: 1, updateTime: -1 });
 
   // timer, clear history
-  ChatSchema.index({ teamId: 1, updateTime: -1 }, { background: true });
+  ChatSchema.index({ teamId: 1, updateTime: -1 });
 } catch (error) {
   console.log(error);
 }

packages/service/core/dataset/collection/controller.ts

@@ -24,6 +24,7 @@ import { pushDataListToTrainingQueue } from '../training/controller';
 import { MongoImage } from '../../../common/file/image/schema';
 import { hashStr } from '@fastgpt/global/common/string/tools';
 import { addDays } from 'date-fns';
+import { MongoDatasetDataText } from '../data/dataTextSchema';
 
 export const createCollectionAndInsertData = async ({
   dataset,
@@ -240,12 +241,12 @@ export const delCollectionRelatedSource = async ({
     .map((item) => item?.metadata?.relatedImgId || '')
     .filter(Boolean);
 
-  // delete files
+  // Delete files
   await delFileByFileIdList({
     bucketName: BucketNameEnum.dataset,
     fileIdList
   });
-  // delete images
+  // Delete images
   await delImgByRelatedId({
     teamId,
     relateIds: relatedImageIds,
@@ -273,7 +274,7 @@ export async function delCollection({
   const datasetIds = Array.from(new Set(collections.map((item) => String(item.datasetId))));
   const collectionIds = collections.map((item) => String(item._id));
 
-  // delete training data
+  // Delete training data
   await MongoDatasetTraining.deleteMany({
     teamId,
     datasetIds: { $in: datasetIds },
@@ -285,11 +286,16 @@ export async function delCollection({
     await delCollectionRelatedSource({ collections, session });
   }
 
-  // delete dataset.datas
+  // Delete dataset_datas
   await MongoDatasetData.deleteMany(
     { teamId, datasetIds: { $in: datasetIds }, collectionId: { $in: collectionIds } },
     { session }
   );
+  // Delete dataset_data_texts
+  await MongoDatasetDataText.deleteMany(
+    { teamId, datasetIds: { $in: datasetIds }, collectionId: { $in: collectionIds } },
+    { session }
+  );
 
   // delete collections
   await MongoDatasetCollection.deleteMany(

packages/service/core/dataset/controller.ts

@@ -6,6 +6,7 @@ import { ClientSession } from '../../common/mongo';
 import { MongoDatasetTraining } from './training/schema';
 import { MongoDatasetData } from './data/schema';
 import { deleteDatasetDataVector } from '../../common/vectorStore/controller';
+import { MongoDatasetDataText } from './data/dataTextSchema';
 
 /* ============= dataset ========== */
 /* find all datasetId by top datasetId */
@@ -92,7 +93,7 @@ export async function delDatasetRelevantData({
     { session }
   ).lean();
 
-  // image and file
+  // Delete Image and file
   await delCollectionRelatedSource({ collections, session });
 
   // delete collections
@@ -101,9 +102,15 @@ export async function delDatasetRelevantData({
     datasetId: { $in: datasetIds }
   }).session(session);
 
-  // delete dataset.datas(Not need session)
+  // No session delete:
+  // Delete dataset_data_texts
+  await MongoDatasetDataText.deleteMany({
+    teamId,
+    datasetId: { $in: datasetIds }
+  });
+  // delete dataset_datas
   await MongoDatasetData.deleteMany({ teamId, datasetId: { $in: datasetIds } });
 
-  // no session delete: delete files, vector data
+  // Delete vector data
   await deleteDatasetDataVector({ teamId, datasetIds });
 }

packages/service/core/dataset/data/dataTextSchema.ts

@@ -0,0 +1,45 @@
+import { connectionMongo, getMongoModel } from '../../../common/mongo';
+const { Schema } = connectionMongo;
+import { DatasetDataSchemaType } from '@fastgpt/global/core/dataset/type.d';
+import { TeamCollectionName } from '@fastgpt/global/support/user/team/constant';
+import { DatasetCollectionName } from '../schema';
+import { DatasetColCollectionName } from '../collection/schema';
+import { DatasetDataCollectionName } from './schema';
+
+export const DatasetDataTextCollectionName = 'dataset_data_texts';
+
+const DatasetDataTextSchema = new Schema({
+  teamId: {
+    type: Schema.Types.ObjectId,
+    ref: TeamCollectionName,
+    required: true
+  },
+  datasetId: {
+    type: Schema.Types.ObjectId,
+    ref: DatasetCollectionName,
+    required: true
+  },
+  collectionId: {
+    type: Schema.Types.ObjectId,
+    ref: DatasetColCollectionName,
+    required: true
+  },
+  dataId: {
+    type: Schema.Types.ObjectId,
+    ref: DatasetDataCollectionName,
+    required: true
+  },
+  fullTextToken: String
+});
+
+try {
+  DatasetDataTextSchema.index({ teamId: 1, datasetId: 1, fullTextToken: 'text' });
+  DatasetDataTextSchema.index({ dataId: 1 }, { unique: true });
+} catch (error) {
+  console.log(error);
+}
+
+export const MongoDatasetDataText = getMongoModel<DatasetDataSchemaType>(
+  DatasetDataTextCollectionName,
+  DatasetDataTextSchema
+);

packages/service/core/dataset/data/schema.ts

@@ -1,4 +1,4 @@
-import { connectionMongo, getMongoModel, type Model } from '../../../common/mongo';
+import { connectionMongo, getMongoModel } from '../../../common/mongo';
 const { Schema, model, models } = connectionMongo;
 import { DatasetDataSchemaType } from '@fastgpt/global/core/dataset/type.d';
 import {
@@ -39,10 +39,6 @@ const DatasetDataSchema = new Schema({
     type: String,
     default: ''
   },
-  fullTextToken: {
-    type: String,
-    default: ''
-  },
   indexes: {
     type: [
       {
@@ -71,17 +67,11 @@ const DatasetDataSchema = new Schema({
     type: Number,
     default: 0
   },
-  inited: {
-    type: Boolean
-  },
-  rebuilding: Boolean
-});
+  rebuilding: Boolean,
 
-DatasetDataSchema.virtual('collection', {
-  ref: DatasetColCollectionName,
-  localField: 'collectionId',
-  foreignField: '_id',
-  justOne: true
+  // Abandon
+  fullTextToken: String,
+  initFullText: Boolean
 });
 
 try {
@@ -93,13 +83,15 @@ try {
     chunkIndex: 1,
     updateTime: -1
   });
-  // full text index
-  DatasetDataSchema.index({ teamId: 1, datasetId: 1, fullTextToken: 'text' });
+  // FullText tmp full text index
+  // DatasetDataSchema.index({ teamId: 1, datasetId: 1, fullTextToken: 'text' });
   // Recall vectors after data matching
   DatasetDataSchema.index({ teamId: 1, datasetId: 1, collectionId: 1, 'indexes.dataId': 1 });
   DatasetDataSchema.index({ updateTime: 1 });
   // rebuild data
   DatasetDataSchema.index({ rebuilding: 1, teamId: 1, datasetId: 1 });
+
+  DatasetDataSchema.index({ initFullText: 1 });
 } catch (error) {
   console.log(error);
 }

packages/service/core/dataset/search/controller.ts

@@ -8,8 +8,8 @@ import { getVectorsByText } from '../../ai/embedding';
 import { getVectorModel } from '../../ai/model';
 import { MongoDatasetData } from '../data/schema';
 import {
-  DatasetCollectionSchemaType,
   DatasetDataSchemaType,
+  DatasetDataTextSchemaType,
   SearchDataResponseItemType
 } from '@fastgpt/global/core/dataset/type';
 import { MongoDatasetCollection } from '../collection/schema';
@@ -23,6 +23,7 @@ import { Types } from '../../../common/mongo';
 import json5 from 'json5';
 import { MongoDatasetCollectionTags } from '../tag/schema';
 import { readFromSecondary } from '../../../common/mongo/utils';
+import { MongoDatasetDataText } from '../data/dataTextSchema';
 
 type SearchDatasetDataProps = {
   teamId: string;
@@ -266,57 +267,60 @@ export async function searchDatasetData(props: SearchDatasetDataProps) {
       filterCollectionIdList
     });
 
-    // get q and a
-    const dataList = await MongoDatasetData.find(
-      {
-        teamId,
-        datasetId: { $in: datasetIds },
-        collectionId: { $in: Array.from(new Set(results.map((item) => item.collectionId))) },
-        'indexes.dataId': { $in: results.map((item) => item.id?.trim()) }
-      },
-      'datasetId collectionId updateTime q a chunkIndex indexes'
-    )
-      .populate<{ collection: DatasetCollectionSchemaType }>(
-        'collection',
-        'name fileId rawLink externalFileId externalFileUrl'
-      )
-      .lean();
+    // Get data and collections
+    const collectionIdList = Array.from(new Set(results.map((item) => item.collectionId)));
+    const [dataList, collections] = await Promise.all([
+      MongoDatasetData.find(
+        {
+          teamId,
+          datasetId: { $in: datasetIds },
+          collectionId: { $in: collectionIdList },
+          'indexes.dataId': { $in: results.map((item) => item.id?.trim()) }
+        },
+        '_id datasetId collectionId updateTime q a chunkIndex indexes',
+        { ...readFromSecondary }
+      ).lean(),
+      MongoDatasetCollection.find(
+        {
+          _id: { $in: collectionIdList }
+        },
+        '_id name fileId rawLink externalFileId externalFileUrl',
+        { ...readFromSecondary }
+      ).lean()
+    ]);
 
-    // add score to data(It's already sorted. The first one is the one with the most points)
-    const concatResults = dataList.map((data) => {
-      const dataIdList = data.indexes.map((item) => item.dataId);
+    const formatResult = results
+      .map((item, index) => {
+        const collection = collections.find((col) => String(col._id) === String(item.collectionId));
+        if (!collection) {
+          console.log('Collection is not found', item);
+          return;
+        }
+        const data = dataList.find((data) =>
+          data.indexes.some((index) => index.dataId === item.id)
+        );
+        if (!data) {
+          console.log('Data is not found', item);
+          return;
+        }
 
-      const maxScoreResult = results.find((item) => {
-        return dataIdList.includes(item.id);
-      });
+        const score = item?.score || 0;
 
-      return {
-        ...data,
-        score: maxScoreResult?.score || 0
-      };
-    });
+        const result: SearchDataResponseItemType = {
+          id: String(data._id),
+          updateTime: data.updateTime,
+          q: data.q,
+          a: data.a,
+          chunkIndex: data.chunkIndex,
+          datasetId: String(data.datasetId),
+          collectionId: String(data.collectionId),
+          ...getCollectionSourceData(collection),
+          score: [{ type: SearchScoreTypeEnum.embedding, value: score, index }]
+        };
 
-    concatResults.sort((a, b) => b.score - a.score);
-
-    const formatResult = concatResults.map((data, index) => {
-      if (!data.collectionId) {
-        console.log('Collection is not found', data);
-      }
-
-      const result: SearchDataResponseItemType = {
-        id: String(data._id),
-        updateTime: data.updateTime,
-        q: data.q,
-        a: data.a,
-        chunkIndex: data.chunkIndex,
-        datasetId: String(data.datasetId),
-        collectionId: String(data.collectionId),
-        ...getCollectionSourceData(data.collection),
-        score: [{ type: SearchScoreTypeEnum.embedding, value: data.score, index }]
-      };
-
-      return result;
-    });
+        return result;
+      })
+      .filter(Boolean) as SearchDataResponseItemType[];
 
     return {
       embeddingRecallResults: formatResult,
@@ -344,88 +348,224 @@ export async function searchDatasetData(props: SearchDatasetDataProps) {
       };
     }
 
-    let searchResults = (
+    const searchResults = (
       await Promise.all(
         datasetIds.map(async (id) => {
-          return MongoDatasetData.aggregate([
-            {
-              $match: {
-                teamId: new Types.ObjectId(teamId),
-                datasetId: new Types.ObjectId(id),
-                $text: { $search: jiebaSplit({ text: query }) },
-                ...(filterCollectionIdList
-                  ? {
-                      collectionId: {
-                        $in: filterCollectionIdList.map((id) => new Types.ObjectId(id))
+          return MongoDatasetData.aggregate(
+            [
+              {
+                $match: {
+                  teamId: new Types.ObjectId(teamId),
+                  datasetId: new Types.ObjectId(id),
+                  $text: { $search: jiebaSplit({ text: query }) },
+                  ...(filterCollectionIdList
+                    ? {
+                        collectionId: {
+                          $in: filterCollectionIdList.map((id) => new Types.ObjectId(id))
+                        }
                       }
-                    }
-                  : {}),
-                ...(forbidCollectionIdList && forbidCollectionIdList.length > 0
-                  ? {
-                      collectionId: {
-                        $nin: forbidCollectionIdList.map((id) => new Types.ObjectId(id))
+                    : {}),
+                  ...(forbidCollectionIdList && forbidCollectionIdList.length > 0
+                    ? {
+                        collectionId: {
+                          $nin: forbidCollectionIdList.map((id) => new Types.ObjectId(id))
+                        }
                       }
-                    }
-                  : {})
+                    : {})
+                }
+              },
+              {
+                $sort: {
+                  score: { $meta: 'textScore' }
+                }
+              },
+              {
+                $limit: limit
+              },
+              {
+                $project: {
+                  _id: 1,
+                  datasetId: 1,
+                  collectionId: 1,
+                  updateTime: 1,
+                  q: 1,
+                  a: 1,
+                  chunkIndex: 1,
+                  score: { $meta: 'textScore' }
+                }
               }
-            },
+            ],
             {
-              $addFields: {
-                score: { $meta: 'textScore' }
-              }
-            },
-            {
-              $sort: {
-                score: { $meta: 'textScore' }
-              }
-            },
-            {
-              $limit: limit
-            },
-            {
-              $project: {
-                _id: 1,
-                datasetId: 1,
-                collectionId: 1,
-                updateTime: 1,
-                q: 1,
-                a: 1,
-                chunkIndex: 1,
-                score: 1
-              }
+              ...readFromSecondary
             }
-          ]);
+          );
         })
       )
     ).flat() as (DatasetDataSchemaType & { score: number })[];
 
-    // resort
-    searchResults.sort((a, b) => b.score - a.score);
-    searchResults.slice(0, limit);
-
+    // Get data and collections
     const collections = await MongoDatasetCollection.find(
       {
         _id: { $in: searchResults.map((item) => item.collectionId) }
       },
-      '_id name fileId rawLink'
-    );
+      '_id name fileId rawLink externalFileId externalFileUrl',
+      { ...readFromSecondary }
+    ).lean();
 
     return {
-      fullTextRecallResults: searchResults.map((item, index) => {
-        const collection = collections.find((col) => String(col._id) === String(item.collectionId));
-        return {
-          id: String(item._id),
-          datasetId: String(item.datasetId),
-          collectionId: String(item.collectionId),
-          updateTime: item.updateTime,
-          ...getCollectionSourceData(collection),
-          q: item.q,
-          a: item.a,
-          chunkIndex: item.chunkIndex,
-          indexes: item.indexes,
-          score: [{ type: SearchScoreTypeEnum.fullText, value: item.score, index }]
-        };
-      }),
+      fullTextRecallResults: searchResults
+        .map((data, index) => {
+          const collection = collections.find(
+            (col) => String(col._id) === String(data.collectionId)
+          );
+          if (!collection) {
+            console.log('Collection is not found', data);
+            return;
+          }
+
+          return {
+            id: String(data._id),
+            datasetId: String(data.datasetId),
+            collectionId: String(data.collectionId),
+            updateTime: data.updateTime,
+            q: data.q,
+            a: data.a,
+            chunkIndex: data.chunkIndex,
+            indexes: data.indexes,
+            ...getCollectionSourceData(collection),
+            score: [{ type: SearchScoreTypeEnum.fullText, value: data.score ?? 0, index }]
+          };
+        })
+        .filter(Boolean) as SearchDataResponseItemType[],
+      tokenLen: 0
+    };
+  };
+  const fullTextRecall2 = async ({
+    query,
+    limit,
+    filterCollectionIdList,
+    forbidCollectionIdList
+  }: {
+    query: string;
+    limit: number;
+    filterCollectionIdList?: string[];
+    forbidCollectionIdList: string[];
+  }): Promise<{
+    fullTextRecallResults: SearchDataResponseItemType[];
+    tokenLen: number;
+  }> => {
+    if (limit === 0) {
+      return {
+        fullTextRecallResults: [],
+        tokenLen: 0
+      };
+    }
+
+    const searchResults = (
+      await Promise.all(
+        datasetIds.map(async (id) => {
+          return MongoDatasetDataText.aggregate(
+            [
+              {
+                $match: {
+                  teamId: new Types.ObjectId(teamId),
+                  datasetId: new Types.ObjectId(id),
+                  $text: { $search: jiebaSplit({ text: query }) },
+                  ...(filterCollectionIdList
+                    ? {
+                        collectionId: {
+                          $in: filterCollectionIdList.map((id) => new Types.ObjectId(id))
+                        }
+                      }
+                    : {}),
+                  ...(forbidCollectionIdList && forbidCollectionIdList.length > 0
+                    ? {
+                        collectionId: {
+                          $nin: forbidCollectionIdList.map((id) => new Types.ObjectId(id))
+                        }
+                      }
+                    : {})
+                }
+              },
+              {
+                $sort: {
+                  score: { $meta: 'textScore' }
+                }
+              },
+              {
+                $limit: limit
+              },
+              {
+                $project: {
+                  _id: 1,
+                  collectionId: 1,
+                  dataId: 1,
+                  score: { $meta: 'textScore' }
+                }
+              }
+            ],
+            {
+              ...readFromSecondary
+            }
+          );
+        })
+      )
+    ).flat() as (DatasetDataTextSchemaType & { score: number })[];
+
+    // Get data and collections
+    const [dataList, collections] = await Promise.all([
+      MongoDatasetData.find(
+        {
+          _id: { $in: searchResults.map((item) => item.dataId) }
+        },
+        '_id datasetId collectionId updateTime q a chunkIndex indexes',
+        { ...readFromSecondary }
+      ).lean(),
+      MongoDatasetCollection.find(
+        {
+          _id: { $in: searchResults.map((item) => item.collectionId) }
+        },
+        '_id name fileId rawLink externalFileId externalFileUrl',
+        { ...readFromSecondary }
+      ).lean()
+    ]);
+
+    return {
+      fullTextRecallResults: searchResults
+        .map((item, index) => {
+          const collection = collections.find(
+            (col) => String(col._id) === String(item.collectionId)
+          );
+          if (!collection) {
+            console.log('Collection is not found', item);
+            return;
+          }
+          const data = dataList.find((data) => String(data._id) === String(item.dataId));
+          if (!data) {
+            console.log('Data is not found', item);
+            return;
+          }
+
+          return {
+            id: String(data._id),
+            datasetId: String(data.datasetId),
+            collectionId: String(data.collectionId),
+            updateTime: data.updateTime,
+            q: data.q,
+            a: data.a,
+            chunkIndex: data.chunkIndex,
+            indexes: data.indexes,
+            ...getCollectionSourceData(collection),
+            score: [
+              {
+                type: SearchScoreTypeEnum.fullText,
+                value: item.score || 0,
+                index
+              }
+            ]
+          };
+        })
+        .filter(Boolean) as SearchDataResponseItemType[],
       tokenLen: 0
     };
   };
@@ -496,7 +636,8 @@ export async function searchDatasetData(props: SearchDatasetDataProps) {
             forbidCollectionIdList,
             filterCollectionIdList
           }),
-          fullTextRecall({
+          // FullText tmp
+          fullTextRecall2({
             query,
             limit: fullTextLimit,
             filterCollectionIdList,

packages/service/core/workflow/dispatch/agent/runTool/toolChoice.ts

@@ -210,7 +210,7 @@ export const runToolWithToolChoice = async (
       properties[item.key] = {
         ...jsonSchema,
         description: item.toolDescription || '',
-        enum: item.enum?.split('\n').filter(Boolean) || []
+        enum: item.enum?.split('\n').filter(Boolean) || undefined
       };
     });
 
@@ -227,6 +227,7 @@ export const runToolWithToolChoice = async (
       }
     };
   });
+
   // Filter histories by maxToken
   const filterMessages = (
     await filterGPTMessageByMaxTokens({

packages/service/core/workflow/dispatch/index.ts

@@ -487,16 +487,16 @@ export async function dispatchWorkFlow(data: Props): Promise<DispatchFlowRespons
       if (input.key === dynamicInput?.key) return;
 
       // Skip some special key
-      if (input.key === NodeInputKeyEnum.childrenNodeIdList) {
+      if (
+        [NodeInputKeyEnum.childrenNodeIdList, NodeInputKeyEnum.httpJsonBody].includes(
+          input.key as any
+        )
+      ) {
         params[input.key] = input.value;
-
         return;
       }
 
-      // replace {{xx}} variables
-      // let value = replaceVariable(input.value, variables);
-
-      // replace {{$xx.xx$}} variables
+      // replace {{$xx.xx$}} and {{xx}} variables
       let value = replaceEditorVariable({
         text: input.value,
         nodes: runtimeNodes,
@@ -606,6 +606,11 @@ export async function dispatchWorkFlow(data: Props): Promise<DispatchFlowRespons
       };
     }
 
+    // Error
+    if (dispatchRes?.responseData?.error) {
+      addLog.warn('workflow error', dispatchRes.responseData.error);
+    }
+
     return {
       node,
       runStatus: 'run',

packages/service/core/workflow/dispatch/tools/http468.ts

@@ -2,6 +2,7 @@ import type { ModuleDispatchProps } from '@fastgpt/global/core/workflow/runtime/
 import {
   NodeInputKeyEnum,
   NodeOutputKeyEnum,
+  VARIABLE_NODE_ID,
   WorkflowIOValueTypeEnum
 } from '@fastgpt/global/core/workflow/constants';
 import {
@@ -16,7 +17,9 @@ import { DispatchNodeResultType } from '@fastgpt/global/core/workflow/runtime/ty
 import { getErrText } from '@fastgpt/global/common/error/utils';
 import {
   textAdaptGptResponse,
-  replaceEditorVariable
+  replaceEditorVariable,
+  formatVariableValByType,
+  getReferenceVariableValue
 } from '@fastgpt/global/core/workflow/runtime/utils';
 import { ContentTypes } from '@fastgpt/global/core/workflow/constants';
 import { uploadFileFromBase64Img } from '../../../../common/file/gridfs/controller';
@@ -97,22 +100,78 @@ export const dispatchHttp468Request = async (props: HttpRequestProps): Promise<H
   const concatVariables = {
     ...variables,
     ...body,
-    // ...dynamicInput,
     ...systemVariables
   };
-  const allVariables = {
+  const allVariables: Record<string, any> = {
     [NodeInputKeyEnum.addInputParam]: concatVariables,
     ...concatVariables
   };
+
+  // General data for variable substitution（Exclude: json body)
   const replaceStringVariables = (text: string) => {
-    return replaceVariable(
-      replaceEditorVariable({
-        text,
-        nodes: runtimeNodes,
-        variables: allVariables
-      }),
-      allVariables
-    );
+    return replaceEditorVariable({
+      text,
+      nodes: runtimeNodes,
+      variables: allVariables
+    });
+  };
+  /* Replace the JSON string to reduce parsing errors
+    1. Replace undefined values with null
+    2. Replace newline strings
+  */
+  const replaceJsonBodyString = (text: string) => {
+    const valToStr = (val: any) => {
+      if (val === undefined) return 'null';
+      if (val === null) return 'null';
+
+      if (typeof val === 'object') return JSON.stringify(val);
+
+      if (typeof val === 'string') {
+        const str = JSON.stringify(val);
+        return str.startsWith('"') && str.endsWith('"') ? str.slice(1, -1) : str;
+      }
+
+      return String(val);
+    };
+
+    // 1. Replace {{key.key}} variables
+    const regex1 = /\{\{\$([^.]+)\.([^$]+)\$\}\}/g;
+    const matches1 = [...text.matchAll(regex1)];
+    matches1.forEach((match) => {
+      const nodeId = match[1];
+      const id = match[2];
+
+      const variableVal = (() => {
+        if (nodeId === VARIABLE_NODE_ID) {
+          return variables[id];
+        }
+        // Find upstream node input/output
+        const node = runtimeNodes.find((node) => node.nodeId === nodeId);
+        if (!node) return;
+
+        const output = node.outputs.find((output) => output.id === id);
+        if (output) return formatVariableValByType(output.value, output.valueType);
+
+        const input = node.inputs.find((input) => input.key === id);
+        if (input)
+          return getReferenceVariableValue({ value: input.value, nodes: runtimeNodes, variables });
+      })();
+
+      const formatVal = valToStr(variableVal);
+
+      const regex = new RegExp(`\\{\\{\\$(${nodeId}\\.${id})\\$\\}\\}`, 'g');
+      text = text.replace(regex, () => formatVal);
+    });
+
+    // 2. Replace {{key}} variables
+    const regex2 = /{{([^}]+)}}/g;
+    const matches2 = text.match(regex2) || [];
+    const uniqueKeys2 = [...new Set(matches2.map((match) => match.slice(2, -2)))];
+    for (const key of uniqueKeys2) {
+      text = text.replace(new RegExp(`{{(${key})}}`, 'g'), () => valToStr(allVariables[key]));
+    }
+
+    return text.replace(/(".*?")\s*:\s*undefined\b/g, '$1: null');
   };
 
   httpReqUrl = replaceStringVariables(httpReqUrl);
@@ -176,18 +235,13 @@ export const dispatchHttp468Request = async (props: HttpRequestProps): Promise<H
       }
       if (!httpJsonBody) return {};
       if (httpContentType === ContentTypes.json) {
-        httpJsonBody = replaceStringVariables(httpJsonBody);
-        // Json body, parse and return
-        const jsonParse = json5.parse(
-          httpJsonBody.replace(/(".*?")\s*:\s*undefined\b/g, '$1: null')
-        );
-        const removeSignJson = removeUndefinedSign(jsonParse);
-        return removeSignJson;
+        return json5.parse(replaceJsonBodyString(httpJsonBody));
       }
+
+      // Raw text, xml
       httpJsonBody = replaceStringVariables(httpJsonBody);
       return httpJsonBody.replaceAll(UNDEFINED_SIGN, 'null');
     } catch (error) {
-      console.log(error);
       return Promise.reject(`Invalid JSON body: ${httpJsonBody}`);
     }
   })();
@@ -335,40 +389,40 @@ async function fetchData({
   };
 }
 
-function replaceVariable(text: string, obj: Record<string, any>) {
-  for (const [key, value] of Object.entries(obj)) {
-    if (value === undefined) {
-      text = text.replace(new RegExp(`{{(${key})}}`, 'g'), UNDEFINED_SIGN);
-    } else {
-      const replacement = JSON.stringify(value);
-      const unquotedReplacement =
-        replacement.startsWith('"') && replacement.endsWith('"')
-          ? replacement.slice(1, -1)
-          : replacement;
-      text = text.replace(new RegExp(`{{(${key})}}`, 'g'), () => unquotedReplacement);
-    }
-  }
-  return text || '';
-}
-function removeUndefinedSign(obj: Record<string, any>) {
-  for (const key in obj) {
-    if (obj[key] === UNDEFINED_SIGN) {
-      obj[key] = undefined;
-    } else if (Array.isArray(obj[key])) {
-      obj[key] = obj[key].map((item: any) => {
-        if (item === UNDEFINED_SIGN) {
-          return undefined;
-        } else if (typeof item === 'object') {
-          removeUndefinedSign(item);
-        }
-        return item;
-      });
-    } else if (typeof obj[key] === 'object') {
-      removeUndefinedSign(obj[key]);
-    }
-  }
-  return obj;
-}
+// function replaceVariable(text: string, obj: Record<string, any>) {
+//   for (const [key, value] of Object.entries(obj)) {
+//     if (value === undefined) {
+//       text = text.replace(new RegExp(`{{(${key})}}`, 'g'), UNDEFINED_SIGN);
+//     } else {
+//       const replacement = JSON.stringify(value);
+//       const unquotedReplacement =
+//         replacement.startsWith('"') && replacement.endsWith('"')
+//           ? replacement.slice(1, -1)
+//           : replacement;
+//       text = text.replace(new RegExp(`{{(${key})}}`, 'g'), () => unquotedReplacement);
+//     }
+//   }
+//   return text || '';
+// }
+// function removeUndefinedSign(obj: Record<string, any>) {
+//   for (const key in obj) {
+//     if (obj[key] === UNDEFINED_SIGN) {
+//       obj[key] = undefined;
+//     } else if (Array.isArray(obj[key])) {
+//       obj[key] = obj[key].map((item: any) => {
+//         if (item === UNDEFINED_SIGN) {
+//           return undefined;
+//         } else if (typeof item === 'object') {
+//           removeUndefinedSign(item);
+//         }
+//         return item;
+//       });
+//     } else if (typeof obj[key] === 'object') {
+//       removeUndefinedSign(obj[key]);
+//     }
+//   }
+//   return obj;
+// }
 
 // Replace some special response from system plugin
 async function replaceSystemPluginResponse({

packages/service/support/outLink/schema.ts

@@ -92,6 +92,7 @@ OutLinkSchema.virtual('associatedApp', {
 
 try {
   OutLinkSchema.index({ shareId: -1 });
+  OutLinkSchema.index({ teamId: 1, tmbId: 1, appId: 1 });
 } catch (error) {
   console.log(error);
 }

packages/service/support/permission/auth/org.ts

@@ -0,0 +1,43 @@
+import { TeamPermission } from '@fastgpt/global/support/permission/user/controller';
+import { AuthModeType, AuthResponseType } from '../type';
+import { TeamErrEnum } from '@fastgpt/global/common/error/code/team';
+import { authUserPer } from '../user/auth';
+import { ManagePermissionVal } from '@fastgpt/global/support/permission/constant';
+
+/* 
+  Team manager can control org
+*/
+export const authOrgMember = async ({
+  orgIds,
+  ...props
+}: {
+  orgIds: string | string[];
+} & AuthModeType): Promise<AuthResponseType> => {
+  const result = await authUserPer({
+    ...props,
+    per: ManagePermissionVal
+  });
+  const { teamId, tmbId, isRoot, tmb } = result;
+
+  if (isRoot) {
+    return {
+      teamId,
+      tmbId,
+      userId: result.userId,
+      appId: result.appId,
+      apikey: result.apikey,
+      isRoot,
+      authType: result.authType,
+      permission: new TeamPermission({ isOwner: true })
+    };
+  }
+
+  if (tmb.permission.hasManagePer) {
+    return {
+      ...result,
+      permission: tmb.permission
+    };
+  }
+
+  return Promise.reject(TeamErrEnum.unAuthTeam);
+};

packages/service/support/permission/auth/team.ts

@@ -1,8 +1,8 @@
 import { MongoTeamMember } from '../../user/team/teamMemberSchema';
 import { checkTeamAIPoints } from '../teamLimit';
-import { UserErrEnum } from '@fastgpt/global/common/error/code/user';
 import { UserModelSchema } from '@fastgpt/global/support/user/type';
 import { TeamSchema } from '@fastgpt/global/support/user/team/type';
+import { TeamErrEnum } from '@fastgpt/global/common/error/code/team';
 
 export async function getUserChatInfoAndAuthTeamPoints(tmbId: string) {
   const tmb = await MongoTeamMember.findById(tmbId, 'userId teamId')
@@ -18,7 +18,7 @@ export async function getUserChatInfoAndAuthTeamPoints(tmbId: string) {
     ])
     .lean();
 
-  if (!tmb) return Promise.reject(UserErrEnum.unAuthUser);
+  if (!tmb) return Promise.reject(TeamErrEnum.notUser);
 
   await checkTeamAIPoints(tmb.team._id);
 

packages/service/support/permission/controller.ts

@@ -8,10 +8,7 @@ import { authOpenApiKey } from '../openapi/auth';
 import { FileTokenQuery } from '@fastgpt/global/common/file/type';
 import { MongoResourcePermission } from './schema';
 import { ClientSession } from 'mongoose';
-import {
-  PermissionValueType,
-  ResourcePermissionType
-} from '@fastgpt/global/support/permission/type';
+import { PermissionValueType } from '@fastgpt/global/support/permission/type';
 import { bucketNameMap } from '@fastgpt/global/common/file/constants';
 import { addMinutes } from 'date-fns';
 import { getGroupsByTmbId } from './memberGroup/controllers';
@@ -21,6 +18,8 @@ import { CommonErrEnum } from '@fastgpt/global/common/error/code/common';
 import { MemberGroupSchemaType } from '@fastgpt/global/support/permission/memberGroup/type';
 import { TeamMemberSchema } from '@fastgpt/global/support/user/team/type';
 import { UserModelSchema } from '@fastgpt/global/support/user/type';
+import { OrgSchemaType } from '@fastgpt/global/support/user/team/org/type';
+import { getOrgIdSetWithParentByTmbId } from './org/controllers';
 
 /** get resource permission for a team member
  * If there is no permission for the team member, it will return undefined
@@ -67,67 +66,44 @@ export const getResourcePermission = async ({
   }
 
   // If there is no personal permission, get the group permission
-  const groupIdList = (await getGroupsByTmbId({ tmbId, teamId })).map((item) => item._id);
+  const [groupPers, orgPers] = await Promise.all([
+    getGroupsByTmbId({ tmbId, teamId })
+      .then((res) => res.map((item) => item._id))
+      .then((groupIdList) =>
+        MongoResourcePermission.find(
+          {
+            teamId,
+            resourceType,
+            groupId: {
+              $in: groupIdList
+            },
+            resourceId
+          },
+          'permission'
+        ).lean()
+      )
+      .then((perList) => perList.map((item) => item.permission)),
+    getOrgIdSetWithParentByTmbId({ tmbId, teamId })
+      .then((item) => Array.from(item))
+      .then((orgIds) =>
+        MongoResourcePermission.find(
+          {
+            teamId,
+            resourceType,
+            orgId: {
+              $in: Array.from(orgIds)
+            },
+            resourceId
+          },
+          'permission'
+        ).lean()
+      )
+      .then((perList) => perList.map((item) => item.permission))
+  ]);
 
-  if (groupIdList.length === 0) {
-    return undefined;
-  }
-
-  // get the maximum permission of the group
-  const pers = (
-    await MongoResourcePermission.find(
-      {
-        teamId,
-        resourceType,
-        groupId: {
-          $in: groupIdList
-        },
-        resourceId
-      },
-      'permission'
-    ).lean()
-  ).map((item) => item.permission);
-
-  const groupPer = getGroupPer(pers);
-
-  return groupPer;
+  return concatPer([...groupPers, ...orgPers]);
 };
 
-/* 仅取 members 不取 groups */
-export async function getResourceAllClbs({
-  resourceId,
-  teamId,
-  resourceType,
-  session
-}: {
-  teamId: string;
-  session?: ClientSession;
-} & (
-  | {
-      resourceType: 'team';
-      resourceId?: undefined;
-    }
-  | {
-      resourceType: Omit<PerResourceTypeEnum, 'team'>;
-      resourceId?: string | null;
-    }
-)): Promise<ResourcePermissionType[]> {
-  return MongoResourcePermission.find(
-    {
-      resourceType: resourceType,
-      teamId: teamId,
-      resourceId,
-      groupId: {
-        $exists: false
-      }
-    },
-    null,
-    {
-      session
-    }
-  ).lean();
-}
-
 export async function getResourceClbsAndGroups({
   resourceId,
   resourceType,
@@ -155,10 +131,17 @@ export const getClbsAndGroupsWithInfo = async ({
   resourceType,
   teamId
 }: {
-  resourceId: ParentIdType;
-  resourceType: Omit<`${PerResourceTypeEnum}`, 'team'>;
   teamId: string;
-}) =>
+} & (
+  | {
+      resourceId: ParentIdType;
+      resourceType: Omit<`${PerResourceTypeEnum}`, 'team'>;
+    }
+  | {
+      resourceType: 'team';
+      resourceId?: undefined;
+    }
+)) =>
   Promise.all([
     MongoResourcePermission.find({
       teamId,
@@ -170,7 +153,7 @@ export const getClbsAndGroupsWithInfo = async ({
     })
       .populate<{ tmb: TeamMemberSchema & { user: UserModelSchema } }>({
         path: 'tmb',
-        select: 'name userId',
+        select: 'name userId role',
         populate: {
           path: 'user',
           select: 'avatar'
@@ -186,6 +169,16 @@ export const getClbsAndGroupsWithInfo = async ({
       }
     })
       .populate<{ group: MemberGroupSchemaType }>('group', 'name avatar')
+      .lean(),
+    MongoResourcePermission.find({
+      teamId,
+      resourceId,
+      resourceType,
+      orgId: {
+        $exists: true
+      }
+    })
+      .populate<{ org: OrgSchemaType }>({ path: 'org', select: 'name avatar' })
       .lean()
   ]);
 
@@ -196,6 +189,7 @@ export const delResourcePermission = ({
   session,
   tmbId,
   groupId,
+  orgId,
   ...props
 }: {
   resourceType: PerResourceTypeEnum;
@@ -204,15 +198,18 @@ export const delResourcePermission = ({
   session?: ClientSession;
   tmbId?: string;
   groupId?: string;
+  orgId?: string;
 }) => {
-  // tmbId or groupId only one and not both
-  if (!!tmbId === !!groupId) {
+  // either tmbId or groupId or orgId must be provided
+  if (!tmbId && !groupId && !orgId) {
     return Promise.reject(CommonErrEnum.missingParams);
   }
+
   return MongoResourcePermission.deleteOne(
     {
       ...(tmbId ? { tmbId } : {}),
       ...(groupId ? { groupId } : {}),
+      ...(orgId ? { orgId } : {}),
       ...props
     },
     { session }
@@ -250,7 +247,7 @@ export function authJWT(token: string) {
   }>((resolve, reject) => {
     const key = process.env.TOKEN_KEY as string;
 
-    jwt.verify(token, key, function (err, decoded: any) {
+    jwt.verify(token, key, (err, decoded: any) => {
       if (err || !decoded?.userId) {
         reject(ERROR_ENUM.unAuthorization);
         return;
@@ -436,7 +433,7 @@ export const authFileToken = (token?: string) =>
     }
     const key = (process.env.FILE_TOKEN_KEY as string) ?? 'filetoken';
 
-    jwt.verify(token, key, function (err, decoded: any) {
+    jwt.verify(token, key, (err, decoded: any) => {
       if (err || !decoded.bucketName || !decoded?.teamId || !decoded?.fileId) {
         reject(ERROR_ENUM.unAuthFile);
         return;
@@ -450,10 +447,10 @@ export const authFileToken = (token?: string) =>
     });
   });
 
-export const getGroupPer = (groups: PermissionValueType[] = []) => {
-  if (groups.length === 0) {
+export const concatPer = (perList: PermissionValueType[] = []) => {
+  if (perList.length === 0) {
     return undefined;
   }
 
-  return new Permission().addPer(...groups).value;
+  return new Permission().addPer(...perList).value;
 };

packages/service/support/permission/inheritPermission.ts

@@ -1,11 +1,11 @@
 import { mongoSessionRun } from '../../common/mongo/sessionRun';
 import { MongoResourcePermission } from './schema';
-import { ClientSession, Model } from 'mongoose';
-import { PerResourceTypeEnum } from '@fastgpt/global/support/permission/constant';
-import { PermissionValueType } from '@fastgpt/global/support/permission/type';
+import type { ClientSession, Model } from 'mongoose';
+import type { PerResourceTypeEnum } from '@fastgpt/global/support/permission/constant';
+import type { PermissionValueType } from '@fastgpt/global/support/permission/type';
 import { getResourceClbsAndGroups } from './controller';
-import { RequireOnlyOne } from '@fastgpt/global/common/type/utils';
-import { ParentIdType } from '@fastgpt/global/common/parentFolder/type';
+import type { RequireOnlyOne } from '@fastgpt/global/common/type/utils';
+import type { ParentIdType } from '@fastgpt/global/common/parentFolder/type';
 
 export type SyncChildrenPermissionResourceType = {
   _id: string;
@@ -18,6 +18,7 @@ export type UpdateCollaboratorItem = {
 } & RequireOnlyOne<{
   tmbId: string;
   groupId: string;
+  orgId: string;
 }>;
 
 // sync the permission to all children folders.
@@ -161,7 +162,7 @@ export async function resumeInheritPermission({
   }
 }
 
-/* 
+/*
   Delete all the collaborators and then insert the new collaborators.
 */
 export async function syncCollaborators({

packages/service/support/permission/memberGroup/controllers.ts

@@ -1,9 +1,6 @@
 import { MemberGroupSchemaType } from '@fastgpt/global/support/permission/memberGroup/type';
 import { MongoGroupMemberModel } from './groupMemberSchema';
-import { TeamMemberSchema } from '@fastgpt/global/support/user/team/type';
-import { PerResourceTypeEnum } from '@fastgpt/global/support/permission/constant';
-import { MongoResourcePermission } from '../schema';
-import { getGroupPer, parseHeaderCert } from '../controller';
+import { parseHeaderCert } from '../controller';
 import { MongoMemberGroupModel } from './memberGroupSchema';
 import { DefaultGroupName } from '@fastgpt/global/support/user/team/group/constant';
 import { ClientSession } from 'mongoose';
@@ -50,26 +47,32 @@ export const getTeamDefaultGroup = async ({
 export const getGroupsByTmbId = async ({
   tmbId,
   teamId,
-  role
+  role,
+  session
 }: {
   tmbId: string;
   teamId: string;
   role?: `${GroupMemberRole}`[];
+  session?: ClientSession;
 }) =>
   (
     await Promise.all([
       (
-        await MongoGroupMemberModel.find({
-          tmbId,
-          groupId: {
-            $exists: true
+        await MongoGroupMemberModel.find(
+          {
+            tmbId,
+            groupId: {
+              $exists: true
+            },
+            ...(role ? { role: { $in: role } } : {})
           },
-          ...(role ? { role: { $in: role } } : {})
-        })
+          undefined,
+          { session }
+        )
           .populate<{ group: MemberGroupSchemaType }>('group')
           .lean()
       ).map((item) => item.group),
-      role ? [] : getTeamDefaultGroup({ teamId })
+      role ? [] : getTeamDefaultGroup({ teamId, session })
     ])
   ).flat();
 
@@ -79,46 +82,6 @@ export const getGroupMembersByGroupId = async (groupId: string) => {
   }).lean();
 };
 
-/**
- * Get tmb's group permission: the maximum permission of the group
- * @param tmbId
- * @param resourceId
- * @param resourceType
- * @returns the maximum permission of the group
- */
-export const getGroupPermission = async ({
-  tmbId,
-  resourceId,
-  teamId,
-  resourceType
-}: {
-  tmbId: string;
-  teamId: string;
-} & (
-  | {
-      resourceId?: undefined;
-      resourceType: 'team';
-    }
-  | {
-      resourceId: string;
-      resourceType: Omit<PerResourceTypeEnum, 'team'>;
-    }
-)) => {
-  const groupIds = (await getGroupsByTmbId({ tmbId, teamId })).map((item) => item._id);
-  const groupPermissions = (
-    await MongoResourcePermission.find({
-      groupId: {
-        $in: groupIds
-      },
-      resourceType,
-      resourceId,
-      teamId
-    })
-  ).map((item) => item.permission);
-
-  return getGroupPer(groupPermissions);
-};
-
 // auth group member role
 export const authGroupMemberRole = async ({
   groupId,
@@ -140,8 +103,12 @@ export const authGroupMemberRole = async ({
       tmbId
     };
   }
-  const groupMember = await MongoGroupMemberModel.findOne({ groupId, tmbId });
-  const tmb = await getTmbInfoByTmbId({ tmbId });
+  const [groupMember, tmb] = await Promise.all([
+    MongoGroupMemberModel.findOne({ groupId, tmbId }),
+    getTmbInfoByTmbId({ tmbId })
+  ]);
+
+  // Team admin or role check
   if (tmb.permission.hasManagePer || (groupMember && role.includes(groupMember.role))) {
     return {
       ...result,

packages/service/support/permission/org/controllers.ts

@@ -0,0 +1,95 @@
+import { TeamErrEnum } from '@fastgpt/global/common/error/code/team';
+import type { OrgSchemaType } from '@fastgpt/global/support/user/team/org/type';
+import type { ClientSession } from 'mongoose';
+import { MongoOrgModel } from './orgSchema';
+import { MongoOrgMemberModel } from './orgMemberSchema';
+import { getOrgChildrenPath } from '@fastgpt/global/support/user/team/org/constant';
+
+export const getOrgsByTmbId = async ({ teamId, tmbId }: { teamId: string; tmbId: string }) =>
+  MongoOrgMemberModel.find({ teamId, tmbId }, 'orgId').lean();
+
+export const getOrgIdSetWithParentByTmbId = async ({
+  teamId,
+  tmbId
+}: {
+  teamId: string;
+  tmbId: string;
+}) => {
+  const orgMembers = await MongoOrgMemberModel.find({ teamId, tmbId }, 'orgId').lean();
+
+  const orgIds = Array.from(new Set(orgMembers.map((item) => String(item.orgId))));
+  const orgs = await MongoOrgModel.find({ _id: { $in: orgIds } }, 'path').lean();
+
+  const pathIdList = new Set<string>(
+    orgs
+      .map((org) => {
+        const pathIdList = org.path.split('/').filter(Boolean);
+        return pathIdList;
+      })
+      .flat()
+  );
+  const parentOrgs = await MongoOrgModel.find(
+    {
+      teamId,
+      pathId: { $in: Array.from(pathIdList) }
+    },
+    '_id'
+  ).lean();
+  const parentOrgIds = parentOrgs.map((item) => String(item._id));
+
+  return new Set([...orgIds, ...parentOrgIds]);
+};
+
+export const getChildrenByOrg = async ({
+  org,
+  teamId,
+  session
+}: {
+  org: OrgSchemaType;
+  teamId: string;
+  session?: ClientSession;
+}) => {
+  return MongoOrgModel.find(
+    { teamId, path: { $regex: `^${getOrgChildrenPath(org)}` } },
+    undefined,
+    {
+      session
+    }
+  ).lean();
+};
+
+export const getOrgAndChildren = async ({
+  orgId,
+  teamId,
+  session
+}: {
+  orgId: string;
+  teamId: string;
+  session?: ClientSession;
+}) => {
+  const org = await MongoOrgModel.findOne({ _id: orgId, teamId }, undefined, { session }).lean();
+  if (!org) {
+    return Promise.reject(TeamErrEnum.orgNotExist);
+  }
+  const children = await getChildrenByOrg({ org, teamId, session });
+  return { org, children };
+};
+
+export async function createRootOrg({
+  teamId,
+  session
+}: {
+  teamId: string;
+  session?: ClientSession;
+}) {
+  return MongoOrgModel.create(
+    [
+      {
+        teamId,
+        name: 'ROOT',
+        path: ''
+      }
+    ],
+    { session }
+  );
+}

packages/service/support/permission/org/orgMemberSchema.ts

@@ -0,0 +1,65 @@
+import { OrgCollectionName } from '@fastgpt/global/support/user/team/org/constant';
+import { connectionMongo, getMongoModel } from '../../../common/mongo';
+import {
+  TeamCollectionName,
+  TeamMemberCollectionName
+} from '@fastgpt/global/support/user/team/constant';
+import { OrgMemberSchemaType } from '@fastgpt/global/support/user/team/org/type';
+const { Schema } = connectionMongo;
+
+export const OrgMemberCollectionName = 'team_org_members';
+
+export const OrgMemberSchema = new Schema({
+  teamId: {
+    type: Schema.Types.ObjectId,
+    ref: TeamCollectionName,
+    required: true
+  },
+  orgId: {
+    type: Schema.Types.ObjectId,
+    ref: OrgCollectionName,
+    required: true
+  },
+  tmbId: {
+    type: Schema.Types.ObjectId,
+    ref: TeamMemberCollectionName,
+    required: true
+  }
+  // role: {
+  //   type: String,
+  //   enum: Object.values(OrgMemberRole),
+  //   required: true,
+  //   default: OrgMemberRole.member
+  // }
+});
+
+OrgMemberSchema.virtual('org', {
+  ref: OrgCollectionName,
+  localField: 'orgId',
+  foreignField: '_id',
+  justOne: true
+});
+
+try {
+  OrgMemberSchema.index(
+    {
+      teamId: 1,
+      orgId: 1,
+      tmbId: 1
+    },
+    {
+      unique: true
+    }
+  );
+  OrgMemberSchema.index({
+    teamId: 1,
+    tmbId: 1
+  });
+} catch (error) {
+  console.log(error);
+}
+
+export const MongoOrgMemberModel = getMongoModel<OrgMemberSchemaType>(
+  OrgMemberCollectionName,
+  OrgMemberSchema
+);

packages/service/support/permission/org/orgSchema.ts

@@ -0,0 +1,77 @@
+import { TeamCollectionName } from '@fastgpt/global/support/user/team/constant';
+import { OrgCollectionName } from '@fastgpt/global/support/user/team/org/constant';
+import type { OrgSchemaType } from '@fastgpt/global/support/user/team/org/type';
+import { connectionMongo, getMongoModel } from '../../../common/mongo';
+import { OrgMemberCollectionName } from './orgMemberSchema';
+import { getNanoid } from '@fastgpt/global/common/string/tools';
+const { Schema } = connectionMongo;
+
+export const OrgSchema = new Schema(
+  {
+    teamId: {
+      type: Schema.Types.ObjectId,
+      ref: TeamCollectionName,
+      required: true
+    },
+    pathId: {
+      // path id, only used for path
+      type: String,
+      required: true,
+      default: () => getNanoid()
+    },
+    path: {
+      type: String,
+      required: function (this: OrgSchemaType) {
+        return typeof this.path !== 'string';
+      } // allow empty string, but not null
+    },
+    name: {
+      type: String,
+      required: true
+    },
+    avatar: String,
+    description: String,
+    updateTime: {
+      type: Date,
+      default: () => new Date()
+    }
+  },
+  {
+    // Auto update updateTime
+    timestamps: {
+      updatedAt: 'updateTime'
+    }
+  }
+);
+
+OrgSchema.virtual('members', {
+  ref: OrgMemberCollectionName,
+  localField: '_id',
+  foreignField: 'orgId'
+});
+// OrgSchema.virtual('permission', {
+//   ref: ResourcePermissionCollectionName,
+//   localField: '_id',
+//   foreignField: 'orgId',
+//   justOne: true
+// });
+
+try {
+  OrgSchema.index({
+    teamId: 1,
+    path: 1
+  });
+  OrgSchema.index(
+    {
+      teamId: 1,
+      pathId: 1
+    },
+    {
+      unique: true
+    }
+  );
+} catch (error) {
+  console.log(error);
+}
+
+export const MongoOrgModel = getMongoModel<OrgSchemaType>(OrgCollectionName, OrgSchema);

packages/service/support/permission/schema.ts

@@ -6,6 +6,7 @@ import { connectionMongo, getMongoModel } from '../../common/mongo';
 import type { ResourcePermissionType } from '@fastgpt/global/support/permission/type';
 import { PerResourceTypeEnum } from '@fastgpt/global/support/permission/constant';
 import { MemberGroupCollectionName } from './memberGroup/memberGroupSchema';
+import { OrgCollectionName } from '@fastgpt/global/support/user/team/org/constant';
 const { Schema } = connectionMongo;
 
 export const ResourcePermissionCollectionName = 'resource_permissions';
@@ -23,6 +24,10 @@ export const ResourcePermissionSchema = new Schema({
     type: Schema.Types.ObjectId,
     ref: MemberGroupCollectionName
   },
+  orgId: {
+    type: Schema.Types.ObjectId,
+    ref: OrgCollectionName
+  },
   resourceType: {
     type: String,
     enum: Object.values(PerResourceTypeEnum),
@@ -51,6 +56,12 @@ ResourcePermissionSchema.virtual('group', {
   foreignField: '_id',
   justOne: true
 });
+ResourcePermissionSchema.virtual('org', {
+  ref: OrgCollectionName,
+  localField: 'orgId',
+  foreignField: '_id',
+  justOne: true
+});
 
 try {
   ResourcePermissionSchema.index(
@@ -70,6 +81,23 @@ try {
     }
   );
 
+  ResourcePermissionSchema.index(
+    {
+      resourceType: 1,
+      teamId: 1,
+      resourceId: 1,
+      orgId: 1
+    },
+    {
+      unique: true,
+      partialFilterExpression: {
+        orgId: {
+          $exists: true
+        }
+      }
+    }
+  );
+
   ResourcePermissionSchema.index(
     {
       resourceType: 1,
@@ -87,6 +115,7 @@ try {
     }
   );
 
+  // Delete tmb permission
   ResourcePermissionSchema.index({
     resourceType: 1,
     teamId: 1,

packages/service/support/permission/teamLimit.ts

@@ -19,9 +19,7 @@ export const checkDatasetLimit = async ({
   if (!standardConstants) return;
 
   if (usedDatasetSize + insertLen >= datasetMaxSize) {
-    return Promise.reject(
-      `您的知识库容量为: ${datasetMaxSize}组，已使用: ${usedDatasetSize}组，导入当前文件需要: ${insertLen}组，请增加知识库容量后导入。`
-    );
+    return Promise.reject(TeamErrEnum.datasetSizeNotEnough);
   }
 
   if (usedPoints >= totalPoints) {

packages/service/support/user/schema.ts

@@ -3,22 +3,10 @@ const { Schema } = connectionMongo;
 import { hashStr } from '@fastgpt/global/common/string/tools';
 import type { UserModelSchema } from '@fastgpt/global/support/user/type';
 import { UserStatusEnum, userStatusMap } from '@fastgpt/global/support/user/constant';
+import { getRandomUserAvatar } from '@fastgpt/global/support/user/utils';
 
 export const userCollectionName = 'users';
 
-const defaultAvatars = [
-  '/imgs/avatar/RoyalBlueAvatar.svg',
-  '/imgs/avatar/PurpleAvatar.svg',
-  '/imgs/avatar/AdoraAvatar.svg',
-  '/imgs/avatar/OrangeAvatar.svg',
-  '/imgs/avatar/RedAvatar.svg',
-  '/imgs/avatar/GrayModernAvatar.svg',
-  '/imgs/avatar/TealAvatar.svg',
-  '/imgs/avatar/GreenAvatar.svg',
-  '/imgs/avatar/BrightBlueAvatar.svg',
-  '/imgs/avatar/BlueAvatar.svg'
-];
-
 const UserSchema = new Schema({
   status: {
     type: String,
@@ -47,7 +35,7 @@ const UserSchema = new Schema({
   },
   avatar: {
     type: String,
-    default: defaultAvatars[Math.floor(Math.random() * defaultAvatars.length)]
+    default: () => getRandomUserAvatar()
   },
 
   promotionRate: {
@@ -78,11 +66,8 @@ const UserSchema = new Schema({
 });
 
 try {
-  // login
-  UserSchema.index({ username: 1, password: 1 }, { background: true });
-
   // Admin charts
-  UserSchema.index({ createTime: -1 }, { background: true });
+  UserSchema.index({ createTime: -1 });
 } catch (error) {
   console.log(error);
 }

packages/service/support/user/team/controller.ts

@@ -16,6 +16,8 @@ import { MongoMemberGroupModel } from '../../permission/memberGroup/memberGroupS
 import { mongoSessionRun } from '../../../common/mongo/sessionRun';
 import { DefaultGroupName } from '@fastgpt/global/support/user/team/group/constant';
 import { getAIApi, openaiBaseUrl } from '../../../core/ai/config';
+import { createRootOrg } from '../../permission/org/controllers';
+import { refreshSourceAvatar } from '../../../common/file/image/controller';
 
 async function getTeamMember(match: Record<string, any>): Promise<TeamTmbItemType> {
   const tmb = await MongoTeamMember.findOne(match).populate<{ team: TeamSchema }>('team').lean();
@@ -32,6 +34,7 @@ async function getTeamMember(match: Record<string, any>): Promise<TeamTmbItemTyp
   return {
     userId: String(tmb.userId),
     teamId: String(tmb.teamId),
+    teamAvatar: tmb.team.avatar,
     teamName: tmb.team.name,
     memberName: tmb.name,
     avatar: tmb.team.avatar,
@@ -77,13 +80,11 @@ export async function createDefaultTeam({
   userId,
   teamName = 'My Team',
   avatar = '/icon/logo.svg',
-  balance,
   session
 }: {
   userId: string;
   teamName?: string;
   avatar?: string;
-  balance?: number;
   session: ClientSession;
 }) {
   // auth default team
@@ -100,7 +101,6 @@ export async function createDefaultTeam({
           ownerId: userId,
           name: teamName,
           avatar,
-          balance,
           createTime: new Date()
         }
       ],
@@ -132,15 +132,11 @@ export async function createDefaultTeam({
       ],
       { session }
     );
-    console.log('create default team and group', userId);
+    await createRootOrg({ teamId: tmb.teamId, session });
+    console.log('create default team, group and root org', userId);
     return tmb;
   } else {
     console.log('default team exist', userId);
-    await MongoTeam.findByIdAndUpdate(tmb.teamId, {
-      $set: {
-        ...(balance !== undefined && { balance })
-      }
-    });
   }
 }
 
@@ -215,7 +211,8 @@ export async function updateTeam({
       return obj;
     })();
 
-    await MongoTeam.findByIdAndUpdate(
+    // This is where we get the old team
+    const team = await MongoTeam.findByIdAndUpdate(
       teamId,
       {
         $set: {
@@ -241,6 +238,8 @@ export async function updateTeam({
         },
         { session }
       );
+
+      await refreshSourceAvatar(avatar, team?.avatar, session);
     }
   });
 }

packages/service/support/user/team/teamMemberSchema.ts

@@ -23,10 +23,6 @@ const TeamMemberSchema = new Schema({
     type: String,
     default: 'Member'
   },
-  role: {
-    type: String
-    // enum: Object.keys(TeamMemberRoleMap) // disable enum validation for old data
-  },
   status: {
     type: String,
     enum: Object.keys(TeamMemberStatusMap)
@@ -38,6 +34,12 @@ const TeamMemberSchema = new Schema({
   defaultTeam: {
     type: Boolean,
     default: false
+  },
+
+  // Abandoned
+  role: {
+    type: String
+    // enum: Object.keys(TeamMemberRoleMap) // disable enum validation for old data
   }
 });
 

packages/service/support/user/team/teamSchema.ts

@@ -21,10 +21,7 @@ const TeamSchema = new Schema({
     type: Date,
     default: () => Date.now()
   },
-  balance: {
-    type: Number,
-    default: 0
-  },
+  balance: Number,
   teamDomain: {
     type: String
   },

packages/service/support/wallet/usage/schema.ts

@@ -61,11 +61,11 @@ const UsageSchema = new Schema({
 });
 
 try {
-  UsageSchema.index({ teamId: 1, tmbId: 1, source: 1, time: -1 }, { background: true });
+  UsageSchema.index({ teamId: 1, tmbId: 1, source: 1, time: -1 });
   // timer task. clear dead team
-  // UsageSchema.index({ teamId: 1, time: -1 }, { background: true });
+  // UsageSchema.index({ teamId: 1, time: -1 });
 
-  UsageSchema.index({ time: 1 }, { background: true, expireAfterSeconds: 360 * 24 * 60 * 60 });
+  UsageSchema.index({ time: 1 }, { expireAfterSeconds: 360 * 24 * 60 * 60 });
 } catch (error) {
   console.log(error);
 }