perf: 优化SQL工作台大结果渲染

- 提供一百到一万行返回档位

- 使用虚拟表格降低大结果集页面开销

easyflow-api/easyflow-api-admin/pom.xml

@@ -40,6 +40,10 @@
             <groupId>tech.easyflow</groupId>
             <artifactId>easyflow-module-job</artifactId>
         </dependency>
+        <dependency>
+            <groupId>tech.easyflow</groupId>
+            <artifactId>easyflow-module-dataspace</artifactId>
+        </dependency>
         <dependency>
             <groupId>tech.easyflow</groupId>
             <artifactId>easyflow-common-captcha</artifactId>

easyflow-api/easyflow-api-admin/src/main/java/tech/easyflow/admin/controller/ai/DocumentChunkController.java

@@ -1,18 +1,23 @@
 package tech.easyflow.admin.controller.ai;
 
 import cn.dev33.satoken.annotation.SaCheckPermission;
+import com.easyagents.core.model.embedding.EmbeddingModel;
 import com.mybatisflex.core.paginate.Page;
-import com.mybatisflex.core.query.QueryWrapper;
-import tech.easyflow.ai.dto.DocumentChunkContentUpdateRequest;
-import tech.easyflow.ai.dto.DocumentChunkSyncRetryRequest;
-import tech.easyflow.ai.dto.DocumentChunkSyncStatus;
-import tech.easyflow.ai.dto.DocumentChunkSyncStatusRequest;
 import tech.easyflow.ai.entity.DocumentChunk;
+import tech.easyflow.ai.entity.DocumentCollection;
+import tech.easyflow.ai.entity.Model;
 import tech.easyflow.ai.service.DocumentChunkService;
+import tech.easyflow.ai.service.DocumentCollectionService;
+import tech.easyflow.ai.service.ModelService;
+import tech.easyflow.ai.support.DocumentStoreLifecycleSupport;
 import tech.easyflow.common.annotation.UsePermission;
 import tech.easyflow.common.domain.Result;
-import tech.easyflow.common.web.controller.BaseController;
+import tech.easyflow.common.web.controller.BaseCurdController;
 import tech.easyflow.common.web.jsonbody.JsonBody;
+import com.easyagents.core.document.Document;
+import com.easyagents.core.store.DocumentStore;
+import com.easyagents.core.store.StoreOptions;
+import com.easyagents.core.store.StoreResult;
 import jakarta.servlet.http.HttpServletRequest;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.GetMapping;
@@ -23,8 +28,12 @@ import tech.easyflow.system.enums.ResourceAction;
 import tech.easyflow.system.enums.ResourceLookup;
 import tech.easyflow.system.permission.resource.RequireResourceAccess;
 
+import javax.annotation.Resource;
 import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 /**
  *  控制层。
@@ -35,12 +44,19 @@ import java.util.List;
 @RestController
 @RequestMapping("/api/v1/documentChunk")
 @UsePermission(moduleName = "/api/v1/documentCollection")
-public class DocumentChunkController extends BaseController {
+public class DocumentChunkController extends BaseCurdController<DocumentChunkService, DocumentChunk> {
 
-    private final DocumentChunkService documentChunkService;
+    @Resource
+    DocumentCollectionService documentCollectionService;
+
+    @Resource
+    ModelService modelService;
+
+    @Resource
+    DocumentChunkService documentChunkService;
 
     public DocumentChunkController(DocumentChunkService service) {
-        this.documentChunkService = service;
+        super(service);
     }
 
     @GetMapping("page")
@@ -52,30 +68,9 @@ public class DocumentChunkController extends BaseController {
             idExpr = "#request.getParameter('documentId')",
             denyMessage = "无权限访问知识库"
     )
-    public Result<Page<DocumentChunk>> page(
+    @Override
-        HttpServletRequest request,
+    public Result<Page<DocumentChunk>> page(HttpServletRequest request, String sortKey, String sortType, Long pageNumber, Long pageSize) {
-        Long pageNumber,
+        return super.page(request, sortKey, sortType, pageNumber, pageSize);
-        Long pageSize
-    ) {
-        String documentIdValue = request.getParameter("documentId");
-        if (documentIdValue == null || documentIdValue.isBlank()) {
-            return Result.<Page<DocumentChunk>>fail("documentId不能为空", null);
-        }
-        BigInteger documentId;
-        try {
-            documentId = new BigInteger(documentIdValue);
-        } catch (NumberFormatException e) {
-            return Result.<Page<DocumentChunk>>fail("documentId格式不正确", null);
-        }
-        long normalizedPageNumber = pageNumber == null || pageNumber < 1 ? 1 : pageNumber;
-        long normalizedPageSize = pageSize == null || pageSize < 1 ? 10 : pageSize;
-        QueryWrapper query = QueryWrapper.create()
-            .eq(DocumentChunk::getDocumentId, documentId)
-            .orderBy("sorting asc");
-        return Result.ok(documentChunkService.page(
-            new Page<>(normalizedPageNumber, normalizedPageSize),
-            query
-        ));
     }
 
     @PostMapping("update")
@@ -84,23 +79,43 @@ public class DocumentChunkController extends BaseController {
             resource = CategoryResourceType.KNOWLEDGE,
             action = ResourceAction.MANAGE,
             lookup = ResourceLookup.DOCUMENT_CHUNK_ID,
-            idExpr = "#request.id",
+            idExpr = "#documentChunk.id",
             denyMessage = "无权限管理知识库"
     )
-    public Result<?> update(
+    public Result<?> update(@JsonBody DocumentChunk documentChunk) {
-        @JsonBody(required = true, skipConvertError = false)
+        boolean success = service.updateById(documentChunk);
-        DocumentChunkContentUpdateRequest request
+        if (success){
-    ) {
+            DocumentChunk record = documentChunkService.getById(documentChunk.getId());
-        DocumentChunk current = documentChunkService.getById(request.getId());
+            DocumentCollection knowledge = documentCollectionService.getById(record.getDocumentCollectionId());
-        if (current == null) {
+            if (knowledge == null) {
-            return Result.fail(1, "记录不存在");
+                return Result.fail(1, "知识库不存在");
             }
-        DocumentChunk updated = documentChunkService.updateContent(
+            DocumentStore documentStore = knowledge.toDocumentStore();
-            current.getDocumentCollectionId(),
+            if (documentStore == null) {
-            current.getId(),
+                return Result.fail(2, "知识库没有配置向量库");
-            request.getContent()
+            }
-        );
+            try {
-        return Result.ok(updated);
+                // 设置向量模型
+                Model model = modelService.getModelInstance(knowledge.getVectorEmbedModelId());
+                if (model == null) {
+                    return Result.fail(3, "知识库没有配置向量模型");
+                }
+                EmbeddingModel embeddingModel = model.toEmbeddingModel();
+                documentStore.setEmbeddingModel(embeddingModel);
+                StoreOptions options = StoreOptions.ofCollectionName(knowledge.getVectorStoreCollection());
+                Document document = Document.of(documentChunk.getContent());
+                document.setId(documentChunk.getId());
+                Map<String, Object> metadata = new HashMap<>();
+                metadata.put("keywords", documentChunk.getMetadataKeyWords());
+                metadata.put("questions", documentChunk.getMetadataQuestions());
+                document.setMetadataMap(metadata);
+                StoreResult result = documentStore.update(document, options); // 更新已有记录
+                return Result.ok(result);
+            } finally {
+                DocumentStoreLifecycleSupport.closeQuietly(documentStore);
+            }
+        }
+        return Result.ok(false);
     }
 
     @PostMapping("removeChunk")
@@ -112,58 +127,36 @@ public class DocumentChunkController extends BaseController {
             idExpr = "#chunkId",
             denyMessage = "无权限管理知识库"
     )
-    public Result<?> removeChunk(@JsonBody(value = "id", required = true) BigInteger chunkId) {
+    public Result<?> remove(@JsonBody(value = "id", required = true) BigInteger chunkId) {
         DocumentChunk docChunk =  documentChunkService.getById(chunkId);
         if (docChunk == null) {
             return Result.fail(1, "记录不存在");
         }
-        return Result.ok(documentChunkService.deleteChunk(
+        DocumentCollection knowledge = documentCollectionService.getById(docChunk.getDocumentCollectionId());
-            docChunk.getDocumentCollectionId(),
+        if (knowledge == null) {
-            chunkId
+            return Result.fail(2, "知识库不存在");
-        ));
         }
+        DocumentStore documentStore = knowledge.toDocumentStore();
+        if (documentStore == null) {
+            return Result.fail(3, "知识库没有配置向量库");
+        }
+        try {
+            // 设置向量模型
+            Model model = modelService.getModelInstance(knowledge.getVectorEmbedModelId());
+            if (model == null) {
+                return Result.fail(4, "知识库没有配置向量模型");
+            }
+            EmbeddingModel embeddingModel = model.toEmbeddingModel();
+            documentStore.setEmbeddingModel(embeddingModel);
+            StoreOptions options = StoreOptions.ofCollectionName(knowledge.getVectorStoreCollection());
+            List<BigInteger> deleteList = new ArrayList<>();
+            deleteList.add(chunkId);
+            documentStore.delete(deleteList, options);
+            documentChunkService.removeChunk(knowledge, chunkId);
 
-    @PostMapping("syncStatus")
+            return super.remove(chunkId);
-    @SaCheckPermission("/api/v1/documentCollection/query")
+        } finally {
-    @RequireResourceAccess(
+            DocumentStoreLifecycleSupport.closeQuietly(documentStore);
-            resource = CategoryResourceType.KNOWLEDGE,
+        }
-            action = ResourceAction.READ,
-            lookup = ResourceLookup.DOCUMENT_ID,
-            idExpr = "#request.documentId",
-            denyMessage = "无权限访问知识库"
-    )
-    public Result<List<DocumentChunkSyncStatus>> syncStatus(
-        @JsonBody(required = true, skipConvertError = false)
-        DocumentChunkSyncStatusRequest request
-    ) {
-        return Result.ok(documentChunkService.listIndexSyncStatus(
-            null,
-            request.getDocumentId(),
-            request.getIds()
-        ));
-    }
-
-    @PostMapping("retrySync")
-    @SaCheckPermission("/api/v1/documentCollection/save")
-    @RequireResourceAccess(
-            resource = CategoryResourceType.KNOWLEDGE,
-            action = ResourceAction.MANAGE,
-            lookup = ResourceLookup.DOCUMENT_CHUNK_ID,
-            idExpr = "#request.id",
-            denyMessage = "无权限管理知识库"
-    )
-    public Result<?> retrySync(
-        @JsonBody(required = true, skipConvertError = false)
-        DocumentChunkSyncRetryRequest request
-    ) {
-        DocumentChunk current = documentChunkService.getById(request.getId());
-        if (current == null || request.getIndexSyncVersion() == null) {
-            return Result.fail(1, "记录不存在或同步版本缺失");
-        }
-        return Result.ok(documentChunkService.retryIndexSync(
-            current.getDocumentCollectionId(),
-            current.getId(),
-            request.getIndexSyncVersion()
-        ));
     }
 }

easyflow-api/easyflow-api-admin/src/main/java/tech/easyflow/admin/controller/ai/DocumentController.java

@@ -118,10 +118,12 @@ public class DocumentController extends BaseCurdController<DocumentService, Docu
         List<Serializable> ids = Collections.singletonList(id);
         Result<?> result = onRemoveBefore(ids);
         if (result != null) return result;
-        boolean success = documentService.removeDoc(id);
+        boolean isSuccess = documentService.removeDoc(id);
-        if (success) {
+        if (!isSuccess){
-            onRemoveAfter(ids);
+            return Result.ok(false);
         }
+        boolean success = service.removeById(id);
+        onRemoveAfter(ids);
         return Result.ok(success);
     }
 

easyflow-api/easyflow-api-admin/src/main/java/tech/easyflow/admin/controller/ai/PluginItemController.java

@@ -18,12 +18,10 @@ import tech.easyflow.ai.easyagentsflow.entity.NodeInfo;
 import tech.easyflow.ai.easyagentsflow.entity.WorkflowCheckStage;
 import tech.easyflow.ai.easyagentsflow.service.TinyFlowService;
 import tech.easyflow.ai.easyagentsflow.service.WorkflowCheckService;
-import tech.easyflow.ai.easyagentsflow.service.WorkflowResumeService;
 import tech.easyflow.ai.easyagentsflow.support.PublishedWorkflowDefinitionIds;
 import tech.easyflow.ai.entity.Plugin;
 import tech.easyflow.ai.entity.PluginItem;
 import tech.easyflow.ai.entity.Workflow;
-import tech.easyflow.ai.entity.WorkflowExecResult;
 import tech.easyflow.ai.enums.PluginType;
 import tech.easyflow.ai.plugin.workflow.snapshot.WorkflowPluginSnapshotResolver;
 import tech.easyflow.ai.service.PluginService;
@@ -31,7 +29,6 @@ import tech.easyflow.ai.service.PluginItemService;
 import tech.easyflow.ai.service.AgentResourceReferenceService;
 import tech.easyflow.ai.service.PluginVisibilityService;
 import tech.easyflow.ai.service.WorkflowService;
-import tech.easyflow.ai.service.WorkflowExecResultService;
 import tech.easyflow.common.constant.Constants;
 import tech.easyflow.common.annotation.UsePermission;
 import tech.easyflow.common.domain.Result;
@@ -94,15 +91,11 @@ public class PluginItemController extends BaseCurdController<PluginItemService,
     @Resource
     private WorkflowService workflowService;
     @Resource
-    private WorkflowExecResultService workflowExecResultService;
-    @Resource
     private ChainExecutor chainExecutor;
     @Resource
     private TinyFlowService tinyFlowService;
     @Resource
     private WorkflowCheckService workflowCheckService;
-    @Resource
-    private WorkflowResumeService workflowResumeService;
 
     @PostMapping("/tool/save")
     @SaCheckPermission("/api/v1/plugin/save")
@@ -222,7 +215,6 @@ public class PluginItemController extends BaseCurdController<PluginItemService,
     @SaCheckPermission("/api/v1/plugin/query")
     public Result<ChainInfo> pluginToolTestChainStatus(@JsonBody(value = "executeId", required = true) String executeId,
                                                        @JsonBody("nodes") List<NodeInfo> nodes) {
-        assertPluginTestExecutionOwnership(executeId);
         return Result.ok(tinyFlowService.getChainStatus(executeId, nodes));
     }
 
@@ -237,33 +229,10 @@ public class PluginItemController extends BaseCurdController<PluginItemService,
     @SaCheckPermission("/api/v1/plugin/query")
     public Result<Void> pluginToolTestResume(@JsonBody(value = "executeId", required = true) String executeId,
                                              @JsonBody("confirmParams") Map<String, Object> confirmParams) {
-        assertPluginTestExecutionOwnership(executeId);
+        chainExecutor.resumeAsync(executeId, confirmParams);
-        workflowResumeService.resume(executeId, confirmParams);
         return Result.ok();
     }
 
-    /**
-     * 校验插件试运行实例由当前登录用户发起。
-     *
-     * @param executeId 执行实例 ID
-     */
-    private void assertPluginTestExecutionOwnership(String executeId) {
-        if (StrUtil.isBlank(executeId)) {
-            throw new BusinessException("执行ID不能为空");
-        }
-        WorkflowExecResult record = workflowExecResultService.getByExecKey(executeId);
-        if (record == null) {
-            throw new BusinessException(404, 404, "工作流执行记录不存在或已过期");
-        }
-        LoginAccount currentAccount = SaTokenUtil.getLoginAccount();
-        if (currentAccount == null
-                || currentAccount.getId() == null
-                || record.getCreatedBy() == null
-                || !currentAccount.getId().toString().equals(record.getCreatedBy())) {
-            throw new BusinessException(403, 403, "无权限访问当前插件试运行实例");
-        }
-    }
-
     private void handleArray(JSONArray array) {
         for (Object o : array) {
             JSONObject obj = (JSONObject) o;

easyflow-api/easyflow-api-admin/src/main/java/tech/easyflow/admin/controller/ai/ShareKnowledgeController.java

@@ -1,6 +1,10 @@
 package tech.easyflow.admin.controller.ai;
 
 import cn.hutool.core.io.IoUtil;
+import com.easyagents.core.model.embedding.EmbeddingModel;
+import com.easyagents.core.store.DocumentStore;
+import com.easyagents.core.store.StoreOptions;
+import com.easyagents.core.store.StoreResult;
 import com.mybatisflex.core.paginate.Page;
 import com.mybatisflex.core.query.QueryColumn;
 import com.mybatisflex.core.query.QueryWrapper;
@@ -18,11 +22,6 @@ import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;
 import org.springframework.web.multipart.MultipartFile;
 import tech.easyflow.ai.documentimport.DocumentImportDtos;
 import tech.easyflow.ai.documentimport.task.DocumentImportTaskStatusStreamService;
-import tech.easyflow.ai.dto.DocumentChunkContentUpdateRequest;
-import tech.easyflow.ai.dto.DocumentChunkDeleteResult;
-import tech.easyflow.ai.dto.DocumentChunkSyncRetryRequest;
-import tech.easyflow.ai.dto.DocumentChunkSyncStatus;
-import tech.easyflow.ai.dto.DocumentChunkSyncStatusRequest;
 import tech.easyflow.ai.dto.KnowledgeShareLimitedConfigRequest;
 import tech.easyflow.ai.dto.KnowledgeSearchResultItem;
 import tech.easyflow.ai.entity.Document;
@@ -44,6 +43,7 @@ import tech.easyflow.ai.service.KnowledgeEmbeddingService;
 import tech.easyflow.ai.service.KnowledgeShareAuditService;
 import tech.easyflow.ai.service.KnowledgeShareService;
 import tech.easyflow.ai.service.ModelService;
+import tech.easyflow.ai.support.DocumentStoreLifecycleSupport;
 import tech.easyflow.ai.vo.FaqImportResultVo;
 import tech.easyflow.ai.vo.KnowledgeShareAuthContext;
 import tech.easyflow.ai.vo.KnowledgeShareViewDetail;
@@ -62,6 +62,7 @@ import java.net.URLEncoder;
 import java.nio.charset.StandardCharsets;
 import java.text.SimpleDateFormat;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.Date;
 import java.util.HashMap;
 import java.util.HashSet;
@@ -504,27 +505,43 @@ public class ShareKnowledgeController {
     @PostMapping("/documentChunk/update")
     public Result<?> updateDocumentChunk(
         @RequestParam String shareKey,
-        @JsonBody(required = true, skipConvertError = false)
+        @JsonBody DocumentChunk documentChunk
-        DocumentChunkContentUpdateRequest request
     ) {
         KnowledgeShareAuthContext context = knowledgeShareService.assertUrlShareAccess(
             shareKey,
             null,
             KnowledgeShareActionScope.CONTENT_UPDATE.name()
         );
-        DocumentChunk current = documentChunkService.getById(request.getId());
+        DocumentChunk current = documentChunkService.getById(documentChunk.getId());
         if (current == null || current.getDocumentCollectionId() == null
             || current.getDocumentCollectionId().compareTo(context.getKnowledge().getId()) != 0) {
             throw new BusinessException("记录不存在");
         }
-        DocumentChunk updated = documentChunkService.updateContent(
+        boolean success = documentChunkService.updateById(documentChunk);
-            context.getKnowledge().getId(),
+        if (success) {
-            current.getId(),
+            DocumentStore documentStore = context.getKnowledge().toDocumentStore();
-            request.getContent()
+            if (documentStore == null) {
-        );
+                return Result.fail(2, "知识库没有配置向量库");
+            }
+            try {
+                Model model = modelService.getModelInstance(context.getKnowledge().getVectorEmbedModelId());
+                if (model == null) {
+                    return Result.fail(3, "知识库没有配置向量模型");
+                }
+                EmbeddingModel embeddingModel = model.toEmbeddingModel();
+                documentStore.setEmbeddingModel(embeddingModel);
+                StoreOptions options = StoreOptions.ofCollectionName(context.getKnowledge().getVectorStoreCollection());
+                com.easyagents.core.document.Document doc = com.easyagents.core.document.Document.of(documentChunk.getContent());
+                doc.setId(documentChunk.getId());
+                StoreResult result = documentStore.update(doc, options);
                 audit(context, "更新分享文档 Chunk", "KNOWLEDGE_SHARE_URL_WRITE", true,
-            auditDetail("knowledgeId", context.getKnowledge().getId(), "chunkId", request.getId()));
+                    auditDetail("knowledgeId", context.getKnowledge().getId(), "chunkId", documentChunk.getId()));
-        return Result.ok(updated);
+                return Result.ok(result);
+            } finally {
+                DocumentStoreLifecycleSupport.closeQuietly(documentStore);
+            }
+        }
+        return Result.ok(false);
     }
 
     /**
@@ -545,50 +562,25 @@ public class ShareKnowledgeController {
             || current.getDocumentCollectionId().compareTo(context.getKnowledge().getId()) != 0) {
             return Result.fail(1, "记录不存在");
         }
-        DocumentChunkDeleteResult removed = documentChunkService.deleteChunk(
+        DocumentStore documentStore = context.getKnowledge().toDocumentStore();
-            context.getKnowledge().getId(),
+        if (documentStore == null) {
-            chunkId
+            return Result.fail(2, "知识库没有配置向量库");
-        );
+        }
+        try {
+            Model model = modelService.getModelInstance(context.getKnowledge().getVectorEmbedModelId());
+            if (model == null) {
+                return Result.fail(3, "知识库没有配置向量模型");
+            }
+            documentStore.setEmbeddingModel(model.toEmbeddingModel());
+            StoreOptions options = StoreOptions.ofCollectionName(context.getKnowledge().getVectorStoreCollection());
+            documentStore.delete(Collections.singletonList(chunkId), options);
+            documentChunkService.removeById(chunkId);
             audit(context, "删除分享文档 Chunk", "KNOWLEDGE_SHARE_URL_WRITE", true,
                 auditDetail("knowledgeId", context.getKnowledge().getId(), "chunkId", chunkId));
-        return Result.ok(removed);
+            return Result.ok(true);
+        } finally {
+            DocumentStoreLifecycleSupport.closeQuietly(documentStore);
         }
-
-    @PostMapping("/documentChunk/syncStatus")
-    public Result<List<DocumentChunkSyncStatus>> documentChunkSyncStatus(
-        @RequestParam String shareKey,
-        @JsonBody DocumentChunkSyncStatusRequest request
-    ) {
-        KnowledgeShareAuthContext context = knowledgeShareService.assertUrlShareAccess(
-            shareKey, null, KnowledgeShareActionScope.VIEW.name()
-        );
-        Document document = documentService.getById(request.getDocumentId());
-        if (document == null || document.getCollectionId() == null
-            || document.getCollectionId().compareTo(context.getKnowledge().getId()) != 0) {
-            throw new BusinessException("文档不存在");
-        }
-        return Result.ok(documentChunkService.listIndexSyncStatus(
-            context.getKnowledge().getId(), request.getDocumentId(), request.getIds()
-        ));
-    }
-
-    @PostMapping("/documentChunk/retrySync")
-    public Result<DocumentChunk> retryDocumentChunkSync(
-        @RequestParam String shareKey,
-        @JsonBody DocumentChunkSyncRetryRequest request
-    ) {
-        KnowledgeShareAuthContext context = knowledgeShareService.assertUrlShareAccess(
-            shareKey, null, KnowledgeShareActionScope.CONTENT_UPDATE.name()
-        );
-        if (request.getIndexSyncVersion() == null) {
-            throw new BusinessException("同步版本不能为空");
-        }
-        DocumentChunk chunk = documentChunkService.retryIndexSync(
-            context.getKnowledge().getId(), request.getId(), request.getIndexSyncVersion()
-        );
-        audit(context, "重试分享文档 Chunk 索引同步", "KNOWLEDGE_SHARE_URL_WRITE", true,
-            auditDetail("knowledgeId", context.getKnowledge().getId(), "chunkId", request.getId()));
-        return Result.ok(chunk);
     }
 
     /**

easyflow-api/easyflow-api-admin/src/main/java/tech/easyflow/admin/controller/ai/WorkflowChatController.java

@@ -1,5 +1,6 @@
 package tech.easyflow.admin.controller.ai;
 
+import com.easyagents.flow.core.chain.ChainStatus;
 import com.easyagents.flow.core.chain.runtime.ChainExecutor;
 import com.mybatisflex.core.query.QueryWrapper;
 import jakarta.servlet.http.HttpServletRequest;
@@ -13,7 +14,6 @@ import tech.easyflow.admin.service.ai.WorkflowChatEventStream;
 import tech.easyflow.ai.easyagentsflow.entity.WorkflowCheckStage;
 import tech.easyflow.ai.easyagentsflow.service.WorkflowCheckService;
 import tech.easyflow.ai.easyagentsflow.service.WorkflowRunningParameterResolver;
-import tech.easyflow.ai.easyagentsflow.service.WorkflowResumeService;
 import tech.easyflow.ai.easyagentsflow.support.PublishedWorkflowDefinitionIds;
 import tech.easyflow.ai.entity.Workflow;
 import tech.easyflow.ai.entity.WorkflowExecResult;
@@ -64,8 +64,6 @@ public class WorkflowChatController {
     @Resource
     private ChainExecutor chainExecutor;
     @Resource
-    private WorkflowResumeService workflowResumeService;
-    @Resource
     private WorkflowExecResultService execResultService;
     @Resource
     private WorkflowExecStepService execStepService;
@@ -173,8 +171,19 @@ public class WorkflowChatController {
             @JsonBody("confirmParams")
             Map<String, Object> confirmParams
     ) {
-        assertExecutionOwnership(executeId);
+        WorkflowExecResult record = assertExecutionOwnership(executeId);
-        workflowResumeService.resume(executeId, confirmParams);
+        if (record.getStatus() != null
+                && (record.getStatus() == ChainStatus.SUCCEEDED.getValue()
+                || record.getStatus() == ChainStatus.FAILED.getValue()
+                || record.getStatus() == ChainStatus.CANCELLED.getValue())) {
+            throw new BusinessException("当前工作流执行已结束");
+        }
+        chainExecutor.resumeAsync(
+                executeId,
+                confirmParams == null
+                        ? new LinkedHashMap<>()
+                        : new LinkedHashMap<>(confirmParams)
+        );
         return Result.ok();
     }
 

easyflow-api/easyflow-api-admin/src/main/java/tech/easyflow/admin/controller/ai/WorkflowController.java

@@ -31,7 +31,6 @@ import tech.easyflow.ai.easyagentsflow.service.TinyFlowService;
 import tech.easyflow.ai.easyagentsflow.service.WorkflowCheckService;
 import tech.easyflow.ai.easyagentsflow.service.WorkflowDatacenterContentService;
 import tech.easyflow.ai.easyagentsflow.service.WorkflowRunningParameterResolver;
-import tech.easyflow.ai.easyagentsflow.service.WorkflowResumeService;
 import tech.easyflow.ai.entity.Workflow;
 import tech.easyflow.ai.enums.PublishStatus;
 import tech.easyflow.ai.publish.WorkflowPublishAppService;
@@ -95,8 +94,6 @@ public class WorkflowController extends BaseCurdController<WorkflowService, Work
     @Resource
     private WorkflowRunningParameterResolver workflowRunningParameterResolver;
     @Resource
-    private WorkflowResumeService workflowResumeService;
-    @Resource
     private ResourceAccessService resourceAccessService;
     @Resource
     private WorkflowVisibilityQueryHelper workflowVisibilityQueryHelper;
@@ -327,7 +324,12 @@ public class WorkflowController extends BaseCurdController<WorkflowService, Work
     )
     public Result<Void> resume(@JsonBody(value = "executeId", required = true) String executeId,
                                @JsonBody("confirmParams") Map<String, Object> confirmParams) {
-        workflowResumeService.resume(executeId, confirmParams);
+        if (!chainExecutor.resumeAsyncIfSuspended(executeId, confirmParams)) {
+            throw new BusinessException(
+                    409,
+                    40901,
+                    "当前执行状态不可恢复，仅暂停中的工作流允许恢复");
+        }
         return Result.ok();
     }
 

easyflow-api/easyflow-api-admin/src/main/java/tech/easyflow/admin/controller/datacenter/DatacenterDatasetController.java

@@ -24,6 +24,11 @@ import java.util.List;
 @RequestMapping("/api/v1/datacenterDataset")
 public class DatacenterDatasetController {
 
+    /** 对外 Schema 接口的默认字段页码。 */
+    private static final long DEFAULT_FIELD_PAGE_NUMBER = 1L;
+    /** 对外 Schema 接口的默认字段页大小。 */
+    private static final long DEFAULT_FIELD_PAGE_SIZE = 200L;
+
     @Resource
     private DatacenterDatasetQueryService queryService;
     @Resource
@@ -32,13 +37,18 @@ public class DatacenterDatasetController {
     @PostMapping("/queryPage")
     @SaCheckPermission("/api/v1/datacenterSource/query")
     public Result<Page<Row>> queryPage(@RequestBody DatacenterQueryRequest request) {
-        return Result.ok(queryService.queryPage(request));
+        return Result.ok(queryService.queryPage(
+                request, SaTokenUtil.getLoginAccount()));
     }
 
     @GetMapping("/schema")
     @SaCheckPermission("/api/v1/datacenterSource/query")
-    public Result<DatacenterSchemaResponse> schema(DatasetRef datasetRef) {
+    public Result<DatacenterSchemaResponse> schema(
-        return Result.ok(queryService.getSchema(datasetRef));
+            DatasetRef datasetRef,
+            @RequestParam(defaultValue = "1") Long fieldPageNumber,
+            @RequestParam(defaultValue = "200") Long fieldPageSize) {
+        return Result.ok(queryService.getSchema(
+                datasetRef, fieldPageNumber, fieldPageSize));
     }
 
     @GetMapping("/managedTables")
@@ -63,6 +73,13 @@ public class DatacenterDatasetController {
                 request == null ? List.of() : request.getFields(),
                 account
         );
-        return Result.ok(queryService.getSchema(registryService.resolveDatasetRef(table.getId())));
+        return Result.ok(queryService.getSchema(
+                registryService.resolveDatasetRef(table.getId()),
+                request == null || request.getFieldPageNumber() == null
+                        ? DEFAULT_FIELD_PAGE_NUMBER
+                        : request.getFieldPageNumber(),
+                request == null || request.getFieldPageSize() == null
+                        ? DEFAULT_FIELD_PAGE_SIZE
+                        : request.getFieldPageSize()));
     }
 }

easyflow-api/easyflow-api-admin/src/main/java/tech/easyflow/admin/controller/datacenter/DatacenterQueryController.java

@@ -0,0 +1,84 @@
+package tech.easyflow.admin.controller.datacenter;
+
+import cn.dev33.satoken.annotation.SaCheckPermission;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import tech.easyflow.common.domain.Result;
+import tech.easyflow.common.entity.LoginAccount;
+import tech.easyflow.common.satoken.util.SaTokenUtil;
+import tech.easyflow.datacenter.execution.model.DatacenterSqlConsoleRequest;
+import tech.easyflow.datacenter.execution.model.DatacenterSqlConsoleResult;
+import tech.easyflow.datacenter.execution.model.DatacenterSqlCancelRequest;
+import tech.easyflow.datacenter.federation.DatacenterFederationQueryService;
+import tech.easyflow.datacenter.federation.DatacenterFederationQueryCancellationService;
+import tech.easyflow.datacenter.meta.entity.DatacenterSource;
+import tech.easyflow.datacenter.meta.service.DatacenterDatasetRegistryService;
+
+/**
+ * 数据中枢管理端只读 SQL 控制台。
+ */
+@RestController
+@RequestMapping("/api/v1/datacenterQuery")
+public class DatacenterQueryController {
+
+    private final DatacenterDatasetRegistryService registryService;
+    private final DatacenterFederationQueryService queryService;
+    private final DatacenterFederationQueryCancellationService cancellationService;
+
+    /**
+     * 创建查询 Controller。
+     *
+     * @param registryService 数据集注册服务
+     * @param queryService Federation 查询服务
+     * @param cancellationService 跨节点查询取消服务
+     */
+    public DatacenterQueryController(
+            DatacenterDatasetRegistryService registryService,
+            DatacenterFederationQueryService queryService,
+            DatacenterFederationQueryCancellationService cancellationService) {
+        this.registryService = registryService;
+        this.queryService = queryService;
+        this.cancellationService = cancellationService;
+    }
+
+    /**
+     * 执行一条受 Calcite 与业务 Policy 校验的只读 SQL。
+     *
+     * @param request 查询请求
+     * @return 有界查询结果
+     */
+    @PostMapping("/execute")
+    @SaCheckPermission("/api/v1/datacenterSource/query")
+    public Result<DatacenterSqlConsoleResult> execute(
+            @RequestBody DatacenterSqlConsoleRequest request) {
+        LoginAccount account = SaTokenUtil.getLoginAccount();
+        DatacenterSource source = registryService.getSourceRequired(
+                request == null ? null : request.sourceId());
+        return Result.ok(queryService.execute(
+                source,
+                request == null ? null : request.sql(),
+                java.util.List.of(),
+                request == null ? null : request.maxRows(),
+                account,
+                "MANUAL",
+                account == null || account.getId() == null
+                        ? null : account.getId().toString(),
+                request == null ? null : request.queryId()));
+    }
+
+    /**
+     * 取消当前租户在任一节点执行的 SQL 查询。
+     *
+     * @param request 取消请求
+     * @return 是否在本地或集群中接受取消提示
+     */
+    @PostMapping("/cancel")
+    @SaCheckPermission("/api/v1/datacenterSource/query")
+    public Result<Boolean> cancel(@RequestBody DatacenterSqlCancelRequest request) {
+        LoginAccount account = SaTokenUtil.getLoginAccount();
+        return Result.ok(cancellationService.cancel(
+                request == null ? null : request.queryId(), account));
+    }
+}

easyflow-api/easyflow-api-admin/src/main/java/tech/easyflow/admin/controller/datacenter/DatacenterSourceController.java

@@ -8,10 +8,16 @@ import tech.easyflow.common.entity.LoginAccount;
 import tech.easyflow.common.satoken.util.SaTokenUtil;
 import tech.easyflow.datacenter.entity.DatacenterTable;
 import tech.easyflow.datacenter.execution.model.DatacenterConnectionTestResult;
-import tech.easyflow.datacenter.meta.entity.DatacenterSource;
 import tech.easyflow.datacenter.meta.model.DatacenterBatchRegisterRequest;
 import tech.easyflow.datacenter.meta.model.DatacenterCatalogMeta;
+import tech.easyflow.datacenter.meta.model.DatacenterMetadataPage;
 import tech.easyflow.datacenter.meta.model.DatacenterRemoveSourceRequest;
+import tech.easyflow.datacenter.meta.model.DatacenterSourceActivateRequest;
+import tech.easyflow.datacenter.meta.model.DatacenterSourceCandidateMetadataRequest;
+import tech.easyflow.datacenter.meta.model.DatacenterSourceCandidateCatalogRequest;
+import tech.easyflow.datacenter.meta.model.DatacenterSourceDraftRequest;
+import tech.easyflow.datacenter.meta.model.DatacenterSourceReconfigureRequest;
+import tech.easyflow.datacenter.meta.model.DatacenterSourceView;
 import tech.easyflow.datacenter.meta.model.DatacenterTableDetailMeta;
 import tech.easyflow.datacenter.meta.service.DatacenterSourceService;
 
@@ -19,6 +25,9 @@ import javax.annotation.Resource;
 import java.math.BigInteger;
 import java.util.List;
 
+/**
+ * 数据源绑定、生命周期与元数据浏览接口。
+ */
 @RestController
 @RequestMapping("/api/v1/datacenterSource")
 public class DatacenterSourceController {
@@ -26,23 +35,100 @@ public class DatacenterSourceController {
     @Resource
     private DatacenterSourceService sourceService;
 
-    @PostMapping("/testConnection")
+    @PostMapping("/draft")
-    @SaCheckPermission("/api/v1/datacenterSource/query")
+    @SaCheckPermission("/api/v1/datacenterSource/save")
-    public Result<DatacenterConnectionTestResult> testConnection(@RequestBody DatacenterSource source) {
+    public Result<DatacenterSourceView> saveDraft(@RequestBody DatacenterSourceDraftRequest request) {
         LoginAccount account = SaTokenUtil.getLoginAccount();
-        return Result.ok(sourceService.testConnection(source, account));
+        return Result.ok(sourceService.saveDraft(request, account));
     }
 
-    @PostMapping("/save")
+    @PostMapping("/{sourceId}/probe")
-    @SaCheckPermission("/api/v1/datacenterSource/save")
+    @SaCheckPermission("/api/v1/datacenterSource/query")
-    public Result<DatacenterSource> save(@RequestBody DatacenterSource source) {
+    public Result<DatacenterConnectionTestResult> probe(@PathVariable BigInteger sourceId) {
         LoginAccount account = SaTokenUtil.getLoginAccount();
-        return Result.ok(sourceService.saveSource(source, account));
+        return Result.ok(sourceService.probe(sourceId, account));
+    }
+
+    @PostMapping("/activate")
+    @SaCheckPermission("/api/v1/datacenterSource/save")
+    public Result<DatacenterSourceView> activate(@RequestBody DatacenterSourceActivateRequest request) {
+        LoginAccount account = SaTokenUtil.getLoginAccount();
+        return Result.ok(sourceService.activate(request, account));
+    }
+
+    /**
+     * 探测活动数据源的未发布候选配置。
+     *
+     * @param request 候选连接配置
+     * @return 连接探测结果
+     */
+    @PostMapping("/candidate/probe")
+    @SaCheckPermission("/api/v1/datacenterSource/save")
+    public Result<DatacenterConnectionTestResult> probeCandidate(
+            @RequestBody DatacenterSourceDraftRequest request) {
+        return Result.ok(sourceService.probeCandidate(
+                request, SaTokenUtil.getLoginAccount()));
+    }
+
+    /**
+     * 浏览活动数据源候选配置可访问的命名空间。
+     *
+     * @param request 候选连接配置
+     * @return 命名空间列表
+     */
+    @PostMapping("/candidate/catalogs")
+    @SaCheckPermission("/api/v1/datacenterSource/save")
+    public Result<List<DatacenterCatalogMeta>> candidateCatalogs(
+            @RequestBody DatacenterSourceDraftRequest request) {
+        return Result.ok(sourceService.listCandidateCatalogs(
+                request, SaTokenUtil.getLoginAccount()));
+    }
+
+    /**
+     * 分页浏览候选配置可访问的命名空间。
+     *
+     * @param request 候选配置和分页条件
+     * @return 有界命名空间列表
+     */
+    @PostMapping("/candidate/catalogs/page")
+    @SaCheckPermission("/api/v1/datacenterSource/save")
+    public Result<DatacenterMetadataPage<DatacenterCatalogMeta>> candidateCatalogsPage(
+            @RequestBody DatacenterSourceCandidateCatalogRequest request) {
+        return Result.ok(sourceService.listCandidateCatalogsPage(
+                request, SaTokenUtil.getLoginAccount()));
+    }
+
+    /**
+     * 分页浏览活动数据源候选配置可访问的表。
+     *
+     * @param request 候选配置与分页条件
+     * @return 有界表列表
+     */
+    @PostMapping("/candidate/tables")
+    @SaCheckPermission("/api/v1/datacenterSource/save")
+    public Result<DatacenterMetadataPage<DatacenterTable>> candidateTables(
+            @RequestBody DatacenterSourceCandidateMetadataRequest request) {
+        return Result.ok(sourceService.listCandidateTables(
+                request, SaTokenUtil.getLoginAccount()));
+    }
+
+    /**
+     * 原地发布活动数据源的新连接配置和纳管范围。
+     *
+     * @param request 重配置请求
+     * @return 发布后的数据源视图
+     */
+    @PostMapping("/reconfigure")
+    @SaCheckPermission("/api/v1/datacenterSource/save")
+    public Result<DatacenterSourceView> reconfigure(
+            @RequestBody DatacenterSourceReconfigureRequest request) {
+        return Result.ok(sourceService.reconfigure(
+                request, SaTokenUtil.getLoginAccount()));
     }
 
     @GetMapping("/page")
     @SaCheckPermission("/api/v1/datacenterSource/query")
-    public Result<Page<DatacenterSource>> page(Long pageNumber, Long pageSize) {
+    public Result<Page<DatacenterSourceView>> page(Long pageNumber, Long pageSize) {
         LoginAccount account = SaTokenUtil.getLoginAccount();
         return Result.ok(sourceService.pageSources(pageNumber, pageSize, account));
     }
@@ -54,19 +140,53 @@ public class DatacenterSourceController {
         return Result.ok(sourceService.listCatalogs(sourceId, account));
     }
 
+    /**
+     * 分页浏览当前数据源的命名空间。
+     *
+     * @param sourceId 数据源 ID
+     * @param keyword 名称搜索词
+     * @param pageNumber 页码
+     * @param pageSize 每页大小
+     * @return 有界命名空间列表
+     */
+    @GetMapping("/catalogs/page")
+    @SaCheckPermission("/api/v1/datacenterSource/query")
+    public Result<DatacenterMetadataPage<DatacenterCatalogMeta>> catalogsPage(
+            BigInteger sourceId,
+            String keyword,
+            Long pageNumber,
+            Long pageSize) {
+        return Result.ok(sourceService.listCatalogsPage(
+                sourceId, keyword, pageNumber, pageSize,
+                SaTokenUtil.getLoginAccount()));
+    }
+
     @GetMapping("/tables")
     @SaCheckPermission("/api/v1/datacenterSource/query")
-    public Result<List<DatacenterTable>> tables(BigInteger sourceId, String catalogName) {
+    public Result<DatacenterMetadataPage<DatacenterTable>> tables(
+            BigInteger sourceId,
+            String catalogName,
+            String keyword,
+            Long pageNumber,
+            Long pageSize) {
         LoginAccount account = SaTokenUtil.getLoginAccount();
-        return Result.ok(sourceService.listTables(sourceId, catalogName, account));
+        return Result.ok(sourceService.listTables(
+                sourceId, catalogName, keyword, pageNumber, pageSize, account));
     }
 
     @GetMapping("/tableDetail")
     @SaCheckPermission("/api/v1/datacenterSource/query")
-    public Result<DatacenterTableDetailMeta> tableDetail(BigInteger sourceId, String catalogName, String tableName,
+    public Result<DatacenterTableDetailMeta> tableDetail(
-                                                         @RequestParam(defaultValue = "false") boolean register) {
+            BigInteger sourceId,
+            String catalogName,
+            String tableName,
+            @RequestParam(defaultValue = "false") boolean register,
+            Long fieldPageNumber,
+            Long fieldPageSize) {
         LoginAccount account = SaTokenUtil.getLoginAccount();
-        return Result.ok(sourceService.getTableDetail(sourceId, catalogName, tableName, register, account));
+        return Result.ok(sourceService.getTableDetail(
+                sourceId, catalogName, tableName, register,
+                fieldPageNumber, fieldPageSize, account));
     }
 
     @PostMapping("/registerBatch")
@@ -83,4 +203,44 @@ public class DatacenterSourceController {
         sourceService.removeSource(request == null ? null : request.getSourceId(), account);
         return Result.ok();
     }
+
+    /**
+     * 停用活动数据源。
+     *
+     * @param sourceId 数据源 ID
+     * @return 停用后的数据源视图
+     */
+    @PostMapping("/{sourceId}/disable")
+    @SaCheckPermission("/api/v1/datacenterSource/save")
+    public Result<DatacenterSourceView> disable(@PathVariable BigInteger sourceId) {
+        return Result.ok(sourceService.disable(
+                sourceId, SaTokenUtil.getLoginAccount()));
+    }
+
+    /**
+     * 重新启用已停用数据源。
+     *
+     * @param sourceId 数据源 ID
+     * @return 启用后的数据源视图
+     */
+    @PostMapping("/{sourceId}/enable")
+    @SaCheckPermission("/api/v1/datacenterSource/save")
+    public Result<DatacenterSourceView> enable(@PathVariable BigInteger sourceId) {
+        return Result.ok(sourceService.enable(
+                sourceId, SaTokenUtil.getLoginAccount()));
+    }
+
+    /**
+     * 刷新已纳管对象的 JDBC 元数据观测状态。
+     *
+     * @param sourceId 数据源 ID
+     * @return 刷新后的数据源视图
+     */
+    @PostMapping("/{sourceId}/metadata/refresh")
+    @SaCheckPermission("/api/v1/datacenterSource/save")
+    public Result<DatacenterSourceView> refreshMetadata(
+            @PathVariable BigInteger sourceId) {
+        return Result.ok(sourceService.refreshMetadata(
+                sourceId, SaTokenUtil.getLoginAccount()));
+    }
 }

easyflow-api/easyflow-api-admin/src/main/java/tech/easyflow/admin/controller/dataspace/DataspaceConnectionController.java

@@ -0,0 +1,161 @@
+package tech.easyflow.admin.controller.dataspace;
+
+import cn.dev33.satoken.annotation.SaCheckPermission;
+import java.math.BigInteger;
+import java.util.List;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import tech.easyflow.common.domain.Result;
+import tech.easyflow.common.web.jsonbody.JsonBody;
+import tech.easyflow.common.web.exceptions.BusinessException;
+import tech.easyflow.dataspace.model.ConnectionDefinition;
+import tech.easyflow.dataspace.model.ConnectionView;
+import tech.easyflow.dataspace.model.ObjectView;
+import tech.easyflow.dataspace.provider.DataspaceProbe;
+import tech.easyflow.dataspace.service.DataspaceConnectionService;
+
+/**
+ * 数据空间物理连接管理端 API。
+ */
+@RestController
+@RequestMapping("/api/v1/dataspaceConnection")
+public class DataspaceConnectionController {
+
+    private final DataspaceConnectionService connectionService;
+
+    /**
+     * 创建连接控制器。
+     *
+     * @param connectionService 连接服务
+     */
+    public DataspaceConnectionController(DataspaceConnectionService connectionService) {
+        this.connectionService = connectionService;
+    }
+
+    /**
+     * 查询当前租户连接列表。
+     *
+     * @param keyword 搜索关键词
+     * @return 连接列表
+     */
+    @GetMapping("/list")
+    @SaCheckPermission("/api/v1/dataspaceConnection/query")
+    public Result<List<ConnectionView>> list(String keyword) {
+        return Result.ok(connectionService.list(keyword));
+    }
+
+    /**
+     * 获取连接详情。
+     *
+     * @param id 连接 ID
+     * @return 连接详情
+     */
+    @GetMapping("/detail")
+    @SaCheckPermission("/api/v1/dataspaceConnection/query")
+    public Result<ConnectionView> detail(BigInteger id) {
+        return Result.ok(connectionService.detail(id));
+    }
+
+    /**
+     * 测试候选或已保存连接。
+     *
+     * @param definition 连接定义
+     * @return 测试结果
+     */
+    @PostMapping("/test")
+    @SaCheckPermission("/api/v1/dataspaceConnection/test")
+    public Result<DataspaceProbe> test(
+            @JsonBody(required = true, skipConvertError = false) ConnectionDefinition definition) {
+        return Result.ok(connectionService.test(definition));
+    }
+
+    /**
+     * 创建或更新连接。
+     *
+     * @param definition 连接定义
+     * @return 保存后的连接
+     */
+    @PostMapping("/save")
+    @SaCheckPermission("/api/v1/dataspaceConnection/save")
+    public Result<ConnectionView> save(
+            @JsonBody(required = true, skipConvertError = false) ConnectionDefinition definition) {
+        return Result.ok(connectionService.save(definition));
+    }
+
+    /**
+     * 启用或禁用连接。
+     *
+     * @param request 状态变更请求
+     * @return 变更后的连接
+     */
+    @PostMapping("/status")
+    @SaCheckPermission("/api/v1/dataspaceConnection/save")
+    public Result<ConnectionView> status(
+            @JsonBody(required = true, skipConvertError = false) StatusRequest request) {
+        if (request == null || request.enabled() == null) {
+            throw new BusinessException("连接状态不能为空");
+        }
+        return Result.ok(connectionService.setEnabled(request.id(), request.enabled()));
+    }
+
+    /**
+     * 查询当前连接的对象树数据。
+     *
+     * @param connectionId 连接 ID
+     * @param keyword Schema 或表名关键词
+     * @return 对象列表
+     */
+    @GetMapping("/objects")
+    @SaCheckPermission("/api/v1/dataspaceConnection/query")
+    public Result<List<ObjectView>> objects(BigInteger connectionId, String keyword) {
+        return Result.ok(connectionService.objects(connectionId, keyword));
+    }
+
+    /**
+     * 刷新连接元数据。
+     *
+     * @param request 刷新请求
+     * @return 新 revision 对象列表
+     */
+    @PostMapping("/refreshMetadata")
+    @SaCheckPermission("/api/v1/dataspaceConnection/metadata")
+    public Result<List<ObjectView>> refreshMetadata(
+            @JsonBody(required = true, skipConvertError = false) RefreshRequest request) {
+        return Result.ok(connectionService.refreshMetadata(
+                request.connectionId(), request.expectedRevision()));
+    }
+
+    /**
+     * 删除未被引用的连接。
+     *
+     * @param id 连接 ID
+     * @return 成功结果
+     */
+    @PostMapping("/remove")
+    @SaCheckPermission("/api/v1/dataspaceConnection/remove")
+    public Result<Void> remove(
+            @JsonBody(value = "id", required = true, skipConvertError = false) BigInteger id) {
+        connectionService.remove(id);
+        return Result.ok();
+    }
+
+    /**
+     * 元数据刷新请求。
+     *
+     * @param connectionId 连接 ID
+     * @param expectedRevision 期望 revision
+     */
+    public record RefreshRequest(BigInteger connectionId, long expectedRevision) {
+    }
+
+    /**
+     * 连接状态变更请求。
+     *
+     * @param id 连接 ID
+     * @param enabled 是否启用
+     */
+    public record StatusRequest(BigInteger id, Boolean enabled) {
+    }
+}

easyflow-api/easyflow-api-admin/src/main/java/tech/easyflow/admin/controller/dataspace/DataspaceController.java

@@ -0,0 +1,113 @@
+package tech.easyflow.admin.controller.dataspace;
+
+import cn.dev33.satoken.annotation.SaCheckPermission;
+import java.math.BigInteger;
+import java.util.List;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RestController;
+import tech.easyflow.common.domain.Result;
+import tech.easyflow.common.web.jsonbody.JsonBody;
+import tech.easyflow.common.web.exceptions.BusinessException;
+import tech.easyflow.dataspace.model.DataspaceDefinition;
+import tech.easyflow.dataspace.model.DataspaceSummary;
+import tech.easyflow.dataspace.model.DataspaceView;
+import tech.easyflow.dataspace.service.DataspaceService;
+
+/**
+ * 虚拟数据空间管理端 API。
+ */
+@RestController
+@RequestMapping("/api/v1/dataspace")
+public class DataspaceController {
+
+    private final DataspaceService dataspaceService;
+
+    /**
+     * 创建数据空间控制器。
+     *
+     * @param dataspaceService 数据空间服务
+     */
+    public DataspaceController(DataspaceService dataspaceService) {
+        this.dataspaceService = dataspaceService;
+    }
+
+    /**
+     * 查询数据空间列表。
+     *
+     * @param keyword 搜索关键词
+     * @return 数据空间摘要
+     */
+    @GetMapping("/list")
+    @SaCheckPermission("/api/v1/dataspace/query")
+    public Result<List<DataspaceSummary>> list(String keyword) {
+        return Result.ok(dataspaceService.list(keyword));
+    }
+
+    /**
+     * 获取数据空间当前 revision 详情。
+     *
+     * @param id 数据空间 ID
+     * @return 数据空间详情
+     */
+    @GetMapping("/detail")
+    @SaCheckPermission("/api/v1/dataspace/detail")
+    public Result<DataspaceView> detail(BigInteger id) {
+        return Result.ok(dataspaceService.detail(id));
+    }
+
+    /**
+     * 保存数据空间并生成新 revision。
+     *
+     * @param definition 数据空间定义
+     * @return 保存后的详情
+     */
+    @PostMapping("/save")
+    @SaCheckPermission("/api/v1/dataspace/save")
+    public Result<DataspaceView> save(
+            @RequestBody DataspaceDefinition definition) {
+        return Result.ok(dataspaceService.save(definition));
+    }
+
+    /**
+     * 启用或禁用数据空间。
+     *
+     * @param request 状态变更请求
+     * @return 成功结果
+     */
+    @PostMapping("/status")
+    @SaCheckPermission("/api/v1/dataspace/save")
+    public Result<Void> status(
+            @JsonBody(required = true, skipConvertError = false) StatusRequest request) {
+        if (request == null || request.enabled() == null) {
+            throw new BusinessException("数据空间状态不能为空");
+        }
+        dataspaceService.setEnabled(request.id(), request.enabled());
+        return Result.ok();
+    }
+
+    /**
+     * 逻辑删除数据空间。
+     *
+     * @param id 数据空间 ID
+     * @return 成功结果
+     */
+    @PostMapping("/remove")
+    @SaCheckPermission("/api/v1/dataspace/remove")
+    public Result<Void> remove(
+            @JsonBody(value = "id", required = true, skipConvertError = false) BigInteger id) {
+        dataspaceService.remove(id);
+        return Result.ok();
+    }
+
+    /**
+     * 数据空间状态变更请求。
+     *
+     * @param id 数据空间 ID
+     * @param enabled 是否启用
+     */
+    public record StatusRequest(BigInteger id, Boolean enabled) {
+    }
+}

easyflow-api/easyflow-api-admin/src/main/java/tech/easyflow/admin/controller/dataspace/DataspaceSqlController.java

@@ -0,0 +1,86 @@
+package tech.easyflow.admin.controller.dataspace;
+
+import cn.dev33.satoken.annotation.SaCheckPermission;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import tech.easyflow.common.domain.Result;
+import tech.easyflow.common.web.jsonbody.JsonBody;
+import tech.easyflow.dataspace.model.DataspaceExplainResult;
+import tech.easyflow.dataspace.model.DataspaceQueryRequest;
+import tech.easyflow.dataspace.model.DataspaceQueryResult;
+import tech.easyflow.dataspace.model.DataspaceSqlCompletionRequest;
+import tech.easyflow.dataspace.model.DataspaceSqlCompletionResult;
+import tech.easyflow.dataspace.service.DataspaceQueryService;
+
+/**
+ * 数据空间 SQL 工作台 Query、Explain、Complete 与 Cancel API。
+ */
+@RestController
+@RequestMapping("/api/v1/dataspaceSql")
+public class DataspaceSqlController {
+
+    private final DataspaceQueryService queryService;
+
+    /**
+     * 创建 SQL 控制器。
+     *
+     * @param queryService 查询服务
+     */
+    public DataspaceSqlController(DataspaceQueryService queryService) {
+        this.queryService = queryService;
+    }
+
+    /**
+     * 执行只读 SQL。
+     *
+     * @param request 查询请求
+     * @return 查询结果与指标
+     */
+    @PostMapping("/query")
+    @SaCheckPermission("/api/v1/dataspaceSql/query")
+    public Result<DataspaceQueryResult> query(
+            @JsonBody(required = true, skipConvertError = false) DataspaceQueryRequest request) {
+        return Result.ok(queryService.query(request));
+    }
+
+    /**
+     * 显式执行非 ANALYZE Explain。
+     *
+     * @param request Explain 请求
+     * @return Explain 与索引信息
+     */
+    @PostMapping("/explain")
+    @SaCheckPermission("/api/v1/dataspaceSql/explain")
+    public Result<DataspaceExplainResult> explain(
+            @JsonBody(required = true, skipConvertError = false) DataspaceQueryRequest request) {
+        return Result.ok(queryService.explain(request));
+    }
+
+    /**
+     * 返回当前数据空间内的 Calcite SQL 补全候选。
+     *
+     * @param request 补全请求
+     * @return 补全替换区间与候选
+     */
+    @PostMapping("/complete")
+    @SaCheckPermission("/api/v1/dataspaceSql/query")
+    public Result<DataspaceSqlCompletionResult> complete(
+            @JsonBody(required = true, skipConvertError = false)
+            DataspaceSqlCompletionRequest request) {
+        return Result.ok(queryService.complete(request));
+    }
+
+    /**
+     * 尝试取消当前节点查询。
+     *
+     * @param queryId 查询 ID
+     * @return 是否找到并发起取消
+     */
+    @PostMapping("/cancel")
+    @SaCheckPermission("/api/v1/dataspaceSql/query")
+    public Result<Boolean> cancel(
+            @JsonBody(value = "queryId", required = true, skipConvertError = false) String queryId) {
+        return Result.ok(queryService.cancel(queryId));
+    }
+}

easyflow-api/easyflow-api-admin/src/main/java/tech/easyflow/admin/controller/job/SysJobController.java

@@ -1,26 +1,31 @@
 package tech.easyflow.admin.controller.job;
 
 import cn.dev33.satoken.annotation.SaCheckPermission;
-import cn.hutool.core.date.DateUtil;
 import com.easyagents.flow.core.chain.Parameter;
 import com.mybatisflex.core.query.QueryWrapper;
-import org.quartz.CronExpression;
+import org.springframework.beans.factory.annotation.Value;
 import org.springframework.util.StringUtils;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
 import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 import tech.easyflow.ai.easyagentsflow.service.WorkflowRunningParameterResolver;
 import tech.easyflow.ai.entity.Workflow;
+import tech.easyflow.ai.enums.PublishStatus;
 import tech.easyflow.ai.service.WorkflowService;
 import tech.easyflow.ai.service.WorkflowUsageAuthorizationService;
 import tech.easyflow.admin.model.SysJobWorkflowOptionView;
-import tech.easyflow.common.constant.enums.EnumDataStatus;
+import tech.easyflow.common.constant.enums.EnumJobStatus;
 import tech.easyflow.common.constant.enums.EnumJobType;
+import tech.easyflow.common.constant.enums.EnumMisfirePolicy;
 import tech.easyflow.common.domain.Result;
 import tech.easyflow.common.entity.LoginAccount;
 import tech.easyflow.common.satoken.util.SaTokenUtil;
 import tech.easyflow.common.web.controller.BaseCurdController;
 import tech.easyflow.common.web.exceptions.BusinessException;
+import tech.easyflow.common.web.jsonbody.JsonBody;
 import tech.easyflow.job.entity.SysJob;
 import tech.easyflow.job.job.JobConstant;
 import tech.easyflow.job.service.SysJobService;
@@ -32,7 +37,8 @@ import tech.easyflow.system.service.ResourceAccessService;
 
 import java.io.Serializable;
 import java.math.BigInteger;
-import java.util.ArrayList;
+import java.time.ZoneId;
+import java.time.format.DateTimeFormatter;
 import java.util.Collection;
 import java.util.Date;
 import java.util.List;
@@ -61,6 +67,9 @@ public class SysJobController extends BaseCurdController<SysJobService, SysJob>
     /** 工作流运行参数解析器。 */
     private final WorkflowRunningParameterResolver workflowRunningParameterResolver;
 
+    /** 与调度计算一致的 Cron 预览格式化器。 */
+    private final DateTimeFormatter jobTimeFormatter;
+
     /**
      * 创建定时任务控制器。
      *
@@ -69,17 +78,21 @@ public class SysJobController extends BaseCurdController<SysJobService, SysJob>
      * @param workflowUsageAuthorizationService 工作流使用权限校验服务
      * @param resourceAccessService 资源访问控制服务
      * @param workflowRunningParameterResolver 工作流运行参数解析器
+     * @param jobTimezone 定时任务业务时区
      */
     public SysJobController(SysJobService service,
                             WorkflowService workflowService,
                             WorkflowUsageAuthorizationService workflowUsageAuthorizationService,
                             ResourceAccessService resourceAccessService,
-                            WorkflowRunningParameterResolver workflowRunningParameterResolver) {
+                            WorkflowRunningParameterResolver workflowRunningParameterResolver,
+                            @Value("${easyflow.job.timezone:Asia/Shanghai}") String jobTimezone) {
         super(service);
         this.workflowService = workflowService;
         this.workflowUsageAuthorizationService = workflowUsageAuthorizationService;
         this.resourceAccessService = resourceAccessService;
         this.workflowRunningParameterResolver = workflowRunningParameterResolver;
+        this.jobTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")
+                .withZone(ZoneId.of(jobTimezone));
     }
 
     /**
@@ -111,18 +124,43 @@ public class SysJobController extends BaseCurdController<SysJobService, SysJob>
         return Result.ok();
     }
 
+    @GetMapping("/trigger")
+    @SaCheckPermission("/api/v1/sysJob/save")
+    @LogRecord("立即执行定时任务")
+    public Result<String> trigger(BigInteger id) {
+        LoginAccount account = SaTokenUtil.getLoginAccount();
+        SysJob job = requireExistingJob(id);
+        validateWorkflowReference(job, account);
+        return Result.ok(service.triggerNow(id));
+    }
+
     @GetMapping("/getNextTimes")
     @SaCheckPermission("/api/v1/sysJob/save")
-    public Result<List<String>> getNextTimes(String cronExpression) throws  Exception{
+    public Result<List<String>> getNextTimes(String cronExpression) {
-        CronExpression ex = new CronExpression(cronExpression);
+        return Result.ok(service.nextFireTimes(cronExpression, 5).stream()
-        List<String> times = new ArrayList<>();
+                .map(Date::toInstant)
-        Date date = new Date();
+                .map(jobTimeFormatter::format)
-        for (int i = 0; i < 5; i++) {
+                .toList());
-            Date next = ex.getNextValidTimeAfter(date);
-            times.add(DateUtil.formatDateTime(next));
-            date = next;
     }
-        return Result.ok(times);
+
+    @Override
+    @PostMapping("remove")
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+    public Result<?> remove(@JsonBody(value = "id", required = true) Serializable id) {
+        service.deleteJob(List.of(id));
+        return Result.ok(true);
+    }
+
+    @Override
+    @PostMapping("removeBatch")
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+    public Result<?> removeBatch(
+            @JsonBody(value = "ids", required = true) Collection<Serializable> ids) {
+        if (ids == null || ids.isEmpty()) {
+            return Result.fail("id不能为空");
+        }
+        service.deleteJob(ids);
+        return Result.ok(true);
     }
 
     /**
@@ -136,15 +174,19 @@ public class SysJobController extends BaseCurdController<SysJobService, SysJob>
         LoginAccount account = SaTokenUtil.getLoginAccount();
         List<SysJobWorkflowOptionView> options = workflowService.list(QueryWrapper.create()
                 .eq(Workflow::getTenantId, account.getTenantId())
-                        .eq(Workflow::getStatus, EnumDataStatus.AVAILABLE.getCode())
+                        .eq(Workflow::getPublishStatus, PublishStatus.PUBLISHED.getCode())
                         .orderBy(Workflow::getModified, false))
                 .stream()
                 .filter(workflow -> Objects.equals(workflow.getTenantId(), account.getTenantId()))
+                .filter(workflow -> workflow.getPublishedSnapshotJson() != null
+                        && !workflow.getPublishedSnapshotJson().isEmpty())
                 .filter(workflow -> resourceAccessService.canAccess(
                         account,
                         CategoryResourceType.WORKFLOW,
                         workflow,
                         ResourceAction.USE))
+                .map(workflowService::toPublishedView)
+                .filter(Objects::nonNull)
                 .map(workflow -> new SysJobWorkflowOptionView(
                         workflow.getId(),
                         workflow.getTitle(),
@@ -166,7 +208,7 @@ public class SysJobController extends BaseCurdController<SysJobService, SysJob>
         Workflow workflow = workflowUsageAuthorizationService.requireUsableWorkflow(
                 id,
                 SaTokenUtil.getLoginAccount(),
-                "工作流不存在、已禁用或无权运行");
+                "工作流不存在、未发布或无权运行");
         Map<String, Object> result = workflowRunningParameterResolver.buildRunningParametersView(workflow);
         if (result == null) {
             throw new BusinessException("工作流参数配置无效，请检查工作流后重试");
@@ -182,6 +224,9 @@ public class SysJobController extends BaseCurdController<SysJobService, SysJob>
         LoginAccount loginUser = SaTokenUtil.getLoginAccount();
         SysJob effectiveEntity = entity;
         if (isSave) {
+            // 新任务固定从 STOP 和第 0 代开始，禁止请求绕过启动协议。
+            entity.setStatus(EnumJobStatus.STOP.getCode());
+            entity.setScheduleGeneration(0L);
             commonFiled(entity,loginUser.getId(),loginUser.getTenantId(), loginUser.getDeptId());
         } else {
             SysJob existing = requireExistingJob(entity.getId());
@@ -191,9 +236,25 @@ public class SysJobController extends BaseCurdController<SysJobService, SysJob>
             entity.setModifiedBy(loginUser.getId());
         }
         validateWorkflowReference(effectiveEntity, loginUser);
+        validateCronExpression(effectiveEntity.getCronExpression());
+        validateMisfirePolicy(effectiveEntity.getMisfirePolicy());
         return super.onSaveOrUpdateBefore(entity, isSave);
     }
 
+    @Override
+    protected void onSaveOrUpdateAfter(SysJob entity, boolean isSave) {
+        service.syncJob(entity.getId());
+    }
+
+    @Override
+    @PostMapping("update")
+    public Result<?> update(@JsonBody SysJob entity) {
+        Result<?> result = onSaveOrUpdateBefore(entity, false);
+        if (result != null) return result;
+        service.updateJobDefinition(entity);
+        return Result.ok();
+    }
+
     /**
      * 校验工作流类型任务引用的工作流可被当前用户运行。
      *
@@ -210,7 +271,7 @@ public class SysJobController extends BaseCurdController<SysJobService, SysJob>
         Workflow workflow = workflowUsageAuthorizationService.requireUsableWorkflow(
                 workflowId,
                 account,
-                "工作流不存在、已禁用或无权运行");
+                "工作流不存在、未发布或无权运行");
         validateRequiredWorkflowParams(entity, workflow);
     }
 
@@ -243,6 +304,8 @@ public class SysJobController extends BaseCurdController<SysJobService, SysJob>
         entity.setDeptId(existing.getDeptId());
         entity.setCreated(existing.getCreated());
         entity.setCreatedBy(existing.getCreatedBy());
+        entity.setStatus(existing.getStatus());
+        entity.setScheduleGeneration(existing.getScheduleGeneration());
     }
 
     /**
@@ -260,9 +323,30 @@ public class SysJobController extends BaseCurdController<SysJobService, SysJob>
         effective.setJobParams(entity.getJobParams() == null
                 ? existing.getJobParams()
                 : entity.getJobParams());
+        effective.setCronExpression(entity.getCronExpression() == null
+                ? existing.getCronExpression()
+                : entity.getCronExpression());
+        effective.setMisfirePolicy(entity.getMisfirePolicy() == null
+                ? existing.getMisfirePolicy()
+                : entity.getMisfirePolicy());
         return effective;
     }
 
+    private void validateMisfirePolicy(Integer misfirePolicy) {
+        if (!Integer.valueOf(EnumMisfirePolicy.FIRE_ONCE_NOW.getCode()).equals(misfirePolicy)
+                && !Integer.valueOf(EnumMisfirePolicy.SKIP.getCode()).equals(misfirePolicy)) {
+            throw new BusinessException("错过策略只支持恢复后补执行一次或跳过本次");
+        }
+    }
+
+    private void validateCronExpression(String cronExpression) {
+        try {
+            service.nextFireTimes(cronExpression, 1);
+        } catch (RuntimeException exception) {
+            throw new BusinessException(400, 1, "Cron 表达式无效", exception);
+        }
+    }
+
     /**
      * 校验定时任务已填写工作流的全部必填运行参数。
      *
@@ -322,9 +406,4 @@ public class SysJobController extends BaseCurdController<SysJobService, SysJob>
         return true;
     }
 
-    @Override
-    protected Result onRemoveBefore(Collection<Serializable> ids) {
-        service.deleteJob(ids);
-        return super.onRemoveBefore(ids);
-    }
 }

easyflow-api/easyflow-api-admin/src/main/java/tech/easyflow/admin/controller/job/SysJobLogController.java

@@ -1,15 +1,29 @@
 package tech.easyflow.admin.controller.job;
 
-import tech.easyflow.common.annotation.UsePermission;
+import com.mybatisflex.core.paginate.Page;
-import tech.easyflow.common.domain.Result;
+import com.mybatisflex.core.query.QueryWrapper;
-import tech.easyflow.common.satoken.util.SaTokenUtil;
+import jakarta.servlet.http.HttpServletRequest;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
-import tech.easyflow.common.entity.LoginAccount;
+import tech.easyflow.common.annotation.UsePermission;
+import tech.easyflow.common.domain.Result;
+import tech.easyflow.common.util.StringUtil;
 import tech.easyflow.common.web.controller.BaseCurdController;
+import tech.easyflow.common.web.exceptions.BusinessException;
 import tech.easyflow.job.entity.SysJobLog;
 import tech.easyflow.job.service.SysJobLogService;
 
+import java.io.Serializable;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.format.DateTimeFormatter;
+import java.time.format.DateTimeParseException;
+import java.util.Collection;
+import java.util.Date;
+import java.util.List;
+
 /**
  * 系统任务日志 控制层。
  *
@@ -20,16 +34,112 @@ import tech.easyflow.job.service.SysJobLogService;
 @RequestMapping("/api/v1/sysJobLog")
 @UsePermission(moduleName = "/api/v1/sysJob")
 public class SysJobLogController extends BaseCurdController<SysJobLogService, SysJobLog> {
-    public SysJobLogController(SysJobLogService service) {
+    private static final long DEFAULT_PAGE_SIZE = 10L;
+    private static final long MAX_PAGE_SIZE = 100L;
+    private static final DateTimeFormatter QUERY_TIME_FORMATTER =
+            DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
+
+    private final ZoneId jobZoneId;
+
+    public SysJobLogController(
+            SysJobLogService service,
+            @Value("${easyflow.job.timezone:Asia/Shanghai}") String jobTimezone) {
         super(service);
+        this.jobZoneId = ZoneId.of(jobTimezone);
+    }
+
+    /**
+     * 构造日志筛选条件，并追加计划触发时间和实际触发时间范围。
+     */
+    @Override
+    protected QueryWrapper buildQueryWrapper(HttpServletRequest request) {
+        QueryWrapper queryWrapper = super.buildQueryWrapper(request);
+        Date scheduledStart = parseQueryTime(
+                request.getParameter("scheduledStart"), "计划触发开始时间");
+        Date scheduledEnd = parseQueryTime(
+                request.getParameter("scheduledEnd"), "计划触发结束时间");
+        Date actualStart = parseQueryTime(
+                request.getParameter("actualStart"), "实际触发开始时间");
+        Date actualEnd = parseQueryTime(
+                request.getParameter("actualEnd"), "实际触发结束时间");
+
+        validateTimeRange(scheduledStart, scheduledEnd, "计划触发时间");
+        validateTimeRange(actualStart, actualEnd, "实际触发时间");
+        if (scheduledStart != null) {
+            queryWrapper.ge(SysJobLog::getScheduledFireTime, scheduledStart);
+        }
+        if (scheduledEnd != null) {
+            queryWrapper.le(SysJobLog::getScheduledFireTime, scheduledEnd);
+        }
+        if (actualStart != null) {
+            queryWrapper.ge(SysJobLog::getActualFireTime, actualStart);
+        }
+        if (actualEnd != null) {
+            queryWrapper.le(SysJobLog::getActualFireTime, actualEnd);
+        }
+        return queryWrapper;
+    }
+
+    /**
+     * 自动刷新只读取当前第一页，不执行分页总数统计。
+     */
+    @GetMapping("refresh")
+    public Result<List<SysJobLog>> refresh(HttpServletRequest request, Long pageSize) {
+        QueryWrapper queryWrapper = buildQueryWrapper(request);
+        queryWrapper.orderBy(buildOrderBy(null, null, getDefaultOrderBy()));
+        queryWrapper.limit(resolvePageSize(pageSize));
+        return Result.ok(service.list(queryWrapper));
+    }
+
+    /**
+     * 最新计划触发记录优先，并用主键保证毫秒时间相同时顺序稳定。
+     */
+    @Override
+    protected String getDefaultOrderBy() {
+        return "scheduled_fire_time desc, id desc";
+    }
+
+    @Override
+    protected Page<SysJobLog> queryPage(
+            Page<SysJobLog> page, QueryWrapper queryWrapper) {
+        page.setPageSize(resolvePageSize(page.getPageSize()));
+        return super.queryPage(page, queryWrapper);
     }
 
     @Override
     protected Result onSaveOrUpdateBefore(SysJobLog entity, boolean isSave) {
-        LoginAccount loginUser = SaTokenUtil.getLoginAccount();
+        throw new IllegalStateException("定时任务执行记录由系统维护，禁止外部写入");
-        if (isSave) {
+    }
-            commonFiled(entity,loginUser.getId(),loginUser.getTenantId(), loginUser.getDeptId());
+
+    @Override
+    protected Result onRemoveBefore(Collection<Serializable> ids) {
+        service.requireTerminal(ids);
+        return super.onRemoveBefore(ids);
+    }
+
+    private long resolvePageSize(Long pageSize) {
+        if (pageSize == null || pageSize < 1) {
+            return DEFAULT_PAGE_SIZE;
+        }
+        return Math.min(pageSize, MAX_PAGE_SIZE);
+    }
+
+    private Date parseQueryTime(String value, String fieldName) {
+        if (!StringUtil.hasText(value)) {
+            return null;
+        }
+        try {
+            LocalDateTime dateTime = LocalDateTime.parse(value, QUERY_TIME_FORMATTER);
+            return Date.from(dateTime.atZone(jobZoneId).toInstant());
+        } catch (DateTimeParseException exception) {
+            throw new BusinessException(
+                    400, 400, fieldName + "格式不正确", exception);
+        }
+    }
+
+    private void validateTimeRange(Date start, Date end, String fieldName) {
+        if (start != null && end != null && start.after(end)) {
+            throw new BusinessException(400, 400, fieldName + "范围不正确");
         }
-        return super.onSaveOrUpdateBefore(entity, isSave);
     }
 }

easyflow-api/easyflow-api-admin/src/main/java/tech/easyflow/admin/model/ai/WorkflowDesignerOptionsView.java

@@ -52,17 +52,11 @@ public record WorkflowDesignerOptionsView(
      * @param id 知识库 ID
      * @param title 知识库标题
      * @param description 知识库描述
-     * @param vectorEmbedModelId Embedding 模型 ID
-     * @param dimensionOfVectorModel 向量维度
-     * @param vectorStoreEnabled 是否可用于向量检索
      */
     public record KnowledgeOption(
             @JsonSerialize(using = ToStringSerializer.class) BigInteger id,
             String title,
-            String description,
+            String description
-            @JsonSerialize(using = ToStringSerializer.class) BigInteger vectorEmbedModelId,
-            Integer dimensionOfVectorModel,
-            Boolean vectorStoreEnabled
     ) {
     }
 
@@ -132,6 +126,7 @@ public record WorkflowDesignerOptionsView(
      * 已接入数据集安全选项。
      *
      * @param id 数据集 ID
+     * @param tenantId 租户 ID
      * @param sourceId 数据源 ID
      * @param catalogId 目录 ID
      * @param tableName 数据表名称
@@ -139,6 +134,7 @@ public record WorkflowDesignerOptionsView(
      */
     public record DatasetOption(
             @JsonSerialize(using = ToStringSerializer.class) BigInteger id,
+            @JsonSerialize(using = ToStringSerializer.class) BigInteger tenantId,
             @JsonSerialize(using = ToStringSerializer.class) BigInteger sourceId,
             @JsonSerialize(using = ToStringSerializer.class) BigInteger catalogId,
             String tableName,

easyflow-api/easyflow-api-admin/src/main/java/tech/easyflow/admin/service/ai/WorkflowDesignerOptionService.java

@@ -14,7 +14,6 @@ import com.mybatisflex.core.query.QueryWrapper;
 import org.springframework.stereotype.Service;
 import tech.easyflow.admin.model.ai.WorkflowDesignerOptionsView;
 import tech.easyflow.ai.easyagentsflow.service.WorkflowDatacenterContentService;
-import tech.easyflow.ai.easyagentsflow.knowledge.WorkflowKnowledgeContractService;
 import tech.easyflow.ai.entity.DocumentCollection;
 import tech.easyflow.ai.entity.Model;
 import tech.easyflow.ai.entity.ModelProvider;
@@ -76,7 +75,6 @@ public class WorkflowDesignerOptionService {
     private final DatacenterSourceService datacenterSourceService;
     private final DatacenterDatasetRegistryService datacenterDatasetRegistryService;
     private final DatacenterDatasetQueryService datacenterDatasetQueryService;
-    private final WorkflowKnowledgeContractService workflowKnowledgeContractService;
 
     /**
      * 创建工作流设计器选项服务。
@@ -95,7 +93,6 @@ public class WorkflowDesignerOptionService {
      * @param datacenterSourceService 数据源服务
      * @param datacenterDatasetRegistryService 数据集注册服务
      * @param datacenterDatasetQueryService 数据集查询服务
-     * @param workflowKnowledgeContractService 工作流知识库契约服务
      */
     public WorkflowDesignerOptionService(
             ModelService modelService,
@@ -111,8 +108,7 @@ public class WorkflowDesignerOptionService {
             ResourceAccessService resourceAccessService,
             DatacenterSourceService datacenterSourceService,
             DatacenterDatasetRegistryService datacenterDatasetRegistryService,
-            DatacenterDatasetQueryService datacenterDatasetQueryService,
+            DatacenterDatasetQueryService datacenterDatasetQueryService) {
-            WorkflowKnowledgeContractService workflowKnowledgeContractService) {
         this.modelService = modelService;
         this.documentCollectionService = documentCollectionService;
         this.pluginService = pluginService;
@@ -127,7 +123,6 @@ public class WorkflowDesignerOptionService {
         this.datacenterSourceService = datacenterSourceService;
         this.datacenterDatasetRegistryService = datacenterDatasetRegistryService;
         this.datacenterDatasetQueryService = datacenterDatasetQueryService;
-        this.workflowKnowledgeContractService = workflowKnowledgeContractService;
     }
 
     /**
@@ -168,7 +163,6 @@ public class WorkflowDesignerOptionService {
         LoginAccount account = requireAccount();
         Set<BigInteger> modelIds = new HashSet<>();
         Set<BigInteger> knowledgeIds = new HashSet<>();
-        List<List<BigInteger>> knowledgeGroups = new ArrayList<>();
         Set<BigInteger> checkedPluginItemIds = new HashSet<>();
         Set<BigInteger> checkedWorkflowIds = new HashSet<>();
         Set<BigInteger> checkedSourceIds = new HashSet<>();
@@ -183,22 +177,14 @@ public class WorkflowDesignerOptionService {
             if (data == null) {
                 continue;
             }
-            String nodeType = node.getString("type");
+            String nodeType = data.getString("type");
-            String dataType = data.getString("type");
-            if (nodeType != null && !nodeType.isBlank()
-                    && dataType != null && !dataType.isBlank()
-                    && !Objects.equals(nodeType, dataType)) {
-                throw new BusinessException("工作流节点类型与节点数据类型不一致");
-            }
             if (nodeType == null || nodeType.isBlank()) {
-                nodeType = dataType;
+                nodeType = node.getString("type");
             }
             if ("llmNode".equals(nodeType)) {
                 addReferenceId(modelIds, readReferenceId(data, "llmId", "模型"));
             } else if ("knowledgeNode".equals(nodeType)) {
-                List<BigInteger> nodeKnowledgeIds = readKnowledgeReferenceIds(data);
+                addReferenceId(knowledgeIds, readReferenceId(data, "knowledgeId", "知识库"));
-                knowledgeIds.addAll(nodeKnowledgeIds);
-                knowledgeGroups.add(nodeKnowledgeIds);
             } else if ("plugin-node".equals(nodeType)) {
                 BigInteger pluginItemId = readReferenceId(data, "pluginId", "插件工具");
                 if (pluginItemId != null && checkedPluginItemIds.add(pluginItemId)) {
@@ -212,8 +198,6 @@ public class WorkflowDesignerOptionService {
         }
         assertModelReferences(modelIds, account);
         assertKnowledgeReferences(knowledgeIds, account);
-        workflowKnowledgeContractService.assertMultiKnowledgeContracts(
-                knowledgeGroups, account.getTenantId());
     }
 
     /**
@@ -334,7 +318,7 @@ public class WorkflowDesignerOptionService {
         Workflow workflow = workflowUsageAuthorizationService.requireUsableWorkflow(
                 childWorkflowId,
                 account,
-                "子流程不存在、已禁用或无权使用");
+                "子流程不存在、未发布或无权使用");
         assertContentReferences(workflow.getContent());
 
         ChainDefinition definition = chainParser.parse(
@@ -476,55 +460,17 @@ public class WorkflowDesignerOptionService {
     }
 
     private List<WorkflowDesignerOptionsView.KnowledgeOption> listKnowledgeOptions(LoginAccount account) {
-        List<DocumentCollection> collections = documentCollectionService.list(QueryWrapper.create()
+        return documentCollectionService.list(QueryWrapper.create()
                         .eq(DocumentCollection::getTenantId, account.getTenantId())
-                        .orderBy(DocumentCollection::getModified, false));
+                        .orderBy(DocumentCollection::getModified, false))
-        Set<BigInteger> vectorReadyIds = workflowKnowledgeContractService
+                .stream()
-                .findVectorReadyKnowledgeIds(collections, account.getTenantId());
-        return collections.stream()
                 .filter(item -> resourceAccessService.canAccess(
                         account, CategoryResourceType.KNOWLEDGE, item, ResourceAction.USE))
                 .map(item -> new WorkflowDesignerOptionsView.KnowledgeOption(
-                        item.getId(),
+                        item.getId(), item.getTitle(), item.getDescription()))
-                        item.getTitle(),
-                        item.getDescription(),
-                        item.getVectorEmbedModelId(),
-                        item.getDimensionOfVectorModel(),
-                        vectorReadyIds.contains(item.getId())))
                 .toList();
     }
 
-    private List<BigInteger> readKnowledgeReferenceIds(JSONObject data) {
-        if (data.containsKey("knowledgeIds")) {
-            Object rawIds = data.get("knowledgeIds");
-            if (!(rawIds instanceof JSONArray ids) || ids.isEmpty()) {
-                throw new BusinessException("知识库节点至少需要选择一个知识库");
-            }
-            List<BigInteger> result = new ArrayList<>();
-            for (Object id : ids) {
-                BigInteger parsed = parseReferenceId(id, "知识库");
-                if (result.contains(parsed)) {
-                    throw new BusinessException("知识库节点不能重复选择同一知识库");
-                }
-                result.add(parsed);
-            }
-            return result;
-        }
-        BigInteger legacyId = readReferenceId(data, "knowledgeId", "知识库");
-        return legacyId == null ? List.of() : List.of(legacyId);
-    }
-
-    private BigInteger parseReferenceId(Object value, String resourceName) {
-        if (value == null || String.valueOf(value).isBlank()) {
-            throw new BusinessException(resourceName + "ID不能为空");
-        }
-        try {
-            return new BigInteger(String.valueOf(value));
-        } catch (NumberFormatException exception) {
-            throw new BusinessException(resourceName + "ID无效");
-        }
-    }
-
     private void addReferenceId(Set<BigInteger> resourceIds, BigInteger resourceId) {
         if (resourceId != null) {
             resourceIds.add(resourceId);
@@ -572,7 +518,7 @@ public class WorkflowDesignerOptionService {
         workflowUsageAuthorizationService.requireUsableWorkflow(
                 workflowId,
                 account,
-                "子流程不存在、已禁用或无权使用");
+                "子流程不存在、未发布或无权使用");
     }
 
     private void assertDatasetReference(
@@ -707,6 +653,7 @@ public class WorkflowDesignerOptionService {
     private WorkflowDesignerOptionsView.DatasetOption toDatasetOption(DatacenterTable table) {
         return new WorkflowDesignerOptionsView.DatasetOption(
                 table.getId(),
+                table.getTenantId(),
                 table.getSourceId(),
                 table.getCatalogId(),
                 table.getTableName(),

easyflow-api/easyflow-api-admin/src/main/java/tech/easyflow/admin/service/ai/WorkflowPublicChatService.java

@@ -13,7 +13,6 @@ import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;
 import tech.easyflow.ai.easyagentsflow.entity.WorkflowCheckStage;
 import tech.easyflow.ai.easyagentsflow.service.WorkflowCheckService;
 import tech.easyflow.ai.easyagentsflow.service.WorkflowRunningParameterResolver;
-import tech.easyflow.ai.easyagentsflow.service.WorkflowResumeService;
 import tech.easyflow.ai.easyagentsflow.support.PublishedWorkflowDefinitionIds;
 import tech.easyflow.ai.entity.WorkflowExecResult;
 import tech.easyflow.ai.entity.WorkflowExecStep;
@@ -47,7 +46,6 @@ public class WorkflowPublicChatService {
     private final WorkflowPublicChatAccessGuard accessGuard;
     private final WorkflowChatEventStream eventStream;
     private final ChainExecutor chainExecutor;
-    private final WorkflowResumeService workflowResumeService;
     private final WorkflowExecResultService execResultService;
     private final WorkflowExecStepService execStepService;
 
@@ -59,7 +57,6 @@ public class WorkflowPublicChatService {
             WorkflowPublicChatAccessGuard accessGuard,
             WorkflowChatEventStream eventStream,
             ChainExecutor chainExecutor,
-            WorkflowResumeService workflowResumeService,
             WorkflowExecResultService execResultService,
             WorkflowExecStepService execStepService
     ) {
@@ -70,7 +67,6 @@ public class WorkflowPublicChatService {
         this.accessGuard = accessGuard;
         this.eventStream = eventStream;
         this.chainExecutor = chainExecutor;
-        this.workflowResumeService = workflowResumeService;
         this.execResultService = execResultService;
         this.execStepService = execStepService;
     }
@@ -189,8 +185,17 @@ public class WorkflowPublicChatService {
     ) {
         WorkflowPublicChatContext context = contextResolver.resolveActive(
                 shareKey, visitorId);
-        assertExecutionOwnership(context, executeId);
+        WorkflowExecResult record = assertExecutionOwnership(
-        workflowResumeService.resume(executeId, confirmParams);
+                context, executeId);
+        if (isTerminal(record.getStatus())) {
+            throw new BusinessException("当前工作流执行已结束");
+        }
+        chainExecutor.resumeAsync(
+                executeId,
+                confirmParams == null
+                        ? new LinkedHashMap<>()
+                        : new LinkedHashMap<>(confirmParams)
+        );
     }
 
     /**
@@ -248,6 +253,13 @@ public class WorkflowPublicChatService {
         return record;
     }
 
+    private boolean isTerminal(Integer status) {
+        return status != null
+                && (status == ChainStatus.SUCCEEDED.getValue()
+                || status == ChainStatus.FAILED.getValue()
+                || status == ChainStatus.CANCELLED.getValue());
+    }
+
     private Map<String, Object> buildExecutionDetail(
             WorkflowExecResult record,
             List<WorkflowExecStep> steps,

easyflow-api/easyflow-api-admin/src/test/java/tech/easyflow/admin/controller/ai/DocumentChunkControllerContractTest.java

@@ -1,120 +0,0 @@
-package tech.easyflow.admin.controller.ai;
-
-import org.testng.Assert;
-import org.testng.annotations.Test;
-import org.springframework.web.bind.annotation.PostMapping;
-import tech.easyflow.ai.dto.DocumentChunkContentUpdateRequest;
-import tech.easyflow.ai.entity.DocumentChunk;
-import tech.easyflow.ai.service.DocumentChunkService;
-import tech.easyflow.common.web.controller.BaseController;
-import tech.easyflow.common.web.jsonbody.JsonBody;
-import tech.easyflow.system.permission.resource.RequireResourceAccess;
-
-import java.lang.reflect.Field;
-import java.lang.reflect.Method;
-import java.lang.reflect.Parameter;
-import java.math.BigInteger;
-import java.util.Arrays;
-import java.util.Set;
-import java.util.stream.Collectors;
-
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
-/**
- * 文档分块维护接口契约测试。
- */
-public class DocumentChunkControllerContractTest {
-
-    @Test
-    public void updateEndpointsShouldOnlyAcceptChunkIdAndContent() throws Exception {
-        Method adminUpdate = DocumentChunkController.class.getDeclaredMethod(
-            "update",
-            DocumentChunkContentUpdateRequest.class
-        );
-        Method shareUpdate = ShareKnowledgeController.class.getDeclaredMethod(
-            "updateDocumentChunk",
-            String.class,
-            DocumentChunkContentUpdateRequest.class
-        );
-
-        Assert.assertNotNull(adminUpdate);
-        Assert.assertNotNull(shareUpdate);
-        assertStrictJsonBody(adminUpdate.getParameters()[0]);
-        assertStrictJsonBody(shareUpdate.getParameters()[1]);
-        Assert.assertEquals(
-            adminUpdate.getAnnotation(RequireResourceAccess.class).idExpr(),
-            "#request.id"
-        );
-        Set<String> fields = Arrays.stream(
-                DocumentChunkContentUpdateRequest.class.getDeclaredFields()
-            )
-            .map(Field::getName)
-            .collect(Collectors.toSet());
-        Assert.assertEquals(Set.of("id", "content"), fields);
-        Assert.assertEquals(
-            DocumentChunkController.class.getMethod(
-                "update",
-                DocumentChunkContentUpdateRequest.class
-            ).getDeclaringClass(),
-            DocumentChunkController.class
-        );
-        Assert.assertEquals(
-            Arrays.stream(DocumentChunkController.class.getDeclaredMethods())
-                .filter(method -> method.getName().equals("update"))
-                .filter(method -> !method.isBridge() && !method.isSynthetic())
-                .count(),
-            1L
-        );
-    }
-
-    @Test
-    public void controllerShouldNotExposeGenericWriteEndpoints() {
-        Assert.assertEquals(DocumentChunkController.class.getSuperclass(), BaseController.class);
-        Set<String> postMappings = Arrays.stream(DocumentChunkController.class.getMethods())
-            .map(method -> method.getAnnotation(PostMapping.class))
-            .filter(annotation -> annotation != null)
-            .flatMap(annotation -> Arrays.stream(annotation.value()))
-            .collect(Collectors.toSet());
-
-        Assert.assertEquals(
-            postMappings,
-            Set.of("update", "removeChunk", "syncStatus", "retrySync")
-        );
-        Assert.assertFalse(postMappings.contains("save"));
-        Assert.assertFalse(postMappings.contains("remove"));
-        Assert.assertFalse(postMappings.contains("removeBatch"));
-    }
-
-    @Test
-    public void adminUpdateAndDeleteShouldUseUnifiedMaintenanceService() {
-        DocumentChunkService service = mock(DocumentChunkService.class);
-        DocumentChunkController controller = new DocumentChunkController(service);
-
-        DocumentChunk current = new DocumentChunk();
-        current.setId(BigInteger.ONE);
-        current.setDocumentCollectionId(BigInteger.TWO);
-        when(service.getById(BigInteger.ONE)).thenReturn(current);
-
-        DocumentChunkContentUpdateRequest request = new DocumentChunkContentUpdateRequest();
-        request.setId(BigInteger.ONE);
-        request.setContent("updated");
-        controller.update(request);
-        controller.removeChunk(BigInteger.ONE);
-
-        verify(service).updateContent(BigInteger.TWO, BigInteger.ONE, "updated");
-        verify(service).deleteChunk(BigInteger.TWO, BigInteger.ONE);
-        verify(service, never()).updateById(any(DocumentChunk.class));
-        verify(service, never()).removeById(any());
-    }
-
-    private static void assertStrictJsonBody(Parameter parameter) {
-        JsonBody jsonBody = parameter.getAnnotation(JsonBody.class);
-        Assert.assertNotNull(jsonBody);
-        Assert.assertTrue(jsonBody.required());
-        Assert.assertFalse(jsonBody.skipConvertError());
-    }
-}

easyflow-api/easyflow-api-admin/src/test/java/tech/easyflow/admin/controller/ai/PluginItemControllerTest.java

@@ -7,27 +7,21 @@ import org.testng.Assert;
 import org.testng.annotations.Test;
 import tech.easyflow.ai.entity.Plugin;
 import tech.easyflow.ai.entity.PluginItem;
-import tech.easyflow.ai.entity.WorkflowExecResult;
-import tech.easyflow.ai.easyagentsflow.service.WorkflowResumeService;
 import tech.easyflow.ai.service.AgentResourceReferenceService;
 import tech.easyflow.ai.service.PluginItemService;
 import tech.easyflow.ai.service.PluginService;
 import tech.easyflow.ai.service.PluginVisibilityService;
-import tech.easyflow.ai.service.WorkflowExecResultService;
 import tech.easyflow.common.entity.LoginAccount;
 import tech.easyflow.common.satoken.util.SaTokenUtil;
-import tech.easyflow.common.web.exceptions.BusinessException;
 
 import java.math.BigInteger;
 import java.util.List;
 import java.util.Locale;
-import java.util.Map;
 
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.mockStatic;
 import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoInteractions;
 import static org.mockito.Mockito.when;
 
 /**
@@ -74,61 +68,6 @@ public class PluginItemControllerTest {
         verify(visibilityService).assertPluginVisible(1L, BigInteger.TEN, "无权限删除该插件工具");
     }
 
-    /**
-     * 验证当前用户不能恢复其他用户发起的插件试运行实例。
-     */
-    @Test
-    public void testResumeShouldRejectAnotherUsersExecution() {
-        PluginItemService pluginItemService = mock(PluginItemService.class);
-        WorkflowExecResultService execResultService = mock(WorkflowExecResultService.class);
-        WorkflowResumeService resumeService = mock(WorkflowResumeService.class);
-        WorkflowExecResult record = new WorkflowExecResult();
-        record.setCreatedBy(BigInteger.ONE.toString());
-        when(execResultService.getByExecKey("execution-1")).thenReturn(record);
-
-        PluginItemController controller = new PluginItemController(pluginItemService);
-        setField(controller, "workflowExecResultService", execResultService);
-        setField(controller, "workflowResumeService", resumeService);
-        LoginAccount currentAccount = new LoginAccount();
-        currentAccount.setId(BigInteger.TWO);
-
-        try (MockedStatic<SaTokenUtil> login = mockStatic(SaTokenUtil.class)) {
-            login.when(SaTokenUtil::getLoginAccount).thenReturn(currentAccount);
-            BusinessException error = Assert.expectThrows(
-                    BusinessException.class,
-                    () -> controller.pluginToolTestResume("execution-1", Map.of())
-            );
-            Assert.assertEquals(error.getHttpStatus(), 403);
-            Assert.assertEquals(error.getErrorCode(), 403);
-        }
-        verifyNoInteractions(resumeService);
-    }
-
-    /**
-     * 验证当前用户可以恢复自己发起的插件试运行实例。
-     */
-    @Test
-    public void testResumeShouldAllowExecutionOwner() {
-        PluginItemService pluginItemService = mock(PluginItemService.class);
-        WorkflowExecResultService execResultService = mock(WorkflowExecResultService.class);
-        WorkflowResumeService resumeService = mock(WorkflowResumeService.class);
-        WorkflowExecResult record = new WorkflowExecResult();
-        record.setCreatedBy(BigInteger.ONE.toString());
-        when(execResultService.getByExecKey("execution-1")).thenReturn(record);
-
-        PluginItemController controller = new PluginItemController(pluginItemService);
-        setField(controller, "workflowExecResultService", execResultService);
-        setField(controller, "workflowResumeService", resumeService);
-        LoginAccount currentAccount = new LoginAccount();
-        currentAccount.setId(BigInteger.ONE);
-
-        try (MockedStatic<SaTokenUtil> login = mockStatic(SaTokenUtil.class)) {
-            login.when(SaTokenUtil::getLoginAccount).thenReturn(currentAccount);
-            controller.pluginToolTestResume("execution-1", Map.of("choice", "A"));
-        }
-        verify(resumeService).resume("execution-1", Map.of("choice", "A"));
-    }
-
     /**
      * 创建插件工具。
      *

easyflow-api/easyflow-api-admin/src/test/java/tech/easyflow/admin/controller/dataspace/DataspaceControllerContractTest.java

@@ -0,0 +1,77 @@
+package tech.easyflow.admin.controller.dataspace;
+
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertNotNull;
+import static org.testng.Assert.assertNull;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.testng.annotations.Test;
+import tech.easyflow.common.web.jsonbody.JsonBody;
+import tech.easyflow.dataspace.model.DataspaceDefinition;
+
+/**
+ * 数据空间管理接口请求绑定契约测试。
+ */
+public class DataspaceControllerContractTest {
+
+    /**
+     * 验证保存接口使用 Jackson 请求体绑定，避免嵌套定义残留为 JSONObject。
+     *
+     * @throws Exception 反射或 JSON 转换失败时抛出
+     */
+    @Test
+    public void shouldBindNestedDataspaceDefinitionWithJackson() throws Exception {
+        Method method = DataspaceController.class.getMethod(
+                "save", DataspaceDefinition.class);
+        Parameter parameter = method.getParameters()[0];
+        assertNotNull(parameter.getAnnotation(RequestBody.class));
+        assertNull(parameter.getAnnotation(JsonBody.class));
+
+        String request = """
+                {
+                  "name": "网点经营分析",
+                  "tables": [
+                    {
+                      "clientKey": "table:outlet",
+                      "objectId": "1001",
+                      "sourceAlias": "MYSQL_1",
+                      "schemaAlias": "MAIN",
+                      "tableAlias": "outlet",
+                      "positionX": 80,
+                      "positionY": 120
+                    },
+                    {
+                      "clientKey": "table:region",
+                      "objectId": "1002",
+                      "sourceAlias": "PG_1",
+                      "schemaAlias": "PUBLIC",
+                      "tableAlias": "outlet_region",
+                      "positionX": 420,
+                      "positionY": 120
+                    }
+                  ],
+                  "relations": [
+                    {
+                      "leftClientKey": "table:outlet",
+                      "rightClientKey": "table:region",
+                      "joinType": "INNER",
+                      "leftColumn": "institution_id",
+                      "rightColumn": "institution_id"
+                    }
+                  ]
+                }
+                """;
+
+        DataspaceDefinition definition = new ObjectMapper().readValue(
+                request, DataspaceDefinition.class);
+
+        assertEquals(2, definition.tables().size());
+        assertEquals("outlet", definition.tables().get(0).tableAlias());
+        assertEquals("outlet_region", definition.tables().get(1).tableAlias());
+        assertEquals(1, definition.relations().size());
+        assertEquals("institution_id", definition.relations().get(0).leftColumn());
+    }
+}

easyflow-api/easyflow-api-admin/src/test/java/tech/easyflow/admin/controller/job/SysJobControllerTest.java

@@ -1,26 +1,39 @@
 package tech.easyflow.admin.controller.job;
 
 import com.easyagents.flow.core.chain.Parameter;
+import com.mybatisflex.core.query.QueryWrapper;
+import org.mockito.ArgumentCaptor;
 import org.mockito.MockedStatic;
 import org.testng.Assert;
 import org.testng.annotations.Test;
 import tech.easyflow.ai.easyagentsflow.service.WorkflowRunningParameterResolver;
 import tech.easyflow.ai.entity.Workflow;
+import tech.easyflow.ai.enums.PublishStatus;
 import tech.easyflow.ai.service.WorkflowService;
 import tech.easyflow.ai.service.WorkflowUsageAuthorizationService;
+import tech.easyflow.admin.model.SysJobWorkflowOptionView;
 import tech.easyflow.common.constant.enums.EnumJobType;
+import tech.easyflow.common.constant.enums.EnumJobStatus;
+import tech.easyflow.common.constant.enums.EnumMisfirePolicy;
 import tech.easyflow.common.entity.LoginAccount;
 import tech.easyflow.common.satoken.util.SaTokenUtil;
 import tech.easyflow.common.web.exceptions.BusinessException;
 import tech.easyflow.job.entity.SysJob;
 import tech.easyflow.job.job.JobConstant;
 import tech.easyflow.job.service.SysJobService;
+import tech.easyflow.system.enums.CategoryResourceType;
+import tech.easyflow.system.enums.ResourceAction;
 import tech.easyflow.system.service.ResourceAccessService;
 
 import java.math.BigInteger;
+import java.time.Instant;
+import java.util.Date;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
+import java.util.TimeZone;
 
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.mockStatic;
 import static org.mockito.Mockito.verify;
@@ -31,6 +44,114 @@ import static org.mockito.Mockito.when;
  */
 public class SysJobControllerTest {
 
+    @Test
+    public void shouldQueryPublishedWorkflowOptionsAndReturnPublishedMetadata() {
+        BigInteger workflowId = BigInteger.valueOf(501);
+        LoginAccount account = account();
+        Workflow raw = new Workflow();
+        raw.setId(workflowId);
+        raw.setTenantId(account.getTenantId());
+        raw.setPublishStatus(PublishStatus.PUBLISHED.getCode());
+        raw.setPublishedSnapshotJson(Map.of("title", "发布标题"));
+        raw.setTitle("草稿标题");
+        Workflow withoutSnapshot = new Workflow();
+        withoutSnapshot.setId(BigInteger.valueOf(502));
+        withoutSnapshot.setTenantId(account.getTenantId());
+        withoutSnapshot.setPublishStatus(PublishStatus.PUBLISHED.getCode());
+        Workflow published = new Workflow();
+        published.setId(workflowId);
+        published.setTitle("发布标题");
+        published.setDescription("发布描述");
+        WorkflowService workflowService = mock(WorkflowService.class);
+        ResourceAccessService resourceAccessService = mock(ResourceAccessService.class);
+        when(workflowService.list(any(QueryWrapper.class)))
+                .thenReturn(List.of(raw, withoutSnapshot));
+        when(resourceAccessService.canAccess(
+                account,
+                CategoryResourceType.WORKFLOW,
+                raw,
+                ResourceAction.USE)).thenReturn(true);
+        when(workflowService.toPublishedView(raw)).thenReturn(published);
+        SysJobController controller = new SysJobController(
+                mock(SysJobService.class),
+                workflowService,
+                mock(WorkflowUsageAuthorizationService.class),
+                resourceAccessService,
+                mock(WorkflowRunningParameterResolver.class),
+                "Asia/Shanghai");
+
+        List<SysJobWorkflowOptionView> options;
+        try (MockedStatic<SaTokenUtil> saToken = mockStatic(SaTokenUtil.class)) {
+            saToken.when(SaTokenUtil::getLoginAccount).thenReturn(account);
+            options = controller.workflowOptions().getData();
+        }
+
+        Assert.assertEquals(options.size(), 1);
+        Assert.assertEquals(options.get(0).title(), "发布标题");
+        ArgumentCaptor<QueryWrapper> queryCaptor = ArgumentCaptor.forClass(QueryWrapper.class);
+        verify(workflowService).list(queryCaptor.capture());
+        String sql = queryCaptor.getValue().toSQL().toLowerCase(Locale.ROOT);
+        Assert.assertTrue(sql.contains("publish_status"));
+        Assert.assertFalse(sql.replace("publish_status", "").matches("(?s).*\\bstatus\\b.*"));
+    }
+
+    @Test
+    public void shouldFormatCronPreviewWithConfiguredTimezone() {
+        SysJobService service = mock(SysJobService.class);
+        when(service.nextFireTimes("0 0 9 * * ?", 5))
+            .thenReturn(List.of(Date.from(Instant.parse("2026-01-01T01:00:00Z"))));
+        TimeZone previous = TimeZone.getDefault();
+        try {
+            TimeZone.setDefault(TimeZone.getTimeZone("UTC"));
+            Assert.assertEquals(
+                controller(service).getNextTimes("0 0 9 * * ?").getData().get(0),
+                "2026-01-01 09:00:00");
+        } finally {
+            TimeZone.setDefault(previous);
+        }
+    }
+
+    @Test
+    public void shouldForceNewJobToStoppedGenerationZero() {
+        SysJobController controller = controller(mock(SysJobService.class));
+        SysJob job = validJavaJob();
+        job.setStatus(EnumJobStatus.RUNNING.getCode());
+        job.setScheduleGeneration(99L);
+        LoginAccount account = account();
+
+        try (MockedStatic<SaTokenUtil> saToken = mockStatic(SaTokenUtil.class)) {
+            saToken.when(SaTokenUtil::getLoginAccount).thenReturn(account);
+            controller.onSaveOrUpdateBefore(job, true);
+        }
+
+        Assert.assertEquals(job.getStatus(), Integer.valueOf(EnumJobStatus.STOP.getCode()));
+        Assert.assertEquals(job.getScheduleGeneration(), Long.valueOf(0L));
+    }
+
+    @Test
+    public void shouldRejectStatusAndGenerationMutationThroughOrdinaryUpdate() {
+        BigInteger id = BigInteger.valueOf(401);
+        SysJobService service = mock(SysJobService.class);
+        SysJob existing = validJavaJob();
+        existing.setId(id);
+        existing.setStatus(EnumJobStatus.STOP.getCode());
+        existing.setScheduleGeneration(8L);
+        when(service.getById(id)).thenReturn(existing);
+
+        SysJob update = validJavaJob();
+        update.setId(id);
+        update.setStatus(EnumJobStatus.RUNNING.getCode());
+        update.setScheduleGeneration(100L);
+        try (MockedStatic<SaTokenUtil> saToken = mockStatic(SaTokenUtil.class)) {
+            saToken.when(SaTokenUtil::getLoginAccount).thenReturn(account());
+            controller(service).update(update);
+        }
+
+        Assert.assertEquals(update.getStatus(), Integer.valueOf(EnumJobStatus.STOP.getCode()));
+        Assert.assertEquals(update.getScheduleGeneration(), Long.valueOf(8L));
+        verify(service).updateJobDefinition(update);
+    }
+
     /**
      * 验证缺少工作流必填参数时拒绝保存定时任务。
      */
@@ -63,7 +184,8 @@ public class SysJobControllerTest {
                 workflowService,
                 workflowAuthorizationService,
                 resourceAccessService,
-                parameterResolver
+                parameterResolver,
+                "Asia/Shanghai"
         );
         SysJob job = new SysJob();
         job.setJobType(EnumJobType.TINY_FLOW.getCode());
@@ -130,7 +252,8 @@ public class SysJobControllerTest {
                 workflowService,
                 workflowAuthorizationService,
                 resourceAccessService,
-                parameterResolver
+                parameterResolver,
+                "Asia/Shanghai"
         );
         try (MockedStatic<SaTokenUtil> saToken = mockStatic(SaTokenUtil.class)) {
             saToken.when(SaTokenUtil::getLoginAccount).thenReturn(account);
@@ -147,4 +270,34 @@ public class SysJobControllerTest {
                     org.mockito.ArgumentMatchers.anyString());
         }
     }
+
+    private static SysJobController controller(SysJobService service) {
+        return new SysJobController(
+            service,
+            mock(WorkflowService.class),
+            mock(WorkflowUsageAuthorizationService.class),
+            mock(ResourceAccessService.class),
+            mock(WorkflowRunningParameterResolver.class),
+            "Asia/Shanghai");
+    }
+
+    private static SysJob validJavaJob() {
+        SysJob job = new SysJob();
+        job.setJobName("generation-test");
+        job.setJobType(EnumJobType.JAVA_CLASS.getCode());
+        job.setCronExpression("0 0 0 1 1 ? 2099");
+        job.setMisfirePolicy(EnumMisfirePolicy.SKIP.getCode());
+        job.setAllowConcurrent(0);
+        job.setJobParams(Map.of(JobConstant.JAVA_METHOD_KEY,
+            "tech.easyflow.job.util.JobUtil.test()"));
+        return job;
+    }
+
+    private static LoginAccount account() {
+        LoginAccount account = new LoginAccount();
+        account.setId(BigInteger.ONE);
+        account.setTenantId(BigInteger.ONE);
+        account.setDeptId(BigInteger.ONE);
+        return account;
+    }
 }

easyflow-api/easyflow-api-admin/src/test/java/tech/easyflow/admin/controller/job/SysJobLogControllerTest.java

@@ -0,0 +1,103 @@
+package tech.easyflow.admin.controller.job;
+
+import com.mybatisflex.core.paginate.Page;
+import com.mybatisflex.core.query.QueryWrapper;
+import jakarta.servlet.http.HttpServletRequest;
+import org.mockito.ArgumentCaptor;
+import org.testng.Assert;
+import org.testng.annotations.Test;
+import tech.easyflow.common.web.exceptions.BusinessException;
+import tech.easyflow.job.entity.SysJobLog;
+import tech.easyflow.job.service.SysJobLogService;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * {@link SysJobLogController} 查询与轻量刷新边界测试。
+ */
+public class SysJobLogControllerTest {
+
+    @Test
+    public void shouldBuildBothFireTimeRanges() {
+        SysJobLogController controller = controller(mock(SysJobLogService.class));
+        HttpServletRequest request = emptyRequest();
+        when(request.getParameter("scheduledStart")).thenReturn("2026-08-31 10:00:00");
+        when(request.getParameter("scheduledEnd")).thenReturn("2026-08-31 11:00:00");
+        when(request.getParameter("actualStart")).thenReturn("2026-08-31 10:00:01");
+        when(request.getParameter("actualEnd")).thenReturn("2026-08-31 11:00:01");
+
+        String sql = controller.buildQueryWrapper(request).toSQL().toLowerCase(Locale.ROOT);
+
+        Assert.assertEquals(countOccurrences(sql, "scheduled_fire_time"), 2);
+        Assert.assertEquals(countOccurrences(sql, "actual_fire_time"), 2);
+    }
+
+    @Test(expectedExceptions = BusinessException.class)
+    public void shouldRejectInvalidFireTime() {
+        SysJobLogController controller = controller(mock(SysJobLogService.class));
+        HttpServletRequest request = emptyRequest();
+        when(request.getParameter("scheduledStart")).thenReturn("2026/08/31 10:00:00");
+
+        controller.buildQueryWrapper(request);
+    }
+
+    @Test(expectedExceptions = BusinessException.class)
+    public void shouldRejectReversedActualFireTimeRange() {
+        SysJobLogController controller = controller(mock(SysJobLogService.class));
+        HttpServletRequest request = emptyRequest();
+        when(request.getParameter("actualStart")).thenReturn("2026-08-31 11:00:00");
+        when(request.getParameter("actualEnd")).thenReturn("2026-08-31 10:00:00");
+
+        controller.buildQueryWrapper(request);
+    }
+
+    @Test
+    public void shouldClampRefreshAndPageSize() {
+        SysJobLogService service = mock(SysJobLogService.class);
+        when(service.list(any(QueryWrapper.class))).thenReturn(List.of());
+        when(service.page(any(Page.class), any(QueryWrapper.class)))
+                .thenAnswer(invocation -> invocation.getArgument(0));
+        SysJobLogController controller = controller(service);
+        HttpServletRequest request = emptyRequest();
+
+        controller.refresh(request, 500L);
+        Page<SysJobLog> page = controller.queryPage(
+                new Page<>(1, 500), QueryWrapper.create());
+
+        ArgumentCaptor<QueryWrapper> queryCaptor =
+                ArgumentCaptor.forClass(QueryWrapper.class);
+        verify(service).list(queryCaptor.capture());
+        String refreshSql = queryCaptor.getValue().toSQL().toLowerCase(Locale.ROOT);
+        Assert.assertTrue(refreshSql.contains("limit 100"));
+        Assert.assertEquals(page.getPageSize(), 100L);
+    }
+
+    @Test
+    public void shouldUseStableScheduledFireTimeOrder() {
+        Assert.assertEquals(
+                controller(mock(SysJobLogService.class)).getDefaultOrderBy(),
+                "scheduled_fire_time desc, id desc");
+    }
+
+    private static SysJobLogController controller(SysJobLogService service) {
+        return new SysJobLogController(service, "Asia/Shanghai");
+    }
+
+    private static HttpServletRequest emptyRequest() {
+        HttpServletRequest request = mock(HttpServletRequest.class);
+        when(request.getParameterMap()).thenReturn(Collections.emptyMap());
+        return request;
+    }
+
+    private static int countOccurrences(String source, String expected) {
+        return (source.length() - source.replace(expected, "").length())
+                / expected.length();
+    }
+}

easyflow-api/easyflow-api-admin/src/test/java/tech/easyflow/admin/service/ai/WorkflowDesignerOptionServiceTest.java

@@ -6,10 +6,7 @@ import org.mockito.MockedStatic;
 import org.testng.Assert;
 import org.testng.annotations.Test;
 import tech.easyflow.ai.easyagentsflow.service.WorkflowDatacenterContentService;
-import tech.easyflow.ai.easyagentsflow.knowledge.WorkflowKnowledgeContractService;
 import tech.easyflow.ai.entity.Model;
-import tech.easyflow.ai.entity.ModelProvider;
-import tech.easyflow.ai.entity.DocumentCollection;
 import tech.easyflow.ai.entity.Workflow;
 import tech.easyflow.ai.plugin.workflow.snapshot.WorkflowPluginSnapshotResolver;
 import tech.easyflow.ai.service.DocumentCollectionService;
@@ -132,96 +129,6 @@ public class WorkflowDesignerOptionServiceTest {
         }
     }
 
-    @Test
-    public void shouldAcceptCompatibleMultiKnowledgeReferences() {
-        ModelService modelService = mock(ModelService.class);
-        DocumentCollectionService knowledgeService =
-                mock(DocumentCollectionService.class);
-        ResourceAccessService accessService = mock(ResourceAccessService.class);
-        when(accessService.canAccess(any(), any(), any(), any()))
-                .thenReturn(true);
-        when(knowledgeService.listByIds(any()))
-                .thenReturn(List.of(
-                        knowledge(1, 7, 3),
-                        knowledge(2, 7, 3)));
-        when(modelService.listModelInstances(any()))
-                .thenReturn(List.of(embeddingModel(7)));
-        WorkflowDesignerOptionService service = createService(
-                modelService,
-                knowledgeService,
-                mock(DatacenterSourceService.class),
-                mock(WorkflowService.class),
-                accessService);
-
-        try (MockedStatic<SaTokenUtil> saToken = mockStatic(SaTokenUtil.class)) {
-            saToken.when(SaTokenUtil::getLoginAccount).thenReturn(loginAccount());
-
-            service.assertContentReferences("""
-                    {"nodes":[{"type":"knowledgeNode","data":{
-                      "knowledgeIds":["1","2"],"retrievalMode":"VECTOR"
-                    }}]}
-                    """);
-        }
-    }
-
-    @Test
-    public void shouldRejectIncompatibleMultiKnowledgeReferences() {
-        ModelService modelService = mock(ModelService.class);
-        DocumentCollectionService knowledgeService =
-                mock(DocumentCollectionService.class);
-        ResourceAccessService accessService = mock(ResourceAccessService.class);
-        when(accessService.canAccess(any(), any(), any(), any()))
-                .thenReturn(true);
-        when(knowledgeService.listByIds(any()))
-                .thenReturn(List.of(
-                        knowledge(1, 7, 3),
-                        knowledge(2, 8, 3)));
-        when(modelService.listModelInstances(any()))
-                .thenReturn(List.of(embeddingModel(7), embeddingModel(8)));
-        WorkflowDesignerOptionService service = createService(
-                modelService,
-                knowledgeService,
-                mock(DatacenterSourceService.class),
-                mock(WorkflowService.class),
-                accessService);
-
-        try (MockedStatic<SaTokenUtil> saToken = mockStatic(SaTokenUtil.class)) {
-            saToken.when(SaTokenUtil::getLoginAccount).thenReturn(loginAccount());
-
-            BusinessException exception = Assert.expectThrows(
-                    BusinessException.class,
-                    () -> service.assertContentReferences("""
-                            {"nodes":[{"type":"knowledgeNode","data":{
-                              "knowledgeIds":["1","2"],"retrievalMode":"VECTOR"
-                            }}]}
-                            """));
-
-            Assert.assertTrue(exception.getMessage().contains("Embedding"));
-        }
-    }
-
-    @Test
-    public void shouldRejectConflictingRootAndDataNodeTypes() {
-        WorkflowDesignerOptionService service = createService(
-                mock(ModelService.class),
-                mock(DocumentCollectionService.class),
-                mock(DatacenterSourceService.class));
-
-        try (MockedStatic<SaTokenUtil> saToken = mockStatic(SaTokenUtil.class)) {
-            saToken.when(SaTokenUtil::getLoginAccount).thenReturn(loginAccount());
-
-            BusinessException exception = Assert.expectThrows(
-                    BusinessException.class,
-                    () -> service.assertContentReferences("""
-                            {"nodes":[{"type":"knowledgeNode","data":{
-                              "type":"llmNode","knowledgeId":"1"
-                            }}]}
-                            """));
-
-            Assert.assertTrue(exception.getMessage().contains("类型"));
-        }
-    }
-
     private WorkflowDesignerOptionService createService(
             ModelService modelService,
             DocumentCollectionService knowledgeService,
@@ -235,20 +142,6 @@ public class WorkflowDesignerOptionServiceTest {
             DatacenterSourceService sourceService,
             WorkflowService workflowService) {
         ResourceAccessService resourceAccessService = mock(ResourceAccessService.class);
-        return createService(
-                modelService,
-                knowledgeService,
-                sourceService,
-                workflowService,
-                resourceAccessService);
-    }
-
-    private WorkflowDesignerOptionService createService(
-            ModelService modelService,
-            DocumentCollectionService knowledgeService,
-            DatacenterSourceService sourceService,
-            WorkflowService workflowService,
-            ResourceAccessService resourceAccessService) {
         return new WorkflowDesignerOptionService(
                 modelService,
                 knowledgeService,
@@ -263,40 +156,10 @@ public class WorkflowDesignerOptionServiceTest {
                 resourceAccessService,
                 sourceService,
                 mock(DatacenterDatasetRegistryService.class),
-                mock(DatacenterDatasetQueryService.class),
+                mock(DatacenterDatasetQueryService.class)
-                new WorkflowKnowledgeContractService(
-                        knowledgeService, modelService)
         );
     }
 
-    private DocumentCollection knowledge(
-            long id, long embeddingModelId, int dimension) {
-        DocumentCollection collection = new DocumentCollection();
-        collection.setId(BigInteger.valueOf(id));
-        collection.setTenantId(BigInteger.valueOf(100));
-        collection.setVectorEmbedModelId(BigInteger.valueOf(embeddingModelId));
-        collection.setDimensionOfVectorModel(dimension);
-        collection.setVectorStoreEnable(true);
-        collection.setVectorStoreCollection("collection_" + id);
-        return collection;
-    }
-
-    private Model embeddingModel(long id) {
-        Model model = new Model();
-        model.setId(BigInteger.valueOf(id));
-        model.setTenantId(BigInteger.valueOf(100));
-        model.setModelType(Model.MODEL_TYPES[1]);
-        model.setProviderId(BigInteger.ONE);
-        model.setModelName("embedding-" + id);
-        model.setEndpoint("https://embedding.example");
-        model.setRequestPath("/v1/embeddings");
-        ModelProvider provider = new ModelProvider();
-        provider.setId(BigInteger.ONE);
-        provider.setProviderType("openai");
-        model.setModelProvider(provider);
-        return model;
-    }
-
     private LoginAccount loginAccount() {
         LoginAccount account = new LoginAccount();
         account.setId(BigInteger.ONE);

easyflow-api/easyflow-api-admin/src/test/java/tech/easyflow/admin/service/ai/WorkflowPublicChatServiceTest.java

@@ -12,7 +12,6 @@ import org.testng.Assert;
 import org.testng.annotations.Test;
 import tech.easyflow.ai.easyagentsflow.service.WorkflowCheckService;
 import tech.easyflow.ai.easyagentsflow.service.WorkflowRunningParameterResolver;
-import tech.easyflow.ai.easyagentsflow.service.WorkflowResumeService;
 import tech.easyflow.ai.easyagentsflow.support.PublishedWorkflowDefinitionIds;
 import tech.easyflow.ai.entity.Workflow;
 import tech.easyflow.ai.entity.WorkflowExecResult;
@@ -163,8 +162,6 @@ public class WorkflowPublicChatServiceTest {
         WorkflowChatEventStream eventStream = mock(
                 WorkflowChatEventStream.class);
         ChainExecutor chainExecutor = mock(ChainExecutor.class);
-        WorkflowResumeService workflowResumeService =
-                mock(WorkflowResumeService.class);
         WorkflowExecResultService execResultService = mock(
                 WorkflowExecResultService.class);
         WorkflowExecStepService execStepService = mock(
@@ -199,7 +196,6 @@ public class WorkflowPublicChatServiceTest {
                 accessGuard,
                 eventStream,
                 chainExecutor,
-                workflowResumeService,
                 execResultService,
                 execStepService
         );

easyflow-api/easyflow-api-public/src/main/java/tech/easyflow/publicapi/controller/PublicKnowledgeShareController.java

@@ -1,6 +1,10 @@
 package tech.easyflow.publicapi.controller;
 
 import cn.hutool.core.io.IoUtil;
+import com.easyagents.core.model.embedding.EmbeddingModel;
+import com.easyagents.core.store.DocumentStore;
+import com.easyagents.core.store.StoreOptions;
+import com.easyagents.core.store.StoreResult;
 import com.mybatisflex.core.paginate.Page;
 import com.mybatisflex.core.query.QueryWrapper;
 import jakarta.servlet.http.HttpServletRequest;
@@ -14,15 +18,11 @@ import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.RestController;
 import org.springframework.web.multipart.MultipartFile;
 import tech.easyflow.ai.documentimport.DocumentImportDtos;
-import tech.easyflow.ai.dto.DocumentChunkDeleteResult;
-import tech.easyflow.ai.dto.DocumentChunkAsyncUpdateResult;
-import tech.easyflow.ai.dto.DocumentChunkSyncRetryRequest;
-import tech.easyflow.ai.dto.DocumentChunkSyncStatus;
-import tech.easyflow.ai.dto.DocumentChunkSyncStatusRequest;
 import tech.easyflow.ai.entity.Document;
 import tech.easyflow.ai.entity.DocumentChunk;
 import tech.easyflow.ai.entity.DocumentCollection;
 import tech.easyflow.ai.entity.FaqItem;
+import tech.easyflow.ai.entity.Model;
 import tech.easyflow.ai.enums.KnowledgeApiPermissionScope;
 import tech.easyflow.ai.rag.KnowledgeRetrievalModes;
 import tech.easyflow.ai.rag.KnowledgeRetrievalRequest;
@@ -33,7 +33,9 @@ import tech.easyflow.ai.service.FaqCategoryService;
 import tech.easyflow.ai.service.FaqItemService;
 import tech.easyflow.ai.service.KnowledgeShareAuditService;
 import tech.easyflow.ai.service.KnowledgeSharePermissionService;
+import tech.easyflow.ai.service.ModelService;
 import tech.easyflow.ai.service.impl.KnowledgeSharePermissionServiceImpl;
+import tech.easyflow.ai.support.DocumentStoreLifecycleSupport;
 import tech.easyflow.ai.vo.FaqImportResultVo;
 import tech.easyflow.common.domain.Result;
 import tech.easyflow.common.filestorage.FileStorageService;
@@ -79,6 +81,8 @@ public class PublicKnowledgeShareController {
     private FaqItemService faqItemService;
     @Resource
     private FaqCategoryService faqCategoryService;
+    @Resource
+    private ModelService modelService;
     @Resource(name = "default")
     private FileStorageService fileStorageService;
 
@@ -347,20 +351,37 @@ public class PublicKnowledgeShareController {
     public Result<?> updateDocumentChunk(
         @RequestHeader("ApiKey") String apiKey,
         @JsonBody(value = "knowledgeId", required = true) BigInteger knowledgeId,
-        @JsonBody(required = true, skipConvertError = false)
+        @JsonBody DocumentChunk documentChunk,
-        DocumentChunk documentChunk,
         HttpServletRequest request
     ) {
         assertApiShare(apiKey, request.getRequestURI(), knowledgeId, KnowledgeApiPermissionScope.KNOWLEDGE_MAINTENANCE.name());
         requireDocumentKnowledge(knowledgeId);
         DocumentChunk current = requireDocumentChunk(documentChunk.getId(), knowledgeId);
-        DocumentChunk updated = documentChunkService.updateContent(
+        boolean success = documentChunkService.updateById(documentChunk);
-            knowledgeId,
+        if (success) {
-            current.getId(),
+            DocumentCollection knowledge = documentCollectionService.getById(knowledgeId);
-            documentChunk.getContent()
+            DocumentStore documentStore = knowledge.toDocumentStore();
-        );
+            if (documentStore == null) {
+                return Result.fail(2, "知识库没有配置向量库");
+            }
+            try {
+                Model model = modelService.getModelInstance(knowledge.getVectorEmbedModelId());
+                if (model == null) {
+                    return Result.fail(3, "知识库没有配置向量模型");
+                }
+                EmbeddingModel embeddingModel = model.toEmbeddingModel();
+                documentStore.setEmbeddingModel(embeddingModel);
+                StoreOptions options = StoreOptions.ofCollectionName(knowledge.getVectorStoreCollection());
+                com.easyagents.core.document.Document doc = com.easyagents.core.document.Document.of(documentChunk.getContent());
+                doc.setId(current.getId());
+                StoreResult result = documentStore.update(doc, options);
                 audit(apiKey, "API更新文档 Chunk", "KNOWLEDGE_API_SHARE_WRITE", request.getRequestURI(), Map.of("knowledgeId", knowledgeId, "chunkId", documentChunk.getId()));
-        return Result.ok(DocumentChunkAsyncUpdateResult.from(updated));
+                return Result.ok(result);
+            } finally {
+                DocumentStoreLifecycleSupport.closeQuietly(documentStore);
+            }
+        }
+        return Result.ok(false);
     }
 
     /**
@@ -376,51 +397,25 @@ public class PublicKnowledgeShareController {
         assertApiShare(apiKey, request.getRequestURI(), knowledgeId, KnowledgeApiPermissionScope.KNOWLEDGE_MAINTENANCE.name());
         requireDocumentKnowledge(knowledgeId);
         requireDocumentChunk(chunkId, knowledgeId);
-        DocumentChunkDeleteResult removed = documentChunkService.deleteChunk(
+        DocumentCollection knowledge = documentCollectionService.getById(knowledgeId);
-            knowledgeId,
+        DocumentStore documentStore = knowledge.toDocumentStore();
-            chunkId
+        if (documentStore == null) {
-        );
+            return Result.fail(2, "知识库没有配置向量库");
+        }
+        try {
+            Model model = modelService.getModelInstance(knowledge.getVectorEmbedModelId());
+            if (model == null) {
+                return Result.fail(3, "知识库没有配置向量模型");
+            }
+            documentStore.setEmbeddingModel(model.toEmbeddingModel());
+            StoreOptions options = StoreOptions.ofCollectionName(knowledge.getVectorStoreCollection());
+            documentStore.delete(Collections.singletonList(chunkId), options);
+            documentChunkService.removeById(chunkId);
             audit(apiKey, "API删除文档 Chunk", "KNOWLEDGE_API_SHARE_WRITE", request.getRequestURI(), Map.of("knowledgeId", knowledgeId, "chunkId", chunkId));
-        return Result.ok(removed != null);
+            return Result.ok(true);
+        } finally {
+            DocumentStoreLifecycleSupport.closeQuietly(documentStore);
         }
-
-    @PostMapping("/documentChunk/syncStatus")
-    public Result<List<DocumentChunkSyncStatus>> documentChunkSyncStatus(
-        @RequestHeader("ApiKey") String apiKey,
-        @JsonBody(value = "knowledgeId", required = true) BigInteger knowledgeId,
-        @JsonBody(required = true, skipConvertError = false)
-        DocumentChunkSyncStatusRequest statusRequest,
-        HttpServletRequest request
-    ) {
-        assertApiShare(apiKey, request.getRequestURI(), knowledgeId,
-            KnowledgeApiPermissionScope.KNOWLEDGE_READ.name());
-        requireDocumentKnowledge(knowledgeId);
-        requireDocument(statusRequest.getDocumentId(), knowledgeId);
-        return Result.ok(documentChunkService.listIndexSyncStatus(
-            knowledgeId, statusRequest.getDocumentId(), statusRequest.getIds()
-        ));
-    }
-
-    @PostMapping("/documentChunk/retrySync")
-    public Result<DocumentChunk> retryDocumentChunkSync(
-        @RequestHeader("ApiKey") String apiKey,
-        @JsonBody(value = "knowledgeId", required = true) BigInteger knowledgeId,
-        @JsonBody(required = true, skipConvertError = false)
-        DocumentChunkSyncRetryRequest retryRequest,
-        HttpServletRequest request
-    ) {
-        assertApiShare(apiKey, request.getRequestURI(), knowledgeId,
-            KnowledgeApiPermissionScope.KNOWLEDGE_MAINTENANCE.name());
-        requireDocumentKnowledge(knowledgeId);
-        if (retryRequest.getIndexSyncVersion() == null) {
-            throw new BusinessException("同步版本不能为空");
-        }
-        DocumentChunk chunk = documentChunkService.retryIndexSync(
-            knowledgeId, retryRequest.getId(), retryRequest.getIndexSyncVersion()
-        );
-        audit(apiKey, "API重试文档 Chunk 索引同步", "KNOWLEDGE_API_SHARE_WRITE",
-            request.getRequestURI(), Map.of("knowledgeId", knowledgeId, "chunkId", retryRequest.getId()));
-        return Result.ok(chunk);
     }
 
     /**

easyflow-api/easyflow-api-public/src/main/java/tech/easyflow/publicapi/controller/PublicWorkflowController.java

@@ -18,7 +18,6 @@ import tech.easyflow.ai.easyagentsflow.entity.WorkflowCheckStage;
 import tech.easyflow.ai.easyagentsflow.service.TinyFlowService;
 import tech.easyflow.ai.easyagentsflow.service.WorkflowCheckService;
 import tech.easyflow.ai.easyagentsflow.service.WorkflowRunningParameterResolver;
-import tech.easyflow.ai.easyagentsflow.service.WorkflowResumeService;
 import tech.easyflow.ai.easyagentsflow.support.PublishedWorkflowDefinitionIds;
 import tech.easyflow.ai.easyagentsflow.upload.WorkflowApiPreparedUpload;
 import tech.easyflow.ai.easyagentsflow.upload.WorkflowApiUploadLifecycleService;
@@ -71,8 +70,6 @@ public class PublicWorkflowController {
     @Resource
     private WorkflowRunningParameterResolver workflowRunningParameterResolver;
     @Resource
-    private WorkflowResumeService workflowResumeService;
-    @Resource
     private WorkflowApiPermissionService workflowApiPermissionService;
     @Resource
     private WorkflowExecResultService workflowExecResultService;
@@ -253,7 +250,14 @@ public class PublicWorkflowController {
         SysApiKey apiKey = workflowApiPermissionService.assertWorkflowApi(request.getHeader("ApiKey"), request.getRequestURI());
         WorkflowExecResult execResult = assertApiKeyExecutionOwnership(apiKey, executeId);
         assertWorkflowExecutionResumable(execResult);
-        workflowResumeService.resume(executeId, confirmParams);
+        if (!chainExecutor.resumeAsyncIfSuspended(
+                executeId,
+                confirmParams)) {
+            throw new BusinessException(
+                    409,
+                    40901,
+                    "当前执行状态不可恢复，仅暂停中的工作流允许恢复");
+        }
         return Result.ok();
     }
 

easyflow-api/easyflow-api-public/src/main/java/tech/easyflow/publicapi/error/WorkflowRunAsyncErrorProfile.java

@@ -394,7 +394,6 @@ public final class WorkflowRunAsyncErrorProfile
      */
     private boolean isStableBusinessCode(int code) {
         return (code >= 40011 && code <= 40017)
-                || code == 40031
                 || (code >= 40101 && code <= 40103)
                 || (code >= 40301 && code <= 40302)
                 || (code >= 40401 && code <= 40402)
@@ -413,8 +412,7 @@ public final class WorkflowRunAsyncErrorProfile
      * @return 对外 HTTP 状态
      */
     private int normalizeHttpStatus(int code, int fallback) {
-        if ((code >= 40011 && code <= 40017)
+        if (code >= 40011 && code <= 40017) {
-                || code == 40031) {
             return 400;
         }
         if (code >= 40101 && code <= 40103) {

easyflow-api/easyflow-api-public/src/test/java/tech/easyflow/publicapi/controller/PublicKnowledgeShareControllerContractTest.java

@@ -66,8 +66,6 @@ public class PublicKnowledgeShareControllerContractTest {
         JsonBody chunkBody = chunk.getAnnotation(JsonBody.class);
         Assert.assertNotNull(chunkBody);
         Assert.assertEquals("", chunkBody.value());
-        Assert.assertTrue(chunkBody.required());
-        Assert.assertFalse(chunkBody.skipConvertError());
     }
 
     /**

easyflow-api/easyflow-api-public/src/test/java/tech/easyflow/publicapi/controller/PublicWorkflowControllerBehaviorTest.java

@@ -12,7 +12,6 @@ import org.springframework.test.util.ReflectionTestUtils;
 import tech.easyflow.ai.easyagentsflow.entity.ChainInfo;
 import tech.easyflow.ai.easyagentsflow.entity.NodeInfo;
 import tech.easyflow.ai.easyagentsflow.service.TinyFlowService;
-import tech.easyflow.ai.easyagentsflow.service.WorkflowResumeService;
 import tech.easyflow.ai.entity.Workflow;
 import tech.easyflow.ai.entity.WorkflowExecResult;
 import tech.easyflow.ai.enums.PublishStatus;
@@ -45,7 +44,6 @@ public class PublicWorkflowControllerBehaviorTest {
 
     private PublicWorkflowController controller;
     private ChainExecutor chainExecutor;
-    private WorkflowResumeService workflowResumeService;
     private TinyFlowService tinyFlowService;
     private HttpServletRequest request;
 
@@ -56,7 +54,6 @@ public class PublicWorkflowControllerBehaviorTest {
     public void setUp() {
         controller = new PublicWorkflowController();
         chainExecutor = Mockito.mock(ChainExecutor.class);
-        workflowResumeService = Mockito.mock(WorkflowResumeService.class);
         tinyFlowService = Mockito.mock(TinyFlowService.class);
         WorkflowApiPermissionService permissionService =
                 Mockito.mock(WorkflowApiPermissionService.class);
@@ -82,10 +79,6 @@ public class PublicWorkflowControllerBehaviorTest {
                 controller,
                 "chainExecutor",
                 chainExecutor);
-        ReflectionTestUtils.setField(
-                controller,
-                "workflowResumeService",
-                workflowResumeService);
         ReflectionTestUtils.setField(
                 controller,
                 "tinyFlowService",
@@ -115,12 +108,10 @@ public class PublicWorkflowControllerBehaviorTest {
     public void resumeShouldRejectNonSuspendedExecution() {
         when(request.getRequestURI()).thenReturn(
                 "/public-api/workflow/resume");
-        Mockito.doThrow(new BusinessException(
+        when(chainExecutor.resumeAsyncIfSuspended(
-                        409,
+                EXECUTE_ID,
-                        40901,
+                Map.of("approved", true)))
-                        "当前执行状态不可恢复，仅暂停中的工作流允许恢复"))
+                .thenReturn(false);
-                .when(workflowResumeService)
-                .resume(EXECUTE_ID, Map.of("approved", true));
 
         try {
             controller.resume(
@@ -133,7 +124,7 @@ public class PublicWorkflowControllerBehaviorTest {
             Assert.assertEquals(40901, exception.getErrorCode());
         }
 
-        verify(workflowResumeService).resume(
+        verify(chainExecutor).resumeAsyncIfSuspended(
                 EXECUTE_ID,
                 Map.of("approved", true));
     }

easyflow-api/easyflow-api-public/src/test/java/tech/easyflow/publicapi/error/WorkflowRunAsyncErrorProfileTest.java

@@ -167,28 +167,6 @@ public class WorkflowRunAsyncErrorProfileTest {
                 resolution.modelAndView.getModel().get("message"));
     }
 
-    /**
-     * 验证确认节点恢复校验保留专用错误码，不回退为运行参数错误。
-     */
-    @Test
-    public void shouldKeepResumeValidationCode() {
-        Resolution resolution = resolve(
-                "/public-api/workflow/resume",
-                MediaType.APPLICATION_JSON_VALUE,
-                new BusinessException(
-                        400,
-                        40031,
-                        "确认参数[模板类型]包含未配置选项"));
-
-        Assert.assertEquals(400, resolution.response.getStatus());
-        Assert.assertEquals(
-                40031,
-                resolution.modelAndView.getModel().get("errorCode"));
-        Assert.assertEquals(
-                "确认参数[模板类型]包含未配置选项",
-                resolution.modelAndView.getModel().get("message"));
-    }
-
     /**
      * 验证 API Key 无效和两层权限错误保持可区分。
      */

easyflow-api/easyflow-api-usercenter/src/main/java/tech/easyflow/usercenter/controller/ai/UcWorkflowController.java

@@ -13,7 +13,6 @@ import tech.easyflow.ai.easyagentsflow.entity.WorkflowCheckStage;
 import tech.easyflow.ai.easyagentsflow.service.TinyFlowService;
 import tech.easyflow.ai.easyagentsflow.service.WorkflowCheckService;
 import tech.easyflow.ai.easyagentsflow.service.WorkflowRunningParameterResolver;
-import tech.easyflow.ai.easyagentsflow.service.WorkflowResumeService;
 import tech.easyflow.ai.entity.Workflow;
 import tech.easyflow.ai.service.WorkflowService;
 import tech.easyflow.common.annotation.UsePermission;
@@ -55,8 +54,6 @@ public class UcWorkflowController extends BaseCurdController<WorkflowService, Wo
     @Resource
     private WorkflowRunningParameterResolver workflowRunningParameterResolver;
     @Resource
-    private WorkflowResumeService workflowResumeService;
-    @Resource
     private WorkflowVisibilityQueryHelper workflowVisibilityQueryHelper;
 
     public UcWorkflowController(WorkflowService service) {
@@ -166,7 +163,12 @@ public class UcWorkflowController extends BaseCurdController<WorkflowService, Wo
     )
     public Result<Void> resume(@JsonBody(value = "executeId", required = true) String executeId,
                                @JsonBody("confirmParams") Map<String, Object> confirmParams) {
-        workflowResumeService.resume(executeId, confirmParams);
+        if (!chainExecutor.resumeAsyncIfSuspended(executeId, confirmParams)) {
+            throw new BusinessException(
+                    409,
+                    40901,
+                    "当前执行状态不可恢复，仅暂停中的工作流允许恢复");
+        }
         return Result.ok();
     }
 

easyflow-commons/easyflow-common-base/src/main/java/tech/easyflow/common/constant/enums/EnumJobResult.java

@@ -5,9 +5,12 @@ import tech.easyflow.common.annotation.DictDef;
 @DictDef(name = "任务执行结果", code = "jobResult", keyField = "code", labelField = "text")
 public enum EnumJobResult {
 
-
     SUCCESS(1,"成功"),
     FAIL(0,"失败"),
+    PENDING(2,"等待执行"),
+    RUNNING(3,"执行中"),
+    DEAD(4,"需人工处理"),
+    CANCELLED(5,"已取消"),
     ;
 
     private final int code;

easyflow-commons/easyflow-common-base/src/main/java/tech/easyflow/common/constant/enums/EnumMisfirePolicy.java

@@ -5,10 +5,8 @@ import tech.easyflow.common.annotation.DictDef;
 @DictDef(name = "错过策略", code = "misfirePolicy", keyField = "code", labelField = "text")
 public enum EnumMisfirePolicy {
 
-    DEFAULT(0,"默认"),
+    FIRE_ONCE_NOW(2,"恢复后补执行一次"),
-    MISFIRE_IGNORE_MISFIRES(1,"立即触发"),
+    SKIP(3,"跳过本次");
-    MISFIRE_FIRE_AND_PROCEED(2,"立即触发一次"),
-    MISFIRE_DO_NOTHING(3,"忽略");
     ;
 
     private final int code;

easyflow-modules/easyflow-module-agent/src/main/java/tech/easyflow/agent/runtime/asynctool/AbstractAgentAsyncSubTools.java

@@ -67,9 +67,7 @@ public abstract class AbstractAgentAsyncSubTools implements AsyncSubTools {
      * @param arguments 调用参数
      * @return 执行结果
      */
-    protected abstract AgentToolExecutionResult executeBusiness(
+    protected abstract AgentToolExecutionResult executeBusiness(Map<String, Object> arguments);
-            Map<String, Object> arguments,
-            AgentToolContext context);
 
     /**
      * {@inheritDoc}
@@ -94,7 +92,7 @@ public abstract class AbstractAgentAsyncSubTools implements AsyncSubTools {
         record.getMetadata().put("toolDisplayName", displayName());
         appendEvent(record, "SUBMITTED", displayName() + "任务已提交");
         taskStore.create(record);
-        dispatch(sessionId, record.getTaskId(), record.getArguments(), context);
+        dispatch(sessionId, record.getTaskId(), record.getArguments());
 
         AsyncToolSubmitResult result = new AsyncToolSubmitResult();
         result.setTaskId(taskId);
@@ -159,23 +157,16 @@ public abstract class AbstractAgentAsyncSubTools implements AsyncSubTools {
         return result;
     }
 
-    private void dispatch(String sessionId,
+    private void dispatch(String sessionId, String taskId, Map<String, Object> arguments) {
-                          String taskId,
-                          Map<String, Object> arguments,
-                          AgentToolContext context) {
         try {
-            taskExecutor.execute(() -> executeTask(
+            taskExecutor.execute(() -> executeTask(sessionId, taskId, arguments));
-                    sessionId, taskId, arguments, context));
         } catch (Exception e) {
             taskStore.update(sessionId, taskId, record -> fail(record, e));
             throw new BusinessException("提交异步工具任务失败：" + safeMessage(e));
         }
     }
 
-    private void executeTask(String sessionId,
+    private void executeTask(String sessionId, String taskId, Map<String, Object> arguments) {
-                             String taskId,
-                             Map<String, Object> arguments,
-                             AgentToolContext context) {
         try {
             taskStore.update(sessionId, taskId, record -> {
                 record.setStatus(AsyncToolTaskStatus.RUNNING);
@@ -183,8 +174,7 @@ public abstract class AbstractAgentAsyncSubTools implements AsyncSubTools {
                 appendEvent(record, "RUNNING", displayName() + "任务执行中");
                 return record;
             });
-            AgentToolExecutionResult executionResult = executeBusiness(
+            AgentToolExecutionResult executionResult = executeBusiness(arguments);
-                    arguments, context);
             taskStore.update(sessionId, taskId, record -> {
                 record.setStatus(AsyncToolTaskStatus.SUCCEEDED);
                 record.setSummary(displayName() + "任务已完成");

easyflow-modules/easyflow-module-agent/src/main/java/tech/easyflow/agent/runtime/asynctool/PluginAsyncSubTools.java

@@ -1,6 +1,5 @@
 package tech.easyflow.agent.runtime.asynctool;
 
-import com.easyagents.agent.runtime.tool.AgentToolContext;
 import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
 import tech.easyflow.agent.enums.AgentToolType;
 import tech.easyflow.agent.runtime.tool.AgentToolExecutionResult;
@@ -83,9 +82,7 @@ public class PluginAsyncSubTools extends AbstractAgentAsyncSubTools {
      * {@inheritDoc}
      */
     @Override
-    protected AgentToolExecutionResult executeBusiness(
+    protected AgentToolExecutionResult executeBusiness(Map<String, Object> arguments) {
-            Map<String, Object> arguments,
-            AgentToolContext context) {
         return pluginToolExecutor.execute(pluginItem, plugin, arguments);
     }
 }

easyflow-modules/easyflow-module-agent/src/main/java/tech/easyflow/agent/runtime/asynctool/WorkflowAsyncSubTools.java

@@ -1,6 +1,5 @@
 package tech.easyflow.agent.runtime.asynctool;
 
-import com.easyagents.agent.runtime.tool.AgentToolContext;
 import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
 import tech.easyflow.agent.enums.AgentToolType;
 import tech.easyflow.agent.runtime.tool.AgentToolExecutionResult;
@@ -78,9 +77,7 @@ public class WorkflowAsyncSubTools extends AbstractAgentAsyncSubTools {
      * {@inheritDoc}
      */
     @Override
-    protected AgentToolExecutionResult executeBusiness(
+    protected AgentToolExecutionResult executeBusiness(Map<String, Object> arguments) {
-            Map<String, Object> arguments,
+        return workflowToolExecutor.execute(workflow, arguments);
-            AgentToolContext context) {
-        return workflowToolExecutor.execute(workflow, arguments, context);
     }
 }

easyflow-modules/easyflow-module-agent/src/main/java/tech/easyflow/agent/runtime/tool/AgentToolRuntimeCompiler.java

@@ -161,7 +161,7 @@ public class AgentToolRuntimeCompiler {
             Tool tool = workflowToolExecutor.buildTool(workflow);
             AgentToolSpec spec = toToolSpec(tool, binding);
             AgentToolInvoker invoker = (arguments, context) -> invokeSafely(spec.getName(), binding, context,
-                    () -> workflowToolExecutor.execute(workflow, arguments, context).getResult());
+                    () -> workflowToolExecutor.execute(workflow, arguments).getResult());
             return new CompiledSyncTool(spec, invoker);
         }
         if (type == AgentToolType.PLUGIN) {

easyflow-modules/easyflow-module-agent/src/main/java/tech/easyflow/agent/runtime/tool/WorkflowToolExecutor.java

@@ -2,19 +2,13 @@ package tech.easyflow.agent.runtime.tool;
 
 import com.easyagents.flow.core.chain.runtime.ChainExecutor;
 import com.easyagents.core.model.chat.tool.Tool;
-import com.easyagents.agent.runtime.AgentRuntimeContext;
-import com.easyagents.agent.runtime.tool.AgentToolContext;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import tech.easyflow.ai.easyagents.tool.WorkflowTool;
 import tech.easyflow.ai.easyagentsflow.repository.FrozenWorkflowDefinitionRegistry;
 import tech.easyflow.ai.easyagentsflow.support.PublishedWorkflowDefinitionIds;
 import tech.easyflow.ai.entity.Workflow;
-import tech.easyflow.common.constant.Constants;
-import tech.easyflow.common.entity.LoginAccount;
 
-import java.math.BigInteger;
-import java.util.LinkedHashMap;
 import java.util.Map;
 
 /**
@@ -65,63 +59,11 @@ public class WorkflowToolExecutor {
      * @return 执行结果
      */
     public AgentToolExecutionResult execute(Workflow workflow, Map<String, Object> arguments) {
-        return execute(workflow, arguments, null);
-    }
-
-    /**
-     * 使用 Agent 调用身份执行 Workflow 工具。
-     *
-     * @param workflow 工作流
-     * @param arguments 执行参数
-     * @param context Agent 工具上下文
-     * @return 执行结果
-     */
-    public AgentToolExecutionResult execute(Workflow workflow,
-                                            Map<String, Object> arguments,
-                                            AgentToolContext context) {
-        Map<String, Object> variables = arguments == null
-                ? new LinkedHashMap<>()
-                : new LinkedHashMap<>(arguments);
-        variables.remove(Constants.LOGIN_USER_KEY);
-        LoginAccount account = toLoginAccount(context);
-        if (account != null) {
-            variables.put(Constants.LOGIN_USER_KEY, account);
-        }
         Object result = chainExecutor.executeWithoutSuspension(
-                definitionId(workflow), variables);
+                definitionId(workflow), arguments == null ? Map.of() : arguments);
         return new AgentToolExecutionResult(result, resolveBusinessExecutionId(result));
     }
 
-    private LoginAccount toLoginAccount(AgentToolContext context) {
-        AgentRuntimeContext runtimeContext = context == null
-                ? null
-                : context.getRuntimeContext();
-        BigInteger userId = positiveId(runtimeContext == null
-                ? null
-                : runtimeContext.getUserId());
-        BigInteger tenantId = positiveId(runtimeContext == null
-                ? null
-                : runtimeContext.getTenantId());
-        if (userId == null || tenantId == null) {
-            return null;
-        }
-        LoginAccount account = new LoginAccount();
-        account.setId(userId);
-        account.setTenantId(tenantId);
-        account.setLoginName(runtimeContext.getUserName());
-        account.setNickname(runtimeContext.getUserName());
-        return account;
-    }
-
-    private BigInteger positiveId(String value) {
-        try {
-            BigInteger id = new BigInteger(value);
-            return id.signum() > 0 ? id : null;
-        } catch (RuntimeException exception) {
-            return null;
-        }
-    }
-
     private String definitionId(Workflow workflow) {
         if (frozenDefinitionRegistry != null && workflow != null
                 && workflow.getContent() != null && !workflow.getContent().isBlank()) {

easyflow-modules/easyflow-module-agent/src/test/java/tech/easyflow/agent/runtime/asynctool/AbstractAgentAsyncSubToolsTest.java

@@ -146,9 +146,7 @@ public class AbstractAgentAsyncSubToolsTest {
         }
 
         @Override
-        protected AgentToolExecutionResult executeBusiness(
+        protected AgentToolExecutionResult executeBusiness(Map<String, Object> arguments) {
-                Map<String, Object> arguments,
-                AgentToolContext context) {
             return new AgentToolExecutionResult(Map.of("echo", arguments.get("keyword")), "business-run-1");
         }
     }

easyflow-modules/easyflow-module-agent/src/test/java/tech/easyflow/agent/runtime/asynctool/WorkflowPluginAsyncSubToolsTest.java

@@ -153,10 +153,7 @@ public class WorkflowPluginAsyncSubToolsTest {
         }
 
         @Override
-        public AgentToolExecutionResult execute(
+        public AgentToolExecutionResult execute(Workflow workflow, Map<String, Object> arguments) {
-                Workflow workflow,
-                Map<String, Object> arguments,
-                AgentToolContext context) {
             return new AgentToolExecutionResult(businessResult, "workflow-run-1");
         }
     }

easyflow-modules/easyflow-module-agent/src/test/java/tech/easyflow/agent/runtime/tool/AgentToolRuntimeCompilerTest.java

@@ -145,10 +145,7 @@ public class AgentToolRuntimeCompilerTest {
             }
 
             @Override
-            public AgentToolExecutionResult execute(
+            public AgentToolExecutionResult execute(Workflow workflow, Map<String, Object> arguments) {
-                    Workflow workflow,
-                    Map<String, Object> arguments,
-                    AgentToolContext context) {
                 throw new IllegalStateException("jdbc:mysql://internal:3306 secret-token");
             }
         });
@@ -265,10 +262,7 @@ public class AgentToolRuntimeCompilerTest {
         }
 
         @Override
-        public AgentToolExecutionResult execute(
+        public AgentToolExecutionResult execute(Workflow workflow, Map<String, Object> arguments) {
-                Workflow workflow,
-                Map<String, Object> arguments,
-                AgentToolContext context) {
             return new AgentToolExecutionResult(Map.of("ok", true), "wf-run-1");
         }
     }

easyflow-modules/easyflow-module-agent/src/test/java/tech/easyflow/agent/runtime/tool/WorkflowToolExecutorTest.java

@@ -1,100 +0,0 @@
-package tech.easyflow.agent.runtime.tool;
-
-import com.easyagents.agent.runtime.AgentRuntimeContext;
-import com.easyagents.agent.runtime.tool.AgentToolContext;
-import com.easyagents.flow.core.chain.runtime.ChainExecutor;
-import org.junit.Assert;
-import org.junit.Test;
-import org.mockito.ArgumentCaptor;
-import tech.easyflow.ai.easyagentsflow.repository.FrozenWorkflowDefinitionRegistry;
-import tech.easyflow.ai.entity.Workflow;
-import tech.easyflow.common.constant.Constants;
-import tech.easyflow.common.entity.LoginAccount;
-
-import java.math.BigInteger;
-import java.util.LinkedHashMap;
-import java.util.Map;
-
-import static org.mockito.ArgumentMatchers.anyMap;
-import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
-/**
- * Agent Workflow 工具调用上下文测试。
- */
-public class WorkflowToolExecutorTest {
-
-    @Test
-    @SuppressWarnings("unchecked")
-    public void shouldForwardAgentIdentityToFrozenWorkflowVariables() {
-        ChainExecutor chainExecutor = mock(ChainExecutor.class);
-        FrozenWorkflowDefinitionRegistry registry =
-                mock(FrozenWorkflowDefinitionRegistry.class);
-        Workflow workflow = new Workflow();
-        workflow.setId(BigInteger.valueOf(101));
-        workflow.setContent("{\"nodes\":[]}");
-        when(registry.register(workflow)).thenReturn("agent-frozen:101:hash");
-        when(chainExecutor.executeWithoutSuspension(anyString(), anyMap()))
-                .thenReturn(Map.of("ok", true));
-        WorkflowToolExecutor executor = new WorkflowToolExecutor(
-                chainExecutor, registry);
-
-        AgentRuntimeContext runtimeContext = new AgentRuntimeContext();
-        runtimeContext.setUserId("7");
-        runtimeContext.setTenantId("9");
-        runtimeContext.setUserName("测试用户");
-        AgentToolContext context = new AgentToolContext();
-        context.setRuntimeContext(runtimeContext);
-        Map<String, Object> arguments = new LinkedHashMap<>();
-        arguments.put("question", "问题");
-        LoginAccount forgedAccount = new LoginAccount();
-        forgedAccount.setId(BigInteger.valueOf(999));
-        forgedAccount.setTenantId(BigInteger.valueOf(999));
-        arguments.put(Constants.LOGIN_USER_KEY, forgedAccount);
-
-        executor.execute(workflow, arguments, context);
-
-        ArgumentCaptor<Map<String, Object>> variables =
-                ArgumentCaptor.forClass(Map.class);
-        verify(chainExecutor).executeWithoutSuspension(
-                org.mockito.ArgumentMatchers.eq("agent-frozen:101:hash"),
-                variables.capture());
-        LoginAccount account = (LoginAccount) variables.getValue()
-                .get(Constants.LOGIN_USER_KEY);
-        Assert.assertEquals(BigInteger.valueOf(7), account.getId());
-        Assert.assertEquals(BigInteger.valueOf(9), account.getTenantId());
-        Assert.assertEquals("测试用户", account.getLoginName());
-        Assert.assertSame(forgedAccount,
-                arguments.get(Constants.LOGIN_USER_KEY));
-    }
-
-    @Test
-    @SuppressWarnings("unchecked")
-    public void shouldDropReservedIdentityWithoutAgentContext() {
-        ChainExecutor chainExecutor = mock(ChainExecutor.class);
-        FrozenWorkflowDefinitionRegistry registry =
-                mock(FrozenWorkflowDefinitionRegistry.class);
-        Workflow workflow = new Workflow();
-        workflow.setId(BigInteger.valueOf(101));
-        workflow.setContent("{\"nodes\":[]}");
-        when(registry.register(workflow)).thenReturn("agent-frozen:101:hash");
-        when(chainExecutor.executeWithoutSuspension(anyString(), anyMap()))
-                .thenReturn(Map.of("ok", true));
-        WorkflowToolExecutor executor = new WorkflowToolExecutor(
-                chainExecutor, registry);
-        Map<String, Object> arguments = new LinkedHashMap<>();
-        arguments.put(Constants.LOGIN_USER_KEY, new LoginAccount());
-
-        executor.execute(workflow, arguments);
-
-        ArgumentCaptor<Map<String, Object>> variables =
-                ArgumentCaptor.forClass(Map.class);
-        verify(chainExecutor).executeWithoutSuspension(
-                anyString(), variables.capture());
-        Assert.assertFalse(variables.getValue()
-                .containsKey(Constants.LOGIN_USER_KEY));
-        Assert.assertTrue(arguments.containsKey(Constants.LOGIN_USER_KEY));
-    }
-}

easyflow-modules/easyflow-module-ai/pom.xml

@@ -53,10 +53,6 @@
             <groupId>com.easyagents</groupId>
             <artifactId>easy-agents-spring-boot-starter</artifactId>
         </dependency>
-        <dependency>
-            <groupId>io.milvus</groupId>
-            <artifactId>milvus-sdk-java</artifactId>
-        </dependency>
         <dependency>
             <groupId>com.google.re2j</groupId>
             <artifactId>re2j</artifactId>

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/config/AiMilvusClientManager.java

@@ -1,23 +0,0 @@
-package tech.easyflow.ai.config;
-
-import com.easyagents.store.milvus.MilvusClientManager;
-import jakarta.annotation.PreDestroy;
-import org.springframework.stereotype.Component;
-import org.springframework.context.annotation.Lazy;
-
-/**
- * 应用级 Milvus 客户端池。
- */
-@Component
-@Lazy
-public class AiMilvusClientManager extends MilvusClientManager {
-
-    public AiMilvusClientManager(AiMilvusConfig config) {
-        super(config);
-    }
-
-    @PreDestroy
-    public void destroy() {
-        close();
-    }
-}

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/config/AiMilvusConfig.java

@@ -17,14 +17,6 @@ public class AiMilvusConfig extends MilvusVectorStoreConfig {
         config.setPassword(getPassword());
         config.setAutoCreateCollection(isAutoCreateCollection());
         config.setDefaultCollectionName(collectionName);
-        config.setPoolMaxTotal(getPoolMaxTotal());
-        config.setPoolMaxTotalPerKey(getPoolMaxTotalPerKey());
-        config.setPoolMaxIdlePerKey(getPoolMaxIdlePerKey());
-        config.setPoolMinIdlePerKey(getPoolMinIdlePerKey());
-        config.setPoolMaxWaitMillis(getPoolMaxWaitMillis());
-        config.setPoolEvictionIntervalMillis(getPoolEvictionIntervalMillis());
-        config.setPoolMinEvictableIdleMillis(getPoolMinEvictableIdleMillis());
-        config.setSearchTimeoutMillis(getSearchTimeoutMillis());
         return config;
     }
 }

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/config/AiModuleConfig.java

@@ -14,8 +14,7 @@ import tech.easyflow.ai.documentimport.task.DocumentImportStatusBroadcastPropert
     DocumentImportBulkProperties.class,
     DocumentImportParseMonitorProperties.class,
     DocumentImportStatusBroadcastProperties.class,
-    RagHealthProperties.class,
+    RagHealthProperties.class
-    MultiKnowledgeRetrievalProperties.class
 })
 @AutoConfiguration
 public class AiModuleConfig {

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/config/EasyFlowThreadPoolProperties.java

@@ -11,7 +11,6 @@ public class EasyFlowThreadPoolProperties {
     private Pool sse = new Pool(4, 16, 2000, 30, true);
     private Pool documentImport = new Pool(2, 4, 200, 60, true);
     private Pool agentAsyncTool = new Pool(2, 8, 200, 60, true);
-    private Pool knowledgeRetrieval = new Pool(4, 8, 64, 30, true);
 
     /**
      * 获取 SSE 线程池配置。
@@ -67,14 +66,6 @@ public class EasyFlowThreadPoolProperties {
         this.agentAsyncTool = agentAsyncTool;
     }
 
-    public Pool getKnowledgeRetrieval() {
-        return knowledgeRetrieval;
-    }
-
-    public void setKnowledgeRetrieval(Pool knowledgeRetrieval) {
-        this.knowledgeRetrieval = knowledgeRetrieval;
-    }
-
     /**
      * 线程池配置项。
      */

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/config/MultiKnowledgeRetrievalProperties.java

@@ -1,108 +0,0 @@
-package tech.easyflow.ai.config;
-
-import org.springframework.boot.context.properties.ConfigurationProperties;
-
-import java.time.Duration;
-
-/**
- * 工作流多知识库向量检索的资源与时限配置。
- */
-@ConfigurationProperties(prefix = "easyflow.ai.knowledge.multi-retrieval")
-public class MultiKnowledgeRetrievalProperties {
-
-    private int maxSources = 8;
-    private int candidateMultiplier = 5;
-    private int perSourceCandidateLimit = 50;
-    private int totalCandidateLimit = 400;
-    private double minVectorScore = 0.6D;
-    private Duration perSourceTimeout = Duration.ofSeconds(10);
-    private Duration totalTimeout = Duration.ofSeconds(20);
-
-    public int getMaxSources() {
-        return maxSources;
-    }
-
-    public void setMaxSources(int maxSources) {
-        this.maxSources = maxSources;
-    }
-
-    public int getCandidateMultiplier() {
-        return candidateMultiplier;
-    }
-
-    public void setCandidateMultiplier(int candidateMultiplier) {
-        this.candidateMultiplier = candidateMultiplier;
-    }
-
-    public int getPerSourceCandidateLimit() {
-        return perSourceCandidateLimit;
-    }
-
-    public void setPerSourceCandidateLimit(int perSourceCandidateLimit) {
-        this.perSourceCandidateLimit = perSourceCandidateLimit;
-    }
-
-    public int getTotalCandidateLimit() {
-        return totalCandidateLimit;
-    }
-
-    public void setTotalCandidateLimit(int totalCandidateLimit) {
-        this.totalCandidateLimit = totalCandidateLimit;
-    }
-
-    public double getMinVectorScore() {
-        return minVectorScore;
-    }
-
-    public void setMinVectorScore(double minVectorScore) {
-        this.minVectorScore = minVectorScore;
-    }
-
-    public Duration getPerSourceTimeout() {
-        return perSourceTimeout;
-    }
-
-    public void setPerSourceTimeout(Duration perSourceTimeout) {
-        this.perSourceTimeout = perSourceTimeout;
-    }
-
-    public Duration getTotalTimeout() {
-        return totalTimeout;
-    }
-
-    public void setTotalTimeout(Duration totalTimeout) {
-        this.totalTimeout = totalTimeout;
-    }
-
-    /**
-     * 启动期校验全部有界配置。
-     */
-    public void validate() {
-        if (maxSources < 2 || maxSources > 64) {
-            throw new IllegalArgumentException("多知识库最大来源数必须在 2 到 64 之间");
-        }
-        if (candidateMultiplier < 1 || candidateMultiplier > 20) {
-            throw new IllegalArgumentException("多知识库候选倍率必须在 1 到 20 之间");
-        }
-        if (perSourceCandidateLimit < 1 || perSourceCandidateLimit > 1000) {
-            throw new IllegalArgumentException("单知识库候选上限必须在 1 到 1000 之间");
-        }
-        long derivedCandidateLimit = (long) maxSources
-                * perSourceCandidateLimit;
-        if (totalCandidateLimit < derivedCandidateLimit
-                || totalCandidateLimit > 10000) {
-            throw new IllegalArgumentException(
-                    "多知识库总候选上限不能小于最大来源数与单库候选上限的乘积");
-        }
-        if (!Double.isFinite(minVectorScore) || minVectorScore < 0D || minVectorScore > 1D) {
-            throw new IllegalArgumentException("多知识库向量阈值必须在 0 到 1 之间");
-        }
-        if (perSourceTimeout == null || perSourceTimeout.isZero() || perSourceTimeout.isNegative()) {
-            throw new IllegalArgumentException("单知识库超时时间必须大于 0");
-        }
-        if (totalTimeout == null || totalTimeout.isZero() || totalTimeout.isNegative()
-                || totalTimeout.compareTo(perSourceTimeout) < 0) {
-            throw new IllegalArgumentException("节点总超时时间不能小于单知识库超时时间");
-        }
-    }
-}

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/config/RagHealthIndicator.java

@@ -25,23 +25,16 @@ public class RagHealthIndicator {
     public static class RagMilvusHealthIndicator extends CachedHealthIndicatorSupport implements HealthIndicator {
 
         private final AiMilvusConfig aiMilvusConfig;
-        private final AiMilvusClientManager milvusClientManager;
 
         /**
          * 创建 Milvus 健康检查器。
          *
          * @param aiMilvusConfig Milvus 配置
-         * @param milvusClientManager 应用级 Milvus 客户端池
          * @param healthProperties RAG 健康检查配置
          */
-        public RagMilvusHealthIndicator(
+        public RagMilvusHealthIndicator(AiMilvusConfig aiMilvusConfig, RagHealthProperties healthProperties) {
-            AiMilvusConfig aiMilvusConfig,
-            AiMilvusClientManager milvusClientManager,
-            RagHealthProperties healthProperties
-        ) {
             super(healthProperties);
             this.aiMilvusConfig = aiMilvusConfig;
-            this.milvusClientManager = milvusClientManager;
         }
 
         /**
@@ -58,10 +51,8 @@ public class RagHealthIndicator {
         protected Health doHealthCheck() {
             MilvusVectorStore vectorStore = null;
             try {
-                milvusClientManager.reconfigureIfNeeded(aiMilvusConfig);
                 vectorStore = new MilvusVectorStore(
-                    aiMilvusConfig.copyForCollection("__rag_health_probe__"),
+                    aiMilvusConfig.copyForCollection("__rag_health_probe__")
-                    milvusClientManager
                 );
                 if (vectorStore.checkAvailable()) {
                     return Health.up().withDetail("uri", aiMilvusConfig.getUri()).build();

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/config/ThreadPoolConfig.java

@@ -104,28 +104,4 @@ public class ThreadPoolConfig {
         executor.initialize();
         return executor;
     }
-
-    /**
-     * 创建工作流多知识库检索线程池。
-     *
-     * @return 多知识库检索线程池
-     */
-    @Bean(name = "knowledgeRetrievalExecutor")
-    public ThreadPoolTaskExecutor knowledgeRetrievalExecutor() {
-        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
-        EasyFlowThreadPoolProperties.Pool pool = properties.getKnowledgeRetrieval();
-        executor.setCorePoolSize(pool.getCoreSize());
-        executor.setMaxPoolSize(pool.getMaxSize());
-        executor.setQueueCapacity(pool.getQueueCapacity());
-        executor.setKeepAliveSeconds(pool.getKeepAliveSeconds());
-        executor.setAllowCoreThreadTimeOut(pool.isAllowCoreThreadTimeout());
-        executor.setThreadNamePrefix("knowledge-retrieval-");
-        executor.setRejectedExecutionHandler((runnable, executorService) -> {
-            log.error("多知识库检索线程池过载，active={}, queue={}",
-                    executorService.getActiveCount(), executorService.getQueue().size());
-            throw new BusinessException("知识库检索繁忙，请稍后重试");
-        });
-        executor.initialize();
-        return executor;
-    }
 }

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/document/exception/DocumentParseBridgeException.java

@@ -75,10 +75,6 @@ public class DocumentParseBridgeException extends RuntimeException {
         return new DocumentParseBridgeException("task_failed", message);
     }
 
-    public static DocumentParseBridgeException taskNotFound(String message, Throwable cause) {
-        return new DocumentParseBridgeException("task_not_found", message, cause);
-    }
-
     public static DocumentParseBridgeException resultFetchFailed(String message, Throwable cause) {
         return new DocumentParseBridgeException("result_fetch_failed", message, cause);
     }

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/document/service/impl/DocumentParseBridgeServiceImpl.java

@@ -5,7 +5,6 @@ import com.easyagents.document.core.entity.ParseResponse;
 import com.easyagents.document.core.entity.ParseResult;
 import com.easyagents.document.core.entity.ParseTaskInfo;
 import com.easyagents.document.core.entity.ParseTaskStatus;
-import com.easyagents.document.core.exception.DocumentAsyncTaskNotFoundException;
 import com.easyagents.document.pdf.PdfDocumentParseService;
 import com.easyagents.document.pptx.PptxDocumentParseService;
 import com.easyagents.document.xlsx.XlsxDocumentParseService;
@@ -141,8 +140,6 @@ public class DocumentParseBridgeServiceImpl implements DocumentParseBridgeServic
             return parseResultMapper.map(taskStatus);
         } catch (DocumentParseBridgeException e) {
             throw e;
-        } catch (DocumentAsyncTaskNotFoundException e) {
-            throw DocumentParseBridgeException.taskNotFound("异步文档解析任务不存在", e);
         } catch (Exception e) {
             throw DocumentParseBridgeException.taskFailed("查询异步文档解析任务状态失败", e);
         }
@@ -178,9 +175,6 @@ public class DocumentParseBridgeServiceImpl implements DocumentParseBridgeServic
         } catch (DocumentParseBridgeException e) {
             LOG.error("桥接服务获取异步解析结果失败: providerTaskId={}", taskId, e);
             throw e;
-        } catch (DocumentAsyncTaskNotFoundException e) {
-            LOG.warn("桥接服务异步解析执行已丢失: providerTaskId={}", taskId);
-            throw DocumentParseBridgeException.taskNotFound("异步文档解析任务不存在", e);
         } catch (Exception e) {
             LOG.error("桥接服务获取异步解析结果异常: providerTaskId={}", taskId, e);
             throw DocumentParseBridgeException.resultFetchFailed("获取异步文档解析结果失败", e);
@@ -218,9 +212,6 @@ public class DocumentParseBridgeServiceImpl implements DocumentParseBridgeServic
         } catch (DocumentParseBridgeException e) {
             LOG.error("桥接服务查询异步解析任务状态失败: providerTaskId={}", taskId, e);
             throw e;
-        } catch (DocumentAsyncTaskNotFoundException e) {
-            LOG.warn("桥接服务异步解析执行已丢失: providerTaskId={}", taskId);
-            throw DocumentParseBridgeException.taskNotFound("异步文档解析任务不存在", e);
         } catch (Exception e) {
             LOG.error("桥接服务查询异步解析任务状态异常: providerTaskId={}", taskId, e);
             throw DocumentParseBridgeException.taskFailed("聚合查询异步文档解析任务信息失败", e);

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/document/support/DocumentParseFilePolicy.java

@@ -1,86 +0,0 @@
-package tech.easyflow.ai.document.support;
-
-import java.util.List;
-import java.util.Locale;
-import java.util.Set;
-import java.util.stream.Collectors;
-
-/**
- * 知识库导入与工作流文档解析共用的文件格式策略。
- *
- * @author Codex
- * @since 2026-09-02
- */
-public final class DocumentParseFilePolicy {
-
-    private static final List<String> SUPPORTED_EXTENSION_ORDER =
-        List.of("txt", "pdf", "docx", "md", "pptx", "xlsx", "csv");
-    private static final Set<String> SUPPORTED_EXTENSIONS =
-        Set.copyOf(SUPPORTED_EXTENSION_ORDER);
-    private static final String SUPPORTED_TYPE_LABEL =
-        SUPPORTED_EXTENSION_ORDER.stream()
-            .map(extension -> extension.toUpperCase(Locale.ROOT))
-            .collect(Collectors.joining("、"));
-
-    /**
-     * 禁止实例化格式策略工具类。
-     */
-    private DocumentParseFilePolicy() {
-    }
-
-    /**
-     * 返回只读的支持格式集合。
-     *
-     * @return 支持的文件扩展名
-     */
-    public static Set<String> supportedExtensions() {
-        return SUPPORTED_EXTENSIONS;
-    }
-
-    /**
-     * 返回面向用户展示的支持格式列表。
-     *
-     * @return 大写扩展名列表
-     */
-    public static String supportedTypeLabel() {
-        return SUPPORTED_TYPE_LABEL;
-    }
-
-    /**
-     * 判断扩展名是否属于文档解析支持范围。
-     *
-     * @param extension 文件扩展名
-     * @return 支持时返回 {@code true}
-     */
-    public static boolean isSupportedExtension(String extension) {
-        return SUPPORTED_EXTENSIONS.contains(normalizeExtension(extension));
-    }
-
-    /**
-     * 判断文件名是否属于文档解析支持范围。
-     *
-     * @param fileName 文件名
-     * @return 支持时返回 {@code true}
-     */
-    public static boolean isSupportedFileName(String fileName) {
-        return isSupportedExtension(extensionOf(fileName));
-    }
-
-    /**
-     * 提取文件名中的小写扩展名。
-     *
-     * @param fileName 文件名
-     * @return 小写扩展名；无扩展名时返回空字符串
-     */
-    public static String extensionOf(String fileName) {
-        String normalizedName = fileName == null ? "" : fileName.trim();
-        int dotIndex = normalizedName.lastIndexOf('.');
-        return dotIndex < 0 || dotIndex == normalizedName.length() - 1
-            ? ""
-            : normalizeExtension(normalizedName.substring(dotIndex + 1));
-    }
-
-    private static String normalizeExtension(String extension) {
-        return extension == null ? "" : extension.trim().toLowerCase(Locale.ROOT);
-    }
-}

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/documentchunk/DocumentChunkSyncState.java

@@ -1,34 +0,0 @@
-package tech.easyflow.ai.documentchunk;
-
-/**
- * 分块检索索引同步状态常量。
- */
-public final class DocumentChunkSyncState {
-
-    private static final String PARENT_LOCK_PREFIX =
-        "easyflow:lock:document-chunk-parent:";
-    private static final String SYNC_LOCK_PREFIX =
-        "easyflow:lock:document-chunk-sync:";
-
-    public static final String SYNCED = "SYNCED";
-    public static final String PENDING = "PENDING";
-    public static final String FAILED = "FAILED";
-
-    public static final String TASK_RUNNING = "RUNNING";
-    public static final String TASK_SUCCEEDED = "SUCCEEDED";
-    public static final String TASK_SUPERSEDED = "SUPERSEDED";
-
-    public static final String OPERATION_UPSERT = "UPSERT";
-    public static final String OPERATION_DELETE = "DELETE";
-
-    public static String parentLockKey(Object documentId) {
-        return PARENT_LOCK_PREFIX + documentId;
-    }
-
-    public static String syncLockKey(Object chunkId) {
-        return SYNC_LOCK_PREFIX + chunkId;
-    }
-
-    private DocumentChunkSyncState() {
-    }
-}

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/documentchunk/DocumentChunkSyncTaskAppService.java

@@ -1,414 +0,0 @@
-package tech.easyflow.ai.documentchunk;
-
-import com.easyagents.core.model.embedding.EmbeddingModel;
-import com.easyagents.core.model.embedding.EmbeddingOptions;
-import com.easyagents.core.store.DocumentStore;
-import com.easyagents.core.store.StoreOptions;
-import com.easyagents.core.store.StoreResult;
-import com.easyagents.search.engine.service.DocumentSearcher;
-import com.easyagents.search.engine.service.KeywordSearchMetadataKeys;
-import com.easyagents.store.milvus.MilvusVectorStore;
-import com.easyagents.store.milvus.MilvusVectorStoreConfig;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.stereotype.Service;
-import org.springframework.beans.factory.ObjectProvider;
-import org.springframework.transaction.PlatformTransactionManager;
-import org.springframework.transaction.support.TransactionTemplate;
-import tech.easyflow.ai.config.AiMilvusClientManager;
-import tech.easyflow.ai.config.AiMilvusConfig;
-import tech.easyflow.ai.config.SearcherFactory;
-import tech.easyflow.ai.entity.DocumentChunk;
-import tech.easyflow.ai.entity.DocumentChunkSyncTask;
-import tech.easyflow.ai.entity.DocumentCollection;
-import tech.easyflow.ai.entity.Model;
-import tech.easyflow.ai.mapper.DocumentChunkMapper;
-import tech.easyflow.ai.mapper.DocumentChunkSyncTaskMapper;
-import tech.easyflow.ai.service.DocumentCollectionService;
-import tech.easyflow.ai.service.ModelService;
-import tech.easyflow.ai.support.DocumentStoreLifecycleSupport;
-import tech.easyflow.common.cache.RedisLockExecutor;
-
-import java.math.BigInteger;
-import java.time.Duration;
-import java.util.Collections;
-import java.util.Date;
-import java.util.UUID;
-
-/**
- * 持久化分块索引同步任务的投递、执行和恢复。
- */
-@Service
-public class DocumentChunkSyncTaskAppService {
-
-    private static final Logger LOG = LoggerFactory.getLogger(DocumentChunkSyncTaskAppService.class);
-    private static final int MAX_ATTEMPTS = 5;
-    private static final int DISPATCH_LIMIT = 100;
-    private static final long REDISPATCH_MILLIS = 5_000L;
-    private static final long LEASE_MILLIS = 300_000L;
-
-    private final DocumentChunkSyncTaskMapper taskMapper;
-    private final DocumentChunkMapper chunkMapper;
-    private final DocumentCollectionService collectionService;
-    private final ModelService modelService;
-    private final SearcherFactory searcherFactory;
-    private final DocumentChunkSyncTaskProducer producer;
-    private final PlatformTransactionManager transactionManager;
-    private final RedisLockExecutor redisLockExecutor;
-    private final AiMilvusConfig milvusConfig;
-    private final ObjectProvider<AiMilvusClientManager> milvusClientManagerProvider;
-
-    public DocumentChunkSyncTaskAppService(
-        DocumentChunkSyncTaskMapper taskMapper,
-        DocumentChunkMapper chunkMapper,
-        DocumentCollectionService collectionService,
-        ModelService modelService,
-        SearcherFactory searcherFactory,
-        DocumentChunkSyncTaskProducer producer,
-        PlatformTransactionManager transactionManager,
-        RedisLockExecutor redisLockExecutor,
-        AiMilvusConfig milvusConfig,
-        ObjectProvider<AiMilvusClientManager> milvusClientManagerProvider
-    ) {
-        this.taskMapper = taskMapper;
-        this.chunkMapper = chunkMapper;
-        this.collectionService = collectionService;
-        this.modelService = modelService;
-        this.searcherFactory = searcherFactory;
-        this.producer = producer;
-        this.transactionManager = transactionManager;
-        this.redisLockExecutor = redisLockExecutor;
-        this.milvusConfig = milvusConfig;
-        this.milvusClientManagerProvider = milvusClientManagerProvider;
-    }
-
-    public DocumentChunkSyncTask createTask(
-        DocumentChunk chunk,
-        DocumentCollection collection,
-        String operation,
-        long version,
-        Date now
-    ) {
-        taskMapper.supersedeOlder(chunk.getId(), version, now);
-        DocumentChunkSyncTask task = new DocumentChunkSyncTask();
-        task.setChunkId(chunk.getId());
-        task.setDocumentId(chunk.getDocumentId());
-        task.setDocumentCollectionId(chunk.getDocumentCollectionId());
-        task.setVectorCollection(collection.getVectorStoreCollection());
-        task.setOperation(operation);
-        task.setSyncVersion(version);
-        task.setStatus(DocumentChunkSyncState.PENDING);
-        task.setAttemptCount(0);
-        task.setNextRetryAt(now);
-        task.setCreated(now);
-        task.setModified(now);
-        if (taskMapper.insert(task) <= 0) {
-            throw new IllegalStateException("创建分块索引同步任务失败");
-        }
-        return task;
-    }
-
-    public void dispatchBestEffort(BigInteger taskId) {
-        try {
-            producer.send(taskId);
-        } catch (RuntimeException exception) {
-            LOG.warn("分块索引同步消息投递失败，等待数据库补投: taskId={}", taskId, exception);
-        }
-    }
-
-    public void dispatchPendingTasks() {
-        Date now = new Date();
-        taskMapper.recoverExpired(now);
-        Date redispatchBefore = new Date(now.getTime() - REDISPATCH_MILLIS);
-        for (DocumentChunkSyncTask task : taskMapper.selectPendingDue(
-            now,
-            redispatchBefore,
-            DISPATCH_LIMIT
-        )) {
-            if (taskMapper.markDispatched(task.getId(), now, redispatchBefore) <= 0) {
-                continue;
-            }
-            try {
-                producer.send(task.getId());
-            } catch (RuntimeException exception) {
-                LOG.warn("补投分块索引同步消息失败: taskId={}", task.getId(), exception);
-            }
-        }
-    }
-
-    public void handleTask(BigInteger taskId) {
-        DocumentChunkSyncTask snapshot = taskMapper.selectOneById(taskId);
-        if (snapshot == null || !DocumentChunkSyncState.PENDING.equals(snapshot.getStatus())) {
-            return;
-        }
-        redisLockExecutor.executeWithRenewingLock(
-            DocumentChunkSyncState.syncLockKey(snapshot.getChunkId()),
-            Duration.ofSeconds(3),
-            Duration.ofMinutes(5),
-            () -> {
-                claimAndExecute(taskId, snapshot.getChunkId());
-                return null;
-            }
-        );
-    }
-
-    private void claimAndExecute(BigInteger taskId, BigInteger chunkId) {
-        Date now = new Date();
-        String token = UUID.randomUUID().toString();
-        if (taskMapper.claim(
-            taskId,
-            token,
-            new Date(now.getTime() + LEASE_MILLIS),
-            now
-        ) <= 0) {
-            return;
-        }
-        new TransactionTemplate(transactionManager).executeWithoutResult(status ->
-            executeOwnedTask(taskId, chunkId, token)
-        );
-    }
-
-    private void executeOwnedTask(
-        BigInteger taskId,
-        BigInteger chunkId,
-        String token
-    ) {
-        // FOR UPDATE 必须是本事务的第一次读取。MySQL REPEATABLE READ 下，
-        // 若先做普通查询会建立旧快照，使删除或新版本建单已经提交后仍读取旧分块。
-        taskMapper.lockChunkTasks(chunkId);
-        DocumentChunkSyncTask task = taskMapper.selectOneById(taskId);
-        if (task == null
-            || !DocumentChunkSyncState.TASK_RUNNING.equals(task.getStatus())
-            || !token.equals(task.getExecutionToken())) {
-            return;
-        }
-        if (isSuperseded(task)) {
-            finishTask(task, token, DocumentChunkSyncState.TASK_SUPERSEDED, null, null);
-            return;
-        }
-        try {
-            synchronizeIndexes(task);
-            finishSuccess(task, token);
-        } catch (IndexSyncException exception) {
-            LOG.warn("分块索引同步失败: taskId={}, chunkId={}, code={}",
-                task.getId(), task.getChunkId(), exception.code, exception.getCause());
-            finishFailure(task, token, exception.code, exception.getMessage());
-        } catch (RuntimeException exception) {
-            LOG.error("分块索引同步发生未分类异常: taskId={}, chunkId={}",
-                task.getId(), task.getChunkId(), exception);
-            finishFailure(task, token, "INDEX_SYNC_FAILED", "检索索引同步失败");
-        }
-    }
-
-    private boolean isSuperseded(DocumentChunkSyncTask task) {
-        DocumentChunk chunk = chunkMapper.selectOneById(task.getChunkId());
-        if (DocumentChunkSyncState.OPERATION_DELETE.equals(task.getOperation())) {
-            return chunk != null;
-        }
-        return chunk == null
-            || chunk.getIndexSyncVersion() == null
-            || chunk.getIndexSyncVersion().longValue() != task.getSyncVersion().longValue()
-            || !DocumentChunkSyncState.PENDING.equals(chunk.getIndexSyncStatus());
-    }
-
-    private void synchronizeIndexes(DocumentChunkSyncTask task) {
-        if (DocumentChunkSyncState.OPERATION_DELETE.equals(task.getOperation())) {
-            synchronizeDelete(task);
-            return;
-        }
-        synchronizeUpsert(task);
-    }
-
-    private void synchronizeUpsert(DocumentChunkSyncTask task) {
-        DocumentChunk chunk = chunkMapper.selectOneById(task.getChunkId());
-        DocumentCollection collection = collectionService.getById(task.getDocumentCollectionId());
-        if (chunk == null || collection == null) {
-            throw new IndexSyncException("INDEX_SOURCE_MISSING", "分块或知识库不存在", null);
-        }
-        StoreContext context = prepareUpsertContext(collection, task.getVectorCollection());
-        try {
-            com.easyagents.core.document.Document document = toSearchDocument(chunk, task.getDocumentCollectionId());
-            StoreResult vectorResult = context.documentStore.update(
-                Collections.singletonList(document),
-                context.storeOptions
-            );
-            if (vectorResult == null || !vectorResult.isSuccess()) {
-                throw new IndexSyncException("VECTOR_UPSERT_FAILED", "向量索引更新失败", null);
-            }
-            if (context.searcher != null
-                && !context.searcher.addDocuments(Collections.singletonList(document))) {
-                throw new IndexSyncException("KEYWORD_UPSERT_FAILED", "关键词索引更新失败", null);
-            }
-        } catch (IndexSyncException exception) {
-            throw exception;
-        } catch (RuntimeException exception) {
-            throw new IndexSyncException("INDEX_UPSERT_FAILED", "检索索引更新失败", exception);
-        } finally {
-            DocumentStoreLifecycleSupport.closeQuietly(context.documentStore);
-        }
-    }
-
-    private void synchronizeDelete(DocumentChunkSyncTask task) {
-        MilvusVectorStoreConfig storeConfig = milvusConfig.copyForCollection(task.getVectorCollection());
-        AiMilvusClientManager clientManager = milvusClientManagerProvider.getObject();
-        clientManager.reconfigureIfNeeded(milvusConfig);
-        DocumentStore documentStore = new MilvusVectorStore(
-            storeConfig,
-            clientManager
-        );
-        StoreOptions storeOptions = StoreOptions.ofCollectionName(task.getVectorCollection());
-        DocumentSearcher searcher = searcherFactory.getSearcher();
-        try {
-            StoreResult result = documentStore.delete(
-                Collections.singletonList(task.getChunkId().toString()),
-                storeOptions
-            );
-            if (result == null || !result.isSuccess()) {
-                throw new IndexSyncException("VECTOR_DELETE_FAILED", "向量索引删除失败", null);
-            }
-            if (searcher != null && !searcher.deleteDocument(task.getChunkId())) {
-                throw new IndexSyncException("KEYWORD_DELETE_FAILED", "关键词索引删除失败", null);
-            }
-        } catch (IndexSyncException exception) {
-            throw exception;
-        } catch (RuntimeException exception) {
-            throw new IndexSyncException("INDEX_DELETE_FAILED", "检索索引删除失败", exception);
-        } finally {
-            DocumentStoreLifecycleSupport.closeQuietly(documentStore);
-        }
-    }
-
-    private StoreContext prepareUpsertContext(
-        DocumentCollection collection,
-        String vectorCollection
-    ) {
-        DocumentStore documentStore = collection.toDocumentStore();
-        if (documentStore == null) {
-            throw new IndexSyncException("VECTOR_STORE_MISSING", "知识库没有配置向量库", null);
-        }
-        try {
-            Model model = modelService.getModelInstance(collection.getVectorEmbedModelId());
-            if (model == null) {
-                throw new IndexSyncException("EMBEDDING_MODEL_MISSING", "知识库没有配置向量模型", null);
-            }
-            EmbeddingModel embeddingModel = model.toEmbeddingModel();
-            documentStore.setEmbeddingModel(embeddingModel);
-            StoreOptions options = StoreOptions.ofCollectionName(vectorCollection);
-            EmbeddingOptions embeddingOptions = new EmbeddingOptions();
-            embeddingOptions.setModel(model.getModelName());
-            embeddingOptions.setDimensions(collection.getDimensionOfVectorModel());
-            options.setEmbeddingOptions(embeddingOptions);
-            options.setIndexName(vectorCollection);
-            return new StoreContext(documentStore, options, searcherFactory.getSearcher());
-        } catch (RuntimeException exception) {
-            DocumentStoreLifecycleSupport.closeQuietly(documentStore);
-            throw exception;
-        }
-    }
-
-    private com.easyagents.core.document.Document toSearchDocument(
-        DocumentChunk chunk,
-        BigInteger knowledgeId
-    ) {
-        com.easyagents.core.document.Document document =
-            com.easyagents.core.document.Document.of(chunk.getContent());
-        document.setId(chunk.getId());
-        document.addMetadata(KeywordSearchMetadataKeys.KNOWLEDGE_ID, knowledgeId.toString());
-        return document;
-    }
-
-    private void finishSuccess(DocumentChunkSyncTask task, String token) {
-        new TransactionTemplate(transactionManager).executeWithoutResult(status -> {
-            if (taskMapper.finishOwned(
-                task.getId(), token, DocumentChunkSyncState.TASK_SUCCEEDED, null, null, new Date()
-            ) > 0 && DocumentChunkSyncState.OPERATION_UPSERT.equals(task.getOperation())) {
-                chunkMapper.updateSyncState(
-                    task.getChunkId(), task.getSyncVersion(), DocumentChunkSyncState.SYNCED, null, null
-                );
-            }
-        });
-    }
-
-    private void finishTask(
-        DocumentChunkSyncTask task,
-        String token,
-        String status,
-        String errorCode,
-        String errorMessage
-    ) {
-        taskMapper.finishOwned(task.getId(), token, status, errorCode, errorMessage, new Date());
-    }
-
-    private void finishFailure(
-        DocumentChunkSyncTask task,
-        String token,
-        String errorCode,
-        String errorMessage
-    ) {
-        int attempts = task.getAttemptCount() == null ? 1 : task.getAttemptCount();
-        boolean deleteOperation = DocumentChunkSyncState.OPERATION_DELETE.equals(
-            task.getOperation()
-        );
-        // 删除后已没有页面实体承载手动重试入口，因此清理任务必须保留为持久化 tombstone。
-        boolean exhausted = !deleteOperation && attempts >= MAX_ATTEMPTS;
-        String nextStatus = exhausted ? DocumentChunkSyncState.FAILED : DocumentChunkSyncState.PENDING;
-        long delaySeconds = Math.min(1L << Math.min(attempts, 6), 60L);
-        Date now = new Date();
-        Date nextRetryAt = exhausted ? now : new Date(now.getTime() + delaySeconds * 1_000L);
-        new TransactionTemplate(transactionManager).executeWithoutResult(status -> {
-            if (taskMapper.failOrRetryOwned(
-                task.getId(), token, nextStatus, nextRetryAt, errorCode, errorMessage, now
-            ) > 0 && exhausted && DocumentChunkSyncState.OPERATION_UPSERT.equals(task.getOperation())) {
-                chunkMapper.updateSyncState(
-                    task.getChunkId(), task.getSyncVersion(), DocumentChunkSyncState.FAILED,
-                    errorCode, errorMessage
-                );
-            }
-        });
-    }
-
-    public DocumentChunk retry(BigInteger chunkId, long syncVersion) {
-        Date now = new Date();
-        DocumentChunk chunk = chunkMapper.selectOneById(chunkId);
-        if (chunk == null || chunk.getIndexSyncVersion() == null
-            || chunk.getIndexSyncVersion().longValue() != syncVersion
-            || !DocumentChunkSyncState.FAILED.equals(chunk.getIndexSyncStatus())) {
-            throw new IllegalStateException("分块同步状态已变化，请刷新后重试");
-        }
-        DocumentChunkSyncTask task = taskMapper.selectFailed(chunkId, syncVersion);
-        if (task == null) {
-            throw new IllegalStateException("未找到可重试的索引同步任务");
-        }
-        new TransactionTemplate(transactionManager).executeWithoutResult(status -> {
-            if (taskMapper.retryFailed(task.getId(), chunkId, syncVersion, now) <= 0) {
-                throw new IllegalStateException("索引同步任务状态已变化");
-            }
-            if (chunkMapper.updateSyncState(
-                chunkId, syncVersion, DocumentChunkSyncState.PENDING, null, null
-            ) <= 0) {
-                throw new IllegalStateException("分块同步状态已变化");
-            }
-        });
-        dispatchBestEffort(task.getId());
-        chunk.setIndexSyncStatus(DocumentChunkSyncState.PENDING);
-        chunk.setIndexSyncErrorCode(null);
-        chunk.setIndexSyncErrorMessage(null);
-        return chunk;
-    }
-
-    private record StoreContext(
-        DocumentStore documentStore,
-        StoreOptions storeOptions,
-        DocumentSearcher searcher
-    ) {
-    }
-
-    private static final class IndexSyncException extends RuntimeException {
-        private final String code;
-
-        private IndexSyncException(String code, String message, Throwable cause) {
-            super(message, cause);
-            this.code = code;
-        }
-    }
-}

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/documentchunk/DocumentChunkSyncTaskConsumer.java

@@ -1,66 +0,0 @@
-package tech.easyflow.ai.documentchunk;
-
-import com.alibaba.fastjson2.JSON;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.stereotype.Component;
-import tech.easyflow.common.mq.config.MQProperties;
-import tech.easyflow.common.mq.core.MQConsumerHandler;
-import tech.easyflow.common.mq.core.MQDeferException;
-import tech.easyflow.common.mq.core.MQMessage;
-import tech.easyflow.common.mq.core.MQSubscription;
-
-import java.util.List;
-
-/**
- * 分块索引同步消息消费者。
- */
-@Component
-public class DocumentChunkSyncTaskConsumer implements MQConsumerHandler {
-
-    private static final Logger LOG = LoggerFactory.getLogger(DocumentChunkSyncTaskConsumer.class);
-
-    private final DocumentChunkSyncTaskAppService appService;
-    private final MQProperties mqProperties;
-
-    public DocumentChunkSyncTaskConsumer(
-        DocumentChunkSyncTaskAppService appService,
-        MQProperties mqProperties
-    ) {
-        this.appService = appService;
-        this.mqProperties = mqProperties;
-    }
-
-    @Override
-    public MQSubscription subscription() {
-        MQSubscription subscription = new MQSubscription();
-        subscription.setTopic(DocumentChunkSyncTaskProducer.TOPIC);
-        subscription.setConsumerGroup(DocumentChunkSyncTaskProducer.GROUP);
-        subscription.setShardCount(Math.max(
-            mqProperties.getRedis().getChatPersistShardCount(),
-            1
-        ));
-        subscription.setBatchEnabled(false);
-        return subscription;
-    }
-
-    @Override
-    public void handle(List<MQMessage> messages) {
-        for (MQMessage message : messages) {
-            DocumentChunkSyncTaskMessage event = JSON.parseObject(
-                message.getBody(),
-                DocumentChunkSyncTaskMessage.class
-            );
-            if (event == null || event.getTaskId() == null) {
-                LOG.warn("忽略非法分块索引同步消息: messageId={}", message.getMessageId());
-                continue;
-            }
-            try {
-                appService.handleTask(event.getTaskId());
-            } catch (RuntimeException exception) {
-                LOG.error("分块索引同步任务状态处理失败: taskId={}", event.getTaskId(), exception);
-                throw new MQDeferException("分块索引同步任务暂时无法处理", exception);
-            }
-        }
-    }
-}

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/documentchunk/DocumentChunkSyncTaskMessage.java

@@ -1,18 +0,0 @@
-package tech.easyflow.ai.documentchunk;
-
-import java.io.Serializable;
-import java.math.BigInteger;
-import java.util.Date;
-
-/**
- * 分块索引同步消息。
- */
-public class DocumentChunkSyncTaskMessage implements Serializable {
-    private BigInteger taskId;
-    private Date occurredAt;
-
-    public BigInteger getTaskId() { return taskId; }
-    public void setTaskId(BigInteger taskId) { this.taskId = taskId; }
-    public Date getOccurredAt() { return occurredAt; }
-    public void setOccurredAt(Date occurredAt) { this.occurredAt = occurredAt; }
-}

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/documentchunk/DocumentChunkSyncTaskMonitor.java

@@ -1,33 +0,0 @@
-package tech.easyflow.ai.documentchunk;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.scheduling.annotation.Scheduled;
-import org.springframework.stereotype.Component;
-import tech.easyflow.common.cache.DistributedScheduledLock;
-
-/**
- * 补投待同步任务并回收过期租约。
- */
-@Component
-public class DocumentChunkSyncTaskMonitor {
-
-    private static final Logger LOG = LoggerFactory.getLogger(DocumentChunkSyncTaskMonitor.class);
-
-    private final DocumentChunkSyncTaskAppService appService;
-
-    public DocumentChunkSyncTaskMonitor(DocumentChunkSyncTaskAppService appService) {
-        this.appService = appService;
-    }
-
-    @Scheduled(fixedDelayString = "${easyflow.ai.document-chunk-sync.dispatch-interval:2s}",
-        initialDelayString = "${easyflow.ai.document-chunk-sync.dispatch-interval:2s}")
-    @DistributedScheduledLock(key = "easyflow:schedule:document-chunk-index-sync", leaseSeconds = 2L)
-    public void dispatchPendingTasks() {
-        try {
-            appService.dispatchPendingTasks();
-        } catch (RuntimeException exception) {
-            LOG.error("分块索引同步补投失败", exception);
-        }
-    }
-}

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/documentchunk/DocumentChunkSyncTaskProducer.java

@@ -1,39 +0,0 @@
-package tech.easyflow.ai.documentchunk;
-
-import com.alibaba.fastjson2.JSON;
-import org.springframework.stereotype.Service;
-import tech.easyflow.common.mq.core.MQMessage;
-import tech.easyflow.common.mq.core.MQProducer;
-
-import java.math.BigInteger;
-import java.util.Date;
-
-/**
- * 分块索引同步消息生产者。
- */
-@Service
-public class DocumentChunkSyncTaskProducer {
-
-    static final String TOPIC = "document-chunk-index-sync";
-    static final String GROUP = "document-chunk-index-sync-group";
-
-    private final MQProducer mqProducer;
-
-    public DocumentChunkSyncTaskProducer(MQProducer mqProducer) {
-        this.mqProducer = mqProducer;
-    }
-
-    public void send(BigInteger taskId) {
-        Date now = new Date();
-        DocumentChunkSyncTaskMessage event = new DocumentChunkSyncTaskMessage();
-        event.setTaskId(taskId);
-        event.setOccurredAt(now);
-        MQMessage message = new MQMessage();
-        message.setMessageId("chunk-sync-" + taskId);
-        message.setTopic(TOPIC);
-        message.setKey(String.valueOf(taskId));
-        message.setCreatedAt(now);
-        message.setBody(JSON.toJSONString(event));
-        mqProducer.send(message);
-    }
-}

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/documentimport/task/DocumentImportBatchAppService.java

@@ -10,7 +10,6 @@ import org.springframework.transaction.support.TransactionSynchronization;
 import org.springframework.transaction.support.TransactionSynchronizationManager;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.web.multipart.MultipartFile;
-import tech.easyflow.ai.document.support.DocumentParseFilePolicy;
 import tech.easyflow.ai.documentimport.DocumentImportBatchCreateContext;
 import tech.easyflow.ai.documentimport.DocumentImportBatchDtos;
 import tech.easyflow.ai.documentimport.DocumentImportBatchRetryResult;
@@ -64,7 +63,7 @@ public class DocumentImportBatchAppService {
 
     private static final Logger LOG = LoggerFactory.getLogger(DocumentImportBatchAppService.class);
     private static final Set<String> SUPPORTED_EXTENSIONS =
-        DocumentParseFilePolicy.supportedExtensions();
+        DocumentImportFormatPolicy.supportedExtensions();
     private static final Duration BATCH_MUTATION_LOCK_LEASE = Duration.ofMinutes(30);
     private static final Duration RECOVERY_DISPATCH_LEASE = Duration.ofMinutes(2);
     private static final Duration RECOVERY_LEASE_RENEW_INTERVAL =
@@ -80,7 +79,6 @@ public class DocumentImportBatchAppService {
     private final DocumentMapper documentMapper;
     private final RedisLockExecutor redisLockExecutor;
     private final DocumentImportBatchCircuitBreaker circuitBreaker;
-    private final DocumentImportRecoveryCoordinator recoveryCoordinator;
 
     @Resource(name = "default")
     private FileStorageService storageService;
@@ -98,7 +96,6 @@ public class DocumentImportBatchAppService {
      * @param documentMapper 文档 Mapper
      * @param redisLockExecutor 分布式锁执行器
      * @param circuitBreaker 自动导入批次熔断器
-     * @param recoveryCoordinator 恢复令牌事务协调器
      */
     public DocumentImportBatchAppService(DocumentImportBatchService batchService,
                                          DocumentImportBatchItemService itemService,
@@ -109,8 +106,7 @@ public class DocumentImportBatchAppService {
                                          DocumentImportBatchItemMapper itemMapper,
                                          DocumentMapper documentMapper,
                                          RedisLockExecutor redisLockExecutor,
-                                         DocumentImportBatchCircuitBreaker circuitBreaker,
+                                         DocumentImportBatchCircuitBreaker circuitBreaker) {
-                                         DocumentImportRecoveryCoordinator recoveryCoordinator) {
         this.batchService = batchService;
         this.itemService = itemService;
         this.batchTracker = batchTracker;
@@ -121,7 +117,6 @@ public class DocumentImportBatchAppService {
         this.documentMapper = documentMapper;
         this.redisLockExecutor = redisLockExecutor;
         this.circuitBreaker = circuitBreaker;
-        this.recoveryCoordinator = recoveryCoordinator;
     }
 
     /**
@@ -1250,10 +1245,13 @@ public class DocumentImportBatchAppService {
         Date claimedAt = new Date();
         Date leaseUntil = new Date(
             claimedAt.getTime() + RECOVERY_DISPATCH_LEASE.toMillis());
+        if (batchMapper.claimRecoveryPending(
+            batchId, recoveryToken, leaseUntil, claimedAt) <= 0) {
+            return;
+        }
         try {
             DocumentImportBatch claimedBatch =
-                recoveryCoordinator.claim(
+                batchMapper.selectClaimedRecovery(batchId, recoveryToken);
-                    batchId, recoveryToken, leaseUntil, claimedAt);
             if (claimedBatch == null) {
                 LOG.info(
                     "批次恢复调度令牌已失效，旧持有者停止恢复: "
@@ -1285,8 +1283,9 @@ public class DocumentImportBatchAppService {
                 );
                 return;
             }
-            if (!recoveryCoordinator.finalizeRecovery(
+            int finalized = batchMapper.finalizeRecoveryPending(
-                batchId, recoveryToken, new Date())) {
+                batchId, recoveryToken, new Date());
+            if (finalized <= 0) {
                 LOG.info(
                     "批次恢复待办已变更，当前实例跳过收尾: "
                         + "batchId={}, recoveryToken={}",
@@ -1299,8 +1298,7 @@ public class DocumentImportBatchAppService {
                 if (!circuitBreaker.interruptRecoveryBatch(
                     batchId, recoveryToken, error)) {
                     LOG.info(
-                        "批次恢复异常发生时令牌已失效或已有并发推进，"
+                        "批次恢复异常发生时令牌已失效，跳过旧持有者熔断: "
-                            + "跳过当前持有者熔断: "
                             + "batchId={}, recoveryToken={}",
                         batchId,
                         recoveryToken
@@ -1351,13 +1349,13 @@ public class DocumentImportBatchAppService {
             Date renewedLeaseUntil = new Date(
                 nowMillis + RECOVERY_DISPATCH_LEASE.toMillis()
             );
-            boolean renewed = recoveryCoordinator.renew(
+            int renewed = batchMapper.renewRecoveryPendingLease(
                 batchId,
                 recoveryToken,
                 renewedLeaseUntil,
                 now
             );
-            if (!renewed) {
+            if (renewed <= 0) {
                 return false;
             }
             renewAfter.set(nowMillis + renewIntervalMillis);
@@ -1458,11 +1456,7 @@ public class DocumentImportBatchAppService {
         int dotIndex = fileName == null ? -1 : fileName.lastIndexOf('.');
         String extension = dotIndex < 0 ? "" : fileName.substring(dotIndex + 1).toLowerCase(Locale.ROOT);
         if (!SUPPORTED_EXTENSIONS.contains(extension)) {
-            throw new BusinessException(
+            throw new BusinessException("暂不支持该文件格式");
-                "暂不支持该文件格式，仅支持 "
-                    + DocumentParseFilePolicy.supportedTypeLabel()
-                    + " 文件"
-            );
         }
     }
 

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/documentimport/task/DocumentImportBatchCircuitBreaker.java

@@ -9,9 +9,7 @@ import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Propagation;
 import org.springframework.transaction.annotation.Transactional;
 import tech.easyflow.ai.entity.DocumentImportBatch;
-import tech.easyflow.ai.entity.DocumentImportBatchItem;
 import tech.easyflow.ai.entity.DocumentImportTask;
-import tech.easyflow.ai.enums.DocumentImportBatchItemStatus;
 import tech.easyflow.ai.enums.DocumentImportBatchStatus;
 import tech.easyflow.ai.enums.DocumentImportMode;
 import tech.easyflow.ai.enums.DocumentImportTaskStatus;
@@ -25,8 +23,6 @@ import java.sql.SQLRecoverableException;
 import java.sql.SQLTimeoutException;
 import java.sql.SQLTransientConnectionException;
 import java.util.Date;
-import java.util.List;
-import java.util.Objects;
 import java.util.concurrent.RejectedExecutionException;
 
 /**
@@ -139,18 +135,13 @@ public class DocumentImportBatchCircuitBreaker {
         if (recoveryToken == null || recoveryToken.isBlank()) {
             throw new IllegalArgumentException("恢复调度令牌不能为空");
         }
-        DocumentImportRecoveryException recoveryError =
-            findCause(error, DocumentImportRecoveryException.class);
         return interruptBatch(
             batchId,
             resolveReason(error),
             null,
             null,
             error,
-            recoveryToken,
+            recoveryToken
-            recoveryError == null
-                ? List.of()
-                : recoveryError.getFailureFenceItemIds()
         );
     }
 
@@ -220,7 +211,7 @@ public class DocumentImportBatchCircuitBreaker {
                                    String phase,
                                    Throwable error) {
         return interruptBatch(
-            batchId, reason, taskId, phase, error, null, List.of());
+            batchId, reason, taskId, phase, error, null);
     }
 
     /**
@@ -232,7 +223,6 @@ public class DocumentImportBatchCircuitBreaker {
      * @param phase 触发任务阶段，可为空
      * @param error 原始异常
      * @param recoveryToken 恢复调度令牌，可为空
-     * @param recoveryFailureItemIds 零重排时的初始失败项围栏
      * @return 批次是否已经停止运行；围栏失效时返回 {@code false}
      */
     private boolean interruptBatch(BigInteger batchId,
@@ -240,17 +230,11 @@ public class DocumentImportBatchCircuitBreaker {
                                    BigInteger taskId,
                                    String phase,
                                    Throwable error,
-                                   String recoveryToken,
+                                   String recoveryToken) {
-                                   List<BigInteger> recoveryFailureItemIds) {
         if (batchId == null) {
             return false;
         }
-        boolean fencedRecoveryFailure = recoveryToken != null
+        DocumentImportBatch batch = batchMapper.selectOneById(batchId);
-            && recoveryFailureItemIds != null
-            && !recoveryFailureItemIds.isEmpty();
-        // 批次行是后续 task/item 状态收口的根锁；所有熔断路径先锁定
-        // batch，避免多表围栏更新与任务完成事务形成 task -> batch 逆序。
-        DocumentImportBatch batch = batchMapper.selectForUpdate(batchId);
         if (batch == null) {
             LOG.warn(
                 "忽略无法关联批次的自动导入熔断请求: taskId={}, batchId={}",
@@ -265,39 +249,6 @@ public class DocumentImportBatchCircuitBreaker {
         }
 
         Date now = new Date();
-        if (fencedRecoveryFailure) {
-            if (!Boolean.TRUE.equals(batch.getRecoveryPending())
-                || !Objects.equals(recoveryToken, batch.getRecoveryToken())
-                || batch.getRecoveryLeaseUntil() == null
-                || !batch.getRecoveryLeaseUntil().after(now)) {
-                return false;
-            }
-            if (itemMapper.countActiveItems(batchId) > 0) {
-                LOG.info(
-                    "恢复失败熔断发现批次已有活跃文件项，保留运行批次: "
-                        + "batchId={}",
-                    batchId
-                );
-                return false;
-            }
-            for (BigInteger itemId : recoveryFailureItemIds) {
-                DocumentImportBatchItem item =
-                    itemMapper.selectForUpdate(itemId);
-                if (item == null
-                    || !batchId.equals(item.getBatchId())
-                    || !DocumentImportBatchItemStatus.FAILED
-                        .name().equals(item.getStatus())) {
-                    LOG.info(
-                        "恢复失败熔断发现等价并发推进，保留运行批次: "
-                            + "batchId={}, itemId={}, status={}",
-                        batchId,
-                        itemId,
-                        item == null ? null : item.getStatus()
-                    );
-                    return false;
-                }
-            }
-        }
         int interrupted;
         if (recoveryToken != null) {
             interrupted = batchMapper.interruptOwnedRecoveryBatch(
@@ -354,14 +305,6 @@ public class DocumentImportBatchCircuitBreaker {
      * @return 稳定错误码与用户可见摘要
      */
     private InterruptionReason resolveReason(Throwable error) {
-        DocumentImportRecoveryException recoveryError =
-            findCause(error, DocumentImportRecoveryException.class);
-        if (recoveryError != null) {
-            return new InterruptionReason(
-                recoveryError.getCode(),
-                recoveryError.getUserMessage()
-            );
-        }
         if (containsRedisFailure(error)) {
             return new InterruptionReason(
                 REDIS_UNAVAILABLE,
@@ -386,25 +329,6 @@ public class DocumentImportBatchCircuitBreaker {
         );
     }
 
-    /**
-     * 从异常链中查找指定类型。
-     *
-     * @param error 原始异常
-     * @param type 目标异常类型
-     * @param <T> 异常类型
-     * @return 匹配异常；不存在时返回 {@code null}
-     */
-    private <T extends Throwable> T findCause(Throwable error, Class<T> type) {
-        Throwable current = error;
-        while (current != null) {
-            if (type.isInstance(current)) {
-                return type.cast(current);
-            }
-            current = current.getCause();
-        }
-        return null;
-    }
-
     /**
      * 判断异常链是否来自 Redis/Lettuce。
      *

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/documentimport/task/DocumentImportBatchTracker.java

@@ -27,18 +27,6 @@ import java.util.Date;
 @Service
 public class DocumentImportBatchTracker {
 
-    /**
-     * 单文件恢复失败原因的事务内处理结果。
-     */
-    public enum FailedRetryErrorOutcome {
-        /** 失败原因已写回，文件项仍等待后续人工恢复。 */
-        ERROR_RECORDED,
-        /** 等价并发操作已把文件项推进出失败状态。 */
-        ALREADY_ADVANCED,
-        /** 批次或文件项已不再允许当前恢复请求写回。 */
-        REJECTED
-    }
-
     private final DocumentImportBatchService batchService;
     private final DocumentImportBatchItemService itemService;
     private final DocumentImportBatchMapper batchMapper;
@@ -76,31 +64,6 @@ public class DocumentImportBatchTracker {
         return batch;
     }
 
-    /**
-     * 在任务行变更前锁定所属批次，统一 batch -> task 锁序。
-     *
-     * <p>自动导入的任务生命周期由运行批次驱动，批次结束后不允许
-     * 旧任务继续推进。手动导入的上传批次可以先结束，用户之后再手动
-     * 执行分块和索引，因此只参与锁序，不以批次终态阻断后续任务。</p>
-     *
-     * @param batchId 批次 ID；无批次任务传入 {@code null}
-     * @return 批次存在且允许当前任务推进时为 {@code true}
-     */
-    public boolean lockBatchForTaskMutation(BigInteger batchId) {
-        if (batchId == null) {
-            return true;
-        }
-        DocumentImportBatch batch = batchMapper.selectForUpdate(batchId);
-        if (batch == null) {
-            return false;
-        }
-        if (DocumentImportMode.AUTO.name().equals(batch.getImportMode())) {
-            return DocumentImportBatchStatus.RUNNING.name().equals(
-                batch.getStatus());
-        }
-        return DocumentImportMode.MANUAL.name().equals(batch.getImportMode());
-    }
-
     /**
      * 查询批次文件项。
      *
@@ -144,8 +107,10 @@ public class DocumentImportBatchTracker {
         if (itemId == null) {
             return false;
         }
+        DocumentImportBatchItem current = requireItem(itemId);
         int attemptDelta = (status == DocumentImportBatchItemStatus.PENDING
             || status == DocumentImportBatchItemStatus.RUNNING)
+            && DocumentImportBatchItemStatus.FAILED.name().equals(current.getStatus())
             ? 1
             : 0;
         return transitionItem(itemId, stage, status, errorSummary,
@@ -197,34 +162,28 @@ public class DocumentImportBatchTracker {
         if (itemId == null) {
             return false;
         }
-        LockedBatchItem locked = lockBatchThenItem(itemId);
+        for (int attempt = 0; attempt < 3; attempt++) {
-        if (DocumentImportBatchStatus.INTERRUPTED.name()
+            DocumentImportBatchItem current = requireItem(itemId);
-            .equals(locked.batch.getStatus())) {
-            return false;
-        }
-        DocumentImportBatchItem current = locked.item;
             DocumentImportBatchItemStatus currentStatus =
                 DocumentImportBatchItemStatus.valueOf(current.getStatus());
             if (!isAllowedTransition(currentStatus, status)) {
                 return false;
             }
+            String expectedStatus = current.getStatus();
             Date now = new Date();
-        int effectiveAttemptDelta = currentStatus == DocumentImportBatchItemStatus.FAILED
-            ? Math.max(0, attemptDelta)
-            : 0;
             int updated = itemMapper.transitionStatus(
                 itemId,
-            current.getStatus(),
+                expectedStatus,
                 stage.name(),
                 status.name(),
                 errorSummary,
                 failureCode,
                 retryable,
-            effectiveAttemptDelta,
+                Math.max(0, attemptDelta),
                 now
             );
             if (updated <= 0) {
-            return false;
+                continue;
             }
             CounterDelta delta = CounterDelta.between(current, status, retryable);
             if (!delta.isZero()) {
@@ -244,6 +203,8 @@ public class DocumentImportBatchTracker {
             refreshBatch(current.getBatchId());
             return true;
         }
+        return false;
+    }
 
     /**
      * 校验文件项状态机，拒绝迟到任务覆盖终态。
@@ -282,12 +243,7 @@ public class DocumentImportBatchTracker {
      */
     @org.springframework.transaction.annotation.Transactional
     public void bindDocument(BigInteger itemId, BigInteger documentId) {
-        LockedBatchItem locked = lockBatchThenItem(itemId);
+        DocumentImportBatchItem item = requireItem(itemId);
-        if (DocumentImportBatchStatus.INTERRUPTED.name()
-            .equals(locked.batch.getStatus())) {
-            throw new BusinessException("导入批次已中断，请继续批次后重试");
-        }
-        DocumentImportBatchItem item = locked.item;
         if (documentId.equals(item.getDocumentId())
             && DocumentImportBatchItemStatus.PENDING.name().equals(item.getStatus())) {
             return;
@@ -296,11 +252,6 @@ public class DocumentImportBatchTracker {
         boolean recoveringFailedItem =
             DocumentImportBatchItemStatus.FAILED.name().equals(item.getStatus())
                 && item.getDocumentId() == null;
-        if (recoveringFailedItem
-            && !DocumentImportBatchStatus.RUNNING.name()
-                .equals(locked.batch.getStatus())) {
-            throw new BusinessException("导入批次状态已变化，请刷新后重试");
-        }
         int updated = recoveringFailedItem
             ? itemMapper.bindFailedDocument(itemId, documentId, now)
             : itemMapper.bindDocument(itemId, documentId, now);
@@ -317,91 +268,6 @@ public class DocumentImportBatchTracker {
         refreshBatch(item.getBatchId());
     }
 
-    /**
-     * 将引用已丢失文档的失败项重新绑定到恢复创建的新文档。
-     *
-     * @param itemId 文件项 ID
-     * @param missingDocumentId 已不存在的旧文档 ID
-     * @param documentId 恢复创建的新文档 ID
-     */
-    @org.springframework.transaction.annotation.Transactional
-    public void replaceMissingDocument(BigInteger itemId,
-                                       BigInteger missingDocumentId,
-                                       BigInteger documentId) {
-        LockedBatchItem locked = lockBatchThenItem(itemId);
-        if (!DocumentImportBatchStatus.RUNNING.name()
-            .equals(locked.batch.getStatus())) {
-            throw new BusinessException("导入批次状态已变化，请刷新后重试");
-        }
-        DocumentImportBatchItem item = locked.item;
-        if (!DocumentImportBatchItemStatus.FAILED.name().equals(item.getStatus())
-            || !java.util.Objects.equals(missingDocumentId, item.getDocumentId())) {
-            throw new BusinessException("导入文件状态已变化，请刷新后重试");
-        }
-        Date now = new Date();
-        if (itemMapper.replaceMissingDocument(
-            itemId, missingDocumentId, documentId, now) <= 0) {
-            throw new BusinessException("原文档状态已变化，请刷新后重试");
-        }
-        batchMapper.refreshCountersFromItems(item.getBatchId(), now);
-        refreshBatch(item.getBatchId());
-    }
-
-    /**
-     * 按批次到文件项的固定顺序取得失败项恢复权。
-     *
-     * @param itemId 文件项 ID
-     * @return 可恢复文件项；状态已变化时返回 null
-     */
-    @org.springframework.transaction.annotation.Transactional
-    public DocumentImportBatchItem lockFailedItemForRetry(BigInteger itemId) {
-        if (itemId == null) {
-            return null;
-        }
-        LockedBatchItem locked = lockBatchThenItem(itemId);
-        if (!DocumentImportBatchStatus.RUNNING.name()
-            .equals(locked.batch.getStatus())
-            || !DocumentImportBatchItemStatus.FAILED.name()
-                .equals(locked.item.getStatus())) {
-            return null;
-        }
-        return locked.item;
-    }
-
-    /**
-     * 在运行批次内保留单文件恢复失败原因。
-     *
-     * @param itemId 文件项 ID
-     * @param batchId 批次 ID
-     * @param errorSummary 错误摘要
-     * @return 失败原因写回、并发推进或拒绝结果
-     */
-    @org.springframework.transaction.annotation.Transactional(
-        propagation = org.springframework.transaction.annotation.Propagation.REQUIRES_NEW)
-    public FailedRetryErrorOutcome updateFailedRetryError(
-        BigInteger itemId,
-        BigInteger batchId,
-        String errorSummary
-    ) {
-        if (itemId == null || batchId == null) {
-            return FailedRetryErrorOutcome.REJECTED;
-        }
-        LockedBatchItem locked = lockBatchThenItem(itemId);
-        if (!batchId.equals(locked.batch.getId())
-            || !DocumentImportBatchStatus.RUNNING.name()
-                .equals(locked.batch.getStatus())) {
-            return FailedRetryErrorOutcome.REJECTED;
-        }
-        if (!DocumentImportBatchItemStatus.FAILED.name()
-            .equals(locked.item.getStatus())) {
-            return FailedRetryErrorOutcome.ALREADY_ADVANCED;
-        }
-        return itemMapper.updateFailedRetryError(
-            itemId, batchId, errorSummary, new Date()) > 0
-                ? FailedRetryErrorOutcome.ERROR_RECORDED
-                : FailedRetryErrorOutcome.REJECTED;
-    }
-
     /**
      * 原子完成文件上传并增量更新批次上传数。
      *
@@ -414,12 +280,7 @@ public class DocumentImportBatchTracker {
     public boolean completeUpload(BigInteger itemId,
                                   String filePath,
                                   String storageLocator) {
-        LockedBatchItem locked = lockBatchThenItem(itemId);
+        DocumentImportBatchItem item = requireItem(itemId);
-        if (DocumentImportBatchStatus.INTERRUPTED.name()
-            .equals(locked.batch.getStatus())) {
-            return false;
-        }
-        DocumentImportBatchItem item = locked.item;
         if (DocumentImportBatchItemStatus.UPLOADED.name().equals(item.getStatus())) {
             return filePath.equals(item.getFilePath())
                 && storageLocator.equals(item.getStorageLocator());
@@ -443,34 +304,6 @@ public class DocumentImportBatchTracker {
         return true;
     }
 
-    /**
-     * 先锁批次再锁文件项，统一所有计数迁移路径的加锁顺序。
-     *
-     * @param itemId 文件项 ID
-     * @return 已锁定的批次与文件项
-     */
-    private LockedBatchItem lockBatchThenItem(BigInteger itemId) {
-        DocumentImportBatchItem candidate = requireItem(itemId);
-        DocumentImportBatch batch = batchMapper.selectForUpdate(candidate.getBatchId());
-        if (batch == null) {
-            throw new BusinessException("导入批次不存在");
-        }
-        DocumentImportBatchItem item = itemMapper.selectForUpdate(itemId);
-        if (item == null) {
-            throw new BusinessException("导入文件不存在");
-        }
-        if (!java.util.Objects.equals(batch.getId(), item.getBatchId())) {
-            throw new IllegalStateException("导入文件批次归属已变化");
-        }
-        return new LockedBatchItem(batch, item);
-    }
-
-    private record LockedBatchItem(
-        DocumentImportBatch batch,
-        DocumentImportBatchItem item
-    ) {
-    }
-
     /**
      * 记录文件项成功后需要清理的历史文档。
      *

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/documentimport/task/DocumentImportFormatPolicy.java

@@ -0,0 +1,40 @@
+package tech.easyflow.ai.documentimport.task;
+
+import java.util.Set;
+
+/**
+ * 知识库文档导入格式统一策略。
+ *
+ * @author Codex
+ * @since 2026-08-04
+ */
+public final class DocumentImportFormatPolicy {
+
+    private static final Set<String> SUPPORTED_EXTENSIONS =
+        Set.of("txt", "pdf", "docx", "md", "pptx", "xlsx", "csv");
+
+    /**
+     * 禁止实例化格式策略工具类。
+     */
+    private DocumentImportFormatPolicy() {
+    }
+
+    /**
+     * 返回只读的支持格式集合。
+     *
+     * @return 支持的文件扩展名
+     */
+    public static Set<String> supportedExtensions() {
+        return SUPPORTED_EXTENSIONS;
+    }
+
+    /**
+     * 判断扩展名是否属于知识库导入支持范围。
+     *
+     * @param extension 已转换为小写的文件扩展名
+     * @return 支持时返回 {@code true}
+     */
+    public static boolean isSupported(String extension) {
+        return SUPPORTED_EXTENSIONS.contains(extension);
+    }
+}

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/documentimport/task/DocumentImportRecoveryCoordinator.java

@@ -1,75 +0,0 @@
-package tech.easyflow.ai.documentimport.task;
-
-import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Propagation;
-import org.springframework.transaction.annotation.Transactional;
-import tech.easyflow.ai.entity.DocumentImportBatch;
-import tech.easyflow.ai.mapper.DocumentImportBatchMapper;
-
-import java.math.BigInteger;
-import java.util.Date;
-
-/**
- * 在独立短事务中维护批次恢复令牌。
- *
- * <p>继续操作通常从原事务的 {@code afterCommit} 回调启动。将领取、续租和
- * 收尾放入独立事务，可保证恢复令牌在单文件重试事务开始前已经提交，并避免
- * 复用刚完成提交但尚未解绑的事务资源。</p>
- */
-@Service
-public class DocumentImportRecoveryCoordinator {
-
-    private final DocumentImportBatchMapper batchMapper;
-
-    public DocumentImportRecoveryCoordinator(DocumentImportBatchMapper batchMapper) {
-        this.batchMapper = batchMapper;
-    }
-
-    /**
-     * 领取恢复待办并读取本次令牌对应的恢复参数。
-     *
-     * @param batchId 批次 ID
-     * @param recoveryToken 恢复令牌
-     * @param leaseUntil 租约到期时间
-     * @param claimedAt 领取时间
-     * @return 已领取批次；领取失败时返回 null
-     */
-    @Transactional(propagation = Propagation.REQUIRES_NEW)
-    public DocumentImportBatch claim(BigInteger batchId,
-                                     String recoveryToken,
-                                     Date leaseUntil,
-                                     Date claimedAt) {
-        if (batchMapper.claimRecoveryPending(
-            batchId, recoveryToken, leaseUntil, claimedAt) <= 0) {
-            return null;
-        }
-        return batchMapper.selectClaimedRecovery(batchId, recoveryToken);
-    }
-
-    /**
-     * 续期当前恢复令牌。
-     *
-     * @return 当前令牌仍有效且续期成功时返回 true
-     */
-    @Transactional(propagation = Propagation.REQUIRES_NEW)
-    public boolean renew(BigInteger batchId,
-                         String recoveryToken,
-                         Date leaseUntil,
-                         Date renewedAt) {
-        return batchMapper.renewRecoveryPendingLease(
-            batchId, recoveryToken, leaseUntil, renewedAt) > 0;
-    }
-
-    /**
-     * 按真实计数收尾并清除恢复待办。
-     *
-     * @return 当前令牌仍有效且收尾成功时返回 true
-     */
-    @Transactional(propagation = Propagation.REQUIRES_NEW)
-    public boolean finalizeRecovery(BigInteger batchId,
-                                    String recoveryToken,
-                                    Date finalizedAt) {
-        return batchMapper.finalizeRecoveryPending(
-            batchId, recoveryToken, finalizedAt) > 0;
-    }
-}

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/documentimport/task/DocumentImportRecoveryException.java

@@ -1,71 +0,0 @@
-package tech.easyflow.ai.documentimport.task;
-
-import java.math.BigInteger;
-import java.util.Collection;
-import java.util.List;
-
-/**
- * 批次恢复未能重新排队任何失败项。
- *
- * <p>该异常只携带稳定错误码和用户可见摘要，供恢复令牌持有者
- * 中断批次，避免“继续”请求在没有启动任何新任务时表现为成功。</p>
- */
-public class DocumentImportRecoveryException extends RuntimeException {
-
-    private static final String ERROR_CODE = "document_import_recovery_failed";
-    private static final String USER_MESSAGE =
-        "未能重新排队任何失败文件，请查看文件错误后继续";
-    private final List<BigInteger> failureFenceItemIds;
-
-    /**
-     * 创建批次恢复失败异常。
-     */
-    public DocumentImportRecoveryException() {
-        this(List.of());
-    }
-
-    /**
-     * 创建带初始失败项快照的批次恢复失败异常。
-     *
-     * @param failureFenceItemIds 领取恢复时仍为失败的文件项 ID
-     */
-    public DocumentImportRecoveryException(
-        Collection<BigInteger> failureFenceItemIds
-    ) {
-        super(USER_MESSAGE);
-        this.failureFenceItemIds = failureFenceItemIds == null
-            ? List.of()
-            : failureFenceItemIds.stream()
-                .filter(java.util.Objects::nonNull)
-                .distinct()
-                .sorted()
-                .toList();
-    }
-
-    /**
-     * 获取稳定错误码。
-     *
-     * @return 稳定错误码
-     */
-    public String getCode() {
-        return ERROR_CODE;
-    }
-
-    /**
-     * 获取用户可见摘要。
-     *
-     * @return 用户可见摘要
-     */
-    public String getUserMessage() {
-        return USER_MESSAGE;
-    }
-
-    /**
-     * 获取用于原子熔断围栏的初始失败项。
-     *
-     * @return 按 ID 排序的不可变列表
-     */
-    public List<BigInteger> getFailureFenceItemIds() {
-        return failureFenceItemIds;
-    }
-}

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/documentimport/task/KnowledgeImportBatchFacade.java

@@ -8,7 +8,6 @@ import org.slf4j.LoggerFactory;
 import org.springframework.dao.DuplicateKeyException;
 import org.springframework.stereotype.Service;
 import org.springframework.web.multipart.MultipartFile;
-import tech.easyflow.ai.document.support.DocumentParseFilePolicy;
 import tech.easyflow.ai.documentimport.DocumentImportBatchCreateContext;
 import tech.easyflow.ai.documentimport.DocumentImportBatchDtos;
 import tech.easyflow.ai.documentimport.DocumentImportBatchRetryResult;
@@ -61,7 +60,7 @@ public class KnowledgeImportBatchFacade {
     private static final Duration INCOMPLETE_SUBMISSION_TIMEOUT =
         Duration.ofMinutes(30);
     private static final Set<String> SUPPORTED_EXTENSIONS =
-        DocumentParseFilePolicy.supportedExtensions();
+        DocumentImportFormatPolicy.supportedExtensions();
 
     private final DocumentImportBatchAppService batchAppService;
     private final DocumentImportBatchTracker batchTracker;
@@ -890,13 +889,7 @@ public class KnowledgeImportBatchFacade {
      */
     private void assertSupportedExtension(String fileName) {
         if (!SUPPORTED_EXTENSIONS.contains(extension(fileName))) {
-            throw new BusinessException(
+            throw new BusinessException(415, 41502, "暂不支持该文件格式");
-                415,
-                41502,
-                "暂不支持该文件格式，仅支持 "
-                    + DocumentParseFilePolicy.supportedTypeLabel()
-                    + " 文件"
-            );
         }
     }
 

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/dto/DocumentChunkAsyncUpdateResult.java

@@ -1,24 +0,0 @@
-package tech.easyflow.ai.dto;
-
-import tech.easyflow.ai.entity.DocumentChunk;
-
-import java.math.BigInteger;
-
-/**
- * 兼容 success 字段的异步分块更新结果。
- */
-public record DocumentChunkAsyncUpdateResult(
-    boolean success,
-    BigInteger id,
-    String indexSyncStatus,
-    Long indexSyncVersion
-) {
-    public static DocumentChunkAsyncUpdateResult from(DocumentChunk chunk) {
-        return new DocumentChunkAsyncUpdateResult(
-            true,
-            chunk.getId(),
-            chunk.getIndexSyncStatus(),
-            chunk.getIndexSyncVersion()
-        );
-    }
-}

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/dto/DocumentChunkContentUpdateRequest.java

@@ -1,29 +0,0 @@
-package tech.easyflow.ai.dto;
-
-import java.io.Serializable;
-import java.math.BigInteger;
-
-/**
- * 分块正文更新请求，只允许修改 Markdown 内容。
- */
-public class DocumentChunkContentUpdateRequest implements Serializable {
-
-    private BigInteger id;
-    private String content;
-
-    public BigInteger getId() {
-        return id;
-    }
-
-    public void setId(BigInteger id) {
-        this.id = id;
-    }
-
-    public String getContent() {
-        return content;
-    }
-
-    public void setContent(String content) {
-        this.content = content;
-    }
-}

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/dto/DocumentChunkDeleteResult.java

@@ -1,14 +0,0 @@
-package tech.easyflow.ai.dto;
-
-import java.io.Serializable;
-import java.math.BigInteger;
-
-/**
- * 分块删除结果。
- */
-public record DocumentChunkDeleteResult(
-    BigInteger id,
-    BigInteger documentId,
-    long remainingChunkCount
-) implements Serializable {
-}

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/dto/DocumentChunkSyncRetryRequest.java

@@ -1,16 +0,0 @@
-package tech.easyflow.ai.dto;
-
-import java.math.BigInteger;
-
-/**
- * 重试分块索引同步请求。
- */
-public class DocumentChunkSyncRetryRequest {
-    private BigInteger id;
-    private Long indexSyncVersion;
-
-    public BigInteger getId() { return id; }
-    public void setId(BigInteger id) { this.id = id; }
-    public Long getIndexSyncVersion() { return indexSyncVersion; }
-    public void setIndexSyncVersion(Long indexSyncVersion) { this.indexSyncVersion = indexSyncVersion; }
-}

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/dto/DocumentChunkSyncStatus.java

@@ -1,15 +0,0 @@
-package tech.easyflow.ai.dto;
-
-import java.math.BigInteger;
-
-/**
- * 分块索引同步状态。
- */
-public record DocumentChunkSyncStatus(
-    BigInteger id,
-    String indexSyncStatus,
-    Long indexSyncVersion,
-    String indexSyncErrorCode,
-    String indexSyncErrorMessage
-) {
-}

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/dto/DocumentChunkSyncStatusRequest.java

@@ -1,17 +0,0 @@
-package tech.easyflow.ai.dto;
-
-import java.math.BigInteger;
-import java.util.List;
-
-/**
- * 批量查询分块索引同步状态。
- */
-public class DocumentChunkSyncStatusRequest {
-    private BigInteger documentId;
-    private List<BigInteger> ids;
-
-    public BigInteger getDocumentId() { return documentId; }
-    public void setDocumentId(BigInteger documentId) { this.documentId = documentId; }
-    public List<BigInteger> getIds() { return ids; }
-    public void setIds(List<BigInteger> ids) { this.ids = ids; }
-}

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/easyagentsflow/cancellation/WorkflowDatasetQueryCancellationListener.java

@@ -0,0 +1,42 @@
+package tech.easyflow.ai.easyagentsflow.cancellation;
+
+import com.easyagents.flow.core.chain.Chain;
+import com.easyagents.flow.core.chain.ChainStatus;
+import com.easyagents.flow.core.chain.Event;
+import com.easyagents.flow.core.chain.event.ChainStatusChangeEvent;
+import com.easyagents.flow.core.chain.listener.ChainEventListener;
+import org.springframework.stereotype.Component;
+
+/**
+ * 将工作流取消终态桥接到活动数据集查询。
+ */
+@Component
+public class WorkflowDatasetQueryCancellationListener
+        implements ChainEventListener {
+
+    private final WorkflowDatasetQueryCancellationRegistry registry;
+
+    /**
+     * 创建工作流查询取消监听器。
+     *
+     * @param registry 工作流查询取消登记表
+     */
+    public WorkflowDatasetQueryCancellationListener(
+            WorkflowDatasetQueryCancellationRegistry registry) {
+        this.registry = registry;
+    }
+
+    /**
+     * 在工作流进入取消终态后取消该实例的活动查询。
+     *
+     * @param event 工作流事件
+     * @param chain 工作流实例
+     */
+    @Override
+    public void onEvent(Event event, Chain chain) {
+        if (event instanceof ChainStatusChangeEvent statusChangeEvent
+                && statusChangeEvent.getStatus() == ChainStatus.CANCELLED) {
+            registry.cancelExecution(chain.getStateInstanceId());
+        }
+    }
+}

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/easyagentsflow/cancellation/WorkflowDatasetQueryCancellationRegistry.java

@@ -0,0 +1,279 @@
+package tech.easyflow.ai.easyagentsflow.cancellation;
+
+import java.math.BigInteger;
+import java.time.Duration;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicBoolean;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.ObjectProvider;
+import org.springframework.data.redis.core.StringRedisTemplate;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+import tech.easyflow.common.entity.LoginAccount;
+import tech.easyflow.common.web.exceptions.BusinessException;
+import tech.easyflow.datacenter.federation.DatacenterFederationQueryCancellationService;
+
+/**
+ * 维护工作流实例到活动数据集查询的跨节点取消映射。
+ */
+@Component
+public class WorkflowDatasetQueryCancellationRegistry {
+
+    private static final String ACTIVE_KEY_PREFIX =
+            "easyflow:workflow:dataset-query:active:";
+    private static final String CANCELLED_KEY_PREFIX =
+            "easyflow:workflow:dataset-query:cancelled:";
+    private static final Duration STATE_TTL = Duration.ofHours(24);
+    private static final Logger log = LoggerFactory.getLogger(
+            WorkflowDatasetQueryCancellationRegistry.class);
+
+    private final DatacenterFederationQueryCancellationService cancellationService;
+    private final ObjectProvider<StringRedisTemplate> redisTemplateProvider;
+    private final ConcurrentHashMap<String, ConcurrentHashMap<String, BigInteger>>
+            localActive = new ConcurrentHashMap<>();
+    private final ConcurrentHashMap<String, Long> localCancelledUntil =
+            new ConcurrentHashMap<>();
+
+    /**
+     * 创建工作流查询取消登记表。
+     *
+     * @param cancellationService 数据中枢查询取消服务
+     * @param redisTemplateProvider 可选 Redis 模板
+     */
+    public WorkflowDatasetQueryCancellationRegistry(
+            DatacenterFederationQueryCancellationService cancellationService,
+            ObjectProvider<StringRedisTemplate> redisTemplateProvider) {
+        this.cancellationService = cancellationService;
+        this.redisTemplateProvider = redisTemplateProvider;
+    }
+
+    /**
+     * 在数据库查询开始前登记工作流与 QueryId。
+     *
+     * @param stateInstanceId 工作流实例 ID
+     * @param account 执行账号
+     * @param queryId 查询 UUID
+     * @return 必须关闭的登记句柄
+     * @throws BusinessException 参数缺失时抛出
+     */
+    public Registration register(
+            String stateInstanceId,
+            LoginAccount account,
+            String queryId) {
+        String instanceId = requireText(stateInstanceId, "工作流实例 ID 不能为空");
+        String normalizedQueryId = requireText(queryId, "queryId 不能为空");
+        BigInteger tenantId = requireTenantId(account);
+        localActive.computeIfAbsent(
+                        instanceId,
+                        ignored -> new ConcurrentHashMap<>())
+                .put(normalizedQueryId, tenantId);
+        persistActive(instanceId, normalizedQueryId, tenantId);
+        Registration registration = new Registration(
+                instanceId, normalizedQueryId, tenantId);
+        if (isExecutionCancelled(instanceId)) {
+            cancelQuery(normalizedQueryId, tenantId);
+        }
+        return registration;
+    }
+
+    /**
+     * 取消工作流当前登记的全部数据集查询。
+     *
+     * @param stateInstanceId 工作流实例 ID
+     * @return 是否发现至少一个活动查询
+     */
+    public boolean cancelExecution(String stateInstanceId) {
+        String instanceId = requireText(stateInstanceId, "工作流实例 ID 不能为空");
+        long expiresAt = System.currentTimeMillis() + STATE_TTL.toMillis();
+        localCancelledUntil.put(instanceId, expiresAt);
+        persistCancellationMarker(instanceId);
+
+        Map<String, BigInteger> active = new LinkedHashMap<>();
+        ConcurrentHashMap<String, BigInteger> local = localActive.get(instanceId);
+        if (local != null) {
+            active.putAll(local);
+        }
+        loadPersistedActive(instanceId).forEach(active::putIfAbsent);
+        active.forEach((queryId, tenantId) -> {
+            try {
+                cancelQuery(queryId, tenantId);
+            } catch (RuntimeException exception) {
+                // 单个驱动取消失败不能阻断同一工作流的其他活动查询。
+                log.error("Failed to cancel workflow dataset query {} for {}",
+                        queryId, instanceId, exception);
+            }
+        });
+        return !active.isEmpty();
+    }
+
+    /**
+     * 清理本机已过期的取消墓碑，避免不可达工作流持续占用内存。
+     */
+    @Scheduled(fixedDelayString =
+            "${easyflow.workflow.dataset-query-cancel-cleanup-ms:60000}")
+    public void cleanupExpiredLocalMarkers() {
+        long now = System.currentTimeMillis();
+        localCancelledUntil.entrySet().removeIf(
+                entry -> entry.getValue() <= now);
+    }
+
+    private void cancelQuery(String queryId, BigInteger tenantId) {
+        LoginAccount account = new LoginAccount();
+        account.setTenantId(tenantId);
+        cancellationService.cancel(queryId, account);
+    }
+
+    private boolean isExecutionCancelled(String stateInstanceId) {
+        Long localDeadline = localCancelledUntil.get(stateInstanceId);
+        if (localDeadline != null && localDeadline > System.currentTimeMillis()) {
+            return true;
+        }
+        StringRedisTemplate redisTemplate = redisTemplateProvider.getIfAvailable();
+        if (redisTemplate == null) {
+            return false;
+        }
+        try {
+            return Boolean.TRUE.equals(redisTemplate.hasKey(
+                    cancelledKey(stateInstanceId)));
+        } catch (RuntimeException exception) {
+            log.warn("Failed to read workflow dataset cancellation marker for {}",
+                    stateInstanceId, exception);
+            return false;
+        }
+    }
+
+    private void persistActive(
+            String stateInstanceId,
+            String queryId,
+            BigInteger tenantId) {
+        StringRedisTemplate redisTemplate = redisTemplateProvider.getIfAvailable();
+        if (redisTemplate == null) {
+            return;
+        }
+        try {
+            String key = activeKey(stateInstanceId);
+            redisTemplate.opsForHash().put(key, queryId, tenantId.toString());
+            redisTemplate.expire(key, STATE_TTL);
+        } catch (RuntimeException exception) {
+            log.warn("Failed to persist workflow dataset query mapping for {}",
+                    stateInstanceId, exception);
+        }
+    }
+
+    private Map<String, BigInteger> loadPersistedActive(String stateInstanceId) {
+        StringRedisTemplate redisTemplate = redisTemplateProvider.getIfAvailable();
+        if (redisTemplate == null) {
+            return Map.of();
+        }
+        try {
+            Map<Object, Object> entries = redisTemplate.opsForHash()
+                    .entries(activeKey(stateInstanceId));
+            Map<String, BigInteger> active = new LinkedHashMap<>();
+            entries.forEach((queryId, tenantId) -> {
+                try {
+                    active.put(String.valueOf(queryId),
+                            new BigInteger(String.valueOf(tenantId)));
+                } catch (RuntimeException exception) {
+                    log.warn("Ignored invalid workflow dataset query mapping for {}",
+                            stateInstanceId, exception);
+                }
+            });
+            return active;
+        } catch (RuntimeException exception) {
+            log.warn("Failed to load workflow dataset query mappings for {}",
+                    stateInstanceId, exception);
+            return Map.of();
+        }
+    }
+
+    private void persistCancellationMarker(String stateInstanceId) {
+        StringRedisTemplate redisTemplate = redisTemplateProvider.getIfAvailable();
+        if (redisTemplate == null) {
+            return;
+        }
+        try {
+            redisTemplate.opsForValue().set(
+                    cancelledKey(stateInstanceId), "1", STATE_TTL);
+        } catch (RuntimeException exception) {
+            log.warn("Failed to persist workflow dataset cancellation marker for {}",
+                    stateInstanceId, exception);
+        }
+    }
+
+    private void unregister(
+            String stateInstanceId,
+            String queryId,
+            BigInteger tenantId) {
+        localActive.computeIfPresent(stateInstanceId, (ignored, queries) -> {
+            queries.remove(queryId, tenantId);
+            return queries.isEmpty() ? null : queries;
+        });
+        StringRedisTemplate redisTemplate = redisTemplateProvider.getIfAvailable();
+        if (redisTemplate == null) {
+            return;
+        }
+        try {
+            redisTemplate.opsForHash().delete(
+                    activeKey(stateInstanceId), queryId);
+        } catch (RuntimeException exception) {
+            log.warn("Failed to remove workflow dataset query mapping for {}",
+                    stateInstanceId, exception);
+        }
+    }
+
+    private String activeKey(String stateInstanceId) {
+        return ACTIVE_KEY_PREFIX + stateInstanceId;
+    }
+
+    private String cancelledKey(String stateInstanceId) {
+        return CANCELLED_KEY_PREFIX + stateInstanceId;
+    }
+
+    private String requireText(String value, String message) {
+        if (value == null || value.isBlank()) {
+            throw new BusinessException(message);
+        }
+        return value.trim();
+    }
+
+    private BigInteger requireTenantId(LoginAccount account) {
+        if (account == null || account.getTenantId() == null) {
+            throw new BusinessException("工作流数据集查询缺少执行租户");
+        }
+        return account.getTenantId();
+    }
+
+    /**
+     * 单次工作流查询登记句柄。
+     */
+    public final class Registration implements AutoCloseable {
+
+        private final String stateInstanceId;
+        private final String queryId;
+        private final BigInteger tenantId;
+        private final AtomicBoolean closed = new AtomicBoolean();
+
+        private Registration(
+                String stateInstanceId,
+                String queryId,
+                BigInteger tenantId) {
+            this.stateInstanceId = stateInstanceId;
+            this.queryId = queryId;
+            this.tenantId = tenantId;
+        }
+
+        /**
+         * 幂等注销当前工作流查询。
+         */
+        @Override
+        public void close() {
+            if (closed.compareAndSet(false, true)) {
+                unregister(stateInstanceId, queryId, tenantId);
+            }
+        }
+    }
+}

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/easyagentsflow/config/ChainExecutorConfig.java

@@ -14,6 +14,7 @@ import org.springframework.context.annotation.Configuration;
 import tech.easyflow.ai.easyagentsflow.listener.ChainErrorListenerForSave;
 import tech.easyflow.ai.easyagentsflow.listener.ChainEventListenerForSave;
 import tech.easyflow.ai.easyagentsflow.listener.NodeErrorListenerForSave;
+import tech.easyflow.ai.easyagentsflow.cancellation.WorkflowDatasetQueryCancellationListener;
 import tech.easyflow.ai.easyagentsflow.upload.WorkflowApiUploadCleanupListener;
 
 import javax.annotation.Resource;
@@ -40,6 +41,9 @@ public class ChainExecutorConfig {
     @Resource
     private WorkflowApiUploadCleanupListener workflowApiUploadCleanupListener;
     @Resource
+    private WorkflowDatasetQueryCancellationListener
+            workflowDatasetQueryCancellationListener;
+    @Resource
     private WorkflowExecutionBudgetProperties workflowExecutionBudgetProperties;
     @Resource
     private WorkflowRuntimeProperties workflowRuntimeProperties;
@@ -91,6 +95,9 @@ public class ChainExecutorConfig {
         chainExecutor.addEventListener(
                 ChainStatusChangeEvent.class,
                 workflowApiUploadCleanupListener);
+        chainExecutor.addEventListener(
+                ChainStatusChangeEvent.class,
+                workflowDatasetQueryCancellationListener);
         chainExecutor.addErrorListener(new ChainErrorListenerForSave());
         chainExecutor.addNodeErrorListener(new NodeErrorListenerForSave());
     }

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/easyagentsflow/knowledge/KnowledgeProviderImpl.java

@@ -5,7 +5,6 @@ import com.alibaba.fastjson2.JSONObject;
 import com.easyagents.flow.core.chain.Chain;
 import com.easyagents.flow.core.knowledge.Knowledge;
 import com.easyagents.flow.core.knowledge.KnowledgeProvider;
-import com.easyagents.flow.core.knowledge.KnowledgeSearchRequest;
 import com.easyagents.flow.core.node.KnowledgeNode;
 import org.springframework.stereotype.Component;
 import tech.easyflow.ai.rag.KnowledgeRetrievalRequest;
@@ -15,7 +14,6 @@ import tech.easyflow.ai.service.DocumentCollectionService;
 import javax.annotation.Resource;
 import java.math.BigInteger;
 import java.util.ArrayList;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 
@@ -28,9 +26,6 @@ public class KnowledgeProviderImpl implements KnowledgeProvider {
     @Resource
     private DocumentCollectionService documentCollectionService;
 
-    @Resource
-    private WorkflowMultiKnowledgeRetrievalService multiKnowledgeRetrievalService;
-
     /**
      * 获取知识库检索器。
      *
@@ -49,86 +44,24 @@ public class KnowledgeProviderImpl implements KnowledgeProvider {
                     int limit,
                     KnowledgeNode knowledgeNode,
                     Chain chain) {
-                return searchSingle(
-                        new BigInteger(id.toString()),
-                        keyword,
-                        limit,
-                        knowledgeNode);
-            }
-        };
-    }
-
-    @Override
-    public Map<String, Object> search(KnowledgeSearchRequest request) {
-        if (request == null || request.getKnowledgeIds().isEmpty()) {
-            return null;
-        }
-        List<BigInteger> knowledgeIds = new ArrayList<>();
-        for (Object id : request.getKnowledgeIds()) {
-            try {
-                knowledgeIds.add(new BigInteger(String.valueOf(id)));
-            } catch (RuntimeException exception) {
-                throw new IllegalArgumentException("知识库 ID 无效: " + id, exception);
-            }
-        }
-        if (knowledgeIds.size() == 1) {
-            List<Map<String, Object>> documents = searchSingle(
-                    knowledgeIds.get(0),
-                    request.getKeyword(),
-                    request.getLimit(),
-                    request.getKnowledgeNode());
-            return buildOutputs(documents);
-        }
-        if (!"VECTOR".equalsIgnoreCase(request.getRetrievalMode())) {
-            throw new IllegalArgumentException("多知识库检索仅支持 VECTOR 模式");
-        }
-        MultiKnowledgeRetrievalResult result = multiKnowledgeRetrievalService.search(
-                knowledgeIds,
-                request.getKeyword(),
-                request.getLimit(),
-                request.getKnowledgeNode() == null
-                        ? null
-                        : request.getKnowledgeNode().getId(),
-                request.getChain());
-        List<Map<String, Object>> documents = new ArrayList<>();
-        for (Document document : result.getDocuments()) {
-            documents.add(toWorkflowDocument(
-                    document,
-                    document.getMetadata("knowledgeId", null)));
-        }
-        return buildOutputs(documents);
-    }
-
-    private List<Map<String, Object>> searchSingle(
-            BigInteger knowledgeId,
-            String keyword,
-            int limit,
-            KnowledgeNode knowledgeNode) {
                 KnowledgeRetrievalRequest request = new KnowledgeRetrievalRequest();
-        request.setKnowledgeId(knowledgeId);
+                request.setKnowledgeId(new BigInteger(id.toString()));
                 request.setQuery(keyword);
                 request.setLimit(limit);
-        request.setRetrievalMode(KnowledgeRetrievalModes.parse(
+                request.setRetrievalMode(KnowledgeRetrievalModes.parse(knowledgeNode.getRetrievalMode()));
-                knowledgeNode == null
-                        ? null
-                        : knowledgeNode.getRetrievalMode()));
                 request.setCallerType("WORKFLOW");
-        request.setCallerId(knowledgeNode == null ? null : knowledgeNode.getId());
+                request.setCallerId(knowledgeNode.getId());
                 List<Document> documents = documentCollectionService.search(request);
                 if (limit > 0 && documents.size() > limit) {
                     documents = new ArrayList<>(documents.subList(0, limit));
                 }
-        List<Map<String, Object>> result = new ArrayList<>();
+                List<Map<String, Object>> res = new ArrayList<>();
                 for (Document document : documents) {
-            result.add(toWorkflowDocument(document, knowledgeId));
+                    res.add(toWorkflowDocument(document, id));
                 }
-        return result;
+                return res;
             }
-
+        };
-    private Map<String, Object> buildOutputs(List<Map<String, Object>> documents) {
-        Map<String, Object> outputs = new LinkedHashMap<>();
-        outputs.put("documents", documents);
-        return outputs;
     }
 
     /**
@@ -141,7 +74,7 @@ public class KnowledgeProviderImpl implements KnowledgeProvider {
     private Map<String, Object> toWorkflowDocument(
             Document document, Object knowledgeId) {
         JSONObject result = JSONObject.from(document);
-        result.put("title", resolveWorkflowTitle(document));
+        result.put("title", document.getTitle());
         result.put("content", document.getContent());
         result.put(
                 "documentId",
@@ -149,30 +82,4 @@ public class KnowledgeProviderImpl implements KnowledgeProvider {
         result.put("knowledgeId", knowledgeId);
         return result;
     }
-
-    /**
-     * 获取工作流文档标题，兼容历史检索结果只在元数据中保存来源标题的情况。
-     *
-     * @param document 检索文档
-     * @return 工作流文档标题
-     */
-    private String resolveWorkflowTitle(Document document) {
-        String title = trimToNull(document.getTitle());
-        if (title != null) {
-            return title;
-        }
-        title = trimToNull(document.getMetadata("sourceFileName"));
-        if (title != null) {
-            return title;
-        }
-        return trimToNull(document.getMetadata("question"));
-    }
-
-    private String trimToNull(Object value) {
-        if (value == null) {
-            return null;
-        }
-        String text = String.valueOf(value).trim();
-        return text.isEmpty() ? null : text;
-    }
 }

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/easyagentsflow/knowledge/MultiKnowledgeRetrievalResult.java

@@ -1,46 +0,0 @@
-package tech.easyflow.ai.easyagentsflow.knowledge;
-
-import com.easyagents.core.document.Document;
-
-import java.util.Collections;
-import java.util.ArrayList;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-
-/**
- * 多知识库检索结果及可观察状态。
- */
-public class MultiKnowledgeRetrievalResult {
-
-    private final List<Document> documents;
-    private final Map<String, Object> summary;
-    private final List<Map<String, Object>> sourceStatuses;
-
-    public MultiKnowledgeRetrievalResult(
-            List<Document> documents,
-            Map<String, Object> summary,
-            List<Map<String, Object>> sourceStatuses) {
-        this.documents = documents == null
-                ? Collections.emptyList()
-                : Collections.unmodifiableList(new ArrayList<>(documents));
-        this.summary = summary == null
-                ? Collections.emptyMap()
-                : Collections.unmodifiableMap(new LinkedHashMap<>(summary));
-        this.sourceStatuses = sourceStatuses == null
-                ? Collections.emptyList()
-                : Collections.unmodifiableList(new ArrayList<>(sourceStatuses));
-    }
-
-    public List<Document> getDocuments() {
-        return documents;
-    }
-
-    public Map<String, Object> getSummary() {
-        return summary;
-    }
-
-    public List<Map<String, Object>> getSourceStatuses() {
-        return sourceStatuses;
-    }
-}

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/easyagentsflow/knowledge/WorkflowKnowledgeContractService.java

@@ -1,579 +0,0 @@
-package tech.easyflow.ai.easyagentsflow.knowledge;
-
-import com.alibaba.fastjson2.JSON;
-import com.alibaba.fastjson2.JSONArray;
-import com.alibaba.fastjson2.JSONObject;
-import org.springframework.stereotype.Service;
-import tech.easyflow.ai.entity.DocumentCollection;
-import tech.easyflow.ai.entity.Model;
-import tech.easyflow.ai.service.DocumentCollectionService;
-import tech.easyflow.ai.service.ModelService;
-import tech.easyflow.common.web.exceptions.BusinessException;
-
-import java.math.BigInteger;
-import java.nio.charset.StandardCharsets;
-import java.security.MessageDigest;
-import java.security.NoSuchAlgorithmException;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HexFormat;
-import java.util.LinkedHashMap;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Set;
-
-/**
- * 工作流多知识库 Embedding 契约校验与发布快照服务。
- */
-@Service
-public class WorkflowKnowledgeContractService {
-
-    public static final String SNAPSHOT_KEY = "knowledgeContracts";
-
-    private final DocumentCollectionService documentCollectionService;
-    private final ModelService modelService;
-
-    public WorkflowKnowledgeContractService(
-            DocumentCollectionService documentCollectionService,
-            ModelService modelService) {
-        this.documentCollectionService = documentCollectionService;
-        this.modelService = modelService;
-    }
-
-    /**
-     * 批量计算设计器中真正具备向量检索条件的知识库。
-     *
-     * @param collections 候选知识库
-     * @param tenantId 当前租户
-     * @return 可用知识库 ID
-     */
-    public Set<BigInteger> findVectorReadyKnowledgeIds(
-            List<DocumentCollection> collections,
-            BigInteger tenantId) {
-        if (collections == null || collections.isEmpty()) {
-            return Collections.emptySet();
-        }
-        Map<BigInteger, Model> models = loadModels(collections);
-        Set<BigInteger> result = new LinkedHashSet<>();
-        for (DocumentCollection collection : collections) {
-            if (isVectorReady(collection, models, tenantId)) {
-                result.add(collection.getId());
-            }
-        }
-        return result;
-    }
-
-    /**
-     * 校验保存阶段全部多知识库节点的 Embedding 契约。
-     *
-     * @param knowledgeGroups 各知识库节点的有序引用
-     * @param tenantId 当前租户
-     */
-    public void assertMultiKnowledgeContracts(
-            List<List<BigInteger>> knowledgeGroups,
-            BigInteger tenantId) {
-        resolveContext(onlyMultiGroups(knowledgeGroups), tenantId);
-    }
-
-    /**
-     * 解析工作流引用的全部知识库，并校验存在性与租户归属。
-     *
-     * @param content 工作流内容
-     * @param tenantId 工作流租户
-     * @return 按工作流首次引用顺序排列的知识库
-     */
-    public List<DocumentCollection> resolveReferencedCollections(
-            String content,
-            BigInteger tenantId) {
-        List<List<BigInteger>> groups = readKnowledgeGroups(content);
-        if (groups.isEmpty()) {
-            return List.of();
-        }
-        Set<BigInteger> ids = new LinkedHashSet<>();
-        groups.forEach(ids::addAll);
-        Map<BigInteger, DocumentCollection> collections = loadCollections(
-                ids, tenantId);
-        return ids.stream().map(collections::get).toList();
-    }
-
-    /**
-     * 校验工作流内容并生成不包含凭据的多知识库发布契约。
-     *
-     * @param content 工作流内容
-     * @param tenantId 工作流租户
-     * @return 稳定的发布契约列表
-     */
-    public List<Map<String, Object>> buildSnapshotContracts(
-            String content,
-            BigInteger tenantId) {
-        List<List<BigInteger>> groups = readKnowledgeGroups(content).stream()
-                .filter(group -> group.size() > 1)
-                .toList();
-        ContractContext context = resolveContext(groups, tenantId);
-        if (groups.isEmpty()) {
-            return List.of();
-        }
-        Set<BigInteger> orderedIds = new LinkedHashSet<>();
-        groups.forEach(orderedIds::addAll);
-        List<Map<String, Object>> result = new ArrayList<>();
-        for (BigInteger id : orderedIds) {
-            result.add(toContract(
-                    context.collections.get(id),
-                    context.models,
-                    tenantId));
-        }
-        return List.copyOf(result);
-    }
-
-    /**
-     * 审批真正发布前重新校验提交快照与当前知识库契约是否一致。
-     *
-     * @param resourceSnapshot 待发布工作流快照
-     */
-    public void assertSnapshotCurrent(Map<String, Object> resourceSnapshot) {
-        if (resourceSnapshot == null) {
-            throw new BusinessException("工作流发布快照不能为空");
-        }
-        String content = text(resourceSnapshot.get("content"));
-        BigInteger tenantId = bigInteger(resourceSnapshot.get("tenantId"));
-        List<Map<String, Object>> current = buildSnapshotContracts(
-                content, tenantId);
-        List<Map<String, Object>> frozen = readSnapshotContracts(
-                resourceSnapshot.get(SNAPSHOT_KEY));
-        if (!current.equals(frozen)) {
-            throw new BusinessException("工作流引用的知识库 Embedding 配置已变化，请重新提交发布");
-        }
-    }
-
-    /**
-     * 已发布工作流运行时校验本节点引用仍与发布契约一致。
-     *
-     * @param publishedSnapshot 已发布工作流快照
-     * @param collections 当前节点知识库
-     */
-    public Model assertPublishedContracts(
-            Map<String, Object> publishedSnapshot,
-            List<DocumentCollection> collections) {
-        if (collections == null || collections.size() < 2) {
-            throw new BusinessException("多知识库检索至少需要两个知识库");
-        }
-        if (publishedSnapshot == null || publishedSnapshot.isEmpty()) {
-            throw new BusinessException("已发布工作流缺少知识库契约");
-        }
-        BigInteger tenantId = bigInteger(publishedSnapshot.get("tenantId"));
-        ContractContext context = resolveLoadedContext(collections, tenantId);
-        Model embeddingModel = requireCompatibleEmbeddingModel(
-                collections, context, tenantId);
-        Map<String, Map<String, Object>> frozenById = new LinkedHashMap<>();
-        for (Map<String, Object> contract : readSnapshotContracts(
-                publishedSnapshot.get(SNAPSHOT_KEY))) {
-            frozenById.put(text(contract.get("knowledgeId")), contract);
-        }
-        for (DocumentCollection collection : collections) {
-            Map<String, Object> frozen = frozenById.get(
-                    String.valueOf(collection.getId()));
-            Map<String, Object> current = toContract(
-                    collection, context.models, tenantId);
-            if (!current.equals(frozen)) {
-                throw new BusinessException("已发布工作流的知识库 Embedding 配置已变化，请重新发布");
-            }
-        }
-        return embeddingModel;
-    }
-
-    /**
-     * 校验 Agent 冻结定义中的契约指纹与当前有效配置一致。
-     *
-     * @param expectedFingerprint 冻结定义中的契约指纹
-     * @param collections 定义引用的全部多知识库
-     * @param tenantId 冻结定义租户
-     */
-    public Model assertFrozenContractFingerprint(
-            String expectedFingerprint,
-            List<DocumentCollection> allCollections,
-            List<DocumentCollection> currentCollections,
-            BigInteger tenantId) {
-        ContractContext context = resolveLoadedContext(
-                allCollections, tenantId);
-        Model embeddingModel = requireCompatibleEmbeddingModel(
-                currentCollections, context, tenantId);
-        List<Map<String, Object>> current = new ArrayList<>();
-        for (DocumentCollection collection : allCollections) {
-            current.add(toContract(collection, context.models, tenantId));
-        }
-        if (!Objects.equals(expectedFingerprint, fingerprint(current))) {
-            throw new BusinessException("Agent 冻结工作流的知识库 Embedding 配置已变化，请重新发布 Agent");
-        }
-        return embeddingModel;
-    }
-
-    /**
-     * 使用已加载的知识库快照校验当前多库契约，并返回同一次批量读取的模型快照。
-     *
-     * @param collections 当前节点知识库快照
-     * @param tenantId 执行租户
-     * @return 已校验的 Embedding 模型快照
-     */
-    public Model requireCompatibleEmbeddingModel(
-            List<DocumentCollection> collections,
-            BigInteger tenantId) {
-        ContractContext context = resolveLoadedContext(collections, tenantId);
-        return requireCompatibleEmbeddingModel(
-                collections, context, tenantId);
-    }
-
-    /**
-     * 计算发布快照中规范知识库契约的稳定指纹。
-     *
-     * @param contracts 发布快照契约
-     * @return SHA-256 十六进制指纹
-     */
-    public String fingerprintSnapshotContracts(Object contracts) {
-        return fingerprint(readSnapshotContracts(contracts));
-    }
-
-    private ContractContext resolveContext(
-            List<List<BigInteger>> groups,
-            BigInteger tenantId) {
-        if (groups == null || groups.isEmpty()) {
-            return ContractContext.empty();
-        }
-        if (tenantId == null) {
-            throw new BusinessException("工作流租户不能为空");
-        }
-        Set<BigInteger> ids = new LinkedHashSet<>();
-        groups.forEach(ids::addAll);
-        Map<BigInteger, DocumentCollection> collections = loadCollections(
-                ids, tenantId);
-        Map<BigInteger, Model> models = loadModels(collections.values());
-        for (List<BigInteger> group : groups) {
-            assertCompatibleGroup(group, collections, models, tenantId);
-        }
-        return new ContractContext(collections, models);
-    }
-
-    private ContractContext resolveLoadedContext(
-            List<DocumentCollection> collections,
-            BigInteger tenantId) {
-        if (collections == null || collections.isEmpty()) {
-            throw new BusinessException("工作流引用的知识库不存在或已失效");
-        }
-        if (tenantId == null) {
-            throw new BusinessException("工作流租户不能为空");
-        }
-        Map<BigInteger, DocumentCollection> byId = new LinkedHashMap<>();
-        for (DocumentCollection collection : collections) {
-            if (collection == null || collection.getId() == null) {
-                throw new BusinessException("工作流引用的知识库不存在或已失效");
-            }
-            if (!Objects.equals(tenantId, collection.getTenantId())) {
-                throw new BusinessException("工作流引用了其他租户的知识库");
-            }
-            if (byId.put(collection.getId(), collection) != null) {
-                throw new BusinessException("知识库节点不能重复选择同一知识库");
-            }
-        }
-        return new ContractContext(byId, loadModels(collections));
-    }
-
-    private Model requireCompatibleEmbeddingModel(
-            List<DocumentCollection> collections,
-            ContractContext context,
-            BigInteger tenantId) {
-        if (collections == null || collections.size() < 2) {
-            throw new BusinessException("多知识库检索至少需要两个知识库");
-        }
-        List<BigInteger> ids = collections.stream()
-                .map(DocumentCollection::getId)
-                .toList();
-        assertCompatibleGroup(
-                ids, context.collections, context.models, tenantId);
-        Model embeddingModel = context.models.get(
-                collections.get(0).getVectorEmbedModelId());
-        if (embeddingModel == null) {
-            throw new BusinessException("知识库 Embedding 模型不存在或已失效");
-        }
-        return embeddingModel;
-    }
-
-    private void assertCompatibleGroup(
-            List<BigInteger> group,
-            Map<BigInteger, DocumentCollection> collections,
-            Map<BigInteger, Model> models,
-            BigInteger tenantId) {
-        DocumentCollection first = collections.get(group.get(0));
-        if (!isVectorReady(first, models, tenantId)) {
-            throw new BusinessException("知识库未完成有效的向量检索配置: " + first.getTitle());
-        }
-        for (BigInteger id : group) {
-            DocumentCollection current = collections.get(id);
-            if (!isVectorReady(current, models, tenantId)) {
-                throw new BusinessException("知识库未完成有效的向量检索配置: " + current.getTitle());
-            }
-            if (!Objects.equals(
-                    first.getVectorEmbedModelId(),
-                    current.getVectorEmbedModelId())
-                    || !Objects.equals(
-                    first.getDimensionOfVectorModel(),
-                    current.getDimensionOfVectorModel())
-                    || !Objects.equals(
-                    first.getTenantId(), current.getTenantId())) {
-                throw new BusinessException("多知识库检索要求使用相同的 Embedding 模型和向量维度");
-            }
-        }
-    }
-
-    private boolean isVectorReady(
-            DocumentCollection collection,
-            Map<BigInteger, Model> models,
-            BigInteger tenantId) {
-        if (collection == null
-                || collection.getId() == null
-                || !Objects.equals(collection.getTenantId(), tenantId)
-                || !Boolean.TRUE.equals(collection.getVectorStoreEnable())
-                || collection.getVectorEmbedModelId() == null
-                || collection.getDimensionOfVectorModel() == null
-                || collection.getDimensionOfVectorModel() <= 0
-                || collection.getVectorStoreCollection() == null
-                || collection.getVectorStoreCollection().isBlank()) {
-            return false;
-        }
-        Model model = models.get(collection.getVectorEmbedModelId());
-        return model != null
-                && Model.MODEL_TYPES[1].equals(model.getModelType())
-                && model.getModelProvider() != null
-                && text(model.getModelProvider().getProviderType()) != null
-                && Objects.equals(model.getTenantId(), tenantId);
-    }
-
-    private Map<BigInteger, Model> loadModels(
-            Collection<DocumentCollection> collections) {
-        Set<BigInteger> modelIds = new LinkedHashSet<>();
-        for (DocumentCollection collection : collections) {
-            if (collection != null && collection.getVectorEmbedModelId() != null) {
-                modelIds.add(collection.getVectorEmbedModelId());
-            }
-        }
-        if (modelIds.isEmpty()) {
-            return Collections.emptyMap();
-        }
-        List<Model> loaded = modelService.listModelInstances(modelIds);
-        Map<BigInteger, Model> result = new LinkedHashMap<>();
-        if (loaded != null) {
-            for (Model model : loaded) {
-                if (model != null && model.getId() != null) {
-                    result.put(model.getId(), model);
-                }
-            }
-        }
-        return result;
-    }
-
-    private Map<String, Object> toContract(
-            DocumentCollection collection,
-            Map<BigInteger, Model> models,
-            BigInteger tenantId) {
-        if (!isVectorReady(collection, models, tenantId)) {
-            throw new BusinessException("知识库未完成有效的向量检索配置: "
-                    + (collection == null ? "" : collection.getTitle()));
-        }
-        Model model = models.get(collection.getVectorEmbedModelId());
-        Map<String, Object> contract = new LinkedHashMap<>();
-        contract.put("knowledgeId", String.valueOf(collection.getId()));
-        contract.put("tenantId", String.valueOf(collection.getTenantId()));
-        contract.put("embeddingModelId", String.valueOf(model.getId()));
-        contract.put("embeddingDimension", collection.getDimensionOfVectorModel());
-        contract.put("vectorStoreCollection", collection.getVectorStoreCollection());
-        contract.put("vectorStoreType", nullableText(collection.getVectorStoreType()));
-        contract.put("modelProviderId", nullableString(model.getProviderId()));
-        contract.put(
-                "modelProviderType",
-                nullableText(model.getModelProvider().getProviderType()));
-        contract.put("modelType", model.getModelType());
-        contract.put("modelName", nullableText(model.getModelName()));
-        contract.put("modelEndpoint", nullableText(model.getEndpoint()));
-        contract.put("modelRequestPath", nullableText(model.getRequestPath()));
-        return contract;
-    }
-
-    private Map<BigInteger, DocumentCollection> loadCollections(
-            Set<BigInteger> ids,
-            BigInteger tenantId) {
-        if (tenantId == null) {
-            throw new BusinessException("工作流租户不能为空");
-        }
-        List<DocumentCollection> loaded = documentCollectionService.listByIds(ids);
-        Map<BigInteger, DocumentCollection> collections = new LinkedHashMap<>();
-        if (loaded != null) {
-            for (DocumentCollection collection : loaded) {
-                if (collection != null && collection.getId() != null) {
-                    collections.put(collection.getId(), collection);
-                }
-            }
-        }
-        if (collections.size() != ids.size()) {
-            throw new BusinessException("工作流引用的知识库不存在或已失效");
-        }
-        for (DocumentCollection collection : collections.values()) {
-            if (!Objects.equals(tenantId, collection.getTenantId())) {
-                throw new BusinessException("工作流引用了其他租户的知识库");
-            }
-        }
-        return collections;
-    }
-
-    private List<List<BigInteger>> readKnowledgeGroups(String content) {
-        if (content == null || content.isBlank()) {
-            return List.of();
-        }
-        JSONObject root;
-        try {
-            root = JSON.parseObject(content);
-        } catch (RuntimeException exception) {
-            throw new BusinessException("工作流内容不是合法JSON");
-        }
-        JSONArray nodes = root.getJSONArray("nodes");
-        if (nodes == null || nodes.isEmpty()) {
-            return List.of();
-        }
-        List<List<BigInteger>> groups = new ArrayList<>();
-        for (int index = 0; index < nodes.size(); index++) {
-            JSONObject node = nodes.getJSONObject(index);
-            JSONObject data = node == null ? null : node.getJSONObject("data");
-            if (data == null || !"knowledgeNode".equals(nodeType(node, data))) {
-                continue;
-            }
-            List<BigInteger> group = new ArrayList<>();
-            Set<BigInteger> unique = new LinkedHashSet<>();
-            Object rawIds = data.get("knowledgeIds");
-            if (rawIds instanceof JSONArray ids && !ids.isEmpty()) {
-                for (Object rawId : ids) {
-                    BigInteger id = bigInteger(rawId);
-                    if (!unique.add(id)) {
-                        throw new BusinessException("知识库节点不能重复选择同一知识库");
-                    }
-                    group.add(id);
-                }
-            } else {
-                group.add(bigInteger(data.get("knowledgeId")));
-            }
-            groups.add(List.copyOf(group));
-        }
-        return List.copyOf(groups);
-    }
-
-    private List<List<BigInteger>> onlyMultiGroups(
-            List<List<BigInteger>> knowledgeGroups) {
-        if (knowledgeGroups == null || knowledgeGroups.isEmpty()) {
-            return List.of();
-        }
-        return knowledgeGroups.stream()
-                .filter(Objects::nonNull)
-                .filter(group -> group.size() > 1)
-                .map(List::copyOf)
-                .toList();
-    }
-
-    private List<Map<String, Object>> readSnapshotContracts(Object value) {
-        if (value == null) {
-            return List.of();
-        }
-        JSONArray array;
-        try {
-            array = value instanceof JSONArray jsonArray
-                    ? jsonArray
-                    : JSON.parseArray(JSON.toJSONString(value));
-        } catch (RuntimeException exception) {
-            throw new BusinessException("工作流知识库发布契约无效");
-        }
-        List<Map<String, Object>> result = new ArrayList<>();
-        for (int index = 0; index < array.size(); index++) {
-            JSONObject object = array.getJSONObject(index);
-            if (object == null) {
-                throw new BusinessException("工作流知识库发布契约无效");
-            }
-            Map<String, Object> contract = new LinkedHashMap<>();
-            contract.put("knowledgeId", text(object.get("knowledgeId")));
-            contract.put("tenantId", text(object.get("tenantId")));
-            contract.put("embeddingModelId", text(object.get("embeddingModelId")));
-            contract.put("embeddingDimension", object.getInteger("embeddingDimension"));
-            contract.put("vectorStoreCollection", nullableText(object.getString("vectorStoreCollection")));
-            contract.put("vectorStoreType", nullableText(object.getString("vectorStoreType")));
-            contract.put("modelProviderId", nullableText(object.getString("modelProviderId")));
-            contract.put("modelProviderType", nullableText(object.getString("modelProviderType")));
-            contract.put("modelType", nullableText(object.getString("modelType")));
-            contract.put("modelName", nullableText(object.getString("modelName")));
-            contract.put("modelEndpoint", nullableText(object.getString("modelEndpoint")));
-            contract.put("modelRequestPath", nullableText(object.getString("modelRequestPath")));
-            result.add(contract);
-        }
-        return List.copyOf(result);
-    }
-
-    private String nodeType(JSONObject node, JSONObject data) {
-        String rootType = text(node.getString("type"));
-        String dataType = text(data.getString("type"));
-        if (rootType != null && dataType != null
-                && !Objects.equals(rootType, dataType)) {
-            throw new BusinessException("工作流节点类型与节点数据类型不一致");
-        }
-        return rootType == null ? dataType : rootType;
-    }
-
-    private BigInteger bigInteger(Object value) {
-        String normalized = text(value);
-        if (normalized == null) {
-            throw new BusinessException("知识库或租户 ID 无效");
-        }
-        try {
-            BigInteger result = new BigInteger(normalized);
-            if (result.signum() <= 0) {
-                throw new NumberFormatException("non-positive");
-            }
-            return result;
-        } catch (NumberFormatException exception) {
-            throw new BusinessException("知识库或租户 ID 无效");
-        }
-    }
-
-    private String text(Object value) {
-        if (value == null) {
-            return null;
-        }
-        String result = String.valueOf(value).trim();
-        return result.isEmpty() ? null : result;
-    }
-
-    private String nullableText(String value) {
-        return text(value);
-    }
-
-    private String nullableString(Object value) {
-        return value == null ? null : String.valueOf(value);
-    }
-
-    private String fingerprint(Object value) {
-        try {
-            byte[] bytes = JSON.toJSONString(value)
-                    .getBytes(StandardCharsets.UTF_8);
-            return HexFormat.of().formatHex(
-                    MessageDigest.getInstance("SHA-256").digest(bytes));
-        } catch (NoSuchAlgorithmException exception) {
-            throw new IllegalStateException("SHA-256 is unavailable", exception);
-        }
-    }
-
-    private record ContractContext(
-            Map<BigInteger, DocumentCollection> collections,
-            Map<BigInteger, Model> models) {
-
-        private static ContractContext empty() {
-            return new ContractContext(
-                    Collections.emptyMap(),
-                    Collections.emptyMap());
-        }
-    }
-}

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/easyagentsflow/repository/AgentWorkflowSnapshotFactory.java

@@ -1,6 +1,5 @@
 package tech.easyflow.ai.easyagentsflow.repository;
 
-import com.alibaba.fastjson2.JSON;
 import com.easyagents.flow.core.chain.ChainDefinition;
 import com.easyagents.flow.core.node.ConfirmNode;
 import com.easyagents.flow.core.parser.ChainParser;
@@ -85,35 +84,9 @@ public class AgentWorkflowSnapshotFactory {
         snapshot.put("englishName", workflow.getEnglishName());
         snapshot.put("revision", workflow.getRevision());
         snapshot.put("content", prepared.content());
-        snapshot.put("tenantId", workflow.getTenantId());
-        snapshot.put(
-                "publishedSnapshotJson",
-                knowledgeRuntimeSnapshot(workflow));
         return snapshot;
     }
 
-    /**
-     * 提取冻结执行所需的知识库契约，不携带工作流快照中的其他字段。
-     *
-     * @param workflow 已发布工作流
-     * @return 租户与知识库契约白名单
-     */
-    Map<String, Object> knowledgeRuntimeSnapshot(Workflow workflow) {
-        Map<String, Object> runtimeSnapshot = new LinkedHashMap<>();
-        runtimeSnapshot.put("tenantId", workflow.getTenantId());
-        Map<String, Object> publishedSnapshot =
-                workflow.getPublishedSnapshotJson();
-        Object contracts = publishedSnapshot == null
-                ? null
-                : publishedSnapshot.get("knowledgeContracts");
-        runtimeSnapshot.put(
-                "knowledgeContracts",
-                contracts == null
-                        ? java.util.List.of()
-                        : JSON.parse(JSON.toJSONString(contracts)));
-        return runtimeSnapshot;
-    }
-
     /**
      * Agent 可执行 Workflow 的准备结果。
      *

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/easyagentsflow/repository/FrozenWorkflowDefinitionRegistry.java

@@ -2,11 +2,8 @@ package tech.easyflow.ai.easyagentsflow.repository;
 
 import com.easyagents.flow.core.chain.ChainDefinition;
 import org.springframework.stereotype.Component;
-import tech.easyflow.ai.easyagentsflow.knowledge.WorkflowKnowledgeContractService;
 import tech.easyflow.ai.entity.Workflow;
-import tech.easyflow.common.web.exceptions.BusinessException;
 
-import java.math.BigInteger;
 import java.nio.charset.StandardCharsets;
 import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
@@ -27,7 +24,6 @@ public class FrozenWorkflowDefinitionRegistry {
     private static final int MAX_ENTRIES = 512;
 
     private final AgentWorkflowSnapshotFactory snapshotFactory;
-    private final WorkflowKnowledgeContractService workflowKnowledgeContractService;
     private final Map<String, ChainDefinition> definitions =
             new LinkedHashMap<>(32, 0.75F, true);
     private final Map<String, Workflow> workflows =
@@ -37,13 +33,9 @@ public class FrozenWorkflowDefinitionRegistry {
      * 创建冻结定义注册表。
      *
      * @param snapshotFactory Agent Workflow 冻结快照工厂
-     * @param workflowKnowledgeContractService 知识库契约服务
      */
-    public FrozenWorkflowDefinitionRegistry(
+    public FrozenWorkflowDefinitionRegistry(AgentWorkflowSnapshotFactory snapshotFactory) {
-            AgentWorkflowSnapshotFactory snapshotFactory,
-            WorkflowKnowledgeContractService workflowKnowledgeContractService) {
         this.snapshotFactory = snapshotFactory;
-        this.workflowKnowledgeContractService = workflowKnowledgeContractService;
     }
 
     /**
@@ -56,19 +48,7 @@ public class FrozenWorkflowDefinitionRegistry {
     public String register(Workflow workflow) {
         AgentWorkflowSnapshotFactory.PreparedWorkflow prepared = snapshotFactory.prepare(workflow);
         String preparedContent = prepared.content();
-        Map<String, Object> runtimeSnapshot =
+        String id = PREFIX + workflow.getId() + ":" + sha256(preparedContent);
-                snapshotFactory.knowledgeRuntimeSnapshot(workflow);
-        if (workflow.getTenantId() == null
-                || workflow.getTenantId().signum() <= 0) {
-            throw new BusinessException("绑定工作流租户快照不完整，请重新发布工作流");
-        }
-        String contractFingerprint = workflowKnowledgeContractService
-                .fingerprintSnapshotContracts(
-                        runtimeSnapshot.get("knowledgeContracts"));
-        String id = PREFIX + workflow.getId()
-                + ":" + workflow.getTenantId()
-                + ":" + contractFingerprint
-                + ":" + sha256(preparedContent);
         synchronized (definitions) {
             if (definitions.containsKey(id)) {
                 definitions.get(id);
@@ -79,7 +59,7 @@ public class FrozenWorkflowDefinitionRegistry {
             definition.setName(workflow.getEnglishName());
             definition.setDescription(workflow.getDescription());
             definitions.put(id, definition);
-            workflows.put(id, frozenWorkflow(workflow, runtimeSnapshot));
+            workflows.put(id, workflow);
             while (definitions.size() > MAX_ENTRIES) {
                 String eldest = definitions.keySet().iterator().next();
                 definitions.remove(eldest);
@@ -120,66 +100,9 @@ public class FrozenWorkflowDefinitionRegistry {
      * @return 是否冻结定义
      */
     public boolean isFrozen(String definitionId) {
-        return isFrozenDefinitionId(definitionId);
-    }
-
-    /**
-     * 判断定义 ID 是否属于冻结 Agent 工作流，不触发注册表实例创建。
-     *
-     * @param definitionId 定义 ID
-     * @return 是否冻结定义
-     */
-    public static boolean isFrozenDefinitionId(String definitionId) {
         return definitionId != null && definitionId.startsWith(PREFIX);
     }
 
-    /**
-     * 解析冻结定义中可独立校验的租户和知识库契约指纹。
-     *
-     * @param definitionId 冻结定义 ID
-     * @return 冻结定义身份
-     */
-    public static FrozenDefinitionIdentity parseIdentity(String definitionId) {
-        if (!isFrozenDefinitionId(definitionId)) {
-            throw new IllegalArgumentException("Not a frozen workflow definition");
-        }
-        String[] parts = definitionId.substring(PREFIX.length())
-                .split(":", 4);
-        if (parts.length != 4
-                || !parts[2].matches("[0-9a-f]{64}")
-                || !parts[3].matches("[0-9a-f]{64}")) {
-            throw new IllegalArgumentException("Invalid frozen workflow definition");
-        }
-        try {
-            BigInteger workflowId = new BigInteger(parts[0]);
-            BigInteger tenantId = new BigInteger(parts[1]);
-            if (workflowId.signum() <= 0 || tenantId.signum() <= 0) {
-                throw new NumberFormatException("non-positive");
-            }
-            return new FrozenDefinitionIdentity(
-                    workflowId, tenantId, parts[2]);
-        } catch (NumberFormatException exception) {
-            throw new IllegalArgumentException(
-                    "Invalid frozen workflow definition", exception);
-        }
-    }
-
-    private Workflow frozenWorkflow(
-            Workflow source,
-            Map<String, Object> runtimeSnapshot) {
-        Workflow frozen = new Workflow();
-        frozen.setId(source.getId());
-        frozen.setTenantId(source.getTenantId());
-        frozen.setTitle(source.getTitle());
-        frozen.setDescription(source.getDescription());
-        frozen.setEnglishName(source.getEnglishName());
-        frozen.setRevision(source.getRevision());
-        frozen.setContent(source.getContent());
-        frozen.setPublishedSnapshotJson(
-                new LinkedHashMap<>(runtimeSnapshot));
-        return frozen;
-    }
-
     private String sha256(String content) {
         try {
             return HexFormat.of().formatHex(MessageDigest.getInstance("SHA-256")
@@ -188,17 +111,4 @@ public class FrozenWorkflowDefinitionRegistry {
             throw new IllegalStateException("SHA-256 is unavailable", exception);
         }
     }
-
-    /**
-     * 冻结定义中不依赖进程内 LRU 状态的执行身份。
-     *
-     * @param workflowId 工作流 ID
-     * @param tenantId 工作流租户
-     * @param knowledgeContractFingerprint 知识库契约指纹
-     */
-    public record FrozenDefinitionIdentity(
-            BigInteger workflowId,
-            BigInteger tenantId,
-            String knowledgeContractFingerprint) {
-    }
 }

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/easyagentsflow/service/TinyFlowService.java

@@ -1,6 +1,5 @@
 package tech.easyflow.ai.easyagentsflow.service;
 
-import com.easyagents.document.core.exception.DocumentParseException;
 import com.easyagents.flow.core.chain.ChainState;
 import com.easyagents.flow.core.chain.ExceptionSummary;
 import com.easyagents.flow.core.chain.NodeState;
@@ -142,12 +141,9 @@ public class TinyFlowService {
             node.setResult(resolved);
         }
 
-        if (nodeState != null
+        // 只有当参数不为空时才覆盖
-                && nodeState.getStatus() == NodeStatus.SUSPEND
+        if (chainState.getSuspendForParameters() != null) {
-                && chainState.getSuspendForParameters() != null) {
             node.setSuspendForParameters(chainState.getSuspendForParameters());
-        } else {
-            node.setSuspendForParameters(null);
         }
     }
 
@@ -169,10 +165,6 @@ public class TinyFlowService {
         String rootMessage = StringUtil.hasText(error.getRootCauseMessage())
                 ? error.getRootCauseMessage()
                 : error.getMessage();
-        if (DocumentParseException.class.getName().equals(rootClass)
-                && StringUtil.hasText(rootMessage)) {
-            return rootMessage;
-        }
         if (StringUtil.noText(rootClass)) {
             return rootMessage;
         }

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/easyagentsflow/service/WorkflowCheckService.java

@@ -3,14 +3,9 @@ package tech.easyflow.ai.easyagentsflow.service;
 import com.alibaba.fastjson2.JSON;
 import com.alibaba.fastjson2.JSONArray;
 import com.alibaba.fastjson2.JSONObject;
-import com.easyagents.flow.core.chain.DataType;
-import com.easyagents.flow.core.node.ConfirmNode;
 import com.easyagents.flow.core.parser.ChainParser;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 import org.springframework.stereotype.Service;
 import org.springframework.util.StringUtils;
-import tech.easyflow.ai.config.MultiKnowledgeRetrievalProperties;
 import tech.easyflow.ai.easyagentsflow.entity.WorkflowCheckIssue;
 import tech.easyflow.ai.easyagentsflow.entity.WorkflowCheckResult;
 import tech.easyflow.ai.easyagentsflow.entity.WorkflowCheckStage;
@@ -45,7 +40,6 @@ import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
-import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 
 /**
@@ -53,29 +47,18 @@ import java.util.stream.Collectors;
  */
 @Service
 public class WorkflowCheckService {
-    private static final Logger LOGGER = LoggerFactory.getLogger(
-            WorkflowCheckService.class);
-    private static final long SLOW_CHECK_THRESHOLD_MS = 500L;
     private static final String LEVEL_ERROR = "ERROR";
     private static final String LEVEL_WARNING = "WARNING";
     private static final String TYPE_START = "startNode";
     private static final String TYPE_END = "endNode";
     private static final String TYPE_LOOP = "loopNode";
     private static final String TYPE_CONDITION = "conditionNode";
-    private static final String TYPE_CONFIRM = "confirmNode";
-    private static final String TYPE_KNOWLEDGE = "knowledgeNode";
-    private static final Set<String> CONFIRM_ARRAY_LEFT_OPERATORS = Set.of(
-            "contains", "notContains", "isEmpty", "isNotEmpty");
     private static final String TYPE_WORKFLOW = "workflow-node";
     private static final String TYPE_PLUGIN = "plugin-node";
     private static final String TYPE_MAKE_FILE = "make-file";
     private static final String SYSTEM_START_PARAM_NAME = "user_input";
     private static final int MIN_LOOP_COUNT = 1;
     private static final int MAX_LOOP_COUNT = 300;
-    private static final int DEFAULT_MAX_KNOWLEDGE_SOURCES = 8;
-    private static final int DEFAULT_MAX_MULTI_KNOWLEDGE_LIMIT = 200;
-    private static final Pattern COMPLETE_VARIABLE_REFERENCE =
-            Pattern.compile("^\\{\\{\\s*[^\\s{}][^{}]*?\\s*}}$");
     private static final String JOIN_MODE_ANY = "any";
     private static final String JOIN_MODE_ALL = "all";
 
@@ -91,8 +74,6 @@ public class WorkflowCheckService {
     private PluginItemService pluginItemService;
     @Resource
     private WorkflowPluginSnapshotResolver workflowPluginSnapshotResolver;
-    @Resource
-    private MultiKnowledgeRetrievalProperties multiKnowledgeRetrievalProperties;
 
     public WorkflowCheckResult checkWorkflow(BigInteger workflowId, WorkflowCheckStage stage) {
         if (workflowId == null) {
@@ -109,11 +90,9 @@ public class WorkflowCheckService {
         if (stage == null) {
             throw new BusinessException("校验阶段不能为空");
         }
-        long checkStartedAt = System.nanoTime();
         List<WorkflowCheckIssue> issues = new ArrayList<>();
         Set<String> issueKeys = new LinkedHashSet<>();
         ParsedWorkflow parsedWorkflow = parseAndCheckBase(content, issues, issueKeys);
-        long baseFinishedAt = System.nanoTime();
         if (parsedWorkflow != null) {
             List<NodeView> startNodes = parsedWorkflow.nodes.stream()
                     .filter(node -> TYPE_START.equals(node.type))
@@ -121,22 +100,11 @@ public class WorkflowCheckService {
             checkStartFormSchema(startNodes, issues, issueKeys);
             checkPluginSchemaHashes(parsedWorkflow, issues, issueKeys);
         }
-        long schemaFinishedAt = System.nanoTime();
 
         if (stage == WorkflowCheckStage.PRE_EXECUTE && parsedWorkflow != null) {
             runStrictChecks(content, parsedWorkflow, currentWorkflowId, issues, issueKeys);
         }
-        WorkflowCheckResult result = buildResult(stage, issues);
+        return buildResult(stage, issues);
-        logSlowCheck(
-                stage,
-                currentWorkflowId,
-                parsedWorkflow,
-                issues.size(),
-                checkStartedAt,
-                baseFinishedAt,
-                schemaFinishedAt,
-                System.nanoTime());
-        return result;
     }
 
     public void checkOrThrow(String content, WorkflowCheckStage stage, BigInteger currentWorkflowId) {
@@ -201,21 +169,6 @@ public class WorkflowCheckService {
             if (!StringUtils.hasText(node.type) || !parserMap.containsKey(node.type)) {
                 addIssue(issues, issueKeys, "NODE_TYPE_UNKNOWN", "节点类型无法识别: " + safe(node.type), node.id, null, node.name);
             }
-            String dataType = node.data == null
-                    ? null
-                    : trimToNull(node.data.getString("type"));
-            if (StringUtils.hasText(node.type)
-                    && StringUtils.hasText(dataType)
-                    && !Objects.equals(node.type, dataType)) {
-                addIssue(
-                        issues,
-                        issueKeys,
-                        "NODE_TYPE_MISMATCH",
-                        "节点类型与节点数据类型不一致",
-                        node.id,
-                        null,
-                        node.name);
-            }
             if (StringUtils.hasText(node.parentId) && node.parentId.equals(node.id)) {
                 addIssue(issues, issueKeys, "NODE_PARENT_SELF", "节点不能引用自己作为父节点", node.id, null, node.name);
             }
@@ -231,9 +184,6 @@ public class WorkflowCheckService {
         }
         checkLoopConfigurations(nodes, nodeMap, issues, issueKeys);
         checkConditionConfigurations(nodes, issues, issueKeys);
-        checkKnowledgeConfigurations(nodes, issues, issueKeys);
-        checkConfirmConfigurations(nodes, issues, issueKeys);
-        checkConfirmOutputReferences(nodes, issues, issueKeys);
 
         List<EdgeView> edges = new ArrayList<>();
         Set<String> edgeIds = new HashSet<>();
@@ -289,195 +239,6 @@ public class WorkflowCheckService {
         return parsedWorkflow;
     }
 
-    /**
-     * 校验知识库节点的新旧引用字段和多库向量模式约束。
-     */
-    private void checkKnowledgeConfigurations(
-            List<NodeView> nodes,
-            List<WorkflowCheckIssue> issues,
-            Set<String> issueKeys) {
-        for (NodeView node : nodes) {
-            if (!TYPE_KNOWLEDGE.equals(node.type) || node.data == null) {
-                continue;
-            }
-            checkKnowledgeOutputContract(node, issues, issueKeys);
-            List<String> knowledgeIds = new ArrayList<>();
-            if (node.data.containsKey("knowledgeIds")) {
-                Object rawIds = node.data.get("knowledgeIds");
-                if (!(rawIds instanceof JSONArray ids) || ids.isEmpty()) {
-                    addIssue(
-                            issues,
-                            issueKeys,
-                            "KNOWLEDGE_IDS_INVALID",
-                            "知识库节点至少需要选择一个知识库",
-                            node.id,
-                            null,
-                            node.name);
-                    continue;
-                }
-                Set<String> unique = new LinkedHashSet<>();
-                for (Object rawId : ids) {
-                    String id = trimToNull(rawId == null
-                            ? null
-                            : String.valueOf(rawId));
-                    if (id == null || !id.matches("[0-9]+")) {
-                        addIssue(
-                                issues,
-                                issueKeys,
-                                "KNOWLEDGE_IDS_INVALID",
-                                "知识库节点包含无效的知识库ID",
-                                node.id,
-                                null,
-                                node.name);
-                        continue;
-                    }
-                    if (!unique.add(id)) {
-                        addIssue(
-                                issues,
-                                issueKeys,
-                                "KNOWLEDGE_IDS_DUPLICATE",
-                                "知识库节点不能重复选择同一知识库",
-                                node.id,
-                                null,
-                                node.name);
-                    }
-                }
-                knowledgeIds.addAll(unique);
-                if (knowledgeIds.size() > maxKnowledgeSources()) {
-                    addIssue(
-                            issues,
-                            issueKeys,
-                            "KNOWLEDGE_SOURCE_LIMIT_EXCEEDED",
-                            "知识库节点选择数量超过平台上限",
-                            node.id,
-                            null,
-                            node.name);
-                }
-            } else {
-                String legacyId = trimToNull(node.data.getString("knowledgeId"));
-                if (legacyId == null || !legacyId.matches("[0-9]+")) {
-                    addIssue(
-                            issues,
-                            issueKeys,
-                            "KNOWLEDGE_ID_INVALID",
-                            "知识库节点需要选择知识库",
-                            node.id,
-                            null,
-                            node.name);
-                    continue;
-                }
-                knowledgeIds.add(legacyId);
-            }
-
-            String retrievalMode = trimToNull(
-                    node.data.getString("retrievalMode"));
-            if (knowledgeIds.size() > 1
-                    && !"VECTOR".equalsIgnoreCase(retrievalMode)) {
-                addIssue(
-                        issues,
-                        issueKeys,
-                        "MULTI_KNOWLEDGE_MODE_INVALID",
-                        "多知识库检索仅支持向量检索",
-                        node.id,
-                        null,
-                        node.name);
-            }
-            String limit = trimToNull(node.data.getString("limit"));
-            if (limit != null
-                    && !COMPLETE_VARIABLE_REFERENCE.matcher(limit).matches()) {
-                try {
-                    int parsedLimit = Integer.parseInt(limit);
-                    if (parsedLimit <= 0
-                            || (knowledgeIds.size() > 1
-                            && parsedLimit > maxMultiKnowledgeLimit())) {
-                        throw new NumberFormatException("non-positive");
-                    }
-                } catch (NumberFormatException exception) {
-                    addIssue(
-                            issues,
-                            issueKeys,
-                            "KNOWLEDGE_LIMIT_INVALID",
-                            "知识库节点最终返回条数必须为正整数或有效变量引用",
-                            node.id,
-                            null,
-                            node.name);
-                }
-            }
-        }
-    }
-
-    /**
-     * 知识库节点只允许暴露稳定的 documents 输出及四个历史子字段。
-     */
-    private void checkKnowledgeOutputContract(
-            NodeView node,
-            List<WorkflowCheckIssue> issues,
-            Set<String> issueKeys) {
-        if (!node.data.containsKey("outputDefs")) {
-            return;
-        }
-        Object rawOutputDefs = node.data.get("outputDefs");
-        if (rawOutputDefs instanceof JSONArray outputDefs
-                && outputDefs.size() == 1
-                && isCanonicalKnowledgeDocumentsOutput(
-                outputDefs.getJSONObject(0))) {
-            return;
-        }
-        addIssue(
-                issues,
-                issueKeys,
-                "KNOWLEDGE_OUTPUT_SCHEMA_INVALID",
-                "知识库节点输出参数必须为 documents，并仅包含 title、content、documentId、knowledgeId",
-                node.id,
-                null,
-                node.name);
-    }
-
-    private boolean isCanonicalKnowledgeDocumentsOutput(JSONObject output) {
-        if (output == null
-                || !"documents".equals(output.getString("name"))
-                || !"Array".equalsIgnoreCase(output.getString("dataType"))) {
-            return false;
-        }
-        JSONArray children = output.getJSONArray("children");
-        if (children == null || children.size() != 4) {
-            return false;
-        }
-        Map<String, String> expectedTypes = Map.of(
-                "title", "String",
-                "content", "String",
-                "documentId", "Number",
-                "knowledgeId", "Number");
-        Set<String> names = new LinkedHashSet<>();
-        for (int index = 0; index < children.size(); index++) {
-            JSONObject child = children.getJSONObject(index);
-            if (child == null) {
-                return false;
-            }
-            String name = trimToNull(child.getString("name"));
-            String expectedType = expectedTypes.get(name);
-            if (expectedType == null
-                    || !names.add(name)
-                    || !expectedType.equalsIgnoreCase(
-                    child.getString("dataType"))) {
-                return false;
-            }
-        }
-        return names.equals(expectedTypes.keySet());
-    }
-
-    private int maxKnowledgeSources() {
-        return multiKnowledgeRetrievalProperties == null
-                ? DEFAULT_MAX_KNOWLEDGE_SOURCES
-                : multiKnowledgeRetrievalProperties.getMaxSources();
-    }
-
-    private int maxMultiKnowledgeLimit() {
-        return multiKnowledgeRetrievalProperties == null
-                ? DEFAULT_MAX_MULTI_KNOWLEDGE_LIMIT
-                : multiKnowledgeRetrievalProperties.getTotalCandidateLimit();
-    }
-
     /**
      * 校验节点汇聚模式及其静态可证明的到达安全性。
      *
@@ -753,288 +514,6 @@ public class WorkflowCheckService {
         }
     }
 
-    /**
-     * 校验用户确认节点配置及其对外输出定义。
-     */
-    private void checkConfirmConfigurations(
-            List<NodeView> nodes,
-            List<WorkflowCheckIssue> issues,
-            Set<String> issueKeys) {
-        for (NodeView node : nodes) {
-            if (!TYPE_CONFIRM.equals(node.type)) {
-                continue;
-            }
-            if (node.data == null) {
-                addIssue(
-                        issues,
-                        issueKeys,
-                        "CONFIRM_CONFIGURATION_INVALID",
-                        "用户确认节点配置不能为空",
-                        node.id,
-                        null,
-                        node.name);
-                continue;
-            }
-
-            ConfirmNode configuration;
-            try {
-                validateConfirmConfigurationTypes(node.data);
-                checkConfirmOutputDefinitions(
-                        node,
-                        Boolean.TRUE.equals(node.data.get("multiple")),
-                        issues,
-                        issueKeys);
-                configuration = node.data.toJavaObject(ConfirmNode.class);
-                configuration.validateConfiguration();
-            } catch (Exception exception) {
-                addIssue(
-                        issues,
-                        issueKeys,
-                        "CONFIRM_CONFIGURATION_INVALID",
-                        "用户确认节点配置无效: " + shortError(exception),
-                        node.id,
-                        null,
-                        node.name);
-                continue;
-            }
-        }
-    }
-
-    private void validateConfirmConfigurationTypes(JSONObject data) {
-        for (String key : data.keySet()) {
-            if (!ConfirmNode.SUPPORTED_CONFIGURATION_KEYS.contains(key)) {
-                throw new IllegalArgumentException(
-                        "用户确认节点包含无效配置字段: " + key);
-            }
-        }
-        if (!(data.get("message") instanceof String)) {
-            throw new IllegalArgumentException("用户确认节点提示内容必须为字符串");
-        }
-        if (!(data.get("multiple") instanceof Boolean)) {
-            throw new IllegalArgumentException("用户确认节点选择方式必须为布尔值");
-        }
-
-        Object optionsValue = data.get("options");
-        if (optionsValue == null) {
-            return;
-        }
-        if (!(optionsValue instanceof JSONArray options)) {
-            throw new IllegalArgumentException("用户确认节点选项必须为数组");
-        }
-        for (Object option : options) {
-            if (!(option instanceof String)) {
-                throw new IllegalArgumentException("用户确认节点选项内容必须为字符串");
-            }
-        }
-    }
-
-    private void checkConfirmOutputDefinitions(
-            NodeView node,
-            boolean multiple,
-            List<WorkflowCheckIssue> issues,
-            Set<String> issueKeys) {
-        Object outputDefsValue = node.data.get("outputDefs");
-        if (!(outputDefsValue instanceof JSONArray outputDefs)
-                || outputDefs.size() != 1) {
-            addConfirmOutputIssue(node, issues, issueKeys);
-            return;
-        }
-        Object outputValue = outputDefs.get(0);
-        if (!(outputValue instanceof JSONObject output)) {
-            addConfirmOutputIssue(node, issues, issueKeys);
-            return;
-        }
-        String expectedType = multiple
-                ? DataType.Array_String.toString()
-                : DataType.String.toString();
-        if (trimToNull(output.getString("name")) == null
-                || !expectedType.equals(
-                        trimToNull(output.getString("dataType")))) {
-            addConfirmOutputIssue(node, issues, issueKeys);
-        }
-    }
-
-    private void addConfirmOutputIssue(
-            NodeView node,
-            List<WorkflowCheckIssue> issues,
-            Set<String> issueKeys) {
-        addIssue(
-                issues,
-                issueKeys,
-                "CONFIRM_OUTPUT_SCHEMA_INVALID",
-                "用户确认节点必须配置唯一非空输出参数，且类型与选择方式一致",
-                node.id,
-                null,
-                node.name);
-    }
-
-    /**
-     * 校验下游节点保存的确认输出引用仍然存在且类型一致。
-     */
-    private void checkConfirmOutputReferences(
-            List<NodeView> nodes,
-            List<WorkflowCheckIssue> issues,
-            Set<String> issueKeys) {
-        ConfirmOutputIndex confirmOutputs = new ConfirmOutputIndex();
-        for (NodeView node : nodes) {
-            if (!TYPE_CONFIRM.equals(node.type) || node.data == null) {
-                continue;
-            }
-            try {
-                ConfirmNode configuration = node.data.toJavaObject(ConfirmNode.class);
-                configuration.validateConfiguration();
-                confirmOutputs.put(
-                        node.id,
-                        configuration.resolveOutputName(),
-                        configuration.isMultiple()
-                                ? DataType.Array_String.toString()
-                                : DataType.String.toString());
-            } catch (Exception ignored) {
-                // 配置错误已由 checkConfirmConfigurations 给出精确问题。
-            }
-        }
-        if (confirmOutputs.isEmpty()) {
-            return;
-        }
-        for (NodeView node : nodes) {
-            if (node.data != null) {
-                checkConfirmOutputReferences(
-                        node.data,
-                        node,
-                        confirmOutputs,
-                        issues,
-                        issueKeys);
-            }
-        }
-    }
-
-    private void checkConfirmOutputReferences(
-            Object value,
-            NodeView consumer,
-            ConfirmOutputIndex confirmOutputs,
-            List<WorkflowCheckIssue> issues,
-            Set<String> issueKeys) {
-        if (value instanceof JSONObject object) {
-            if ("ref".equals(trimToNull(object.getString("refType")))) {
-                checkConfirmOutputReference(
-                        object.getString("ref"),
-                        object.getString("dataType"),
-                        true,
-                        consumer,
-                        confirmOutputs,
-                        issues,
-                        issueKeys);
-            }
-            String leftType = checkConfirmOutputReference(
-                    object.getString("leftRef"),
-                    null,
-                    false,
-                    consumer,
-                    confirmOutputs,
-                    issues,
-                    issueKeys);
-            String operator = trimToNull(object.getString("operator"));
-            if (DataType.Array_String.toString().equals(leftType)
-                    && !CONFIRM_ARRAY_LEFT_OPERATORS.contains(operator)) {
-                addConfirmConditionTypeIssue(
-                        object.getString("leftRef"),
-                        operator,
-                        consumer,
-                        issues,
-                        issueKeys);
-            }
-            if ("ref".equals(trimToNull(object.getString("rightType")))) {
-                String rightType = checkConfirmOutputReference(
-                        object.getString("rightRef"),
-                        null,
-                        false,
-                        consumer,
-                        confirmOutputs,
-                        issues,
-                        issueKeys);
-                if (DataType.Array_String.toString().equals(rightType)) {
-                    addConfirmConditionTypeIssue(
-                            object.getString("rightRef"),
-                            operator,
-                            consumer,
-                            issues,
-                            issueKeys);
-                }
-            }
-            for (Object child : object.values()) {
-                checkConfirmOutputReferences(
-                        child,
-                        consumer,
-                        confirmOutputs,
-                        issues,
-                        issueKeys);
-            }
-            return;
-        }
-        if (value instanceof JSONArray array) {
-            for (Object child : array) {
-                checkConfirmOutputReferences(
-                        child,
-                        consumer,
-                        confirmOutputs,
-                        issues,
-                        issueKeys);
-            }
-        }
-    }
-
-    private String checkConfirmOutputReference(
-            String rawReference,
-            String rawActualType,
-            boolean requireActualType,
-            NodeView consumer,
-            ConfirmOutputIndex confirmOutputs,
-            List<WorkflowCheckIssue> issues,
-            Set<String> issueKeys) {
-        String reference = trimToNull(rawReference);
-        if (reference == null) {
-            return null;
-        }
-        String expectedType = confirmOutputs.get(reference);
-        if (expectedType == null
-                && !confirmOutputs.referencesConfirmNode(reference)) {
-            return null;
-        }
-        String actualType = trimToNull(rawActualType);
-        boolean invalidType = actualType == null
-                ? requireActualType
-                : !Objects.equals(expectedType, actualType);
-        if (expectedType == null || invalidType) {
-            addIssue(
-                    issues,
-                    issueKeys,
-                    "CONFIRM_OUTPUT_REFERENCE_INVALID",
-                    "用户确认输出引用不存在或类型已变化: "
-                            + reference,
-                    consumer.id,
-                    null,
-                    consumer.name);
-        }
-        return expectedType;
-    }
-
-    private void addConfirmConditionTypeIssue(
-            String reference,
-            String operator,
-            NodeView consumer,
-            List<WorkflowCheckIssue> issues,
-            Set<String> issueKeys) {
-        addIssue(
-                issues,
-                issueKeys,
-                "CONFIRM_OUTPUT_REFERENCE_INVALID",
-                "用户确认多选输出不支持当前条件操作符: "
-                        + trimToNull(reference) + " (" + operator + ")",
-                consumer.id,
-                null,
-                consumer.name);
-    }
-
     /**
      * 将 JSON 条件规则转换为运行时规则对象。
      *
@@ -2195,65 +1674,6 @@ public class WorkflowCheckService {
         return result;
     }
 
-    private void logSlowCheck(
-            WorkflowCheckStage stage,
-            BigInteger workflowId,
-            ParsedWorkflow parsedWorkflow,
-            int issueCount,
-            long checkStartedAt,
-            long baseFinishedAt,
-            long schemaFinishedAt,
-            long checkFinishedAt) {
-        long totalMs = elapsedMillis(checkStartedAt, checkFinishedAt);
-        if (totalMs < SLOW_CHECK_THRESHOLD_MS) {
-            return;
-        }
-        LOGGER.warn(
-                "Workflow check is slow: stage={}, workflowId={}, nodes={}, "
-                        + "issues={}, baseMs={}, schemaMs={}, strictMs={}, totalMs={}",
-                stage,
-                workflowId,
-                parsedWorkflow == null ? 0 : parsedWorkflow.nodes.size(),
-                issueCount,
-                elapsedMillis(checkStartedAt, baseFinishedAt),
-                elapsedMillis(baseFinishedAt, schemaFinishedAt),
-                elapsedMillis(schemaFinishedAt, checkFinishedAt),
-                totalMs);
-    }
-
-    private long elapsedMillis(long startedAt, long finishedAt) {
-        return Math.max(0L, (finishedAt - startedAt) / 1_000_000L);
-    }
-
-    private static class ConfirmOutputIndex {
-        private final Map<String, String> outputTypes = new HashMap<>();
-        private final Set<String> nodeIds = new HashSet<>();
-
-        private void put(String nodeId, String outputName, String dataType) {
-            nodeIds.add(nodeId);
-            outputTypes.put(nodeId + "." + outputName, dataType);
-        }
-
-        private String get(String reference) {
-            return outputTypes.get(reference);
-        }
-
-        private boolean isEmpty() {
-            return outputTypes.isEmpty();
-        }
-
-        private boolean referencesConfirmNode(String reference) {
-            int separator = reference.indexOf('.');
-            while (separator > 0) {
-                if (nodeIds.contains(reference.substring(0, separator))) {
-                    return true;
-                }
-                separator = reference.indexOf('.', separator + 1);
-            }
-            return false;
-        }
-    }
-
     private void throwIfFailed(WorkflowCheckResult result) {
         if (result == null) {
             return;

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/easyagentsflow/service/WorkflowDatacenterContentService.java

@@ -14,12 +14,13 @@ import tech.easyflow.datacenter.execution.model.DatasetRef;
 import tech.easyflow.datacenter.execution.service.DatacenterDatasetQueryService;
 import tech.easyflow.datacenter.meta.entity.DatacenterCatalog;
 import tech.easyflow.datacenter.meta.entity.DatacenterSource;
+import tech.easyflow.datacenter.meta.enums.DatacenterMetadataStatus;
+import tech.easyflow.datacenter.meta.enums.DatacenterSensitivityLevel;
 import tech.easyflow.datacenter.meta.service.DatacenterDatasetRegistryService;
 
 import javax.annotation.Resource;
 import java.math.BigInteger;
 import java.util.ArrayList;
-import java.util.Comparator;
 import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
 import java.util.List;
@@ -34,6 +35,7 @@ public class WorkflowDatacenterContentService {
     public static final String LLM_NODE_TYPE = "llmNode";
     public static final String QUERY_DATA_CONTEXT = "queryDataContext";
     public static final String SEARCH_SOURCE_MISSING_MESSAGE = "查询数据节点未选择连接服务";
+    public static final String SEARCH_TABLE_MISSING_MESSAGE = "查询数据节点未选择已接入表";
     public static final String SEARCH_SQL_MISSING_MESSAGE = "查询数据节点未设置 SQL";
     public static final String SAVE_EXPIRED_MESSAGE = "写入数据节点配置已过期，请重新选择已接入表";
     public static final String INVALID_QUERY_CONTEXT_MESSAGE = "查询上下文配置无效，请重新选择查询数据节点";
@@ -135,11 +137,16 @@ public class WorkflowDatacenterContentService {
         if (datasetRef == null || datasetRef.getSourceId() == null) {
             throw new BusinessException(SEARCH_SOURCE_MISSING_MESSAGE);
         }
+        if (datasetRef.getTableId() == null) {
+            throw new BusinessException(SEARCH_TABLE_MISSING_MESSAGE);
+        }
         String querySql = data == null ? null : trimToNull(data.getString("querySql"));
         if (!StringUtils.hasText(querySql)) {
             throw new BusinessException(SEARCH_SQL_MISSING_MESSAGE);
         }
-        return datasetRef;
+        DatasetRef boundRef = bindAuthoritativeTenant(datasetRef);
+        data.put("datasetRef", boundRef);
+        return boundRef;
     }
 
     public DatasetRef requireSaveDatasetRef(JSONObject data) {
@@ -150,6 +157,31 @@ public class WorkflowDatacenterContentService {
         if (datasetRef == null || datasetRef.getTableId() == null) {
             throw new BusinessException(SAVE_EXPIRED_MESSAGE);
         }
+        DatasetRef boundRef = bindAuthoritativeTenant(datasetRef);
+        data.put("datasetRef", boundRef);
+        return boundRef;
+    }
+
+    /**
+     * 依据当前租户可见的权威 Source/Table 覆盖调用方声明的租户字段。
+     *
+     * @param datasetRef 工作流数据集引用
+     * @return 已绑定权威租户的数据集引用
+     */
+    private DatasetRef bindAuthoritativeTenant(DatasetRef datasetRef) {
+        DatacenterTable table = datasetRef.getTableId() == null
+                ? null : registryService.getTableWithFields(datasetRef.getTableId());
+        BigInteger sourceId = table == null ? datasetRef.getSourceId() : table.getSourceId();
+        if (sourceId == null) {
+            throw new BusinessException(SEARCH_SOURCE_MISSING_MESSAGE);
+        }
+        DatacenterSource source = registryService.getSourceRequired(sourceId);
+        if (table != null && (!sourceId.equals(table.getSourceId())
+                || !java.util.Objects.equals(source.getTenantId(), table.getTenantId()))) {
+            throw new BusinessException("数据集引用与当前租户不一致");
+        }
+        datasetRef.setTenantId(source.getTenantId());
+        datasetRef.setSourceId(sourceId);
         return datasetRef;
     }
 
@@ -172,20 +204,30 @@ public class WorkflowDatacenterContentService {
         if (datasetRef == null || datasetRef.getSourceId() == null) {
             throw new BusinessException(SEARCH_SOURCE_MISSING_MESSAGE);
         }
+        if (datasetRef.getTableId() == null) {
+            throw new BusinessException(SEARCH_TABLE_MISSING_MESSAGE);
+        }
         DatacenterSource source = registryService.getSourceRequired(datasetRef.getSourceId());
-        List<DatacenterTable> managedTables = registryService.listManagedTables(datasetRef.getSourceId(), datasetRef.getCatalogId());
+        DatacenterTable fullTable = registryService.getTableWithFields(
-        managedTables.sort(Comparator.comparing(table -> table.getTableName() == null ? "" : table.getTableName()));
+                datasetRef.getTableId());
+        if (fullTable == null
+                || !datasetRef.getSourceId().equals(fullTable.getSourceId())
+                || !Integer.valueOf(1).equals(fullTable.getQueryable())
+                || !DatacenterMetadataStatus.ACTIVE.name().equals(
+                        fullTable.getMetadataStatus())) {
+            throw new BusinessException("查询数据节点绑定的表不可用");
+        }
+        DatacenterCatalog catalog = registryService.getCatalogById(
+                fullTable.getCatalogId());
+        if (StringUtils.hasText(datasetRef.getCatalogName())
+                && (catalog == null || !datasetRef.getCatalogName().equals(
+                        catalog.getCatalogName()))) {
+            throw new BusinessException("查询数据节点绑定的命名空间已变化");
+        }
         JSONObject sourceSummary = new JSONObject();
         sourceSummary.put("sourceName", source.getSourceName());
         sourceSummary.put("sourceType", source.getSourceType());
         JSONArray tables = new JSONArray();
-        for (DatacenterTable table : managedTables) {
-            DatacenterTable fullTable = registryService.getTableWithFields(table.getId());
-            DatacenterCatalog catalog = registryService.getCatalogById(fullTable.getCatalogId());
-            if (StringUtils.hasText(datasetRef.getCatalogName())
-                    && (catalog == null || !datasetRef.getCatalogName().equals(catalog.getCatalogName()))) {
-                continue;
-            }
         JSONObject tableSummary = new JSONObject();
         tableSummary.put("catalogName", catalog == null ? null : catalog.getCatalogName());
         tableSummary.put("tableName", fullTable.getTableName());
@@ -193,6 +235,9 @@ public class WorkflowDatacenterContentService {
         JSONArray fields = new JSONArray();
         if (fullTable.getFields() != null) {
             for (DatacenterTableField field : fullTable.getFields()) {
+                if (!isQueryablePublicField(field)) {
+                    continue;
+                }
                 JSONObject fieldSummary = new JSONObject();
                 fieldSummary.put("fieldName", field.getFieldName());
                 fieldSummary.put("fieldDesc", field.getFieldDesc());
@@ -202,11 +247,25 @@ public class WorkflowDatacenterContentService {
         }
         tableSummary.put("fields", fields);
         tables.add(tableSummary);
-        }
         sourceSummary.put("tables", tables);
         return sourceSummary;
     }
 
+    /**
+     * 判断字段是否允许暴露给 SQL 生成上下文。
+     *
+     * @param field 字段元数据
+     * @return 是否为当前可查询的公开字段
+     */
+    private boolean isQueryablePublicField(DatacenterTableField field) {
+        return field != null
+                && Integer.valueOf(1).equals(field.getQueryable())
+                && DatacenterMetadataStatus.ACTIVE.name().equals(
+                        field.getMetadataStatus())
+                && DatacenterSensitivityLevel.PUBLIC.name().equals(
+                        field.getSensitivityLevel());
+    }
+
     private void injectQueryDataContext(JSONObject data, Map<String, JSONObject> nodeMap) {
         if (data == null) {
             return;
@@ -217,7 +276,7 @@ public class WorkflowDatacenterContentService {
             removeQueryDataContextPlaceholder(data);
             return;
         }
-        Map<BigInteger, JSONObject> sourceSummaries = new LinkedHashMap<>();
+        Map<String, JSONObject> sourceSummaries = new LinkedHashMap<>();
         Set<String> visitedNodeIds = new LinkedHashSet<>();
         for (int i = 0; i < nodeIds.size(); i++) {
             String nodeId = trimToNull(nodeIds.getString(i));
@@ -229,7 +288,10 @@ public class WorkflowDatacenterContentService {
                 throw new BusinessException(INVALID_QUERY_CONTEXT_MESSAGE);
             }
             DatasetRef datasetRef = requireSearchDatasetRef(targetNode.getJSONObject("data"));
-            sourceSummaries.putIfAbsent(datasetRef.getSourceId(), buildSourceSummary(datasetRef));
+            String summaryKey = datasetRef.getSourceId() + ":" + datasetRef.getTableId();
+            if (!sourceSummaries.containsKey(summaryKey)) {
+                sourceSummaries.put(summaryKey, buildSourceSummary(datasetRef));
+            }
         }
         String contextValue = QUERY_CONTEXT_PROMPT + "\n" + JSON.toJSONString(new ArrayList<>(sourceSummaries.values()));
         upsertQueryDataContextParameter(data, contextValue);
@@ -343,6 +405,7 @@ public class WorkflowDatacenterContentService {
 
     private DatasetRef copyDatasetRef(DatasetRef datasetRef) {
         DatasetRef copy = new DatasetRef();
+        copy.setTenantId(datasetRef.getTenantId());
         copy.setSourceId(datasetRef.getSourceId());
         copy.setCatalogId(datasetRef.getCatalogId());
         copy.setCatalogName(datasetRef.getCatalogName());

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/easyagentsflow/service/WorkflowResumeService.java

@@ -1,49 +0,0 @@
-package tech.easyflow.ai.easyagentsflow.service;
-
-import com.easyagents.flow.core.chain.ChainResumeException;
-import com.easyagents.flow.core.chain.runtime.ChainExecutor;
-import org.springframework.stereotype.Service;
-import tech.easyflow.common.web.exceptions.BusinessException;
-
-import javax.annotation.Resource;
-import java.util.LinkedHashMap;
-import java.util.Map;
-
-/**
- * 统一校验并恢复暂停中的工作流。
- */
-@Service
-public class WorkflowResumeService {
-
-    @Resource
-    private ChainExecutor chainExecutor;
-
-    /**
-     * 恢复暂停实例，并将引擎校验失败转换为稳定的接口错误。
-     *
-     * @param executeId 工作流实例 ID
-     * @param variables 用户提交的确认参数
-     */
-    public void resume(String executeId, Map<String, Object> variables) {
-        Map<String, Object> submitted = variables == null
-                ? new LinkedHashMap<>()
-                : new LinkedHashMap<>(variables);
-        final boolean resumed;
-        try {
-            resumed = chainExecutor.resumeAsyncIfSuspended(
-                    executeId, submitted);
-        } catch (ChainResumeException exception) {
-            throw new BusinessException(
-                    400,
-                    40031,
-                    exception.getMessage(),
-                    exception);
-        }
-        if (!resumed) {
-            throw new BusinessException(
-                    409,
-                    40901,
-                    "当前执行状态不可恢复，仅暂停中的工作流允许恢复");
-        }
-    }
-}

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/entity/DocumentChunkSyncTask.java

@@ -1,78 +0,0 @@
-package tech.easyflow.ai.entity;
-
-import com.mybatisflex.annotation.Column;
-import com.mybatisflex.annotation.Id;
-import com.mybatisflex.annotation.KeyType;
-import com.mybatisflex.annotation.Table;
-import tech.easyflow.common.entity.DateEntity;
-
-import java.io.Serializable;
-import java.math.BigInteger;
-import java.util.Date;
-
-/**
- * 文档分块检索索引同步任务。
- */
-@Table("tb_document_chunk_sync_task")
-public class DocumentChunkSyncTask extends DateEntity implements Serializable {
-
-    @Id(keyType = KeyType.Generator, value = "snowFlakeId")
-    private BigInteger id;
-    private BigInteger chunkId;
-    private BigInteger documentId;
-    private BigInteger documentCollectionId;
-    private String vectorCollection;
-    private String operation;
-    private Long syncVersion;
-    private String status;
-    private Integer attemptCount;
-    private Date nextRetryAt;
-    private Date lastDispatchedAt;
-    private String executionToken;
-    private Date leaseUntil;
-    private String errorCode;
-    private String errorMessage;
-    private Date created;
-    private BigInteger createdBy;
-    private Date modified;
-    private BigInteger modifiedBy;
-
-    public BigInteger getId() { return id; }
-    public void setId(BigInteger id) { this.id = id; }
-    public BigInteger getChunkId() { return chunkId; }
-    public void setChunkId(BigInteger chunkId) { this.chunkId = chunkId; }
-    public BigInteger getDocumentId() { return documentId; }
-    public void setDocumentId(BigInteger documentId) { this.documentId = documentId; }
-    public BigInteger getDocumentCollectionId() { return documentCollectionId; }
-    public void setDocumentCollectionId(BigInteger documentCollectionId) { this.documentCollectionId = documentCollectionId; }
-    public String getVectorCollection() { return vectorCollection; }
-    public void setVectorCollection(String vectorCollection) { this.vectorCollection = vectorCollection; }
-    public String getOperation() { return operation; }
-    public void setOperation(String operation) { this.operation = operation; }
-    public Long getSyncVersion() { return syncVersion; }
-    public void setSyncVersion(Long syncVersion) { this.syncVersion = syncVersion; }
-    public String getStatus() { return status; }
-    public void setStatus(String status) { this.status = status; }
-    public Integer getAttemptCount() { return attemptCount; }
-    public void setAttemptCount(Integer attemptCount) { this.attemptCount = attemptCount; }
-    public Date getNextRetryAt() { return nextRetryAt; }
-    public void setNextRetryAt(Date nextRetryAt) { this.nextRetryAt = nextRetryAt; }
-    public Date getLastDispatchedAt() { return lastDispatchedAt; }
-    public void setLastDispatchedAt(Date lastDispatchedAt) { this.lastDispatchedAt = lastDispatchedAt; }
-    public String getExecutionToken() { return executionToken; }
-    public void setExecutionToken(String executionToken) { this.executionToken = executionToken; }
-    public Date getLeaseUntil() { return leaseUntil; }
-    public void setLeaseUntil(Date leaseUntil) { this.leaseUntil = leaseUntil; }
-    public String getErrorCode() { return errorCode; }
-    public void setErrorCode(String errorCode) { this.errorCode = errorCode; }
-    public String getErrorMessage() { return errorMessage; }
-    public void setErrorMessage(String errorMessage) { this.errorMessage = errorMessage; }
-    @Override public Date getCreated() { return created; }
-    @Override public void setCreated(Date created) { this.created = created; }
-    public BigInteger getCreatedBy() { return createdBy; }
-    public void setCreatedBy(BigInteger createdBy) { this.createdBy = createdBy; }
-    @Override public Date getModified() { return modified; }
-    @Override public void setModified(Date modified) { this.modified = modified; }
-    public BigInteger getModifiedBy() { return modifiedBy; }
-    public void setModifiedBy(BigInteger modifiedBy) { this.modifiedBy = modifiedBy; }
-}

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/entity/DocumentCollection.java

@@ -8,7 +8,6 @@ import com.easyagents.store.milvus.MilvusVectorStore;
 import com.easyagents.store.milvus.MilvusVectorStoreConfig;
 import com.mybatisflex.annotation.Table;
 import tech.easyflow.ai.config.AiMilvusConfig;
-import tech.easyflow.ai.config.AiMilvusClientManager;
 import tech.easyflow.ai.chattime.availability.ChatTimeToolAvailabilityContext;
 import tech.easyflow.ai.easyagents.tool.DocumentCollectionTool;
 import tech.easyflow.ai.entity.base.DocumentCollectionBase;
@@ -104,10 +103,8 @@ public class DocumentCollection extends DocumentCollectionBase implements Visibi
 
     private DocumentStore milvusStore() {
         AiMilvusConfig aiMilvusConfig = SpringContextUtil.getBean(AiMilvusConfig.class);
-        AiMilvusClientManager clientManager = SpringContextUtil.getBean(AiMilvusClientManager.class);
-        clientManager.reconfigureIfNeeded(aiMilvusConfig);
         MilvusVectorStoreConfig milvusVectorStoreConfig = aiMilvusConfig.copyForCollection(this.getVectorStoreCollection());
-        return new MilvusVectorStore(milvusVectorStoreConfig, clientManager);
+        return new MilvusVectorStore(milvusVectorStoreConfig);
     }
 
     public Tool toFunction(boolean needEnglishName) {

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/entity/base/DocumentChunkBase.java

@@ -46,18 +46,6 @@ public class DocumentChunkBase implements Serializable {
     @Column(typeHandler = FastjsonTypeHandler.class, comment = "扩展元信息")
     private Map<String, Object> options;
 
-    @Column(comment = "检索索引同步状态")
-    private String indexSyncStatus;
-
-    @Column(comment = "检索索引同步版本")
-    private Long indexSyncVersion;
-
-    @Column(comment = "脱敏同步错误码")
-    private String indexSyncErrorCode;
-
-    @Column(comment = "脱敏同步错误摘要")
-    private String indexSyncErrorMessage;
-
     public BigInteger getId() {
         return id;
     }
@@ -106,36 +94,4 @@ public class DocumentChunkBase implements Serializable {
         this.options = options;
     }
 
-    public String getIndexSyncStatus() {
-        return indexSyncStatus;
-    }
-
-    public void setIndexSyncStatus(String indexSyncStatus) {
-        this.indexSyncStatus = indexSyncStatus;
-    }
-
-    public Long getIndexSyncVersion() {
-        return indexSyncVersion;
-    }
-
-    public void setIndexSyncVersion(Long indexSyncVersion) {
-        this.indexSyncVersion = indexSyncVersion;
-    }
-
-    public String getIndexSyncErrorCode() {
-        return indexSyncErrorCode;
-    }
-
-    public void setIndexSyncErrorCode(String indexSyncErrorCode) {
-        this.indexSyncErrorCode = indexSyncErrorCode;
-    }
-
-    public String getIndexSyncErrorMessage() {
-        return indexSyncErrorMessage;
-    }
-
-    public void setIndexSyncErrorMessage(String indexSyncErrorMessage) {
-        this.indexSyncErrorMessage = indexSyncErrorMessage;
-    }
-
 }

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/mapper/DocumentChunkMapper.java

@@ -2,12 +2,6 @@ package tech.easyflow.ai.mapper;
 
 import tech.easyflow.ai.entity.DocumentChunk;
 import com.mybatisflex.core.BaseMapper;
-import org.apache.ibatis.annotations.Param;
-import org.apache.ibatis.annotations.Select;
-import org.apache.ibatis.annotations.Update;
-
-import java.math.BigInteger;
-import java.util.List;
 
 /**
  *  映射层。
@@ -17,23 +11,4 @@ import java.util.List;
  */
 public interface DocumentChunkMapper extends BaseMapper<DocumentChunk> {
 
-    @Update("UPDATE tb_document_chunk SET index_sync_status=#{status}, "
-        + "index_sync_error_code=#{errorCode}, index_sync_error_message=#{errorMessage} "
-        + "WHERE id=#{id} AND index_sync_version=#{version}")
-    int updateSyncState(@Param("id") BigInteger id,
-                        @Param("version") long version,
-                        @Param("status") String status,
-                        @Param("errorCode") String errorCode,
-                        @Param("errorMessage") String errorMessage);
-
-    @Select("<script>SELECT id, document_id AS documentId, "
-        + "document_collection_id AS documentCollectionId, "
-        + "index_sync_status AS indexSyncStatus, index_sync_version AS indexSyncVersion, "
-        + "index_sync_error_code AS indexSyncErrorCode, "
-        + "index_sync_error_message AS indexSyncErrorMessage "
-        + "FROM tb_document_chunk WHERE document_id=#{documentId} AND id IN "
-        + "<foreach collection='ids' item='id' open='(' separator=',' close=')'>#{id}</foreach>"
-        + "</script>")
-    List<DocumentChunk> selectSyncStates(@Param("documentId") BigInteger documentId,
-                                         @Param("ids") List<BigInteger> ids);
 }

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/mapper/DocumentChunkSyncTaskMapper.java

@@ -1,115 +0,0 @@
-package tech.easyflow.ai.mapper;
-
-import com.mybatisflex.core.BaseMapper;
-import org.apache.ibatis.annotations.Param;
-import org.apache.ibatis.annotations.Select;
-import org.apache.ibatis.annotations.Update;
-import tech.easyflow.ai.entity.DocumentChunkSyncTask;
-
-import java.math.BigInteger;
-import java.util.Date;
-import java.util.List;
-
-/**
- * 文档分块索引同步任务映射层。
- */
-public interface DocumentChunkSyncTaskMapper extends BaseMapper<DocumentChunkSyncTask> {
-
-    String SELECT_COLUMNS = "id, chunk_id AS chunkId, document_id AS documentId, "
-        + "document_collection_id AS documentCollectionId, "
-        + "vector_collection AS vectorCollection, operation, sync_version AS syncVersion, "
-        + "status, attempt_count AS attemptCount, next_retry_at AS nextRetryAt, "
-        + "last_dispatched_at AS lastDispatchedAt, execution_token AS executionToken, "
-        + "lease_until AS leaseUntil, error_code AS errorCode, error_message AS errorMessage, "
-        + "created, created_by AS createdBy, modified, modified_by AS modifiedBy";
-
-    @Update("UPDATE tb_document_chunk_sync_task SET status='SUPERSEDED', "
-        + "execution_token=NULL, lease_until=NULL, modified=#{now} "
-        + "WHERE chunk_id=#{chunkId} AND sync_version < #{syncVersion} "
-        + "AND status IN ('PENDING','RUNNING','FAILED')")
-    int supersedeOlder(@Param("chunkId") BigInteger chunkId,
-                       @Param("syncVersion") long syncVersion,
-                       @Param("now") Date now);
-
-    @Update("UPDATE tb_document_chunk_sync_task SET status='SUPERSEDED', "
-        + "execution_token=NULL, lease_until=NULL, modified=#{now} "
-        + "WHERE chunk_id=#{chunkId} AND status IN ('PENDING','RUNNING','FAILED')")
-    int supersedeChunk(@Param("chunkId") BigInteger chunkId,
-                       @Param("now") Date now);
-
-    /**
-     * 锁定同一分块的任务版本范围，保证外部索引写入与新版本建单按版本串行。
-     */
-    @Select("SELECT id FROM tb_document_chunk_sync_task WHERE chunk_id=#{chunkId} "
-        + "ORDER BY sync_version, id FOR UPDATE")
-    List<BigInteger> lockChunkTasks(@Param("chunkId") BigInteger chunkId);
-
-    @Select("SELECT " + SELECT_COLUMNS + " FROM tb_document_chunk_sync_task "
-        + "WHERE status='PENDING' AND next_retry_at <= #{now} "
-        + "AND (last_dispatched_at IS NULL OR last_dispatched_at <= #{redispatchBefore}) "
-        + "ORDER BY next_retry_at, id LIMIT #{limit}")
-    List<DocumentChunkSyncTask> selectPendingDue(@Param("now") Date now,
-                                                 @Param("redispatchBefore") Date redispatchBefore,
-                                                 @Param("limit") int limit);
-
-    @Update("UPDATE tb_document_chunk_sync_task SET last_dispatched_at=#{now}, modified=#{now} "
-        + "WHERE id=#{id} AND status='PENDING' AND next_retry_at <= #{now} "
-        + "AND (last_dispatched_at IS NULL OR last_dispatched_at <= #{redispatchBefore})")
-    int markDispatched(@Param("id") BigInteger id,
-                       @Param("now") Date now,
-                       @Param("redispatchBefore") Date redispatchBefore);
-
-    @Update("UPDATE tb_document_chunk_sync_task SET status='PENDING', "
-        + "execution_token=NULL, lease_until=NULL, next_retry_at=#{now}, "
-        + "last_dispatched_at=NULL, modified=#{now} "
-        + "WHERE status='RUNNING' AND lease_until <= #{now}")
-    int recoverExpired(@Param("now") Date now);
-
-    @Update("UPDATE tb_document_chunk_sync_task SET status='RUNNING', "
-        + "attempt_count=attempt_count + 1, execution_token=#{token}, "
-        + "lease_until=#{leaseUntil}, error_code=NULL, error_message=NULL, modified=#{now} "
-        + "WHERE id=#{id} AND status='PENDING' AND next_retry_at <= #{now}")
-    int claim(@Param("id") BigInteger id,
-              @Param("token") String token,
-              @Param("leaseUntil") Date leaseUntil,
-              @Param("now") Date now);
-
-    @Update("UPDATE tb_document_chunk_sync_task SET status=#{status}, "
-        + "execution_token=NULL, lease_until=NULL, error_code=#{errorCode}, "
-        + "error_message=#{errorMessage}, modified=#{now} "
-        + "WHERE id=#{id} AND status='RUNNING' AND execution_token=#{token}")
-    int finishOwned(@Param("id") BigInteger id,
-                    @Param("token") String token,
-                    @Param("status") String status,
-                    @Param("errorCode") String errorCode,
-                    @Param("errorMessage") String errorMessage,
-                    @Param("now") Date now);
-
-    @Update("UPDATE tb_document_chunk_sync_task SET status=#{status}, "
-        + "execution_token=NULL, lease_until=NULL, next_retry_at=#{nextRetryAt}, "
-        + "last_dispatched_at=NULL, error_code=#{errorCode}, "
-        + "error_message=#{errorMessage}, modified=#{now} "
-        + "WHERE id=#{id} AND status='RUNNING' AND execution_token=#{token}")
-    int failOrRetryOwned(@Param("id") BigInteger id,
-                         @Param("token") String token,
-                         @Param("status") String status,
-                         @Param("nextRetryAt") Date nextRetryAt,
-                         @Param("errorCode") String errorCode,
-                         @Param("errorMessage") String errorMessage,
-                         @Param("now") Date now);
-
-    @Update("UPDATE tb_document_chunk_sync_task SET status='PENDING', "
-        + "attempt_count=0, next_retry_at=#{now}, last_dispatched_at=NULL, "
-        + "execution_token=NULL, lease_until=NULL, error_code=NULL, error_message=NULL, modified=#{now} "
-        + "WHERE id=#{id} AND chunk_id=#{chunkId} AND sync_version=#{syncVersion} "
-        + "AND status='FAILED'")
-    int retryFailed(@Param("id") BigInteger id,
-                    @Param("chunkId") BigInteger chunkId,
-                    @Param("syncVersion") long syncVersion,
-                    @Param("now") Date now);
-
-    @Select("SELECT " + SELECT_COLUMNS + " FROM tb_document_chunk_sync_task WHERE chunk_id=#{chunkId} "
-        + "AND sync_version=#{syncVersion} AND status='FAILED' ORDER BY id DESC LIMIT 1")
-    DocumentChunkSyncTask selectFailed(@Param("chunkId") BigInteger chunkId,
-                                       @Param("syncVersion") long syncVersion);
-}

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/mapper/DocumentImportBatchItemMapper.java

@@ -17,49 +17,22 @@ import java.util.Date;
  */
 public interface DocumentImportBatchItemMapper extends BaseMapper<DocumentImportBatchItem> {
 
-    String SELECT_COLUMNS = "id, batch_id AS batchId, knowledge_id AS knowledgeId, "
-        + "document_id AS documentId, replaced_document_id AS replacedDocumentId, "
-        + "client_file_key AS clientFileKey, file_name AS fileName, "
-        + "relative_path AS relativePath, file_size AS fileSize, "
-        + "file_path AS filePath, storage_locator AS storageLocator, "
-        + "cleanup_pending AS cleanupPending, content_sha256 AS contentSha256, "
-        + "stage, status, error_summary AS errorSummary, "
-        + "failure_code AS failureCode, applied_strategy_code AS appliedStrategyCode, "
-        + "strategy_snapshot_json AS strategySnapshotJson, retryable, "
-        + "attempt_count AS attemptCount, created, created_by AS createdBy, "
-        + "modified, modified_by AS modifiedBy";
-
     /**
-     * 锁定并读取批次文件项。
+     * 锁定运行批次中的失败项并取得本轮恢复权。
      *
-     * <p>调用方必须先锁定所属批次，再调用本方法，避免批次计数更新时
+     * <p>同时锁定批次和文件项，使恢复任务创建与批次熔断串行化。</p>
-     * 出现共享锁升级死锁。</p>
      *
      * @param itemId 文件项 ID
-     * @return 文件项；不存在时返回 null
+     * @return 可恢复文件项；状态已变化时返回 null
      */
-    @Select("SELECT " + SELECT_COLUMNS + " FROM tb_document_import_batch_item "
+    @Select("SELECT item.* FROM tb_document_import_batch_item item "
-        + "WHERE id=#{itemId} FOR UPDATE")
+        + "INNER JOIN tb_document_import_batch batch ON batch.id=item.batch_id "
-    DocumentImportBatchItem selectForUpdate(
+        + "WHERE item.id=#{itemId} AND item.status='FAILED' "
+        + "AND batch.status='RUNNING' FOR UPDATE")
+    DocumentImportBatchItem selectFailedForRetry(
         @Param("itemId") BigInteger itemId
     );
 
-    /**
-     * 统计运行批次内已经由等价请求推进的活跃文件项。
-     *
-     * <p>调用方必须先锁定批次；所有文件项状态迁移遵循批次到文件项
-     * 的锁顺序，因此该当前状态检查到后续熔断之间不会新增活跃项。</p>
-     *
-     * @param batchId 批次 ID
-     * @return 活跃文件项数量
-     */
-    @Select("SELECT COUNT(*) FROM tb_document_import_batch_item "
-        + "WHERE batch_id=#{batchId} "
-        + "AND status IN ('PENDING','UPLOADING','RUNNING','UPLOADED')")
-    int countActiveItems(
-        @Param("batchId") BigInteger batchId
-    );
-
     /**
      * 将中断批次中尚未结束的文件项统一收口为可恢复失败。
      *
@@ -127,13 +100,14 @@ public interface DocumentImportBatchItemMapper extends BaseMapper<DocumentImport
      * @param modified 修改时间
      * @return 更新行数
      */
-    @Update("UPDATE tb_document_import_batch_item SET "
+    @Update("UPDATE tb_document_import_batch_item item "
-        + "stage=#{stage}, status=#{status}, "
+        + "INNER JOIN tb_document_import_batch batch ON batch.id=item.batch_id SET "
-        + "error_summary=#{errorSummary}, failure_code=#{failureCode}, "
+        + "item.stage=#{stage}, item.status=#{status}, "
-        + "retryable=#{retryable}, "
+        + "item.error_summary=#{errorSummary}, item.failure_code=#{failureCode}, "
-        + "attempt_count=attempt_count + #{attemptDelta}, "
+        + "item.retryable=#{retryable}, "
-        + "modified=#{modified} WHERE id=#{id} "
+        + "item.attempt_count=item.attempt_count + #{attemptDelta}, "
-        + "AND status=#{expectedStatus}")
+        + "item.modified=#{modified} WHERE item.id=#{id} "
+        + "AND item.status=#{expectedStatus} AND batch.status<>'INTERRUPTED'")
     int transitionStatus(
         @Param("id") BigInteger id,
         @Param("expectedStatus") String expectedStatus,
@@ -172,46 +146,21 @@ public interface DocumentImportBatchItemMapper extends BaseMapper<DocumentImport
      * @param modified 修改时间
      * @return 文件项仍属于运行批次且绑定成功时返回 1
      */
-    @Update("UPDATE tb_document_import_batch_item SET "
+    @Update("UPDATE tb_document_import_batch_item item "
-        + "document_id=#{documentId}, stage='PARSE', "
+        + "INNER JOIN tb_document_import_batch batch ON batch.id=item.batch_id SET "
-        + "status='PENDING', error_summary=NULL, "
+        + "item.document_id=#{documentId}, item.stage='PARSE', "
-        + "failure_code=NULL, retryable=0, "
+        + "item.status='PENDING', item.error_summary=NULL, "
-        + "attempt_count=COALESCE(attempt_count, 0) + 1, "
+        + "item.failure_code=NULL, item.retryable=0, "
-        + "modified=#{modified} "
+        + "item.attempt_count=COALESCE(item.attempt_count, 0) + 1, "
-        + "WHERE id=#{id} AND status='FAILED' "
+        + "item.modified=#{modified} "
-        + "AND document_id IS NULL")
+        + "WHERE item.id=#{id} AND item.status='FAILED' "
+        + "AND item.document_id IS NULL AND batch.status='RUNNING'")
     int bindFailedDocument(
         @Param("id") BigInteger id,
         @Param("documentId") BigInteger documentId,
         @Param("modified") Date modified
     );
 
-    /**
-     * 将引用已丢失文档的失败项绑定到恢复创建的新文档。
-     *
-     * @param id 文件项 ID
-     * @param missingDocumentId 已不存在的旧文档 ID
-     * @param documentId 恢复创建的新文档 ID
-     * @param modified 修改时间
-     * @return 文件项仍处于预期失败状态且旧文档确实不存在时返回 1
-     */
-    @Update("UPDATE tb_document_import_batch_item SET "
-        + "document_id=#{documentId}, stage='PARSE', "
-        + "status='PENDING', error_summary=NULL, "
-        + "failure_code=NULL, retryable=0, "
-        + "attempt_count=COALESCE(attempt_count, 0) + 1, "
-        + "modified=#{modified} "
-        + "WHERE id=#{id} AND status='FAILED' "
-        + "AND document_id=#{missingDocumentId} "
-        + "AND NOT EXISTS (SELECT 1 FROM tb_document "
-        + "WHERE id=#{missingDocumentId})")
-    int replaceMissingDocument(
-        @Param("id") BigInteger id,
-        @Param("missingDocumentId") BigInteger missingDocumentId,
-        @Param("documentId") BigInteger documentId,
-        @Param("modified") Date modified
-    );
-
     /**
      * 更新恢复失败项的业务错误，但不提前汇总批次终态。
      *
@@ -221,11 +170,12 @@ public interface DocumentImportBatchItemMapper extends BaseMapper<DocumentImport
      * @param modified 修改时间
      * @return 文件项仍属于运行批次且更新成功时返回 1
      */
-    @Update("UPDATE tb_document_import_batch_item SET "
+    @Update("UPDATE tb_document_import_batch_item item "
-        + "error_summary=#{errorSummary}, failure_code=NULL, "
+        + "INNER JOIN tb_document_import_batch batch ON batch.id=item.batch_id SET "
-        + "retryable=1, modified=#{modified} "
+        + "item.error_summary=#{errorSummary}, item.failure_code=NULL, "
-        + "WHERE id=#{id} AND batch_id=#{batchId} "
+        + "item.retryable=1, item.modified=#{modified} "
-        + "AND status='FAILED'")
+        + "WHERE item.id=#{id} AND item.batch_id=#{batchId} "
+        + "AND item.status='FAILED' AND batch.status='RUNNING'")
     int updateFailedRetryError(
         @Param("id") BigInteger id,
         @Param("batchId") BigInteger batchId,

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/mapper/DocumentImportBatchMapper.java

@@ -18,38 +18,6 @@ import java.util.List;
  */
 public interface DocumentImportBatchMapper extends BaseMapper<DocumentImportBatch> {
 
-    String SELECT_COLUMNS = "id, knowledge_id AS knowledgeId, "
-        + "caller_type AS callerType, caller_id AS callerId, "
-        + "idempotency_key_hash AS idempotencyKeyHash, "
-        + "request_digest AS requestDigest, duplicate_policy AS duplicatePolicy, "
-        + "requested_strategy_json AS requestedStrategyJson, "
-        + "retry_generation AS retryGeneration, version, "
-        + "import_mode AS importMode, status, total_count AS totalCount, "
-        + "total_bytes AS totalBytes, completed_count AS completedCount, "
-        + "processing_count AS processingCount, failed_count AS failedCount, "
-        + "pending_count AS pendingCount, uploaded_count AS uploadedCount, "
-        + "skipped_count AS skippedCount, cancelled_count AS cancelledCount, "
-        + "retryable_failed_count AS retryableFailedCount, "
-        + "interrupt_code AS interruptCode, interrupt_message AS interruptMessage, "
-        + "interrupted_at AS interruptedAt, recovery_pending AS recoveryPending, "
-        + "recovery_file_keys_json AS recoveryFileKeysJson, "
-        + "recovery_token AS recoveryToken, "
-        + "recovery_lease_until AS recoveryLeaseUntil, "
-        + "started_at AS startedAt, finished_at AS finishedAt, created, "
-        + "created_by AS createdBy, modified, modified_by AS modifiedBy";
-
-    /**
-     * 锁定并读取批次，统一批次计数与文件项状态更新的加锁顺序。
-     *
-     * @param batchId 批次 ID
-     * @return 批次；不存在时返回 null
-     */
-    @Select("SELECT " + SELECT_COLUMNS + " FROM tb_document_import_batch "
-        + "WHERE id=#{batchId} FOR UPDATE")
-    DocumentImportBatch selectForUpdate(
-        @Param("batchId") BigInteger batchId
-    );
-
     /**
      * 锁定并读取调用者拥有的批次，保证后续重试基于最新状态。
      *
@@ -58,7 +26,7 @@ public interface DocumentImportBatchMapper extends BaseMapper<DocumentImportBatc
      * @param callerId 调用者 ID
      * @return 批次；不存在时返回 null
      */
-    @Select("SELECT " + SELECT_COLUMNS + " FROM tb_document_import_batch "
+    @Select("SELECT * FROM tb_document_import_batch "
         + "WHERE id=#{batchId} AND caller_type=#{callerType} "
         + "AND caller_id=#{callerId} FOR UPDATE")
     DocumentImportBatch selectOwnedForUpdate(
@@ -227,7 +195,7 @@ public interface DocumentImportBatchMapper extends BaseMapper<DocumentImportBatc
      * @param limit 最大批次数
      * @return 待恢复批次
      */
-    @Select("SELECT " + SELECT_COLUMNS + " FROM tb_document_import_batch "
+    @Select("SELECT * FROM tb_document_import_batch "
         + "WHERE status='RUNNING' AND recovery_pending=1 "
         + "AND (recovery_token IS NULL OR recovery_lease_until <= #{now}) "
         + "ORDER BY modified, id LIMIT #{limit}")
@@ -288,7 +256,7 @@ public interface DocumentImportBatchMapper extends BaseMapper<DocumentImportBatc
      * @param recoveryToken 恢复调度令牌
      * @return 当前令牌持有的批次；令牌失效时返回空
      */
-    @Select("SELECT " + SELECT_COLUMNS + " FROM tb_document_import_batch "
+    @Select("SELECT * FROM tb_document_import_batch "
         + "WHERE id=#{batchId} AND status='RUNNING' "
         + "AND recovery_pending=1 AND recovery_token=#{recoveryToken}")
     DocumentImportBatch selectClaimedRecovery(
@@ -415,7 +383,7 @@ public interface DocumentImportBatchMapper extends BaseMapper<DocumentImportBatc
      * @param limit 最大返回数量
      * @return 待回收批次
      */
-    @Select("SELECT " + SELECT_COLUMNS + " FROM tb_document_import_batch "
+    @Select("SELECT * FROM tb_document_import_batch "
         + "WHERE status IN ('UPLOADING','READY') "
         + "AND ((modified IS NOT NULL AND modified < #{incompleteCutoff}) "
         + "OR (modified IS NULL AND created < #{incompleteCutoff})) "

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/mapper/DocumentImportTaskMapper.java

@@ -18,26 +18,6 @@ import java.util.List;
  */
 public interface DocumentImportTaskMapper extends BaseMapper<DocumentImportTask> {
 
-    String SELECT_COLUMNS = "id, document_id AS documentId, "
-        + "knowledge_id AS knowledgeId, batch_id AS batchId, "
-        + "batch_item_id AS batchItemId, phase, status, "
-        + "provider_task_id AS providerTaskId, payload_json AS payloadJson, "
-        + "error_summary AS errorSummary, failure_code AS failureCode, "
-        + "attempt_no AS attemptNo, execution_token AS executionToken, "
-        + "lease_until AS leaseUntil, version, started_at AS startedAt, "
-        + "finished_at AS finishedAt, created, created_by AS createdBy, "
-        + "modified, modified_by AS modifiedBy";
-
-    String QUALIFIED_SELECT_COLUMNS = "task.id, task.document_id AS documentId, "
-        + "task.knowledge_id AS knowledgeId, task.batch_id AS batchId, "
-        + "task.batch_item_id AS batchItemId, task.phase, task.status, "
-        + "task.provider_task_id AS providerTaskId, task.payload_json AS payloadJson, "
-        + "task.error_summary AS errorSummary, task.failure_code AS failureCode, "
-        + "task.attempt_no AS attemptNo, task.execution_token AS executionToken, "
-        + "task.lease_until AS leaseUntil, task.version, task.started_at AS startedAt, "
-        + "task.finished_at AS finishedAt, task.created, task.created_by AS createdBy, "
-        + "task.modified, task.modified_by AS modifiedBy";
-
     /**
      * 按任务阶段和批次轮转查询待投递任务，避免大批次独占投递窗口。
      *
@@ -45,16 +25,14 @@ public interface DocumentImportTaskMapper extends BaseMapper<DocumentImportTask>
      * @param limit 最大任务数
      * @return 公平排序后的待投递任务
      */
-    @Select("SELECT " + QUALIFIED_SELECT_COLUMNS
+    @Select("SELECT task.* FROM tb_document_import_task task JOIN ("
-        + " FROM tb_document_import_task task JOIN ("
         + "SELECT task.id, ROW_NUMBER() OVER ("
         + "PARTITION BY task.phase, COALESCE(task.batch_id, task.id) "
         + "ORDER BY task.created, task.id) AS lane_row "
         + "FROM tb_document_import_task task "
         + "LEFT JOIN tb_document_import_batch batch ON batch.id=task.batch_id "
         + "WHERE task.status='PENDING' AND task.modified <= #{redispatchBefore} "
-        + "AND (task.batch_id IS NULL OR batch.import_mode='MANUAL' "
+        + "AND (task.batch_id IS NULL OR batch.status='RUNNING')"
-        + "OR batch.status='RUNNING')"
         + ") ranked ON ranked.id=task.id "
         + "ORDER BY ranked.lane_row, task.created, task.id LIMIT #{limit}")
     List<DocumentImportTask> selectPendingFairly(
@@ -74,7 +52,11 @@ public interface DocumentImportTaskMapper extends BaseMapper<DocumentImportTask>
     @Update("UPDATE tb_document_import_task SET modified=#{now}, "
         + "modified_by=#{operatorId}, version=COALESCE(version, 0) + 1 "
         + "WHERE id=#{id} AND status='PENDING' "
-        + "AND modified <= #{redispatchBefore}")
+        + "AND modified <= #{redispatchBefore} "
+        + "AND (batch_id IS NULL OR EXISTS ("
+        + "SELECT 1 FROM tb_document_import_batch batch "
+        + "WHERE batch.id=tb_document_import_task.batch_id "
+        + "AND batch.status='RUNNING'))")
     int touchPendingForDispatch(
         @Param("id") BigInteger id,
         @Param("redispatchBefore") Date redispatchBefore,
@@ -90,7 +72,7 @@ public interface DocumentImportTaskMapper extends BaseMapper<DocumentImportTask>
      * @param limit 最大任务数
      * @return 已失去执行租约的运行任务
      */
-    @Select("SELECT " + SELECT_COLUMNS + " FROM tb_document_import_task "
+    @Select("SELECT * FROM tb_document_import_task "
         + "WHERE status='RUNNING' AND ("
         + "(lease_until IS NOT NULL AND lease_until <= #{now}) OR "
         + "(lease_until IS NULL AND modified <= #{legacyCutoff})) "
@@ -117,7 +99,11 @@ public interface DocumentImportTaskMapper extends BaseMapper<DocumentImportTask>
         + "started_at=COALESCE(started_at, #{now}), finished_at=NULL, "
         + "error_summary=NULL, failure_code=NULL, modified=#{now}, "
         + "modified_by=#{operatorId}, version=COALESCE(version, 0) + 1 "
-        + "WHERE id=#{id} AND status='PENDING'")
+        + "WHERE id=#{id} AND status='PENDING' "
+        + "AND (batch_id IS NULL OR EXISTS ("
+        + "SELECT 1 FROM tb_document_import_batch batch "
+        + "WHERE batch.id=tb_document_import_task.batch_id "
+        + "AND batch.status='RUNNING'))")
     int claimPending(
         @Param("id") BigInteger id,
         @Param("executionToken") String executionToken,
@@ -140,7 +126,11 @@ public interface DocumentImportTaskMapper extends BaseMapper<DocumentImportTask>
         + "modified=#{now}, modified_by=#{operatorId}, "
         + "version=COALESCE(version, 0) + 1 "
         + "WHERE id=#{id} AND status='RUNNING' "
-        + "AND execution_token=#{executionToken}")
+        + "AND execution_token=#{executionToken} "
+        + "AND (batch_id IS NULL OR EXISTS ("
+        + "SELECT 1 FROM tb_document_import_batch batch "
+        + "WHERE batch.id=tb_document_import_task.batch_id "
+        + "AND batch.status='RUNNING'))")
     int renewLease(
         @Param("id") BigInteger id,
         @Param("executionToken") String executionToken,
@@ -166,7 +156,11 @@ public interface DocumentImportTaskMapper extends BaseMapper<DocumentImportTask>
         + "lease_until=NULL, finished_at=#{now}, modified=#{now}, "
         + "modified_by=#{operatorId}, version=COALESCE(version, 0) + 1 "
         + "WHERE id=#{id} AND status='RUNNING' "
-        + "AND execution_token=#{executionToken}")
+        + "AND execution_token=#{executionToken} "
+        + "AND (batch_id IS NULL OR EXISTS ("
+        + "SELECT 1 FROM tb_document_import_batch batch "
+        + "WHERE batch.id=tb_document_import_task.batch_id "
+        + "AND batch.status='RUNNING'))")
     int finishOwned(
         @Param("id") BigInteger id,
         @Param("executionToken") String executionToken,

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/node/DefaultReadService.java

@@ -26,6 +26,10 @@ public class DefaultReadService implements ReadDocService {
     @Override
     public String read(String fileName, InputStream is) {
         String suffix = DocUtil.getSuffix(fileName);
-        return DocUtil.readPreviewContent(suffix, is);
+        if ("pdf".equals(suffix)) {
+            return DocUtil.readPdfFile(is);
+        } else {
+            return DocUtil.readWordFile(suffix, is);
+        }
     }
 }

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/node/DocNodeFileContentExtractor.java

@@ -12,7 +12,6 @@ import tech.easyflow.ai.document.model.DocumentSourceRef;
 import tech.easyflow.ai.document.exception.DocumentParseBridgeException;
 import tech.easyflow.ai.document.service.DocumentParseBridgeService;
 import tech.easyflow.ai.document.support.DocumentInputStreamSupport;
-import tech.easyflow.ai.document.support.DocumentParseFilePolicy;
 import tech.easyflow.ai.document.support.DocumentParseSourceType;
 import tech.easyflow.ai.easyagentsflow.upload.WorkflowApiUploadedFileReader;
 import tech.easyflow.common.filestorage.FileStorageService;
@@ -207,16 +206,6 @@ public class DocNodeFileContentExtractor {
         if (!StringUtil.hasText(sourceRef.getFilePath())) {
             throw new BusinessException("文件输入缺少 filePath");
         }
-        if (!DocumentParseFilePolicy.isSupportedFileName(
-                sourceRef.getFileName())) {
-            throw new BusinessException(
-                "文件“"
-                    + sourceRef.getFileName()
-                    + "”格式不支持，文档解析仅支持 "
-                    + DocumentParseFilePolicy.supportedTypeLabel()
-                    + " 文件"
-            );
-        }
     }
 
     private void collectFileValues(Object value, List<Object> result) {
@@ -296,12 +285,8 @@ public class DocNodeFileContentExtractor {
                                  "document:default-reader");
                  InputStream inputStream =
                          Files.newInputStream(temporaryFile)) {
-                String content = readerManager.getReader().read(
+                return readerManager.getReader().read(
                         sourceRef.getFileName(), inputStream);
-                if (!StringUtil.hasText(content)) {
-                    throw new BusinessException("文档解析结果为空");
-                }
-                return content;
             }
         } catch (IOException e) {
             DocumentInputStreamSupport.SizeLimitExceededException sizeError =

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/node/SaveDatasetNode.java

@@ -6,7 +6,6 @@ import com.easyagents.flow.core.chain.Chain;
 import com.easyagents.flow.core.chain.runtime.RetryableTriggerException;
 import com.easyagents.flow.core.node.BaseNode;
 import com.easyagents.flow.core.util.IoBulkhead;
-import com.mybatisflex.core.tenant.TenantManager;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import tech.easyflow.ai.utils.WorkFlowUtil;
@@ -55,7 +54,6 @@ public class SaveDatasetNode extends BaseNode {
             rows.add(item instanceof JSONObject json ? json : JSONObject.from(item));
         }
         try {
-            TenantManager.ignoreTenantCondition();
             try (IoBulkhead.Permit ignored = IoBulkhead.dataset().acquire(resolveIoTarget())) {
                 writeService.saveRowsIdempotently(
                         datasetRef,
@@ -77,8 +75,6 @@ public class SaveDatasetNode extends BaseNode {
         } catch (Exception ex) {
             log.error("工作流保存数据到统一数据集失败，datasetRef={}", datasetRef, ex);
             throw ex;
-        } finally {
-            TenantManager.restoreTenantCondition();
         }
     }
 

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/node/SearchDatasetNode.java

@@ -7,12 +7,13 @@ import com.easyagents.flow.core.chain.repository.LoopInputReference;
 import com.easyagents.flow.core.node.BaseNode;
 import com.easyagents.flow.core.util.IoBulkhead;
 import com.mybatisflex.core.row.Row;
-import com.mybatisflex.core.tenant.TenantManager;
 import tech.easyflow.common.util.SpringContextUtil;
+import tech.easyflow.common.entity.LoginAccount;
 import tech.easyflow.common.web.exceptions.BusinessException;
 import tech.easyflow.datacenter.execution.model.DatacenterSqlQueryRequest;
 import tech.easyflow.datacenter.execution.model.DatasetRef;
 import tech.easyflow.datacenter.execution.service.DatacenterDatasetQueryService;
+import tech.easyflow.ai.easyagentsflow.cancellation.WorkflowDatasetQueryCancellationRegistry;
 
 import java.util.HashMap;
 import java.util.List;
@@ -55,20 +56,29 @@ public class SearchDatasetNode extends BaseNode {
         Map<String, Object> params =
                 chain.getExecutionState().resolveParameters(this);
         DatacenterDatasetQueryService queryService = SpringContextUtil.getBean(DatacenterDatasetQueryService.class);
+        WorkflowDatasetQueryCancellationRegistry cancellationRegistry =
+                SpringContextUtil.getBean(
+                        WorkflowDatasetQueryCancellationRegistry.class);
+        LoginAccount account = tech.easyflow.ai.utils.WorkFlowUtil.getOperator(chain);
         DatacenterSqlQueryRequest request = buildRuntimeRequest(params);
         Map<String, Object> result = new HashMap<>();
-        try {
+        String queryId = UUID.randomUUID().toString();
-            TenantManager.ignoreTenantCondition();
+        try (WorkflowDatasetQueryCancellationRegistry.Registration registration =
-            try (IoBulkhead.Permit ignored = IoBulkhead.dataset().acquire(resolveIoTarget())) {
+                     cancellationRegistry.register(
+                             chain.getStateInstanceId(), account, queryId);
+             IoBulkhead.Permit ignored = IoBulkhead.dataset()
+                     .acquire(resolveIoTarget())) {
             String resultId = chain.getStateInstanceId()
                     + ":dataset:"
-                        + UUID.randomUUID();
+                    + queryId;
             int rowCount =
                     chain.storeProducedLoopInputOutsideLock(
                     resultId,
                     sink -> queryService.consumeBySql(
                             request,
                             QUERY_PAGE_SIZE,
+                            account,
+                            queryId,
                             sink::accept),
                     0L,
                     chain.currentFencingClaimId(),
@@ -79,9 +89,6 @@ public class SearchDatasetNode extends BaseNode {
                             resultId, rowCount));
             return result;
         }
-        } finally {
-            TenantManager.restoreTenantCondition();
-        }
     }
 
     /**
@@ -97,6 +104,9 @@ public class SearchDatasetNode extends BaseNode {
     }
 
     private DatacenterSqlQueryRequest buildRuntimeRequest(Map<String, Object> params) {
+        if (datasetRef == null || datasetRef.getSourceId() == null) {
+            throw new BusinessException("数据集绑定缺少连接信息，请重新选择数据集");
+        }
         DatacenterSqlQueryRequest request = new DatacenterSqlQueryRequest();
         request.setDatasetRef(copyDatasetRef());
         request.setSql(resolveQuerySql(params));
@@ -128,12 +138,13 @@ public class SearchDatasetNode extends BaseNode {
 
     private DatasetRef copyDatasetRef() {
         DatasetRef copy = new DatasetRef();
+        copy.setTenantId(datasetRef == null ? null : datasetRef.getTenantId());
         copy.setSourceId(datasetRef == null ? null : datasetRef.getSourceId());
         copy.setCatalogId(datasetRef == null ? null : datasetRef.getCatalogId());
         copy.setCatalogName(datasetRef == null ? null : datasetRef.getCatalogName());
-        copy.setTableId(null);
+        copy.setTableId(datasetRef == null ? null : datasetRef.getTableId());
-        copy.setTableName(null);
+        copy.setTableName(datasetRef == null ? null : datasetRef.getTableName());
-        copy.setVersionId(null);
+        copy.setVersionId(datasetRef == null ? null : datasetRef.getVersionId());
         return copy;
     }
 

easyflow-modules/easyflow-module-ai/src/main/java/tech/easyflow/ai/publish/AbstractAiResourceLifecycleHandler.java

@@ -157,15 +157,6 @@ public abstract class AbstractAiResourceLifecycleHandler<T> implements ApprovalS
     protected void enrichOfflineSnapshot(T resource, Map<String, Object> snapshot) {
     }
 
-    /**
-     * 在发布快照参与重复发布比较前补充资源专属契约。
-     *
-     * @param resource 资源
-     * @param snapshot 当前发布快照
-     */
-    protected void enrichPublishSnapshot(T resource, Map<String, Object> snapshot) {
-    }
-
     /**
      * 删除前额外校验。
      *
@@ -296,7 +287,6 @@ public abstract class AbstractAiResourceLifecycleHandler<T> implements ApprovalS
             throw new BusinessException("当前" + resourceLabel() + "状态不允许发布");
         }
         Map<String, Object> snapshot = buildResourceSnapshot(resource);
-        enrichPublishSnapshot(resource, snapshot);
         if (currentStatus == PublishStatus.PUBLISHED && isSameSnapshot(snapshot, getPublishedSnapshot(resource))) {
             throw new BusinessException("当前内容与已发布版本一致，无需重新发布");
         }