fix: milvus sdk (#3249)

* fix: base64 image

* perf: quote qa

.github/ISSUE_TEMPLATE/bugs.md

@@ -21,7 +21,7 @@ assignees: ''
 - [ ] 公有云版本
 - [ ] 私有部署版本, 具体版本号: 
 
-**问题描述, 日志截图**
+**问题描述, 日志截图，配置文件等**
 
 **复现步骤**
 

.vscode/settings.json

@@ -16,8 +16,8 @@
     "i18n-ally.keystyle": "flat",
     "i18n-ally.sortKeys": true,
     "i18n-ally.keepFulfilled": false,
-    "i18n-ally.sourceLanguage": "zh", // 根据此语言文件翻译其他语言文件的变量和内容
+    "i18n-ally.sourceLanguage": "zh-CN", // 根据此语言文件翻译其他语言文件的变量和内容
-    "i18n-ally.displayLanguage": "zh", // 显示语言
+    "i18n-ally.displayLanguage": "zh-CN", // 显示语言
     "i18n-ally.namespace": true,
     "i18n-ally.pathMatcher": "{locale}/{namespaces}.json",
     "i18n-ally.extract.targetPickingStrategy": "most-similar-by-key",

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

@@ -23,6 +23,7 @@ weight: 708
   "systemEnv": {
     "vectorMaxProcess": 15,
     "qaMaxProcess": 15,
+    "tokenWorkers": 50, // Token 计算线程保持数，会持续占用内存，不能设置太大。
     "pgHNSWEfSearch": 100 // 向量搜索参数。越大，搜索越精确，但是速度越慢。设置为100，有99%+精度。
   },
   "llmModels": [

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

@@ -35,9 +35,7 @@ weight: 707
 
 ### Milvus版本
 
-暂不推荐，部分系统存在精度丢失，等待修复。
+生产部署首选，对于千万级以上向量性能更优秀。
-
-对于千万级以上向量性能更优秀。
 
 [点击查看 Milvus 官方推荐配置](https://milvus.io/docs/prerequisite-docker.md)
 
@@ -51,9 +49,7 @@ weight: 707
 
 ### zilliz cloud版本
 
-暂不推荐，部分系统存在精度丢失，等待修复。
+Milvus 的全托管服务，性能优于 Milvus 并提供 SLA，点击使用 [Zilliz Cloud](https://zilliz.com.cn/)。
-
-亿级以上向量首选。
 
 由于向量库使用了 Cloud，无需占用本地资源，无需太关注。
 
@@ -138,14 +134,16 @@ curl -o docker-compose.yml https://raw.githubusercontent.com/labring/FastGPT/mai
 # curl -o docker-compose.yml https://raw.githubusercontent.com/labring/FastGPT/main/files/docker/docker-compose-zilliz.yml
 ```
 
-### 2. 修改 docker-compose.yml 环境变量
+### 2. 修改环境变量
+
+找到 yml 文件中，fastgpt 容器的环境变量进行下面操作：
 
 {{< tabs tabTotal="3" >}}
 {{< tab tabName="PgVector版本" >}}
 {{< markdownify >}}
 
 ```
-无需操作
+FE_DOMAIN=你的前端你访问地址,例如 http://192.168.0.1:3000;https://cloud.fastgpt.cn
 ```
 
 {{< /markdownify >}}
@@ -154,7 +152,7 @@ curl -o docker-compose.yml https://raw.githubusercontent.com/labring/FastGPT/mai
 {{< markdownify >}}
 
 ```
-无需操作
+FE_DOMAIN=你的前端你访问地址,例如 http://192.168.0.1:3000;https://cloud.fastgpt.cn
 ```
 
 {{< /markdownify >}}
@@ -162,11 +160,14 @@ curl -o docker-compose.yml https://raw.githubusercontent.com/labring/FastGPT/mai
 {{< tab tabName="Zilliz版本" >}}
 {{< markdownify >}}
 
+打开 [Zilliz Cloud](https://zilliz.com.cn/), 创建实例并获取相关秘钥。
+
 ![zilliz_key](/imgs/zilliz_key.png)
 
 {{% alert icon="🤖" context="success" %}}
 
-修改`MILVUS_ADDRESS`和`MILVUS_TOKEN`链接参数，分别对应 `zilliz` 的 `Public Endpoint` 和 `Api key`，记得把自己ip加入白名单。
+1. 修改`MILVUS_ADDRESS`和`MILVUS_TOKEN`链接参数，分别对应 `zilliz` 的 `Public Endpoint` 和 `Api key`，记得把自己ip加入白名单。
+2. 修改FE_DOMAIN=你的前端你访问地址,例如 http://192.168.0.1:3000;https://cloud.fastgpt.cn
 
 {{% /alert %}}
 

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

@@ -25,7 +25,7 @@ FastGPT 的 API Key **有 2 类**，一类是全局通用的 key (无法直接
 
 |        通用key               |           应用特定 key            |
 | --------------------- | --------------------- |
-| ![](/imgs/fastgpt-api2.jpg) | ![](/imgs/fastgpt-api.jpg) |
+| ![](/imgs/fastgpt-api2.jpg) | ![](/imgs/fastgpt-api1.jpg) |
 
 ## 基本配置
 

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

@@ -35,9 +35,10 @@ curl --location --request POST 'http://localhost:3000/api/v1/chat/completions' \
 --header 'Authorization: Bearer fastgpt-xxxxxx' \
 --header 'Content-Type: application/json' \
 --data-raw '{
-    "chatId": "abcd",
+    "chatId": "my_chatId",
     "stream": false,
     "detail": false,
+    "responseChatItemId": "my_responseChatItemId",
     "variables": {
         "uid": "asdfadsfasfd2323",
         "name": "张三"
@@ -104,6 +105,7 @@ curl --location --request POST 'http://localhost:3000/api/v1/chat/completions' \
   - 为 `undefined` 时（不传入），不使用 FastGpt 提供的上下文功能，完全通过传入的 messages 构建上下文。 不会将你的记录存储到数据库中，你也无法在记录汇总中查阅到。
   - 为`非空字符串`时，意味着使用 chatId 进行对话，自动从 FastGpt 数据库取历史记录，并使用 messages 数组最后一个内容作为用户问题。请自行确保 chatId 唯一，长度小于250，通常可以是自己系统的对话框ID。
 - messages: 结构与 [GPT接口](https://platform.openai.com/docs/api-reference/chat/object) chat模式一致。
+- responseChatItemId: string | undefined 。如果传入，则会将该值作为本次对话的响应消息的 ID，FastGPT 会自动将该 ID 存入数据库。请确保，在当前`chatId`下，`responseChatItemId`是唯一的。
 - detail: 是否返回中间值（模块状态，响应的完整结果等），`stream模式`下会通过`event`进行区分，`非stream模式`结果保存在`responseData`中。
 - variables: 模块变量，一个对象，会替换模块中，输入框内容里的`{{key}}`
 {{% /alert %}}

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

@@ -31,17 +31,6 @@ curl --location --request POST 'http://localhost:3000/api/support/wallet/usage/c
 }'
 ```
 
-**x例子**
-
-```bash
-curl --location --request POST 'http://localhost:3000/api/support/wallet/bill/createTrainingBill' \
---header 'Authorization: Bearer {{apikey}}' \
---header 'Content-Type: application/json' \
---data-raw '{
-    "name": "可选，自定义订单名称，例如：文档训练-fastgpt.docx"
-}'
-```
-
 {{< /markdownify >}}
 {{< /tab >}}
 

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

@@ -32,7 +32,7 @@ curl --location --request POST 'https://{{host}}/api/admin/initv464' \
 4. 优化 - 历史记录模块。弃用旧的历史记录模块，直接在对应地方填写数值即可。
 5. 调整 - 知识库搜索模块 topk 逻辑，采用 MaxToken 计算，兼容不同长度的文本块
 6. 调整鉴权顺序，提高 apikey 的优先级，避免cookie抢占 apikey 的鉴权。
-7. 链接读取支持多选择器。参考[Web 站点同步用法](/docs/course/websync)
+7. 链接读取支持多选择器。参考[Web 站点同步用法](/docs/guide/knowledge_base/websync/)
 8. 修复 - 分享链接图片上传鉴权问题
 9. 修复 - Mongo 连接池未释放问题。
 10. 修复 - Dataset Intro 无法更新

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

@@ -21,10 +21,10 @@ weight: 831
 
 ## V4.6.5 功能介绍
 
-1. 新增 - [问题优化模块](/docs/workflow/modules/coreferenceresolution/)
+1. 新增 - [问题优化模块](/docs/guide/workbench/workflow/coreferenceresolution/)
-2. 新增 - [文本编辑模块](/docs/workflow/modules/text_editor/)
+2. 新增 - [文本编辑模块](/docs/guide/workbench/workflow/text_editor/)
-3. 新增 - [判断器模块](/docs/workflow/modules/tfswitch/)
+3. 新增 - [判断器模块](/docs/guide/workbench/workflow/tfswitch//)
-4. 新增 - [自定义反馈模块](/docs/workflow/modules/custom_feedback/)
+4. 新增 - [自定义反馈模块](/docs/guide/workbench/workflow/custom_feedback/)
 5. 新增 - 【内容提取】模块支持选择模型，以及字段枚举
 6. 优化 - docx读取，兼容表格（表格转markdown）
 7. 优化 - 高级编排连接线交互

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

@@ -25,7 +25,7 @@ weight: 830
 
 1. 查看 [FastGPT 2024 RoadMap](https://github.com/labring/FastGPT?tab=readme-ov-file#-%E5%9C%A8%E7%BA%BF%E4%BD%BF%E7%94%A8)
 2. 新增 - Http 模块请求头支持 Json 编辑器。
-3. 新增 - [ReRank模型部署](/docs/development/custom-models/reranker/)
+3. 新增 - [ReRank模型部署](/docs/development/custom-models/bge-rerank/)
 4. 新增 - 搜索方式：分离向量语义检索，全文检索和重排，通过 RRF 进行排序合并。
 5. 优化 - 问题分类提示词，id引导。测试国产商用 api 模型（百度阿里智谱讯飞）使用 Prompt 模式均可分类。
 6. UI 优化，未来将逐步替换新的UI设计。

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

@@ -91,7 +91,7 @@ curl --location --request POST 'https://{{host}}/api/init/v468' \
 
 1. 新增 - 知识库搜索合并模块。
 2. 新增 - 新的 Http 模块，支持更加灵活的参数传入。同时支持了输入输出自动数据类型转化，例如：接口输出的 JSON 类型会自动转成字符串类型，直接给其他模块使用。此外，还补充了一些例子，可在文档中查看。
-3. 优化 - 内容补全。将内容补全内置到【知识库搜索】中，并实现了一次内容补全，即可完成“指代消除”和“问题扩展”。FastGPT知识库搜索详细流程可查看：[知识库搜索介绍](/docs/course/data_search/)
+3. 优化 - 内容补全。将内容补全内置到【知识库搜索】中，并实现了一次内容补全，即可完成“指代消除”和“问题扩展”。FastGPT知识库搜索详细流程可查看：[知识库搜索介绍](/docs/guide/workbench/workflow/dataset_search/)
 4. 优化 - LLM 模型配置，不再区分对话、分类、提取模型。同时支持模型的默认参数，避免不同模型参数冲突，可通过`defaultConfig`传入默认的配置。
 5. 优化 - 流响应，参考了`ChatNextWeb`的流，更加丝滑。此外，之前提到的乱码、中断，刷新后又正常了，可能会修复）
 6. 修复 - 语音输入文件无法上传。

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

@@ -1,5 +1,5 @@
 ---
-title: 'V4.8.13(进行中)'
+title: 'V4.8.13'
 description: 'FastGPT V4.8.13 更新说明'
 icon: 'upgrade'
 draft: false
@@ -13,13 +13,17 @@ weight: 811
 
 ### 2. 修改镜像
 
-- 更新 FastGPT 镜像 tag: v4.8.13-alpha
+- 更新 FastGPT 镜像 tag: v4.8.13-fix
-- 更新 FastGPT 管理端镜像 tag: v4.8.13-alpha （fastgpt-pro镜像）
+- 更新 FastGPT 商业版镜像 tag: v4.8.13-fix （fastgpt-pro镜像）
 - Sandbox 镜像，可以不更新
 
-### 3. 调整文件上传编排
+### 3. 添加环境变量
 
-虽然依然兼容旧版的文件上传编排，但是未来两个版本内将会去除兼容代码，请尽快调整编排，以适应最新的文件上传逻辑。尤其是嵌套应用的文件传递，未来将不会自动传递，必须手动指定传递的文件。
+- 给 fastgpt 和 fastgpt-pro 镜像添加环境变量：`FE_DOMAIN=http://xx.com`，值为 fastgpt 前端访问地址，注意后面不要加`/`。可以自动补齐相对文件地址的前缀。
+
+### 4. 调整文件上传编排
+
+虽然依然兼容旧版的文件上传编排，但是未来两个版本内将会去除兼容代码，请尽快调整编排，以适应最新的文件上传逻辑。尤其是嵌套应用的文件传递，未来将不会自动传递，必须手动指定传递的文件。具体内容可参考: [文件上传变更](/docs/guide/course/fileinput/#4813%E7%89%88%E6%9C%AC%E8%B5%B7%E5%85%B3%E4%BA%8E%E6%96%87%E4%BB%B6%E4%B8%8A%E4%BC%A0%E7%9A%84%E6%9B%B4%E6%96%B0)
 
 ## 更新说明
 
@@ -39,6 +43,9 @@ weight: 811
 14. 优化 - Markdown 组件自动空格，避免分割 url 中的中文。  
 15. 优化 - 工作流上下文拆分，性能优化。 
 16. 优化 - 语音播报，不支持 mediaSource 的浏览器可等待完全生成语音后输出。 
-17. 修复 - Dockerfile pnpm install 支持代理。 
+17. 优化 - 对话引导 csv 读取，自动识别编码
-18. 修复 - BI 图表生成无法写入文件。同时优化其解析，支持数字类型数组。
+18. 优化 - csv 导入问题引导可能乱码
-19. 修复 - 分享链接首次加载时，标题显示不正确。 
+19. 修复 - Dockerfile pnpm install 支持代理。。
+20. 修复 - Dockerfile pnpm install 支持代理。 
+21. 修复 - BI 图表生成无法写入文件。同时优化其解析，支持数字类型数组。
+22. 修复 - 分享链接首次加载时，标题显示不正确。 

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

@@ -0,0 +1,52 @@
+---
+title: 'V4.8.14'
+description: 'FastGPT V4.8.14 更新说明'
+icon: 'upgrade'
+draft: false
+toc: true
+weight: 810
+---
+
+## 更新指南
+
+### 1. 做好数据备份
+
+### 2. 修改镜像
+
+- 更新 FastGPT 镜像 tag: v4.8.14
+- 更新 FastGPT 商业版镜像 tag: v4.8.14 （fastgpt-pro镜像）
+- Sandbox 镜像，可以不更新
+
+## 新功能预览
+
+### 自动触发工作流
+
+可以允许你配置用户加载对话时，自动触发一次工作流。可以用于一些 CRM 系统，可以快速的引导用户使用，无需等待用户主动触发。
+
+| | |
+| --- | --- |
+| ![alt text](/imgs/image-8.png) | ![alt text](/imgs/image-9.png) |
+
+
+## 完整更新内容
+
+1. 新增 - 工作流支持进入聊天框/点击开始对话后，自动触发一轮对话。
+2. 新增 - 重写 chatContext，对话测试也会有日志，并且刷新后不会丢失对话。
+3. 新增 - 分享链接支持配置是否允许查看原文。
+4. 新增 - 新的 doc2x 插件。
+5. 新增 - 繁体中文-台湾。
+6. 新增 - 分析链接和 chat api 支持传入自定义 uid。
+7. 商业版新增 - 微软 oauth 登录
+8. 优化 - 工作流 ui 细节。
+9. 优化 - 应用编辑记录采用 diff 存储，避免浏览器溢出。
+10. 优化 - 代码入口，增加 register 入口，无需等待首次访问才执行。
+11. 优化 - 工作流检查，增加更多缺失值检查。
+12. 优化 - 增加知识库训练最大重试次数限制。
+13. 优化 - 图片路径问题和示意图任务
+14. 优化 - Milvus description
+15. 修复 - 分块策略，四级标题会被丢失。 同时新增了五级标题的支持。
+16. 修复 - MongoDB 知识库集合唯一索引。
+17. 修复 - 反选知识库引用后可能会报错。
+18. 修复 - 简易模式转工作流，不是使用最新编辑记录进行转移。
+19. 修复 - 表单输入的说明文字不显示。
+20. 修复 - API 无法使用 base64 图片。

docSite/content/zh-cn/docs/guide/course/ai_settings.md

@@ -66,7 +66,7 @@ Tips: 可以通过点击上下文按键查看完整的上下文组成，便于
 
 FastGPT 知识库采用 QA 对(不一定都是问答格式，仅代表两个变量)的格式存储，在转义成字符串时候会根据**引用模板**来进行格式化。知识库包含多个可用变量： q, a, sourceId（数据的ID）, index(第n个数据), source(数据的集合名、文件名)，score(距离得分，0-1) 可以通过 {{q}} {{a}} {{sourceId}} {{index}} {{source}} {{score}} 按需引入。下面一个模板例子：
 
-可以通过 [知识库结构讲解](/docs/course/dataset_engine/) 了解详细的知识库的结构。
+可以通过 [知识库结构讲解](/docs/guide/knowledge_base/dataset_engine/) 了解详细的知识库的结构。
 
 #### 引用模板
 

docSite/content/zh-cn/docs/guide/workbench/workflow/ai_chat.md

@@ -30,5 +30,5 @@ weight: 232
 
 
 {{% alert icon="🍅" context="success" %}}
-具体配置参数介绍可以参考: [AI参数配置说明](/docs/course/ai_settings)
+具体配置参数介绍可以参考: [AI参数配置说明](/docs/guide/course/ai_settings/)
 {{% /alert %}}

docSite/content/zh-cn/docs/guide/workbench/workflow/coreferenceResolution.md

@@ -36,4 +36,4 @@ weight: 264
 
 ## 示例
 
-- [接入谷歌搜索](/docs/workflow/examples/google_search/)
+- [接入谷歌搜索](/docs/use-cases/app-cases/google_search/)

docSite/content/zh-cn/docs/guide/workbench/workflow/form_input.md

@@ -6,3 +6,27 @@ draft: false
 toc: true
 weight: 244
 ---
+
+## 特点 
+
+- 用户交互
+- 可重复添加
+- 触发执行
+
+![](/imgs/form_input1.png)
+
+## 功能 
+
+「表单输入」节点属于用户交互节点，当触发这个节点时，对话会进入“交互”状态，会记录工作流的状态，等用户完成交互后，继续向下执行工作流
+
+![](/imgs/form_input2.png)
+
+比如上图中的例子，当触发表单输入节点时，对话框隐藏，对话进入“交互状态”
+
+![](/imgs/form_input3.png)
+
+当用户填完必填的信息并点击提交后，节点能够收集用户填写的表单信息，传递到后续的节点中使用
+
+## 作用
+
+能够精准收集需要的用户信息，再根据用户信息进行后续操作

docSite/content/zh-cn/docs/guide/workbench/workflow/http.md

@@ -250,6 +250,6 @@ export default async function (ctx: FunctionContext) {
 
 ## 相关示例
 
-- [谷歌搜索](/docs/workflow/examples/google_search/)
+- [谷歌搜索](/docs/use-cases/app-cases/google_search/)
-- [发送飞书webhook](/docs/workflow/examples/feishu_webhook/)
+- [发送飞书webhook](/docs/use-cases/app-cases/feishu_webhook/)
-- [实验室预约（操作数据库）](/docs/workflow/examples/lab_appointment/)
+- [实验室预约（操作数据库）](/docs/use-cases/app-cases/lab_appointment/)

docSite/content/zh-cn/docs/guide/workbench/workflow/text_editor.md

@@ -29,4 +29,4 @@ weight: 246
 
 ## 示例
 
-- [接入谷歌搜索](/docs/workflow/examples/google_search/)
+- [接入谷歌搜索](/docs/use-cases/app-cases/google_search/)

docSite/content/zh-cn/docs/guide/workbench/workflow/tool.md

@@ -7,20 +7,21 @@ toc: true
 weight: 236
 ---
 
+
 ![](/imgs/flow-tool1.png)
 
-## 什么是工具
+### **什么是工具**
 
 工具可以是一个系统模块，例如：AI对话、知识库搜索、HTTP模块等。也可以是一个插件。
 
 工具调用可以让 LLM 更动态的决策流程，而不都是固定的流程。（当然，缺点就是费tokens）
 
-## 工具的组成
+### **工具的组成**
 
 1. 工具介绍。通常是模块的介绍或插件的介绍，这个介绍会告诉LLM，这个工具的作用是什么。
 2. 工具参数。对于系统模块来说，工具参数已经是固定的，无需额外配置。对于插件来说，工具参数是一个可配置项。
 
-## 工具是如何运行的
+### **工具是如何运行的**
 
 要了解工具如何运行的，首先需要知道它的运行条件。
 
@@ -29,43 +30,57 @@ weight: 236
 
 结合工具的介绍、参数介绍和参数是否必须，LLM会决定是否调用这个工具。有以下几种情况：
 
-
 1. 无参数的工具：直接根据工具介绍，决定是否需要执行。例如：获取当前时间。
 2. 有参数的工具：
    1. 无必须的参数：尽管上下文中，没有适合的参数，也可以调用该工具。但有时候，LLM会自己伪造一个参数。
    2. 有必须的参数：如果没有适合的参数，LLM可能不会调用该工具。可以通过提示词，引导用户提供参数。
 
+#### **工具调用逻辑**
+
 在支持`函数调用`的模型中，可以一次性调用多个工具，调用逻辑如下：
 
 ![](/imgs/flow-tool2.png)
 
-## 怎么用
+### **怎么用**
 
-| 有工具调用模块 | 无工具调用模块 |
+<div style="display: flex; gap: 10px;">
-| --- | --- |
+    <img src="/imgs/flow-tool3.png" alt="工具调用模块示例 3" width="40%" />
-| ![](/imgs/flow-tool3.png) | ![](/imgs/flow-tool4.png) |
+    <img src="/imgs/flow-tool4.png" alt="工具调用模块示例 4" width="60%" />
+</div>
 
-高级编排中，托动工具调用的连接点，可用的工具头部会出现一个菱形，可以将它与工具调用模块底部的菱形相连接。
+<!-- ![](/imgs/flow-tool3.png)!![](/imgs/flow-tool4.png) -->
 
-被连接的工具，会自动分离工具输入与普通的输入，并且可以编辑`描述`，可以通过调整介绍，使得该工具调用时机更加精确。对于一些内置的节点，务必修改`描述`才能让模型正常调用。
+高级编排中，拖动工具调用的连接点，可用的工具头部会出现一个菱形，可以将它与工具调用模块底部的菱形相连接。
+
+被连接的工具，会自动分离工具输入与普通的输入，并且可以编辑`介绍`，可以通过调整介绍，使得该工具调用时机更加精确。
 
 关于工具调用，如何调试仍然是一个玄学，所以建议，不要一次性增加太多工具，选择少量工具调优后再进一步尝试。
 
-## 组合节点
+#### 用途
 
-### 工具调用终止
+默认清空下，工具调用节点，在决定调用工具后，会将工具运行的结果，返回给AI，让 AI 对工具运行的结果进行总结输出。有时候，如果你不需要 AI 进行进一步的总结输出，可以使用该节点，将其接入对于工具流程的末尾。
 
-工具调用默认会把子流程运行的结果作为`工具结果`，返回给模型进行回答。有时候，你可能不希望模型做回答，你可以给对应子流程的末尾增加上一个`工具调用终止`节点，这样，子流程的结果就不会被返回给模型。
+如下图，在执行知识库搜索后，发送给了 HTTP 请求，搜索将不会返回搜索的结果给工具调用进行 AI 总结。
 
-![alt text](/imgs/image-3.png)
+![](/imgs/flow-tool5.png)
+
+### 附加节点
+
+当您使用了工具调用节点，同时就会出现工具调用终止节点和自定义变量节点，能够进一步提升工具调用的使用体验。
+
+#### 工具调用终止
+
+工具调用终止可用于结束本次调用，即可以接在某个工具后面，当工作流执行到这个节点时，便会强制结束本次工具调用，不再调用其他工具，也不会再调用 AI 针对工具调用结果回答问题。
+
+![](/imgs/flow-tool6.png)
 
 ### 自定义工具变量
 
-工具调用的子流程运行，有时候会依赖`AI`生成的一些变量，为了简化交互流程，我们给系统内置的节点都指定了`工具变量`。然而，有些时候，你需要的变量不仅是目标流程的`首个节点`的变量，而是需要更复杂的变量，此时你可以使用`自定义工具变量`。它允许你完全自定义该`工具流程`的变量。
+自定义变量可以扩展工具的变量输入，即对于一些未被视作工具参数或无法工具调用的节点，可以自定义工具变量，填上对应的参数描述，那么工具调用便会相对应的调用这个节点，进而调用其之后的工作流。
 
-![alt text](/imgs/image-4.png)
+![](/imgs/flow-tool7.png)
 
-## 相关示例
+### **相关示例**
 
-- [谷歌搜索](/docs/workflow/examples/google_search/)
+- [谷歌搜索](https://doc.fastgpt.in/docs/use-cases/app-cases/google_search/)
-- [发送飞书webhook](/docs/workflow/examples/feishu_webhook/)
+- [发送飞书webhook](https://doc.fastgpt.in/docs/use-cases/app-cases/feishu_webhook/)

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

@@ -85,16 +85,15 @@ FastGPT 商业版软件根据不同的部署方式，分为 3 类收费模式。
 
 ## QA
 
-1. 如何交付？
+### 如何交付？
 
    完整版应用 = 开源版镜像 + 商业版镜像
 
    我们会提供一个商业版镜像给你使用，该镜像需要一个 License 启动。
 
-2. 二次开发如何操作？
+### 二次开发如何操作？
-
-   可自行修改开源版代码进行二次开发，不支持修改商业版镜像。
 
+   可以修改开源版部分代码，不支持修改商业版镜像。完整版本=开源版+商业版镜像，所以是可以修改部分内容的。但是如果二开了，后续则需要自己进行代码合并升级。
 
 ## Sealos 费用
 

docSite/content/zh-cn/docs/use-cases/external-integration/official_account.md

@@ -39,44 +39,53 @@ weight: 506
 海外版用户（cloud.tryfastgpt.ai)可以填写下面的 IP 白名单：
 
 ```
-34.87.20.17
-35.247.161.35
-34.87.51.146
-34.87.110.152	
-35.247.163.68
-34.126.163.205
-34.87.20.189
-34.87.102.86
 35.240.227.100
-35.198.192.104
-34.143.149.171
-34.87.152.33
 34.124.237.188
-35.197.149.75
-34.87.44.74
-34.124.189.116
-34.87.79.202
-34.87.173.252
 34.143.240.160
-34.87.180.104
+34.87.51.146
+34.87.79.202
+35.247.163.68
+34.87.102.86
+35.198.192.104
+34.126.163.205
+34.124.189.116
+34.143.149.171
+34.87.173.252
 34.142.157.52
+34.87.180.104
+34.87.20.189
+34.87.110.152
+34.87.44.74
+34.87.152.33
+35.197.149.75
+35.247.161.35
 ```
 
 国内版用户（fastgpt.cn)可以填写下面的 IP 白名单：
 
 ```
-47.97.59.172
+47.97.1.240
-121.43.108.48
+121.43.105.217
-121.41.75.88
 121.41.178.7
 121.40.65.187
-121.196.235.183
+47.97.59.172
-120.55.195.90
-120.55.193.112
-120.26.229.115
-112.124.41.79
 101.37.205.32
+120.55.195.90
+120.26.229.115
+120.55.193.112
 47.98.190.173
+112.124.41.79
+121.196.235.183
+121.41.75.88
+121.43.108.48
+112.124.12.6
+121.43.52.222
+121.199.162.43
+121.199.162.102
+120.55.94.163
+47.99.59.223
+112.124.46.5
+121.40.46.247
 ```
 
 ## 4. 获取AES Key，选择加密方式

docSite/content/zh-cn/docs/use-cases/external-integration/onwechat.md

@@ -11,7 +11,7 @@ weight: 509
 
 [chatgpt-on-wechat GitHub 地址](https://github.com/zhayujie/chatgpt-on-wechat)
 
-由于 FastGPT 的 API 接口和 OpenAI 的规范一致，可以无需变更原来的应用即可使用 FastGPT 上编排好的应用。API 使用可参考 [这篇文章](/docs/course/openapi/)。编排示例，可参考 [高级编排介绍](/docs/workflow/intro)
+由于 FastGPT 的 API 接口和 OpenAI 的规范一致，可以无需变更原来的应用即可使用 FastGPT 上编排好的应用。API 使用可参考 [这篇文章](/docs/use-cases/external-integration/openapi/)。编排示例，可参考 [高级编排介绍](/docs/workflow/intro)
 
 ## 1. 获取 OpenAPI 密钥
 

files/docker/docker-compose-milvus.yml

@@ -114,15 +114,15 @@ services:
   # fastgpt
   sandbox:
     container_name: sandbox
-    image: ghcr.io/labring/fastgpt-sandbox:v4.8.11 # git
+    image: ghcr.io/labring/fastgpt-sandbox:v4.8.13-fix # git
-    # image: registry.cn-hangzhou.aliyuncs.com/fastgpt/fastgpt-sandbox:v4.8.11 # 阿里云
+    # image: registry.cn-hangzhou.aliyuncs.com/fastgpt/fastgpt-sandbox:v4.8.13-fix # 阿里云
     networks:
       - fastgpt
     restart: always
   fastgpt:
     container_name: fastgpt
-    image: ghcr.io/labring/fastgpt:v4.8.11 # git
+    image: ghcr.io/labring/fastgpt:v4.8.13-fix # git
-    # image: registry.cn-hangzhou.aliyuncs.com/fastgpt/fastgpt:v4.8.11 # 阿里云
+    # image: registry.cn-hangzhou.aliyuncs.com/fastgpt/fastgpt:v4.8.13-fix # 阿里云
     ports:
       - 3000:3000
     networks:
@@ -133,14 +133,14 @@ services:
       - sandbox
     restart: always
     environment:
+      # 前端访问地址: http://localhost:3000
+      - FE_DOMAIN=
       # root 密码，用户名为: root。如果需要修改 root 密码，直接修改这个环境变量，并重启即可。
       - DEFAULT_ROOT_PSW=1234
       # AI模型的API地址哦。务必加 /v1。这里默认填写了OneApi的访问地址。
       - OPENAI_BASE_URL=http://oneapi:3000/v1
       # AI模型的API Key。（这里默认填写了OneAPI的快速默认key，测试通后，务必及时修改）
       - CHAT_API_KEY=sk-fastgpt
-      # 是否将图片转成 base64 传递给模型，本地开发和内网环境使用共有模型时候需要设置为 true
-      - MULTIPLE_DATA_TO_BASE64=false
       # 数据库最大连接数
       - DB_MAX_LINK=30
       # 登录凭证密钥
@@ -156,8 +156,6 @@ services:
       - MILVUS_TOKEN=none
       # sandbox 地址
       - SANDBOX_URL=http://sandbox:3000
-      # 前端地址: http://localhost:3000
-      - FE_DOMAIN=
       # 日志等级: debug, info, warn, error
       - LOG_LEVEL=info
       - STORE_LOG_LEVEL=warn

files/docker/docker-compose-pgvector.yml

@@ -72,15 +72,15 @@ services:
   # fastgpt
   sandbox:
     container_name: sandbox
-    image: ghcr.io/labring/fastgpt-sandbox:v4.8.11 # git
+    image: ghcr.io/labring/fastgpt-sandbox:v4.8.13 # git
-    # image: registry.cn-hangzhou.aliyuncs.com/fastgpt/fastgpt-sandbox:v4.8.11 # 阿里云
+    # image: registry.cn-hangzhou.aliyuncs.com/fastgpt/fastgpt-sandbox:v4.8.13 # 阿里云
     networks:
       - fastgpt
     restart: always
   fastgpt:
     container_name: fastgpt
-    image: ghcr.io/labring/fastgpt:v4.8.11 # git
+    image: ghcr.io/labring/fastgpt:v4.8.14 # git
-    # image: registry.cn-hangzhou.aliyuncs.com/fastgpt/fastgpt:v4.8.11 # 阿里云
+    # image: registry.cn-hangzhou.aliyuncs.com/fastgpt/fastgpt:v4.8.14 # 阿里云
     ports:
       - 3000:3000
     networks:
@@ -91,14 +91,14 @@ services:
       - sandbox
     restart: always
     environment:
+      # 前端访问地址: http://localhost:3000
+      - FE_DOMAIN=
       # root 密码，用户名为: root。如果需要修改 root 密码，直接修改这个环境变量，并重启即可。
       - DEFAULT_ROOT_PSW=1234
       # AI模型的API地址哦。务必加 /v1。这里默认填写了OneApi的访问地址。
       - OPENAI_BASE_URL=http://oneapi:3000/v1
       # AI模型的API Key。（这里默认填写了OneAPI的快速默认key，测试通后，务必及时修改）
       - CHAT_API_KEY=sk-fastgpt
-      # 是否将图片转成 base64 传递给模型，本地开发和内网环境使用共有模型时候需要设置为 true
-      - MULTIPLE_DATA_TO_BASE64=false
       # 数据库最大连接数
       - DB_MAX_LINK=30
       # 登录凭证密钥
@@ -113,8 +113,6 @@ services:
       - PG_URL=postgresql://username:password@pg:5432/postgres
       # sandbox 地址
       - SANDBOX_URL=http://sandbox:3000
-      # 前端地址: http://localhost:3000
-      - FE_DOMAIN=
       # 日志等级: debug, info, warn, error
       - LOG_LEVEL=info
       - STORE_LOG_LEVEL=warn

files/docker/docker-compose-zilliz.yml

@@ -53,15 +53,15 @@ services:
         wait $$!
   sandbox:
     container_name: sandbox
-    image: ghcr.io/labring/fastgpt-sandbox:v4.8.11 # git
+    image: ghcr.io/labring/fastgpt-sandbox:v4.8.13-fix # git
-    # image: registry.cn-hangzhou.aliyuncs.com/fastgpt/fastgpt-sandbox:v4.8.11 # 阿里云
+    # image: registry.cn-hangzhou.aliyuncs.com/fastgpt/fastgpt-sandbox:v4.8.13-fix # 阿里云
     networks:
       - fastgpt
     restart: always
   fastgpt:
     container_name: fastgpt
-    image: ghcr.io/labring/fastgpt:v4.8.11 # git
+    image: ghcr.io/labring/fastgpt:v4.8.13-fix # git
-    # image: registry.cn-hangzhou.aliyuncs.com/fastgpt/fastgpt:v4.8.11 # 阿里云
+    # image: registry.cn-hangzhou.aliyuncs.com/fastgpt/fastgpt:v4.8.13-fix # 阿里云
     ports:
       - 3000:3000
     networks:
@@ -71,14 +71,14 @@ services:
       - sandbox
     restart: always
     environment:
+      # 前端访问地址: http://localhost:3000
+      - FE_DOMAIN=
       # root 密码，用户名为: root。如果需要修改 root 密码，直接修改这个环境变量，并重启即可。
       - DEFAULT_ROOT_PSW=1234
       # AI模型的API地址哦。务必加 /v1。这里默认填写了OneApi的访问地址。
       - OPENAI_BASE_URL=http://oneapi:3000/v1
       # AI模型的API Key。（这里默认填写了OneAPI的快速默认key，测试通后，务必及时修改）
       - CHAT_API_KEY=sk-fastgpt
-      # 是否将图片转成 base64 传递给模型，本地开发和内网环境使用共有模型时候需要设置为 true
-      - MULTIPLE_DATA_TO_BASE64=false
       # 数据库最大连接数
       - DB_MAX_LINK=30
       # 登录凭证密钥
@@ -94,8 +94,6 @@ services:
       - MILVUS_TOKEN=zilliz_cloud_token
       # sandbox 地址
       - SANDBOX_URL=http://sandbox:3000
-      # 前端地址: http://localhost:3000
-      - FE_DOMAIN=
       # 日志等级: debug, info, warn, error
       - LOG_LEVEL=info
       - STORE_LOG_LEVEL=warn

packages/global/common/file/constants.ts

@@ -16,7 +16,7 @@ export const bucketNameMap = {
   }
 };
 
-export const ReadFileBaseUrl = `${process.env.FE_DOMAIN || ''}${process.env.NEXT_PUBLIC_BASE_URL}/api/common/file/read`;
+export const ReadFileBaseUrl = `${process.env.FE_DOMAIN || ''}${process.env.NEXT_PUBLIC_BASE_URL || ''}/api/common/file/read`;
 
 export const documentFileType = '.txt, .docx, .csv, .xlsx, .pdf, .md, .html, .pptx';
 export const imageFileType =

packages/global/common/file/icon.ts

@@ -12,5 +12,7 @@ export const fileImgs = [
 ];
 
 export function getFileIcon(name = '', defaultImg = 'file/fill/file') {
-  return fileImgs.find((item) => new RegExp(item.suffix, 'gi').test(name))?.src || defaultImg;
+  return (
+    fileImgs.find((item) => new RegExp(`\.${item.suffix}`, 'gi').test(name))?.src || defaultImg
+  );
 }

packages/global/common/file/tools.ts

@@ -23,6 +23,11 @@ export const parseUrlToFileType = (url: string): UserChatItemValueItemType['file
   const parseUrl = new URL(url, 'https://locaohost:3000');
 
   const filename = (() => {
+    // Check base64 image
+    if (url.startsWith('data:image/')) {
+      const mime = url.split(',')[0].split(':')[1].split(';')[0];
+      return `image.${mime.split('/')[1]}`;
+    }
     // Old version file url: https://xxx.com/file/read?filename=xxx.pdf
     const filenameQuery = parseUrl.searchParams.get('filename');
     if (filenameQuery) return filenameQuery;

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

@@ -3,6 +3,7 @@ import { BucketNameEnum } from './constants';
 export type FileTokenQuery = {
   bucketName: `${BucketNameEnum}`;
   teamId: string;
-  tmbId: string;
+  uid: string; // tmbId/ share uid/ teamChat uid
   fileId: string;
+  customExpireMinutes?: number;
 };

packages/global/common/string/markdown.ts

@@ -1,5 +1,6 @@
 import { batchRun } from '../fn/utils';
-import { simpleText } from './tools';
+import { getNanoid, simpleText } from './tools';
+import type { ImageType } from '../../../service/worker/readFile/type';
 
 /* Delete redundant text in markdown */
 export const simpleMarkdownText = (rawText: string) => {
@@ -92,3 +93,25 @@ export const markdownProcess = async ({
 
   return simpleMarkdownText(imageProcess);
 };
+
+export const matchMdImgTextAndUpload = (text: string) => {
+  const base64Regex = /"(data:image\/[^;]+;base64[^"]+)"/g;
+  const imageList: ImageType[] = [];
+  const images = Array.from(text.match(base64Regex) || []);
+  for (const image of images) {
+    const uuid = `IMAGE_${getNanoid(12)}_IMAGE`;
+    const mime = image.split(';')[0].split(':')[1];
+    const base64 = image.split(',')[1];
+    text = text.replace(image, uuid);
+    imageList.push({
+      uuid,
+      base64,
+      mime
+    });
+  }
+
+  return {
+    text,
+    imageList
+  };
+};

packages/global/common/string/textSplitter.ts

@@ -99,7 +99,7 @@ ${mdSplitString}
   5. 标点分割：重叠
 */
 const commonSplit = (props: SplitProps): SplitResponse => {
-  let { text = '', chunkLen, overlapRatio = 0.2, customReg = [] } = props;
+  let { text = '', chunkLen, overlapRatio = 0.15, customReg = [] } = props;
 
   const splitMarker = 'SPLIT_HERE_SPLIT_HERE';
   const codeBlockMarker = 'CODE_BLOCK_LINE_MARKER';
@@ -113,6 +113,8 @@ const commonSplit = (props: SplitProps): SplitResponse => {
   text = text.replace(/(\r?\n|\r){3,}/g, '\n\n\n');
 
   // The larger maxLen is, the next sentence is less likely to trigger splitting
+  const markdownIndex = 4;
+  const forbidOverlapIndex = 8;
   const stepReges: { reg: RegExp; maxLen: number }[] = [
     ...customReg.map((text) => ({
       reg: new RegExp(`(${replaceRegChars(text)})`, 'g'),
@@ -122,9 +124,11 @@ const commonSplit = (props: SplitProps): SplitResponse => {
     { reg: /^(##\s[^\n]+\n)/gm, maxLen: chunkLen * 1.4 },
     { reg: /^(###\s[^\n]+\n)/gm, maxLen: chunkLen * 1.6 },
     { reg: /^(####\s[^\n]+\n)/gm, maxLen: chunkLen * 1.8 },
+    { reg: /^(#####\s[^\n]+\n)/gm, maxLen: chunkLen * 1.8 },
 
     { reg: /([\n]([`~]))/g, maxLen: chunkLen * 4 }, // code block
-    { reg: /([\n](?!\s*[\*\-|>0-9]))/g, maxLen: chunkLen * 2 }, // 增大块，尽可能保证它是一个完整的段落。 (?![\*\-|>`0-9]): markdown special char
+    { reg: /([\n](?=\s*[0-9]+\.))/g, maxLen: chunkLen * 2 }, // 增大块，尽可能保证它是一个完整的段落。 (?![\*\-|>`0-9]): markdown special char
+    { reg: /(\n{2,})/g, maxLen: chunkLen * 1.6 },
     { reg: /([\n])/g, maxLen: chunkLen * 1.2 },
     // ------ There's no overlap on the top
     { reg: /([。]|([a-zA-Z])\.\s)/g, maxLen: chunkLen * 1.2 },
@@ -136,8 +140,10 @@ const commonSplit = (props: SplitProps): SplitResponse => {
 
   const customRegLen = customReg.length;
   const checkIsCustomStep = (step: number) => step < customRegLen;
-  const checkIsMarkdownSplit = (step: number) => step >= customRegLen && step <= 3 + customRegLen;
+  const checkIsMarkdownSplit = (step: number) =>
-  const checkForbidOverlap = (step: number) => step <= 6 + customRegLen;
+    step >= customRegLen && step <= markdownIndex + customRegLen;
+  +customReg.length;
+  const checkForbidOverlap = (step: number) => step <= forbidOverlapIndex + customRegLen;
 
   // if use markdown title split, Separate record title
   const getSplitTexts = ({ text, step }: { text: string; step: number }) => {
@@ -231,7 +237,7 @@ const commonSplit = (props: SplitProps): SplitResponse => {
       // use slice-chunkLen to split text
       const chunks: string[] = [];
       for (let i = 0; i < text.length; i += chunkLen - overlapLen) {
-        chunks.push(`${parentTitle}${text.slice(i, i + chunkLen)}`);
+        chunks.push(text.slice(i, i + chunkLen));
       }
       return chunks;
     }
@@ -241,7 +247,6 @@ const commonSplit = (props: SplitProps): SplitResponse => {
 
     const maxLen = splitTexts.length > 1 ? stepReges[step].maxLen : chunkLen;
     const minChunkLen = chunkLen * 0.7;
-    // console.log(splitTexts, stepReges[step].reg);
 
     const chunks: string[] = [];
     for (let i = 0; i < splitTexts.length; i++) {
@@ -249,12 +254,34 @@ const commonSplit = (props: SplitProps): SplitResponse => {
 
       const lastTextLen = lastText.length;
       const currentText = item.text;
-      const currentTextLen = currentText.length;
       const newText = lastText + currentText;
-      const newTextLen = lastTextLen + currentTextLen;
+      const newTextLen = newText.length;
+
+      // Markdown 模式下，会强制向下拆分最小块，并再最后一个标题时候，给小块都补充上所有标题（包含父级标题）
+      if (isMarkdownStep) {
+        // split new Text, split chunks must will greater 1 (small lastText)
+        const innerChunks = splitTextRecursively({
+          text: newText,
+          step: step + 1,
+          lastText: '',
+          parentTitle: parentTitle + item.title
+        });
+
+        const lastChunk = innerChunks[innerChunks.length - 1];
+        if (!lastChunk) continue;
+
+        chunks.push(
+          ...innerChunks.map(
+            (chunk) =>
+              step === markdownIndex + customRegLen ? `${parentTitle}${item.title}${chunk}` : chunk // 合并进 Markdown 分块时，需要补标题
+          )
+        );
+
+        continue;
+      }
 
       // newText is too large(now, The lastText must be smaller than chunkLen)
-      if (newTextLen > maxLen || isMarkdownStep) {
+      if (newTextLen > maxLen) {
         // lastText greater minChunkLen, direct push it to chunks, not add to next chunk. (large lastText)
         if (lastTextLen > minChunkLen) {
           chunks.push(lastText);
@@ -278,15 +305,6 @@ const commonSplit = (props: SplitProps): SplitResponse => {
 
         if (!lastChunk) continue;
 
-        if (forbidConcat) {
-          chunks.push(
-            ...innerChunks.map(
-              (chunk) => (step === 3 + customRegLen ? `${parentTitle}${chunk}` : chunk) // 合并进 Markdown 分块时，需要补标题
-            )
-          );
-          continue;
-        }
-
         // last chunk is too small, concat it to lastText(next chunk start)
         if (lastChunk.length < minChunkLen) {
           chunks.push(...innerChunks.slice(0, -1));
@@ -304,11 +322,11 @@ const commonSplit = (props: SplitProps): SplitResponse => {
         continue;
       }
 
-      // new text is small
+      // New text is small
 
       // Not overlap
       if (forbidConcat) {
-        chunks.push(`${parentTitle}${item.title}${item.text}`);
+        chunks.push(item.text);
         continue;
       }
 

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

@@ -56,6 +56,7 @@ export type FastGPTFeConfigsType = {
     github?: string;
     google?: string;
     wechat?: string;
+    microsoft?: string;
   };
   limit?: {
     exportDatasetLimitMinutes?: number;

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

@@ -49,6 +49,7 @@ export type ChatCompletionMessageParam = (
   | CustomChatCompletionAssistantMessageParam
 ) & {
   dataId?: string;
+  hideInUI?: boolean;
 };
 export type SdkChatCompletionMessageParam = SdkChatCompletionMessageParam;
 

packages/global/core/app/constants.ts

@@ -1,4 +1,9 @@
-import { AppTTSConfigType, AppFileSelectConfigType, AppWhisperConfigType } from './type';
+import {
+  AppTTSConfigType,
+  AppFileSelectConfigType,
+  AppWhisperConfigType,
+  AppAutoExecuteConfigType
+} from './type';
 
 export enum AppTypeEnum {
   folder = 'folder',
@@ -12,6 +17,11 @@ export const AppFolderTypeList = [AppTypeEnum.folder, AppTypeEnum.httpPlugin];
 
 export const defaultTTSConfig: AppTTSConfigType = { type: 'web' };
 
+export const defaultAutoExecuteConfig: AppAutoExecuteConfigType = {
+  open: false,
+  defaultPrompt: ''
+};
+
 export const defaultWhisperConfig: AppWhisperConfigType = {
   open: false,
   autoSend: false,

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

@@ -96,6 +96,7 @@ export type AppSimpleEditFormType = {
 export type AppChatConfigType = {
   welcomeText?: string;
   variables?: VariableItemType[];
+  autoExecute?: AppAutoExecuteConfigType;
   questionGuide?: boolean;
   ttsConfig?: AppTTSConfigType;
   whisperConfig?: AppWhisperConfigType;
@@ -158,6 +159,11 @@ export type AppScheduledTriggerConfigType = {
   timezone: string;
   defaultPrompt: string;
 };
+// auto execute
+export type AppAutoExecuteConfigType = {
+  open: boolean;
+  defaultPrompt: string;
+};
 // File
 export type AppFileSelectConfigType = {
   canSelectFile: boolean;

packages/global/core/chat/adapt.ts

@@ -76,6 +76,7 @@ export const chats2GPTMessages = ({
 
       results.push({
         dataId,
+        hideInUI: item.hideInUI,
         role: ChatCompletionRequestMessageRoleEnum.User,
         content: simpleUserContentPart(value)
       });
@@ -318,6 +319,7 @@ export const GPTMessages2Chats = (
       return {
         dataId: item.dataId,
         obj,
+        hideInUI: item.hideInUI,
         value
       } as ChatItemType;
     })

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

@@ -56,6 +56,7 @@ export type UserChatItemValueItemType = {
 export type UserChatItemType = {
   obj: ChatRoleEnum.Human;
   value: UserChatItemValueItemType[];
+  hideInUI?: boolean;
 };
 export type SystemChatItemValueItemType = {
   type: ChatItemValueTypeEnum.text;

packages/global/core/chat/utils.ts

@@ -78,11 +78,15 @@ export const getHistoryPreview = (
 };
 
 export const filterPublicNodeResponseData = ({
-  flowResponses = []
+  flowResponses = [],
+  responseDetail = false
 }: {
   flowResponses?: ChatHistoryItemResType[];
+  responseDetail?: boolean;
 }) => {
-  const filedList = ['quoteList', 'moduleType', 'pluginOutput', 'runningTime'];
+  const filedList = responseDetail
+    ? ['quoteList', 'moduleType', 'pluginOutput', 'runningTime']
+    : ['moduleType', 'pluginOutput', 'runningTime'];
   const filterModuleTypeList: any[] = [
     FlowNodeTypeEnum.pluginModule,
     FlowNodeTypeEnum.datasetSearchNode,
@@ -97,7 +101,7 @@ export const filterPublicNodeResponseData = ({
       for (let key in item) {
         if (key === 'toolDetail' || key === 'pluginDetail') {
           // @ts-ignore
-          obj[key] = filterPublicNodeResponseData({ flowResponses: item[key] });
+          obj[key] = filterPublicNodeResponseData({ flowResponses: item[key], responseDetail });
         } else if (filedList.includes(key)) {
           // @ts-ignore
           obj[key] = item[key];

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

@@ -204,7 +204,8 @@ export type DatasetFileSchema = {
   contentType: string;
   metadata: {
     teamId: string;
-    tmbId: string;
+    tmbId?: string;
+    uid: string;
     encoding?: string;
   };
 };

packages/global/core/workflow/constants.ts

@@ -106,6 +106,7 @@ export enum NodeInputKeyEnum {
   variables = 'variables',
   scheduleTrigger = 'scheduleTrigger',
   chatInputGuide = 'chatInputGuide',
+  autoExecute = 'autoExecute',
 
   // plugin config
   instruction = 'instruction',

packages/global/core/workflow/template/system/datasetSearch.ts

@@ -95,10 +95,10 @@ export const DatasetSearchModule: FlowNodeTemplateType = {
     },
     {
       key: NodeInputKeyEnum.collectionFilterMatch,
-      renderTypeList: [FlowNodeInputTypeEnum.JSONEditor, FlowNodeInputTypeEnum.reference],
+      renderTypeList: [FlowNodeInputTypeEnum.textarea, FlowNodeInputTypeEnum.reference],
       label: i18nT('workflow:collection_metadata_filter'),
 
-      valueType: WorkflowIOValueTypeEnum.object,
+      valueType: WorkflowIOValueTypeEnum.string,
       isPro: true,
       description: i18nT('workflow:filter_description')
     }

packages/global/core/workflow/utils.ts

@@ -25,10 +25,12 @@ import type {
   AppWhisperConfigType,
   AppScheduledTriggerConfigType,
   ChatInputGuideConfigType,
-  AppChatConfigType
+  AppChatConfigType,
+  AppAutoExecuteConfigType
 } from '../app/type';
 import { EditorVariablePickerType } from '../../../web/components/common/Textarea/PromptEditor/type';
 import {
+  defaultAutoExecuteConfig,
   defaultChatInputGuideConfig,
   defaultTTSConfig,
   defaultWhisperConfig
@@ -69,34 +71,37 @@ export const getGuideModule = (modules: StoreNodeItemType[]) =>
   );
 export const splitGuideModule = (guideModules?: StoreNodeItemType) => {
   const welcomeText: string =
-    guideModules?.inputs?.find((item) => item.key === NodeInputKeyEnum.welcomeText)?.value || '';
+    guideModules?.inputs?.find((item) => item.key === NodeInputKeyEnum.welcomeText)?.value ?? '';
 
   const variables: VariableItemType[] =
-    guideModules?.inputs.find((item) => item.key === NodeInputKeyEnum.variables)?.value || [];
+    guideModules?.inputs.find((item) => item.key === NodeInputKeyEnum.variables)?.value ?? [];
 
   const questionGuide: boolean =
-    !!guideModules?.inputs?.find((item) => item.key === NodeInputKeyEnum.questionGuide)?.value ||
+    !!guideModules?.inputs?.find((item) => item.key === NodeInputKeyEnum.questionGuide)?.value ??
     false;
 
   const ttsConfig: AppTTSConfigType =
-    guideModules?.inputs?.find((item) => item.key === NodeInputKeyEnum.tts)?.value ||
+    guideModules?.inputs?.find((item) => item.key === NodeInputKeyEnum.tts)?.value ??
     defaultTTSConfig;
 
   const whisperConfig: AppWhisperConfigType =
-    guideModules?.inputs?.find((item) => item.key === NodeInputKeyEnum.whisper)?.value ||
+    guideModules?.inputs?.find((item) => item.key === NodeInputKeyEnum.whisper)?.value ??
     defaultWhisperConfig;
 
-  const scheduledTriggerConfig: AppScheduledTriggerConfigType = guideModules?.inputs?.find(
+  const scheduledTriggerConfig: AppScheduledTriggerConfigType =
-    (item) => item.key === NodeInputKeyEnum.scheduleTrigger
+    guideModules?.inputs?.find((item) => item.key === NodeInputKeyEnum.scheduleTrigger)?.value ??
-  )?.value;
+    undefined;
 
   const chatInputGuide: ChatInputGuideConfigType =
-    guideModules?.inputs?.find((item) => item.key === NodeInputKeyEnum.chatInputGuide)?.value ||
+    guideModules?.inputs?.find((item) => item.key === NodeInputKeyEnum.chatInputGuide)?.value ??
     defaultChatInputGuideConfig;
 
-  // plugin
   const instruction: string =
-    guideModules?.inputs?.find((item) => item.key === NodeInputKeyEnum.instruction)?.value || '';
+    guideModules?.inputs?.find((item) => item.key === NodeInputKeyEnum.instruction)?.value ?? '';
+
+  const autoExecute: AppAutoExecuteConfigType =
+    guideModules?.inputs?.find((item) => item.key === NodeInputKeyEnum.autoExecute)?.value ??
+    defaultAutoExecuteConfig;
 
   return {
     welcomeText,
@@ -106,7 +111,8 @@ export const splitGuideModule = (guideModules?: StoreNodeItemType) => {
     whisperConfig,
     scheduledTriggerConfig,
     chatInputGuide,
-    instruction
+    instruction,
+    autoExecute
   };
 };
 
@@ -132,7 +138,8 @@ export const getAppChatConfig = ({
     whisperConfig,
     scheduledTriggerConfig,
     chatInputGuide,
-    instruction
+    instruction,
+    autoExecute
   } = splitGuideModule(systemConfigNode);
 
   const config: AppChatConfigType = {
@@ -142,6 +149,7 @@ export const getAppChatConfig = ({
     scheduledTriggerConfig,
     chatInputGuide,
     instruction,
+    autoExecute,
     ...chatConfig,
     variables: storeVariables ?? chatConfig?.variables ?? variables,
     welcomeText: storeWelcomeText ?? chatConfig?.welcomeText ?? welcomeText

packages/global/support/user/constant.ts

@@ -14,5 +14,6 @@ export const userStatusMap = {
 export enum OAuthEnum {
   github = 'github',
   google = 'google',
-  wechat = 'wechat'
+  wechat = 'wechat',
+  microsoft = 'microsoft'
 }

packages/plugins/register.ts

@@ -5,18 +5,7 @@ import { cloneDeep } from 'lodash';
 import { WorkerNameEnum, runWorker } from '@fastgpt/service/worker/utils';
 
 // Run in main thread
-const staticPluginList = [
+const staticPluginList = ['getTime', 'fetchUrl', 'feishu', 'google', 'bing'];
-  'getTime',
-  'fetchUrl',
-  'Doc2X',
-  'Doc2X/URLPDF2text',
-  'Doc2X/URLImg2text',
-  `Doc2X/FilePDF2text`,
-  `Doc2X/FileImg2text`,
-  'feishu',
-  'google',
-  'bing'
-];
 // Run in worker thread (Have npm packages)
 const packagePluginList = [
   'mathExprVal',
@@ -28,7 +17,9 @@ const packagePluginList = [
   'drawing',
   'drawing/baseChart',
   'wiki',
-  'databaseConnection'
+  'databaseConnection',
+  'Doc2X',
+  'Doc2X/PDF2text'
 ];
 
 export const list = [...staticPluginList, ...packagePluginList];
@@ -55,6 +46,8 @@ export const getCommunityPlugins = () => {
 };
 
 export const getSystemPluginTemplates = () => {
+  if (!global.systemPlugins) return [];
+
   const oldPlugins = global.communityPlugins ?? [];
   return [...oldPlugins, ...cloneDeep(global.systemPlugins)];
 };
@@ -96,7 +89,3 @@ export const getCommunityCb = async () => {
     {}
   );
 };
-
-export const getSystemPluginCb = async () => {
-  return global.systemPluginCb;
-};

packages/plugins/src/Doc2X/FileImg2text/index.ts

@@ -1,172 +0,0 @@
-import { delay } from '@fastgpt/global/common/system/utils';
-import { addLog } from '@fastgpt/service/common/system/log';
-
-type Props = {
-  apikey: string;
-  files: Array<string>;
-  img_correction: boolean;
-  formula: boolean;
-};
-
-type Response = Promise<{
-  result: string;
-  failreason: string;
-  success: boolean;
-}>;
-
-const main = async ({ apikey, files, img_correction, formula }: Props): Response => {
-  // Check the apikey
-  if (!apikey) {
-    return {
-      result: '',
-      failreason: `API key is required`,
-      success: false
-    };
-  }
-
-  let real_api_key = apikey;
-  if (!apikey.startsWith('sk-')) {
-    const response = await fetch('https://api.doc2x.noedgeai.com/api/token/refresh', {
-      method: 'POST',
-      headers: {
-        Authorization: `Bearer ${apikey}`
-      }
-    });
-    if (response.status !== 200) {
-      return {
-        result: '',
-        failreason: `Get token failed: ${await response.text()}`,
-        success: false
-      };
-    }
-    const data = await response.json();
-    real_api_key = data.data.token;
-  }
-
-  let final_result = '';
-  let fail_reason = '';
-  let flag = false;
-  //Process each file one by one
-  for await (const url of files) {
-    // Fetch the image and check its content type
-    const imageResponse = await fetch(url);
-    if (!imageResponse.ok) {
-      fail_reason += `\n---\nFile:${url} \n<Content>\nFailed to fetch image from URL\n</Content>\n`;
-      flag = true;
-      continue;
-    }
-
-    const contentType = imageResponse.headers.get('content-type');
-    const fileName = url.match(/read\?filename=([^&]+)/)?.[1] || 'unknown.png';
-    if (!contentType || !contentType.startsWith('image/')) {
-      fail_reason += `\n---\nFile:${url} \n<Content>\nThe provided URL does not point to an image: ${contentType}\n</Content>\n`;
-      flag = true;
-      continue;
-    }
-
-    const blob = await imageResponse.blob();
-    const formData = new FormData();
-    formData.append('file', blob, fileName);
-    formData.append('img_correction', img_correction ? '1' : '0');
-    formData.append('equation', formula ? '1' : '0');
-
-    let upload_url = 'https://api.doc2x.noedgeai.com/api/platform/async/img';
-    if (real_api_key.startsWith('sk-')) {
-      upload_url = 'https://api.doc2x.noedgeai.com/api/v1/async/img';
-    }
-
-    let uuid;
-    let upload_flag = true;
-    const uploadAttempts = [1, 2, 3];
-    for await (const attempt of uploadAttempts) {
-      const upload_response = await fetch(upload_url, {
-        method: 'POST',
-        headers: {
-          Authorization: `Bearer ${real_api_key}`
-        },
-        body: formData
-      });
-
-      if (!upload_response.ok) {
-        // Rate limit, wait for 10s and retry at most 3 times
-        if (upload_response.status === 429 && attempt < 3) {
-          await delay(10000);
-          continue;
-        }
-        fail_reason += `\n---\nFile:${fileName}\n<Content>\nFailed to upload file: ${await upload_response.text()}\n</Content>\n`;
-        flag = true;
-        upload_flag = false;
-        break;
-      }
-      if (!upload_flag) {
-        continue;
-      }
-
-      const upload_data = await upload_response.json();
-      uuid = upload_data.data.uuid;
-      break;
-    }
-
-    // Get the result by uuid
-    let result_url = 'https://api.doc2x.noedgeai.com/api/platform/async/status?uuid=' + uuid;
-    if (real_api_key.startsWith('sk-')) {
-      result_url = 'https://api.doc2x.noedgeai.com/api/v1/async/status?uuid=' + uuid;
-    }
-
-    let required_flag = true;
-    const maxAttempts = 100;
-    // Wait for the result, at most 100s
-    for await (const _ of Array(maxAttempts).keys()) {
-      const result_response = await fetch(result_url, {
-        headers: {
-          Authorization: `Bearer ${real_api_key}`
-        }
-      });
-      if (!result_response.ok) {
-        fail_reason += `\n---\nFile:${fileName}\n<Content>\nFailed to get result: ${await result_response.text()}\n</Content>\n`;
-        flag = true;
-        required_flag = false;
-        break;
-      }
-      const result_data = await result_response.json();
-      if (['ready', 'processing'].includes(result_data.data.status)) {
-        await delay(1000);
-      } else if (result_data.data.status === 'pages limit exceeded') {
-        fail_reason += `\n---\nFile:${fileName}\n<Content>\nFailed to get result: pages limit exceeded\n</Content>\n`;
-        flag = true;
-        required_flag = false;
-        break;
-      } else if (result_data.data.status === 'success') {
-        let result;
-        try {
-          result = result_data.data.result.pages[0].md;
-          result = result.replace(/\\[\(\)]/g, '$').replace(/\\[\[\]]/g, '$$');
-        } catch {
-          // no pages
-          final_result += `\n---\nFile:${fileName}\n<Content>\n \n</Content>\n`;
-          required_flag = false;
-        }
-        final_result += `\n---\nFile:${fileName}\n<Content>\n${result}\n</Content>\n`;
-        required_flag = false;
-        break;
-      } else {
-        fail_reason += `\n---\nFile:${fileName}\n<Content>\nFailed to get result: ${result_data.data.status}\n</Content>\n`;
-        flag = true;
-        required_flag = false;
-        break;
-      }
-    }
-    if (required_flag) {
-      fail_reason += `\n---\nFile:${fileName}\n<Content>\nTimeout waiting for result\n</Content>\n`;
-      flag = true;
-    }
-  }
-
-  return {
-    result: final_result,
-    failreason: fail_reason,
-    success: !flag
-  };
-};
-
-export default main;

packages/plugins/src/Doc2X/FileImg2text/template.json

@@ -1,500 +0,0 @@
-{
-  "author": "Menghuan1918",
-  "version": "488",
-  "name": "Doc2X 图像(文件)识别",
-  "avatar": "plugins/doc2x",
-  "intro": "将上传的图片文件发送至Doc2X进行解析，返回带LaTeX公式的markdown格式的文本",
-  "courseUrl": "https://fael3z0zfze.feishu.cn/wiki/Rkc5witXWiJoi5kORd2cofh6nDg?fromScene=spaceOverview",
-  "showStatus": true,
-  "weight": 10,
-
-  "isTool": true,
-  "templateType": "tools",
-
-  "workflow": {
-    "nodes": [
-      {
-        "nodeId": "pluginConfig",
-        "name": "common:core.module.template.system_config",
-        "intro": "",
-        "avatar": "core/workflow/template/systemConfig",
-        "flowNodeType": "pluginConfig",
-        "position": {
-          "x": -90.53591960393504,
-          "y": -17.580286776561252
-        },
-        "version": "4811",
-        "inputs": [],
-        "outputs": []
-      },
-      {
-        "nodeId": "pluginInput",
-        "name": "插件开始",
-        "intro": "可以配置插件需要哪些输入，利用这些输入来运行插件",
-        "avatar": "core/workflow/template/workflowStart",
-        "flowNodeType": "pluginInput",
-        "showStatus": false,
-        "position": {
-          "x": 368.6800424053505,
-          "y": -17.580286776561252
-        },
-        "version": "481",
-        "inputs": [
-          {
-            "renderTypeList": ["input"],
-            "selectedTypeIndex": 0,
-            "valueType": "string",
-            "canEdit": true,
-            "key": "apikey",
-            "label": "apikey",
-            "description": "Doc2X的验证密匙，对于个人用户可以从Doc2X官网 - 个人信息 - 身份令牌获得",
-            "required": true,
-            "toolDescription": "",
-            "defaultValue": ""
-          },
-          {
-            "renderTypeList": ["reference"],
-            "selectedTypeIndex": 0,
-            "valueType": "arrayString",
-            "canEdit": true,
-            "key": "files",
-            "label": "files",
-            "description": "待处理图片文件",
-            "required": true,
-            "toolDescription": "待处理图片文件"
-          },
-          {
-            "renderTypeList": ["switch"],
-            "selectedTypeIndex": 0,
-            "valueType": "boolean",
-            "canEdit": true,
-            "key": "img_correction",
-            "label": "img_correction",
-            "description": "是否启用图形矫正功能",
-            "required": true,
-            "toolDescription": "",
-            "defaultValue": false
-          },
-          {
-            "renderTypeList": ["switch"],
-            "selectedTypeIndex": 0,
-            "valueType": "boolean",
-            "canEdit": true,
-            "key": "formula",
-            "label": "formula",
-            "description": "是否开启纯公式识别(仅适用于图片内容仅有公式时)",
-            "required": true,
-            "toolDescription": "",
-            "defaultValue": false
-          }
-        ],
-        "outputs": [
-          {
-            "id": "apikey",
-            "valueType": "string",
-            "key": "apikey",
-            "label": "apikey",
-            "type": "hidden"
-          },
-          {
-            "id": "url",
-            "valueType": "arrayString",
-            "key": "files",
-            "label": "files",
-            "type": "hidden"
-          },
-          {
-            "id": "img_correction",
-            "valueType": "boolean",
-            "key": "img_correction",
-            "label": "img_correction",
-            "type": "hidden"
-          },
-          {
-            "id": "formula",
-            "valueType": "boolean",
-            "key": "formula",
-            "label": "formula",
-            "type": "hidden"
-          }
-        ]
-      },
-      {
-        "nodeId": "pluginOutput",
-        "name": "插件输出",
-        "intro": "自定义配置外部输出，使用插件时，仅暴露自定义配置的输出",
-        "avatar": "core/workflow/template/pluginOutput",
-        "flowNodeType": "pluginOutput",
-        "showStatus": false,
-        "position": {
-          "x": 1796.2235867744578,
-          "y": 6.419713223438748
-        },
-        "version": "481",
-        "inputs": [
-          {
-            "renderTypeList": ["reference"],
-            "valueType": "string",
-            "canEdit": true,
-            "key": "result",
-            "label": "result",
-            "description": "处理结果(或者是报错信息)",
-            "value": ["zHG5jJBkXmjB", "xWQuEf50F3mr"]
-          },
-          {
-            "renderTypeList": ["reference"],
-            "valueType": "string",
-            "canEdit": true,
-            "key": "failreason",
-            "label": "failreason",
-            "description": "文件处理失败原因，由文件名以及报错组成，多个文件之间由横线分隔开",
-            "value": ["zHG5jJBkXmjB", "jbv4nVZvmFXm"]
-          },
-          {
-            "renderTypeList": ["reference"],
-            "valueType": "boolean",
-            "canEdit": true,
-            "key": "success",
-            "label": "success",
-            "description": "是否全部文件都处理成功，如有没有处理成功的文件，失败原因将会输出在failreason中",
-            "value": ["zHG5jJBkXmjB", "k46cjNulVk5Y"]
-          }
-        ],
-        "outputs": []
-      },
-      {
-        "nodeId": "zHG5jJBkXmjB",
-        "name": "HTTP 请求",
-        "intro": "可以发出一个 HTTP 请求，实现更为复杂的操作（联网搜索、数据库查询等）",
-        "avatar": "core/workflow/template/httpRequest",
-        "flowNodeType": "httpRequest468",
-        "showStatus": true,
-        "position": {
-          "x": 1081.967607938733,
-          "y": -426.08028677656125
-        },
-        "version": "481",
-        "inputs": [
-          {
-            "key": "system_addInputParam",
-            "renderTypeList": ["addInputParam"],
-            "valueType": "dynamic",
-            "label": "",
-            "required": false,
-            "description": "common:core.module.input.description.HTTP Dynamic Input",
-            "customInputConfig": {
-              "selectValueTypeList": [
-                "string",
-                "number",
-                "boolean",
-                "object",
-                "arrayString",
-                "arrayNumber",
-                "arrayBoolean",
-                "arrayObject",
-                "arrayAny",
-                "any",
-                "chatHistory",
-                "datasetQuote",
-                "dynamic",
-                "selectApp",
-                "selectDataset"
-              ],
-              "showDescription": false,
-              "showDefaultValue": true
-            },
-            "debugLabel": "",
-            "toolDescription": ""
-          },
-          {
-            "key": "system_httpMethod",
-            "renderTypeList": ["custom"],
-            "valueType": "string",
-            "label": "",
-            "value": "POST",
-            "required": true,
-            "debugLabel": "",
-            "toolDescription": ""
-          },
-          {
-            "key": "system_httpTimeout",
-            "renderTypeList": ["custom"],
-            "valueType": "number",
-            "label": "",
-            "value": 30,
-            "min": 5,
-            "max": 600,
-            "required": true,
-            "debugLabel": "",
-            "toolDescription": ""
-          },
-          {
-            "key": "system_httpReqUrl",
-            "renderTypeList": ["hidden"],
-            "valueType": "string",
-            "label": "",
-            "description": "common:core.module.input.description.Http Request Url",
-            "placeholder": "https://api.ai.com/getInventory",
-            "required": false,
-            "value": "Doc2X/FileImg2text",
-            "debugLabel": "",
-            "toolDescription": ""
-          },
-          {
-            "key": "system_httpHeader",
-            "renderTypeList": ["custom"],
-            "valueType": "any",
-            "value": [],
-            "label": "",
-            "description": "common:core.module.input.description.Http Request Header",
-            "placeholder": "common:core.module.input.description.Http Request Header",
-            "required": false,
-            "debugLabel": "",
-            "toolDescription": ""
-          },
-          {
-            "key": "system_httpParams",
-            "renderTypeList": ["hidden"],
-            "valueType": "any",
-            "value": [],
-            "label": "",
-            "required": false,
-            "debugLabel": "",
-            "toolDescription": ""
-          },
-          {
-            "key": "system_httpJsonBody",
-            "renderTypeList": ["hidden"],
-            "valueType": "any",
-            "value": "{\n  \"apikey\": \"{{apikey}}\",\n  \"files\": {{files}},\n  \"img_correction\": {{img_correction}},\n  \"formula\": {{formula}}\n}",
-            "label": "",
-            "required": false,
-            "debugLabel": "",
-            "toolDescription": ""
-          },
-          {
-            "key": "system_httpFormBody",
-            "renderTypeList": ["hidden"],
-            "valueType": "any",
-            "value": [],
-            "label": "",
-            "required": false,
-            "debugLabel": "",
-            "toolDescription": ""
-          },
-          {
-            "key": "system_httpContentType",
-            "renderTypeList": ["hidden"],
-            "valueType": "string",
-            "value": "json",
-            "label": "",
-            "required": false,
-            "debugLabel": "",
-            "toolDescription": ""
-          },
-          {
-            "renderTypeList": ["reference"],
-            "valueType": "string",
-            "canEdit": true,
-            "key": "apikey",
-            "label": "apikey",
-            "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", "apikey"]
-          },
-          {
-            "renderTypeList": ["reference"],
-            "valueType": "arrayString",
-            "canEdit": true,
-            "key": "files",
-            "label": "files",
-            "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", "url"]
-          },
-          {
-            "renderTypeList": ["reference"],
-            "valueType": "boolean",
-            "canEdit": true,
-            "key": "img_correction",
-            "label": "img_correction",
-            "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", "img_correction"]
-          },
-          {
-            "renderTypeList": ["reference"],
-            "valueType": "boolean",
-            "canEdit": true,
-            "key": "formula",
-            "label": "formula",
-            "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", "formula"]
-          }
-        ],
-        "outputs": [
-          {
-            "id": "error",
-            "key": "error",
-            "label": "workflow:request_error",
-            "description": "HTTP请求错误信息，成功时返回空",
-            "valueType": "object",
-            "type": "static"
-          },
-          {
-            "id": "httpRawResponse",
-            "key": "httpRawResponse",
-            "required": true,
-            "label": "workflow:raw_response",
-            "description": "HTTP请求的原始响应。只能接受字符串或JSON类型响应数据。",
-            "valueType": "any",
-            "type": "static"
-          },
-          {
-            "id": "system_addOutputParam",
-            "key": "system_addOutputParam",
-            "type": "dynamic",
-            "valueType": "dynamic",
-            "label": "",
-            "customFieldConfig": {
-              "selectValueTypeList": [
-                "string",
-                "number",
-                "boolean",
-                "object",
-                "arrayString",
-                "arrayNumber",
-                "arrayBoolean",
-                "arrayObject",
-                "any",
-                "chatHistory",
-                "datasetQuote",
-                "dynamic",
-                "selectApp",
-                "selectDataset"
-              ],
-              "showDescription": false,
-              "showDefaultValue": false
-            }
-          },
-          {
-            "id": "xWQuEf50F3mr",
-            "valueType": "string",
-            "type": "dynamic",
-            "key": "result",
-            "label": "result"
-          },
-          {
-            "id": "jbv4nVZvmFXm",
-            "valueType": "string",
-            "type": "dynamic",
-            "key": "failreason",
-            "label": "failreason"
-          },
-          {
-            "id": "k46cjNulVk5Y",
-            "valueType": "boolean",
-            "type": "dynamic",
-            "key": "success",
-            "label": "success"
-          }
-        ]
-      }
-    ],
-    "edges": [
-      {
-        "source": "pluginInput",
-        "target": "zHG5jJBkXmjB",
-        "sourceHandle": "pluginInput-source-right",
-        "targetHandle": "zHG5jJBkXmjB-target-left"
-      },
-      {
-        "source": "zHG5jJBkXmjB",
-        "target": "pluginOutput",
-        "sourceHandle": "zHG5jJBkXmjB-source-right",
-        "targetHandle": "pluginOutput-target-left"
-      }
-    ]
-  }
-}

packages/plugins/src/Doc2X/FilePDF2text/index.ts

@@ -1,165 +0,0 @@
-import { delay } from '@fastgpt/global/common/system/utils';
-import { addLog } from '@fastgpt/service/common/system/log';
-import { result } from 'lodash';
-
-type Props = {
-  apikey: string;
-  files: Array<string>;
-  ocr: boolean;
-};
-
-// Response type same as HTTP outputs
-type Response = Promise<{
-  result: string;
-  failreason: string;
-  success: boolean;
-}>;
-
-const main = async ({ apikey, files, ocr }: Props): Response => {
-  // Check the apikey
-  if (!apikey) {
-    return {
-      result: '',
-      failreason: `API key is required`,
-      success: false
-    };
-  }
-
-  let real_api_key = apikey;
-  if (!apikey.startsWith('sk-')) {
-    const response = await fetch('https://api.doc2x.noedgeai.com/api/token/refresh', {
-      method: 'POST',
-      headers: {
-        Authorization: `Bearer ${apikey}`
-      }
-    });
-    if (response.status !== 200) {
-      return {
-        result: '',
-        failreason: `Get token failed: ${await response.text()}`,
-        success: false
-      };
-    }
-    const data = await response.json();
-    real_api_key = data.data.token;
-  }
-
-  let final_result = '';
-  let fail_reason = '';
-  let flag = false;
-  //Process each file one by one
-  for await (const url of files) {
-    //Fetch the pdf and check its contene type
-    const PDFResponse = await fetch(url);
-    if (!PDFResponse.ok) {
-      fail_reason += `\n---\nFile:${url} \n<Content>\nFailed to fetch PDF from URL\n</Content>\n`;
-      flag = true;
-      continue;
-    }
-
-    const contentType = PDFResponse.headers.get('content-type');
-    const file_name = url.match(/read\?filename=([^&]+)/)?.[1] || 'unknown.pdf';
-    if (!contentType || !contentType.startsWith('application/pdf')) {
-      fail_reason += `\n---\nFile:${file_name}\n<Content>\nThe provided file does not point to a PDF: ${contentType}\n</Content>\n`;
-      flag = true;
-      continue;
-    }
-
-    const blob = await PDFResponse.blob();
-    const formData = new FormData();
-    formData.append('file', blob, file_name);
-    formData.append('ocr', ocr ? '1' : '0');
-
-    let upload_url = 'https://api.doc2x.noedgeai.com/api/platform/async/pdf';
-    if (real_api_key.startsWith('sk-')) {
-      upload_url = 'https://api.doc2x.noedgeai.com/api/v1/async/pdf';
-    }
-
-    let uuid;
-    let upload_flag = true;
-    const uploadAttempts = [1, 2, 3];
-    for await (const attempt of uploadAttempts) {
-      const upload_response = await fetch(upload_url, {
-        method: 'POST',
-        headers: {
-          Authorization: `Bearer ${real_api_key}`
-        },
-        body: formData
-      });
-      if (!upload_response.ok) {
-        // Rate limit, wait for 10s and retry at most 3 times
-        if (upload_response.status === 429 && attempt < 3) {
-          await delay(10000);
-          continue;
-        }
-        fail_reason += `\n---\nFile:${file_name}\n<Content>\nFailed to upload file: ${await upload_response.text()}\n</Content>\n`;
-        flag = true;
-        upload_flag = false;
-      }
-      if (!upload_flag) {
-        continue;
-      }
-      const upload_data = await upload_response.json();
-      uuid = upload_data.data.uuid;
-      break;
-    }
-
-    // Get the result by uuid
-    let result_url = 'https://api.doc2x.noedgeai.com/api/platform/async/status?uuid=' + uuid;
-    if (real_api_key.startsWith('sk-')) {
-      result_url = 'https://api.doc2x.noedgeai.com/api/v1/async/status?uuid=' + uuid;
-    }
-
-    let required_flag = true;
-    let result = '';
-    // Wait for the result, at most 100s
-    const maxAttempts = 100;
-    for await (const _ of Array(maxAttempts).keys()) {
-      const result_response = await fetch(result_url, {
-        headers: {
-          Authorization: `Bearer ${real_api_key}`
-        }
-      });
-      if (!result_response.ok) {
-        fail_reason += `\n---\nFile:${file_name}\n<Content>\nFailed to get result: ${await result_response.text()}\n</Content>\n`;
-        flag = true;
-        required_flag = false;
-        break;
-      }
-      const result_data = await result_response.json();
-      if (['ready', 'processing'].includes(result_data.data.status)) {
-        await delay(1000);
-      } else if (result_data.data.status === 'pages limit exceeded') {
-        fail_reason += `\n---\nFile:${file_name}\n<Content>\nPages limit exceeded\n</Content>\n`;
-        flag = true;
-        required_flag = false;
-        break;
-      } else if (result_data.data.status === 'success') {
-        result = await Promise.all(
-          result_data.data.result.pages.map((page: { md: any }) => page.md)
-        ).then((pages) => pages.join('\n'));
-        result = result.replace(/\\[\(\)]/g, '$').replace(/\\[\[\]]/g, '$$');
-        final_result += `\n---\nFile:${file_name}\n<Content>\n${result}\n</Content>\n`;
-        required_flag = false;
-        break;
-      } else {
-        fail_reason += `\n---\nFile:${file_name}\n<Content>\nFailed to get result: ${result_data.data.status}\n</Content>\n`;
-        flag = true;
-        required_flag = false;
-        break;
-      }
-    }
-    if (required_flag) {
-      fail_reason += `\n---\nFile:${file_name}\n<Content>\nTimeout after 100s for uuid ${uuid}\n</Content>\n`;
-      flag = true;
-    }
-  }
-
-  return {
-    result: final_result,
-    failreason: fail_reason,
-    success: !flag
-  };
-};
-
-export default main;

packages/plugins/src/Doc2X/PDF2text/index.ts

@@ -0,0 +1,256 @@
+import { delay } from '@fastgpt/global/common/system/utils';
+import axios from 'axios';
+import { getErrText } from '@fastgpt/global/common/error/utils';
+
+type Props = {
+  apikey: string;
+  HTMLtable: boolean;
+  files: string[];
+};
+
+// Response type same as HTTP outputs
+type Response = Promise<{
+  result: string;
+  success: boolean;
+  error?: Record<string, any>;
+}>;
+
+function processContent(content: string, HTMLtable: boolean): string {
+  if (HTMLtable) {
+    return content;
+  }
+  return content.replace(/<table>[\s\S]*?<\/table>/g, (htmlTable) => {
+    try {
+      // Clean up whitespace and newlines
+      const cleanHtml = htmlTable.replace(/\n\s*/g, '');
+      const rows = cleanHtml.match(/<tr>(.*?)<\/tr>/g);
+      if (!rows) return htmlTable;
+
+      // Parse table data
+      let tableData: string[][] = [];
+      let maxColumns = 0;
+
+      // Try to convert to markdown table
+      try {
+        rows.forEach((row, rowIndex) => {
+          if (!tableData[rowIndex]) {
+            tableData[rowIndex] = [];
+          }
+          let colIndex = 0;
+          const cells = row.match(/<td.*?>(.*?)<\/td>/g) || [];
+
+          cells.forEach((cell) => {
+            while (tableData[rowIndex][colIndex]) {
+              colIndex++;
+            }
+            const colspan = parseInt(cell.match(/colspan="(\d+)"/)?.[1] || '1');
+            const rowspan = parseInt(cell.match(/rowspan="(\d+)"/)?.[1] || '1');
+            const content = cell.replace(/<td.*?>|<\/td>/g, '').trim();
+
+            for (let i = 0; i < rowspan; i++) {
+              for (let j = 0; j < colspan; j++) {
+                if (!tableData[rowIndex + i]) {
+                  tableData[rowIndex + i] = [];
+                }
+                tableData[rowIndex + i][colIndex + j] = i === 0 && j === 0 ? content : '^^';
+              }
+            }
+            colIndex += colspan;
+            maxColumns = Math.max(maxColumns, colIndex);
+          });
+
+          for (let i = 0; i < maxColumns; i++) {
+            if (!tableData[rowIndex][i]) {
+              tableData[rowIndex][i] = ' ';
+            }
+          }
+        });
+        const chunks: string[] = [];
+
+        const headerCells = tableData[0]
+          .slice(0, maxColumns)
+          .map((cell) => (cell === '^^' ? ' ' : cell || ' '));
+        const headerRow = '| ' + headerCells.join(' | ') + ' |';
+        chunks.push(headerRow);
+
+        const separator = '| ' + Array(headerCells.length).fill('---').join(' | ') + ' |';
+        chunks.push(separator);
+
+        tableData.slice(1).forEach((row) => {
+          const paddedRow = row
+            .slice(0, maxColumns)
+            .map((cell) => (cell === '^^' ? ' ' : cell || ' '));
+          while (paddedRow.length < maxColumns) {
+            paddedRow.push(' ');
+          }
+          chunks.push('| ' + paddedRow.join(' | ') + ' |');
+        });
+
+        return chunks.join('\n');
+      } catch (error) {
+        return htmlTable;
+      }
+    } catch (error) {
+      return htmlTable;
+    }
+  });
+}
+
+const main = async ({ apikey, files, HTMLtable }: Props): Response => {
+  // Check the apikey
+  if (!apikey) {
+    return Promise.reject(`API key is required`);
+  }
+  const successResult = [];
+  const failedResult = [];
+
+  const axiosInstance = axios.create({
+    timeout: 30000 // 30 seconds timeout
+  });
+
+  //Process each file one by one
+  for await (const url of files) {
+    try {
+      //Fetch the pdf and check its content type
+      const PDFResponse = await axios
+        .get(url, {
+          responseType: 'arraybuffer',
+          proxy: false,
+          timeout: 20000
+        })
+        .catch((error) => {
+          throw new Error(`[Fetch PDF Error] Failed to fetch PDF: ${getErrText(error)}`);
+        });
+
+      if (PDFResponse.status !== 200) {
+        throw new Error(
+          `[Fetch PDF Error] Failed with status ${PDFResponse.status}: ${PDFResponse.data}`
+        );
+      }
+
+      const contentType = PDFResponse.headers['content-type'];
+      const file_name = url.match(/read\/([^?]+)/)?.[1] || 'unknown.pdf';
+      if (!contentType || !contentType.startsWith('application/pdf')) {
+        throw new Error(`The provided file does not point to a PDF: ${contentType}`);
+      }
+
+      const blob = new Blob([PDFResponse.data], { type: 'application/pdf' });
+      // Get pre-upload URL first
+      const preupload_response = await axiosInstance
+        .post('https://v2.doc2x.noedgeai.com/api/v2/parse/preupload', null, {
+          headers: {
+            Authorization: `Bearer ${apikey}`
+          }
+        })
+        .catch((error) => {
+          throw new Error(`[Pre-upload Error] Failed to get pre-upload URL: ${getErrText(error)}`);
+        });
+
+      if (preupload_response.status !== 200) {
+        throw new Error(`Failed to get pre-upload URL: ${preupload_response.data}`);
+      }
+
+      const preupload_data = preupload_response.data;
+      if (preupload_data.code !== 'success') {
+        throw new Error(`Failed to get pre-upload URL: ${JSON.stringify(preupload_data)}`);
+      }
+
+      const upload_url = preupload_data.data.url;
+      const uid = preupload_data.data.uid;
+      // Upload file to pre-signed URL with binary stream
+
+      const response = await axiosInstance
+        .put(upload_url, blob, {
+          headers: {
+            'Content-Type': 'application/pdf'
+          }
+        })
+        .catch((error) => {
+          throw new Error(`[Upload Error] Failed to upload file: ${getErrText(error)}`);
+        });
+
+      if (response.status !== 200) {
+        throw new Error(`Upload failed with status ${response.status}: ${response.statusText}`);
+      }
+
+      // Get the result by uid
+
+      // Wait for the result
+      const checkResult = async (retry = 20) => {
+        if (retry <= 0)
+          return Promise.reject(
+            `File:${file_name}\n<Content>\n[Parse Timeout Error] Failed to get result (uid: ${uid}): Process timeout\n</Content>`
+          );
+
+        try {
+          const result_response = await axiosInstance
+            .get(`https://v2.doc2x.noedgeai.com/api/v2/parse/status?uid=${uid}`, {
+              headers: {
+                Authorization: `Bearer ${apikey}`
+              }
+            })
+            .catch((error) => {
+              throw new Error(
+                `[Parse Status Error] Failed to get parse status: ${getErrText(error)}`
+              );
+            });
+
+          const result_data = result_response.data;
+          if (!['ok', 'success'].includes(result_data.code)) {
+            return Promise.reject(
+              `File:${file_name}\n<Content>\nFailed to get result (uid: ${uid}): ${JSON.stringify(result_data)}\n</Content>`
+            );
+          }
+
+          if (['ready', 'processing'].includes(result_data.data.status)) {
+            await delay(4000);
+            return checkResult(retry - 1);
+          }
+
+          if (result_data.data.status === 'success') {
+            const result = processContent(
+              await Promise.all(
+                result_data.data.result.pages.map((page: { md: any }) => page.md)
+              ).then((pages) => pages.join('\n')),
+              HTMLtable
+            )
+              // Do some post-processing
+              .replace(/\\[\(\)]/g, '$')
+              .replace(/\\[\[\]]/g, '$$')
+              .replace(/<img\s+src="([^"]+)"(?:\s*\?[^>]*)?(?:\s*\/>|>)/g, '![img]($1)')
+              .replace(/<!-- Media -->/g, '')
+              .replace(/<!-- Footnote -->/g, '')
+              .replace(/\$(.+?)\s+\\tag\{(.+?)\}\$/g, '$$$1 \\qquad \\qquad ($2)$$')
+              .replace(/\\text\{([^}]*?)(\b\w+)_(\w+\b)([^}]*?)\}/g, '\\text{$1$2\\_$3$4}');
+
+            return `File:${file_name}\n<Content>\n${result}\n</Content>`;
+          }
+          return checkResult(retry - 1);
+        } catch (error) {
+          if (retry > 1) {
+            await delay(100);
+            return checkResult(retry - 1);
+          }
+          throw error;
+        }
+      };
+
+      const result = await checkResult();
+      successResult.push(result);
+    } catch (error) {
+      failedResult.push(
+        `File:${url} \n<Content>\nFailed to fetch file from URL: ${getErrText(error)}\n</Content>`
+      );
+    }
+  }
+
+  return {
+    result: successResult.join('\n******\n'),
+    error: {
+      message: failedResult.join('\n******\n')
+    },
+    success: failedResult.length === 0
+  };
+};
+
+export default main;

packages/plugins/src/Doc2X/PDF2text/template.json

@@ -1,42 +1,26 @@
 {
   "author": "Menghuan1918",
   "version": "488",
-  "name": "Doc2X PDF文件(文件)识别",
+  "name": "PDF识别",
   "avatar": "plugins/doc2x",
-  "intro": "将上传的PDF文件发送至Doc2X进行解析，返回带LaTeX公式的markdown格式的文本",
+  "intro": "将PDF文件发送至Doc2X进行解析，返回结构化的LaTeX公式的文本(markdown)，支持传入String类型的URL或者流程输出中的文件链接变量",
   "courseUrl": "https://fael3z0zfze.feishu.cn/wiki/Rkc5witXWiJoi5kORd2cofh6nDg?fromScene=spaceOverview",
   "showStatus": true,
   "weight": 10,
-
   "isTool": true,
   "templateType": "tools",
-
   "workflow": {
     "nodes": [
-      {
-        "nodeId": "pluginConfig",
-        "name": "common:core.module.template.system_config",
-        "intro": "",
-        "avatar": "core/workflow/template/systemConfig",
-        "flowNodeType": "pluginConfig",
-        "position": {
-          "x": -30.474351356537454,
-          "y": -101.45216221730038
-        },
-        "version": "4811",
-        "inputs": [],
-        "outputs": []
-      },
       {
         "nodeId": "pluginInput",
-        "name": "插件开始",
+        "name": "自定义插件输入",
         "intro": "可以配置插件需要哪些输入，利用这些输入来运行插件",
         "avatar": "core/workflow/template/workflowStart",
         "flowNodeType": "pluginInput",
         "showStatus": false,
         "position": {
-          "x": 407.2817920483865,
+          "x": -137.96875104510553,
-          "y": -101.45216221730038
+          "y": -90.9968973555371
         },
         "version": "481",
         "inputs": [
@@ -47,33 +31,45 @@
             "canEdit": true,
             "key": "apikey",
             "label": "apikey",
-            "description": "Doc2X的验证密匙，对于个人用户可以从Doc2X官网 - 个人信息 - 身份令牌获得",
+            "description": "Doc2X的API密匙，可以从Doc2X开放平台获得",
             "required": true,
-            "toolDescription": "",
+            "defaultValue": "",
-            "defaultValue": ""
+            "list": []
           },
           {
-            "renderTypeList": ["reference"],
+            "renderTypeList": ["fileSelect"],
             "selectedTypeIndex": 0,
             "valueType": "arrayString",
             "canEdit": true,
             "key": "files",
             "label": "files",
-            "description": "待处理的PDF文件",
+            "description": "需要处理的PDF地址",
             "required": true,
-            "toolDescription": "待处理的PDF文件"
+            "list": [],
+            "canSelectFile": true,
+            "canSelectImg": false,
+            "maxFiles": 14,
+            "defaultValue": ""
           },
           {
-            "renderTypeList": ["switch"],
+            "renderTypeList": ["switch", "reference"],
             "selectedTypeIndex": 0,
             "valueType": "boolean",
             "canEdit": true,
-            "key": "ocr",
+            "key": "HTMLtable",
-            "label": "ocr",
+            "label": "HTMLtable",
-            "description": "是否开启对PDF文件内图片的OCR识别，建议开启",
+            "description": "是否以HTML格式输出表格。如果需要精确地输出表格，请打开此开关以使用HTML格式。关闭后，表格将转换为Markdown形式输出，但这可能会损失一些表格特性，如合并单元格。",
-            "required": true,
+            "defaultValue": false,
-            "toolDescription": "",
+            "list": [
-            "defaultValue": true
+              {
+                "label": "",
+                "value": ""
+              }
+            ],
+            "maxFiles": 5,
+            "canSelectFile": true,
+            "canSelectImg": true,
+            "required": true
           }
         ],
         "outputs": [
@@ -92,24 +88,24 @@
             "type": "hidden"
           },
           {
-            "id": "formula",
+            "id": "htmltable",
             "valueType": "boolean",
-            "key": "ocr",
+            "key": "HTMLtable",
-            "label": "ocr",
+            "label": "HTMLtable",
             "type": "hidden"
           }
         ]
       },
       {
         "nodeId": "pluginOutput",
-        "name": "插件输出",
+        "name": "自定义插件输出",
         "intro": "自定义配置外部输出，使用插件时，仅暴露自定义配置的输出",
         "avatar": "core/workflow/template/pluginOutput",
         "flowNodeType": "pluginOutput",
         "showStatus": false,
         "position": {
-          "x": 1842.070888321717,
+          "x": 1505.494975310334,
-          "y": -101.45216221730038
+          "y": -4.14668564643415
         },
         "version": "481",
         "inputs": [
@@ -124,12 +120,13 @@
           },
           {
             "renderTypeList": ["reference"],
-            "valueType": "string",
+            "valueType": "object",
             "canEdit": true,
-            "key": "failreason",
+            "key": "error",
-            "label": "failreason",
+            "label": "error",
-            "description": "文件处理失败原因，由文件名以及报错组成，多个文件之间由横线分隔开",
+            "description": "",
-            "value": ["zHG5jJBkXmjB", "yDxzW5CFalGw"]
+            "value": ["zHG5jJBkXmjB", "httpRawResponse"],
+            "isToolOutput": true
           },
           {
             "renderTypeList": ["reference"],
@@ -138,7 +135,8 @@
             "key": "success",
             "label": "success",
             "description": "是否全部文件都处理成功，如有没有处理成功的文件，失败原因将会输出在failreason中",
-            "value": ["zHG5jJBkXmjB", "m6CJJj7GFud5"]
+            "value": ["zHG5jJBkXmjB", "m6CJJj7GFud5"],
+            "isToolOutput": false
           }
         ],
         "outputs": []
@@ -151,8 +149,8 @@
         "flowNodeType": "httpRequest468",
         "showStatus": true,
         "position": {
-          "x": 1077.7986740892777,
+          "x": 619.0661933308237,
-          "y": -496.9521622173004
+          "y": -472.91377894611503
         },
         "version": "481",
         "inputs": [
@@ -202,7 +200,7 @@
             "renderTypeList": ["custom"],
             "valueType": "number",
             "label": "",
-            "value": 30,
+            "value": 300,
             "min": 5,
             "max": 600,
             "required": true,
@@ -217,7 +215,7 @@
             "description": "common:core.module.input.description.Http Request Url",
             "placeholder": "https://api.ai.com/getInventory",
             "required": false,
-            "value": "Doc2X/FilePDF2text",
+            "value": "Doc2X/PDF2text",
             "debugLabel": "",
             "toolDescription": ""
           },
@@ -247,7 +245,7 @@
             "key": "system_httpJsonBody",
             "renderTypeList": ["hidden"],
             "valueType": "any",
-            "value": "{\n  \"apikey\": \"{{apikey}}\",\n  \"files\": {{files}},\n  \"ocr\": {{ocr}}\n}",
+            "value": "{\n  \"apikey\": \"{{apikey}}\",\n  \"HTMLtable\": {{HTMLtable}},\n  \"files\": {{files}}\n}",
             "label": "",
             "required": false,
             "debugLabel": "",
@@ -331,14 +329,14 @@
               "showDefaultValue": true
             },
             "required": true,
-            "value": ["pluginInput", "url"]
+            "value": [["pluginInput", "url"]]
           },
           {
             "renderTypeList": ["reference"],
             "valueType": "boolean",
             "canEdit": true,
-            "key": "ocr",
+            "key": "HTMLtable",
-            "label": "ocr",
+            "label": "HTMLtable",
             "customInputConfig": {
               "selectValueTypeList": [
                 "string",
@@ -361,7 +359,7 @@
               "showDefaultValue": true
             },
             "required": true,
-            "value": ["pluginInput", "formula"]
+            "value": ["pluginInput", "htmltable"]
           }
         ],
         "outputs": [
@@ -422,30 +420,42 @@
             "type": "dynamic",
             "key": "success",
             "label": "success"
-          },
-          {
-            "id": "yDxzW5CFalGw",
-            "valueType": "string",
-            "type": "dynamic",
-            "key": "failreason",
-            "label": "failreason"
           }
         ]
       }
     ],
     "edges": [
-      {
-        "source": "pluginInput",
-        "target": "zHG5jJBkXmjB",
-        "sourceHandle": "pluginInput-source-right",
-        "targetHandle": "zHG5jJBkXmjB-target-left"
-      },
       {
         "source": "zHG5jJBkXmjB",
         "target": "pluginOutput",
         "sourceHandle": "zHG5jJBkXmjB-source-right",
         "targetHandle": "pluginOutput-target-left"
+      },
+      {
+        "source": "pluginInput",
+        "target": "zHG5jJBkXmjB",
+        "sourceHandle": "pluginInput-source-right",
+        "targetHandle": "zHG5jJBkXmjB-target-left"
       }
-    ]
+    ],
+    "chatConfig": {
+      "questionGuide": false,
+      "ttsConfig": {
+        "type": "web"
+      },
+      "whisperConfig": {
+        "open": false,
+        "autoSend": false,
+        "autoTTSResponse": false
+      },
+      "chatInputGuide": {
+        "open": false,
+        "textList": [],
+        "customUrl": ""
+      },
+      "instruction": "",
+      "variables": [],
+      "welcomeText": ""
+    }
   }
 }

packages/plugins/src/Doc2X/URLImg2text/index.ts

@@ -1,166 +0,0 @@
-import { delay } from '@fastgpt/global/common/system/utils';
-import { addLog } from '@fastgpt/service/common/system/log';
-
-type Props = {
-  apikey: string;
-  url: string;
-  img_correction: boolean;
-  formula: boolean;
-};
-
-type Response = Promise<{
-  result: string;
-  success: boolean;
-}>;
-
-const main = async ({ apikey, url, img_correction, formula }: Props): Response => {
-  // Check the apikey
-  if (!apikey) {
-    return {
-      result: `API key is required`,
-      success: false
-    };
-  }
-
-  let real_api_key = apikey;
-  if (!apikey.startsWith('sk-')) {
-    const response = await fetch('https://api.doc2x.noedgeai.com/api/token/refresh', {
-      method: 'POST',
-      headers: {
-        Authorization: `Bearer ${apikey}`
-      }
-    });
-    if (response.status !== 200) {
-      return {
-        result: `Get token failed: ${await response.text()}`,
-        success: false
-      };
-    }
-    const data = await response.json();
-    real_api_key = data.data.token;
-  }
-
-  let imageResponse;
-  // Fetch the image and check its content type
-  try {
-    imageResponse = await fetch(url);
-  } catch (e) {
-    return {
-      result: `Failed to fetch image from URL: ${url} with error: ${e}`,
-      success: false
-    };
-  }
-
-  if (!imageResponse.ok) {
-    return {
-      result: `Failed to fetch image from URL: ${url}`,
-      success: false
-    };
-  }
-
-  const contentType = imageResponse.headers.get('content-type');
-  if (!contentType || !contentType.startsWith('image/')) {
-    return {
-      result: `The provided URL does not point to an image: ${contentType}`,
-      success: false
-    };
-  }
-
-  const blob = await imageResponse.blob();
-  const formData = new FormData();
-  const fileName = url.split('/').pop()?.split('?')[0] || 'image';
-  formData.append('file', blob, fileName);
-  formData.append('img_correction', img_correction ? '1' : '0');
-  formData.append('equation', formula ? '1' : '0');
-
-  let upload_url = 'https://api.doc2x.noedgeai.com/api/platform/async/img';
-  if (real_api_key.startsWith('sk-')) {
-    upload_url = 'https://api.doc2x.noedgeai.com/api/v1/async/img';
-  }
-
-  let uuid;
-  const uploadAttempts = [1, 2, 3];
-  for await (const attempt of uploadAttempts) {
-    const upload_response = await fetch(upload_url, {
-      method: 'POST',
-      headers: {
-        Authorization: `Bearer ${real_api_key}`
-      },
-      body: formData
-    });
-
-    if (!upload_response.ok) {
-      // Rate limit, wait for 10s and retry at most 3 times
-      if (upload_response.status === 429 && attempt < 3) {
-        await delay(10000);
-        continue;
-      }
-      return {
-        result: `Failed to upload image: ${await upload_response.text()}`,
-        success: false
-      };
-    }
-
-    const upload_data = await upload_response.json();
-    uuid = upload_data.data.uuid;
-    break;
-  }
-
-  // Get the result by uuid
-  let result_url = 'https://api.doc2x.noedgeai.com/api/platform/async/status?uuid=' + uuid;
-  if (real_api_key.startsWith('sk-')) {
-    result_url = 'https://api.doc2x.noedgeai.com/api/v1/async/status?uuid=' + uuid;
-  }
-  const maxAttempts = 100;
-  // Wait for the result, at most 100s
-  for await (const _ of Array(maxAttempts).keys()) {
-    const result_response = await fetch(result_url, {
-      headers: {
-        Authorization: `Bearer ${real_api_key}`
-      }
-    });
-    if (!result_response.ok) {
-      return {
-        result: `Failed to get result: ${await result_response.text()}`,
-        success: false
-      };
-    }
-    const result_data = await result_response.json();
-    if (['ready', 'processing'].includes(result_data.data.status)) {
-      await delay(1000);
-    } else if (result_data.data.status === 'pages limit exceeded') {
-      return {
-        result: 'Doc2X Pages limit exceeded',
-        success: false
-      };
-    } else if (result_data.data.status === 'success') {
-      let result;
-      try {
-        result = result_data.data.result.pages[0].md;
-        result = result.replace(/\\[\(\)]/g, '$').replace(/\\[\[\]]/g, '$$');
-      } catch {
-        // no pages
-        return {
-          result: '',
-          success: true
-        };
-      }
-      return {
-        result: result,
-        success: true
-      };
-    } else {
-      return {
-        result: `Failed to get result: ${await result_data.text()}`,
-        success: false
-      };
-    }
-  }
-
-  return {
-    result: 'Timeout waiting for result',
-    success: false
-  };
-};
-
-export default main;

packages/plugins/src/Doc2X/URLImg2text/template.json

@@ -1,484 +0,0 @@
-{
-  "author": "Menghuan1918",
-  "version": "488",
-  "name": "Doc2X 图像(URL)识别",
-  "avatar": "plugins/doc2x",
-  "intro": "从URL下载图片并发送至Doc2X进行解析，返回带LaTeX公式的markdown格式的文本",
-  "courseUrl": "https://fael3z0zfze.feishu.cn/wiki/Rkc5witXWiJoi5kORd2cofh6nDg?fromScene=spaceOverview",
-  "showStatus": true,
-  "weight": 10,
-
-  "isTool": true,
-  "templateType": "tools",
-
-  "workflow": {
-    "nodes": [
-      {
-        "nodeId": "pluginInput",
-        "name": "插件开始",
-        "intro": "可以配置插件需要哪些输入，利用这些输入来运行插件",
-        "avatar": "core/workflow/template/workflowStart",
-        "flowNodeType": "pluginInput",
-        "showStatus": false,
-        "position": {
-          "x": 353.91678143999377,
-          "y": -75.09744210499466
-        },
-        "version": "481",
-        "inputs": [
-          {
-            "renderTypeList": ["input"],
-            "selectedTypeIndex": 0,
-            "valueType": "string",
-            "canEdit": true,
-            "key": "apikey",
-            "label": "apikey",
-            "description": "Doc2X的验证密匙，对于个人用户可以从Doc2X官网 - 个人信息 - 身份令牌获得",
-            "required": true,
-            "toolDescription": "",
-            "defaultValue": ""
-          },
-          {
-            "renderTypeList": ["reference"],
-            "selectedTypeIndex": 0,
-            "valueType": "string",
-            "canEdit": true,
-            "key": "url",
-            "label": "url",
-            "description": "待处理图片的URL",
-            "required": true,
-            "toolDescription": "待处理图片的URL"
-          },
-          {
-            "renderTypeList": ["switch"],
-            "selectedTypeIndex": 0,
-            "valueType": "boolean",
-            "canEdit": true,
-            "key": "img_correction",
-            "label": "img_correction",
-            "description": "是否启用图形矫正功能",
-            "required": true,
-            "toolDescription": "",
-            "defaultValue": false
-          },
-          {
-            "renderTypeList": ["switch"],
-            "selectedTypeIndex": 0,
-            "valueType": "boolean",
-            "canEdit": true,
-            "key": "formula",
-            "label": "formula",
-            "description": "是否开启纯公式识别(仅适用于图片内容仅有公式时)",
-            "required": true,
-            "toolDescription": "",
-            "defaultValue": false
-          }
-        ],
-        "outputs": [
-          {
-            "id": "apikey",
-            "valueType": "string",
-            "key": "apikey",
-            "label": "apikey",
-            "type": "hidden"
-          },
-          {
-            "id": "url",
-            "valueType": "string",
-            "key": "url",
-            "label": "url",
-            "type": "hidden"
-          },
-          {
-            "id": "img_correction",
-            "valueType": "boolean",
-            "key": "img_correction",
-            "label": "img_correction",
-            "type": "hidden"
-          },
-          {
-            "id": "formula",
-            "valueType": "boolean",
-            "key": "formula",
-            "label": "formula",
-            "type": "hidden"
-          }
-        ]
-      },
-      {
-        "nodeId": "pluginOutput",
-        "name": "插件输出",
-        "intro": "自定义配置外部输出，使用插件时，仅暴露自定义配置的输出",
-        "avatar": "core/workflow/template/pluginOutput",
-        "flowNodeType": "pluginOutput",
-        "showStatus": false,
-        "position": {
-          "x": 1703.581616889916,
-          "y": -14.097442104994656
-        },
-        "version": "481",
-        "inputs": [
-          {
-            "renderTypeList": ["reference"],
-            "valueType": "string",
-            "canEdit": true,
-            "key": "result",
-            "label": "result",
-            "description": "处理结果(或者是报错信息)",
-            "value": ["zHG5jJBkXmjB", "xWQuEf50F3mr"]
-          },
-          {
-            "renderTypeList": ["reference"],
-            "valueType": "boolean",
-            "canEdit": true,
-            "key": "success",
-            "label": "success",
-            "description": "是否处理成功",
-            "value": ["zHG5jJBkXmjB", "m6CJJj7GFud5"]
-          }
-        ],
-        "outputs": []
-      },
-      {
-        "nodeId": "zHG5jJBkXmjB",
-        "name": "HTTP 请求",
-        "intro": "可以发出一个 HTTP 请求，实现更为复杂的操作（联网搜索、数据库查询等）",
-        "avatar": "core/workflow/template/httpRequest",
-        "flowNodeType": "httpRequest468",
-        "showStatus": true,
-        "position": {
-          "x": 1000.6685388413375,
-          "y": -457.0974421049947
-        },
-        "version": "481",
-        "inputs": [
-          {
-            "key": "system_addInputParam",
-            "renderTypeList": ["addInputParam"],
-            "valueType": "dynamic",
-            "label": "",
-            "required": false,
-            "description": "common:core.module.input.description.HTTP Dynamic Input",
-            "customInputConfig": {
-              "selectValueTypeList": [
-                "string",
-                "number",
-                "boolean",
-                "object",
-                "arrayString",
-                "arrayNumber",
-                "arrayBoolean",
-                "arrayObject",
-                "arrayAny",
-                "any",
-                "chatHistory",
-                "datasetQuote",
-                "dynamic",
-                "selectApp",
-                "selectDataset"
-              ],
-              "showDescription": false,
-              "showDefaultValue": true
-            },
-            "debugLabel": "",
-            "toolDescription": ""
-          },
-          {
-            "key": "system_httpMethod",
-            "renderTypeList": ["custom"],
-            "valueType": "string",
-            "label": "",
-            "value": "POST",
-            "required": true,
-            "debugLabel": "",
-            "toolDescription": ""
-          },
-          {
-            "key": "system_httpTimeout",
-            "renderTypeList": ["custom"],
-            "valueType": "number",
-            "label": "",
-            "value": 30,
-            "min": 5,
-            "max": 600,
-            "required": true,
-            "debugLabel": "",
-            "toolDescription": ""
-          },
-          {
-            "key": "system_httpReqUrl",
-            "renderTypeList": ["hidden"],
-            "valueType": "string",
-            "label": "",
-            "description": "common:core.module.input.description.Http Request Url",
-            "placeholder": "https://api.ai.com/getInventory",
-            "required": false,
-            "value": "Doc2X/URLImg2text",
-            "debugLabel": "",
-            "toolDescription": ""
-          },
-          {
-            "key": "system_httpHeader",
-            "renderTypeList": ["custom"],
-            "valueType": "any",
-            "value": [],
-            "label": "",
-            "description": "common:core.module.input.description.Http Request Header",
-            "placeholder": "common:core.module.input.description.Http Request Header",
-            "required": false,
-            "debugLabel": "",
-            "toolDescription": ""
-          },
-          {
-            "key": "system_httpParams",
-            "renderTypeList": ["hidden"],
-            "valueType": "any",
-            "value": [],
-            "label": "",
-            "required": false,
-            "debugLabel": "",
-            "toolDescription": ""
-          },
-          {
-            "key": "system_httpJsonBody",
-            "renderTypeList": ["hidden"],
-            "valueType": "any",
-            "value": "{\n  \"apikey\": \"{{apikey}}\",\n  \"url\": \"{{url}}\",\n  \"img_correction\": {{img_correction}},\n  \"formula\": {{formula}}\n}",
-            "label": "",
-            "required": false,
-            "debugLabel": "",
-            "toolDescription": ""
-          },
-          {
-            "key": "system_httpFormBody",
-            "renderTypeList": ["hidden"],
-            "valueType": "any",
-            "value": [],
-            "label": "",
-            "required": false,
-            "debugLabel": "",
-            "toolDescription": ""
-          },
-          {
-            "key": "system_httpContentType",
-            "renderTypeList": ["hidden"],
-            "valueType": "string",
-            "value": "json",
-            "label": "",
-            "required": false,
-            "debugLabel": "",
-            "toolDescription": ""
-          },
-          {
-            "renderTypeList": ["reference"],
-            "valueType": "string",
-            "canEdit": true,
-            "key": "apikey",
-            "label": "apikey",
-            "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", "apikey"]
-          },
-          {
-            "renderTypeList": ["reference"],
-            "valueType": "string",
-            "canEdit": true,
-            "key": "url",
-            "label": "url",
-            "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", "url"]
-          },
-          {
-            "renderTypeList": ["reference"],
-            "valueType": "boolean",
-            "canEdit": true,
-            "key": "img_correction",
-            "label": "img_correction",
-            "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", "img_correction"]
-          },
-          {
-            "renderTypeList": ["reference"],
-            "valueType": "boolean",
-            "canEdit": true,
-            "key": "formula",
-            "label": "formula",
-            "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", "formula"]
-          }
-        ],
-        "outputs": [
-          {
-            "id": "error",
-            "key": "error",
-            "label": "workflow:request_error",
-            "description": "HTTP请求错误信息，成功时返回空",
-            "valueType": "object",
-            "type": "static"
-          },
-          {
-            "id": "httpRawResponse",
-            "key": "httpRawResponse",
-            "required": true,
-            "label": "workflow:raw_response",
-            "description": "HTTP请求的原始响应。只能接受字符串或JSON类型响应数据。",
-            "valueType": "any",
-            "type": "static"
-          },
-          {
-            "id": "system_addOutputParam",
-            "key": "system_addOutputParam",
-            "type": "dynamic",
-            "valueType": "dynamic",
-            "label": "",
-            "customFieldConfig": {
-              "selectValueTypeList": [
-                "string",
-                "number",
-                "boolean",
-                "object",
-                "arrayString",
-                "arrayNumber",
-                "arrayBoolean",
-                "arrayObject",
-                "any",
-                "chatHistory",
-                "datasetQuote",
-                "dynamic",
-                "selectApp",
-                "selectDataset"
-              ],
-              "showDescription": false,
-              "showDefaultValue": false
-            }
-          },
-          {
-            "id": "xWQuEf50F3mr",
-            "valueType": "string",
-            "type": "dynamic",
-            "key": "result",
-            "label": "result"
-          },
-          {
-            "id": "m6CJJj7GFud5",
-            "valueType": "boolean",
-            "type": "dynamic",
-            "key": "success",
-            "label": "success"
-          }
-        ]
-      },
-      {
-        "nodeId": "sWEDDSeuI9ar",
-        "name": "系统配置",
-        "intro": "",
-        "avatar": "core/workflow/template/systemConfig",
-        "flowNodeType": "pluginConfig",
-        "position": {
-          "x": -117.03701176267538,
-          "y": -75.09744210499466
-        },
-        "version": "4811",
-        "inputs": [],
-        "outputs": []
-      }
-    ],
-    "edges": [
-      {
-        "source": "pluginInput",
-        "target": "zHG5jJBkXmjB",
-        "sourceHandle": "pluginInput-source-right",
-        "targetHandle": "zHG5jJBkXmjB-target-left"
-      },
-      {
-        "source": "zHG5jJBkXmjB",
-        "target": "pluginOutput",
-        "sourceHandle": "zHG5jJBkXmjB-source-right",
-        "targetHandle": "pluginOutput-target-left"
-      }
-    ]
-  }
-}

packages/plugins/src/Doc2X/URLPDF2text/index.ts

@@ -1,156 +0,0 @@
-import { delay } from '@fastgpt/global/common/system/utils';
-import { addLog } from '@fastgpt/service/common/system/log';
-
-type Props = {
-  apikey: string;
-  url: string;
-  ocr: boolean;
-};
-
-// Response type same as HTTP outputs
-type Response = Promise<{
-  result: string;
-  success: boolean;
-}>;
-
-const main = async ({ apikey, url, ocr }: Props): Response => {
-  // Check the apikey
-  if (!apikey) {
-    return {
-      result: `API key is required`,
-      success: false
-    };
-  }
-
-  let real_api_key = apikey;
-  if (!apikey.startsWith('sk-')) {
-    const response = await fetch('https://api.doc2x.noedgeai.com/api/token/refresh', {
-      method: 'POST',
-      headers: {
-        Authorization: `Bearer ${apikey}`
-      }
-    });
-    if (response.status !== 200) {
-      return {
-        result: `Get token failed: ${await response.text()}`,
-        success: false
-      };
-    }
-    const data = await response.json();
-    real_api_key = data.data.token;
-  }
-
-  //Fetch the pdf and check its contene type
-  let PDFResponse;
-  try {
-    PDFResponse = await fetch(url);
-  } catch (e) {
-    return {
-      result: `Failed to fetch PDF from URL: ${url} with error: ${e}`,
-      success: false
-    };
-  }
-  if (!PDFResponse.ok) {
-    return {
-      result: `Failed to fetch PDF from URL: ${url}`,
-      success: false
-    };
-  }
-
-  const contentType = PDFResponse.headers.get('content-type');
-  if (!contentType || !contentType.startsWith('application/pdf')) {
-    return {
-      result: `The provided URL does not point to a PDF: ${contentType}`,
-      success: false
-    };
-  }
-
-  const blob = await PDFResponse.blob();
-  const formData = new FormData();
-  const fileName = url.split('/').pop()?.split('?')[0] || 'pdf';
-  formData.append('file', blob, fileName);
-  formData.append('ocr', ocr ? '1' : '0');
-
-  let upload_url = 'https://api.doc2x.noedgeai.com/api/platform/async/pdf';
-  if (real_api_key.startsWith('sk-')) {
-    upload_url = 'https://api.doc2x.noedgeai.com/api/v1/async/pdf';
-  }
-
-  let uuid;
-  const uploadAttempts = [1, 2, 3];
-  for await (const attempt of uploadAttempts) {
-    const upload_response = await fetch(upload_url, {
-      method: 'POST',
-      headers: {
-        Authorization: `Bearer ${real_api_key}`
-      },
-      body: formData
-    });
-    if (!upload_response.ok) {
-      if (upload_response.status === 429 && attempt < 3) {
-        await delay(10000);
-        continue;
-      }
-      return {
-        result: `Failed to upload file: ${await upload_response.text()}`,
-        success: false
-      };
-    }
-    const upload_data = await upload_response.json();
-    uuid = upload_data.data.uuid;
-    break;
-  }
-
-  // Get the result by uuid
-  let result_url = 'https://api.doc2x.noedgeai.com/api/platform/async/status?uuid=' + uuid;
-  if (real_api_key.startsWith('sk-')) {
-    result_url = 'https://api.doc2x.noedgeai.com/api/v1/async/status?uuid=' + uuid;
-  }
-
-  let result = '';
-  // Wait for the result, at most 100s
-  const maxAttempts = 100;
-  for await (const _ of Array(maxAttempts).keys()) {
-    const result_response = await fetch(result_url, {
-      headers: {
-        Authorization: `Bearer ${real_api_key}`
-      }
-    });
-    if (!result_response.ok) {
-      return {
-        result: `Failed to get result: ${await result_response.text()}`,
-        success: false
-      };
-    }
-    const result_data = await result_response.json();
-    if (['ready', 'processing'].includes(result_data.data.status)) {
-      await delay(1000);
-    } else if (result_data.data.status === 'pages limit exceeded') {
-      return {
-        result: 'Doc2X Pages limit exceeded',
-        success: false
-      };
-    } else if (result_data.data.status === 'success') {
-      result = await Promise.all(
-        result_data.data.result.pages.map((page: { md: any }) => page.md)
-      ).then((pages) => pages.join('\n'));
-      result = result.replace(/\\[\(\)]/g, '$').replace(/\\[\[\]]/g, '$$');
-      return {
-        result: result,
-        success: true
-      };
-    } else {
-      return {
-        result: `Failed to get result: ${await result_data.text()}`,
-        success: false
-      };
-    }
-  }
-
-  return {
-    result: 'Timeout waiting for result',
-    success: false
-  };
-};
-
-export default main;

packages/plugins/src/Doc2X/URLPDF2text/template.json

@@ -1,435 +0,0 @@
-{
-  "author": "Menghuan1918",
-  "version": "488",
-  "name": "Doc2X PDF文件(URL)识别",
-  "avatar": "plugins/doc2x",
-  "intro": "从URL下载PDF文件，并发送至Doc2X进行解析，返回带LaTeX公式的markdown格式的文本",
-  "courseUrl": "https://fael3z0zfze.feishu.cn/wiki/Rkc5witXWiJoi5kORd2cofh6nDg?fromScene=spaceOverview",
-  "showStatus": true,
-  "weight": 10,
-
-  "isTool": true,
-  "templateType": "tools",
-
-  "workflow": {
-    "nodes": [
-      {
-        "nodeId": "pluginInput",
-        "name": "插件开始",
-        "intro": "可以配置插件需要哪些输入，利用这些输入来运行插件",
-        "avatar": "core/workflow/template/workflowStart",
-        "flowNodeType": "pluginInput",
-        "showStatus": false,
-        "position": {
-          "x": 388.243055058894,
-          "y": -75.09744210499466
-        },
-        "version": "481",
-        "inputs": [
-          {
-            "renderTypeList": ["input"],
-            "selectedTypeIndex": 0,
-            "valueType": "string",
-            "canEdit": true,
-            "key": "apikey",
-            "label": "apikey",
-            "description": "Doc2X的验证密匙，对于个人用户可以从Doc2X官网 - 个人信息 - 身份令牌获得",
-            "required": true,
-            "toolDescription": "",
-            "defaultValue": ""
-          },
-          {
-            "renderTypeList": ["reference"],
-            "selectedTypeIndex": 0,
-            "valueType": "string",
-            "canEdit": true,
-            "key": "url",
-            "label": "url",
-            "description": "待处理PDF文件的URL",
-            "required": true,
-            "toolDescription": "待处理PDF文件的URL"
-          },
-          {
-            "renderTypeList": ["switch"],
-            "selectedTypeIndex": 0,
-            "valueType": "boolean",
-            "canEdit": true,
-            "key": "ocr",
-            "label": "ocr",
-            "description": "是否开启对PDF文件内图片的OCR识别，建议开启",
-            "required": true,
-            "toolDescription": "",
-            "defaultValue": true
-          }
-        ],
-        "outputs": [
-          {
-            "id": "apikey",
-            "valueType": "string",
-            "key": "apikey",
-            "label": "apikey",
-            "type": "hidden"
-          },
-          {
-            "id": "url",
-            "valueType": "string",
-            "key": "url",
-            "label": "url",
-            "type": "hidden"
-          },
-          {
-            "id": "formula",
-            "valueType": "boolean",
-            "key": "ocr",
-            "label": "ocr",
-            "type": "hidden"
-          }
-        ]
-      },
-      {
-        "nodeId": "pluginOutput",
-        "name": "插件输出",
-        "intro": "自定义配置外部输出，使用插件时，仅暴露自定义配置的输出",
-        "avatar": "core/workflow/template/pluginOutput",
-        "flowNodeType": "pluginOutput",
-        "showStatus": false,
-        "position": {
-          "x": 1665.6420513111314,
-          "y": -40.597442104994656
-        },
-        "version": "481",
-        "inputs": [
-          {
-            "renderTypeList": ["reference"],
-            "valueType": "string",
-            "canEdit": true,
-            "key": "result",
-            "label": "result",
-            "description": "处理结果(或者是报错信息)",
-            "value": ["zHG5jJBkXmjB", "xWQuEf50F3mr"]
-          },
-          {
-            "renderTypeList": ["reference"],
-            "valueType": "boolean",
-            "canEdit": true,
-            "key": "success",
-            "label": "success",
-            "description": "是否处理成功",
-            "value": ["zHG5jJBkXmjB", "m6CJJj7GFud5"]
-          }
-        ],
-        "outputs": []
-      },
-      {
-        "nodeId": "zHG5jJBkXmjB",
-        "name": "HTTP 请求",
-        "intro": "可以发出一个 HTTP 请求，实现更为复杂的操作（联网搜索、数据库查询等）",
-        "avatar": "core/workflow/template/httpRequest",
-        "flowNodeType": "httpRequest468",
-        "showStatus": true,
-        "position": {
-          "x": 966.3422652224374,
-          "y": -446.5974421049947
-        },
-        "version": "481",
-        "inputs": [
-          {
-            "key": "system_addInputParam",
-            "renderTypeList": ["addInputParam"],
-            "valueType": "dynamic",
-            "label": "",
-            "required": false,
-            "description": "common:core.module.input.description.HTTP Dynamic Input",
-            "customInputConfig": {
-              "selectValueTypeList": [
-                "string",
-                "number",
-                "boolean",
-                "object",
-                "arrayString",
-                "arrayNumber",
-                "arrayBoolean",
-                "arrayObject",
-                "arrayAny",
-                "any",
-                "chatHistory",
-                "datasetQuote",
-                "dynamic",
-                "selectApp",
-                "selectDataset"
-              ],
-              "showDescription": false,
-              "showDefaultValue": true
-            },
-            "debugLabel": "",
-            "toolDescription": ""
-          },
-          {
-            "key": "system_httpMethod",
-            "renderTypeList": ["custom"],
-            "valueType": "string",
-            "label": "",
-            "value": "POST",
-            "required": true,
-            "debugLabel": "",
-            "toolDescription": ""
-          },
-          {
-            "key": "system_httpTimeout",
-            "renderTypeList": ["custom"],
-            "valueType": "number",
-            "label": "",
-            "value": 30,
-            "min": 5,
-            "max": 600,
-            "required": true,
-            "debugLabel": "",
-            "toolDescription": ""
-          },
-          {
-            "key": "system_httpReqUrl",
-            "renderTypeList": ["hidden"],
-            "valueType": "string",
-            "label": "",
-            "description": "common:core.module.input.description.Http Request Url",
-            "placeholder": "https://api.ai.com/getInventory",
-            "required": false,
-            "value": "Doc2X/URLPDF2text",
-            "debugLabel": "",
-            "toolDescription": ""
-          },
-          {
-            "key": "system_httpHeader",
-            "renderTypeList": ["custom"],
-            "valueType": "any",
-            "value": [],
-            "label": "",
-            "description": "common:core.module.input.description.Http Request Header",
-            "placeholder": "common:core.module.input.description.Http Request Header",
-            "required": false,
-            "debugLabel": "",
-            "toolDescription": ""
-          },
-          {
-            "key": "system_httpParams",
-            "renderTypeList": ["hidden"],
-            "valueType": "any",
-            "value": [],
-            "label": "",
-            "required": false,
-            "debugLabel": "",
-            "toolDescription": ""
-          },
-          {
-            "key": "system_httpJsonBody",
-            "renderTypeList": ["hidden"],
-            "valueType": "any",
-            "value": "{\n  \"apikey\": \"{{apikey}}\",\n  \"url\": \"{{url}}\",\n  \"ocr\": {{ocr}}\n}",
-            "label": "",
-            "required": false,
-            "debugLabel": "",
-            "toolDescription": ""
-          },
-          {
-            "key": "system_httpFormBody",
-            "renderTypeList": ["hidden"],
-            "valueType": "any",
-            "value": [],
-            "label": "",
-            "required": false,
-            "debugLabel": "",
-            "toolDescription": ""
-          },
-          {
-            "key": "system_httpContentType",
-            "renderTypeList": ["hidden"],
-            "valueType": "string",
-            "value": "json",
-            "label": "",
-            "required": false,
-            "debugLabel": "",
-            "toolDescription": ""
-          },
-          {
-            "renderTypeList": ["reference"],
-            "valueType": "string",
-            "canEdit": true,
-            "key": "apikey",
-            "label": "apikey",
-            "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", "apikey"]
-          },
-          {
-            "renderTypeList": ["reference"],
-            "valueType": "string",
-            "canEdit": true,
-            "key": "url",
-            "label": "url",
-            "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", "url"]
-          },
-          {
-            "renderTypeList": ["reference"],
-            "valueType": "boolean",
-            "canEdit": true,
-            "key": "ocr",
-            "label": "ocr",
-            "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", "formula"]
-          }
-        ],
-        "outputs": [
-          {
-            "id": "error",
-            "key": "error",
-            "label": "workflow:request_error",
-            "description": "HTTP请求错误信息，成功时返回空",
-            "valueType": "object",
-            "type": "static"
-          },
-          {
-            "id": "httpRawResponse",
-            "key": "httpRawResponse",
-            "required": true,
-            "label": "workflow:raw_response",
-            "description": "HTTP请求的原始响应。只能接受字符串或JSON类型响应数据。",
-            "valueType": "any",
-            "type": "static"
-          },
-          {
-            "id": "system_addOutputParam",
-            "key": "system_addOutputParam",
-            "type": "dynamic",
-            "valueType": "dynamic",
-            "label": "",
-            "customFieldConfig": {
-              "selectValueTypeList": [
-                "string",
-                "number",
-                "boolean",
-                "object",
-                "arrayString",
-                "arrayNumber",
-                "arrayBoolean",
-                "arrayObject",
-                "any",
-                "chatHistory",
-                "datasetQuote",
-                "dynamic",
-                "selectApp",
-                "selectDataset"
-              ],
-              "showDescription": false,
-              "showDefaultValue": false
-            }
-          },
-          {
-            "id": "xWQuEf50F3mr",
-            "valueType": "string",
-            "type": "dynamic",
-            "key": "result",
-            "label": "result"
-          },
-          {
-            "id": "m6CJJj7GFud5",
-            "valueType": "boolean",
-            "type": "dynamic",
-            "key": "success",
-            "label": "success"
-          }
-        ]
-      },
-      {
-        "nodeId": "rZmLfANEyyJe",
-        "name": "系统配置",
-        "intro": "",
-        "avatar": "core/workflow/template/systemConfig",
-        "flowNodeType": "pluginConfig",
-        "position": {
-          "x": -93.55061402342784,
-          "y": -55.907069101622824
-        },
-        "version": "4811",
-        "inputs": [],
-        "outputs": []
-      }
-    ],
-    "edges": [
-      {
-        "source": "pluginInput",
-        "target": "zHG5jJBkXmjB",
-        "sourceHandle": "pluginInput-source-right",
-        "targetHandle": "zHG5jJBkXmjB-target-left"
-      },
-      {
-        "source": "zHG5jJBkXmjB",
-        "target": "pluginOutput",
-        "sourceHandle": "zHG5jJBkXmjB-source-right",
-        "targetHandle": "pluginOutput-target-left"
-      }
-    ]
-  }
-}

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

@@ -32,18 +32,20 @@ export function getGridBucket(bucket: `${BucketNameEnum}`) {
 export async function uploadFile({
   bucketName,
   teamId,
-  tmbId,
+  uid,
   path,
   filename,
   contentType,
+  encoding,
   metadata = {}
 }: {
   bucketName: `${BucketNameEnum}`;
   teamId: string;
-  tmbId: string;
+  uid: string; // tmbId / outLinkUId
   path: string;
   filename: string;
   contentType?: string;
+  encoding: string;
   metadata?: Record<string, any>;
 }) {
   if (!path) return Promise.reject(`filePath is empty`);
@@ -52,11 +54,11 @@ export async function uploadFile({
   const stats = await fsp.stat(path);
   if (!stats.isFile()) return Promise.reject(`${path} is not a file`);
 
-  const { stream: readStream, encoding } = await stream2Encoding(fs.createReadStream(path));
+  const readStream = fs.createReadStream(path);
 
   // Add default metadata
   metadata.teamId = teamId;
-  metadata.tmbId = tmbId;
+  metadata.uid = uid;
   metadata.encoding = encoding;
 
   // create a gridfs bucket

packages/service/common/file/multer.ts

@@ -4,7 +4,7 @@ import path from 'path';
 import { BucketNameEnum, bucketNameMap } from '@fastgpt/global/common/file/constants';
 import { getNanoid } from '@fastgpt/global/common/string/tools';
 
-type FileType = {
+export type FileType = {
   fieldname: string;
   originalname: string;
   encoding: string;
@@ -41,7 +41,7 @@ export const getUploadModel = ({ maxSize = 500 }: { maxSize?: number }) => {
       })
     }).single('file');
 
-    async doUpload<T = Record<string, any>>(
+    async doUpload<T = any>(
       req: NextApiRequest,
       res: NextApiResponse,
       originBucketName?: `${BucketNameEnum}`

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

@@ -4,16 +4,17 @@ import FormData from 'form-data';
 
 import { WorkerNameEnum, runWorker } from '../../../worker/utils';
 import fs from 'fs';
-import { detectFileEncoding } from '@fastgpt/global/common/file/tools';
 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 = {
   teamId: string;
   path: string;
+  encoding: string;
   metadata?: Record<string, any>;
 };
 export const readRawTextByLocalFile = async (params: readRawTextByLocalFileParams) => {
@@ -22,13 +23,12 @@ export const readRawTextByLocalFile = async (params: readRawTextByLocalFileParam
   const extension = path?.split('.')?.pop()?.toLowerCase() || '';
 
   const buffer = fs.readFileSync(path);
-  const encoding = detectFileEncoding(buffer);
 
   const { rawText } = await readRawContentByFileBuffer({
     extension,
     isQAImport: false,
     teamId: params.teamId,
-    encoding,
+    encoding: params.encoding,
     buffer,
     metadata: params.metadata
   });
@@ -53,6 +53,7 @@ export const readRawContentByFileBuffer = async ({
   encoding: string;
   metadata?: Record<string, any>;
 }) => {
+  // Custom read file service
   const customReadfileUrl = process.env.CUSTOM_READ_FILE_URL;
   const customReadFileExtension = process.env.CUSTOM_READ_FILE_EXTENSION || '';
   const ocrParse = process.env.CUSTOM_READ_FILE_OCR || 'false';
@@ -78,6 +79,7 @@ export const readRawContentByFileBuffer = async ({
       data: {
         page: number;
         markdown: string;
+        duration: number;
       };
     }>(customReadfileUrl, data, {
       timeout: 600000,
@@ -89,10 +91,12 @@ export const readRawContentByFileBuffer = async ({
     addLog.info(`Use custom read file service, time: ${Date.now() - start}ms`);
 
     const rawText = response.data.markdown;
+    const { text, imageList } = matchMdImgTextAndUpload(rawText);
 
     return {
-      rawText,
+      rawText: text,
-      formatText: rawText
+      formatText: rawText,
+      imageList
     };
   };
 
@@ -119,6 +123,9 @@ export const readRawContentByFileBuffer = async ({
         }
       });
       rawText = rawText.replace(item.uuid, src);
+      if (formatText) {
+        formatText = formatText.replace(item.uuid, src);
+      }
     });
   }
 
@@ -127,7 +134,7 @@ export const readRawContentByFileBuffer = async ({
     if (isQAImport) {
       rawText = rawText || '';
     } else {
-      rawText = formatText || '';
+      rawText = formatText || rawText;
     }
   }
 

packages/service/core/ai/config.ts

@@ -1,5 +1,12 @@
 import type { UserModelSchema } from '@fastgpt/global/support/user/type';
 import OpenAI from '@fastgpt/global/core/ai';
+import {
+  ChatCompletionCreateParamsNonStreaming,
+  ChatCompletionCreateParamsStreaming
+} from '@fastgpt/global/core/ai/type';
+import { getErrText } from '@fastgpt/global/common/error/utils';
+import { addLog } from '../../common/system/log';
+import { i18nT } from '../../../web/i18n/utils';
 
 export const openaiBaseUrl = process.env.OPENAI_BASE_URL || 'https://api.openai.com/v1';
 
@@ -34,3 +41,68 @@ export const getAxiosConfig = (props?: { userKey?: UserModelSchema['openaiAccoun
     authorization: `Bearer ${apiKey}`
   };
 };
+
+type CompletionsBodyType =
+  | ChatCompletionCreateParamsNonStreaming
+  | ChatCompletionCreateParamsStreaming;
+type InferResponseType<T extends CompletionsBodyType> =
+  T extends ChatCompletionCreateParamsStreaming
+    ? OpenAI.Chat.Completions.ChatCompletionChunk
+    : OpenAI.Chat.Completions.ChatCompletion;
+
+export const createChatCompletion = async <T extends CompletionsBodyType>({
+  body,
+  userKey,
+  timeout,
+  options
+}: {
+  body: T;
+  userKey?: UserModelSchema['openaiAccount'];
+  timeout?: number;
+  options?: OpenAI.RequestOptions;
+}): Promise<{
+  response: InferResponseType<T>;
+  isStreamResponse: boolean;
+  getEmptyResponseTip: () => string;
+}> => {
+  try {
+    const formatTimeout = timeout ? timeout : body.stream ? 60000 : 600000;
+    const ai = getAIApi({
+      userKey,
+      timeout: formatTimeout
+    });
+    const response = await ai.chat.completions.create(body, options);
+
+    const isStreamResponse =
+      typeof response === 'object' &&
+      response !== null &&
+      ('iterator' in response || 'controller' in response);
+
+    const getEmptyResponseTip = () => {
+      addLog.warn(`LLM response empty`, {
+        baseUrl: userKey?.baseUrl,
+        requestBody: body
+      });
+      if (userKey?.baseUrl) {
+        return `您的 OpenAI key 没有响应: ${JSON.stringify(body)}`;
+      }
+      return i18nT('chat:LLM_model_response_empty');
+    };
+
+    return {
+      response: response as InferResponseType<T>,
+      isStreamResponse,
+      getEmptyResponseTip
+    };
+  } catch (error) {
+    addLog.error(`LLM response error`, error);
+    addLog.warn(`LLM response error`, {
+      baseUrl: userKey?.baseUrl,
+      requestBody: body
+    });
+    if (userKey?.baseUrl) {
+      return Promise.reject(`您的 OpenAI key 出错了: ${getErrText(error)}`);
+    }
+    return Promise.reject(error);
+  }
+};

packages/service/core/ai/embedding/index.ts

@@ -55,7 +55,7 @@ export async function getVectorsByText({ model, input, type }: GetVectorProps) {
 
     return result;
   } catch (error) {
-    console.log(`Embedding Error`, error);
+    addLog.error(`Embedding Error`, error);
 
     return Promise.reject(error);
   }

packages/service/core/ai/functions/createQuestionGuide.ts

@@ -1,5 +1,5 @@
 import type { ChatCompletionMessageParam } from '@fastgpt/global/core/ai/type.d';
-import { getAIApi } from '../config';
+import { createChatCompletion } from '../config';
 import { countGptMessagesTokens } from '../../../common/string/tiktoken/index';
 import { loadRequestMessages } from '../../chat/utils';
 import { llmCompletionsBodyFormat } from '../utils';
@@ -29,11 +29,8 @@ export async function createQuestionGuide({
     }
   ];
 
-  const ai = getAIApi({
+  const { response: data } = await createChatCompletion({
-    timeout: 480000
+    body: llmCompletionsBodyFormat(
-  });
-  const data = await ai.chat.completions.create(
-    llmCompletionsBodyFormat(
       {
         model,
         temperature: 0.1,
@@ -46,7 +43,7 @@ export async function createQuestionGuide({
       },
       model
     )
-  );
+  });
 
   const answer = data.choices?.[0]?.message?.content || '';
 

packages/service/core/ai/functions/queryExtension.ts

@@ -1,8 +1,7 @@
 import { replaceVariable } from '@fastgpt/global/common/string/tools';
-import { getAIApi } from '../config';
+import { createChatCompletion } from '../config';
 import { ChatItemType } from '@fastgpt/global/core/chat/type';
 import { countGptMessagesTokens } from '../../../common/string/tiktoken/index';
-import { ChatCompletion, ChatCompletionMessageParam } from '@fastgpt/global/core/ai/type';
 import { chatValue2RuntimePrompt } from '@fastgpt/global/core/chat/adapt';
 import { getLLMModel } from '../model';
 import { llmCompletionsBodyFormat } from '../utils';
@@ -138,10 +137,6 @@ A: ${chatBg}
 
   const modelData = getLLMModel(model);
 
-  const ai = getAIApi({
-    timeout: 480000
-  });
-
   const messages = [
     {
       role: 'user',
@@ -150,20 +145,19 @@ A: ${chatBg}
         histories: concatFewShot
       })
     }
-  ] as ChatCompletionMessageParam[];
+  ] as any;
 
-  const result = (await ai.chat.completions.create(
+  const { response: result } = await createChatCompletion({
-    llmCompletionsBodyFormat(
+    body: llmCompletionsBodyFormat(
       {
         stream: false,
         model: modelData.model,
         temperature: 0.01,
-        // @ts-ignore
         messages
       },
       modelData
     )
-  )) as ChatCompletion;
+  });
 
   let answer = result.choices?.[0]?.message?.content || '';
   if (!answer) {

packages/service/core/ai/utils.ts

@@ -48,14 +48,17 @@ export const computedTemperature = ({
 type CompletionsBodyType =
   | ChatCompletionCreateParamsNonStreaming
   | ChatCompletionCreateParamsStreaming;
+type InferCompletionsBody<T> = T extends { stream: true }
+  ? ChatCompletionCreateParamsStreaming
+  : ChatCompletionCreateParamsNonStreaming;
 
 export const llmCompletionsBodyFormat = <T extends CompletionsBodyType>(
   body: T,
   model: string | LLMModelItemType
-) => {
+): InferCompletionsBody<T> => {
   const modelData = typeof model === 'string' ? getLLMModel(model) : model;
   if (!modelData) {
-    return body;
+    return body as InferCompletionsBody<T>;
   }
 
   const requestBody: T = {
@@ -81,5 +84,5 @@ export const llmCompletionsBodyFormat = <T extends CompletionsBodyType>(
 
   // console.log(requestBody);
 
-  return requestBody;
+  return requestBody as InferCompletionsBody<T>;
 };

packages/service/core/app/schema.ts

@@ -17,7 +17,8 @@ export const chatConfigType = {
   scheduledTriggerConfig: Object,
   chatInputGuide: Object,
   fileSelectConfig: Object,
-  instruction: String
+  instruction: String,
+  autoExecute: Object
 };
 
 // schema

packages/service/core/chat/chatItemSchema.ts

@@ -46,6 +46,10 @@ const ChatItemSchema = new Schema({
     type: Date,
     default: () => new Date()
   },
+  hideInUI: {
+    type: Boolean,
+    default: false
+  },
   obj: {
     // chat role
     type: String,

packages/service/core/chat/saveChat.ts

@@ -1,15 +1,6 @@
-import type {
+import type { AIChatItemType, UserChatItemType } from '@fastgpt/global/core/chat/type.d';
-  AIChatItemType,
-  ChatItemType,
-  UserChatItemType
-} from '@fastgpt/global/core/chat/type.d';
-import axios from 'axios';
 import { MongoApp } from '../app/schema';
-import {
+import { ChatItemValueTypeEnum, ChatRoleEnum } from '@fastgpt/global/core/chat/constants';
-  ChatItemValueTypeEnum,
-  ChatRoleEnum,
-  ChatSourceEnum
-} from '@fastgpt/global/core/chat/constants';
 import { MongoChatItem } from './chatItemSchema';
 import { MongoChat } from './chatSchema';
 import { addLog } from '../../common/system/log';
@@ -133,21 +124,15 @@ export async function saveChat({
 export const updateInteractiveChat = async ({
   chatId,
   appId,
-  teamId,
-  tmbId,
   userInteractiveVal,
   aiResponse,
-  newVariables,
+  newVariables
-  newTitle
 }: {
   chatId: string;
   appId: string;
-  teamId: string;
-  tmbId: string;
   userInteractiveVal: string;
   aiResponse: AIChatItemType & { dataId?: string };
   newVariables?: Record<string, any>;
-  newTitle: string;
 }) => {
   if (!chatId) return;
 
@@ -232,7 +217,6 @@ export const updateInteractiveChat = async ({
       {
         $set: {
           variables: newVariables,
-          title: newTitle,
           updateTime: new Date()
         }
       },

packages/service/core/chat/utils.ts

@@ -109,7 +109,7 @@ export const loadRequestMessages = async ({
     }
     return Promise.all(
       messages.map(async (item) => {
-        if (item.type === 'image_url' && process.env.MULTIPLE_DATA_TO_BASE64 === 'true') {
+        if (item.type === 'image_url') {
           // Remove url origin
           const imgUrl = (() => {
             if (origin && item.image_url.url.startsWith(origin)) {
@@ -118,6 +118,11 @@ export const loadRequestMessages = async ({
             return item.image_url.url;
           })();
 
+          // base64 image
+          if (imgUrl.startsWith('data:image/')) {
+            return item;
+          }
+
           try {
             // If imgUrl is a local path, load image from local, and set url to base64
             if (imgUrl.startsWith('/')) {

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

@@ -67,7 +67,7 @@ export async function createOneCollection({
 
         fileId,
         rawLink,
-        externalFileId,
+        ...(externalFileId ? { externalFileId } : {}),
         externalFileUrl,
 
         rawTextLength,

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

@@ -118,7 +118,10 @@ export async function searchDatasetData(props: SearchDatasetDataProps) {
     let createTimeCollectionIdList: string[] | undefined = undefined;
 
     try {
-      const jsonMatch = json5.parse(collectionFilterMatch);
+      const jsonMatch =
+        typeof collectionFilterMatch === 'object'
+          ? collectionFilterMatch
+          : json5.parse(collectionFilterMatch);
 
       // Tag
       let andTags = jsonMatch?.tags?.$and as (string | null)[] | undefined;
@@ -347,7 +350,7 @@ export async function searchDatasetData(props: SearchDatasetDataProps) {
                 teamId: new Types.ObjectId(teamId),
                 datasetId: new Types.ObjectId(id),
                 $text: { $search: jiebaSplit({ text: query }) },
-                ...(filterCollectionIdList && filterCollectionIdList.length > 0
+                ...(filterCollectionIdList
                   ? {
                       collectionId: {
                         $in: filterCollectionIdList.map((id) => new Types.ObjectId(id))

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

@@ -77,7 +77,7 @@ export async function pushDataListToTrainingQueue({
 
     if (trainingMode === TrainingModeEnum.chunk) {
       return {
-        maxToken: vectorModelData.maxToken * 1.3,
+        maxToken: vectorModelData.maxToken * 1.5,
         model: vectorModelData.model,
         weight: vectorModelData.weight
       };
@@ -125,10 +125,7 @@ export async function pushDataListToTrainingQueue({
 
     const text = item.q + item.a;
 
-    // count q token
+    if (text.length > maxToken) {
-    const token = item.q.length;
-
-    if (token > maxToken) {
       filterResult.overToken.push(item);
       return;
     }

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

@@ -51,6 +51,11 @@ const TrainingDataSchema = new Schema({
     type: Date,
     default: () => new Date('2000/1/1')
   },
+  retryCount: {
+    type: Number,
+    default: 5
+  },
+
   model: {
     // ai model
     type: String,
@@ -97,7 +102,7 @@ try {
   // lock training data(teamId); delete training data
   TrainingDataSchema.index({ teamId: 1, datasetId: 1 });
   // get training data and sort
-  TrainingDataSchema.index({ mode: 1, lockTime: 1, weight: -1 });
+  TrainingDataSchema.index({ mode: 1, retryCount: 1, lockTime: 1, weight: -1 });
   TrainingDataSchema.index({ expireAt: 1 }, { expireAfterSeconds: 7 * 24 * 60 * 60 }); // 7 days
 } catch (error) {
   console.log(error);

packages/service/core/workflow/dispatch/agent/classifyQuestion.ts

@@ -2,7 +2,7 @@ import { chats2GPTMessages } from '@fastgpt/global/core/chat/adapt';
 import { countMessagesTokens } from '../../../../common/string/tiktoken/index';
 import type { ChatItemType } from '@fastgpt/global/core/chat/type.d';
 import { ChatItemValueTypeEnum, ChatRoleEnum } from '@fastgpt/global/core/chat/constants';
-import { getAIApi } from '../../../ai/config';
+import { createChatCompletion } from '../../../ai/config';
 import type { ClassifyQuestionAgentItemType } from '@fastgpt/global/core/workflow/template/system/classifyQuestion/type';
 import { NodeInputKeyEnum, NodeOutputKeyEnum } from '@fastgpt/global/core/workflow/constants';
 import { DispatchNodeResponseKeyEnum } from '@fastgpt/global/core/workflow/runtime/constants';
@@ -120,13 +120,8 @@ const completions = async ({
     useVision: false
   });
 
-  const ai = getAIApi({
+  const { response: data } = await createChatCompletion({
-    userKey: user.openaiAccount,
+    body: llmCompletionsBodyFormat(
-    timeout: 480000
-  });
-
-  const data = await ai.chat.completions.create(
-    llmCompletionsBodyFormat(
       {
         model: cqModel.model,
         temperature: 0.01,
@@ -134,8 +129,9 @@ const completions = async ({
         stream: false
       },
       cqModel
-    )
+    ),
-  );
+    userKey: user.openaiAccount
+  });
   const answer = data.choices?.[0].message?.content || '';
 
   // console.log(JSON.stringify(chats2GPTMessages({ messages, reserveId: false }), null, 2));

packages/service/core/workflow/dispatch/agent/extract.ts

@@ -6,7 +6,7 @@ import {
   countGptMessagesTokens
 } from '../../../../common/string/tiktoken/index';
 import { ChatItemValueTypeEnum, ChatRoleEnum } from '@fastgpt/global/core/chat/constants';
-import { getAIApi } from '../../../ai/config';
+import { createChatCompletion } from '../../../ai/config';
 import type { ContextExtractAgentItemType } from '@fastgpt/global/core/workflow/template/system/contextExtract/type';
 import { NodeInputKeyEnum, NodeOutputKeyEnum } from '@fastgpt/global/core/workflow/constants';
 import { DispatchNodeResponseKeyEnum } from '@fastgpt/global/core/workflow/runtime/constants';
@@ -222,13 +222,8 @@ const toolChoice = async (props: ActionProps) => {
     }
   ];
 
-  const ai = getAIApi({
+  const { response } = await createChatCompletion({
-    userKey: user.openaiAccount,
+    body: llmCompletionsBodyFormat(
-    timeout: 480000
-  });
-
-  const response = await ai.chat.completions.create(
-    llmCompletionsBodyFormat(
       {
         model: extractModel.model,
         temperature: 0.01,
@@ -237,8 +232,9 @@ const toolChoice = async (props: ActionProps) => {
         tool_choice: { type: 'function', function: { name: agentFunName } }
       },
       extractModel
-    )
+    ),
-  );
+    userKey: user.openaiAccount
+  });
 
   const arg: Record<string, any> = (() => {
     try {
@@ -272,13 +268,8 @@ const functionCall = async (props: ActionProps) => {
   const { agentFunction, filterMessages } = await getFunctionCallSchema(props);
   const functions: ChatCompletionCreateParams.Function[] = [agentFunction];
 
-  const ai = getAIApi({
+  const { response } = await createChatCompletion({
-    userKey: user.openaiAccount,
+    body: llmCompletionsBodyFormat(
-    timeout: 480000
-  });
-
-  const response = await ai.chat.completions.create(
-    llmCompletionsBodyFormat(
       {
         model: extractModel.model,
         temperature: 0.01,
@@ -289,8 +280,9 @@ const functionCall = async (props: ActionProps) => {
         functions
       },
       extractModel
-    )
+    ),
-  );
+    userKey: user.openaiAccount
+  });
 
   try {
     const arg = JSON.parse(response?.choices?.[0]?.message?.function_call?.arguments || '');
@@ -358,12 +350,8 @@ Human: ${content}`
     useVision: false
   });
 
-  const ai = getAIApi({
+  const { response: data } = await createChatCompletion({
-    userKey: user.openaiAccount,
+    body: llmCompletionsBodyFormat(
-    timeout: 480000
-  });
-  const data = await ai.chat.completions.create(
-    llmCompletionsBodyFormat(
       {
         model: extractModel.model,
         temperature: 0.01,
@@ -371,8 +359,9 @@ Human: ${content}`
         stream: false
       },
       extractModel
-    )
+    ),
-  );
+    userKey: user.openaiAccount
+  });
   const answer = data.choices?.[0].message?.content || '';
 
   // parse response

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

@@ -1,5 +1,4 @@
-import { LLMModelItemType } from '@fastgpt/global/core/ai/model.d';
+import { createChatCompletion } from '../../../../ai/config';
-import { getAIApi } from '../../../../ai/config';
 import { filterGPTMessageByMaxTokens, loadRequestMessages } from '../../../../chat/utils';
 import {
   ChatCompletion,
@@ -22,13 +21,12 @@ import { DispatchFlowResponse, WorkflowResponseType } from '../../type';
 import { countGptMessagesTokens } from '../../../../../common/string/tiktoken/index';
 import { getNanoid, sliceStrStartEnd } from '@fastgpt/global/common/string/tools';
 import { AIChatItemType } from '@fastgpt/global/core/chat/type';
-import { chats2GPTMessages, GPTMessages2Chats } from '@fastgpt/global/core/chat/adapt';
+import { GPTMessages2Chats } from '@fastgpt/global/core/chat/adapt';
 import { formatToolResponse, initToolCallEdges, initToolNodes } from './utils';
 import { computedMaxToken, llmCompletionsBodyFormat } from '../../../../ai/utils';
 import { toolValueTypeList } from '@fastgpt/global/core/workflow/constants';
 import { WorkflowInteractiveResponseType } from '@fastgpt/global/core/workflow/template/system/interactive/type';
-import { ChatItemValueTypeEnum, ChatRoleEnum } from '@fastgpt/global/core/chat/constants';
+import { ChatItemValueTypeEnum } from '@fastgpt/global/core/chat/constants';
-import { i18nT } from '../../../../../../web/i18n/utils';
 
 type FunctionRunResponseType = {
   toolRunResponse: DispatchFlowResponse;
@@ -45,7 +43,7 @@ export const runToolWithFunctionCall = async (
     requestOrigin,
     runtimeNodes,
     runtimeEdges,
-    node,
+    user,
     stream,
     workflowStreamResponse,
     params: { temperature = 0, maxToken = 4000, aiChatVision }
@@ -217,17 +215,22 @@ export const runToolWithFunctionCall = async (
 
   // console.log(JSON.stringify(requestMessages, null, 2));
   /* Run llm */
-  const ai = getAIApi({
+  const {
-    timeout: 480000
+    response: aiResponse,
-  });
+    isStreamResponse,
-  const aiResponse = await ai.chat.completions.create(requestBody, {
+    getEmptyResponseTip
-    headers: {
+  } = await createChatCompletion({
-      Accept: 'application/json, text/plain, */*'
+    body: requestBody,
+    userKey: user.openaiAccount,
+    options: {
+      headers: {
+        Accept: 'application/json, text/plain, */*'
+      }
     }
   });
 
   const { answer, functionCalls } = await (async () => {
-    if (res && stream) {
+    if (res && isStreamResponse) {
       return streamResponse({
         res,
         toolNodes,
@@ -256,6 +259,9 @@ export const runToolWithFunctionCall = async (
       };
     }
   })();
+  if (!answer && functionCalls.length === 0) {
+    return Promise.reject(getEmptyResponseTip());
+  }
 
   // Run the selected tool.
   const toolsRunResponse = (
@@ -549,9 +555,5 @@ async function streamResponse({
     }
   }
 
-  if (!textAnswer && functionCalls.length === 0) {
-    return Promise.reject(i18nT('chat:LLM_model_response_empty'));
-  }
-
   return { answer: textAnswer, functionCalls };
 }

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

@@ -29,6 +29,7 @@ import { getFileContentFromLinks, getHistoryFileLinks } from '../../tools/readFi
 import { parseUrlToFileType } from '@fastgpt/global/common/file/tools';
 import { Prompt_DocumentQuote } from '@fastgpt/global/core/ai/prompt/AIChat';
 import { FlowNodeTypeEnum } from '@fastgpt/global/core/workflow/node/constant';
+import { postTextCensor } from '../../../../../common/api/requestPlusApi';
 
 type Response = DispatchNodeResultType<{
   [NodeOutputKeyEnum.answerText]: string;
@@ -45,6 +46,7 @@ export const dispatchRunTools = async (props: DispatchToolModuleProps): Promise<
     requestOrigin,
     chatConfig,
     runningAppInfo: { teamId },
+    user,
     params: {
       model,
       systemPrompt,
@@ -150,6 +152,15 @@ export const dispatchRunTools = async (props: DispatchToolModuleProps): Promise<
     return value;
   })();
 
+  // censor model and system key
+  if (toolModel.censor && !user.openaiAccount?.key) {
+    await postTextCensor({
+      text: `${systemPrompt}
+          ${userChatInput}
+        `
+    });
+  }
+
   const {
     toolWorkflowInteractiveResponse,
     dispatchFlowResponse, // tool flow response
@@ -217,13 +228,14 @@ export const dispatchRunTools = async (props: DispatchToolModuleProps): Promise<
     tokens: toolNodeTokens,
     modelType: ModelTypeEnum.llm
   });
+  const toolAIUsage = user.openaiAccount?.key ? 0 : totalPoints;
 
   // flat child tool response
   const childToolResponse = dispatchFlowResponse.map((item) => item.flowResponses).flat();
 
   // concat tool usage
   const totalPointsUsage =
-    totalPoints +
+    toolAIUsage +
     dispatchFlowResponse.reduce((sum, item) => {
       const childrenTotal = item.flowUsages.reduce((sum, item) => sum + item.totalPoints, 0);
       return sum + childrenTotal;
@@ -240,6 +252,7 @@ export const dispatchRunTools = async (props: DispatchToolModuleProps): Promise<
       .join(''),
     [DispatchNodeResponseKeyEnum.assistantResponses]: previewAssistantResponses,
     [DispatchNodeResponseKeyEnum.nodeResponse]: {
+      // 展示的积分消耗
       totalPoints: totalPointsUsage,
       toolCallTokens: toolNodeTokens,
       childTotalPoints: flatUsages.reduce((sum, item) => sum + item.totalPoints, 0),
@@ -254,12 +267,14 @@ export const dispatchRunTools = async (props: DispatchToolModuleProps): Promise<
       mergeSignId: nodeId
     },
     [DispatchNodeResponseKeyEnum.nodeDispatchUsages]: [
+      // 工具调用本身的积分消耗
       {
         moduleName: name,
-        totalPoints,
+        totalPoints: toolAIUsage,
         model: modelName,
         tokens: toolNodeTokens
       },
+      // 工具的消耗
       ...flatUsages
     ],
     [DispatchNodeResponseKeyEnum.interactive]: toolWorkflowInteractiveResponse

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

@@ -1,4 +1,4 @@
-import { getAIApi } from '../../../../ai/config';
+import { createChatCompletion } from '../../../../ai/config';
 import { filterGPTMessageByMaxTokens, loadRequestMessages } from '../../../../chat/utils';
 import {
   ChatCompletion,
@@ -29,7 +29,6 @@ import { WorkflowResponseType } from '../../type';
 import { toolValueTypeList } from '@fastgpt/global/core/workflow/constants';
 import { WorkflowInteractiveResponseType } from '@fastgpt/global/core/workflow/template/system/interactive/type';
 import { ChatItemValueTypeEnum } from '@fastgpt/global/core/chat/constants';
-import { i18nT } from '../../../../../../web/i18n/utils';
 
 type FunctionCallCompletion = {
   id: string;
@@ -52,7 +51,7 @@ export const runToolWithPromptCall = async (
     requestOrigin,
     runtimeNodes,
     runtimeEdges,
-    node,
+    user,
     stream,
     workflowStreamResponse,
     params: { temperature = 0, maxToken = 4000, aiChatVision }
@@ -225,18 +224,19 @@ export const runToolWithPromptCall = async (
 
   // console.log(JSON.stringify(requestMessages, null, 2));
   /* Run llm */
-  const ai = getAIApi({
+  const {
-    timeout: 480000
+    response: aiResponse,
-  });
+    isStreamResponse,
-  const aiResponse = await ai.chat.completions.create(requestBody, {
+    getEmptyResponseTip
-    headers: {
+  } = await createChatCompletion({
-      Accept: 'application/json, text/plain, */*'
+    body: requestBody,
+    userKey: user.openaiAccount,
+    options: {
+      headers: {
+        Accept: 'application/json, text/plain, */*'
+      }
     }
   });
-  const isStreamResponse =
-    typeof aiResponse === 'object' &&
-    aiResponse !== null &&
-    ('iterator' in aiResponse || 'controller' in aiResponse);
 
   const answer = await (async () => {
     if (res && isStreamResponse) {
@@ -254,8 +254,11 @@ export const runToolWithPromptCall = async (
       return result.choices?.[0]?.message?.content || '';
     }
   })();
-
   const { answer: replaceAnswer, toolJson } = parseAnswer(answer);
+  if (!answer && !toolJson) {
+    return Promise.reject(getEmptyResponseTip());
+  }
+
   // No tools
   if (!toolJson) {
     if (replaceAnswer === ERROR_TEXT) {
@@ -537,9 +540,6 @@ async function streamResponse({
     }
   }
 
-  if (!textAnswer) {
-    return Promise.reject(i18nT('chat:LLM_model_response_empty'));
-  }
   return { answer: textAnswer.trim() };
 }
 

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

@@ -1,4 +1,4 @@
-import { getAIApi } from '../../../../ai/config';
+import { createChatCompletion } from '../../../../ai/config';
 import { filterGPTMessageByMaxTokens, loadRequestMessages } from '../../../../chat/utils';
 import {
   ChatCompletion,
@@ -92,6 +92,7 @@ export const runToolWithToolChoice = async (
     runtimeNodes,
     runtimeEdges,
     stream,
+    user,
     workflowStreamResponse,
     params: { temperature = 0, maxToken = 4000, aiChatVision }
   } = workflowProps;
@@ -271,277 +272,272 @@ export const runToolWithToolChoice = async (
   );
   // console.log(JSON.stringify(requestBody, null, 2), '==requestBody');
   /* Run llm */
-  const ai = getAIApi({
+  const {
-    timeout: 480000
+    response: aiResponse,
-  });
+    isStreamResponse,
-
+    getEmptyResponseTip
-  try {
+  } = await createChatCompletion({
-    const aiResponse = await ai.chat.completions.create(requestBody, {
+    body: requestBody,
+    userKey: user.openaiAccount,
+    options: {
       headers: {
         Accept: 'application/json, text/plain, */*'
       }
-    });
+    }
-    const isStreamResponse =
+  });
-      typeof aiResponse === 'object' &&
-      aiResponse !== null &&
-      ('iterator' in aiResponse || 'controller' in aiResponse);
 
-    const { answer, toolCalls } = await (async () => {
+  const { answer, toolCalls } = await (async () => {
-      if (res && isStreamResponse) {
+    if (res && isStreamResponse) {
-        return streamResponse({
+      return streamResponse({
-          res,
+        res,
-          workflowStreamResponse,
+        workflowStreamResponse,
-          toolNodes,
+        toolNodes,
-          stream: aiResponse
+        stream: aiResponse
-        });
+      });
-      } else {
+    } else {
-        const result = aiResponse as ChatCompletion;
+      const result = aiResponse as ChatCompletion;
-        const calls = result.choices?.[0]?.message?.tool_calls || [];
+      const calls = result.choices?.[0]?.message?.tool_calls || [];
-        const answer = result.choices?.[0]?.message?.content || '';
+      const answer = result.choices?.[0]?.message?.content || '';
 
-        // 加上name和avatar
+      // 加上name和avatar
-        const toolCalls = calls.map((tool) => {
+      const toolCalls = calls.map((tool) => {
-          const toolNode = toolNodes.find((item) => item.nodeId === tool.function?.name);
+        const toolNode = toolNodes.find((item) => item.nodeId === tool.function?.name);
-          return {
+        return {
-            ...tool,
+          ...tool,
-            toolName: toolNode?.name || '',
+          toolName: toolNode?.name || '',
-            toolAvatar: toolNode?.avatar || ''
+          toolAvatar: toolNode?.avatar || ''
-          };
+        };
-        });
+      });
 
-        // 不支持 stream 模式的模型的流失响应
+      // 不支持 stream 模式的模型的流失响应
-        toolCalls.forEach((tool) => {
+      toolCalls.forEach((tool) => {
-          workflowStreamResponse?.({
+        workflowStreamResponse?.({
-            event: SseResponseEventEnum.toolCall,
+          event: SseResponseEventEnum.toolCall,
-            data: {
+          data: {
-              tool: {
+            tool: {
-                id: tool.id,
+              id: tool.id,
-                toolName: tool.toolName,
+              toolName: tool.toolName,
-                toolAvatar: tool.toolAvatar,
+              toolAvatar: tool.toolAvatar,
-                functionName: tool.function.name,
+              functionName: tool.function.name,
-                params: tool.function?.arguments ?? '',
+              params: tool.function?.arguments ?? '',
-                response: ''
+              response: ''
-              }
             }
-          });
+          }
+        });
+      });
+      if (answer) {
+        workflowStreamResponse?.({
+          event: SseResponseEventEnum.fastAnswer,
+          data: textAdaptGptResponse({
+            text: answer
+          })
+        });
+      }
+
+      return {
+        answer,
+        toolCalls: toolCalls
+      };
+    }
+  })();
+  if (!answer && toolCalls.length === 0) {
+    return Promise.reject(getEmptyResponseTip());
+  }
+
+  // Run the selected tool by LLM.
+  const toolsRunResponse = (
+    await Promise.all(
+      toolCalls.map(async (tool) => {
+        const toolNode = toolNodes.find((item) => item.nodeId === tool.function?.name);
+
+        if (!toolNode) return;
+
+        const startParams = (() => {
+          try {
+            return json5.parse(tool.function.arguments);
+          } catch (error) {
+            return {};
+          }
+        })();
+
+        initToolNodes(runtimeNodes, [toolNode.nodeId], startParams);
+        const toolRunResponse = await dispatchWorkFlow({
+          ...workflowProps,
+          isToolCall: true
+        });
+
+        const stringToolResponse = formatToolResponse(toolRunResponse.toolResponses);
+
+        const toolMsgParams: ChatCompletionToolMessageParam = {
+          tool_call_id: tool.id,
+          role: ChatCompletionRequestMessageRoleEnum.Tool,
+          name: tool.function.name,
+          content: stringToolResponse
+        };
+
+        workflowStreamResponse?.({
+          event: SseResponseEventEnum.toolResponse,
+          data: {
+            tool: {
+              id: tool.id,
+              toolName: '',
+              toolAvatar: '',
+              params: '',
+              response: sliceStrStartEnd(stringToolResponse, 5000, 5000)
+            }
+          }
         });
-        if (answer) {
-          workflowStreamResponse?.({
-            event: SseResponseEventEnum.fastAnswer,
-            data: textAdaptGptResponse({
-              text: answer
-            })
-          });
-        }
 
         return {
-          answer,
+          toolRunResponse,
-          toolCalls: toolCalls
+          toolMsgParams
         };
+      })
+    )
+  ).filter(Boolean) as ToolRunResponseType;
+
+  const flatToolsResponseData = toolsRunResponse.map((item) => item.toolRunResponse).flat();
+  // concat tool responses
+  const dispatchFlowResponse = response
+    ? response.dispatchFlowResponse.concat(flatToolsResponseData)
+    : flatToolsResponseData;
+
+  if (toolCalls.length > 0 && !res?.closed) {
+    // Run the tool, combine its results, and perform another round of AI calls
+    const assistantToolMsgParams: ChatCompletionAssistantMessageParam[] = [
+      ...(answer
+        ? [
+            {
+              role: ChatCompletionRequestMessageRoleEnum.Assistant as 'assistant',
+              content: answer
+            }
+          ]
+        : []),
+      {
+        role: ChatCompletionRequestMessageRoleEnum.Assistant,
+        tool_calls: toolCalls
       }
-    })();
+    ];
 
-    // Run the selected tool by LLM.
+    /* 
-    const toolsRunResponse = (
-      await Promise.all(
-        toolCalls.map(async (tool) => {
-          const toolNode = toolNodes.find((item) => item.nodeId === tool.function?.name);
-
-          if (!toolNode) return;
-
-          const startParams = (() => {
-            try {
-              return json5.parse(tool.function.arguments);
-            } catch (error) {
-              return {};
-            }
-          })();
-
-          initToolNodes(runtimeNodes, [toolNode.nodeId], startParams);
-          const toolRunResponse = await dispatchWorkFlow({
-            ...workflowProps,
-            isToolCall: true
-          });
-
-          const stringToolResponse = formatToolResponse(toolRunResponse.toolResponses);
-
-          const toolMsgParams: ChatCompletionToolMessageParam = {
-            tool_call_id: tool.id,
-            role: ChatCompletionRequestMessageRoleEnum.Tool,
-            name: tool.function.name,
-            content: stringToolResponse
-          };
-
-          workflowStreamResponse?.({
-            event: SseResponseEventEnum.toolResponse,
-            data: {
-              tool: {
-                id: tool.id,
-                toolName: '',
-                toolAvatar: '',
-                params: '',
-                response: sliceStrStartEnd(stringToolResponse, 5000, 5000)
-              }
-            }
-          });
-
-          return {
-            toolRunResponse,
-            toolMsgParams
-          };
-        })
-      )
-    ).filter(Boolean) as ToolRunResponseType;
-
-    const flatToolsResponseData = toolsRunResponse.map((item) => item.toolRunResponse).flat();
-    // concat tool responses
-    const dispatchFlowResponse = response
-      ? response.dispatchFlowResponse.concat(flatToolsResponseData)
-      : flatToolsResponseData;
-
-    if (toolCalls.length > 0 && !res?.closed) {
-      // Run the tool, combine its results, and perform another round of AI calls
-      const assistantToolMsgParams: ChatCompletionAssistantMessageParam[] = [
-        ...(answer
-          ? [
-              {
-                role: ChatCompletionRequestMessageRoleEnum.Assistant as 'assistant',
-                content: answer
-              }
-            ]
-          : []),
-        {
-          role: ChatCompletionRequestMessageRoleEnum.Assistant,
-          tool_calls: toolCalls
-        }
-      ];
-
-      /* 
         ...
         user
         assistant: tool data
       */
-      const concatToolMessages = [
+    const concatToolMessages = [
-        ...requestMessages,
+      ...requestMessages,
-        ...assistantToolMsgParams
+      ...assistantToolMsgParams
-      ] as ChatCompletionMessageParam[];
+    ] as ChatCompletionMessageParam[];
 
-      // Only toolCall tokens are counted here, Tool response tokens count towards the next reply
+    // Only toolCall tokens are counted here, Tool response tokens count towards the next reply
-      const tokens = await countGptMessagesTokens(concatToolMessages, tools);
+    const tokens = await countGptMessagesTokens(concatToolMessages, tools);
-      /* 
+    /* 
         ...
         user
         assistant: tool data
         tool: tool response
       */
-      const completeMessages = [
+    const completeMessages = [
-        ...concatToolMessages,
+      ...concatToolMessages,
-        ...toolsRunResponse.map((item) => item?.toolMsgParams)
+      ...toolsRunResponse.map((item) => item?.toolMsgParams)
-      ];
+    ];
 
-      /* 
+    /* 
         Get tool node assistant response
         history assistant
         current tool assistant
         tool child assistant
       */
-      const toolNodeAssistant = GPTMessages2Chats([
+    const toolNodeAssistant = GPTMessages2Chats([
-        ...assistantToolMsgParams,
+      ...assistantToolMsgParams,
-        ...toolsRunResponse.map((item) => item?.toolMsgParams)
+      ...toolsRunResponse.map((item) => item?.toolMsgParams)
-      ])[0] as AIChatItemType;
+    ])[0] as AIChatItemType;
-      const toolChildAssistants = flatToolsResponseData
+    const toolChildAssistants = flatToolsResponseData
-        .map((item) => item.assistantResponses)
+      .map((item) => item.assistantResponses)
-        .flat()
+      .flat()
-        .filter((item) => item.type !== ChatItemValueTypeEnum.interactive); // 交互节点留着下次记录
+      .filter((item) => item.type !== ChatItemValueTypeEnum.interactive); // 交互节点留着下次记录
-      const toolNodeAssistants = [
+    const toolNodeAssistants = [
-        ...assistantResponses,
+      ...assistantResponses,
-        ...toolNodeAssistant.value,
+      ...toolNodeAssistant.value,
-        ...toolChildAssistants
+      ...toolChildAssistants
-      ];
+    ];
 
-      const runTimes =
+    const runTimes =
-        (response?.runTimes || 0) +
+      (response?.runTimes || 0) +
-        flatToolsResponseData.reduce((sum, item) => sum + item.runTimes, 0);
+      flatToolsResponseData.reduce((sum, item) => sum + item.runTimes, 0);
-      const toolNodeTokens = response ? response.toolNodeTokens + tokens : tokens;
+    const toolNodeTokens = response ? response.toolNodeTokens + tokens : tokens;
 
-      // Check stop signal
+    // Check stop signal
-      const hasStopSignal = flatToolsResponseData.some(
+    const hasStopSignal = flatToolsResponseData.some(
-        (item) => !!item.flowResponses?.find((item) => item.toolStop)
+      (item) => !!item.flowResponses?.find((item) => item.toolStop)
-      );
+    );
-      // Check interactive response(Only 1 interaction is reserved)
+    // Check interactive response(Only 1 interaction is reserved)
-      const workflowInteractiveResponseItem = toolsRunResponse.find(
+    const workflowInteractiveResponseItem = toolsRunResponse.find(
-        (item) => item.toolRunResponse.workflowInteractiveResponse
+      (item) => item.toolRunResponse.workflowInteractiveResponse
-      );
+    );
-      if (hasStopSignal || workflowInteractiveResponseItem) {
+    if (hasStopSignal || workflowInteractiveResponseItem) {
-        // Get interactive tool data
+      // Get interactive tool data
-        const workflowInteractiveResponse =
+      const workflowInteractiveResponse =
-          workflowInteractiveResponseItem?.toolRunResponse.workflowInteractiveResponse;
+        workflowInteractiveResponseItem?.toolRunResponse.workflowInteractiveResponse;
 
-        // Flashback traverses completeMessages, intercepting messages that know the first user
+      // Flashback traverses completeMessages, intercepting messages that know the first user
-        const firstUserIndex = completeMessages.findLastIndex((item) => item.role === 'user');
+      const firstUserIndex = completeMessages.findLastIndex((item) => item.role === 'user');
-        const newMessages = completeMessages.slice(firstUserIndex + 1);
+      const newMessages = completeMessages.slice(firstUserIndex + 1);
 
-        const toolWorkflowInteractiveResponse: WorkflowInteractiveResponseType | undefined =
+      const toolWorkflowInteractiveResponse: WorkflowInteractiveResponseType | undefined =
-          workflowInteractiveResponse
+        workflowInteractiveResponse
-            ? {
+          ? {
-                ...workflowInteractiveResponse,
+              ...workflowInteractiveResponse,
-                toolParams: {
+              toolParams: {
-                  entryNodeIds: workflowInteractiveResponse.entryNodeIds,
+                entryNodeIds: workflowInteractiveResponse.entryNodeIds,
-                  toolCallId: workflowInteractiveResponseItem?.toolMsgParams.tool_call_id,
+                toolCallId: workflowInteractiveResponseItem?.toolMsgParams.tool_call_id,
-                  memoryMessages: newMessages
+                memoryMessages: newMessages
-                }
               }
-            : undefined;
+            }
-
+          : undefined;
-        return {
-          dispatchFlowResponse,
-          toolNodeTokens,
-          completeMessages,
-          assistantResponses: toolNodeAssistants,
-          runTimes,
-          toolWorkflowInteractiveResponse
-        };
-      }
-
-      return runToolWithToolChoice(
-        {
-          ...props,
-          maxRunToolTimes: maxRunToolTimes - 1,
-          messages: completeMessages
-        },
-        {
-          dispatchFlowResponse,
-          toolNodeTokens,
-          assistantResponses: toolNodeAssistants,
-          runTimes
-        }
-      );
-    } else {
-      // No tool is invoked, indicating that the process is over
-      const gptAssistantResponse: ChatCompletionAssistantMessageParam = {
-        role: ChatCompletionRequestMessageRoleEnum.Assistant,
-        content: answer
-      };
-      const completeMessages = filterMessages.concat(gptAssistantResponse);
-      const tokens = await countGptMessagesTokens(completeMessages, tools);
-
-      // concat tool assistant
-      const toolNodeAssistant = GPTMessages2Chats([gptAssistantResponse])[0] as AIChatItemType;
 
       return {
-        dispatchFlowResponse: response?.dispatchFlowResponse || [],
+        dispatchFlowResponse,
-        toolNodeTokens: response ? response.toolNodeTokens + tokens : tokens,
+        toolNodeTokens,
         completeMessages,
-        assistantResponses: [...assistantResponses, ...toolNodeAssistant.value],
+        assistantResponses: toolNodeAssistants,
-        runTimes: (response?.runTimes || 0) + 1
+        runTimes,
+        toolWorkflowInteractiveResponse
       };
     }
-  } catch (error) {
+
-    console.log(error);
+    return runToolWithToolChoice(
-    addLog.warn(`LLM response error`, {
+      {
-      requestBody
+        ...props,
-    });
+        maxRunToolTimes: maxRunToolTimes - 1,
-    return Promise.reject(error);
+        messages: completeMessages
+      },
+      {
+        dispatchFlowResponse,
+        toolNodeTokens,
+        assistantResponses: toolNodeAssistants,
+        runTimes
+      }
+    );
+  } else {
+    // No tool is invoked, indicating that the process is over
+    const gptAssistantResponse: ChatCompletionAssistantMessageParam = {
+      role: ChatCompletionRequestMessageRoleEnum.Assistant,
+      content: answer
+    };
+    const completeMessages = filterMessages.concat(gptAssistantResponse);
+    const tokens = await countGptMessagesTokens(completeMessages, tools);
+
+    // concat tool assistant
+    const toolNodeAssistant = GPTMessages2Chats([gptAssistantResponse])[0] as AIChatItemType;
+
+    return {
+      dispatchFlowResponse: response?.dispatchFlowResponse || [],
+      toolNodeTokens: response ? response.toolNodeTokens + tokens : tokens,
+      completeMessages,
+      assistantResponses: [...assistantResponses, ...toolNodeAssistant.value],
+      runTimes: (response?.runTimes || 0) + 1
+    };
   }
 };
 
@@ -656,9 +652,5 @@ async function streamResponse({
     }
   }
 
-  if (!textAnswer && toolCalls.length === 0) {
-    return Promise.reject(i18nT('chat:LLM_model_response_empty'));
-  }
-
   return { answer: textAnswer, toolCalls };
 }

packages/service/core/workflow/dispatch/chat/oneapi.ts

@@ -4,7 +4,7 @@ import type { ChatItemType, UserChatItemValueItemType } from '@fastgpt/global/co
 import { ChatRoleEnum } from '@fastgpt/global/core/chat/constants';
 import { SseResponseEventEnum } from '@fastgpt/global/core/workflow/runtime/constants';
 import { textAdaptGptResponse } from '@fastgpt/global/core/workflow/runtime/utils';
-import { getAIApi } from '../../../ai/config';
+import { createChatCompletion } from '../../../ai/config';
 import type { ChatCompletion, StreamChatType } from '@fastgpt/global/core/ai/type.d';
 import { formatModelChars2Points } from '../../../../support/wallet/usage/utils';
 import type { LLMModelItemType } from '@fastgpt/global/core/ai/model.d';
@@ -33,15 +33,13 @@ import { getLLMModel, ModelTypeEnum } from '../../../ai/model';
 import type { SearchDataResponseItemType } from '@fastgpt/global/core/dataset/type';
 import { NodeInputKeyEnum, NodeOutputKeyEnum } from '@fastgpt/global/core/workflow/constants';
 import { DispatchNodeResponseKeyEnum } from '@fastgpt/global/core/workflow/runtime/constants';
-import { getHistories } from '../utils';
+import { checkQuoteQAValue, getHistories } from '../utils';
 import { filterSearchResultsByMaxChars } from '../../utils';
 import { getHistoryPreview } from '@fastgpt/global/core/chat/utils';
-import { addLog } from '../../../../common/system/log';
 import { computedMaxToken, llmCompletionsBodyFormat } from '../../../ai/utils';
 import { WorkflowResponseType } from '../type';
 import { formatTime2YMDHM } from '@fastgpt/global/common/string/time';
 import { AiChatQuoteRoleType } from '@fastgpt/global/core/workflow/template/system/aiChat/type';
-import { getErrText } from '@fastgpt/global/common/error/utils';
 import { getFileContentFromLinks, getHistoryFileLinks } from '../tools/readFiles';
 import { parseUrlToFileType } from '@fastgpt/global/common/file/tools';
 import { i18nT } from '../../../../../web/i18n/utils';
@@ -93,6 +91,7 @@ export const dispatchChatCompletion = async (props: ChatProps): Promise<ChatResp
   stream = stream && isResponseAnswerText;
 
   const chatHistories = getHistories(history, histories);
+  quoteQA = checkQuoteQAValue(quoteQA);
 
   const modelConstantsData = getLLMModel(model);
   if (!modelConstantsData) {
@@ -138,7 +137,6 @@ export const dispatchChatCompletion = async (props: ChatProps): Promise<ChatResp
       if (modelConstantsData.censor && !user.openaiAccount?.key) {
         return postTextCensor({
           text: `${systemPrompt}
-            ${datasetQuoteText}
             ${userChatInput}
           `
         });
@@ -170,109 +168,91 @@ export const dispatchChatCompletion = async (props: ChatProps): Promise<ChatResp
     modelConstantsData
   );
   // console.log(JSON.stringify(requestBody, null, 2), '===');
-  try {
+  const { response, isStreamResponse, getEmptyResponseTip } = await createChatCompletion({
-    const ai = getAIApi({
+    body: requestBody,
-      userKey: user.openaiAccount,
+    userKey: user.openaiAccount,
-      timeout: 480000
+    options: {
-    });
-    const response = await ai.chat.completions.create(requestBody, {
       headers: {
         Accept: 'application/json, text/plain, */*'
       }
-    });
+    }
+  });
 
-    const isStreamResponse =
+  const { answerText } = await (async () => {
-      typeof response === 'object' &&
+    if (res && isStreamResponse) {
-      response !== null &&
+      // sse response
-      ('iterator' in response || 'controller' in response);
+      const { answer } = await streamResponse({
+        res,
+        stream: response,
+        workflowStreamResponse
+      });
 
-    const { answerText } = await (async () => {
+      return {
-      if (res && isStreamResponse) {
+        answerText: answer
-        // sse response
+      };
-        const { answer } = await streamResponse({
+    } else {
-          res,
+      const unStreamResponse = response as ChatCompletion;
-          stream: response,
+      const answer = unStreamResponse.choices?.[0]?.message?.content || '';
-          workflowStreamResponse
+
+      if (stream) {
+        // Some models do not support streaming
+        workflowStreamResponse?.({
+          event: SseResponseEventEnum.fastAnswer,
+          data: textAdaptGptResponse({
+            text: answer
+          })
         });
-
-        if (!answer) {
-          return Promise.reject(i18nT('chat:LLM_model_response_empty'));
-        }
-
-        return {
-          answerText: answer
-        };
-      } else {
-        const unStreamResponse = response as ChatCompletion;
-        const answer = unStreamResponse.choices?.[0]?.message?.content || '';
-
-        if (stream) {
-          // Some models do not support streaming
-          workflowStreamResponse?.({
-            event: SseResponseEventEnum.fastAnswer,
-            data: textAdaptGptResponse({
-              text: answer
-            })
-          });
-        }
-
-        return {
-          answerText: answer
-        };
       }
-    })();
 
-    const completeMessages = requestMessages.concat({
+      return {
-      role: ChatCompletionRequestMessageRoleEnum.Assistant,
+        answerText: answer
-      content: answerText
+      };
-    });
+    }
-    const chatCompleteMessages = GPTMessages2Chats(completeMessages);
+  })();
 
-    const tokens = await countMessagesTokens(chatCompleteMessages);
+  if (!answerText) {
-    const { totalPoints, modelName } = formatModelChars2Points({
+    return Promise.reject(getEmptyResponseTip());
-      model,
+  }
+
+  const completeMessages = requestMessages.concat({
+    role: ChatCompletionRequestMessageRoleEnum.Assistant,
+    content: answerText
+  });
+  const chatCompleteMessages = GPTMessages2Chats(completeMessages);
+
+  const tokens = await countMessagesTokens(chatCompleteMessages);
+  const { totalPoints, modelName } = formatModelChars2Points({
+    model,
+    tokens,
+    modelType: ModelTypeEnum.llm
+  });
+
+  return {
+    answerText,
+    [DispatchNodeResponseKeyEnum.nodeResponse]: {
+      totalPoints: user.openaiAccount?.key ? 0 : totalPoints,
+      model: modelName,
       tokens,
-      modelType: ModelTypeEnum.llm
+      query: `${userChatInput}`,
-    });
+      maxToken: max_tokens,
-
+      historyPreview: getHistoryPreview(
-    return {
+        chatCompleteMessages,
-      answerText,
+        10000,
-      [DispatchNodeResponseKeyEnum.nodeResponse]: {
+        modelConstantsData.vision && aiChatVision
+      ),
+      contextTotalLen: completeMessages.length
+    },
+    [DispatchNodeResponseKeyEnum.nodeDispatchUsages]: [
+      {
+        moduleName: name,
         totalPoints: user.openaiAccount?.key ? 0 : totalPoints,
         model: modelName,
-        tokens,
+        tokens
-        query: `${userChatInput}`,
+      }
-        maxToken: max_tokens,
+    ],
-        historyPreview: getHistoryPreview(
+    [DispatchNodeResponseKeyEnum.toolResponses]: answerText,
-          chatCompleteMessages,
+    history: chatCompleteMessages
-          10000,
+  };
-          modelConstantsData.vision && aiChatVision
-        ),
-        contextTotalLen: completeMessages.length
-      },
-      [DispatchNodeResponseKeyEnum.nodeDispatchUsages]: [
-        {
-          moduleName: name,
-          totalPoints: user.openaiAccount?.key ? 0 : totalPoints,
-          model: modelName,
-          tokens
-        }
-      ],
-      [DispatchNodeResponseKeyEnum.toolResponses]: answerText,
-      history: chatCompleteMessages
-    };
-  } catch (error) {
-    addLog.warn(`LLM response error`, {
-      baseUrl: user.openaiAccount?.baseUrl,
-      requestBody
-    });
-
-    if (user.openaiAccount?.baseUrl) {
-      return Promise.reject(`您的 OpenAI key 出错了: ${getErrText(error)}`);
-    }
-
-    return Promise.reject(error);
-  }
 };
 
 async function filterDatasetQuote({

packages/service/core/workflow/dispatch/dataset/search.ts

@@ -65,7 +65,17 @@ export async function dispatchDatasetSearch(
   }
 
   if (!userChatInput) {
-    return Promise.reject(i18nT('common:core.chat.error.User input empty'));
+    return {
+      quoteQA: [],
+      [DispatchNodeResponseKeyEnum.nodeResponse]: {
+        totalPoints: 0,
+        query: '',
+        limit,
+        searchMode
+      },
+      nodeDispatchUsages: [],
+      [DispatchNodeResponseKeyEnum.toolResponses]: []
+    };
   }
 
   // query extension

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

@@ -18,7 +18,6 @@ import {
   textAdaptGptResponse,
   replaceEditorVariable
 } from '@fastgpt/global/core/workflow/runtime/utils';
-import { getSystemPluginCb } from '../../../../../plugins/register';
 import { ContentTypes } from '@fastgpt/global/core/workflow/constants';
 import { uploadFileFromBase64Img } from '../../../../common/file/gridfs/controller';
 import { ReadFileBaseUrl } from '@fastgpt/global/common/file/constants';
@@ -209,7 +208,7 @@ export const dispatchHttp468Request = async (props: HttpRequestProps): Promise<H
 
   try {
     const { formatResponse, rawResponse } = await (async () => {
-      const systemPluginCb = await getSystemPluginCb();
+      const systemPluginCb = global.systemPluginCb;
       if (systemPluginCb[httpReqUrl]) {
         const pluginResult = await replaceSystemPluginResponse({
           response: await systemPluginCb[httpReqUrl](requestBody),
@@ -395,7 +394,7 @@ async function replaceSystemPluginResponse({
         response[key] = `${ReadFileBaseUrl}/${filename}?token=${await createFileToken({
           bucketName: 'chat',
           teamId,
-          tmbId,
+          uid: tmbId,
           fileId
         })}`;
       } catch (error) {}

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

@@ -13,6 +13,7 @@ import { responseWrite } from '../../../common/response';
 import { NextApiResponse } from 'next';
 import { SseResponseEventEnum } from '@fastgpt/global/core/workflow/runtime/constants';
 import { getNanoid } from '@fastgpt/global/common/string/tools';
+import { SearchDataResponseItemType } from '@fastgpt/global/core/dataset/type';
 
 export const getWorkflowResponseWrite = ({
   res,
@@ -87,27 +88,6 @@ export const filterToolNodeIdByEdges = ({
     .map((edge) => edge.target);
 };
 
-// export const checkTheModuleConnectedByTool = (
-//   modules: StoreNodeItemType[],
-//   node: StoreNodeItemType
-// ) => {
-//   let sign = false;
-//   const toolModules = modules.filter((item) => item.flowNodeType === FlowNodeTypeEnum.tools);
-
-//   toolModules.forEach((item) => {
-//     const toolOutput = item.outputs.find(
-//       (output) => output.key === NodeOutputKeyEnum.selectedTools
-//     );
-//     toolOutput?.targets.forEach((target) => {
-//       if (target.moduleId === node.moduleId) {
-//         sign = true;
-//       }
-//     });
-//   });
-
-//   return sign;
-// };
-
 export const getHistories = (history?: ChatItemType[] | number, histories: ChatItemType[] = []) => {
   if (!history) return [];
 
@@ -149,6 +129,17 @@ export const valueTypeFormat = (value: any, type?: WorkflowIOValueTypeEnum) => {
   return value;
 };
 
+export const checkQuoteQAValue = (quoteQA?: SearchDataResponseItemType[]) => {
+  if (!quoteQA) return undefined;
+  if (quoteQA.length === 0) {
+    return [];
+  }
+  if (quoteQA.some((item) => !item.q || !item.datasetId)) {
+    return undefined;
+  }
+  return quoteQA;
+};
+
 /* remove system variable */
 export const removeSystemVariable = (variables: Record<string, any>) => {
   const copyVariables = { ...variables };

packages/service/support/outLink/schema.ts

@@ -48,7 +48,8 @@ const OutLinkSchema = new Schema({
     default: false
   },
   showNodeStatus: {
-    type: Boolean
+    type: Boolean,
+    default: true
   },
   showRawSource: {
     type: Boolean

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

@@ -7,7 +7,7 @@ import { CommonErrEnum } from '@fastgpt/global/common/error/code/common';
 import { OwnerPermissionVal, ReadPermissionVal } from '@fastgpt/global/support/permission/constant';
 import { Permission } from '@fastgpt/global/support/permission/controller';
 
-export async function authFile({
+export const authCollectionFile = async ({
   fileId,
   per = OwnerPermissionVal,
   ...props
@@ -17,7 +17,7 @@ export async function authFile({
   AuthResponseType & {
     file: DatasetFileSchema;
   }
-> {
+> => {
   const authRes = await parseHeaderCert(props);
   const { teamId, tmbId } = authRes;
 
@@ -33,7 +33,7 @@ export async function authFile({
 
   const permission = new Permission({
     per: ReadPermissionVal,
-    isOwner: file.metadata?.tmbId === tmbId
+    isOwner: file.metadata?.uid === tmbId || file.metadata?.tmbId === tmbId
   });
 
   if (!permission.checkPer(per)) {
@@ -45,4 +45,4 @@ export async function authFile({
     permission,
     file
   };
-}
+};

packages/service/support/permission/controller.ts

@@ -413,7 +413,8 @@ export const createFileToken = (data: FileTokenQuery) => {
     return Promise.reject('System unset FILE_TOKEN_KEY');
   }
 
-  const expireMinutes = bucketNameMap[data.bucketName].previewExpireMinutes;
+  const expireMinutes =
+    data.customExpireMinutes ?? bucketNameMap[data.bucketName].previewExpireMinutes;
   const expiredTime = Math.floor(addMinutes(new Date(), expireMinutes).getTime() / 1000);
 
   const key = (process.env.FILE_TOKEN_KEY as string) ?? 'filetoken';
@@ -435,14 +436,14 @@ export const authFileToken = (token?: string) =>
     const key = (process.env.FILE_TOKEN_KEY as string) ?? 'filetoken';
 
     jwt.verify(token, key, function (err, decoded: any) {
-      if (err || !decoded.bucketName || !decoded?.teamId || !decoded?.tmbId || !decoded?.fileId) {
+      if (err || !decoded.bucketName || !decoded?.teamId || !decoded?.fileId) {
         reject(ERROR_ENUM.unAuthFile);
         return;
       }
       resolve({
         bucketName: decoded.bucketName,
         teamId: decoded.teamId,
-        tmbId: decoded.tmbId,
+        uid: decoded.uid,
         fileId: decoded.fileId
       });
     });

packages/service/support/permission/publish/authLink.ts

@@ -62,14 +62,14 @@ export async function authOutLinkValid<T extends OutlinkAppType = undefined>({
   if (!shareId) {
     return Promise.reject(OutLinkErrEnum.linkUnInvalid);
   }
-  const shareChat = (await MongoOutLink.findOne({ shareId }).lean()) as OutLinkSchema<T>;
+  const outLinkConfig = (await MongoOutLink.findOne({ shareId }).lean()) as OutLinkSchema<T>;
 
-  if (!shareChat) {
+  if (!outLinkConfig) {
     return Promise.reject(OutLinkErrEnum.linkUnInvalid);
   }
 
   return {
-    appId: shareChat.appId,
+    appId: outLinkConfig.appId,
-    shareChat
+    outLinkConfig
   };
 }

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

@@ -2,6 +2,7 @@ import { Permission } from '@fastgpt/global/support/permission/controller';
 import { ApiRequestProps } from '../../type/next';
 import type { PermissionValueType } from '@fastgpt/global/support/permission/type';
 import { RequireAtLeastOne } from '@fastgpt/global/common/type/utils';
+import { AuthUserTypeEnum } from '@fastgpt/global/support/permission/constant';
 
 export type ReqHeaderAuthType = {
   cookie?: string;

packages/service/type.d.ts

@@ -23,9 +23,6 @@ declare global {
   var whisperModel: WhisperModelType;
   var reRankModels: ReRankModelItemType[];
 
-  var systemLoadedGlobalVariables: boolean;
-  var systemLoadedGlobalConfig: boolean;
-
   var workerPoll: Record<WorkerNameEnum, WorkerPool>;
   var appMarketTemplates: TemplateMarketItemType[];
 }

packages/service/worker/htmlStr2Md/utils.ts

@@ -1,5 +1,6 @@
 import TurndownService from 'turndown';
 import { ImageType } from '../readFile/type';
+import { matchMdImgTextAndUpload } from '@fastgpt/global/common/string/markdown';
 // @ts-ignore
 const turndownPluginGfm = require('joplin-turndown-plugin-gfm');
 
@@ -24,23 +25,10 @@ export const html2md = (
     turndownService.remove(['i', 'script', 'iframe', 'style']);
     turndownService.use(turndownPluginGfm.gfm);
 
-    const base64Regex = /"(data:image\/[^;]+;base64[^"]+)"/g;
+    const { text, imageList } = matchMdImgTextAndUpload(html);
-    const imageList: ImageType[] = [];
-    const images = Array.from(html.match(base64Regex) || []);
-    for (const image of images) {
-      const uuid = crypto.randomUUID();
-      const mime = image.split(';')[0].split(':')[1];
-      const base64 = image.split(',')[1];
-      html = html.replace(image, uuid);
-      imageList.push({
-        uuid,
-        base64,
-        mime
-      });
-    }
 
     return {
-      rawText: turndownService.turndown(html),
+      rawText: turndownService.turndown(text),
       imageList
     };
   } catch (error) {

packages/service/worker/readFile/extension/rawText.ts

@@ -18,9 +18,17 @@ const rawEncodingList = [
 
 // 加载源文件内容
 export const readFileRawText = ({ buffer, encoding }: ReadRawTextByBuffer): ReadFileResponse => {
-  const content = rawEncodingList.includes(encoding)
+  const content = (() => {
-    ? buffer.toString(encoding as BufferEncoding)
+    try {
-    : iconv.decode(buffer, 'gbk');
+      if (rawEncodingList.includes(encoding)) {
+        return buffer.toString(encoding as BufferEncoding);
+      }
+
+      return iconv.decode(buffer, encoding);
+    } catch (error) {
+      return buffer.toString('utf-8');
+    }
+  })();
 
   return {
     rawText: content