fix: fix: update plugin debugging host and port environment variables

.github/ISSUE_TEMPLATE/tracker.yml

@@ -1,13 +0,0 @@
-name: "👾 Tracker"
-description: For inner usages, please donot use this template.
-title: "[Tracker] "
-labels:
-  - tracker
-body:
-  - type: textarea
-    id: content
-    attributes:
-      label: Blockers
-      placeholder: "- [ ] ..."
-    validations:
-      required: true

.gitignore

@@ -183,7 +183,6 @@ docker/nginx/conf.d/default.conf
 docker/nginx/ssl/*
 !docker/nginx/ssl/.gitkeep
 docker/middleware.env
-docker/docker-compose.override.yaml
 
 sdks/python-client/build
 sdks/python-client/dist

CONTRIBUTING_TW.md

@@ -1,153 +0,0 @@
-# 貢獻指南
-
-您想為 Dify 做出貢獻 - 這太棒了，我們迫不及待地想看看您的成果。作為一家人力和資金有限的初創公司，我們有宏大的抱負，希望設計出最直觀的工作流程來構建和管理 LLM 應用程式。來自社群的任何幫助都非常珍貴，真的。
-
-鑑於我們的現狀，我們需要靈活且快速地發展，但同時也希望確保像您這樣的貢獻者能夠獲得盡可能順暢的貢獻體驗。我們編寫了這份貢獻指南，目的是幫助您熟悉代碼庫以及我們如何與貢獻者合作，讓您可以更快地進入有趣的部分。
-
-這份指南，就像 Dify 本身一樣，是不斷發展的。如果有時它落後於實際項目，我們非常感謝您的理解，也歡迎任何改進的反饋。
-
-關於授權，請花一分鐘閱讀我們簡短的[授權和貢獻者協議](./LICENSE)。社群也遵守[行為準則](https://github.com/langgenius/.github/blob/main/CODE_OF_CONDUCT.md)。
-
-## 在開始之前
-
-[尋找](https://github.com/langgenius/dify/issues?q=is:issue+is:open)現有的 issue，或[創建](https://github.com/langgenius/dify/issues/new/choose)一個新的。我們將 issues 分為 2 種類型：
-
-### 功能請求
-
-- 如果您要開啟新的功能請求，我們希望您能解釋所提議的功能要達成什麼目標，並且盡可能包含更多的相關背景資訊。[@perzeusss](https://github.com/perzeuss) 已經製作了一個實用的[功能請求輔助工具](https://udify.app/chat/MK2kVSnw1gakVwMX)，能幫助您草擬您的需求。歡迎試用。
-
-- 如果您想從現有問題中選擇一個來處理，只需在其下方留言表示即可。
-
-  相關方向的團隊成員會加入討論。如果一切順利，他們會同意您開始編寫代碼。我們要求您在得到許可前先不要開始處理該功能，以免我們提出變更時您的工作成果被浪費。
-
-  根據所提議功能的領域不同，您可能會與不同的團隊成員討論。以下是目前每位團隊成員所負責的領域概述：
-
-  | 成員                                                                                    | 負責領域                       |
-  | --------------------------------------------------------------------------------------- | ------------------------------ |
-  | [@yeuoly](https://github.com/Yeuoly)                                                    | 設計 Agents 架構               |
-  | [@jyong](https://github.com/JohnJyong)                                                  | RAG 管道設計                   |
-  | [@GarfieldDai](https://github.com/GarfieldDai)                                          | 建構工作流程編排               |
-  | [@iamjoel](https://github.com/iamjoel) & [@zxhlyh](https://github.com/zxhlyh)           | 打造易用的前端界面             |
-  | [@guchenhe](https://github.com/guchenhe) & [@crazywoola](https://github.com/crazywoola) | 開發者體驗，各類問題的聯絡窗口 |
-  | [@takatost](https://github.com/takatost)                                                | 整體產品方向與架構             |
-
-  我們如何排定優先順序：
-
-  | 功能類型                                                                                                | 優先級   |
-  | ------------------------------------------------------------------------------------------------------- | -------- |
-  | 被團隊成員標記為高優先級的功能                                                                          | 高優先級 |
-  | 來自我們[社群回饋版](https://github.com/langgenius/dify/discussions/categories/feedbacks)的熱門功能請求 | 中優先級 |
-  | 非核心功能和次要增強                                                                                    | 低優先級 |
-  | 有價值但非急迫的功能                                                                                    | 未來功能 |
-
-### 其他事項 (例如錯誤回報、效能優化、錯字更正)
-
-- 可以直接開始編寫程式碼。
-
-  我們如何排定優先順序：
-
-  | 問題類型                                              | 優先級   |
-  | ----------------------------------------------------- | -------- |
-  | 核心功能的錯誤 (無法登入、應用程式無法運行、安全漏洞) | 重要     |
-  | 非關鍵性錯誤、效能提升                                | 中優先級 |
-  | 小修正 (錯字、令人困惑但仍可運作的使用者界面)         | 低優先級 |
-
-## 安裝
-
-以下是設置 Dify 開發環境的步驟：
-
-### 1. 分叉此存儲庫
-
-### 2. 複製代碼庫
-
-從您的終端機複製分叉的代碼庫：
-
-```shell
-git clone git@github.com:<github_username>/dify.git
-```
-
-- [Docker](https://www.docker.com/)
-- [Docker Compose](https://docs.docker.com/compose/install/)
-- [Node.js v18.x (LTS)](http://nodejs.org)
-- [pnpm](https://pnpm.io/)
-- [Python](https://www.python.org/) version 3.11.x or 3.12.x
-
-### 4. 安裝
-
-Dify 由後端和前端組成。透過 `cd api/` 導航至後端目錄，然後按照[後端 README](api/README.md)進行安裝。在另一個終端機視窗中，透過 `cd web/` 導航至前端目錄，然後按照[前端 README](web/README.md)進行安裝。
-
-查閱[安裝常見問題](https://docs.dify.ai/learn-more/faq/install-faq)了解常見問題和故障排除步驟的列表。
-
-### 5. 在瀏覽器中訪問 Dify
-
-要驗證您的設置，請在瀏覽器中訪問 [http://localhost:3000](http://localhost:3000)（預設值，或您自行設定的 URL 和埠號）。現在您應該能看到 Dify 已啟動並運行。
-
-## 開發
-
-如果您要添加模型提供者，請參考[此指南](https://github.com/langgenius/dify/blob/main/api/core/model_runtime/README.md)。
-
-如果您要為 Agent 或工作流程添加工具提供者，請參考[此指南](./api/core/tools/README.md)。
-
-為了幫助您快速找到您的貢獻適合的位置，以下是 Dify 後端和前端的簡要註解大綱：
-
-### 後端
-
-Dify 的後端使用 Python 的 [Flask](https://flask.palletsprojects.com/en/3.0.x/) 框架編寫。它使用 [SQLAlchemy](https://www.sqlalchemy.org/) 作為 ORM 工具，使用 [Celery](https://docs.celeryq.dev/en/stable/getting-started/introduction.html) 進行任務佇列處理。授權邏輯則透過 Flask-login 實現。
-
-```text
-[api/]
-├── constants             // 整個專案中使用的常數與設定值
-├── controllers           // API 路由定義與請求處理邏輯
-├── core                  // 核心應用服務、模型整合與工具實現
-├── docker                // Docker 容器化相關設定檔案
-├── events                // 事件處理與流程管理機制
-├── extensions            // 與第三方框架或平台的整合擴充功能
-├── fields                // 資料序列化與結構定義欄位
-├── libs                  // 可重複使用的共用程式庫與輔助工具
-├── migrations            // 資料庫結構變更與遷移腳本
-├── models                // 資料庫模型與資料結構定義
-├── services              // 核心業務邏輯與功能實現
-├── storage               // 私鑰與敏感資訊儲存機制
-├── tasks                 // 非同步任務與背景作業處理器
-└── tests
-```
-
-### 前端
-
-網站基於 [Next.js](https://nextjs.org/) 的 Typescript 樣板，並使用 [Tailwind CSS](https://tailwindcss.com/) 進行樣式設計。[React-i18next](https://react.i18next.com/) 用於國際化。
-
-```text
-[web/]
-├── app                   // 頁面佈局與介面元件
-│   ├── (commonLayout)    // 應用程式共用佈局結構
-│   ├── (shareLayout)     // Token 會話專用共享佈局
-│   ├── activate          // 帳號啟用頁面
-│   ├── components        // 頁面與佈局共用元件
-│   ├── install           // 系統安裝頁面
-│   ├── signin            // 使用者登入頁面
-│   └── styles            // 全域共用樣式定義
-├── assets                // 靜態資源檔案庫
-├── bin                   // 建構流程執行腳本
-├── config                // 系統可調整設定與選項
-├── context               // 應用程式狀態共享上下文
-├── dictionaries          // 多語系翻譯詞彙庫
-├── docker                // Docker 容器設定檔
-├── hooks                 // 可重複使用的 React Hooks
-├── i18n                  // 國際化與本地化設定
-├── models                // 資料結構與 API 回應模型
-├── public                // 靜態資源與網站圖標
-├── service               // API 操作介面定義
-├── test                  // 測試用例與測試框架
-├── types                 // TypeScript 型別定義
-└── utils                 // 共用輔助功能函式庫
-```
-
-## 提交您的 PR
-
-最後，是時候向我們的存儲庫開啟拉取請求（PR）了。對於主要功能，我們會先將它們合併到 `deploy/dev` 分支進行測試，然後才會進入 `main` 分支。如果您遇到合併衝突或不知道如何開啟拉取請求等問題，請查看 [GitHub 的拉取請求教學](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests)。
-
-就是這樣！一旦您的 PR 被合併，您將作為貢獻者出現在我們的 [README](https://github.com/langgenius/dify/blob/main/README.md) 中。
-
-## 獲取幫助
-
-如果您在貢獻過程中遇到困難或有迫切的問題，只需通過相關的 GitHub issue 向我們提問，或加入我們的 [Discord](https://discord.gg/8Tpq4AcN9c) 進行快速交流。

README.md

@@ -40,7 +40,6 @@
 
 <p align="center">
   <a href="./README.md"><img alt="README in English" src="https://img.shields.io/badge/English-d9d9d9"></a>
-  <a href="./README_TW.md"><img alt="繁體中文文件" src="https://img.shields.io/badge/繁體中文-d9d9d9"></a>
   <a href="./README_CN.md"><img alt="简体中文版自述文件" src="https://img.shields.io/badge/简体中文-d9d9d9"></a>
   <a href="./README_JA.md"><img alt="日本語のREADME" src="https://img.shields.io/badge/日本語-d9d9d9"></a>
   <a href="./README_ES.md"><img alt="README en Español" src="https://img.shields.io/badge/Español-d9d9d9"></a>
@@ -54,14 +53,14 @@
   <a href="./README_BN.md"><img alt="README in বাংলা" src="https://img.shields.io/badge/বাংলা-d9d9d9"></a>
 </p>
 
-Dify is an open-source LLM app development platform. Its intuitive interface combines agentic AI workflow, RAG pipeline, agent capabilities, model management, observability features and more, letting you quickly go from prototype to production.
+
+Dify is an open-source LLM app development platform. Its intuitive interface combines agentic AI workflow, RAG pipeline, agent capabilities, model management, observability features and more, letting you quickly go from prototype to production. 
 
 ## Quick start
-
 > Before installing Dify, make sure your machine meets the following minimum system requirements:
->
-> - CPU >= 2 Core
-> - RAM >= 4 GiB
+> 
+>- CPU >= 2 Core
+>- RAM >= 4 GiB
 
 </br>
 
@@ -77,40 +76,41 @@ docker compose up -d
 After running, you can access the Dify dashboard in your browser at [http://localhost/install](http://localhost/install) and start the initialization process.
 
 #### Seeking help
-
 Please refer to our [FAQ](https://docs.dify.ai/getting-started/install-self-hosted/faqs) if you encounter problems setting up Dify. Reach out to [the community and us](#community--contact) if you are still having issues.
 
 > If you'd like to contribute to Dify or do additional development, refer to our [guide to deploying from source code](https://docs.dify.ai/getting-started/install-self-hosted/local-source-code)
 
 ## Key features
+**1. Workflow**: 
+  Build and test powerful AI workflows on a visual canvas, leveraging all the following features and beyond.
 
-**1. Workflow**:
-Build and test powerful AI workflows on a visual canvas, leveraging all the following features and beyond.
 
-https://github.com/langgenius/dify/assets/13230914/356df23e-1604-483d-80a6-9517ece318aa
+  https://github.com/langgenius/dify/assets/13230914/356df23e-1604-483d-80a6-9517ece318aa
 
-**2. Comprehensive model support**:
-Seamless integration with hundreds of proprietary / open-source LLMs from dozens of inference providers and self-hosted solutions, covering GPT, Mistral, Llama3, and any OpenAI API-compatible models. A full list of supported model providers can be found [here](https://docs.dify.ai/getting-started/readme/model-providers).
+
+
+**2. Comprehensive model support**: 
+  Seamless integration with hundreds of proprietary / open-source LLMs from dozens of inference providers and self-hosted solutions, covering GPT, Mistral, Llama3, and any OpenAI API-compatible models. A full list of supported model providers can be found [here](https://docs.dify.ai/getting-started/readme/model-providers).
 
 ![providers-v5](https://github.com/langgenius/dify/assets/13230914/5a17bdbe-097a-4100-8363-40255b70f6e3)
 
-**3. Prompt IDE**:
-Intuitive interface for crafting prompts, comparing model performance, and adding additional features such as text-to-speech to a chat-based app.
 
-**4. RAG Pipeline**:
-Extensive RAG capabilities that cover everything from document ingestion to retrieval, with out-of-box support for text extraction from PDFs, PPTs, and other common document formats.
+**3. Prompt IDE**: 
+  Intuitive interface for crafting prompts, comparing model performance, and adding additional features such as text-to-speech to a chat-based app. 
 
-**5. Agent capabilities**:
-You can define agents based on LLM Function Calling or ReAct, and add pre-built or custom tools for the agent. Dify provides 50+ built-in tools for AI agents, such as Google Search, DALL·E, Stable Diffusion and WolframAlpha.
+**4. RAG Pipeline**: 
+  Extensive RAG capabilities that cover everything from document ingestion to retrieval, with out-of-box support for text extraction from PDFs, PPTs, and other common document formats.
 
-**6. LLMOps**:
-Monitor and analyze application logs and performance over time. You could continuously improve prompts, datasets, and models based on production data and annotations.
+**5. Agent capabilities**: 
+  You can define agents based on LLM Function Calling or ReAct, and add pre-built or custom tools for the agent. Dify provides 50+ built-in tools for AI agents, such as Google Search, DALL·E, Stable Diffusion and WolframAlpha.
 
-**7. Backend-as-a-Service**:
-All of Dify's offerings come with corresponding APIs, so you could effortlessly integrate Dify into your own business logic.
+**6. LLMOps**: 
+  Monitor and analyze application logs and performance over time. You could continuously improve prompts, datasets, and models based on production data and annotations.
+
+**7. Backend-as-a-Service**: 
+  All of Dify's offerings come with corresponding APIs, so you could effortlessly integrate Dify into your own business logic.
 
 ## Feature Comparison
-
 <table style="width: 100%;">
   <tr>
     <th align="center">Feature</th>
@@ -180,22 +180,24 @@ All of Dify's offerings come with corresponding APIs, so you could effortlessly
 ## Using Dify
 
 - **Cloud </br>**
-  We host a [Dify Cloud](https://dify.ai) service for anyone to try with zero setup. It provides all the capabilities of the self-deployed version, and includes 200 free GPT-4 calls in the sandbox plan.
+We host a [Dify Cloud](https://dify.ai) service for anyone to try with zero setup. It provides all the capabilities of the self-deployed version, and includes 200 free GPT-4 calls in the sandbox plan.
 
 - **Self-hosting Dify Community Edition</br>**
-  Quickly get Dify running in your environment with this [starter guide](#quick-start).
-  Use our [documentation](https://docs.dify.ai) for further references and more in-depth instructions.
+Quickly get Dify running in your environment with this [starter guide](#quick-start).
+Use our [documentation](https://docs.dify.ai) for further references and more in-depth instructions.
 
 - **Dify for enterprise / organizations</br>**
-  We provide additional enterprise-centric features. [Log your questions for us through this chatbot](https://udify.app/chat/22L1zSxg6yW1cWQg) or [send us an email](mailto:business@dify.ai?subject=[GitHub]Business%20License%20Inquiry) to discuss enterprise needs. </br>
+We provide additional enterprise-centric features. [Log your questions for us through this chatbot](https://udify.app/chat/22L1zSxg6yW1cWQg) or [send us an email](mailto:business@dify.ai?subject=[GitHub]Business%20License%20Inquiry) to discuss enterprise needs. </br>
   > For startups and small businesses using AWS, check out [Dify Premium on AWS Marketplace](https://aws.amazon.com/marketplace/pp/prodview-t22mebxzwjhu6) and deploy it to your own AWS VPC with one-click. It's an affordable AMI offering with the option to create apps with custom logo and branding.
 
+
 ## Staying ahead
 
 Star Dify on GitHub and be instantly notified of new releases.
 
 ![star-us](https://github.com/langgenius/dify/assets/13230914/b823edc1-6388-4e25-ad45-2f6b187adbb4)
 
+
 ## Advanced Setup
 
 If you need to customize the configuration, please refer to the comments in our [.env.example](docker/.env.example) file and update the corresponding values in your `.env` file. Additionally, you might need to make adjustments to the `docker-compose.yaml` file itself, such as changing image versions, port mappings, or volume mounts, based on your specific deployment environment and requirements. After making any changes, please re-run `docker-compose up -d`. You can find the full list of available environment variables [here](https://docs.dify.ai/getting-started/install-self-hosted/environments).
@@ -211,34 +213,32 @@ If you'd like to configure a highly-available setup, there are community-contrib
 Deploy Dify to Cloud Platform with a single click using [terraform](https://www.terraform.io/)
 
 ##### Azure Global
-
 - [Azure Terraform by @nikawang](https://github.com/nikawang/dify-azure-terraform)
 
 ##### Google Cloud
-
 - [Google Cloud Terraform by @sotazum](https://github.com/DeNA/dify-google-cloud-terraform)
 
 #### Using AWS CDK for Deployment
 
 Deploy Dify to AWS with [CDK](https://aws.amazon.com/cdk/)
 
-##### AWS
-
+##### AWS 
 - [AWS CDK by @KevinZhao](https://github.com/aws-samples/solution-for-deploying-dify-on-aws)
 
 ## Contributing
 
-For those who'd like to contribute code, see our [Contribution Guide](https://github.com/langgenius/dify/blob/main/CONTRIBUTING.md).
+For those who'd like to contribute code, see our [Contribution Guide](https://github.com/langgenius/dify/blob/main/CONTRIBUTING.md). 
 At the same time, please consider supporting Dify by sharing it on social media and at events and conferences.
 
+
 > We are looking for contributors to help with translating Dify to languages other than Mandarin or English. If you are interested in helping, please see the [i18n README](https://github.com/langgenius/dify/blob/main/web/i18n/README.md) for more information, and leave us a comment in the `global-users` channel of our [Discord Community Server](https://discord.gg/8Tpq4AcN9c).
 
 ## Community & contact
 
-- [Github Discussion](https://github.com/langgenius/dify/discussions). Best for: sharing feedback and asking questions.
-- [GitHub Issues](https://github.com/langgenius/dify/issues). Best for: bugs you encounter using Dify.AI, and feature proposals. See our [Contribution Guide](https://github.com/langgenius/dify/blob/main/CONTRIBUTING.md).
-- [Discord](https://discord.gg/FngNHpbcY7). Best for: sharing your applications and hanging out with the community.
-- [X(Twitter)](https://twitter.com/dify_ai). Best for: sharing your applications and hanging out with the community.
+* [Github Discussion](https://github.com/langgenius/dify/discussions). Best for: sharing feedback and asking questions.
+* [GitHub Issues](https://github.com/langgenius/dify/issues). Best for: bugs you encounter using Dify.AI, and feature proposals. See our [Contribution Guide](https://github.com/langgenius/dify/blob/main/CONTRIBUTING.md).
+* [Discord](https://discord.gg/FngNHpbcY7). Best for: sharing your applications and hanging out with the community.
+* [X(Twitter)](https://twitter.com/dify_ai). Best for: sharing your applications and hanging out with the community.
 
 **Contributors**
 
@@ -250,6 +250,7 @@ At the same time, please consider supporting Dify by sharing it on social media
 
 [![Star History Chart](https://api.star-history.com/svg?repos=langgenius/dify&type=Date)](https://star-history.com/#langgenius/dify&Date)
 
+
 ## Security disclosure
 
 To protect your privacy, please avoid posting security issues on GitHub. Instead, send your questions to security@dify.ai and we will provide you with a more detailed answer.
@@ -257,3 +258,4 @@ To protect your privacy, please avoid posting security issues on GitHub. Instead
 ## License
 
 This repository is available under the [Dify Open Source License](LICENSE), which is essentially Apache 2.0 with a few additional restrictions.
+

README_TW.md

@@ -1,258 +0,0 @@
-![cover-v5-optimized](https://github.com/langgenius/dify/assets/13230914/f9e19af5-61ba-4119-b926-d10c4c06ebab)
-
-<p align="center">
-  📌 <a href="https://dify.ai/blog/introducing-dify-workflow-file-upload-a-demo-on-ai-podcast">介紹 Dify 工作流程檔案上傳功能：重現 Google NotebookLM Podcast</a>
-</p>
-
-<p align="center">
-  <a href="https://cloud.dify.ai">Dify 雲端服務</a> ·
-  <a href="https://docs.dify.ai/getting-started/install-self-hosted">自行託管</a> ·
-  <a href="https://docs.dify.ai">說明文件</a> ·
-  <a href="https://udify.app/chat/22L1zSxg6yW1cWQg">企業諮詢</a>
-</p>
-
-<p align="center">
-    <a href="https://dify.ai" target="_blank">
-        <img alt="Static Badge" src="https://img.shields.io/badge/Product-F04438"></a>
-    <a href="https://dify.ai/pricing" target="_blank">
-        <img alt="Static Badge" src="https://img.shields.io/badge/free-pricing?logo=free&color=%20%23155EEF&label=pricing&labelColor=%20%23528bff"></a>
-    <a href="https://discord.gg/FngNHpbcY7" target="_blank">
-        <img src="https://img.shields.io/discord/1082486657678311454?logo=discord&labelColor=%20%235462eb&logoColor=%20%23f5f5f5&color=%20%235462eb"
-            alt="chat on Discord"></a>
-    <a href="https://reddit.com/r/difyai" target="_blank">  
-        <img src="https://img.shields.io/reddit/subreddit-subscribers/difyai?style=plastic&logo=reddit&label=r%2Fdifyai&labelColor=white"
-            alt="join Reddit"></a>
-    <a href="https://twitter.com/intent/follow?screen_name=dify_ai" target="_blank">
-        <img src="https://img.shields.io/twitter/follow/dify_ai?logo=X&color=%20%23f5f5f5"
-            alt="follow on X(Twitter)"></a>
-    <a href="https://www.linkedin.com/company/langgenius/" target="_blank">
-        <img src="https://custom-icon-badges.demolab.com/badge/LinkedIn-0A66C2?logo=linkedin-white&logoColor=fff"
-            alt="follow on LinkedIn"></a>
-    <a href="https://hub.docker.com/u/langgenius" target="_blank">
-        <img alt="Docker Pulls" src="https://img.shields.io/docker/pulls/langgenius/dify-web?labelColor=%20%23FDB062&color=%20%23f79009"></a>
-    <a href="https://github.com/langgenius/dify/graphs/commit-activity" target="_blank">
-        <img alt="Commits last month" src="https://img.shields.io/github/commit-activity/m/langgenius/dify?labelColor=%20%2332b583&color=%20%2312b76a"></a>
-    <a href="https://github.com/langgenius/dify/" target="_blank">
-        <img alt="Issues closed" src="https://img.shields.io/github/issues-search?query=repo%3Alanggenius%2Fdify%20is%3Aclosed&label=issues%20closed&labelColor=%20%237d89b0&color=%20%235d6b98"></a>
-    <a href="https://github.com/langgenius/dify/discussions/" target="_blank">
-        <img alt="Discussion posts" src="https://img.shields.io/github/discussions/langgenius/dify?labelColor=%20%239b8afb&color=%20%237a5af8"></a>
-</p>
-
-<p align="center">
-  <a href="./README.md"><img alt="README in English" src="https://img.shields.io/badge/English-d9d9d9"></a>
-  <a href="./README_TW.md"><img alt="繁體中文文件" src="https://img.shields.io/badge/繁體中文-d9d9d9"></a>
-  <a href="./README_CN.md"><img alt="简体中文版自述文件" src="https://img.shields.io/badge/简体中文-d9d9d9"></a>
-  <a href="./README_JA.md"><img alt="日本語のREADME" src="https://img.shields.io/badge/日本語-d9d9d9"></a>
-  <a href="./README_ES.md"><img alt="README en Español" src="https://img.shields.io/badge/Español-d9d9d9"></a>
-  <a href="./README_FR.md"><img alt="README en Français" src="https://img.shields.io/badge/Français-d9d9d9"></a>
-  <a href="./README_KL.md"><img alt="README tlhIngan Hol" src="https://img.shields.io/badge/Klingon-d9d9d9"></a>
-  <a href="./README_KR.md"><img alt="README in Korean" src="https://img.shields.io/badge/한국어-d9d9d9"></a>
-  <a href="./README_AR.md"><img alt="README بالعربية" src="https://img.shields.io/badge/العربية-d9d9d9"></a>
-  <a href="./README_TR.md"><img alt="Türkçe README" src="https://img.shields.io/badge/Türkçe-d9d9d9"></a>
-  <a href="./README_VI.md"><img alt="README Tiếng Việt" src="https://img.shields.io/badge/Ti%E1%BA%BFng%20Vi%E1%BB%87t-d9d9d9"></a>
-  <a href="./README_DE.md"><img alt="README in Deutsch" src="https://img.shields.io/badge/German-d9d9d9"></a>
-</p>
-
-Dify 是一個開源的 LLM 應用程式開發平台。其直觀的界面結合了智能代理工作流程、RAG 管道、代理功能、模型管理、可觀察性功能等，讓您能夠快速從原型進展到生產環境。
-
-## 快速開始
-
-> 安裝 Dify 之前，請確保您的機器符合以下最低系統要求：
->
-> - CPU >= 2 核心
-> - 記憶體 >= 4 GiB
-
-</br>
-
-啟動 Dify 伺服器最簡單的方式是透過 [docker compose](docker/docker-compose.yaml)。在使用以下命令運行 Dify 之前，請確保您的機器已安裝 [Docker](https://docs.docker.com/get-docker/) 和 [Docker Compose](https://docs.docker.com/compose/install/)：
-
-```bash
-cd dify
-cd docker
-cp .env.example .env
-docker compose up -d
-```
-
-運行後，您可以在瀏覽器中通過 [http://localhost/install](http://localhost/install) 訪問 Dify 儀表板並開始初始化過程。
-
-### 尋求幫助
-
-如果您在設置 Dify 時遇到問題，請參考我們的 [常見問題](https://docs.dify.ai/getting-started/install-self-hosted/faqs)。如果仍有疑問，請聯絡 [社區和我們](#community--contact)。
-
-> 如果您想為 Dify 做出貢獻或進行額外開發，請參考我們的 [從原始碼部署指南](https://docs.dify.ai/getting-started/install-self-hosted/local-source-code)
-
-## 核心功能
-
-**1. 工作流程**：
-在視覺化畫布上建立和測試強大的 AI 工作流程，利用以下所有功能及更多。
-
-https://github.com/langgenius/dify/assets/13230914/356df23e-1604-483d-80a6-9517ece318aa
-
-**2. 全面的模型支援**：
-無縫整合來自數十個推理提供商和自託管解決方案的數百個專有/開源 LLM，涵蓋 GPT、Mistral、Llama3 和任何與 OpenAI API 兼容的模型。您可以在[此處](https://docs.dify.ai/getting-started/readme/model-providers)找到支援的模型提供商完整列表。
-
-![providers-v5](https://github.com/langgenius/dify/assets/13230914/5a17bdbe-097a-4100-8363-40255b70f6e3)
-
-**3. 提示詞 IDE**：
-直觀的界面，用於編寫提示詞、比較模型性能，以及為聊天型應用程式添加文字轉語音等額外功能。
-
-**4. RAG 管道**：
-廣泛的 RAG 功能，涵蓋從文件擷取到檢索的全部流程，內建支援從 PDF、PPT 和其他常見文件格式提取文本。
-
-**5. 代理功能**：
-您可以基於 LLM 函數調用或 ReAct 定義代理，並為代理添加預構建或自定義工具。Dify 為 AI 代理提供 50 多種內建工具，如 Google 搜尋、DALL·E、Stable Diffusion 和 WolframAlpha。
-
-**6. LLMOps**：
-監控並分析應用程式日誌和長期效能。您可以根據生產數據和標註持續改進提示詞、數據集和模型。
-
-**7. 後端即服務**：
-Dify 的所有功能都提供相應的 API，因此您可以輕鬆地將 Dify 整合到您自己的業務邏輯中。
-
-## 功能比較
-
-<table style="width: 100%;">
-  <tr>
-    <th align="center">功能</th>
-    <th align="center">Dify.AI</th>
-    <th align="center">LangChain</th>
-    <th align="center">Flowise</th>
-    <th align="center">OpenAI Assistants API</th>
-  </tr>
-  <tr>
-    <td align="center">程式設計方法</td>
-    <td align="center">API + 應用導向</td>
-    <td align="center">Python 代碼</td>
-    <td align="center">應用導向</td>
-    <td align="center">API 導向</td>
-  </tr>
-  <tr>
-    <td align="center">支援的 LLM 模型</td>
-    <td align="center">豐富多樣</td>
-    <td align="center">豐富多樣</td>
-    <td align="center">豐富多樣</td>
-    <td align="center">僅限 OpenAI</td>
-  </tr>
-  <tr>
-    <td align="center">RAG 引擎</td>
-    <td align="center">✅</td>
-    <td align="center">✅</td>
-    <td align="center">✅</td>
-    <td align="center">✅</td>
-  </tr>
-  <tr>
-    <td align="center">代理功能</td>
-    <td align="center">✅</td>
-    <td align="center">✅</td>
-    <td align="center">❌</td>
-    <td align="center">✅</td>
-  </tr>
-  <tr>
-    <td align="center">工作流程</td>
-    <td align="center">✅</td>
-    <td align="center">❌</td>
-    <td align="center">✅</td>
-    <td align="center">❌</td>
-  </tr>
-  <tr>
-    <td align="center">可觀察性</td>
-    <td align="center">✅</td>
-    <td align="center">✅</td>
-    <td align="center">❌</td>
-    <td align="center">❌</td>
-  </tr>
-  <tr>
-    <td align="center">企業級功能 (SSO/存取控制)</td>
-    <td align="center">✅</td>
-    <td align="center">❌</td>
-    <td align="center">❌</td>
-    <td align="center">❌</td>
-  </tr>
-  <tr>
-    <td align="center">本地部署</td>
-    <td align="center">✅</td>
-    <td align="center">✅</td>
-    <td align="center">✅</td>
-    <td align="center">❌</td>
-  </tr>
-</table>
-
-## 使用 Dify
-
-- **雲端服務 </br>**
-  我們提供 [Dify Cloud](https://dify.ai) 服務，任何人都可以零配置嘗試。它提供與自部署版本相同的所有功能，並在沙盒計劃中包含 200 次免費 GPT-4 調用。
-
-- **自託管 Dify 社區版</br>**
-  使用這份[快速指南](#快速開始)在您的環境中快速運行 Dify。
-  使用我們的[文檔](https://docs.dify.ai)獲取更多參考和深入指導。
-
-- **企業/組織版 Dify</br>**
-  我們提供額外的企業中心功能。[通過這個聊天機器人記錄您的問題](https://udify.app/chat/22L1zSxg6yW1cWQg)或[發送電子郵件給我們](mailto:business@dify.ai?subject=[GitHub]Business%20License%20Inquiry)討論企業需求。</br>
-  > 對於使用 AWS 的初創企業和小型企業，請查看 [AWS Marketplace 上的 Dify Premium](https://aws.amazon.com/marketplace/pp/prodview-t22mebxzwjhu6)，並一鍵部署到您自己的 AWS VPC。這是一個經濟實惠的 AMI 產品，可選擇使用自定義徽標和品牌創建應用。
-
-## 保持領先
-
-在 GitHub 上為 Dify 加星，即時獲取新版本通知。
-
-![star-us](https://github.com/langgenius/dify/assets/13230914/b823edc1-6388-4e25-ad45-2f6b187adbb4)
-
-## 進階設定
-
-如果您需要自定義配置，請參考我們的 [.env.example](docker/.env.example) 文件中的註釋，並在您的 `.env` 文件中更新相應的值。此外，根據您特定的部署環境和需求，您可能需要調整 `docker-compose.yaml` 文件本身，例如更改映像版本、端口映射或卷掛載。進行任何更改後，請重新運行 `docker-compose up -d`。您可以在[這裡](https://docs.dify.ai/getting-started/install-self-hosted/environments)找到可用環境變數的完整列表。
-
-如果您想配置高可用性設置，社區貢獻的 [Helm Charts](https://helm.sh/) 和 YAML 文件允許在 Kubernetes 上部署 Dify。
-
-- [由 @LeoQuote 提供的 Helm Chart](https://github.com/douban/charts/tree/master/charts/dify)
-- [由 @BorisPolonsky 提供的 Helm Chart](https://github.com/BorisPolonsky/dify-helm)
-- [由 @Winson-030 提供的 YAML 文件](https://github.com/Winson-030/dify-kubernetes)
-
-### 使用 Terraform 進行部署
-
-使用 [terraform](https://www.terraform.io/) 一鍵部署 Dify 到雲端平台
-
-### Azure 全球
-
-- [由 @nikawang 提供的 Azure Terraform](https://github.com/nikawang/dify-azure-terraform)
-
-### Google Cloud
-
-- [由 @sotazum 提供的 Google Cloud Terraform](https://github.com/DeNA/dify-google-cloud-terraform)
-
-### 使用 AWS CDK 進行部署
-
-使用 [CDK](https://aws.amazon.com/cdk/) 部署 Dify 到 AWS
-
-### AWS
-
-- [由 @KevinZhao 提供的 AWS CDK](https://github.com/aws-samples/solution-for-deploying-dify-on-aws)
-
-## 貢獻
-
-對於想要貢獻程式碼的開發者，請參閱我們的[貢獻指南](https://github.com/langgenius/dify/blob/main/CONTRIBUTING.md)。
-同時，也請考慮透過在社群媒體和各種活動與會議上分享 Dify 來支持我們。
-
-> 我們正在尋找貢獻者協助將 Dify 翻譯成中文和英文以外的語言。如果您有興趣幫忙，請查看 [i18n README](https://github.com/langgenius/dify/blob/main/web/i18n/README.md) 獲取更多資訊，並在我們的 [Discord 社群伺服器](https://discord.gg/8Tpq4AcN9c) 的 `global-users` 頻道留言給我們。
-
-## 社群與聯絡方式
-
-- [Github Discussion](https://github.com/langgenius/dify/discussions)：最適合分享反饋和提問。
-- [GitHub Issues](https://github.com/langgenius/dify/issues)：最適合報告使用 Dify.AI 時遇到的問題和提出功能建議。請參閱我們的[貢獻指南](https://github.com/langgenius/dify/blob/main/CONTRIBUTING.md)。
-- [Discord](https://discord.gg/FngNHpbcY7)：最適合分享您的應用程式並與社群互動。
-- [X(Twitter)](https://twitter.com/dify_ai)：最適合分享您的應用程式並與社群互動。
-
-**貢獻者**
-
-<a href="https://github.com/langgenius/dify/graphs/contributors">
-  <img src="https://contrib.rocks/image?repo=langgenius/dify" />
-</a>
-
-## 星星歷史
-
-[![Star History Chart](https://api.star-history.com/svg?repos=langgenius/dify&type=Date)](https://star-history.com/#langgenius/dify&Date)
-
-## 安全揭露
-
-為保護您的隱私，請避免在 GitHub 上發布安全性問題。請將您的問題發送至 security@dify.ai，我們將為您提供更詳細的答覆。
-
-## 授權條款
-
-本代碼庫採用 [Dify 開源授權](LICENSE)，這基本上是 Apache 2.0 授權加上一些額外限制條款。

api/configs/packaging/__init__.py

@@ -9,7 +9,7 @@ class PackagingInfo(BaseSettings):
 
     CURRENT_VERSION: str = Field(
         description="Dify version",
-        default="1.0.1",
+        default="1.0.0",
     )
 
     COMMIT_SHA: str = Field(

api/controllers/console/__init__.py

@@ -71,7 +71,7 @@ from .app import (
 from .auth import activate, data_source_bearer_auth, data_source_oauth, forgot_password, login, oauth
 
 # Import billing controllers
-from .billing import billing, compliance
+from .billing import billing
 
 # Import datasets controllers
 from .datasets import (

api/controllers/console/app/app.py

@@ -316,7 +316,7 @@ class AppTraceApi(Resource):
     @account_initialization_required
     def post(self, app_id):
         # add app trace
-        if not current_user.is_editing_role:
+        if not current_user.is_admin_or_owner:
             raise Forbidden()
         parser = reqparse.RequestParser()
         parser.add_argument("enabled", type=bool, required=True, location="json")

api/controllers/console/app/workflow.py

@@ -1,10 +1,8 @@
 import json
 import logging
-from typing import cast
 
 from flask import abort, request
 from flask_restful import Resource, inputs, marshal_with, reqparse  # type: ignore
-from sqlalchemy.orm import Session
 from werkzeug.exceptions import Forbidden, InternalServerError, NotFound
 
 import services
@@ -15,7 +13,6 @@ from controllers.console.app.wraps import get_app_model
 from controllers.console.wraps import account_initialization_required, setup_required
 from core.app.apps.base_app_queue_manager import AppQueueManager
 from core.app.entities.app_invoke_entities import InvokeFrom
-from extensions.ext_database import db
 from factories import variable_factory
 from fields.workflow_fields import workflow_fields, workflow_pagination_fields
 from fields.workflow_run_fields import workflow_run_node_execution_fields
@@ -27,7 +24,7 @@ from models.account import Account
 from models.model import AppMode
 from services.app_generate_service import AppGenerateService
 from services.errors.app import WorkflowHashNotEqualError
-from services.workflow_service import DraftWorkflowDeletionError, WorkflowInUseError, WorkflowService
+from services.workflow_service import WorkflowService
 
 logger = logging.getLogger(__name__)
 
@@ -249,80 +246,6 @@ class WorkflowDraftRunIterationNodeApi(Resource):
             raise InternalServerError()
 
 
-class AdvancedChatDraftRunLoopNodeApi(Resource):
-    @setup_required
-    @login_required
-    @account_initialization_required
-    @get_app_model(mode=[AppMode.ADVANCED_CHAT])
-    def post(self, app_model: App, node_id: str):
-        """
-        Run draft workflow loop node
-        """
-        # The role of the current user in the ta table must be admin, owner, or editor
-        if not current_user.is_editor:
-            raise Forbidden()
-
-        if not isinstance(current_user, Account):
-            raise Forbidden()
-
-        parser = reqparse.RequestParser()
-        parser.add_argument("inputs", type=dict, location="json")
-        args = parser.parse_args()
-
-        try:
-            response = AppGenerateService.generate_single_loop(
-                app_model=app_model, user=current_user, node_id=node_id, args=args, streaming=True
-            )
-
-            return helper.compact_generate_response(response)
-        except services.errors.conversation.ConversationNotExistsError:
-            raise NotFound("Conversation Not Exists.")
-        except services.errors.conversation.ConversationCompletedError:
-            raise ConversationCompletedError()
-        except ValueError as e:
-            raise e
-        except Exception:
-            logging.exception("internal server error.")
-            raise InternalServerError()
-
-
-class WorkflowDraftRunLoopNodeApi(Resource):
-    @setup_required
-    @login_required
-    @account_initialization_required
-    @get_app_model(mode=[AppMode.WORKFLOW])
-    def post(self, app_model: App, node_id: str):
-        """
-        Run draft workflow loop node
-        """
-        # The role of the current user in the ta table must be admin, owner, or editor
-        if not current_user.is_editor:
-            raise Forbidden()
-
-        if not isinstance(current_user, Account):
-            raise Forbidden()
-
-        parser = reqparse.RequestParser()
-        parser.add_argument("inputs", type=dict, location="json")
-        args = parser.parse_args()
-
-        try:
-            response = AppGenerateService.generate_single_loop(
-                app_model=app_model, user=current_user, node_id=node_id, args=args, streaming=True
-            )
-
-            return helper.compact_generate_response(response)
-        except services.errors.conversation.ConversationNotExistsError:
-            raise NotFound("Conversation Not Exists.")
-        except services.errors.conversation.ConversationCompletedError:
-            raise ConversationCompletedError()
-        except ValueError as e:
-            raise e
-        except Exception:
-            logging.exception("internal server error.")
-            raise InternalServerError()
-
-
 class DraftWorkflowRunApi(Resource):
     @setup_required
     @login_required
@@ -442,38 +365,10 @@ class PublishedWorkflowApi(Resource):
         if not isinstance(current_user, Account):
             raise Forbidden()
 
-        parser = reqparse.RequestParser()
-        parser.add_argument("marked_name", type=str, required=False, default="", location="json")
-        parser.add_argument("marked_comment", type=str, required=False, default="", location="json")
-        args = parser.parse_args()
-
-        # Validate name and comment length
-        if args.marked_name and len(args.marked_name) > 20:
-            raise ValueError("Marked name cannot exceed 20 characters")
-        if args.marked_comment and len(args.marked_comment) > 100:
-            raise ValueError("Marked comment cannot exceed 100 characters")
-
         workflow_service = WorkflowService()
-        with Session(db.engine) as session:
-            workflow = workflow_service.publish_workflow(
-                session=session,
-                app_model=app_model,
-                account=current_user,
-                marked_name=args.marked_name or "",
-                marked_comment=args.marked_comment or "",
-            )
+        workflow = workflow_service.publish_workflow(app_model=app_model, account=current_user)
 
-            app_model.workflow_id = workflow.id
-            db.session.commit()
-
-            workflow_created_at = TimestampField().format(workflow.created_at)
-
-            session.commit()
-
-        return {
-            "result": "success",
-            "created_at": workflow_created_at,
-        }
+        return {"result": "success", "created_at": TimestampField().format(workflow.created_at)}
 
 
 class DefaultBlockConfigsApi(Resource):
@@ -595,193 +490,32 @@ class PublishedAllWorkflowApi(Resource):
         parser = reqparse.RequestParser()
         parser.add_argument("page", type=inputs.int_range(1, 99999), required=False, default=1, location="args")
         parser.add_argument("limit", type=inputs.int_range(1, 100), required=False, default=20, location="args")
-        parser.add_argument("user_id", type=str, required=False, location="args")
-        parser.add_argument("named_only", type=inputs.boolean, required=False, default=False, location="args")
         args = parser.parse_args()
-        page = int(args.get("page", 1))
-        limit = int(args.get("limit", 10))
-        user_id = args.get("user_id")
-        named_only = args.get("named_only", False)
-
-        if user_id:
-            if user_id != current_user.id:
-                raise Forbidden()
-            user_id = cast(str, user_id)
-
+        page = args.get("page")
+        limit = args.get("limit")
         workflow_service = WorkflowService()
-        with Session(db.engine) as session:
-            workflows, has_more = workflow_service.get_all_published_workflow(
-                session=session,
-                app_model=app_model,
-                page=page,
-                limit=limit,
-                user_id=user_id,
-                named_only=named_only,
-            )
+        workflows, has_more = workflow_service.get_all_published_workflow(app_model=app_model, page=page, limit=limit)
 
-            return {
-                "items": workflows,
-                "page": page,
-                "limit": limit,
-                "has_more": has_more,
-            }
+        return {"items": workflows, "page": page, "limit": limit, "has_more": has_more}
 
 
-class WorkflowByIdApi(Resource):
-    @setup_required
-    @login_required
-    @account_initialization_required
-    @get_app_model(mode=[AppMode.ADVANCED_CHAT, AppMode.WORKFLOW])
-    @marshal_with(workflow_fields)
-    def patch(self, app_model: App, workflow_id: str):
-        """
-        Update workflow attributes
-        """
-        # Check permission
-        if not current_user.is_editor:
-            raise Forbidden()
-
-        if not isinstance(current_user, Account):
-            raise Forbidden()
-
-        parser = reqparse.RequestParser()
-        parser.add_argument("marked_name", type=str, required=False, location="json")
-        parser.add_argument("marked_comment", type=str, required=False, location="json")
-        args = parser.parse_args()
-
-        # Validate name and comment length
-        if args.marked_name and len(args.marked_name) > 20:
-            raise ValueError("Marked name cannot exceed 20 characters")
-        if args.marked_comment and len(args.marked_comment) > 100:
-            raise ValueError("Marked comment cannot exceed 100 characters")
-        args = parser.parse_args()
-
-        # Prepare update data
-        update_data = {}
-        if args.get("marked_name") is not None:
-            update_data["marked_name"] = args["marked_name"]
-        if args.get("marked_comment") is not None:
-            update_data["marked_comment"] = args["marked_comment"]
-
-        if not update_data:
-            return {"message": "No valid fields to update"}, 400
-
-        workflow_service = WorkflowService()
-
-        # Create a session and manage the transaction
-        with Session(db.engine, expire_on_commit=False) as session:
-            workflow = workflow_service.update_workflow(
-                session=session,
-                workflow_id=workflow_id,
-                tenant_id=app_model.tenant_id,
-                account_id=current_user.id,
-                data=update_data,
-            )
-
-            if not workflow:
-                raise NotFound("Workflow not found")
-
-            # Commit the transaction in the controller
-            session.commit()
-
-        return workflow
-
-    @setup_required
-    @login_required
-    @account_initialization_required
-    @get_app_model(mode=[AppMode.ADVANCED_CHAT, AppMode.WORKFLOW])
-    def delete(self, app_model: App, workflow_id: str):
-        """
-        Delete workflow
-        """
-        # Check permission
-        if not current_user.is_editor:
-            raise Forbidden()
-
-        if not isinstance(current_user, Account):
-            raise Forbidden()
-
-        workflow_service = WorkflowService()
-
-        # Create a session and manage the transaction
-        with Session(db.engine) as session:
-            try:
-                workflow_service.delete_workflow(
-                    session=session, workflow_id=workflow_id, tenant_id=app_model.tenant_id
-                )
-                # Commit the transaction in the controller
-                session.commit()
-            except WorkflowInUseError as e:
-                abort(400, description=str(e))
-            except DraftWorkflowDeletionError as e:
-                abort(400, description=str(e))
-            except ValueError as e:
-                raise NotFound(str(e))
-
-        return None, 204
-
-
-api.add_resource(
-    DraftWorkflowApi,
-    "/apps/<uuid:app_id>/workflows/draft",
-)
-api.add_resource(
-    WorkflowConfigApi,
-    "/apps/<uuid:app_id>/workflows/draft/config",
-)
-api.add_resource(
-    AdvancedChatDraftWorkflowRunApi,
-    "/apps/<uuid:app_id>/advanced-chat/workflows/draft/run",
-)
-api.add_resource(
-    DraftWorkflowRunApi,
-    "/apps/<uuid:app_id>/workflows/draft/run",
-)
-api.add_resource(
-    WorkflowTaskStopApi,
-    "/apps/<uuid:app_id>/workflow-runs/tasks/<string:task_id>/stop",
-)
-api.add_resource(
-    DraftWorkflowNodeRunApi,
-    "/apps/<uuid:app_id>/workflows/draft/nodes/<string:node_id>/run",
-)
+api.add_resource(DraftWorkflowApi, "/apps/<uuid:app_id>/workflows/draft")
+api.add_resource(WorkflowConfigApi, "/apps/<uuid:app_id>/workflows/draft/config")
+api.add_resource(AdvancedChatDraftWorkflowRunApi, "/apps/<uuid:app_id>/advanced-chat/workflows/draft/run")
+api.add_resource(DraftWorkflowRunApi, "/apps/<uuid:app_id>/workflows/draft/run")
+api.add_resource(WorkflowTaskStopApi, "/apps/<uuid:app_id>/workflow-runs/tasks/<string:task_id>/stop")
+api.add_resource(DraftWorkflowNodeRunApi, "/apps/<uuid:app_id>/workflows/draft/nodes/<string:node_id>/run")
 api.add_resource(
     AdvancedChatDraftRunIterationNodeApi,
     "/apps/<uuid:app_id>/advanced-chat/workflows/draft/iteration/nodes/<string:node_id>/run",
 )
 api.add_resource(
-    WorkflowDraftRunIterationNodeApi,
-    "/apps/<uuid:app_id>/workflows/draft/iteration/nodes/<string:node_id>/run",
+    WorkflowDraftRunIterationNodeApi, "/apps/<uuid:app_id>/workflows/draft/iteration/nodes/<string:node_id>/run"
 )
+api.add_resource(PublishedWorkflowApi, "/apps/<uuid:app_id>/workflows/publish")
+api.add_resource(PublishedAllWorkflowApi, "/apps/<uuid:app_id>/workflows")
+api.add_resource(DefaultBlockConfigsApi, "/apps/<uuid:app_id>/workflows/default-workflow-block-configs")
 api.add_resource(
-    AdvancedChatDraftRunLoopNodeApi,
-    "/apps/<uuid:app_id>/advanced-chat/workflows/draft/loop/nodes/<string:node_id>/run",
-)
-api.add_resource(
-    WorkflowDraftRunLoopNodeApi,
-    "/apps/<uuid:app_id>/workflows/draft/loop/nodes/<string:node_id>/run",
-)
-api.add_resource(
-    PublishedWorkflowApi,
-    "/apps/<uuid:app_id>/workflows/publish",
-)
-api.add_resource(
-    PublishedAllWorkflowApi,
-    "/apps/<uuid:app_id>/workflows",
-)
-api.add_resource(
-    DefaultBlockConfigsApi,
-    "/apps/<uuid:app_id>/workflows/default-workflow-block-configs",
-)
-api.add_resource(
-    DefaultBlockConfigApi,
-    "/apps/<uuid:app_id>/workflows/default-workflow-block-configs/<string:block_type>",
-)
-api.add_resource(
-    ConvertToWorkflowApi,
-    "/apps/<uuid:app_id>/convert-to-workflow",
-)
-api.add_resource(
-    WorkflowByIdApi,
-    "/apps/<uuid:app_id>/workflows/<string:workflow_id>",
+    DefaultBlockConfigApi, "/apps/<uuid:app_id>/workflows/default-workflow-block-configs/<string:block_type>"
 )
+api.add_resource(ConvertToWorkflowApi, "/apps/<uuid:app_id>/convert-to-workflow")

api/controllers/console/app/workflow_app_log.py

@@ -1,18 +1,13 @@
-from datetime import datetime
-
 from flask_restful import Resource, marshal_with, reqparse  # type: ignore
 from flask_restful.inputs import int_range  # type: ignore
-from sqlalchemy.orm import Session
 
 from controllers.console import api
 from controllers.console.app.wraps import get_app_model
 from controllers.console.wraps import account_initialization_required, setup_required
-from extensions.ext_database import db
 from fields.workflow_app_log_fields import workflow_app_log_pagination_fields
 from libs.login import login_required
 from models import App
 from models.model import AppMode
-from models.workflow import WorkflowRunStatus
 from services.workflow_app_service import WorkflowAppService
 
 
@@ -29,38 +24,17 @@ class WorkflowAppLogApi(Resource):
         parser = reqparse.RequestParser()
         parser.add_argument("keyword", type=str, location="args")
         parser.add_argument("status", type=str, choices=["succeeded", "failed", "stopped"], location="args")
-        parser.add_argument(
-            "created_at__before", type=str, location="args", help="Filter logs created before this timestamp"
-        )
-        parser.add_argument(
-            "created_at__after", type=str, location="args", help="Filter logs created after this timestamp"
-        )
         parser.add_argument("page", type=int_range(1, 99999), default=1, location="args")
         parser.add_argument("limit", type=int_range(1, 100), default=20, location="args")
         args = parser.parse_args()
 
-        args.status = WorkflowRunStatus(args.status) if args.status else None
-        if args.created_at__before:
-            args.created_at__before = datetime.fromisoformat(args.created_at__before.replace("Z", "+00:00"))
-
-        if args.created_at__after:
-            args.created_at__after = datetime.fromisoformat(args.created_at__after.replace("Z", "+00:00"))
-
         # get paginate workflow app logs
         workflow_app_service = WorkflowAppService()
-        with Session(db.engine) as session:
-            workflow_app_log_pagination = workflow_app_service.get_paginate_workflow_app_logs(
-                session=session,
-                app_model=app_model,
-                keyword=args.keyword,
-                status=args.status,
-                created_at_before=args.created_at__before,
-                created_at_after=args.created_at__after,
-                page=args.page,
-                limit=args.limit,
-            )
+        workflow_app_log_pagination = workflow_app_service.get_paginate_workflow_app_logs(
+            app_model=app_model, args=args
+        )
 
-            return workflow_app_log_pagination
+        return workflow_app_log_pagination
 
 
 api.add_resource(WorkflowAppLogApi, "/apps/<uuid:app_id>/workflow-app-logs")

api/controllers/console/billing/compliance.py

@@ -1,35 +0,0 @@
-from flask import request
-from flask_login import current_user  # type: ignore
-from flask_restful import Resource, reqparse  # type: ignore
-
-from libs.helper import extract_remote_ip
-from libs.login import login_required
-from services.billing_service import BillingService
-
-from .. import api
-from ..wraps import account_initialization_required, only_edition_cloud, setup_required
-
-
-class ComplianceApi(Resource):
-    @setup_required
-    @login_required
-    @account_initialization_required
-    @only_edition_cloud
-    def get(self):
-        parser = reqparse.RequestParser()
-        parser.add_argument("doc_name", type=str, required=True, location="args")
-        args = parser.parse_args()
-
-        ip_address = extract_remote_ip(request)
-        device_info = request.headers.get("User-Agent", "Unknown device")
-
-        return BillingService.get_compliance_download_link(
-            doc_name=args.doc_name,
-            account_id=current_user.id,
-            tenant_id=current_user.current_tenant_id,
-            ip=ip_address,
-            device_info=device_info,
-        )
-
-
-api.add_resource(ComplianceApi, "/compliance/download")

api/controllers/console/datasets/data_source.py

@@ -122,7 +122,7 @@ class DataSourceNotionListApi(Resource):
                 if dataset.data_source_type != "notion_import":
                     raise ValueError("Dataset is not notion type.")
 
-                documents = session.scalars(
+                documents = session.execute(
                     select(Document).filter_by(
                         dataset_id=dataset_id,
                         tenant_id=current_user.current_tenant_id,

api/controllers/console/datasets/datasets.py

@@ -10,12 +10,7 @@ from controllers.console import api
 from controllers.console.apikey import api_key_fields, api_key_list
 from controllers.console.app.error import ProviderNotInitializeError
 from controllers.console.datasets.error import DatasetInUseError, DatasetNameDuplicateError, IndexingEstimateError
-from controllers.console.wraps import (
-    account_initialization_required,
-    cloud_edition_billing_rate_limit_check,
-    enterprise_license_required,
-    setup_required,
-)
+from controllers.console.wraps import account_initialization_required, enterprise_license_required, setup_required
 from core.errors.error import LLMBadRequestError, ProviderTokenNotInitError
 from core.indexing_runner import IndexingRunner
 from core.model_runtime.entities.model_entities import ModelType
@@ -101,7 +96,6 @@ class DatasetListApi(Resource):
     @setup_required
     @login_required
     @account_initialization_required
-    @cloud_edition_billing_rate_limit_check("knowledge")
     def post(self):
         parser = reqparse.RequestParser()
         parser.add_argument(
@@ -216,7 +210,6 @@ class DatasetApi(Resource):
     @setup_required
     @login_required
     @account_initialization_required
-    @cloud_edition_billing_rate_limit_check("knowledge")
     def patch(self, dataset_id):
         dataset_id_str = str(dataset_id)
         dataset = DatasetService.get_dataset(dataset_id_str)
@@ -283,11 +276,7 @@ class DatasetApi(Resource):
         data = request.get_json()
 
         # check embedding model setting
-        if (
-            data.get("indexing_technique") == "high_quality"
-            and data.get("embedding_model_provider") is not None
-            and data.get("embedding_model") is not None
-        ):
+        if data.get("indexing_technique") == "high_quality":
             DatasetService.check_embedding_model_setting(
                 dataset.tenant_id, data.get("embedding_model_provider"), data.get("embedding_model")
             )
@@ -324,7 +313,6 @@ class DatasetApi(Resource):
     @setup_required
     @login_required
     @account_initialization_required
-    @cloud_edition_billing_rate_limit_check("knowledge")
     def delete(self, dataset_id):
         dataset_id_str = str(dataset_id)
 

api/controllers/console/datasets/datasets_document.py

@@ -26,7 +26,6 @@ from controllers.console.datasets.error import (
 )
 from controllers.console.wraps import (
     account_initialization_required,
-    cloud_edition_billing_rate_limit_check,
     cloud_edition_billing_resource_check,
     setup_required,
 )
@@ -243,7 +242,6 @@ class DatasetDocumentListApi(Resource):
     @account_initialization_required
     @marshal_with(documents_and_batch_fields)
     @cloud_edition_billing_resource_check("vector_space")
-    @cloud_edition_billing_rate_limit_check("knowledge")
     def post(self, dataset_id):
         dataset_id = str(dataset_id)
 
@@ -299,7 +297,6 @@ class DatasetDocumentListApi(Resource):
     @setup_required
     @login_required
     @account_initialization_required
-    @cloud_edition_billing_rate_limit_check("knowledge")
     def delete(self, dataset_id):
         dataset_id = str(dataset_id)
         dataset = DatasetService.get_dataset(dataset_id)
@@ -323,7 +320,6 @@ class DatasetInitApi(Resource):
     @account_initialization_required
     @marshal_with(dataset_and_document_fields)
     @cloud_edition_billing_resource_check("vector_space")
-    @cloud_edition_billing_rate_limit_check("knowledge")
     def post(self):
         # The role of the current user in the ta table must be admin, owner, or editor
         if not current_user.is_editor:
@@ -698,7 +694,6 @@ class DocumentProcessingApi(DocumentResource):
     @setup_required
     @login_required
     @account_initialization_required
-    @cloud_edition_billing_rate_limit_check("knowledge")
     def patch(self, dataset_id, document_id, action):
         dataset_id = str(dataset_id)
         document_id = str(document_id)
@@ -735,7 +730,6 @@ class DocumentDeleteApi(DocumentResource):
     @setup_required
     @login_required
     @account_initialization_required
-    @cloud_edition_billing_rate_limit_check("knowledge")
     def delete(self, dataset_id, document_id):
         dataset_id = str(dataset_id)
         document_id = str(document_id)
@@ -804,7 +798,6 @@ class DocumentStatusApi(DocumentResource):
     @login_required
     @account_initialization_required
     @cloud_edition_billing_resource_check("vector_space")
-    @cloud_edition_billing_rate_limit_check("knowledge")
     def patch(self, dataset_id, action):
         dataset_id = str(dataset_id)
         dataset = DatasetService.get_dataset(dataset_id)
@@ -900,7 +893,6 @@ class DocumentPauseApi(DocumentResource):
     @setup_required
     @login_required
     @account_initialization_required
-    @cloud_edition_billing_rate_limit_check("knowledge")
     def patch(self, dataset_id, document_id):
         """pause document."""
         dataset_id = str(dataset_id)
@@ -933,7 +925,6 @@ class DocumentRecoverApi(DocumentResource):
     @setup_required
     @login_required
     @account_initialization_required
-    @cloud_edition_billing_rate_limit_check("knowledge")
     def patch(self, dataset_id, document_id):
         """recover document."""
         dataset_id = str(dataset_id)
@@ -963,7 +954,6 @@ class DocumentRetryApi(DocumentResource):
     @setup_required
     @login_required
     @account_initialization_required
-    @cloud_edition_billing_rate_limit_check("knowledge")
     def post(self, dataset_id):
         """retry document."""
 

api/controllers/console/datasets/datasets_segments.py

@@ -19,7 +19,6 @@ from controllers.console.datasets.error import (
 from controllers.console.wraps import (
     account_initialization_required,
     cloud_edition_billing_knowledge_limit_check,
-    cloud_edition_billing_rate_limit_check,
     cloud_edition_billing_resource_check,
     setup_required,
 )
@@ -107,7 +106,6 @@ class DatasetDocumentSegmentListApi(Resource):
     @setup_required
     @login_required
     @account_initialization_required
-    @cloud_edition_billing_rate_limit_check("knowledge")
     def delete(self, dataset_id, document_id):
         # check dataset
         dataset_id = str(dataset_id)
@@ -139,7 +137,6 @@ class DatasetDocumentSegmentApi(Resource):
     @login_required
     @account_initialization_required
     @cloud_edition_billing_resource_check("vector_space")
-    @cloud_edition_billing_rate_limit_check("knowledge")
     def patch(self, dataset_id, document_id, action):
         dataset_id = str(dataset_id)
         dataset = DatasetService.get_dataset(dataset_id)
@@ -194,7 +191,6 @@ class DatasetDocumentSegmentAddApi(Resource):
     @account_initialization_required
     @cloud_edition_billing_resource_check("vector_space")
     @cloud_edition_billing_knowledge_limit_check("add_segment")
-    @cloud_edition_billing_rate_limit_check("knowledge")
     def post(self, dataset_id, document_id):
         # check dataset
         dataset_id = str(dataset_id)
@@ -244,7 +240,6 @@ class DatasetDocumentSegmentUpdateApi(Resource):
     @login_required
     @account_initialization_required
     @cloud_edition_billing_resource_check("vector_space")
-    @cloud_edition_billing_rate_limit_check("knowledge")
     def patch(self, dataset_id, document_id, segment_id):
         # check dataset
         dataset_id = str(dataset_id)
@@ -304,7 +299,6 @@ class DatasetDocumentSegmentUpdateApi(Resource):
     @setup_required
     @login_required
     @account_initialization_required
-    @cloud_edition_billing_rate_limit_check("knowledge")
     def delete(self, dataset_id, document_id, segment_id):
         # check dataset
         dataset_id = str(dataset_id)
@@ -342,7 +336,6 @@ class DatasetDocumentSegmentBatchImportApi(Resource):
     @account_initialization_required
     @cloud_edition_billing_resource_check("vector_space")
     @cloud_edition_billing_knowledge_limit_check("add_segment")
-    @cloud_edition_billing_rate_limit_check("knowledge")
     def post(self, dataset_id, document_id):
         # check dataset
         dataset_id = str(dataset_id)
@@ -409,7 +402,6 @@ class ChildChunkAddApi(Resource):
     @account_initialization_required
     @cloud_edition_billing_resource_check("vector_space")
     @cloud_edition_billing_knowledge_limit_check("add_segment")
-    @cloud_edition_billing_rate_limit_check("knowledge")
     def post(self, dataset_id, document_id, segment_id):
         # check dataset
         dataset_id = str(dataset_id)
@@ -507,7 +499,6 @@ class ChildChunkAddApi(Resource):
     @login_required
     @account_initialization_required
     @cloud_edition_billing_resource_check("vector_space")
-    @cloud_edition_billing_rate_limit_check("knowledge")
     def patch(self, dataset_id, document_id, segment_id):
         # check dataset
         dataset_id = str(dataset_id)
@@ -551,7 +542,6 @@ class ChildChunkUpdateApi(Resource):
     @setup_required
     @login_required
     @account_initialization_required
-    @cloud_edition_billing_rate_limit_check("knowledge")
     def delete(self, dataset_id, document_id, segment_id, child_chunk_id):
         # check dataset
         dataset_id = str(dataset_id)
@@ -596,7 +586,6 @@ class ChildChunkUpdateApi(Resource):
     @login_required
     @account_initialization_required
     @cloud_edition_billing_resource_check("vector_space")
-    @cloud_edition_billing_rate_limit_check("knowledge")
     def patch(self, dataset_id, document_id, segment_id, child_chunk_id):
         # check dataset
         dataset_id = str(dataset_id)

api/controllers/console/datasets/hit_testing.py

@@ -2,11 +2,7 @@ from flask_restful import Resource  # type: ignore
 
 from controllers.console import api
 from controllers.console.datasets.hit_testing_base import DatasetsHitTestingBase
-from controllers.console.wraps import (
-    account_initialization_required,
-    cloud_edition_billing_rate_limit_check,
-    setup_required,
-)
+from controllers.console.wraps import account_initialization_required, setup_required
 from libs.login import login_required
 
 
@@ -14,7 +10,6 @@ class HitTestingApi(Resource, DatasetsHitTestingBase):
     @setup_required
     @login_required
     @account_initialization_required
-    @cloud_edition_billing_rate_limit_check("knowledge")
     def post(self, dataset_id):
         dataset_id_str = str(dataset_id)
 

api/controllers/console/error.py

@@ -101,9 +101,3 @@ class AccountInFreezeError(BaseHTTPException):
         "This email account has been deleted within the past 30 days"
         "and is temporarily unavailable for new account registration."
     )
-
-
-class CompilanceRateLimitError(BaseHTTPException):
-    error_code = "compilance_rate_limit"
-    description = "Rate limit exceeded for downloading compliance report."
-    code = 429

api/controllers/console/workspace/workspace.py

@@ -26,7 +26,6 @@ from libs.helper import TimestampField
 from libs.login import login_required
 from models.account import Tenant, TenantStatus
 from services.account_service import TenantService
-from services.feature_service import FeatureService
 from services.file_service import FileService
 from services.workspace_service import WorkspaceService
 
@@ -69,11 +68,6 @@ class TenantListApi(Resource):
         tenants = TenantService.get_join_tenants(current_user)
 
         for tenant in tenants:
-            features = FeatureService.get_features(tenant.id)
-            if features.billing.enabled:
-                tenant.plan = features.billing.subscription.plan
-            else:
-                tenant.plan = "sandbox"
             if tenant.id == current_user.current_tenant_id:
                 tenant.current = True  # Set current=True for current tenant
         return {"workspaces": marshal(tenants, tenants_fields)}, 200

api/controllers/console/wraps.py

@@ -1,6 +1,5 @@
 import json
 import os
-import time
 from functools import wraps
 
 from flask import abort, request
@@ -9,8 +8,6 @@ from flask_login import current_user  # type: ignore
 from configs import dify_config
 from controllers.console.workspace.error import AccountNotInitializedError
 from extensions.ext_database import db
-from extensions.ext_redis import redis_client
-from models.dataset import RateLimitLog
 from models.model import DifySetup
 from services.feature_service import FeatureService, LicenseStatus
 from services.operation_service import OperationService
@@ -70,9 +67,7 @@ def cloud_edition_billing_resource_check(resource: str):
                 elif resource == "apps" and 0 < apps.limit <= apps.size:
                     abort(403, "The number of apps has reached the limit of your subscription.")
                 elif resource == "vector_space" and 0 < vector_space.limit <= vector_space.size:
-                    abort(
-                        403, "The capacity of the knowledge storage space has reached the limit of your subscription."
-                    )
+                    abort(403, "The capacity of the vector space has reached the limit of your subscription.")
                 elif resource == "documents" and 0 < documents_upload_quota.limit <= documents_upload_quota.size:
                     # The api of file upload is used in the multiple places,
                     # so we need to check the source of the request from datasets
@@ -117,41 +112,6 @@ def cloud_edition_billing_knowledge_limit_check(resource: str):
     return interceptor
 
 
-def cloud_edition_billing_rate_limit_check(resource: str):
-    def interceptor(view):
-        @wraps(view)
-        def decorated(*args, **kwargs):
-            if resource == "knowledge":
-                knowledge_rate_limit = FeatureService.get_knowledge_rate_limit(current_user.current_tenant_id)
-                if knowledge_rate_limit.enabled:
-                    current_time = int(time.time() * 1000)
-                    key = f"rate_limit_{current_user.current_tenant_id}"
-
-                    redis_client.zadd(key, {current_time: current_time})
-
-                    redis_client.zremrangebyscore(key, 0, current_time - 60000)
-
-                    request_count = redis_client.zcard(key)
-
-                    if request_count > knowledge_rate_limit.limit:
-                        # add ratelimit record
-                        rate_limit_log = RateLimitLog(
-                            tenant_id=current_user.current_tenant_id,
-                            subscription_plan=knowledge_rate_limit.subscription_plan,
-                            operation="knowledge",
-                        )
-                        db.session.add(rate_limit_log)
-                        db.session.commit()
-                        abort(
-                            403, "Sorry, you have reached the knowledge base request rate limit of your subscription."
-                        )
-            return view(*args, **kwargs)
-
-        return decorated
-
-    return interceptor
-
-
 def cloud_utm_record(view):
     @wraps(view)
     def decorated(*args, **kwargs):

api/controllers/service_api/app/message.py

@@ -70,7 +70,7 @@ class MessageListApi(Resource):
 
         try:
             return MessageService.pagination_by_first_id(
-                app_model, end_user, args["conversation_id"], args["first_id"], args["limit"]
+                app_model, end_user, args["conversation_id"], args["first_id"], args["limit"], "desc"
             )
         except services.errors.conversation.ConversationNotExistsError:
             raise NotFound("Conversation Not Exists.")

api/controllers/service_api/app/workflow.py

@@ -1,9 +1,7 @@
 import logging
-from datetime import datetime
 
 from flask_restful import Resource, fields, marshal_with, reqparse  # type: ignore
 from flask_restful.inputs import int_range  # type: ignore
-from sqlalchemy.orm import Session
 from werkzeug.exceptions import InternalServerError
 
 from controllers.service_api import api
@@ -27,7 +25,7 @@ from extensions.ext_database import db
 from fields.workflow_app_log_fields import workflow_app_log_pagination_fields
 from libs import helper
 from models.model import App, AppMode, EndUser
-from models.workflow import WorkflowRun, WorkflowRunStatus
+from models.workflow import WorkflowRun
 from services.app_generate_service import AppGenerateService
 from services.workflow_app_service import WorkflowAppService
 
@@ -127,34 +125,17 @@ class WorkflowAppLogApi(Resource):
         parser = reqparse.RequestParser()
         parser.add_argument("keyword", type=str, location="args")
         parser.add_argument("status", type=str, choices=["succeeded", "failed", "stopped"], location="args")
-        parser.add_argument("created_at__before", type=str, location="args")
-        parser.add_argument("created_at__after", type=str, location="args")
         parser.add_argument("page", type=int_range(1, 99999), default=1, location="args")
         parser.add_argument("limit", type=int_range(1, 100), default=20, location="args")
         args = parser.parse_args()
 
-        args.status = WorkflowRunStatus(args.status) if args.status else None
-        if args.created_at__before:
-            args.created_at__before = datetime.fromisoformat(args.created_at__before.replace("Z", "+00:00"))
-
-        if args.created_at__after:
-            args.created_at__after = datetime.fromisoformat(args.created_at__after.replace("Z", "+00:00"))
-
         # get paginate workflow app logs
         workflow_app_service = WorkflowAppService()
-        with Session(db.engine) as session:
-            workflow_app_log_pagination = workflow_app_service.get_paginate_workflow_app_logs(
-                session=session,
-                app_model=app_model,
-                keyword=args.keyword,
-                status=args.status,
-                created_at_before=args.created_at__before,
-                created_at_after=args.created_at__after,
-                page=args.page,
-                limit=args.limit,
-            )
+        workflow_app_log_pagination = workflow_app_service.get_paginate_workflow_app_logs(
+            app_model=app_model, args=args
+        )
 
-            return workflow_app_log_pagination
+        return workflow_app_log_pagination
 
 
 api.add_resource(WorkflowRunApi, "/workflows/run")

api/controllers/service_api/wraps.py

@@ -1,4 +1,3 @@
-import time
 from collections.abc import Callable
 from datetime import UTC, datetime, timedelta
 from enum import Enum
@@ -14,10 +13,8 @@ from sqlalchemy.orm import Session
 from werkzeug.exceptions import Forbidden, Unauthorized
 
 from extensions.ext_database import db
-from extensions.ext_redis import redis_client
 from libs.login import _get_user
 from models.account import Account, Tenant, TenantAccountJoin, TenantStatus
-from models.dataset import RateLimitLog
 from models.model import ApiToken, App, EndUser
 from services.feature_service import FeatureService
 
@@ -142,43 +139,6 @@ def cloud_edition_billing_knowledge_limit_check(resource: str, api_token_type: s
     return interceptor
 
 
-def cloud_edition_billing_rate_limit_check(resource: str, api_token_type: str):
-    def interceptor(view):
-        @wraps(view)
-        def decorated(*args, **kwargs):
-            api_token = validate_and_get_api_token(api_token_type)
-
-            if resource == "knowledge":
-                knowledge_rate_limit = FeatureService.get_knowledge_rate_limit(api_token.tenant_id)
-                if knowledge_rate_limit.enabled:
-                    current_time = int(time.time() * 1000)
-                    key = f"rate_limit_{api_token.tenant_id}"
-
-                    redis_client.zadd(key, {current_time: current_time})
-
-                    redis_client.zremrangebyscore(key, 0, current_time - 60000)
-
-                    request_count = redis_client.zcard(key)
-
-                    if request_count > knowledge_rate_limit.limit:
-                        # add ratelimit record
-                        rate_limit_log = RateLimitLog(
-                            tenant_id=api_token.tenant_id,
-                            subscription_plan=knowledge_rate_limit.subscription_plan,
-                            operation="knowledge",
-                        )
-                        db.session.add(rate_limit_log)
-                        db.session.commit()
-                        raise Forbidden(
-                            "Sorry, you have reached the knowledge base request rate limit of your subscription."
-                        )
-            return view(*args, **kwargs)
-
-        return decorated
-
-    return interceptor
-
-
 def validate_dataset_token(view=None):
     def decorator(view):
         @wraps(view)

api/core/app/apps/advanced_chat/app_generator.py

@@ -223,61 +223,6 @@ class AdvancedChatAppGenerator(MessageBasedAppGenerator):
             stream=streaming,
         )
 
-    def single_loop_generate(
-        self,
-        app_model: App,
-        workflow: Workflow,
-        node_id: str,
-        user: Account | EndUser,
-        args: Mapping,
-        streaming: bool = True,
-    ) -> Mapping[str, Any] | Generator[str | Mapping[str, Any], Any, None]:
-        """
-        Generate App response.
-
-        :param app_model: App
-        :param workflow: Workflow
-        :param user: account or end user
-        :param args: request args
-        :param invoke_from: invoke from source
-        :param stream: is stream
-        """
-        if not node_id:
-            raise ValueError("node_id is required")
-
-        if args.get("inputs") is None:
-            raise ValueError("inputs is required")
-
-        # convert to app config
-        app_config = AdvancedChatAppConfigManager.get_app_config(app_model=app_model, workflow=workflow)
-
-        # init application generate entity
-        application_generate_entity = AdvancedChatAppGenerateEntity(
-            task_id=str(uuid.uuid4()),
-            app_config=app_config,
-            conversation_id=None,
-            inputs={},
-            query="",
-            files=[],
-            user_id=user.id,
-            stream=streaming,
-            invoke_from=InvokeFrom.DEBUGGER,
-            extras={"auto_generate_conversation_name": False},
-            single_loop_run=AdvancedChatAppGenerateEntity.SingleLoopRunEntity(node_id=node_id, inputs=args["inputs"]),
-        )
-        contexts.tenant_id.set(application_generate_entity.app_config.tenant_id)
-        contexts.plugin_tool_providers.set({})
-        contexts.plugin_tool_providers_lock.set(threading.Lock())
-
-        return self._generate(
-            workflow=workflow,
-            user=user,
-            invoke_from=InvokeFrom.DEBUGGER,
-            application_generate_entity=application_generate_entity,
-            conversation=None,
-            stream=streaming,
-        )
-
     def _generate(
         self,
         *,

api/core/app/apps/advanced_chat/app_runner.py

@@ -79,13 +79,6 @@ class AdvancedChatAppRunner(WorkflowBasedAppRunner):
                 node_id=self.application_generate_entity.single_iteration_run.node_id,
                 user_inputs=dict(self.application_generate_entity.single_iteration_run.inputs),
             )
-        elif self.application_generate_entity.single_loop_run:
-            # if only single loop run is requested
-            graph, variable_pool = self._get_graph_and_variable_pool_of_single_loop(
-                workflow=workflow,
-                node_id=self.application_generate_entity.single_loop_run.node_id,
-                user_inputs=dict(self.application_generate_entity.single_loop_run.inputs),
-            )
         else:
             inputs = self.application_generate_entity.inputs
             query = self.application_generate_entity.query

api/core/app/apps/advanced_chat/generate_task_pipeline.py

@@ -23,14 +23,10 @@ from core.app.entities.queue_entities import (
     QueueIterationCompletedEvent,
     QueueIterationNextEvent,
     QueueIterationStartEvent,
-    QueueLoopCompletedEvent,
-    QueueLoopNextEvent,
-    QueueLoopStartEvent,
     QueueMessageReplaceEvent,
     QueueNodeExceptionEvent,
     QueueNodeFailedEvent,
     QueueNodeInIterationFailedEvent,
-    QueueNodeInLoopFailedEvent,
     QueueNodeRetryEvent,
     QueueNodeStartedEvent,
     QueueNodeSucceededEvent,
@@ -376,13 +372,7 @@ class AdvancedChatAppGenerateTaskPipeline:
 
                 if node_finish_resp:
                     yield node_finish_resp
-            elif isinstance(
-                event,
-                QueueNodeFailedEvent
-                | QueueNodeInIterationFailedEvent
-                | QueueNodeInLoopFailedEvent
-                | QueueNodeExceptionEvent,
-            ):
+            elif isinstance(event, QueueNodeFailedEvent | QueueNodeInIterationFailedEvent | QueueNodeExceptionEvent):
                 with Session(db.engine, expire_on_commit=False) as session:
                     workflow_node_execution = self._workflow_cycle_manager._handle_workflow_node_execution_failed(
                         session=session, event=event
@@ -482,54 +472,6 @@ class AdvancedChatAppGenerateTaskPipeline:
                     )
 
                 yield iter_finish_resp
-            elif isinstance(event, QueueLoopStartEvent):
-                if not self._workflow_run_id:
-                    raise ValueError("workflow run not initialized.")
-
-                with Session(db.engine, expire_on_commit=False) as session:
-                    workflow_run = self._workflow_cycle_manager._get_workflow_run(
-                        session=session, workflow_run_id=self._workflow_run_id
-                    )
-                    loop_start_resp = self._workflow_cycle_manager._workflow_loop_start_to_stream_response(
-                        session=session,
-                        task_id=self._application_generate_entity.task_id,
-                        workflow_run=workflow_run,
-                        event=event,
-                    )
-
-                yield loop_start_resp
-            elif isinstance(event, QueueLoopNextEvent):
-                if not self._workflow_run_id:
-                    raise ValueError("workflow run not initialized.")
-
-                with Session(db.engine, expire_on_commit=False) as session:
-                    workflow_run = self._workflow_cycle_manager._get_workflow_run(
-                        session=session, workflow_run_id=self._workflow_run_id
-                    )
-                    loop_next_resp = self._workflow_cycle_manager._workflow_loop_next_to_stream_response(
-                        session=session,
-                        task_id=self._application_generate_entity.task_id,
-                        workflow_run=workflow_run,
-                        event=event,
-                    )
-
-                yield loop_next_resp
-            elif isinstance(event, QueueLoopCompletedEvent):
-                if not self._workflow_run_id:
-                    raise ValueError("workflow run not initialized.")
-
-                with Session(db.engine, expire_on_commit=False) as session:
-                    workflow_run = self._workflow_cycle_manager._get_workflow_run(
-                        session=session, workflow_run_id=self._workflow_run_id
-                    )
-                    loop_finish_resp = self._workflow_cycle_manager._workflow_loop_completed_to_stream_response(
-                        session=session,
-                        task_id=self._application_generate_entity.task_id,
-                        workflow_run=workflow_run,
-                        event=event,
-                    )
-
-                yield loop_finish_resp
             elif isinstance(event, QueueWorkflowSucceededEvent):
                 if not self._workflow_run_id:
                     raise ValueError("workflow run not initialized.")

api/core/app/apps/workflow/app_generator.py

@@ -250,60 +250,6 @@ class WorkflowAppGenerator(BaseAppGenerator):
             streaming=streaming,
         )
 
-    def single_loop_generate(
-        self,
-        app_model: App,
-        workflow: Workflow,
-        node_id: str,
-        user: Account | EndUser,
-        args: Mapping[str, Any],
-        streaming: bool = True,
-    ) -> Mapping[str, Any] | Generator[str | Mapping[str, Any], None, None]:
-        """
-        Generate App response.
-
-        :param app_model: App
-        :param workflow: Workflow
-        :param user: account or end user
-        :param args: request args
-        :param invoke_from: invoke from source
-        :param stream: is stream
-        """
-        if not node_id:
-            raise ValueError("node_id is required")
-
-        if args.get("inputs") is None:
-            raise ValueError("inputs is required")
-
-        # convert to app config
-        app_config = WorkflowAppConfigManager.get_app_config(app_model=app_model, workflow=workflow)
-
-        # init application generate entity
-        application_generate_entity = WorkflowAppGenerateEntity(
-            task_id=str(uuid.uuid4()),
-            app_config=app_config,
-            inputs={},
-            files=[],
-            user_id=user.id,
-            stream=streaming,
-            invoke_from=InvokeFrom.DEBUGGER,
-            extras={"auto_generate_conversation_name": False},
-            single_loop_run=WorkflowAppGenerateEntity.SingleLoopRunEntity(node_id=node_id, inputs=args["inputs"]),
-            workflow_run_id=str(uuid.uuid4()),
-        )
-        contexts.tenant_id.set(application_generate_entity.app_config.tenant_id)
-        contexts.plugin_tool_providers.set({})
-        contexts.plugin_tool_providers_lock.set(threading.Lock())
-
-        return self._generate(
-            app_model=app_model,
-            workflow=workflow,
-            user=user,
-            invoke_from=InvokeFrom.DEBUGGER,
-            application_generate_entity=application_generate_entity,
-            streaming=streaming,
-        )
-
     def _generate_worker(
         self,
         flask_app: Flask,

api/core/app/apps/workflow/app_runner.py

@@ -81,13 +81,6 @@ class WorkflowAppRunner(WorkflowBasedAppRunner):
                 node_id=self.application_generate_entity.single_iteration_run.node_id,
                 user_inputs=self.application_generate_entity.single_iteration_run.inputs,
             )
-        elif self.application_generate_entity.single_loop_run:
-            # if only single loop run is requested
-            graph, variable_pool = self._get_graph_and_variable_pool_of_single_loop(
-                workflow=workflow,
-                node_id=self.application_generate_entity.single_loop_run.node_id,
-                user_inputs=self.application_generate_entity.single_loop_run.inputs,
-            )
         else:
             inputs = self.application_generate_entity.inputs
             files = self.application_generate_entity.files

api/core/app/apps/workflow/generate_task_pipeline.py

@@ -18,13 +18,9 @@ from core.app.entities.queue_entities import (
     QueueIterationCompletedEvent,
     QueueIterationNextEvent,
     QueueIterationStartEvent,
-    QueueLoopCompletedEvent,
-    QueueLoopNextEvent,
-    QueueLoopStartEvent,
     QueueNodeExceptionEvent,
     QueueNodeFailedEvent,
     QueueNodeInIterationFailedEvent,
-    QueueNodeInLoopFailedEvent,
     QueueNodeRetryEvent,
     QueueNodeStartedEvent,
     QueueNodeSucceededEvent,
@@ -327,13 +323,7 @@ class WorkflowAppGenerateTaskPipeline:
 
                 if node_success_response:
                     yield node_success_response
-            elif isinstance(
-                event,
-                QueueNodeFailedEvent
-                | QueueNodeInIterationFailedEvent
-                | QueueNodeInLoopFailedEvent
-                | QueueNodeExceptionEvent,
-            ):
+            elif isinstance(event, QueueNodeFailedEvent | QueueNodeInIterationFailedEvent | QueueNodeExceptionEvent):
                 with Session(db.engine, expire_on_commit=False) as session:
                     workflow_node_execution = self._workflow_cycle_manager._handle_workflow_node_execution_failed(
                         session=session,
@@ -439,57 +429,6 @@ class WorkflowAppGenerateTaskPipeline:
 
                 yield iter_finish_resp
 
-            elif isinstance(event, QueueLoopStartEvent):
-                if not self._workflow_run_id:
-                    raise ValueError("workflow run not initialized.")
-
-                with Session(db.engine, expire_on_commit=False) as session:
-                    workflow_run = self._workflow_cycle_manager._get_workflow_run(
-                        session=session, workflow_run_id=self._workflow_run_id
-                    )
-                    loop_start_resp = self._workflow_cycle_manager._workflow_loop_start_to_stream_response(
-                        session=session,
-                        task_id=self._application_generate_entity.task_id,
-                        workflow_run=workflow_run,
-                        event=event,
-                    )
-
-                yield loop_start_resp
-
-            elif isinstance(event, QueueLoopNextEvent):
-                if not self._workflow_run_id:
-                    raise ValueError("workflow run not initialized.")
-
-                with Session(db.engine, expire_on_commit=False) as session:
-                    workflow_run = self._workflow_cycle_manager._get_workflow_run(
-                        session=session, workflow_run_id=self._workflow_run_id
-                    )
-                    loop_next_resp = self._workflow_cycle_manager._workflow_loop_next_to_stream_response(
-                        session=session,
-                        task_id=self._application_generate_entity.task_id,
-                        workflow_run=workflow_run,
-                        event=event,
-                    )
-
-                yield loop_next_resp
-
-            elif isinstance(event, QueueLoopCompletedEvent):
-                if not self._workflow_run_id:
-                    raise ValueError("workflow run not initialized.")
-
-                with Session(db.engine, expire_on_commit=False) as session:
-                    workflow_run = self._workflow_cycle_manager._get_workflow_run(
-                        session=session, workflow_run_id=self._workflow_run_id
-                    )
-                    loop_finish_resp = self._workflow_cycle_manager._workflow_loop_completed_to_stream_response(
-                        session=session,
-                        task_id=self._application_generate_entity.task_id,
-                        workflow_run=workflow_run,
-                        event=event,
-                    )
-
-                yield loop_finish_resp
-
             elif isinstance(event, QueueWorkflowSucceededEvent):
                 if not self._workflow_run_id:
                     raise ValueError("workflow run not initialized.")

api/core/app/apps/workflow_app_runner.py

@@ -9,13 +9,9 @@ from core.app.entities.queue_entities import (
     QueueIterationCompletedEvent,
     QueueIterationNextEvent,
     QueueIterationStartEvent,
-    QueueLoopCompletedEvent,
-    QueueLoopNextEvent,
-    QueueLoopStartEvent,
     QueueNodeExceptionEvent,
     QueueNodeFailedEvent,
     QueueNodeInIterationFailedEvent,
-    QueueNodeInLoopFailedEvent,
     QueueNodeRetryEvent,
     QueueNodeStartedEvent,
     QueueNodeSucceededEvent,
@@ -42,12 +38,7 @@ from core.workflow.graph_engine.entities.event import (
     IterationRunNextEvent,
     IterationRunStartedEvent,
     IterationRunSucceededEvent,
-    LoopRunFailedEvent,
-    LoopRunNextEvent,
-    LoopRunStartedEvent,
-    LoopRunSucceededEvent,
     NodeInIterationFailedEvent,
-    NodeInLoopFailedEvent,
     NodeRunExceptionEvent,
     NodeRunFailedEvent,
     NodeRunRetrieverResourceEvent,
@@ -182,96 +173,6 @@ class WorkflowBasedAppRunner(AppRunner):
 
         return graph, variable_pool
 
-    def _get_graph_and_variable_pool_of_single_loop(
-        self,
-        workflow: Workflow,
-        node_id: str,
-        user_inputs: dict,
-    ) -> tuple[Graph, VariablePool]:
-        """
-        Get variable pool of single loop
-        """
-        # fetch workflow graph
-        graph_config = workflow.graph_dict
-        if not graph_config:
-            raise ValueError("workflow graph not found")
-
-        graph_config = cast(dict[str, Any], graph_config)
-
-        if "nodes" not in graph_config or "edges" not in graph_config:
-            raise ValueError("nodes or edges not found in workflow graph")
-
-        if not isinstance(graph_config.get("nodes"), list):
-            raise ValueError("nodes in workflow graph must be a list")
-
-        if not isinstance(graph_config.get("edges"), list):
-            raise ValueError("edges in workflow graph must be a list")
-
-        # filter nodes only in loop
-        node_configs = [
-            node
-            for node in graph_config.get("nodes", [])
-            if node.get("id") == node_id or node.get("data", {}).get("loop_id", "") == node_id
-        ]
-
-        graph_config["nodes"] = node_configs
-
-        node_ids = [node.get("id") for node in node_configs]
-
-        # filter edges only in loop
-        edge_configs = [
-            edge
-            for edge in graph_config.get("edges", [])
-            if (edge.get("source") is None or edge.get("source") in node_ids)
-            and (edge.get("target") is None or edge.get("target") in node_ids)
-        ]
-
-        graph_config["edges"] = edge_configs
-
-        # init graph
-        graph = Graph.init(graph_config=graph_config, root_node_id=node_id)
-
-        if not graph:
-            raise ValueError("graph not found in workflow")
-
-        # fetch node config from node id
-        loop_node_config = None
-        for node in node_configs:
-            if node.get("id") == node_id:
-                loop_node_config = node
-                break
-
-        if not loop_node_config:
-            raise ValueError("loop node id not found in workflow graph")
-
-        # Get node class
-        node_type = NodeType(loop_node_config.get("data", {}).get("type"))
-        node_version = loop_node_config.get("data", {}).get("version", "1")
-        node_cls = NODE_TYPE_CLASSES_MAPPING[node_type][node_version]
-
-        # init variable pool
-        variable_pool = VariablePool(
-            system_variables={},
-            user_inputs={},
-            environment_variables=workflow.environment_variables,
-        )
-
-        try:
-            variable_mapping = node_cls.extract_variable_selector_to_variable_mapping(
-                graph_config=workflow.graph_dict, config=loop_node_config
-            )
-        except NotImplementedError:
-            variable_mapping = {}
-
-        WorkflowEntry.mapping_user_inputs_to_variable_pool(
-            variable_mapping=variable_mapping,
-            user_inputs=user_inputs,
-            variable_pool=variable_pool,
-            tenant_id=workflow.tenant_id,
-        )
-
-        return graph, variable_pool
-
     def _handle_event(self, workflow_entry: WorkflowEntry, event: GraphEngineEvent) -> None:
         """
         Handle event
@@ -315,7 +216,6 @@ class WorkflowBasedAppRunner(AppRunner):
                     node_run_index=event.route_node_state.index,
                     predecessor_node_id=event.predecessor_node_id,
                     in_iteration_id=event.in_iteration_id,
-                    in_loop_id=event.in_loop_id,
                     parallel_mode_run_id=event.parallel_mode_run_id,
                     inputs=inputs,
                     process_data=process_data,
@@ -340,7 +240,6 @@ class WorkflowBasedAppRunner(AppRunner):
                     node_run_index=event.route_node_state.index,
                     predecessor_node_id=event.predecessor_node_id,
                     in_iteration_id=event.in_iteration_id,
-                    in_loop_id=event.in_loop_id,
                     parallel_mode_run_id=event.parallel_mode_run_id,
                     agent_strategy=event.agent_strategy,
                 )
@@ -373,7 +272,6 @@ class WorkflowBasedAppRunner(AppRunner):
                     outputs=outputs,
                     execution_metadata=execution_metadata,
                     in_iteration_id=event.in_iteration_id,
-                    in_loop_id=event.in_loop_id,
                 )
             )
         elif isinstance(event, NodeRunFailedEvent):
@@ -404,7 +302,6 @@ class WorkflowBasedAppRunner(AppRunner):
                     if event.route_node_state.node_run_result
                     else {},
                     in_iteration_id=event.in_iteration_id,
-                    in_loop_id=event.in_loop_id,
                 )
             )
         elif isinstance(event, NodeRunExceptionEvent):
@@ -435,7 +332,6 @@ class WorkflowBasedAppRunner(AppRunner):
                     if event.route_node_state.node_run_result
                     else {},
                     in_iteration_id=event.in_iteration_id,
-                    in_loop_id=event.in_loop_id,
                 )
             )
         elif isinstance(event, NodeInIterationFailedEvent):
@@ -466,49 +362,18 @@ class WorkflowBasedAppRunner(AppRunner):
                     error=event.error,
                 )
             )
-        elif isinstance(event, NodeInLoopFailedEvent):
-            self._publish_event(
-                QueueNodeInLoopFailedEvent(
-                    node_execution_id=event.id,
-                    node_id=event.node_id,
-                    node_type=event.node_type,
-                    node_data=event.node_data,
-                    parallel_id=event.parallel_id,
-                    parallel_start_node_id=event.parallel_start_node_id,
-                    parent_parallel_id=event.parent_parallel_id,
-                    parent_parallel_start_node_id=event.parent_parallel_start_node_id,
-                    start_at=event.route_node_state.start_at,
-                    inputs=event.route_node_state.node_run_result.inputs
-                    if event.route_node_state.node_run_result
-                    else {},
-                    process_data=event.route_node_state.node_run_result.process_data
-                    if event.route_node_state.node_run_result
-                    else {},
-                    outputs=event.route_node_state.node_run_result.outputs or {}
-                    if event.route_node_state.node_run_result
-                    else {},
-                    execution_metadata=event.route_node_state.node_run_result.metadata
-                    if event.route_node_state.node_run_result
-                    else {},
-                    in_loop_id=event.in_loop_id,
-                    error=event.error,
-                )
-            )
         elif isinstance(event, NodeRunStreamChunkEvent):
             self._publish_event(
                 QueueTextChunkEvent(
                     text=event.chunk_content,
                     from_variable_selector=event.from_variable_selector,
                     in_iteration_id=event.in_iteration_id,
-                    in_loop_id=event.in_loop_id,
                 )
             )
         elif isinstance(event, NodeRunRetrieverResourceEvent):
             self._publish_event(
                 QueueRetrieverResourcesEvent(
-                    retriever_resources=event.retriever_resources,
-                    in_iteration_id=event.in_iteration_id,
-                    in_loop_id=event.in_loop_id,
+                    retriever_resources=event.retriever_resources, in_iteration_id=event.in_iteration_id
                 )
             )
         elif isinstance(event, AgentLogEvent):
@@ -522,7 +387,6 @@ class WorkflowBasedAppRunner(AppRunner):
                     status=event.status,
                     data=event.data,
                     metadata=event.metadata,
-                    node_id=event.node_id,
                 )
             )
         elif isinstance(event, ParallelBranchRunStartedEvent):
@@ -533,7 +397,6 @@ class WorkflowBasedAppRunner(AppRunner):
                     parent_parallel_id=event.parent_parallel_id,
                     parent_parallel_start_node_id=event.parent_parallel_start_node_id,
                     in_iteration_id=event.in_iteration_id,
-                    in_loop_id=event.in_loop_id,
                 )
             )
         elif isinstance(event, ParallelBranchRunSucceededEvent):
@@ -544,7 +407,6 @@ class WorkflowBasedAppRunner(AppRunner):
                     parent_parallel_id=event.parent_parallel_id,
                     parent_parallel_start_node_id=event.parent_parallel_start_node_id,
                     in_iteration_id=event.in_iteration_id,
-                    in_loop_id=event.in_loop_id,
                 )
             )
         elif isinstance(event, ParallelBranchRunFailedEvent):
@@ -555,7 +417,6 @@ class WorkflowBasedAppRunner(AppRunner):
                     parent_parallel_id=event.parent_parallel_id,
                     parent_parallel_start_node_id=event.parent_parallel_start_node_id,
                     in_iteration_id=event.in_iteration_id,
-                    in_loop_id=event.in_loop_id,
                     error=event.error,
                 )
             )
@@ -615,62 +476,6 @@ class WorkflowBasedAppRunner(AppRunner):
                     error=event.error if isinstance(event, IterationRunFailedEvent) else None,
                 )
             )
-        elif isinstance(event, LoopRunStartedEvent):
-            self._publish_event(
-                QueueLoopStartEvent(
-                    node_execution_id=event.loop_id,
-                    node_id=event.loop_node_id,
-                    node_type=event.loop_node_type,
-                    node_data=event.loop_node_data,
-                    parallel_id=event.parallel_id,
-                    parallel_start_node_id=event.parallel_start_node_id,
-                    parent_parallel_id=event.parent_parallel_id,
-                    parent_parallel_start_node_id=event.parent_parallel_start_node_id,
-                    start_at=event.start_at,
-                    node_run_index=workflow_entry.graph_engine.graph_runtime_state.node_run_steps,
-                    inputs=event.inputs,
-                    predecessor_node_id=event.predecessor_node_id,
-                    metadata=event.metadata,
-                )
-            )
-        elif isinstance(event, LoopRunNextEvent):
-            self._publish_event(
-                QueueLoopNextEvent(
-                    node_execution_id=event.loop_id,
-                    node_id=event.loop_node_id,
-                    node_type=event.loop_node_type,
-                    node_data=event.loop_node_data,
-                    parallel_id=event.parallel_id,
-                    parallel_start_node_id=event.parallel_start_node_id,
-                    parent_parallel_id=event.parent_parallel_id,
-                    parent_parallel_start_node_id=event.parent_parallel_start_node_id,
-                    index=event.index,
-                    node_run_index=workflow_entry.graph_engine.graph_runtime_state.node_run_steps,
-                    output=event.pre_loop_output,
-                    parallel_mode_run_id=event.parallel_mode_run_id,
-                    duration=event.duration,
-                )
-            )
-        elif isinstance(event, (LoopRunSucceededEvent | LoopRunFailedEvent)):
-            self._publish_event(
-                QueueLoopCompletedEvent(
-                    node_execution_id=event.loop_id,
-                    node_id=event.loop_node_id,
-                    node_type=event.loop_node_type,
-                    node_data=event.loop_node_data,
-                    parallel_id=event.parallel_id,
-                    parallel_start_node_id=event.parallel_start_node_id,
-                    parent_parallel_id=event.parent_parallel_id,
-                    parent_parallel_start_node_id=event.parent_parallel_start_node_id,
-                    start_at=event.start_at,
-                    node_run_index=workflow_entry.graph_engine.graph_runtime_state.node_run_steps,
-                    inputs=event.inputs,
-                    outputs=event.outputs,
-                    metadata=event.metadata,
-                    steps=event.steps,
-                    error=event.error if isinstance(event, LoopRunFailedEvent) else None,
-                )
-            )
 
     def get_workflow(self, app_model: App, workflow_id: str) -> Optional[Workflow]:
         """

api/core/app/entities/app_invoke_entities.py

@@ -187,16 +187,6 @@ class AdvancedChatAppGenerateEntity(ConversationAppGenerateEntity):
 
     single_iteration_run: Optional[SingleIterationRunEntity] = None
 
-    class SingleLoopRunEntity(BaseModel):
-        """
-        Single Loop Run Entity.
-        """
-
-        node_id: str
-        inputs: Mapping
-
-    single_loop_run: Optional[SingleLoopRunEntity] = None
-
 
 class WorkflowAppGenerateEntity(AppGenerateEntity):
     """
@@ -216,13 +206,3 @@ class WorkflowAppGenerateEntity(AppGenerateEntity):
         inputs: dict
 
     single_iteration_run: Optional[SingleIterationRunEntity] = None
-
-    class SingleLoopRunEntity(BaseModel):
-        """
-        Single Loop Run Entity.
-        """
-
-        node_id: str
-        inputs: dict
-
-    single_loop_run: Optional[SingleLoopRunEntity] = None

api/core/app/entities/queue_entities.py

@@ -30,9 +30,6 @@ class QueueEvent(StrEnum):
     ITERATION_START = "iteration_start"
     ITERATION_NEXT = "iteration_next"
     ITERATION_COMPLETED = "iteration_completed"
-    LOOP_START = "loop_start"
-    LOOP_NEXT = "loop_next"
-    LOOP_COMPLETED = "loop_completed"
     NODE_STARTED = "node_started"
     NODE_SUCCEEDED = "node_succeeded"
     NODE_FAILED = "node_failed"
@@ -152,89 +149,6 @@ class QueueIterationCompletedEvent(AppQueueEvent):
     error: Optional[str] = None
 
 
-class QueueLoopStartEvent(AppQueueEvent):
-    """
-    QueueLoopStartEvent entity
-    """
-
-    event: QueueEvent = QueueEvent.LOOP_START
-    node_execution_id: str
-    node_id: str
-    node_type: NodeType
-    node_data: BaseNodeData
-    parallel_id: Optional[str] = None
-    """parallel id if node is in parallel"""
-    parallel_start_node_id: Optional[str] = None
-    """parallel start node id if node is in parallel"""
-    parent_parallel_id: Optional[str] = None
-    """parent parallel id if node is in parallel"""
-    parent_parallel_start_node_id: Optional[str] = None
-    """parent parallel start node id if node is in parallel"""
-    start_at: datetime
-
-    node_run_index: int
-    inputs: Optional[Mapping[str, Any]] = None
-    predecessor_node_id: Optional[str] = None
-    metadata: Optional[Mapping[str, Any]] = None
-
-
-class QueueLoopNextEvent(AppQueueEvent):
-    """
-    QueueLoopNextEvent entity
-    """
-
-    event: QueueEvent = QueueEvent.LOOP_NEXT
-
-    index: int
-    node_execution_id: str
-    node_id: str
-    node_type: NodeType
-    node_data: BaseNodeData
-    parallel_id: Optional[str] = None
-    """parallel id if node is in parallel"""
-    parallel_start_node_id: Optional[str] = None
-    """parallel start node id if node is in parallel"""
-    parent_parallel_id: Optional[str] = None
-    """parent parallel id if node is in parallel"""
-    parent_parallel_start_node_id: Optional[str] = None
-    """parent parallel start node id if node is in parallel"""
-    parallel_mode_run_id: Optional[str] = None
-    """iteratoin run in parallel mode run id"""
-    node_run_index: int
-    output: Optional[Any] = None  # output for the current loop
-    duration: Optional[float] = None
-
-
-class QueueLoopCompletedEvent(AppQueueEvent):
-    """
-    QueueLoopCompletedEvent entity
-    """
-
-    event: QueueEvent = QueueEvent.LOOP_COMPLETED
-
-    node_execution_id: str
-    node_id: str
-    node_type: NodeType
-    node_data: BaseNodeData
-    parallel_id: Optional[str] = None
-    """parallel id if node is in parallel"""
-    parallel_start_node_id: Optional[str] = None
-    """parallel start node id if node is in parallel"""
-    parent_parallel_id: Optional[str] = None
-    """parent parallel id if node is in parallel"""
-    parent_parallel_start_node_id: Optional[str] = None
-    """parent parallel start node id if node is in parallel"""
-    start_at: datetime
-
-    node_run_index: int
-    inputs: Optional[Mapping[str, Any]] = None
-    outputs: Optional[Mapping[str, Any]] = None
-    metadata: Optional[Mapping[str, Any]] = None
-    steps: int = 0
-
-    error: Optional[str] = None
-
-
 class QueueTextChunkEvent(AppQueueEvent):
     """
     QueueTextChunkEvent entity
@@ -246,8 +160,6 @@ class QueueTextChunkEvent(AppQueueEvent):
     """from variable selector"""
     in_iteration_id: Optional[str] = None
     """iteration id if node is in iteration"""
-    in_loop_id: Optional[str] = None
-    """loop id if node is in loop"""
 
 
 class QueueAgentMessageEvent(AppQueueEvent):
@@ -277,8 +189,6 @@ class QueueRetrieverResourcesEvent(AppQueueEvent):
     retriever_resources: list[dict]
     in_iteration_id: Optional[str] = None
     """iteration id if node is in iteration"""
-    in_loop_id: Optional[str] = None
-    """loop id if node is in loop"""
 
 
 class QueueAnnotationReplyEvent(AppQueueEvent):
@@ -368,8 +278,6 @@ class QueueNodeStartedEvent(AppQueueEvent):
     """parent parallel start node id if node is in parallel"""
     in_iteration_id: Optional[str] = None
     """iteration id if node is in iteration"""
-    in_loop_id: Optional[str] = None
-    """loop id if node is in loop"""
     start_at: datetime
     parallel_mode_run_id: Optional[str] = None
     """iteratoin run in parallel mode run id"""
@@ -397,8 +305,6 @@ class QueueNodeSucceededEvent(AppQueueEvent):
     """parent parallel start node id if node is in parallel"""
     in_iteration_id: Optional[str] = None
     """iteration id if node is in iteration"""
-    in_loop_id: Optional[str] = None
-    """loop id if node is in loop"""
     start_at: datetime
 
     inputs: Optional[Mapping[str, Any]] = None
@@ -409,8 +315,6 @@ class QueueNodeSucceededEvent(AppQueueEvent):
     error: Optional[str] = None
     """single iteration duration map"""
     iteration_duration_map: Optional[dict[str, float]] = None
-    """single loop duration map"""
-    loop_duration_map: Optional[dict[str, float]] = None
 
 
 class QueueAgentLogEvent(AppQueueEvent):
@@ -427,7 +331,6 @@ class QueueAgentLogEvent(AppQueueEvent):
     status: str
     data: Mapping[str, Any]
     metadata: Optional[Mapping[str, Any]] = None
-    node_id: str
 
 
 class QueueNodeRetryEvent(QueueNodeStartedEvent):
@@ -465,41 +368,6 @@ class QueueNodeInIterationFailedEvent(AppQueueEvent):
     """parent parallel start node id if node is in parallel"""
     in_iteration_id: Optional[str] = None
     """iteration id if node is in iteration"""
-    in_loop_id: Optional[str] = None
-    """loop id if node is in loop"""
-    start_at: datetime
-
-    inputs: Optional[Mapping[str, Any]] = None
-    process_data: Optional[Mapping[str, Any]] = None
-    outputs: Optional[Mapping[str, Any]] = None
-    execution_metadata: Optional[Mapping[NodeRunMetadataKey, Any]] = None
-
-    error: str
-
-
-class QueueNodeInLoopFailedEvent(AppQueueEvent):
-    """
-    QueueNodeInLoopFailedEvent entity
-    """
-
-    event: QueueEvent = QueueEvent.NODE_FAILED
-
-    node_execution_id: str
-    node_id: str
-    node_type: NodeType
-    node_data: BaseNodeData
-    parallel_id: Optional[str] = None
-    """parallel id if node is in parallel"""
-    parallel_start_node_id: Optional[str] = None
-    """parallel start node id if node is in parallel"""
-    parent_parallel_id: Optional[str] = None
-    """parent parallel id if node is in parallel"""
-    parent_parallel_start_node_id: Optional[str] = None
-    """parent parallel start node id if node is in parallel"""
-    in_iteration_id: Optional[str] = None
-    """iteration id if node is in iteration"""
-    in_loop_id: Optional[str] = None
-    """loop id if node is in loop"""
     start_at: datetime
 
     inputs: Optional[Mapping[str, Any]] = None
@@ -531,8 +399,6 @@ class QueueNodeExceptionEvent(AppQueueEvent):
     """parent parallel start node id if node is in parallel"""
     in_iteration_id: Optional[str] = None
     """iteration id if node is in iteration"""
-    in_loop_id: Optional[str] = None
-    """loop id if node is in loop"""
     start_at: datetime
 
     inputs: Optional[Mapping[str, Any]] = None
@@ -564,8 +430,6 @@ class QueueNodeFailedEvent(AppQueueEvent):
     """parent parallel start node id if node is in parallel"""
     in_iteration_id: Optional[str] = None
     """iteration id if node is in iteration"""
-    in_loop_id: Optional[str] = None
-    """loop id if node is in loop"""
     start_at: datetime
 
     inputs: Optional[Mapping[str, Any]] = None
@@ -685,8 +549,6 @@ class QueueParallelBranchRunStartedEvent(AppQueueEvent):
     """parent parallel start node id if node is in parallel"""
     in_iteration_id: Optional[str] = None
     """iteration id if node is in iteration"""
-    in_loop_id: Optional[str] = None
-    """loop id if node is in loop"""
 
 
 class QueueParallelBranchRunSucceededEvent(AppQueueEvent):
@@ -704,8 +566,6 @@ class QueueParallelBranchRunSucceededEvent(AppQueueEvent):
     """parent parallel start node id if node is in parallel"""
     in_iteration_id: Optional[str] = None
     """iteration id if node is in iteration"""
-    in_loop_id: Optional[str] = None
-    """loop id if node is in loop"""
 
 
 class QueueParallelBranchRunFailedEvent(AppQueueEvent):
@@ -723,6 +583,4 @@ class QueueParallelBranchRunFailedEvent(AppQueueEvent):
     """parent parallel start node id if node is in parallel"""
     in_iteration_id: Optional[str] = None
     """iteration id if node is in iteration"""
-    in_loop_id: Optional[str] = None
-    """loop id if node is in loop"""
     error: str

api/core/app/entities/task_entities.py

@@ -59,9 +59,6 @@ class StreamEvent(Enum):
     ITERATION_STARTED = "iteration_started"
     ITERATION_NEXT = "iteration_next"
     ITERATION_COMPLETED = "iteration_completed"
-    LOOP_STARTED = "loop_started"
-    LOOP_NEXT = "loop_next"
-    LOOP_COMPLETED = "loop_completed"
     TEXT_CHUNK = "text_chunk"
     TEXT_REPLACE = "text_replace"
     AGENT_LOG = "agent_log"
@@ -251,7 +248,6 @@ class NodeStartStreamResponse(StreamResponse):
         parent_parallel_id: Optional[str] = None
         parent_parallel_start_node_id: Optional[str] = None
         iteration_id: Optional[str] = None
-        loop_id: Optional[str] = None
         parallel_run_id: Optional[str] = None
         agent_strategy: Optional[AgentNodeStrategyInit] = None
 
@@ -279,7 +275,6 @@ class NodeStartStreamResponse(StreamResponse):
                 "parent_parallel_id": self.data.parent_parallel_id,
                 "parent_parallel_start_node_id": self.data.parent_parallel_start_node_id,
                 "iteration_id": self.data.iteration_id,
-                "loop_id": self.data.loop_id,
             },
         }
 
@@ -315,7 +310,6 @@ class NodeFinishStreamResponse(StreamResponse):
         parent_parallel_id: Optional[str] = None
         parent_parallel_start_node_id: Optional[str] = None
         iteration_id: Optional[str] = None
-        loop_id: Optional[str] = None
 
     event: StreamEvent = StreamEvent.NODE_FINISHED
     workflow_run_id: str
@@ -348,7 +342,6 @@ class NodeFinishStreamResponse(StreamResponse):
                 "parent_parallel_id": self.data.parent_parallel_id,
                 "parent_parallel_start_node_id": self.data.parent_parallel_start_node_id,
                 "iteration_id": self.data.iteration_id,
-                "loop_id": self.data.loop_id,
             },
         }
 
@@ -384,7 +377,6 @@ class NodeRetryStreamResponse(StreamResponse):
         parent_parallel_id: Optional[str] = None
         parent_parallel_start_node_id: Optional[str] = None
         iteration_id: Optional[str] = None
-        loop_id: Optional[str] = None
         retry_index: int = 0
 
     event: StreamEvent = StreamEvent.NODE_RETRY
@@ -418,7 +410,6 @@ class NodeRetryStreamResponse(StreamResponse):
                 "parent_parallel_id": self.data.parent_parallel_id,
                 "parent_parallel_start_node_id": self.data.parent_parallel_start_node_id,
                 "iteration_id": self.data.iteration_id,
-                "loop_id": self.data.loop_id,
                 "retry_index": self.data.retry_index,
             },
         }
@@ -439,7 +430,6 @@ class ParallelBranchStartStreamResponse(StreamResponse):
         parent_parallel_id: Optional[str] = None
         parent_parallel_start_node_id: Optional[str] = None
         iteration_id: Optional[str] = None
-        loop_id: Optional[str] = None
         created_at: int
 
     event: StreamEvent = StreamEvent.PARALLEL_BRANCH_STARTED
@@ -462,7 +452,6 @@ class ParallelBranchFinishedStreamResponse(StreamResponse):
         parent_parallel_id: Optional[str] = None
         parent_parallel_start_node_id: Optional[str] = None
         iteration_id: Optional[str] = None
-        loop_id: Optional[str] = None
         status: str
         error: Optional[str] = None
         created_at: int
@@ -559,93 +548,6 @@ class IterationNodeCompletedStreamResponse(StreamResponse):
     data: Data
 
 
-class LoopNodeStartStreamResponse(StreamResponse):
-    """
-    NodeStartStreamResponse entity
-    """
-
-    class Data(BaseModel):
-        """
-        Data entity
-        """
-
-        id: str
-        node_id: str
-        node_type: str
-        title: str
-        created_at: int
-        extras: dict = {}
-        metadata: Mapping = {}
-        inputs: Mapping = {}
-        parallel_id: Optional[str] = None
-        parallel_start_node_id: Optional[str] = None
-
-    event: StreamEvent = StreamEvent.LOOP_STARTED
-    workflow_run_id: str
-    data: Data
-
-
-class LoopNodeNextStreamResponse(StreamResponse):
-    """
-    NodeStartStreamResponse entity
-    """
-
-    class Data(BaseModel):
-        """
-        Data entity
-        """
-
-        id: str
-        node_id: str
-        node_type: str
-        title: str
-        index: int
-        created_at: int
-        pre_loop_output: Optional[Any] = None
-        extras: dict = {}
-        parallel_id: Optional[str] = None
-        parallel_start_node_id: Optional[str] = None
-        parallel_mode_run_id: Optional[str] = None
-        duration: Optional[float] = None
-
-    event: StreamEvent = StreamEvent.LOOP_NEXT
-    workflow_run_id: str
-    data: Data
-
-
-class LoopNodeCompletedStreamResponse(StreamResponse):
-    """
-    NodeCompletedStreamResponse entity
-    """
-
-    class Data(BaseModel):
-        """
-        Data entity
-        """
-
-        id: str
-        node_id: str
-        node_type: str
-        title: str
-        outputs: Optional[Mapping] = None
-        created_at: int
-        extras: Optional[dict] = None
-        inputs: Optional[Mapping] = None
-        status: WorkflowNodeExecutionStatus
-        error: Optional[str] = None
-        elapsed_time: float
-        total_tokens: int
-        execution_metadata: Optional[Mapping] = None
-        finished_at: int
-        steps: int
-        parallel_id: Optional[str] = None
-        parallel_start_node_id: Optional[str] = None
-
-    event: StreamEvent = StreamEvent.LOOP_COMPLETED
-    workflow_run_id: str
-    data: Data
-
-
 class TextChunkStreamResponse(StreamResponse):
     """
     TextChunkStreamResponse entity
@@ -817,7 +719,6 @@ class AgentLogStreamResponse(StreamResponse):
         status: str
         data: Mapping[str, Any]
         metadata: Optional[Mapping[str, Any]] = None
-        node_id: str
 
     event: StreamEvent = StreamEvent.AGENT_LOG
     data: Data

api/core/app/task_pipeline/workflow_cycle_manage.py

@@ -14,13 +14,9 @@ from core.app.entities.queue_entities import (
     QueueIterationCompletedEvent,
     QueueIterationNextEvent,
     QueueIterationStartEvent,
-    QueueLoopCompletedEvent,
-    QueueLoopNextEvent,
-    QueueLoopStartEvent,
     QueueNodeExceptionEvent,
     QueueNodeFailedEvent,
     QueueNodeInIterationFailedEvent,
-    QueueNodeInLoopFailedEvent,
     QueueNodeRetryEvent,
     QueueNodeStartedEvent,
     QueueNodeSucceededEvent,
@@ -33,9 +29,6 @@ from core.app.entities.task_entities import (
     IterationNodeCompletedStreamResponse,
     IterationNodeNextStreamResponse,
     IterationNodeStartStreamResponse,
-    LoopNodeCompletedStreamResponse,
-    LoopNodeNextStreamResponse,
-    LoopNodeStartStreamResponse,
     NodeFinishStreamResponse,
     NodeRetryStreamResponse,
     NodeStartStreamResponse,
@@ -311,7 +304,6 @@ class WorkflowCycleManage:
             {
                 NodeRunMetadataKey.PARALLEL_MODE_RUN_ID: event.parallel_mode_run_id,
                 NodeRunMetadataKey.ITERATION_ID: event.in_iteration_id,
-                NodeRunMetadataKey.LOOP_ID: event.in_loop_id,
             }
         )
         workflow_node_execution.created_at = datetime.now(UTC).replace(tzinfo=None)
@@ -352,10 +344,7 @@ class WorkflowCycleManage:
         self,
         *,
         session: Session,
-        event: QueueNodeFailedEvent
-        | QueueNodeInIterationFailedEvent
-        | QueueNodeInLoopFailedEvent
-        | QueueNodeExceptionEvent,
+        event: QueueNodeFailedEvent | QueueNodeInIterationFailedEvent | QueueNodeExceptionEvent,
     ) -> WorkflowNodeExecution:
         """
         Workflow node execution failed
@@ -407,7 +396,6 @@ class WorkflowCycleManage:
         origin_metadata = {
             NodeRunMetadataKey.ITERATION_ID: event.in_iteration_id,
             NodeRunMetadataKey.PARALLEL_MODE_RUN_ID: event.parallel_mode_run_id,
-            NodeRunMetadataKey.LOOP_ID: event.in_loop_id,
         }
         merged_metadata = (
             {**jsonable_encoder(event.execution_metadata), **origin_metadata}
@@ -552,7 +540,6 @@ class WorkflowCycleManage:
                 parent_parallel_id=event.parent_parallel_id,
                 parent_parallel_start_node_id=event.parent_parallel_start_node_id,
                 iteration_id=event.in_iteration_id,
-                loop_id=event.in_loop_id,
                 parallel_run_id=event.parallel_mode_run_id,
                 agent_strategy=event.agent_strategy,
             ),
@@ -576,7 +563,6 @@ class WorkflowCycleManage:
         event: QueueNodeSucceededEvent
         | QueueNodeFailedEvent
         | QueueNodeInIterationFailedEvent
-        | QueueNodeInLoopFailedEvent
         | QueueNodeExceptionEvent,
         task_id: str,
         workflow_node_execution: WorkflowNodeExecution,
@@ -615,7 +601,6 @@ class WorkflowCycleManage:
                 parent_parallel_id=event.parent_parallel_id,
                 parent_parallel_start_node_id=event.parent_parallel_start_node_id,
                 iteration_id=event.in_iteration_id,
-                loop_id=event.in_loop_id,
             ),
         )
 
@@ -661,7 +646,6 @@ class WorkflowCycleManage:
                 parent_parallel_id=event.parent_parallel_id,
                 parent_parallel_start_node_id=event.parent_parallel_start_node_id,
                 iteration_id=event.in_iteration_id,
-                loop_id=event.in_loop_id,
                 retry_index=event.retry_index,
             ),
         )
@@ -680,7 +664,6 @@ class WorkflowCycleManage:
                 parent_parallel_id=event.parent_parallel_id,
                 parent_parallel_start_node_id=event.parent_parallel_start_node_id,
                 iteration_id=event.in_iteration_id,
-                loop_id=event.in_loop_id,
                 created_at=int(time.time()),
             ),
         )
@@ -704,7 +687,6 @@ class WorkflowCycleManage:
                 parent_parallel_id=event.parent_parallel_id,
                 parent_parallel_start_node_id=event.parent_parallel_start_node_id,
                 iteration_id=event.in_iteration_id,
-                loop_id=event.in_loop_id,
                 status="succeeded" if isinstance(event, QueueParallelBranchRunSucceededEvent) else "failed",
                 error=event.error if isinstance(event, QueueParallelBranchRunFailedEvent) else None,
                 created_at=int(time.time()),
@@ -788,83 +770,6 @@ class WorkflowCycleManage:
             ),
         )
 
-    def _workflow_loop_start_to_stream_response(
-        self, *, session: Session, task_id: str, workflow_run: WorkflowRun, event: QueueLoopStartEvent
-    ) -> LoopNodeStartStreamResponse:
-        # receive session to make sure the workflow_run won't be expired, need a more elegant way to handle this
-        _ = session
-        return LoopNodeStartStreamResponse(
-            task_id=task_id,
-            workflow_run_id=workflow_run.id,
-            data=LoopNodeStartStreamResponse.Data(
-                id=event.node_id,
-                node_id=event.node_id,
-                node_type=event.node_type.value,
-                title=event.node_data.title,
-                created_at=int(time.time()),
-                extras={},
-                inputs=event.inputs or {},
-                metadata=event.metadata or {},
-                parallel_id=event.parallel_id,
-                parallel_start_node_id=event.parallel_start_node_id,
-            ),
-        )
-
-    def _workflow_loop_next_to_stream_response(
-        self, *, session: Session, task_id: str, workflow_run: WorkflowRun, event: QueueLoopNextEvent
-    ) -> LoopNodeNextStreamResponse:
-        # receive session to make sure the workflow_run won't be expired, need a more elegant way to handle this
-        _ = session
-        return LoopNodeNextStreamResponse(
-            task_id=task_id,
-            workflow_run_id=workflow_run.id,
-            data=LoopNodeNextStreamResponse.Data(
-                id=event.node_id,
-                node_id=event.node_id,
-                node_type=event.node_type.value,
-                title=event.node_data.title,
-                index=event.index,
-                pre_loop_output=event.output,
-                created_at=int(time.time()),
-                extras={},
-                parallel_id=event.parallel_id,
-                parallel_start_node_id=event.parallel_start_node_id,
-                parallel_mode_run_id=event.parallel_mode_run_id,
-                duration=event.duration,
-            ),
-        )
-
-    def _workflow_loop_completed_to_stream_response(
-        self, *, session: Session, task_id: str, workflow_run: WorkflowRun, event: QueueLoopCompletedEvent
-    ) -> LoopNodeCompletedStreamResponse:
-        # receive session to make sure the workflow_run won't be expired, need a more elegant way to handle this
-        _ = session
-        return LoopNodeCompletedStreamResponse(
-            task_id=task_id,
-            workflow_run_id=workflow_run.id,
-            data=LoopNodeCompletedStreamResponse.Data(
-                id=event.node_id,
-                node_id=event.node_id,
-                node_type=event.node_type.value,
-                title=event.node_data.title,
-                outputs=event.outputs,
-                created_at=int(time.time()),
-                extras={},
-                inputs=event.inputs or {},
-                status=WorkflowNodeExecutionStatus.SUCCEEDED
-                if event.error is None
-                else WorkflowNodeExecutionStatus.FAILED,
-                error=None,
-                elapsed_time=(datetime.now(UTC).replace(tzinfo=None) - event.start_at).total_seconds(),
-                total_tokens=event.metadata.get("total_tokens", 0) if event.metadata else 0,
-                execution_metadata=event.metadata,
-                finished_at=int(time.time()),
-                steps=event.steps,
-                parallel_id=event.parallel_id,
-                parallel_start_node_id=event.parallel_start_node_id,
-            ),
-        )
-
     def _fetch_files_from_node_outputs(self, outputs_dict: Mapping[str, Any]) -> Sequence[Mapping[str, Any]]:
         """
         Fetch files from node outputs
@@ -959,6 +864,5 @@ class WorkflowCycleManage:
                 status=event.status,
                 data=event.data,
                 metadata=event.metadata,
-                node_id=event.node_id,
             ),
         )

api/core/callback_handler/index_tool_callback_handler.py

@@ -1,11 +1,9 @@
 from core.app.apps.base_app_queue_manager import AppQueueManager, PublishFrom
 from core.app.entities.app_invoke_entities import InvokeFrom
 from core.app.entities.queue_entities import QueueRetrieverResourcesEvent
-from core.rag.index_processor.constant.index_type import IndexType
 from core.rag.models.document import Document
 from extensions.ext_database import db
-from models.dataset import ChildChunk, DatasetQuery, DocumentSegment
-from models.dataset import Document as DatasetDocument
+from models.dataset import DatasetQuery, DocumentSegment
 from models.model import DatasetRetrieverResource
 
 
@@ -43,29 +41,15 @@ class DatasetIndexToolCallbackHandler:
         """Handle tool end."""
         for document in documents:
             if document.metadata is not None:
-                dataset_document = DatasetDocument.query.filter(
-                    DatasetDocument.id == document.metadata["document_id"]
-                ).first()
-                if dataset_document.doc_form == IndexType.PARENT_CHILD_INDEX:
-                    child_chunk = ChildChunk.query.filter(
-                        ChildChunk.index_node_id == document.metadata["doc_id"],
-                        ChildChunk.dataset_id == dataset_document.dataset_id,
-                        ChildChunk.document_id == dataset_document.id,
-                    ).first()
-                    if child_chunk:
-                        segment = DocumentSegment.query.filter(DocumentSegment.id == child_chunk.segment_id).update(
-                            {DocumentSegment.hit_count: DocumentSegment.hit_count + 1}, synchronize_session=False
-                        )
-                else:
-                    query = db.session.query(DocumentSegment).filter(
-                        DocumentSegment.index_node_id == document.metadata["doc_id"]
-                    )
+                query = db.session.query(DocumentSegment).filter(
+                    DocumentSegment.index_node_id == document.metadata["doc_id"]
+                )
 
-                    if "dataset_id" in document.metadata:
-                        query = query.filter(DocumentSegment.dataset_id == document.metadata["dataset_id"])
+                if "dataset_id" in document.metadata:
+                    query = query.filter(DocumentSegment.dataset_id == document.metadata["dataset_id"])
 
-                    # add hit count to document segment
-                    query.update({DocumentSegment.hit_count: DocumentSegment.hit_count + 1}, synchronize_session=False)
+                # add hit count to document segment
+                query.update({DocumentSegment.hit_count: DocumentSegment.hit_count + 1}, synchronize_session=False)
 
                 db.session.commit()
 

api/core/entities/provider_configuration.py

@@ -7,6 +7,7 @@ from json import JSONDecodeError
 from typing import Optional
 
 from pydantic import BaseModel, ConfigDict, Field
+from sqlalchemy import or_
 
 from constants import HIDDEN_VALUE
 from core.entities.model_entities import ModelStatus, ModelWithProviderEntity, SimpleModelProviderEntity
@@ -179,35 +180,25 @@ class ProviderConfiguration(BaseModel):
             else [],
         )
 
-    def _get_custom_provider_credentials(self) -> Provider | None:
-        """
-        Get custom provider credentials.
-        """
-        # get provider
-        model_provider_id = ModelProviderID(self.provider.provider)
-        provider_names = [self.provider.provider]
-        if model_provider_id.is_langgenius():
-            provider_names.append(model_provider_id.provider_name)
-
-        provider_record = (
-            db.session.query(Provider)
-            .filter(
-                Provider.tenant_id == self.tenant_id,
-                Provider.provider_type == ProviderType.CUSTOM.value,
-                Provider.provider_name.in_(provider_names),
-            )
-            .first()
-        )
-
-        return provider_record
-
     def custom_credentials_validate(self, credentials: dict) -> tuple[Provider | None, dict]:
         """
         Validate custom credentials.
         :param credentials: provider credentials
         :return:
         """
-        provider_record = self._get_custom_provider_credentials()
+        # get provider
+        provider_record = (
+            db.session.query(Provider)
+            .filter(
+                Provider.tenant_id == self.tenant_id,
+                Provider.provider_type == ProviderType.CUSTOM.value,
+                or_(
+                    Provider.provider_name == ModelProviderID(self.provider.provider).plugin_name,
+                    Provider.provider_name == self.provider.provider,
+                ),
+            )
+            .first()
+        )
 
         # Get provider credential secret variables
         provider_credential_secret_variables = self.extract_secret_variables(
@@ -288,7 +279,18 @@ class ProviderConfiguration(BaseModel):
         :return:
         """
         # get provider
-        provider_record = self._get_custom_provider_credentials()
+        provider_record = (
+            db.session.query(Provider)
+            .filter(
+                Provider.tenant_id == self.tenant_id,
+                or_(
+                    Provider.provider_name == ModelProviderID(self.provider.provider).plugin_name,
+                    Provider.provider_name == self.provider.provider,
+                ),
+                Provider.provider_type == ProviderType.CUSTOM.value,
+            )
+            .first()
+        )
 
         # delete provider
         if provider_record:
@@ -335,33 +337,6 @@ class ProviderConfiguration(BaseModel):
 
         return None
 
-    def _get_custom_model_credentials(
-        self,
-        model_type: ModelType,
-        model: str,
-    ) -> ProviderModel | None:
-        """
-        Get custom model credentials.
-        """
-        # get provider model
-        model_provider_id = ModelProviderID(self.provider.provider)
-        provider_names = [self.provider.provider]
-        if model_provider_id.is_langgenius():
-            provider_names.append(model_provider_id.provider_name)
-
-        provider_model_record = (
-            db.session.query(ProviderModel)
-            .filter(
-                ProviderModel.tenant_id == self.tenant_id,
-                ProviderModel.provider_name.in_(provider_names),
-                ProviderModel.model_name == model,
-                ProviderModel.model_type == model_type.to_origin_model_type(),
-            )
-            .first()
-        )
-
-        return provider_model_record
-
     def custom_model_credentials_validate(
         self, model_type: ModelType, model: str, credentials: dict
     ) -> tuple[ProviderModel | None, dict]:
@@ -374,7 +349,16 @@ class ProviderConfiguration(BaseModel):
         :return:
         """
         # get provider model
-        provider_model_record = self._get_custom_model_credentials(model_type, model)
+        provider_model_record = (
+            db.session.query(ProviderModel)
+            .filter(
+                ProviderModel.tenant_id == self.tenant_id,
+                ProviderModel.provider_name == self.provider.provider,
+                ProviderModel.model_name == model,
+                ProviderModel.model_type == model_type.to_origin_model_type(),
+            )
+            .first()
+        )
 
         # Get provider credential secret variables
         provider_credential_secret_variables = self.extract_secret_variables(
@@ -455,7 +439,16 @@ class ProviderConfiguration(BaseModel):
         :return:
         """
         # get provider model
-        provider_model_record = self._get_custom_model_credentials(model_type, model)
+        provider_model_record = (
+            db.session.query(ProviderModel)
+            .filter(
+                ProviderModel.tenant_id == self.tenant_id,
+                ProviderModel.provider_name == self.provider.provider,
+                ProviderModel.model_name == model,
+                ProviderModel.model_type == model_type.to_origin_model_type(),
+            )
+            .first()
+        )
 
         # delete provider model
         if provider_model_record:
@@ -470,26 +463,6 @@ class ProviderConfiguration(BaseModel):
 
             provider_model_credentials_cache.delete()
 
-    def _get_provider_model_setting(self, model_type: ModelType, model: str) -> ProviderModelSetting | None:
-        """
-        Get provider model setting.
-        """
-        model_provider_id = ModelProviderID(self.provider.provider)
-        provider_names = [self.provider.provider]
-        if model_provider_id.is_langgenius():
-            provider_names.append(model_provider_id.provider_name)
-
-        return (
-            db.session.query(ProviderModelSetting)
-            .filter(
-                ProviderModelSetting.tenant_id == self.tenant_id,
-                ProviderModelSetting.provider_name.in_(provider_names),
-                ProviderModelSetting.model_type == model_type.to_origin_model_type(),
-                ProviderModelSetting.model_name == model,
-            )
-            .first()
-        )
-
     def enable_model(self, model_type: ModelType, model: str) -> ProviderModelSetting:
         """
         Enable model.
@@ -497,7 +470,16 @@ class ProviderConfiguration(BaseModel):
         :param model: model name
         :return:
         """
-        model_setting = self._get_provider_model_setting(model_type, model)
+        model_setting = (
+            db.session.query(ProviderModelSetting)
+            .filter(
+                ProviderModelSetting.tenant_id == self.tenant_id,
+                ProviderModelSetting.provider_name == self.provider.provider,
+                ProviderModelSetting.model_type == model_type.to_origin_model_type(),
+                ProviderModelSetting.model_name == model,
+            )
+            .first()
+        )
 
         if model_setting:
             model_setting.enabled = True
@@ -522,7 +504,16 @@ class ProviderConfiguration(BaseModel):
         :param model: model name
         :return:
         """
-        model_setting = self._get_provider_model_setting(model_type, model)
+        model_setting = (
+            db.session.query(ProviderModelSetting)
+            .filter(
+                ProviderModelSetting.tenant_id == self.tenant_id,
+                ProviderModelSetting.provider_name == self.provider.provider,
+                ProviderModelSetting.model_type == model_type.to_origin_model_type(),
+                ProviderModelSetting.model_name == model,
+            )
+            .first()
+        )
 
         if model_setting:
             model_setting.enabled = False
@@ -547,24 +538,13 @@ class ProviderConfiguration(BaseModel):
         :param model: model name
         :return:
         """
-        return self._get_provider_model_setting(model_type, model)
-
-    def _get_load_balancing_config(self, model_type: ModelType, model: str) -> Optional[LoadBalancingModelConfig]:
-        """
-        Get load balancing config.
-        """
-        model_provider_id = ModelProviderID(self.provider.provider)
-        provider_names = [self.provider.provider]
-        if model_provider_id.is_langgenius():
-            provider_names.append(model_provider_id.provider_name)
-
         return (
-            db.session.query(LoadBalancingModelConfig)
+            db.session.query(ProviderModelSetting)
             .filter(
-                LoadBalancingModelConfig.tenant_id == self.tenant_id,
-                LoadBalancingModelConfig.provider_name.in_(provider_names),
-                LoadBalancingModelConfig.model_type == model_type.to_origin_model_type(),
-                LoadBalancingModelConfig.model_name == model,
+                ProviderModelSetting.tenant_id == self.tenant_id,
+                ProviderModelSetting.provider_name == self.provider.provider,
+                ProviderModelSetting.model_type == model_type.to_origin_model_type(),
+                ProviderModelSetting.model_name == model,
             )
             .first()
         )
@@ -576,16 +556,11 @@ class ProviderConfiguration(BaseModel):
         :param model: model name
         :return:
         """
-        model_provider_id = ModelProviderID(self.provider.provider)
-        provider_names = [self.provider.provider]
-        if model_provider_id.is_langgenius():
-            provider_names.append(model_provider_id.provider_name)
-
         load_balancing_config_count = (
             db.session.query(LoadBalancingModelConfig)
             .filter(
                 LoadBalancingModelConfig.tenant_id == self.tenant_id,
-                LoadBalancingModelConfig.provider_name.in_(provider_names),
+                LoadBalancingModelConfig.provider_name == self.provider.provider,
                 LoadBalancingModelConfig.model_type == model_type.to_origin_model_type(),
                 LoadBalancingModelConfig.model_name == model,
             )
@@ -595,7 +570,16 @@ class ProviderConfiguration(BaseModel):
         if load_balancing_config_count <= 1:
             raise ValueError("Model load balancing configuration must be more than 1.")
 
-        model_setting = self._get_provider_model_setting(model_type, model)
+        model_setting = (
+            db.session.query(ProviderModelSetting)
+            .filter(
+                ProviderModelSetting.tenant_id == self.tenant_id,
+                ProviderModelSetting.provider_name == self.provider.provider,
+                ProviderModelSetting.model_type == model_type.to_origin_model_type(),
+                ProviderModelSetting.model_name == model,
+            )
+            .first()
+        )
 
         if model_setting:
             model_setting.load_balancing_enabled = True
@@ -620,16 +604,11 @@ class ProviderConfiguration(BaseModel):
         :param model: model name
         :return:
         """
-        model_provider_id = ModelProviderID(self.provider.provider)
-        provider_names = [self.provider.provider]
-        if model_provider_id.is_langgenius():
-            provider_names.append(model_provider_id.provider_name)
-
         model_setting = (
             db.session.query(ProviderModelSetting)
             .filter(
                 ProviderModelSetting.tenant_id == self.tenant_id,
-                ProviderModelSetting.provider_name.in_(provider_names),
+                ProviderModelSetting.provider_name == self.provider.provider,
                 ProviderModelSetting.model_type == model_type.to_origin_model_type(),
                 ProviderModelSetting.model_name == model,
             )
@@ -686,16 +665,11 @@ class ProviderConfiguration(BaseModel):
             return
 
         # get preferred provider
-        model_provider_id = ModelProviderID(self.provider.provider)
-        provider_names = [self.provider.provider]
-        if model_provider_id.is_langgenius():
-            provider_names.append(model_provider_id.provider_name)
-
         preferred_model_provider = (
             db.session.query(TenantPreferredModelProvider)
             .filter(
                 TenantPreferredModelProvider.tenant_id == self.tenant_id,
-                TenantPreferredModelProvider.provider_name.in_(provider_names),
+                TenantPreferredModelProvider.provider_name == self.provider.provider,
             )
             .first()
         )

api/core/file/models.py

@@ -97,18 +97,32 @@ class File(BaseModel):
         return text
 
     def generate_url(self) -> Optional[str]:
-        if self.transfer_method == FileTransferMethod.REMOTE_URL:
-            return self.remote_url
-        elif self.transfer_method == FileTransferMethod.LOCAL_FILE:
-            if self.related_id is None:
-                raise ValueError("Missing file related_id")
-            return helpers.get_signed_file_url(upload_file_id=self.related_id)
-        elif self.transfer_method == FileTransferMethod.TOOL_FILE:
-            assert self.related_id is not None
-            assert self.extension is not None
-            return ToolFileParser.get_tool_file_manager().sign_file(
-                tool_file_id=self.related_id, extension=self.extension
-            )
+        if self.type == FileType.IMAGE:
+            if self.transfer_method == FileTransferMethod.REMOTE_URL:
+                return self.remote_url
+            elif self.transfer_method == FileTransferMethod.LOCAL_FILE:
+                if self.related_id is None:
+                    raise ValueError("Missing file related_id")
+                return helpers.get_signed_file_url(upload_file_id=self.related_id)
+            elif self.transfer_method == FileTransferMethod.TOOL_FILE:
+                assert self.related_id is not None
+                assert self.extension is not None
+                return ToolFileParser.get_tool_file_manager().sign_file(
+                    tool_file_id=self.related_id, extension=self.extension
+                )
+        else:
+            if self.transfer_method == FileTransferMethod.REMOTE_URL:
+                return self.remote_url
+            elif self.transfer_method == FileTransferMethod.LOCAL_FILE:
+                if self.related_id is None:
+                    raise ValueError("Missing file related_id")
+                return helpers.get_signed_file_url(upload_file_id=self.related_id)
+            elif self.transfer_method == FileTransferMethod.TOOL_FILE:
+                assert self.related_id is not None
+                assert self.extension is not None
+                return ToolFileParser.get_tool_file_manager().sign_file(
+                    tool_file_id=self.related_id, extension=self.extension
+                )
 
     def to_plugin_parameter(self) -> dict[str, Any]:
         return {

api/core/plugin/entities/plugin.py

@@ -5,7 +5,6 @@ from collections.abc import Mapping
 from typing import Any, Optional
 
 from pydantic import BaseModel, Field, model_validator
-from werkzeug.exceptions import NotFound
 
 from core.agent.plugin_entities import AgentStrategyProviderEntity
 from core.model_runtime.entities.provider_entities import ProviderEntity
@@ -154,8 +153,6 @@ class GenericProviderID:
         return f"{self.organization}/{self.plugin_name}/{self.provider_name}"
 
     def __init__(self, value: str, is_hardcoded: bool = False) -> None:
-        if not value:
-            raise NotFound("plugin not found, please add plugin")
         # check if the value is a valid plugin id with format: $organization/$plugin_name/$provider_name
         if not re.match(r"^[a-z0-9_-]+\/[a-z0-9_-]+\/[a-z0-9_-]+$", value):
             # check if matches [a-z0-9_-]+, if yes, append with langgenius/$value/$value
@@ -167,9 +164,6 @@ class GenericProviderID:
         self.organization, self.plugin_name, self.provider_name = value.split("/")
         self.is_hardcoded = is_hardcoded
 
-    def is_langgenius(self) -> bool:
-        return self.organization == "langgenius"
-
     @property
     def plugin_id(self) -> str:
         return f"{self.organization}/{self.plugin_name}"

api/core/rag/datasource/vdb/oracle/oraclevector.py

@@ -61,7 +61,7 @@ CREATE TABLE IF NOT EXISTS {table_name} (
 SQL_CREATE_INDEX = """
 CREATE INDEX IF NOT EXISTS idx_docs_{table_name} ON {table_name}(text) 
 INDEXTYPE IS CTXSYS.CONTEXT PARAMETERS 
-('FILTER CTXSYS.NULL_FILTER SECTION GROUP CTXSYS.HTML_SECTION_GROUP LEXER world_lexer')
+('FILTER CTXSYS.NULL_FILTER SECTION GROUP CTXSYS.HTML_SECTION_GROUP LEXER multilingual_lexer')
 """
 
 

api/core/rag/retrieval/dataset_retrieval.py

@@ -21,7 +21,6 @@ from core.rag.data_post_processor.data_post_processor import DataPostProcessor
 from core.rag.datasource.keyword.jieba.jieba_keyword_table_handler import JiebaKeywordTableHandler
 from core.rag.datasource.retrieval_service import RetrievalService
 from core.rag.entities.context_entities import DocumentContext
-from core.rag.index_processor.constant.index_type import IndexType
 from core.rag.models.document import Document
 from core.rag.rerank.rerank_type import RerankMode
 from core.rag.retrieval.retrieval_methods import RetrievalMethod
@@ -29,7 +28,7 @@ from core.rag.retrieval.router.multi_dataset_function_call_router import Functio
 from core.rag.retrieval.router.multi_dataset_react_route import ReactMultiDatasetRouter
 from core.tools.utils.dataset_retriever.dataset_retriever_base_tool import DatasetRetrieverBaseTool
 from extensions.ext_database import db
-from models.dataset import ChildChunk, Dataset, DatasetQuery, DocumentSegment
+from models.dataset import Dataset, DatasetQuery, DocumentSegment
 from models.dataset import Document as DatasetDocument
 from services.external_knowledge_service import ExternalDatasetService
 
@@ -430,31 +429,16 @@ class DatasetRetrieval:
         dify_documents = [document for document in documents if document.provider == "dify"]
         for document in dify_documents:
             if document.metadata is not None:
-                dataset_document = DatasetDocument.query.filter(
-                    DatasetDocument.id == document.metadata["document_id"]
-                ).first()
-                if dataset_document.doc_form == IndexType.PARENT_CHILD_INDEX:
-                    child_chunk = ChildChunk.query.filter(
-                        ChildChunk.index_node_id == document.metadata["doc_id"],
-                        ChildChunk.dataset_id == dataset_document.dataset_id,
-                        ChildChunk.document_id == dataset_document.id,
-                    ).first()
-                    if child_chunk:
-                        segment = DocumentSegment.query.filter(DocumentSegment.id == child_chunk.segment_id).update(
-                            {DocumentSegment.hit_count: DocumentSegment.hit_count + 1}, synchronize_session=False
-                        )
-                        db.session.commit()
-                else:
-                    query = db.session.query(DocumentSegment).filter(
-                        DocumentSegment.index_node_id == document.metadata["doc_id"]
-                    )
+                query = db.session.query(DocumentSegment).filter(
+                    DocumentSegment.index_node_id == document.metadata["doc_id"]
+                )
 
-                    # if 'dataset_id' in document.metadata:
-                    if "dataset_id" in document.metadata:
-                        query = query.filter(DocumentSegment.dataset_id == document.metadata["dataset_id"])
+                # if 'dataset_id' in document.metadata:
+                if "dataset_id" in document.metadata:
+                    query = query.filter(DocumentSegment.dataset_id == document.metadata["dataset_id"])
 
-                    # add hit count to document segment
-                    query.update({DocumentSegment.hit_count: DocumentSegment.hit_count + 1}, synchronize_session=False)
+                # add hit count to document segment
+                query.update({DocumentSegment.hit_count: DocumentSegment.hit_count + 1}, synchronize_session=False)
 
                 db.session.commit()
 

api/core/rag/splitter/fixed_text_splitter.py

@@ -88,10 +88,7 @@ class FixedRecursiveCharacterTextSplitter(EnhanceRecursiveCharacterTextSplitter)
                 break
         # Now that we have the separator, split the text
         if separator:
-            if separator == " ":
-                splits = text.split()
-            else:
-                splits = text.split(separator)
+            splits = text.split(separator)
         else:
             splits = list(text)
         # Now go merging things, recursively splitting longer texts.

api/core/tools/custom_tool/tool.py

@@ -179,18 +179,6 @@ class ApiTool(Tool):
                 for content_type in self.api_bundle.openapi["requestBody"]["content"]:
                     headers["Content-Type"] = content_type
                     body_schema = self.api_bundle.openapi["requestBody"]["content"][content_type]["schema"]
-
-                    # handle ref schema
-                    if "$ref" in body_schema:
-                        ref_path = body_schema["$ref"].split("/")
-                        ref_name = ref_path[-1]
-                        if (
-                            "components" in self.api_bundle.openapi
-                            and "schemas" in self.api_bundle.openapi["components"]
-                        ):
-                            if ref_name in self.api_bundle.openapi["components"]["schemas"]:
-                                body_schema = self.api_bundle.openapi["components"]["schemas"][ref_name]
-
                     required = body_schema.get("required", [])
                     properties = body_schema.get("properties", {})
                     for name, property in properties.items():
@@ -198,8 +186,6 @@ class ApiTool(Tool):
                             if property.get("format") == "binary":
                                 f = parameters[name]
                                 files.append((name, (f.filename, download(f), f.mime_type)))
-                            elif "$ref" in property:
-                                body[name] = parameters[name]
                             else:
                                 # convert type
                                 body[name] = self._convert_body_property_type(property, parameters[name])

api/core/tools/docs/en_US/advanced_scale_out.md

@@ -55,7 +55,7 @@ If you need to return a text message, you can use the following interface.
 If you need to return the raw data of a file, such as images, audio, video, PPT, Word, Excel, etc., you can use the following interface.
 
 - `blob` The raw data of the file, of bytes type
-- `meta` The metadata of the file, if you know the type of the file, it is best to pass a `mime_type`, otherwise Dify will use `application/octet-stream` as the default type
+- `meta` The metadata of the file, if you know the type of the file, it is best to pass a `mime_type`, otherwise Dify will use `octet/stream` as the default type
 
 ```python
     def create_blob_message(self, blob: bytes, meta: dict = None, save_as: str = '') -> ToolInvokeMessage:

api/core/tools/docs/ja_JP/advanced_scale_out.md

@@ -58,7 +58,7 @@ Difyは`テキスト`、`リンク`、`画像`、`ファイルBLOB`、`JSON`な
 画像、音声、動画、PPT、Word、Excelなどのファイルの生データを返す必要がある場合は、以下のインターフェースを使用できます。
 
 - `blob` ファイルの生データ（bytes型）
-- `meta` ファイルのメタデータ。ファイルの種類が分かっている場合は、`mime_type`を渡すことをお勧めします。そうでない場合、Difyはデフォルトタイプとして`application/octet-stream`を使用します。
+- `meta` ファイルのメタデータ。ファイルの種類が分かっている場合は、`mime_type`を渡すことをお勧めします。そうでない場合、Difyはデフォルトタイプとして`octet/stream`を使用します。
 
 ```python
     def create_blob_message(self, blob: bytes, meta: dict = None, save_as: str = '') -> ToolInvokeMessage:

api/core/tools/docs/zh_Hans/advanced_scale_out.md

@@ -58,7 +58,7 @@ Dify支持`文本` `链接` `图片` `文件BLOB` `JSON` 等多种消息类型
 如果你需要返回文件的原始数据，如图片、音频、视频、PPT、Word、Excel等，可以使用以下接口。
 
 - `blob` 文件的原始数据，bytes类型
-- `meta` 文件的元数据，如果你知道该文件的类型，最好传递一个`mime_type`，否则Dify将使用`application/octet-stream`作为默认类型
+- `meta` 文件的元数据，如果你知道该文件的类型，最好传递一个`mime_type`，否则Dify将使用`octet/stream`作为默认类型
 
 ```python
     def create_blob_message(self, blob: bytes, meta: dict = None, save_as: str = '') -> ToolInvokeMessage:

api/core/tools/tool_engine.py

@@ -290,16 +290,14 @@ class ToolEngine:
                     raise ValueError("missing meta data")
 
                 yield ToolInvokeMessageBinary(
-                    mimetype=response.meta.get("mime_type", "application/octet-stream"),
+                    mimetype=response.meta.get("mime_type", "octet/stream"),
                     url=cast(ToolInvokeMessage.TextMessage, response.message).text,
                 )
             elif response.type == ToolInvokeMessage.MessageType.LINK:
                 # check if there is a mime type in meta
                 if response.meta and "mime_type" in response.meta:
                     yield ToolInvokeMessageBinary(
-                        mimetype=response.meta.get("mime_type", "application/octet-stream")
-                        if response.meta
-                        else "application/octet-stream",
+                        mimetype=response.meta.get("mime_type", "octet/stream") if response.meta else "octet/stream",
                         url=cast(ToolInvokeMessage.TextMessage, response.message).text,
                     )
 

api/core/tools/tool_file_manager.py

@@ -101,7 +101,7 @@ class ToolFileManager:
         except httpx.TimeoutException:
             raise ValueError(f"timeout when downloading file from {file_url}")
 
-        mimetype = guess_type(file_url)[0] or "application/octet-stream"
+        mimetype = guess_type(file_url)[0] or "octet/stream"
         extension = guess_extension(mimetype) or ".bin"
         unique_name = uuid4().hex
         filename = f"{unique_name}{extension}"

api/core/tools/tool_manager.py

@@ -765,22 +765,17 @@ class ToolManager:
 
     @classmethod
     def generate_builtin_tool_icon_url(cls, provider_id: str) -> str:
-        return str(
-            URL(dify_config.CONSOLE_API_URL or "/")
-            / "console"
-            / "api"
-            / "workspaces"
-            / "current"
-            / "tool-provider"
-            / "builtin"
-            / provider_id
-            / "icon"
+        return (
+            dify_config.CONSOLE_API_URL
+            + "/console/api/workspaces/current/tool-provider/builtin/"
+            + provider_id
+            + "/icon"
         )
 
     @classmethod
     def generate_plugin_tool_icon_url(cls, tenant_id: str, filename: str) -> str:
         return str(
-            URL(dify_config.CONSOLE_API_URL or "/")
+            URL(dify_config.CONSOLE_API_URL)
             / "console"
             / "api"
             / "workspaces"

api/core/tools/utils/message_transformer.py

@@ -58,7 +58,7 @@ class ToolFileMessageTransformer:
                 # get mime type and save blob to storage
                 meta = message.meta or {}
 
-                mimetype = meta.get("mime_type", "application/octet-stream")
+                mimetype = meta.get("mime_type", "octet/stream")
                 # if message is str, encode it to bytes
 
                 if not isinstance(message.message, ToolInvokeMessage.BlobMessage):

api/core/variables/segments.py

@@ -136,7 +136,7 @@ class ArrayStringSegment(ArraySegment):
 
     @property
     def text(self) -> str:
-        return json.dumps(self.value, ensure_ascii=False)
+        return json.dumps(self.value)
 
 
 class ArrayNumberSegment(ArraySegment):

api/core/workflow/callbacks/workflow_logging_callback.py

@@ -11,10 +11,6 @@ from core.workflow.graph_engine.entities.event import (
     IterationRunNextEvent,
     IterationRunStartedEvent,
     IterationRunSucceededEvent,
-    LoopRunFailedEvent,
-    LoopRunNextEvent,
-    LoopRunStartedEvent,
-    LoopRunSucceededEvent,
     NodeRunFailedEvent,
     NodeRunStartedEvent,
     NodeRunStreamChunkEvent,
@@ -66,12 +62,6 @@ class WorkflowLoggingCallback(WorkflowCallback):
             self.on_workflow_iteration_next(event=event)
         elif isinstance(event, IterationRunSucceededEvent | IterationRunFailedEvent):
             self.on_workflow_iteration_completed(event=event)
-        elif isinstance(event, LoopRunStartedEvent):
-            self.on_workflow_loop_started(event=event)
-        elif isinstance(event, LoopRunNextEvent):
-            self.on_workflow_loop_next(event=event)
-        elif isinstance(event, LoopRunSucceededEvent | LoopRunFailedEvent):
-            self.on_workflow_loop_completed(event=event)
         else:
             self.print_text(f"\n[{event.__class__.__name__}]", color="blue")
 
@@ -170,8 +160,6 @@ class WorkflowLoggingCallback(WorkflowCallback):
         self.print_text(f"Branch ID: {event.parallel_start_node_id}", color="blue")
         if event.in_iteration_id:
             self.print_text(f"Iteration ID: {event.in_iteration_id}", color="blue")
-        if event.in_loop_id:
-            self.print_text(f"Loop ID: {event.in_loop_id}", color="blue")
 
     def on_workflow_parallel_completed(
         self, event: ParallelBranchRunSucceededEvent | ParallelBranchRunFailedEvent
@@ -194,8 +182,6 @@ class WorkflowLoggingCallback(WorkflowCallback):
         self.print_text(f"Branch ID: {event.parallel_start_node_id}", color=color)
         if event.in_iteration_id:
             self.print_text(f"Iteration ID: {event.in_iteration_id}", color=color)
-        if event.in_loop_id:
-            self.print_text(f"Loop ID: {event.in_loop_id}", color=color)
 
         if isinstance(event, ParallelBranchRunFailedEvent):
             self.print_text(f"Error: {event.error}", color=color)
@@ -227,31 +213,6 @@ class WorkflowLoggingCallback(WorkflowCallback):
         )
         self.print_text(f"Node ID: {event.iteration_id}", color="blue")
 
-    def on_workflow_loop_started(self, event: LoopRunStartedEvent) -> None:
-        """
-        Publish loop started
-        """
-        self.print_text("\n[LoopRunStartedEvent]", color="blue")
-        self.print_text(f"Loop Node ID: {event.loop_id}", color="blue")
-
-    def on_workflow_loop_next(self, event: LoopRunNextEvent) -> None:
-        """
-        Publish loop next
-        """
-        self.print_text("\n[LoopRunNextEvent]", color="blue")
-        self.print_text(f"Loop Node ID: {event.loop_id}", color="blue")
-        self.print_text(f"Loop Index: {event.index}", color="blue")
-
-    def on_workflow_loop_completed(self, event: LoopRunSucceededEvent | LoopRunFailedEvent) -> None:
-        """
-        Publish loop completed
-        """
-        self.print_text(
-            "\n[LoopRunSucceededEvent]" if isinstance(event, LoopRunSucceededEvent) else "\n[LoopRunFailedEvent]",
-            color="blue",
-        )
-        self.print_text(f"Node ID: {event.loop_id}", color="blue")
-
     def print_text(self, text: str, color: Optional[str] = None, end: str = "\n") -> None:
         """Print text with highlighting and no end characters."""
         text_to_print = self._get_colored_text(text, color) if color else text

api/core/workflow/entities/node_entities.py

@@ -20,15 +20,12 @@ class NodeRunMetadataKey(StrEnum):
     AGENT_LOG = "agent_log"
     ITERATION_ID = "iteration_id"
     ITERATION_INDEX = "iteration_index"
-    LOOP_ID = "loop_id"
-    LOOP_INDEX = "loop_index"
     PARALLEL_ID = "parallel_id"
     PARALLEL_START_NODE_ID = "parallel_start_node_id"
     PARENT_PARALLEL_ID = "parent_parallel_id"
     PARENT_PARALLEL_START_NODE_ID = "parent_parallel_start_node_id"
     PARALLEL_MODE_RUN_ID = "parallel_mode_run_id"
     ITERATION_DURATION_MAP = "iteration_duration_map"  # single iteration duration if iteration node runs
-    LOOP_DURATION_MAP = "loop_duration_map"  # single loop duration if loop node runs
     ERROR_STRATEGY = "error_strategy"  # node in continue on error mode return the field
 
 

api/core/workflow/entities/workflow_entities.py

@@ -3,7 +3,7 @@ from typing import Optional
 from pydantic import BaseModel
 
 from core.app.entities.app_invoke_entities import InvokeFrom
-from core.workflow.nodes.base import BaseIterationState, BaseLoopState, BaseNode
+from core.workflow.nodes.base import BaseIterationState, BaseNode
 from models.enums import UserFrom
 from models.workflow import Workflow, WorkflowType
 
@@ -41,13 +41,11 @@ class WorkflowRunState:
     class NodeRun(BaseModel):
         node_id: str
         iteration_node_id: str
-        loop_node_id: str
 
     workflow_node_runs: list[NodeRun]
     workflow_node_steps: int
 
     current_iteration_state: Optional[BaseIterationState]
-    current_loop_state: Optional[BaseLoopState]
 
     def __init__(
         self,
@@ -76,4 +74,3 @@ class WorkflowRunState:
         self.workflow_node_steps = 1
         self.workflow_node_runs = []
         self.current_iteration_state = None
-        self.current_loop_state = None

api/core/workflow/graph_engine/entities/event.py

@@ -63,8 +63,6 @@ class BaseNodeEvent(GraphEngineEvent):
     """parent parallel start node id if node is in parallel"""
     in_iteration_id: Optional[str] = None
     """iteration id if node is in iteration"""
-    in_loop_id: Optional[str] = None
-    """loop id if node is in loop"""
 
 
 class NodeRunStartedEvent(BaseNodeEvent):
@@ -102,10 +100,6 @@ class NodeInIterationFailedEvent(BaseNodeEvent):
     error: str = Field(..., description="error")
 
 
-class NodeInLoopFailedEvent(BaseNodeEvent):
-    error: str = Field(..., description="error")
-
-
 class NodeRunRetryEvent(NodeRunStartedEvent):
     error: str = Field(..., description="error")
     retry_index: int = Field(..., description="which retry attempt is about to be performed")
@@ -128,8 +122,6 @@ class BaseParallelBranchEvent(GraphEngineEvent):
     """parent parallel start node id if node is in parallel"""
     in_iteration_id: Optional[str] = None
     """iteration id if node is in iteration"""
-    in_loop_id: Optional[str] = None
-    """loop id if node is in loop"""
 
 
 class ParallelBranchRunStartedEvent(BaseParallelBranchEvent):
@@ -197,59 +189,6 @@ class IterationRunFailedEvent(BaseIterationEvent):
     error: str = Field(..., description="failed reason")
 
 
-###########################################
-# Loop Events
-###########################################
-
-
-class BaseLoopEvent(GraphEngineEvent):
-    loop_id: str = Field(..., description="loop node execution id")
-    loop_node_id: str = Field(..., description="loop node id")
-    loop_node_type: NodeType = Field(..., description="node type, loop or loop")
-    loop_node_data: BaseNodeData = Field(..., description="node data")
-    parallel_id: Optional[str] = None
-    """parallel id if node is in parallel"""
-    parallel_start_node_id: Optional[str] = None
-    """parallel start node id if node is in parallel"""
-    parent_parallel_id: Optional[str] = None
-    """parent parallel id if node is in parallel"""
-    parent_parallel_start_node_id: Optional[str] = None
-    """parent parallel start node id if node is in parallel"""
-    parallel_mode_run_id: Optional[str] = None
-    """loop run in parallel mode run id"""
-
-
-class LoopRunStartedEvent(BaseLoopEvent):
-    start_at: datetime = Field(..., description="start at")
-    inputs: Optional[Mapping[str, Any]] = None
-    metadata: Optional[Mapping[str, Any]] = None
-    predecessor_node_id: Optional[str] = None
-
-
-class LoopRunNextEvent(BaseLoopEvent):
-    index: int = Field(..., description="index")
-    pre_loop_output: Optional[Any] = None
-    duration: Optional[float] = None
-
-
-class LoopRunSucceededEvent(BaseLoopEvent):
-    start_at: datetime = Field(..., description="start at")
-    inputs: Optional[Mapping[str, Any]] = None
-    outputs: Optional[Mapping[str, Any]] = None
-    metadata: Optional[Mapping[str, Any]] = None
-    steps: int = 0
-    loop_duration_map: Optional[dict[str, float]] = None
-
-
-class LoopRunFailedEvent(BaseLoopEvent):
-    start_at: datetime = Field(..., description="start at")
-    inputs: Optional[Mapping[str, Any]] = None
-    outputs: Optional[Mapping[str, Any]] = None
-    metadata: Optional[Mapping[str, Any]] = None
-    steps: int = 0
-    error: str = Field(..., description="failed reason")
-
-
 ###########################################
 # Agent Events
 ###########################################
@@ -268,7 +207,6 @@ class AgentLogEvent(BaseAgentEvent):
     status: str = Field(..., description="status")
     data: Mapping[str, Any] = Field(..., description="data")
     metadata: Optional[Mapping[str, Any]] = Field(default=None, description="metadata")
-    node_id: str = Field(..., description="agent node id")
 
 
-InNodeEvent = BaseNodeEvent | BaseParallelBranchEvent | BaseIterationEvent | BaseAgentEvent | BaseLoopEvent
+InNodeEvent = BaseNodeEvent | BaseParallelBranchEvent | BaseIterationEvent | BaseAgentEvent

api/core/workflow/graph_engine/graph_engine.py

@@ -18,9 +18,7 @@ from core.workflow.entities.node_entities import AgentNodeStrategyInit, NodeRunM
 from core.workflow.entities.variable_pool import VariablePool, VariableValue
 from core.workflow.graph_engine.condition_handlers.condition_manager import ConditionManager
 from core.workflow.graph_engine.entities.event import (
-    BaseAgentEvent,
     BaseIterationEvent,
-    BaseLoopEvent,
     GraphEngineEvent,
     GraphRunFailedEvent,
     GraphRunPartialSucceededEvent,
@@ -503,7 +501,7 @@ class GraphEngine:
                     break
 
                 yield event
-                if not isinstance(event, BaseAgentEvent) and event.parallel_id == parallel_id:
+                if event.parallel_id == parallel_id:
                     if isinstance(event, ParallelBranchRunSucceededEvent):
                         succeeded_count += 1
                         if succeeded_count == len(futures):
@@ -650,12 +648,6 @@ class GraphEngine:
                             item.parallel_start_node_id = parallel_start_node_id
                             item.parent_parallel_id = parent_parallel_id
                             item.parent_parallel_start_node_id = parent_parallel_start_node_id
-                        elif isinstance(item, BaseLoopEvent):
-                            # add parallel info to loop event
-                            item.parallel_id = parallel_id
-                            item.parallel_start_node_id = parallel_start_node_id
-                            item.parent_parallel_id = parent_parallel_id
-                            item.parent_parallel_start_node_id = parent_parallel_start_node_id
 
                         yield item
                     else:

api/core/workflow/nodes/answer/answer_stream_generate_router.py

@@ -158,7 +158,6 @@ class AnswerStreamGeneratorRouter:
                     NodeType.IF_ELSE,
                     NodeType.QUESTION_CLASSIFIER,
                     NodeType.ITERATION,
-                    NodeType.LOOP,
                     NodeType.VARIABLE_ASSIGNER,
                 }
                 or source_node_data.get("error_strategy") == ErrorStrategy.FAIL_BRANCH

api/core/workflow/nodes/answer/answer_stream_processor.py

@@ -35,7 +35,7 @@ class AnswerStreamProcessor(StreamProcessor):
 
                 yield event
             elif isinstance(event, NodeRunStreamChunkEvent):
-                if event.in_iteration_id or event.in_loop_id:
+                if event.in_iteration_id:
                     yield event
                     continue
 

api/core/workflow/nodes/base/__init__.py

@@ -1,11 +1,4 @@
-from .entities import BaseIterationNodeData, BaseIterationState, BaseLoopNodeData, BaseLoopState, BaseNodeData
+from .entities import BaseIterationNodeData, BaseIterationState, BaseNodeData
 from .node import BaseNode
 
-__all__ = [
-    "BaseIterationNodeData",
-    "BaseIterationState",
-    "BaseLoopNodeData",
-    "BaseLoopState",
-    "BaseNode",
-    "BaseNodeData",
-]
+__all__ = ["BaseIterationNodeData", "BaseIterationState", "BaseNode", "BaseNodeData"]

api/core/workflow/nodes/base/entities.py

@@ -147,18 +147,3 @@ class BaseIterationState(BaseModel):
         pass
 
     metadata: MetaData
-
-
-class BaseLoopNodeData(BaseNodeData):
-    start_node_id: Optional[str] = None
-
-
-class BaseLoopState(BaseModel):
-    loop_node_id: str
-    index: int
-    inputs: dict
-
-    class MetaData(BaseModel):
-        pass
-
-    metadata: MetaData

api/core/workflow/nodes/end/end_stream_processor.py

@@ -33,7 +33,7 @@ class EndStreamProcessor(StreamProcessor):
 
                 yield event
             elif isinstance(event, NodeRunStreamChunkEvent):
-                if event.in_iteration_id or event.in_loop_id:
+                if event.in_iteration_id:
                     if self.has_output and event.node_id not in self.output_node_ids:
                         event.chunk_content = "\n" + event.chunk_content
 

api/core/workflow/nodes/enums.py

@@ -16,7 +16,6 @@ class NodeType(StrEnum):
     VARIABLE_AGGREGATOR = "variable-aggregator"
     LEGACY_VARIABLE_AGGREGATOR = "variable-assigner"  # TODO: Merge this into VARIABLE_AGGREGATOR in the database.
     LOOP = "loop"
-    LOOP_START = "loop-start"
     ITERATION = "iteration"
     ITERATION_START = "iteration-start"  # Fake start node for iteration.
     PARAMETER_EXTRACTOR = "parameter-extractor"

api/core/workflow/nodes/http_request/entities.py

@@ -120,10 +120,6 @@ class Response:
             if disp_type == "attachment" or filename is not None:
                 return True
 
-        # For 'text/' types, only 'csv' should be downloaded as file
-        if content_type.startswith("text/") and "csv" not in content_type:
-            return False
-
         # For application types, try to detect if it's a text-based format
         if content_type.startswith("application/"):
             # Common text-based application types

api/core/workflow/nodes/knowledge_retrieval/knowledge_retrieval_node.py

@@ -1,5 +1,4 @@
 import logging
-import time
 from collections.abc import Mapping, Sequence
 from typing import Any, cast
 
@@ -20,10 +19,8 @@ from core.workflow.entities.node_entities import NodeRunResult
 from core.workflow.nodes.base import BaseNode
 from core.workflow.nodes.enums import NodeType
 from extensions.ext_database import db
-from extensions.ext_redis import redis_client
-from models.dataset import Dataset, Document, RateLimitLog
+from models.dataset import Dataset, Document
 from models.workflow import WorkflowNodeExecutionStatus
-from services.feature_service import FeatureService
 
 from .entities import KnowledgeRetrievalNodeData
 from .exc import (
@@ -64,31 +61,6 @@ class KnowledgeRetrievalNode(BaseNode[KnowledgeRetrievalNodeData]):
             return NodeRunResult(
                 status=WorkflowNodeExecutionStatus.FAILED, inputs=variables, error="Query is required."
             )
-        # check rate limit
-        if self.tenant_id:
-            knowledge_rate_limit = FeatureService.get_knowledge_rate_limit(self.tenant_id)
-            if knowledge_rate_limit.enabled:
-                current_time = int(time.time() * 1000)
-                key = f"rate_limit_{self.tenant_id}"
-                redis_client.zadd(key, {current_time: current_time})
-                redis_client.zremrangebyscore(key, 0, current_time - 60000)
-                request_count = redis_client.zcard(key)
-                if request_count > knowledge_rate_limit.limit:
-                    # add ratelimit record
-                    rate_limit_log = RateLimitLog(
-                        tenant_id=self.tenant_id,
-                        subscription_plan=knowledge_rate_limit.subscription_plan,
-                        operation="knowledge",
-                    )
-                    db.session.add(rate_limit_log)
-                    db.session.commit()
-                    return NodeRunResult(
-                        status=WorkflowNodeExecutionStatus.FAILED,
-                        inputs=variables,
-                        error="Sorry, you have reached the knowledge base request rate limit of your subscription.",
-                        error_type="RateLimitExceeded",
-                    )
-
         # retrieve knowledge
         try:
             results = self._fetch_dataset_retriever(node_data=self.node_data, query=query)

api/core/workflow/nodes/llm/node.py

@@ -94,9 +94,6 @@ class LLMNode(BaseNode[LLMNodeData]):
     def _run(self) -> Generator[NodeEvent | InNodeEvent, None, None]:
         node_inputs: Optional[dict[str, Any]] = None
         process_data = None
-        result_text = ""
-        usage = LLMUsage.empty_usage()
-        finish_reason = None
 
         try:
             # init messages template
@@ -181,6 +178,9 @@ class LLMNode(BaseNode[LLMNodeData]):
                 stop=stop,
             )
 
+            result_text = ""
+            usage = LLMUsage.empty_usage()
+            finish_reason = None
             for event in generator:
                 if isinstance(event, RunStreamChunkEvent):
                     yield event

api/core/workflow/nodes/loop/__init__.py

@@ -1,5 +0,0 @@
-from .entities import LoopNodeData
-from .loop_node import LoopNode
-from .loop_start_node import LoopStartNode
-
-__all__ = ["LoopNode", "LoopNodeData", "LoopStartNode"]

api/core/workflow/nodes/loop/entities.py

@@ -1,54 +1,13 @@
-from typing import Any, Literal, Optional
-
-from pydantic import Field
-
-from core.workflow.nodes.base import BaseLoopNodeData, BaseLoopState, BaseNodeData
-from core.workflow.utils.condition.entities import Condition
+from core.workflow.nodes.base import BaseIterationNodeData, BaseIterationState
 
 
-class LoopNodeData(BaseLoopNodeData):
+class LoopNodeData(BaseIterationNodeData):
     """
     Loop Node Data.
     """
 
-    loop_count: int  # Maximum number of loops
-    break_conditions: list[Condition]  # Conditions to break the loop
-    logical_operator: Literal["and", "or"]
 
-
-class LoopStartNodeData(BaseNodeData):
-    """
-    Loop Start Node Data.
-    """
-
-    pass
-
-
-class LoopState(BaseLoopState):
+class LoopState(BaseIterationState):
     """
     Loop State.
     """
-
-    outputs: list[Any] = Field(default_factory=list)
-    current_output: Optional[Any] = None
-
-    class MetaData(BaseLoopState.MetaData):
-        """
-        Data.
-        """
-
-        loop_length: int
-
-    def get_last_output(self) -> Optional[Any]:
-        """
-        Get last output.
-        """
-        if self.outputs:
-            return self.outputs[-1]
-        return None
-
-    def get_current_output(self) -> Optional[Any]:
-        """
-        Get current output.
-        """
-        return self.current_output

api/core/workflow/nodes/loop/loop_node.py

@@ -1,35 +1,9 @@
-import logging
-from collections.abc import Generator, Mapping, Sequence
-from datetime import datetime, timezone
-from typing import Any, cast
+from typing import Any
 
-from configs import dify_config
-from core.variables import IntegerSegment
-from core.workflow.entities.node_entities import NodeRunMetadataKey, NodeRunResult
-from core.workflow.graph_engine.entities.event import (
-    BaseGraphEvent,
-    BaseNodeEvent,
-    BaseParallelBranchEvent,
-    GraphRunFailedEvent,
-    InNodeEvent,
-    LoopRunFailedEvent,
-    LoopRunNextEvent,
-    LoopRunStartedEvent,
-    LoopRunSucceededEvent,
-    NodeRunFailedEvent,
-    NodeRunStartedEvent,
-    NodeRunStreamChunkEvent,
-    NodeRunSucceededEvent,
-)
-from core.workflow.graph_engine.entities.graph import Graph
 from core.workflow.nodes.base import BaseNode
 from core.workflow.nodes.enums import NodeType
-from core.workflow.nodes.event import NodeEvent, RunCompletedEvent
-from core.workflow.nodes.loop.entities import LoopNodeData
-from core.workflow.utils.condition.processor import ConditionProcessor
-from models.workflow import WorkflowNodeExecutionStatus
-
-logger = logging.getLogger(__name__)
+from core.workflow.nodes.loop.entities import LoopNodeData, LoopState
+from core.workflow.utils.condition.entities import Condition
 
 
 class LoopNode(BaseNode[LoopNodeData]):
@@ -40,323 +14,24 @@ class LoopNode(BaseNode[LoopNodeData]):
     _node_data_cls = LoopNodeData
     _node_type = NodeType.LOOP
 
-    def _run(self) -> Generator[NodeEvent | InNodeEvent, None, None]:
-        """Run the node."""
-        # Get inputs
-        loop_count = self.node_data.loop_count
-        break_conditions = self.node_data.break_conditions
-        logical_operator = self.node_data.logical_operator
-
-        inputs = {"loop_count": loop_count}
-
-        if not self.node_data.start_node_id:
-            raise ValueError(f"field start_node_id in loop {self.node_id} not found")
-
-        # Initialize graph
-        loop_graph = Graph.init(graph_config=self.graph_config, root_node_id=self.node_data.start_node_id)
-        if not loop_graph:
-            raise ValueError("loop graph not found")
-
-        # Initialize variable pool
-        variable_pool = self.graph_runtime_state.variable_pool
-        variable_pool.add([self.node_id, "index"], 0)
-
-        from core.workflow.graph_engine.graph_engine import GraphEngine
-
-        graph_engine = GraphEngine(
-            tenant_id=self.tenant_id,
-            app_id=self.app_id,
-            workflow_type=self.workflow_type,
-            workflow_id=self.workflow_id,
-            user_id=self.user_id,
-            user_from=self.user_from,
-            invoke_from=self.invoke_from,
-            call_depth=self.workflow_call_depth,
-            graph=loop_graph,
-            graph_config=self.graph_config,
-            variable_pool=variable_pool,
-            max_execution_steps=dify_config.WORKFLOW_MAX_EXECUTION_STEPS,
-            max_execution_time=dify_config.WORKFLOW_MAX_EXECUTION_TIME,
-            thread_pool_id=self.thread_pool_id,
-        )
-
-        start_at = datetime.now(timezone.utc).replace(tzinfo=None)
-        condition_processor = ConditionProcessor()
-
-        # Start Loop event
-        yield LoopRunStartedEvent(
-            loop_id=self.id,
-            loop_node_id=self.node_id,
-            loop_node_type=self.node_type,
-            loop_node_data=self.node_data,
-            start_at=start_at,
-            inputs=inputs,
-            metadata={"loop_length": loop_count},
-            predecessor_node_id=self.previous_node_id,
-        )
-
-        yield LoopRunNextEvent(
-            loop_id=self.id,
-            loop_node_id=self.node_id,
-            loop_node_type=self.node_type,
-            loop_node_data=self.node_data,
-            index=0,
-            pre_loop_output=None,
-        )
-
-        try:
-            check_break_result = False
-            for i in range(loop_count):
-                # Run workflow
-                rst = graph_engine.run()
-                current_index_variable = variable_pool.get([self.node_id, "index"])
-                if not isinstance(current_index_variable, IntegerSegment):
-                    raise ValueError(f"loop {self.node_id} current index not found")
-                current_index = current_index_variable.value
-
-                check_break_result = False
-
-                for event in rst:
-                    if isinstance(event, (BaseNodeEvent | BaseParallelBranchEvent)) and not event.in_loop_id:
-                        event.in_loop_id = self.node_id
-
-                    if (
-                        isinstance(event, BaseNodeEvent)
-                        and event.node_type == NodeType.LOOP_START
-                        and not isinstance(event, NodeRunStreamChunkEvent)
-                    ):
-                        continue
-
-                    if isinstance(event, NodeRunSucceededEvent):
-                        yield self._handle_event_metadata(event=event, iter_run_index=current_index)
-
-                        # Check if all variables in break conditions exist
-                        exists_variable = False
-                        for condition in break_conditions:
-                            if not self.graph_runtime_state.variable_pool.get(condition.variable_selector):
-                                exists_variable = False
-                                break
-                            else:
-                                exists_variable = True
-                        if exists_variable:
-                            input_conditions, group_result, check_break_result = condition_processor.process_conditions(
-                                variable_pool=self.graph_runtime_state.variable_pool,
-                                conditions=break_conditions,
-                                operator=logical_operator,
-                            )
-                            if check_break_result:
-                                break
-
-                    elif isinstance(event, BaseGraphEvent):
-                        if isinstance(event, GraphRunFailedEvent):
-                            # Loop run failed
-                            yield LoopRunFailedEvent(
-                                loop_id=self.id,
-                                loop_node_id=self.node_id,
-                                loop_node_type=self.node_type,
-                                loop_node_data=self.node_data,
-                                start_at=start_at,
-                                inputs=inputs,
-                                steps=i,
-                                metadata={
-                                    NodeRunMetadataKey.TOTAL_TOKENS: graph_engine.graph_runtime_state.total_tokens,
-                                    "completed_reason": "error",
-                                },
-                                error=event.error,
-                            )
-                            yield RunCompletedEvent(
-                                run_result=NodeRunResult(
-                                    status=WorkflowNodeExecutionStatus.FAILED,
-                                    error=event.error,
-                                    metadata={
-                                        NodeRunMetadataKey.TOTAL_TOKENS: graph_engine.graph_runtime_state.total_tokens
-                                    },
-                                )
-                            )
-                            return
-                    elif isinstance(event, NodeRunFailedEvent):
-                        # Loop run failed
-                        yield event
-                        yield LoopRunFailedEvent(
-                            loop_id=self.id,
-                            loop_node_id=self.node_id,
-                            loop_node_type=self.node_type,
-                            loop_node_data=self.node_data,
-                            start_at=start_at,
-                            inputs=inputs,
-                            steps=i,
-                            metadata={
-                                NodeRunMetadataKey.TOTAL_TOKENS: graph_engine.graph_runtime_state.total_tokens,
-                                "completed_reason": "error",
-                            },
-                            error=event.error,
-                        )
-                        yield RunCompletedEvent(
-                            run_result=NodeRunResult(
-                                status=WorkflowNodeExecutionStatus.FAILED,
-                                error=event.error,
-                                metadata={
-                                    NodeRunMetadataKey.TOTAL_TOKENS: graph_engine.graph_runtime_state.total_tokens
-                                },
-                            )
-                        )
-                        return
-                    else:
-                        yield self._handle_event_metadata(event=cast(InNodeEvent, event), iter_run_index=current_index)
-
-                # Remove all nodes outputs from variable pool
-                for node_id in loop_graph.node_ids:
-                    variable_pool.remove([node_id])
-
-                if check_break_result:
-                    break
-
-                # Move to next loop
-                next_index = current_index + 1
-                variable_pool.add([self.node_id, "index"], next_index)
-
-                yield LoopRunNextEvent(
-                    loop_id=self.id,
-                    loop_node_id=self.node_id,
-                    loop_node_type=self.node_type,
-                    loop_node_data=self.node_data,
-                    index=next_index,
-                    pre_loop_output=None,
-                )
-
-            # Loop completed successfully
-            yield LoopRunSucceededEvent(
-                loop_id=self.id,
-                loop_node_id=self.node_id,
-                loop_node_type=self.node_type,
-                loop_node_data=self.node_data,
-                start_at=start_at,
-                inputs=inputs,
-                steps=loop_count,
-                metadata={
-                    NodeRunMetadataKey.TOTAL_TOKENS: graph_engine.graph_runtime_state.total_tokens,
-                    "completed_reason": "loop_break" if check_break_result else "loop_completed",
-                },
-            )
-
-            yield RunCompletedEvent(
-                run_result=NodeRunResult(
-                    status=WorkflowNodeExecutionStatus.SUCCEEDED,
-                    metadata={NodeRunMetadataKey.TOTAL_TOKENS: graph_engine.graph_runtime_state.total_tokens},
-                )
-            )
-
-        except Exception as e:
-            # Loop failed
-            logger.exception("Loop run failed")
-            yield LoopRunFailedEvent(
-                loop_id=self.id,
-                loop_node_id=self.node_id,
-                loop_node_type=self.node_type,
-                loop_node_data=self.node_data,
-                start_at=start_at,
-                inputs=inputs,
-                steps=loop_count,
-                metadata={
-                    "total_tokens": graph_engine.graph_runtime_state.total_tokens,
-                    "completed_reason": "error",
-                },
-                error=str(e),
-            )
-
-            yield RunCompletedEvent(
-                run_result=NodeRunResult(
-                    status=WorkflowNodeExecutionStatus.FAILED,
-                    error=str(e),
-                    metadata={NodeRunMetadataKey.TOTAL_TOKENS: graph_engine.graph_runtime_state.total_tokens},
-                )
-            )
-
-        finally:
-            # Clean up
-            variable_pool.remove([self.node_id, "index"])
-
-    def _handle_event_metadata(
-        self,
-        *,
-        event: BaseNodeEvent | InNodeEvent,
-        iter_run_index: int,
-    ) -> NodeRunStartedEvent | BaseNodeEvent | InNodeEvent:
-        """
-        add iteration metadata to event.
-        """
-        if not isinstance(event, BaseNodeEvent):
-            return event
-        if event.route_node_state.node_run_result:
-            metadata = event.route_node_state.node_run_result.metadata
-            if not metadata:
-                metadata = {}
-            if NodeRunMetadataKey.LOOP_ID not in metadata:
-                metadata = {
-                    **metadata,
-                    NodeRunMetadataKey.LOOP_ID: self.node_id,
-                    NodeRunMetadataKey.LOOP_INDEX: iter_run_index,
-                }
-                event.route_node_state.node_run_result.metadata = metadata
-        return event
+    def _run(self) -> LoopState:  # type: ignore
+        return super()._run()  # type: ignore
 
     @classmethod
-    def _extract_variable_selector_to_variable_mapping(
-        cls,
-        *,
-        graph_config: Mapping[str, Any],
-        node_id: str,
-        node_data: LoopNodeData,
-    ) -> Mapping[str, Sequence[str]]:
+    def get_conditions(cls, node_config: dict[str, Any]) -> list[Condition]:
         """
-        Extract variable selector to variable mapping
-        :param graph_config: graph config
-        :param node_id: node id
-        :param node_data: node data
-        :return:
+        Get conditions.
         """
-        variable_mapping = {}
+        node_id = node_config.get("id")
+        if not node_id:
+            return []
 
-        # init graph
-        loop_graph = Graph.init(graph_config=graph_config, root_node_id=node_data.start_node_id)
-
-        if not loop_graph:
-            raise ValueError("loop graph not found")
-
-        for sub_node_id, sub_node_config in loop_graph.node_id_config_mapping.items():
-            if sub_node_config.get("data", {}).get("loop_id") != node_id:
-                continue
-
-            # variable selector to variable mapping
-            try:
-                # Get node class
-                from core.workflow.nodes.node_mapping import NODE_TYPE_CLASSES_MAPPING
-
-                node_type = NodeType(sub_node_config.get("data", {}).get("type"))
-                if node_type not in NODE_TYPE_CLASSES_MAPPING:
-                    continue
-                node_version = sub_node_config.get("data", {}).get("version", "1")
-                node_cls = NODE_TYPE_CLASSES_MAPPING[node_type][node_version]
-
-                sub_node_variable_mapping = node_cls.extract_variable_selector_to_variable_mapping(
-                    graph_config=graph_config, config=sub_node_config
-                )
-                sub_node_variable_mapping = cast(dict[str, Sequence[str]], sub_node_variable_mapping)
-            except NotImplementedError:
-                sub_node_variable_mapping = {}
-
-            # remove loop variables
-            sub_node_variable_mapping = {
-                sub_node_id + "." + key: value
-                for key, value in sub_node_variable_mapping.items()
-                if value[0] != node_id
-            }
-
-            variable_mapping.update(sub_node_variable_mapping)
-
-        # remove variable out from loop
-        variable_mapping = {
-            key: value for key, value in variable_mapping.items() if value[0] not in loop_graph.node_ids
-        }
-
-        return variable_mapping
+        # TODO waiting for implementation
+        return [
+            Condition(  # type: ignore
+                variable_selector=[node_id, "index"],
+                comparison_operator="≤",
+                value_type="value_selector",
+                value_selector=[],
+            )
+        ]

api/core/workflow/nodes/loop/loop_start_node.py

@@ -1,20 +0,0 @@
-from core.workflow.entities.node_entities import NodeRunResult
-from core.workflow.nodes.base import BaseNode
-from core.workflow.nodes.enums import NodeType
-from core.workflow.nodes.loop.entities import LoopStartNodeData
-from models.workflow import WorkflowNodeExecutionStatus
-
-
-class LoopStartNode(BaseNode):
-    """
-    Loop Start Node.
-    """
-
-    _node_data_cls = LoopStartNodeData
-    _node_type = NodeType.LOOP_START
-
-    def _run(self) -> NodeRunResult:
-        """
-        Run the node.
-        """
-        return NodeRunResult(status=WorkflowNodeExecutionStatus.SUCCEEDED)

api/core/workflow/nodes/node_mapping.py

@@ -13,7 +13,6 @@ from core.workflow.nodes.iteration import IterationNode, IterationStartNode
 from core.workflow.nodes.knowledge_retrieval import KnowledgeRetrievalNode
 from core.workflow.nodes.list_operator import ListOperatorNode
 from core.workflow.nodes.llm import LLMNode
-from core.workflow.nodes.loop import LoopNode, LoopStartNode
 from core.workflow.nodes.parameter_extractor import ParameterExtractorNode
 from core.workflow.nodes.question_classifier import QuestionClassifierNode
 from core.workflow.nodes.start import StartNode
@@ -86,14 +85,6 @@ NODE_TYPE_CLASSES_MAPPING: Mapping[NodeType, Mapping[str, type[BaseNode]]] = {
         LATEST_VERSION: IterationStartNode,
         "1": IterationStartNode,
     },
-    NodeType.LOOP: {
-        LATEST_VERSION: LoopNode,
-        "1": LoopNode,
-    },
-    NodeType.LOOP_START: {
-        LATEST_VERSION: LoopStartNode,
-        "1": LoopStartNode,
-    },
     NodeType.PARAMETER_EXTRACTOR: {
         LATEST_VERSION: ParameterExtractorNode,
         "1": ParameterExtractorNode,

api/core/workflow/nodes/tool/tool_node.py

@@ -270,9 +270,7 @@ class ToolNode(BaseNode[ToolNodeData]):
                 if self.node_type == NodeType.AGENT:
                     msg_metadata = message.message.json_object.pop("execution_metadata", {})
                     agent_execution_metadata = {
-                        key: value
-                        for key, value in msg_metadata.items()
-                        if key in NodeRunMetadataKey.__members__.values()
+                        key: value for key, value in msg_metadata.items() if key in NodeRunMetadataKey
                     }
                 json.append(message.message.json_object)
             elif message.type == ToolInvokeMessage.MessageType.LINK:
@@ -340,7 +338,6 @@ class ToolNode(BaseNode[ToolNodeData]):
                     data=message.message.data,
                     label=message.message.label,
                     metadata=message.message.metadata,
-                    node_id=self.node_id,
                 )
 
                 # check if the agent log is already in the list

api/extensions/storage/aws_s3_storage.py

@@ -32,7 +32,11 @@ class AwsS3Storage(BaseStorage):
                 aws_access_key_id=dify_config.S3_ACCESS_KEY,
                 endpoint_url=dify_config.S3_ENDPOINT,
                 region_name=dify_config.S3_REGION,
-                config=Config(s3={"addressing_style": dify_config.S3_ADDRESS_STYLE}),
+                config=Config(
+                    s3={"addressing_style": dify_config.S3_ADDRESS_STYLE},
+                    request_checksum_calculation="when_required",
+                    response_checksum_validation="when_required",
+                ),
             )
         # create bucket
         try:

api/factories/file_factory.py

@@ -7,7 +7,7 @@ import httpx
 from sqlalchemy import select
 
 from constants import AUDIO_EXTENSIONS, DOCUMENT_EXTENSIONS, IMAGE_EXTENSIONS, VIDEO_EXTENSIONS
-from core.file import File, FileBelongsTo, FileTransferMethod, FileType, FileUploadConfig, helpers
+from core.file import File, FileBelongsTo, FileTransferMethod, FileType, FileUploadConfig
 from core.helper import ssrf_proxy
 from extensions.ext_database import db
 from models import MessageFile, ToolFile, UploadFile
@@ -158,39 +158,6 @@ def _build_from_remote_url(
     tenant_id: str,
     transfer_method: FileTransferMethod,
 ) -> File:
-    upload_file_id = mapping.get("upload_file_id")
-    if upload_file_id:
-        try:
-            uuid.UUID(upload_file_id)
-        except ValueError:
-            raise ValueError("Invalid upload file id format")
-        stmt = select(UploadFile).where(
-            UploadFile.id == upload_file_id,
-            UploadFile.tenant_id == tenant_id,
-        )
-
-        upload_file = db.session.scalar(stmt)
-        if upload_file is None:
-            raise ValueError("Invalid upload file")
-
-        file_type = FileType(mapping.get("type", "custom"))
-        file_type = _standardize_file_type(
-            file_type, extension="." + upload_file.extension, mime_type=upload_file.mime_type
-        )
-
-        return File(
-            id=mapping.get("id"),
-            filename=upload_file.name,
-            extension="." + upload_file.extension,
-            mime_type=upload_file.mime_type,
-            tenant_id=tenant_id,
-            type=file_type,
-            transfer_method=transfer_method,
-            remote_url=helpers.get_signed_file_url(upload_file_id=str(upload_file_id)),
-            related_id=mapping.get("upload_file_id"),
-            size=upload_file.size,
-            storage_key=upload_file.key,
-        )
     url = mapping.get("url") or mapping.get("remote_url")
     if not url:
         raise ValueError("Invalid file url")

api/fields/workflow_app_log_fields.py

@@ -17,8 +17,8 @@ workflow_app_log_partial_fields = {
 
 workflow_app_log_pagination_fields = {
     "page": fields.Integer,
-    "limit": fields.Integer,
+    "limit": fields.Integer(attribute="per_page"),
     "total": fields.Integer,
-    "has_more": fields.Boolean,
-    "data": fields.List(fields.Nested(workflow_app_log_partial_fields)),
+    "has_more": fields.Boolean(attribute="has_next"),
+    "data": fields.List(fields.Nested(workflow_app_log_partial_fields), attribute="items"),
 }

api/fields/workflow_fields.py

@@ -45,9 +45,7 @@ workflow_fields = {
     "graph": fields.Raw(attribute="graph_dict"),
     "features": fields.Raw(attribute="features_dict"),
     "hash": fields.String(attribute="unique_hash"),
-    "version": fields.String,
-    "marked_name": fields.String,
-    "marked_comment": fields.String,
+    "version": fields.String(attribute="version"),
     "created_by": fields.Nested(simple_account_fields, attribute="created_by_account"),
     "created_at": TimestampField,
     "updated_by": fields.Nested(simple_account_fields, attribute="updated_by_account", allow_null=True),

api/libs/login.py

@@ -77,7 +77,7 @@ def login_required(func):
                             )
                             if tenant_account_join:
                                 tenant, ta = tenant_account_join
-                                account = db.session.query(Account).filter_by(id=ta.account_id).first()
+                                account = Account.query.filter_by(id=ta.account_id).first()
                                 # Login admin
                                 if account:
                                     account.current_tenant = tenant

api/migrations/versions/2025_01_14_0617-f051706725cc_add_rate_limit_logs.py

@@ -1,43 +0,0 @@
-"""add_rate_limit_logs
-
-Revision ID: f051706725cc
-Revises: 923752d42eb6
-Create Date: 2025-01-14 06:17:35.536388
-
-"""
-from alembic import op
-import models as models
-import sqlalchemy as sa
-from sqlalchemy.dialects import postgresql
-
-# revision identifiers, used by Alembic.
-revision = 'f051706725cc'
-down_revision = 'ee79d9b1c156'
-branch_labels = None
-depends_on = None
-
-
-def upgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.create_table('rate_limit_logs',
-    sa.Column('id', models.types.StringUUID(), server_default=sa.text('uuid_generate_v4()'), nullable=False),
-    sa.Column('tenant_id', models.types.StringUUID(), nullable=False),
-    sa.Column('subscription_plan', sa.String(length=255), nullable=False),
-    sa.Column('operation', sa.String(length=255), nullable=False),
-    sa.Column('created_at', sa.DateTime(), server_default=sa.text('CURRENT_TIMESTAMP(0)'), nullable=False),
-    sa.PrimaryKeyConstraint('id', name='rate_limit_log_pkey')
-    )
-    with op.batch_alter_table('rate_limit_logs', schema=None) as batch_op:
-        batch_op.create_index('rate_limit_log_operation_idx', ['operation'], unique=False)
-        batch_op.create_index('rate_limit_log_tenant_idx', ['tenant_id'], unique=False)
-    # ### end Alembic commands ###
-
-
-def downgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    with op.batch_alter_table('rate_limit_logs', schema=None) as batch_op:
-        batch_op.drop_index('rate_limit_log_tenant_idx')
-        batch_op.drop_index('rate_limit_log_operation_idx')
-
-    op.drop_table('rate_limit_logs')
-    # ### end Alembic commands ###

api/migrations/versions/2025_03_03_1436-ee79d9b1c156_add_marked_name_and_marked_comment_in_.py

@@ -1,29 +0,0 @@
-"""add marked_name and marked_comment in workflows
-
-Revision ID: ee79d9b1c156
-Revises: 4413929e1ec2
-Create Date: 2025-03-03 14:36:05.750346
-
-"""
-from alembic import op
-import models as models
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision = 'ee79d9b1c156'
-down_revision = '5511c782ee4c'
-branch_labels = None
-depends_on = None
-
-
-def upgrade():
-    with op.batch_alter_table('workflows', schema=None) as batch_op:
-        batch_op.add_column(sa.Column('marked_name', sa.String(), nullable=False, server_default=''))
-        batch_op.add_column(sa.Column('marked_comment', sa.String(), nullable=False, server_default=''))
-
-
-def downgrade():
-    with op.batch_alter_table('workflows', schema=None) as batch_op:
-        batch_op.drop_column('marked_comment')
-        batch_op.drop_column('marked_name')

api/migrations/versions/2025_03_07_0315-5511c782ee4c_extend_provider_column.py

@@ -1,64 +0,0 @@
-"""extend provider column
-
-Revision ID: 5511c782ee4c
-Revises: 4413929e1ec2
-Create Date: 2025-03-07 03:15:05.364804
-
-"""
-from alembic import op
-import models as models
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision = '5511c782ee4c'
-down_revision = '4413929e1ec2'
-branch_labels = None
-depends_on = None
-
-
-def upgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    with op.batch_alter_table('tool_api_providers', schema=None) as batch_op:
-        batch_op.alter_column('name',
-               existing_type=sa.VARCHAR(length=40),
-               type_=sa.String(length=255),
-               existing_nullable=False)
-
-    with op.batch_alter_table('tool_model_invokes', schema=None) as batch_op:
-        batch_op.alter_column('provider',
-               existing_type=sa.VARCHAR(length=40),
-               type_=sa.String(length=255),
-               existing_nullable=False)
-
-    with op.batch_alter_table('tool_workflow_providers', schema=None) as batch_op:
-        batch_op.alter_column('name',
-               existing_type=sa.VARCHAR(length=40),
-               type_=sa.String(length=255),
-               existing_nullable=False)
-
-    # ### end Alembic commands ###
-
-
-def downgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-
-    with op.batch_alter_table('tool_workflow_providers', schema=None) as batch_op:
-        batch_op.alter_column('name',
-               existing_type=sa.String(length=255),
-               type_=sa.VARCHAR(length=40),
-               existing_nullable=False)
-
-    with op.batch_alter_table('tool_model_invokes', schema=None) as batch_op:
-        batch_op.alter_column('provider',
-               existing_type=sa.String(length=255),
-               type_=sa.VARCHAR(length=40),
-               existing_nullable=False)
-
-    with op.batch_alter_table('tool_api_providers', schema=None) as batch_op:
-        batch_op.alter_column('name',
-               existing_type=sa.String(length=255),
-               type_=sa.VARCHAR(length=40),
-               existing_nullable=False)
-
-    # ### end Alembic commands ###

api/models/dataset.py

@@ -930,18 +930,3 @@ class DatasetAutoDisableLog(db.Model):  # type: ignore[name-defined]
     document_id = db.Column(StringUUID, nullable=False)
     notified = db.Column(db.Boolean, nullable=False, server_default=db.text("false"))
     created_at = db.Column(db.DateTime, nullable=False, server_default=db.text("CURRENT_TIMESTAMP(0)"))
-
-
-class RateLimitLog(db.Model):  # type: ignore[name-defined]
-    __tablename__ = "rate_limit_logs"
-    __table_args__ = (
-        db.PrimaryKeyConstraint("id", name="rate_limit_log_pkey"),
-        db.Index("rate_limit_log_tenant_idx", "tenant_id"),
-        db.Index("rate_limit_log_operation_idx", "operation"),
-    )
-
-    id = db.Column(StringUUID, server_default=db.text("uuid_generate_v4()"))
-    tenant_id = db.Column(StringUUID, nullable=False)
-    subscription_plan = db.Column(db.String(255), nullable=False)
-    operation = db.Column(db.String(255), nullable=False)
-    created_at = db.Column(db.DateTime, nullable=False, server_default=db.text("CURRENT_TIMESTAMP(0)"))

api/models/model.py

@@ -257,7 +257,7 @@ class App(Base):
                 provider_id = tool.get("provider_id", "")
 
                 if provider_type == ToolProviderType.API.value:
-                    if uuid.UUID(provider_id) not in existing_api_providers:
+                    if provider_id not in existing_api_providers:
                         deleted_tools.append(
                             {
                                 "type": ToolProviderType.API.value,
@@ -1081,19 +1081,19 @@ class Message(db.Model):  # type: ignore[name-defined]
 
         files = []
         for message_file in message_files:
-            if message_file.transfer_method == FileTransferMethod.LOCAL_FILE.value:
+            if message_file.transfer_method == "local_file":
                 if message_file.upload_file_id is None:
                     raise ValueError(f"MessageFile {message_file.id} is a local file but has no upload_file_id")
                 file = file_factory.build_from_mapping(
                     mapping={
                         "id": message_file.id,
-                        "type": message_file.type,
-                        "transfer_method": message_file.transfer_method,
                         "upload_file_id": message_file.upload_file_id,
+                        "transfer_method": message_file.transfer_method,
+                        "type": message_file.type,
                     },
                     tenant_id=current_app.tenant_id,
                 )
-            elif message_file.transfer_method == FileTransferMethod.REMOTE_URL.value:
+            elif message_file.transfer_method == "remote_url":
                 if message_file.url is None:
                     raise ValueError(f"MessageFile {message_file.id} is a remote url but has no url")
                 file = file_factory.build_from_mapping(
@@ -1101,12 +1101,11 @@ class Message(db.Model):  # type: ignore[name-defined]
                         "id": message_file.id,
                         "type": message_file.type,
                         "transfer_method": message_file.transfer_method,
-                        "upload_file_id": message_file.upload_file_id,
                         "url": message_file.url,
                     },
                     tenant_id=current_app.tenant_id,
                 )
-            elif message_file.transfer_method == FileTransferMethod.TOOL_FILE.value:
+            elif message_file.transfer_method == "tool_file":
                 if message_file.upload_file_id is None:
                     assert message_file.url is not None
                     message_file.upload_file_id = message_file.url.split("/")[-1].split(".")[0]

api/models/tools.py

@@ -64,7 +64,7 @@ class ApiToolProvider(Base):
 
     id = db.Column(StringUUID, server_default=db.text("uuid_generate_v4()"))
     # name of the api provider
-    name = db.Column(db.String(255), nullable=False)
+    name = db.Column(db.String(40), nullable=False)
     # icon
     icon = db.Column(db.String(255), nullable=False)
     # original schema
@@ -143,7 +143,7 @@ class WorkflowToolProvider(Base):
 
     id: Mapped[str] = mapped_column(StringUUID, server_default=db.text("uuid_generate_v4()"))
     # name of the workflow provider
-    name: Mapped[str] = mapped_column(db.String(255), nullable=False)
+    name: Mapped[str] = mapped_column(db.String(40), nullable=False)
     # label of the workflow provider
     label: Mapped[str] = mapped_column(db.String(255), nullable=False, server_default="")
     # icon
@@ -205,7 +205,7 @@ class ToolModelInvoke(Base):
     # tenant id
     tenant_id = db.Column(StringUUID, nullable=False)
     # provider
-    provider = db.Column(db.String(255), nullable=False)
+    provider = db.Column(db.String(40), nullable=False)
     # type
     tool_type = db.Column(db.String(40), nullable=False)
     # tool name

api/models/workflow.py

@@ -2,8 +2,7 @@ import json
 from collections.abc import Mapping, Sequence
 from datetime import UTC, datetime
 from enum import Enum
-from typing import TYPE_CHECKING, Any, Optional, Self, Union
-from uuid import uuid4
+from typing import TYPE_CHECKING, Any, Optional, Union
 
 if TYPE_CHECKING:
     from models.model import AppMode
@@ -109,9 +108,7 @@ class Workflow(Base):
     tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
     app_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
     type: Mapped[str] = mapped_column(db.String(255), nullable=False)
-    version: Mapped[str]
-    marked_name: Mapped[str] = mapped_column(default="", server_default="")
-    marked_comment: Mapped[str] = mapped_column(default="", server_default="")
+    version: Mapped[str] = mapped_column(db.String(255), nullable=False)
     graph: Mapped[str] = mapped_column(sa.Text)
     _features: Mapped[str] = mapped_column("features", sa.TEXT)
     created_by: Mapped[str] = mapped_column(StringUUID, nullable=False)
@@ -130,9 +127,8 @@ class Workflow(Base):
         "conversation_variables", db.Text, nullable=False, server_default="{}"
     )
 
-    @classmethod
-    def new(
-        cls,
+    def __init__(
+        self,
         *,
         tenant_id: str,
         app_id: str,
@@ -143,25 +139,16 @@ class Workflow(Base):
         created_by: str,
         environment_variables: Sequence[Variable],
         conversation_variables: Sequence[Variable],
-        marked_name: str = "",
-        marked_comment: str = "",
-    ) -> Self:
-        workflow = Workflow()
-        workflow.id = str(uuid4())
-        workflow.tenant_id = tenant_id
-        workflow.app_id = app_id
-        workflow.type = type
-        workflow.version = version
-        workflow.graph = graph
-        workflow.features = features
-        workflow.created_by = created_by
-        workflow.environment_variables = environment_variables or []
-        workflow.conversation_variables = conversation_variables or []
-        workflow.marked_name = marked_name
-        workflow.marked_comment = marked_comment
-        workflow.created_at = datetime.now(UTC).replace(tzinfo=None)
-        workflow.updated_at = workflow.created_at
-        return workflow
+    ):
+        self.tenant_id = tenant_id
+        self.app_id = app_id
+        self.type = type
+        self.version = version
+        self.graph = graph
+        self.features = features
+        self.created_by = created_by
+        self.environment_variables = environment_variables or []
+        self.conversation_variables = conversation_variables or []
 
     @property
     def created_by_account(self):
@@ -354,6 +341,19 @@ class WorkflowRunStatus(StrEnum):
     STOPPED = "stopped"
     PARTIAL_SUCCESSED = "partial-succeeded"
 
+    @classmethod
+    def value_of(cls, value: str) -> "WorkflowRunStatus":
+        """
+        Get value of given mode.
+
+        :param value: mode value
+        :return: mode
+        """
+        for mode in cls:
+            if mode.value == value:
+                return mode
+        raise ValueError(f"invalid workflow run status value {value}")
+
 
 class WorkflowRun(Base):
     """

api/pyproject.toml

@@ -18,7 +18,7 @@ package-mode = false
 authlib = "1.3.1"
 azure-identity = "1.16.1"
 beautifulsoup4 = "4.12.2"
-boto3 = "1.35.99"
+boto3 = "1.37.1"
 bs4 = "~0.0.1"
 cachetools = "~5.3.0"
 celery = "~5.4.0"
@@ -151,7 +151,6 @@ pytest-benchmark = "~4.0.0"
 pytest-env = "~1.1.3"
 pytest-mock = "~3.14.0"
 types-beautifulsoup4 = "~4.12.0.20241020"
-types-deprecated = "~1.2.15.20250304"
 types-flask-cors = "~5.0.0.20240902"
 types-flask-migrate = "~4.1.0.20250112"
 types-html5lib = "~1.1.11.20241018"

api/services/app_generate_service.py

@@ -137,25 +137,6 @@ class AppGenerateService:
         else:
             raise ValueError(f"Invalid app mode {app_model.mode}")
 
-    @classmethod
-    def generate_single_loop(cls, app_model: App, user: Account, node_id: str, args: Any, streaming: bool = True):
-        if app_model.mode == AppMode.ADVANCED_CHAT.value:
-            workflow = cls._get_workflow(app_model, InvokeFrom.DEBUGGER)
-            return AdvancedChatAppGenerator.convert_to_event_stream(
-                AdvancedChatAppGenerator().single_loop_generate(
-                    app_model=app_model, workflow=workflow, node_id=node_id, user=user, args=args, streaming=streaming
-                )
-            )
-        elif app_model.mode == AppMode.WORKFLOW.value:
-            workflow = cls._get_workflow(app_model, InvokeFrom.DEBUGGER)
-            return AdvancedChatAppGenerator.convert_to_event_stream(
-                WorkflowAppGenerator().single_loop_generate(
-                    app_model=app_model, workflow=workflow, node_id=node_id, user=user, args=args, streaming=streaming
-                )
-            )
-        else:
-            raise ValueError(f"Invalid app mode {app_model.mode}")
-
     @classmethod
     def generate_more_like_this(
         cls,

api/services/billing_service.py

@@ -5,7 +5,6 @@ import httpx
 from tenacity import retry, retry_if_exception_type, stop_before_delay, wait_fixed
 
 from extensions.ext_database import db
-from libs.helper import RateLimiter
 from models.account import TenantAccountJoin, TenantAccountRole
 
 
@@ -13,8 +12,6 @@ class BillingService:
     base_url = os.environ.get("BILLING_API_URL", "BILLING_API_URL")
     secret_key = os.environ.get("BILLING_API_SECRET_KEY", "BILLING_API_SECRET_KEY")
 
-    compliance_download_rate_limiter = RateLimiter("compliance_download_rate_limiter", 4, 60)
-
     @classmethod
     def get_info(cls, tenant_id: str):
         params = {"tenant_id": tenant_id}
@@ -22,17 +19,6 @@ class BillingService:
         billing_info = cls._send_request("GET", "/subscription/info", params=params)
         return billing_info
 
-    @classmethod
-    def get_knowledge_rate_limit(cls, tenant_id: str):
-        params = {"tenant_id": tenant_id}
-
-        knowledge_rate_limit = cls._send_request("GET", "/subscription/knowledge-rate-limit", params=params)
-
-        return {
-            "limit": knowledge_rate_limit.get("limit", 10),
-            "subscription_plan": knowledge_rate_limit.get("subscription_plan", "sandbox"),
-        }
-
     @classmethod
     def get_subscription(cls, plan: str, interval: str, prefilled_email: str = "", tenant_id: str = ""):
         params = {"plan": plan, "interval": interval, "prefilled_email": prefilled_email, "tenant_id": tenant_id}
@@ -105,29 +91,3 @@ class BillingService:
         """Update account deletion feedback."""
         json = {"email": email, "feedback": feedback}
         return cls._send_request("POST", "/account/delete-feedback", json=json)
-
-    @classmethod
-    def get_compliance_download_link(
-        cls,
-        doc_name: str,
-        account_id: str,
-        tenant_id: str,
-        ip: str,
-        device_info: str,
-    ):
-        limiter_key = f"{account_id}:{tenant_id}"
-        if cls.compliance_download_rate_limiter.is_rate_limited(limiter_key):
-            from controllers.console.error import CompilanceRateLimitError
-
-            raise CompilanceRateLimitError()
-
-        json = {
-            "doc_name": doc_name,
-            "account_id": account_id,
-            "tenant_id": tenant_id,
-            "ip_address": ip,
-            "device_info": device_info,
-        }
-        res = cls._send_request("POST", "/compliance/download", json=json)
-        cls.compliance_download_rate_limiter.increment_rate_limit(limiter_key)
-        return res

api/services/dataset_service.py

@@ -245,7 +245,7 @@ class DatasetService:
                 "No Embedding Model available. Please configure a valid provider in the Settings -> Model Provider."
             )
         except ProviderTokenNotInitError as ex:
-            raise ValueError(ex.description)
+            raise ValueError(f"The dataset in unavailable, due to: {ex.description}")
 
     @staticmethod
     def update_dataset(dataset_id, data, user):
@@ -327,75 +327,31 @@ class DatasetService:
                         raise ValueError(ex.description)
             else:
                 # add default plugin id to both setting sets, to make sure the plugin model provider is consistent
-                # Skip embedding model checks if not provided in the update request
+                plugin_model_provider = dataset.embedding_model_provider
+                plugin_model_provider = str(ModelProviderID(plugin_model_provider))
+
+                new_plugin_model_provider = data["embedding_model_provider"]
+                new_plugin_model_provider = str(ModelProviderID(new_plugin_model_provider))
+
                 if (
-                    "embedding_model_provider" not in data
-                    or "embedding_model" not in data
-                    or not data.get("embedding_model_provider")
-                    or not data.get("embedding_model")
+                    new_plugin_model_provider != plugin_model_provider
+                    or data["embedding_model"] != dataset.embedding_model
                 ):
-                    # If the dataset already has embedding model settings, use those
-                    if dataset.embedding_model_provider and dataset.embedding_model:
-                        # Keep existing values
-                        filtered_data["embedding_model_provider"] = dataset.embedding_model_provider
-                        filtered_data["embedding_model"] = dataset.embedding_model
-                        # If collection_binding_id exists, keep it too
-                        if dataset.collection_binding_id:
-                            filtered_data["collection_binding_id"] = dataset.collection_binding_id
-                    # Otherwise, don't try to update embedding model settings at all
-                    # Remove these fields from filtered_data if they exist but are None/empty
-                    if "embedding_model_provider" in filtered_data and not filtered_data["embedding_model_provider"]:
-                        del filtered_data["embedding_model_provider"]
-                    if "embedding_model" in filtered_data and not filtered_data["embedding_model"]:
-                        del filtered_data["embedding_model"]
-                else:
-                    skip_embedding_update = False
+                    action = "update"
                     try:
-                        # Handle existing model provider
-                        plugin_model_provider = dataset.embedding_model_provider
-                        plugin_model_provider_str = None
-                        if plugin_model_provider:
-                            plugin_model_provider_str = str(ModelProviderID(plugin_model_provider))
-
-                        # Handle new model provider from request
-                        new_plugin_model_provider = data["embedding_model_provider"]
-                        new_plugin_model_provider_str = None
-                        if new_plugin_model_provider:
-                            new_plugin_model_provider_str = str(ModelProviderID(new_plugin_model_provider))
-
-                        # Only update embedding model if both values are provided and different from current
-                        if (
-                            plugin_model_provider_str != new_plugin_model_provider_str
-                            or data["embedding_model"] != dataset.embedding_model
-                        ):
-                            action = "update"
-                            model_manager = ModelManager()
-                            try:
-                                embedding_model = model_manager.get_model_instance(
-                                    tenant_id=current_user.current_tenant_id,
-                                    provider=data["embedding_model_provider"],
-                                    model_type=ModelType.TEXT_EMBEDDING,
-                                    model=data["embedding_model"],
-                                )
-                            except ProviderTokenNotInitError:
-                                # If we can't get the embedding model, skip updating it
-                                # and keep the existing settings if available
-                                if dataset.embedding_model_provider and dataset.embedding_model:
-                                    filtered_data["embedding_model_provider"] = dataset.embedding_model_provider
-                                    filtered_data["embedding_model"] = dataset.embedding_model
-                                    if dataset.collection_binding_id:
-                                        filtered_data["collection_binding_id"] = dataset.collection_binding_id
-                                # Skip the rest of the embedding model update
-                                skip_embedding_update = True
-                            if not skip_embedding_update:
-                                filtered_data["embedding_model"] = embedding_model.model
-                                filtered_data["embedding_model_provider"] = embedding_model.provider
-                                dataset_collection_binding = (
-                                    DatasetCollectionBindingService.get_dataset_collection_binding(
-                                        embedding_model.provider, embedding_model.model
-                                    )
-                                )
-                                filtered_data["collection_binding_id"] = dataset_collection_binding.id
+                        model_manager = ModelManager()
+                        embedding_model = model_manager.get_model_instance(
+                            tenant_id=current_user.current_tenant_id,
+                            provider=data["embedding_model_provider"],
+                            model_type=ModelType.TEXT_EMBEDDING,
+                            model=data["embedding_model"],
+                        )
+                        filtered_data["embedding_model"] = embedding_model.model
+                        filtered_data["embedding_model_provider"] = embedding_model.provider
+                        dataset_collection_binding = DatasetCollectionBindingService.get_dataset_collection_binding(
+                            embedding_model.provider, embedding_model.model
+                        )
+                        filtered_data["collection_binding_id"] = dataset_collection_binding.id
                     except LLMBadRequestError:
                         raise ValueError(
                             "No Embedding Model available. Please configure a valid provider "

api/services/errors/workflow_service.py

@@ -1,10 +0,0 @@
-class WorkflowInUseError(ValueError):
-    """Raised when attempting to delete a workflow that's in use by an app"""
-
-    pass
-
-
-class DraftWorkflowDeletionError(ValueError):
-    """Raised when attempting to delete a draft workflow"""
-
-    pass

api/services/feature_service.py

@@ -41,7 +41,6 @@ class FeatureModel(BaseModel):
     members: LimitationModel = LimitationModel(size=0, limit=1)
     apps: LimitationModel = LimitationModel(size=0, limit=10)
     vector_space: LimitationModel = LimitationModel(size=0, limit=5)
-    knowledge_rate_limit: int = 10
     annotation_quota_limit: LimitationModel = LimitationModel(size=0, limit=10)
     documents_upload_quota: LimitationModel = LimitationModel(size=0, limit=50)
     docs_processing: str = "standard"
@@ -53,12 +52,6 @@ class FeatureModel(BaseModel):
     model_config = ConfigDict(protected_namespaces=())
 
 
-class KnowledgeRateLimitModel(BaseModel):
-    enabled: bool = False
-    limit: int = 10
-    subscription_plan: str = ""
-
-
 class SystemFeatureModel(BaseModel):
     sso_enforced_for_signin: bool = False
     sso_enforced_for_signin_protocol: str = ""
@@ -88,16 +81,6 @@ class FeatureService:
 
         return features
 
-    @classmethod
-    def get_knowledge_rate_limit(cls, tenant_id: str):
-        knowledge_rate_limit = KnowledgeRateLimitModel()
-        if dify_config.BILLING_ENABLED and tenant_id:
-            knowledge_rate_limit.enabled = True
-            limit_info = BillingService.get_knowledge_rate_limit(tenant_id)
-            knowledge_rate_limit.limit = limit_info.get("limit", 10)
-            knowledge_rate_limit.subscription_plan = limit_info.get("subscription_plan", "sandbox")
-        return knowledge_rate_limit
-
     @classmethod
     def get_system_features(cls) -> SystemFeatureModel:
         system_features = SystemFeatureModel()
@@ -166,9 +149,6 @@ class FeatureService:
         if "model_load_balancing_enabled" in billing_info:
             features.model_load_balancing_enabled = billing_info["model_load_balancing_enabled"]
 
-        if "knowledge_rate_limit" in billing_info:
-            features.knowledge_rate_limit = billing_info["knowledge_rate_limit"]["limit"]
-
     @classmethod
     def _fulfill_params_from_enterprise(cls, features):
         enterprise_info = EnterpriseService.get_info()

api/services/tools/tools_transform_service.py

@@ -29,9 +29,7 @@ logger = logging.getLogger(__name__)
 class ToolTransformService:
     @classmethod
     def get_plugin_icon_url(cls, tenant_id: str, filename: str) -> str:
-        url_prefix = (
-            URL(dify_config.CONSOLE_API_URL or "/") / "console" / "api" / "workspaces" / "current" / "plugin" / "icon"
-        )
+        url_prefix = URL(dify_config.CONSOLE_API_URL) / "console" / "api" / "workspaces" / "current" / "plugin" / "icon"
         return str(url_prefix % {"tenant_id": tenant_id, "filename": filename})
 
     @classmethod
@@ -39,9 +37,7 @@ class ToolTransformService:
         """
         get tool provider icon url
         """
-        url_prefix = (
-            URL(dify_config.CONSOLE_API_URL or "/") / "console" / "api" / "workspaces" / "current" / "tool-provider"
-        )
+        url_prefix = URL(dify_config.CONSOLE_API_URL) / "console" / "api" / "workspaces" / "current" / "tool-provider"
 
         if provider_type == ToolProviderType.BUILT_IN.value:
             return str(url_prefix / "builtin" / provider_name / "icon")

api/services/workflow_app_service.py

@@ -1,46 +1,30 @@
 import uuid
-from datetime import datetime
 
-from sqlalchemy import and_, func, or_, select
-from sqlalchemy.orm import Session
+from flask_sqlalchemy.pagination import Pagination
+from sqlalchemy import and_, or_
 
+from extensions.ext_database import db
 from models import App, EndUser, WorkflowAppLog, WorkflowRun
 from models.enums import CreatedByRole
 from models.workflow import WorkflowRunStatus
 
 
 class WorkflowAppService:
-    def get_paginate_workflow_app_logs(
-        self,
-        *,
-        session: Session,
-        app_model: App,
-        keyword: str | None = None,
-        status: WorkflowRunStatus | None = None,
-        created_at_before: datetime | None = None,
-        created_at_after: datetime | None = None,
-        page: int = 1,
-        limit: int = 20,
-    ) -> dict:
+    def get_paginate_workflow_app_logs(self, app_model: App, args: dict) -> Pagination:
         """
-        Get paginate workflow app logs using SQLAlchemy 2.0 style
-        :param session: SQLAlchemy session
-        :param app_model: app model
-        :param keyword: search keyword
-        :param status: filter by status
-        :param created_at_before: filter logs created before this timestamp
-        :param created_at_after: filter logs created after this timestamp
-        :param page: page number
-        :param limit: items per page
-        :return: Pagination object
+        Get paginate workflow app logs
+        :param app: app model
+        :param args: request args
+        :return:
         """
-        # Build base statement using SQLAlchemy 2.0 style
-        stmt = select(WorkflowAppLog).where(
+        query = db.select(WorkflowAppLog).where(
             WorkflowAppLog.tenant_id == app_model.tenant_id, WorkflowAppLog.app_id == app_model.id
         )
 
+        status = WorkflowRunStatus.value_of(args.get("status", "")) if args.get("status") else None
+        keyword = args["keyword"]
         if keyword or status:
-            stmt = stmt.join(WorkflowRun, WorkflowRun.id == WorkflowAppLog.workflow_run_id)
+            query = query.join(WorkflowRun, WorkflowRun.id == WorkflowAppLog.workflow_run_id)
 
         if keyword:
             keyword_like_val = f"%{keyword[:30].encode('unicode_escape').decode('utf-8')}%".replace(r"\u", r"\\u")
@@ -56,40 +40,20 @@ class WorkflowAppService:
             if keyword_uuid:
                 keyword_conditions.append(WorkflowRun.id == keyword_uuid)
 
-            stmt = stmt.outerjoin(
+            query = query.outerjoin(
                 EndUser,
                 and_(WorkflowRun.created_by == EndUser.id, WorkflowRun.created_by_role == CreatedByRole.END_USER),
-            ).where(or_(*keyword_conditions))
+            ).filter(or_(*keyword_conditions))
 
         if status:
-            stmt = stmt.where(WorkflowRun.status == status)
+            # join with workflow_run and filter by status
+            query = query.filter(WorkflowRun.status == status.value)
 
-        # Add time-based filtering
-        if created_at_before:
-            stmt = stmt.where(WorkflowAppLog.created_at <= created_at_before)
+        query = query.order_by(WorkflowAppLog.created_at.desc())
 
-        if created_at_after:
-            stmt = stmt.where(WorkflowAppLog.created_at >= created_at_after)
+        pagination = db.paginate(query, page=args["page"], per_page=args["limit"], error_out=False)
 
-        stmt = stmt.order_by(WorkflowAppLog.created_at.desc())
-
-        # Get total count using the same filters
-        count_stmt = select(func.count()).select_from(stmt.subquery())
-        total = session.scalar(count_stmt) or 0
-
-        # Apply pagination limits
-        offset_stmt = stmt.offset((page - 1) * limit).limit(limit)
-
-        # Execute query and get items
-        items = list(session.scalars(offset_stmt).all())
-
-        return {
-            "page": page,
-            "limit": limit,
-            "total": total,
-            "has_more": total > page * limit,
-            "data": items,
-        }
+        return pagination
 
     @staticmethod
     def _safe_parse_uuid(value: str):

api/services/workflow_service.py

@@ -5,8 +5,7 @@ from datetime import UTC, datetime
 from typing import Any, Optional
 from uuid import uuid4
 
-from sqlalchemy import select
-from sqlalchemy.orm import Session
+from sqlalchemy import desc
 
 from core.app.apps.advanced_chat.app_config_manager import AdvancedChatAppConfigManager
 from core.app.apps.workflow.app_config_manager import WorkflowAppConfigManager
@@ -37,8 +36,6 @@ from models.workflow import (
 from services.errors.app import WorkflowHashNotEqualError
 from services.workflow.workflow_converter import WorkflowConverter
 
-from .errors.workflow_service import DraftWorkflowDeletionError, WorkflowInUseError
-
 
 class WorkflowService:
     """
@@ -82,38 +79,22 @@ class WorkflowService:
 
         return workflow
 
-    def get_all_published_workflow(
-        self,
-        *,
-        session: Session,
-        app_model: App,
-        page: int,
-        limit: int,
-        user_id: str | None,
-        named_only: bool = False,
-    ) -> tuple[Sequence[Workflow], bool]:
+    def get_all_published_workflow(self, app_model: App, page: int, limit: int) -> tuple[list[Workflow], bool]:
         """
         Get published workflow with pagination
         """
         if not app_model.workflow_id:
             return [], False
 
-        stmt = (
-            select(Workflow)
-            .where(Workflow.app_id == app_model.id)
-            .order_by(Workflow.version.desc())
-            .limit(limit + 1)
+        workflows = (
+            db.session.query(Workflow)
+            .filter(Workflow.app_id == app_model.id)
+            .order_by(desc(Workflow.version))
             .offset((page - 1) * limit)
+            .limit(limit + 1)
+            .all()
         )
 
-        if user_id:
-            stmt = stmt.where(Workflow.created_by == user_id)
-
-        if named_only:
-            stmt = stmt.where(Workflow.marked_name != "")
-
-        workflows = session.scalars(stmt).all()
-
         has_more = len(workflows) > limit
         if has_more:
             workflows = workflows[:-1]
@@ -176,26 +157,23 @@ class WorkflowService:
         # return draft workflow
         return workflow
 
-    def publish_workflow(
-        self,
-        *,
-        session: Session,
-        app_model: App,
-        account: Account,
-        marked_name: str = "",
-        marked_comment: str = "",
-    ) -> Workflow:
-        draft_workflow_stmt = select(Workflow).where(
-            Workflow.tenant_id == app_model.tenant_id,
-            Workflow.app_id == app_model.id,
-            Workflow.version == "draft",
-        )
-        draft_workflow = session.scalar(draft_workflow_stmt)
+    def publish_workflow(self, app_model: App, account: Account, draft_workflow: Optional[Workflow] = None) -> Workflow:
+        """
+        Publish workflow from draft
+
+        :param app_model: App instance
+        :param account: Account instance
+        :param draft_workflow: Workflow instance
+        """
+        if not draft_workflow:
+            # fetch draft workflow by app_model
+            draft_workflow = self.get_draft_workflow(app_model=app_model)
+
         if not draft_workflow:
             raise ValueError("No valid workflow found.")
 
         # create new workflow
-        workflow = Workflow.new(
+        workflow = Workflow(
             tenant_id=app_model.tenant_id,
             app_id=app_model.id,
             type=draft_workflow.type,
@@ -205,12 +183,15 @@ class WorkflowService:
             created_by=account.id,
             environment_variables=draft_workflow.environment_variables,
             conversation_variables=draft_workflow.conversation_variables,
-            marked_name=marked_name,
-            marked_comment=marked_comment,
         )
 
         # commit db session changes
-        session.add(workflow)
+        db.session.add(workflow)
+        db.session.flush()
+        db.session.commit()
+
+        app_model.workflow_id = workflow.id
+        db.session.commit()
 
         # trigger app workflow events
         app_published_workflow_was_updated.send(app_model, published_workflow=workflow)
@@ -455,65 +436,3 @@ class WorkflowService:
             )
         else:
             raise ValueError(f"Invalid app mode: {app_model.mode}")
-
-    def update_workflow(
-        self, *, session: Session, workflow_id: str, tenant_id: str, account_id: str, data: dict
-    ) -> Optional[Workflow]:
-        """
-        Update workflow attributes
-
-        :param session: SQLAlchemy database session
-        :param workflow_id: Workflow ID
-        :param tenant_id: Tenant ID
-        :param account_id: Account ID (for permission check)
-        :param data: Dictionary containing fields to update
-        :return: Updated workflow or None if not found
-        """
-        stmt = select(Workflow).where(Workflow.id == workflow_id, Workflow.tenant_id == tenant_id)
-        workflow = session.scalar(stmt)
-
-        if not workflow:
-            return None
-
-        allowed_fields = ["marked_name", "marked_comment"]
-
-        for field, value in data.items():
-            if field in allowed_fields:
-                setattr(workflow, field, value)
-
-        workflow.updated_by = account_id
-        workflow.updated_at = datetime.now(UTC).replace(tzinfo=None)
-
-        return workflow
-
-    def delete_workflow(self, *, session: Session, workflow_id: str, tenant_id: str) -> bool:
-        """
-        Delete a workflow
-
-        :param session: SQLAlchemy database session
-        :param workflow_id: Workflow ID
-        :param tenant_id: Tenant ID
-        :return: True if successful
-        :raises: ValueError if workflow not found
-        :raises: WorkflowInUseError if workflow is in use
-        :raises: DraftWorkflowDeletionError if workflow is a draft version
-        """
-        stmt = select(Workflow).where(Workflow.id == workflow_id, Workflow.tenant_id == tenant_id)
-        workflow = session.scalar(stmt)
-
-        if not workflow:
-            raise ValueError(f"Workflow with ID {workflow_id} not found")
-
-        # Check if workflow is a draft version
-        if workflow.version == "draft":
-            raise DraftWorkflowDeletionError("Cannot delete draft workflow versions")
-
-        # Check if this workflow is currently referenced by an app
-        stmt = select(App).where(App.workflow_id == workflow_id)
-        app = session.scalar(stmt)
-        if app:
-            # Cannot delete a workflow that's currently in use by an app
-            raise WorkflowInUseError(f"Cannot delete workflow that is currently in use by app '{app.name}'")
-
-        session.delete(workflow)
-        return True

api/tests/unit_tests/libs/test_yarl.py

@@ -18,12 +18,6 @@ def test_yarl_urls():
     assert str(URL("https://dify.ai/api") / "v1") == expected_3
     assert str(URL("https://dify.ai/api/") / "v1") == expected_3
 
-    expected_4 = "api"
-    assert str(URL("") / "api") == expected_4
-
-    expected_5 = "/api"
-    assert str(URL("/") / "api") == expected_5
-
     with pytest.raises(ValueError) as e1:
         str(URL("https://dify.ai") / "/api")
     assert str(e1.value) == "Appending path '/api' starting from slash is forbidden"

api/tests/unit_tests/services/workflow/test_workflow_service.py

@@ -1,162 +0,0 @@
-from unittest.mock import MagicMock
-
-import pytest
-
-from models.model import App
-from models.workflow import Workflow
-from services.workflow_service import WorkflowService
-
-
-class TestWorkflowService:
-    @pytest.fixture
-    def workflow_service(self):
-        return WorkflowService()
-
-    @pytest.fixture
-    def mock_app(self):
-        app = MagicMock(spec=App)
-        app.id = "app-id-1"
-        app.workflow_id = "workflow-id-1"
-        app.tenant_id = "tenant-id-1"
-        return app
-
-    @pytest.fixture
-    def mock_workflows(self):
-        workflows = []
-        for i in range(5):
-            workflow = MagicMock(spec=Workflow)
-            workflow.id = f"workflow-id-{i}"
-            workflow.app_id = "app-id-1"
-            workflow.created_at = f"2023-01-0{5 - i}"  # Descending date order
-            workflow.created_by = "user-id-1" if i % 2 == 0 else "user-id-2"
-            workflow.marked_name = f"Workflow {i}" if i % 2 == 0 else ""
-            workflows.append(workflow)
-        return workflows
-
-    def test_get_all_published_workflow_no_workflow_id(self, workflow_service, mock_app):
-        mock_app.workflow_id = None
-        mock_session = MagicMock()
-
-        workflows, has_more = workflow_service.get_all_published_workflow(
-            session=mock_session, app_model=mock_app, page=1, limit=10, user_id=None
-        )
-
-        assert workflows == []
-        assert has_more is False
-        mock_session.scalars.assert_not_called()
-
-    def test_get_all_published_workflow_basic(self, workflow_service, mock_app, mock_workflows):
-        mock_session = MagicMock()
-        mock_scalar_result = MagicMock()
-        mock_scalar_result.all.return_value = mock_workflows[:3]
-        mock_session.scalars.return_value = mock_scalar_result
-
-        workflows, has_more = workflow_service.get_all_published_workflow(
-            session=mock_session, app_model=mock_app, page=1, limit=3, user_id=None
-        )
-
-        assert workflows == mock_workflows[:3]
-        assert has_more is False
-        mock_session.scalars.assert_called_once()
-
-    def test_get_all_published_workflow_pagination(self, workflow_service, mock_app, mock_workflows):
-        mock_session = MagicMock()
-        mock_scalar_result = MagicMock()
-        # Return 4 items when limit is 3, which should indicate has_more=True
-        mock_scalar_result.all.return_value = mock_workflows[:4]
-        mock_session.scalars.return_value = mock_scalar_result
-
-        workflows, has_more = workflow_service.get_all_published_workflow(
-            session=mock_session, app_model=mock_app, page=1, limit=3, user_id=None
-        )
-
-        # Should return only the first 3 items
-        assert len(workflows) == 3
-        assert workflows == mock_workflows[:3]
-        assert has_more is True
-
-        # Test page 2
-        mock_scalar_result.all.return_value = mock_workflows[3:]
-        mock_session.scalars.return_value = mock_scalar_result
-
-        workflows, has_more = workflow_service.get_all_published_workflow(
-            session=mock_session, app_model=mock_app, page=2, limit=3, user_id=None
-        )
-
-        assert len(workflows) == 2
-        assert has_more is False
-
-    def test_get_all_published_workflow_user_filter(self, workflow_service, mock_app, mock_workflows):
-        mock_session = MagicMock()
-        mock_scalar_result = MagicMock()
-        # Filter workflows for user-id-1
-        filtered_workflows = [w for w in mock_workflows if w.created_by == "user-id-1"]
-        mock_scalar_result.all.return_value = filtered_workflows
-        mock_session.scalars.return_value = mock_scalar_result
-
-        workflows, has_more = workflow_service.get_all_published_workflow(
-            session=mock_session, app_model=mock_app, page=1, limit=10, user_id="user-id-1"
-        )
-
-        assert workflows == filtered_workflows
-        assert has_more is False
-        mock_session.scalars.assert_called_once()
-
-        # Verify that the select contains a user filter clause
-        args = mock_session.scalars.call_args[0][0]
-        assert "created_by" in str(args)
-
-    def test_get_all_published_workflow_named_only(self, workflow_service, mock_app, mock_workflows):
-        mock_session = MagicMock()
-        mock_scalar_result = MagicMock()
-        # Filter workflows that have a marked_name
-        named_workflows = [w for w in mock_workflows if w.marked_name]
-        mock_scalar_result.all.return_value = named_workflows
-        mock_session.scalars.return_value = mock_scalar_result
-
-        workflows, has_more = workflow_service.get_all_published_workflow(
-            session=mock_session, app_model=mock_app, page=1, limit=10, user_id=None, named_only=True
-        )
-
-        assert workflows == named_workflows
-        assert has_more is False
-        mock_session.scalars.assert_called_once()
-
-        # Verify that the select contains a named_only filter clause
-        args = mock_session.scalars.call_args[0][0]
-        assert "marked_name !=" in str(args)
-
-    def test_get_all_published_workflow_combined_filters(self, workflow_service, mock_app, mock_workflows):
-        mock_session = MagicMock()
-        mock_scalar_result = MagicMock()
-        # Combined filter: user-id-1 and has marked_name
-        filtered_workflows = [w for w in mock_workflows if w.created_by == "user-id-1" and w.marked_name]
-        mock_scalar_result.all.return_value = filtered_workflows
-        mock_session.scalars.return_value = mock_scalar_result
-
-        workflows, has_more = workflow_service.get_all_published_workflow(
-            session=mock_session, app_model=mock_app, page=1, limit=10, user_id="user-id-1", named_only=True
-        )
-
-        assert workflows == filtered_workflows
-        assert has_more is False
-        mock_session.scalars.assert_called_once()
-
-        # Verify that both filters are applied
-        args = mock_session.scalars.call_args[0][0]
-        assert "created_by" in str(args)
-        assert "marked_name !=" in str(args)
-
-    def test_get_all_published_workflow_empty_result(self, workflow_service, mock_app):
-        mock_session = MagicMock()
-        mock_scalar_result = MagicMock()
-        mock_scalar_result.all.return_value = []
-        mock_session.scalars.return_value = mock_scalar_result
-
-        workflows, has_more = workflow_service.get_all_published_workflow(
-            session=mock_session, app_model=mock_app, page=1, limit=10, user_id=None
-        )
-
-        assert workflows == []
-        assert has_more is False
-        mock_session.scalars.assert_called_once()

docker/.env.example

@@ -344,7 +344,7 @@ TENCENT_COS_SCHEME=your-scheme
 
 # Oracle Storage Configuration
 #
-OCI_ENDPOINT=https://your-object-storage-namespace.compat.objectstorage.us-ashburn-1.oraclecloud.com
+OCI_ENDPOINT=https://objectstorage.us-ashburn-1.oraclecloud.com
 OCI_BUCKET_NAME=your-bucket-name
 OCI_ACCESS_KEY=your-access-key
 OCI_SECRET_KEY=your-secret-key
@@ -720,9 +720,6 @@ SSRF_PROXY_HTTP_URL=http://ssrf_proxy:3128
 # SSRF Proxy server HTTPS URL
 SSRF_PROXY_HTTPS_URL=http://ssrf_proxy:3128
 
-# Maximum loop count in the workflow
-LOOP_NODE_MAX_COUNT=100
-
 # ------------------------------
 # Environment Variables for web Service
 # ------------------------------
@@ -959,7 +956,6 @@ PLUGIN_DEBUGGING_PORT=5003
 EXPOSE_PLUGIN_DEBUGGING_HOST=localhost
 EXPOSE_PLUGIN_DEBUGGING_PORT=5003
 
-# If this key is changed, DIFY_INNER_API_KEY in plugin_daemon service must also be updated or agent node will fail.
 PLUGIN_DIFY_INNER_API_KEY=QaHbTe77CtuXmsfyhR7+vRjI/+XbV1AaFy691iy+kGDv2Jvy0/eAh8Y1
 PLUGIN_DIFY_INNER_API_URL=http://api:5001
 
@@ -969,8 +965,3 @@ MARKETPLACE_ENABLED=true
 MARKETPLACE_API_URL=https://marketplace.dify.ai
 
 FORCE_VERIFYING_SIGNATURE=true
-
-PLUGIN_PYTHON_ENV_INIT_TIMEOUT=120
-PLUGIN_MAX_EXECUTION_TIMEOUT=600
-# PIP_MIRROR_URL=https://pypi.tuna.tsinghua.edu.cn/simple
-PIP_MIRROR_URL=

docker/docker-compose-template.yaml

@@ -2,7 +2,7 @@ x-shared-env: &shared-api-worker-env
 services:
   # API service
   api:
-    image: langgenius/dify-api:1.0.1
+    image: langgenius/dify-api:1.0.0
     restart: always
     environment:
       # Use the shared environment variables.
@@ -29,7 +29,7 @@ services:
   # worker service
   # The Celery worker for processing the queue.
   worker:
-    image: langgenius/dify-api:1.0.1
+    image: langgenius/dify-api:1.0.0
     restart: always
     environment:
       # Use the shared environment variables.
@@ -53,7 +53,7 @@ services:
 
   # Frontend web application.
   web:
-    image: langgenius/dify-web:1.0.1
+    image: langgenius/dify-web:1.0.0
     restart: always
     environment:
       CONSOLE_API_URL: ${CONSOLE_API_URL:-}
@@ -67,7 +67,6 @@ services:
       TOP_K_MAX_VALUE: ${TOP_K_MAX_VALUE:-}
       INDEXING_MAX_SEGMENTATION_TOKENS_LENGTH: ${INDEXING_MAX_SEGMENTATION_TOKENS_LENGTH:-}
       PM2_INSTANCES: ${PM2_INSTANCES:-2}
-      LOOP_NODE_MAX_COUNT: ${LOOP_NODE_MAX_COUNT:-100}
 
   # The postgres database.
   db:
@@ -91,6 +90,8 @@ services:
       interval: 1s
       timeout: 3s
       retries: 30
+    ports:
+      - '${EXPOSE_DB_PORT:-5432}:5432'
 
   # The redis cache.
   redis:
@@ -131,7 +132,7 @@ services:
 
   # plugin daemon
   plugin_daemon:
-    image: langgenius/dify-plugin-daemon:0.0.4-local
+    image: langgenius/dify-plugin-daemon:0.0.3-local
     restart: always
     environment:
       # Use the shared environment variables.
@@ -142,20 +143,16 @@ services:
       MAX_PLUGIN_PACKAGE_SIZE: ${PLUGIN_MAX_PACKAGE_SIZE:-52428800}
       PPROF_ENABLED: ${PLUGIN_PPROF_ENABLED:-false}
       DIFY_INNER_API_URL: ${PLUGIN_DIFY_INNER_API_URL:-http://api:5001}
-      DIFY_INNER_API_KEY: ${PLUGIN_DIFY_INNER_API_KEY:-QaHbTe77CtuXmsfyhR7+vRjI/+XbV1AaFy691iy+kGDv2Jvy0/eAh8Y1}
+      DIFY_INNER_API_KEY: ${INNER_API_KEY_FOR_PLUGIN:-QaHbTe77CtuXmsfyhR7+vRjI/+XbV1AaFy691iy+kGDv2Jvy0/eAh8Y1}
       PLUGIN_REMOTE_INSTALLING_HOST: ${PLUGIN_DEBUGGING_HOST:-0.0.0.0}
       PLUGIN_REMOTE_INSTALLING_PORT: ${PLUGIN_DEBUGGING_PORT:-5003}
       PLUGIN_WORKING_PATH: ${PLUGIN_WORKING_PATH:-/app/storage/cwd}
       FORCE_VERIFYING_SIGNATURE: ${FORCE_VERIFYING_SIGNATURE:-true}
-      PYTHON_ENV_INIT_TIMEOUT: ${PLUGIN_PYTHON_ENV_INIT_TIMEOUT:-120}
-      PLUGIN_MAX_EXECUTION_TIMEOUT: ${PLUGIN_MAX_EXECUTION_TIMEOUT:-600}
-      PIP_MIRROR_URL: ${PIP_MIRROR_URL:-}
     ports:
       - "${EXPOSE_PLUGIN_DEBUGGING_PORT:-5003}:${PLUGIN_DEBUGGING_PORT:-5003}"
     volumes:
       - ./volumes/plugin_daemon:/app/storage
-    depends_on:
-      - db
+
 
   # ssrf_proxy server
   # for more information, please refer to

docker/docker-compose.middleware.yaml

@@ -66,7 +66,7 @@ services:
 
   # plugin daemon
   plugin_daemon:
-    image: langgenius/dify-plugin-daemon:0.0.4-local
+    image: langgenius/dify-plugin-daemon:0.0.3-local
     restart: always
     environment:
       # Use the shared environment variables.
@@ -88,9 +88,6 @@ services:
       PLUGIN_REMOTE_INSTALLING_PORT: ${PLUGIN_DEBUGGING_PORT:-5003}
       PLUGIN_WORKING_PATH: ${PLUGIN_WORKING_PATH:-/app/storage/cwd}
       FORCE_VERIFYING_SIGNATURE: ${FORCE_VERIFYING_SIGNATURE:-true}
-      PYTHON_ENV_INIT_TIMEOUT: ${PLUGIN_PYTHON_ENV_INIT_TIMEOUT:-120}
-      PLUGIN_MAX_EXECUTION_TIMEOUT: ${PLUGIN_MAX_EXECUTION_TIMEOUT:-600}
-      PIP_MIRROR_URL: ${PIP_MIRROR_URL:-}
     ports:
       - "${EXPOSE_PLUGIN_DAEMON_PORT:-5002}:${PLUGIN_DAEMON_PORT:-5002}"
       - "${EXPOSE_PLUGIN_DEBUGGING_PORT:-5003}:${PLUGIN_DEBUGGING_PORT:-5003}"

docker/docker-compose.yaml

@@ -105,7 +105,7 @@ x-shared-env: &shared-api-worker-env
   TENCENT_COS_SECRET_ID: ${TENCENT_COS_SECRET_ID:-your-secret-id}
   TENCENT_COS_REGION: ${TENCENT_COS_REGION:-your-region}
   TENCENT_COS_SCHEME: ${TENCENT_COS_SCHEME:-your-scheme}
-  OCI_ENDPOINT: ${OCI_ENDPOINT:-https://your-object-storage-namespace.compat.objectstorage.us-ashburn-1.oraclecloud.com}
+  OCI_ENDPOINT: ${OCI_ENDPOINT:-https://objectstorage.us-ashburn-1.oraclecloud.com}
   OCI_BUCKET_NAME: ${OCI_BUCKET_NAME:-your-bucket-name}
   OCI_ACCESS_KEY: ${OCI_ACCESS_KEY:-your-access-key}
   OCI_SECRET_KEY: ${OCI_SECRET_KEY:-your-secret-key}
@@ -310,7 +310,6 @@ x-shared-env: &shared-api-worker-env
   HTTP_REQUEST_NODE_MAX_TEXT_SIZE: ${HTTP_REQUEST_NODE_MAX_TEXT_SIZE:-1048576}
   SSRF_PROXY_HTTP_URL: ${SSRF_PROXY_HTTP_URL:-http://ssrf_proxy:3128}
   SSRF_PROXY_HTTPS_URL: ${SSRF_PROXY_HTTPS_URL:-http://ssrf_proxy:3128}
-  LOOP_NODE_MAX_COUNT: ${LOOP_NODE_MAX_COUNT:-100}
   TEXT_GENERATION_TIMEOUT_MS: ${TEXT_GENERATION_TIMEOUT_MS:-60000}
   PGUSER: ${PGUSER:-${DB_USERNAME}}
   POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-${DB_PASSWORD}}
@@ -413,14 +412,11 @@ x-shared-env: &shared-api-worker-env
   MARKETPLACE_ENABLED: ${MARKETPLACE_ENABLED:-true}
   MARKETPLACE_API_URL: ${MARKETPLACE_API_URL:-https://marketplace.dify.ai}
   FORCE_VERIFYING_SIGNATURE: ${FORCE_VERIFYING_SIGNATURE:-true}
-  PLUGIN_PYTHON_ENV_INIT_TIMEOUT: ${PLUGIN_PYTHON_ENV_INIT_TIMEOUT:-120}
-  PLUGIN_MAX_EXECUTION_TIMEOUT: ${PLUGIN_MAX_EXECUTION_TIMEOUT:-600}
-  PIP_MIRROR_URL: ${PIP_MIRROR_URL:-}
 
 services:
   # API service
   api:
-    image: langgenius/dify-api:1.0.1
+    image: langgenius/dify-api:1.0.0
     restart: always
     environment:
       # Use the shared environment variables.
@@ -447,7 +443,7 @@ services:
   # worker service
   # The Celery worker for processing the queue.
   worker:
-    image: langgenius/dify-api:1.0.1
+    image: langgenius/dify-api:1.0.0
     restart: always
     environment:
       # Use the shared environment variables.
@@ -471,7 +467,7 @@ services:
 
   # Frontend web application.
   web:
-    image: langgenius/dify-web:1.0.1
+    image: langgenius/dify-web:1.0.0
     restart: always
     environment:
       CONSOLE_API_URL: ${CONSOLE_API_URL:-}
@@ -485,7 +481,6 @@ services:
       TOP_K_MAX_VALUE: ${TOP_K_MAX_VALUE:-}
       INDEXING_MAX_SEGMENTATION_TOKENS_LENGTH: ${INDEXING_MAX_SEGMENTATION_TOKENS_LENGTH:-}
       PM2_INSTANCES: ${PM2_INSTANCES:-2}
-      LOOP_NODE_MAX_COUNT: ${LOOP_NODE_MAX_COUNT:-100}
 
   # The postgres database.
   db:
@@ -509,6 +504,8 @@ services:
       interval: 1s
       timeout: 3s
       retries: 30
+    ports:
+      - '${EXPOSE_DB_PORT:-5432}:5432'
 
   # The redis cache.
   redis:
@@ -549,7 +546,7 @@ services:
 
   # plugin daemon
   plugin_daemon:
-    image: langgenius/dify-plugin-daemon:0.0.4-local
+    image: langgenius/dify-plugin-daemon:0.0.3-local
     restart: always
     environment:
       # Use the shared environment variables.
@@ -560,20 +557,16 @@ services:
       MAX_PLUGIN_PACKAGE_SIZE: ${PLUGIN_MAX_PACKAGE_SIZE:-52428800}
       PPROF_ENABLED: ${PLUGIN_PPROF_ENABLED:-false}
       DIFY_INNER_API_URL: ${PLUGIN_DIFY_INNER_API_URL:-http://api:5001}
-      DIFY_INNER_API_KEY: ${PLUGIN_DIFY_INNER_API_KEY:-QaHbTe77CtuXmsfyhR7+vRjI/+XbV1AaFy691iy+kGDv2Jvy0/eAh8Y1}
+      DIFY_INNER_API_KEY: ${INNER_API_KEY_FOR_PLUGIN:-QaHbTe77CtuXmsfyhR7+vRjI/+XbV1AaFy691iy+kGDv2Jvy0/eAh8Y1}
       PLUGIN_REMOTE_INSTALLING_HOST: ${PLUGIN_DEBUGGING_HOST:-0.0.0.0}
       PLUGIN_REMOTE_INSTALLING_PORT: ${PLUGIN_DEBUGGING_PORT:-5003}
       PLUGIN_WORKING_PATH: ${PLUGIN_WORKING_PATH:-/app/storage/cwd}
       FORCE_VERIFYING_SIGNATURE: ${FORCE_VERIFYING_SIGNATURE:-true}
-      PYTHON_ENV_INIT_TIMEOUT: ${PLUGIN_PYTHON_ENV_INIT_TIMEOUT:-120}
-      PLUGIN_MAX_EXECUTION_TIMEOUT: ${PLUGIN_MAX_EXECUTION_TIMEOUT:-600}
-      PIP_MIRROR_URL: ${PIP_MIRROR_URL:-}
     ports:
       - "${EXPOSE_PLUGIN_DEBUGGING_PORT:-5003}:${PLUGIN_DEBUGGING_PORT:-5003}"
     volumes:
       - ./volumes/plugin_daemon:/app/storage
-    depends_on:
-      - db
+
 
   # ssrf_proxy server
   # for more information, please refer to

docker/middleware.env.example

@@ -114,9 +114,4 @@ PLUGIN_DIFY_INNER_API_URL=http://api:5001
 MARKETPLACE_ENABLED=true
 MARKETPLACE_API_URL=https://marketplace.dify.ai
 
-FORCE_VERIFYING_SIGNATURE=true
-
-PLUGIN_PYTHON_ENV_INIT_TIMEOUT=120
-PLUGIN_MAX_EXECUTION_TIMEOUT=600
-# PIP_MIRROR_URL=https://pypi.tuna.tsinghua.edu.cn/simple
-PIP_MIRROR_URL=
+FORCE_VERIFYING_SIGNATURE=true

docker/ssrf_proxy/squid.conf.template

@@ -19,8 +19,6 @@ acl Safe_ports port 488		# gss-http
 acl Safe_ports port 591		# filemaker
 acl Safe_ports port 777		# multiling http
 acl CONNECT method CONNECT
-acl allowed_domains dstdomain .marketplace.dify.ai
-http_access allow allowed_domains
 http_access deny !Safe_ports
 http_access deny CONNECT !SSL_ports
 http_access allow localhost manager

docker/startupscripts/init_user.script

@@ -5,6 +5,6 @@ create user dify identified by dify DEFAULT TABLESPACE users quota unlimited on
 grant DB_DEVELOPER_ROLE to dify;
 
 BEGIN
-CTX_DDL.CREATE_PREFERENCE('dify.world_lexer','WORLD_LEXER');
+CTX_DDL.CREATE_PREFERENCE('dify.multilingual_lexer','CHINESE_VGRAM_LEXER');
 END;
 /