diff --git a/backend-java/src/main/java/com/nanri/aiimage/common/util/CozeGroupResultPropagator.java b/backend-java/src/main/java/com/nanri/aiimage/common/util/GroupResultPropagator.java
similarity index 97%
rename from backend-java/src/main/java/com/nanri/aiimage/common/util/CozeGroupResultPropagator.java
rename to backend-java/src/main/java/com/nanri/aiimage/common/util/GroupResultPropagator.java
index 0c76629b..5bea7ca8 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/common/util/CozeGroupResultPropagator.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/common/util/GroupResultPropagator.java
@@ -10,7 +10,7 @@ import java.util.function.BiConsumer;
import java.util.function.Function;
/**
- * Coze 回流数据按 ID 分组传播工具。
+ * LLM 回流数据按 ID 分组传播工具。
*
* 业务背景：
* 解析行按 Excel 行顺序排列，ID 形如 "1"、"1_1"、"1_2"、"2"、"2_1"。
@@ -33,7 +33,7 @@ import java.util.function.Function;
*
使用方式：
*
* // 专利结论列：组内任一行结论命中 "已侵权" 或 "侵权"，组内都改为该标准值
- * CozeGroupResultPropagator.propagateByGroup(
+ * GroupResultPropagator.propagateByGroup(
* receivedRows,
* AppearancePatentParsedRowVo::getDisplayId,
* row -> findResultRow(row, resultMap),
@@ -44,9 +44,9 @@ import java.util.function.Function;
* );
*
*/
-public final class CozeGroupResultPropagator {
+public final class GroupResultPropagator {
- private static final Logger log = LoggerFactory.getLogger(CozeGroupResultPropagator.class);
+ private static final Logger log = LoggerFactory.getLogger(GroupResultPropagator.class);
/**
* 否定前缀关键字。若当前值同时包含 standard 和这些关键字之一，则不视为命中。
@@ -54,7 +54,7 @@ public final class CozeGroupResultPropagator {
*/
private static final List NEGATIVE_KEYWORDS = Arrays.asList("没有", "无", "不", "未");
- private CozeGroupResultPropagator() {
+ private GroupResultPropagator() {
}
/**
diff --git a/backend-java/src/main/java/com/nanri/aiimage/config/CapacityPlanProperties.java b/backend-java/src/main/java/com/nanri/aiimage/config/CapacityPlanProperties.java
index 9b6e443b..2e91a85d 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/config/CapacityPlanProperties.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/config/CapacityPlanProperties.java
@@ -19,7 +19,7 @@ public class CapacityPlanProperties {
/** 数据库连接池（Hikari maximum-pool-size）。 */
private int dbPoolMaxSize = 30;
- /** 外部 HTTP 客户端（Coze/品牌/紫鸟）连接池容量。 */
+ /** 外部 HTTP 客户端（LLM/品牌/紫鸟）连接池容量。 */
private int httpClientPoolMaxSize = 32;
/** RustFS/MinIO OkHttp 连接池容量。 */
diff --git a/backend-java/src/main/java/com/nanri/aiimage/config/HttpClientPool.java b/backend-java/src/main/java/com/nanri/aiimage/config/HttpClientPool.java
index 45767368..8507b19f 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/config/HttpClientPool.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/config/HttpClientPool.java
@@ -8,7 +8,7 @@ import java.time.Duration;
/**
* Task 77：外部 HTTP 客户端统一连接复用池。
- * Coze / 品牌检查 / 紫鸟三个外部客户端共用同一个 java.net.http.HttpClient
+ * LLM / 品牌检查 / 紫鸟三个外部客户端共用同一个 java.net.http.HttpClient
* （内置 keep-alive 连接池），避免各自新建短命客户端导致连接无法复用、
* 每次请求都重新建连。各客户端按自身超时创建独立的
* JdkClientHttpRequestFactory（共享底层连接池），RestClient 单例懒加载。
diff --git a/backend-java/src/main/java/com/nanri/aiimage/config/RequestTraceFilter.java b/backend-java/src/main/java/com/nanri/aiimage/config/RequestTraceFilter.java
index ab022c9d..3b916461 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/config/RequestTraceFilter.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/config/RequestTraceFilter.java
@@ -4,6 +4,7 @@ import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
+import java.util.Locale;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
@@ -19,13 +20,15 @@ public class RequestTraceFilter extends OncePerRequestFilter {
private static final Logger log = LoggerFactory.getLogger(RequestTraceFilter.class);
+ private static final int MIN_REQUEST_BODY_CACHE_LIMIT_BYTES = 1024 * 1024;
+
private final InstanceMetadata instanceMetadata;
private final int requestBodyCacheLimitBytes;
public RequestTraceFilter(InstanceMetadata instanceMetadata,
- @Value("${aiimage.instance-routing.request-body-cache-limit-bytes:104857600}") int requestBodyCacheLimitBytes) {
+ @Value("${aiimage.instance-routing.request-body-cache-limit-bytes:1048576}") int requestBodyCacheLimitBytes) {
this.instanceMetadata = instanceMetadata;
- this.requestBodyCacheLimitBytes = Math.max(1024 * 1024, requestBodyCacheLimitBytes);
+ this.requestBodyCacheLimitBytes = Math.max(MIN_REQUEST_BODY_CACHE_LIMIT_BYTES, requestBodyCacheLimitBytes);
}
@Override
@@ -76,16 +79,23 @@ public class RequestTraceFilter extends OncePerRequestFilter {
}
}
- private static HttpServletRequest wrapRequestIfNeeded(HttpServletRequest request, int requestBodyCacheLimitBytes) {
+ static HttpServletRequest wrapRequestIfNeeded(HttpServletRequest request, int requestBodyCacheLimitBytes) {
if (request instanceof ContentCachingRequestWrapper) {
return request;
}
+ // multipart 不缓存：过滤器日志不读 body，缓存会整体复制上传流到内存
+ String contentType = request.getContentType();
+ if (contentType != null && contentType.trim().toLowerCase(Locale.ROOT).startsWith("multipart/")) {
+ return request;
+ }
String method = request.getMethod();
if ("POST".equalsIgnoreCase(method)
|| "PUT".equalsIgnoreCase(method)
|| "PATCH".equalsIgnoreCase(method)
|| "DELETE".equalsIgnoreCase(method)) {
- return new ContentCachingRequestWrapper(request, requestBodyCacheLimitBytes);
+ // 阈值统一钳到 1MB 下限：0/负数会令 ContentCachingRequestWrapper 构造抛错
+ return new ContentCachingRequestWrapper(
+ request, Math.max(MIN_REQUEST_BODY_CACHE_LIMIT_BYTES, requestBodyCacheLimitBytes));
}
return request;
}
diff --git a/backend-java/src/main/java/com/nanri/aiimage/config/SimilarAsinProperties.java b/backend-java/src/main/java/com/nanri/aiimage/config/SimilarAsinProperties.java
index 186a7e19..6665e546 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/config/SimilarAsinProperties.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/config/SimilarAsinProperties.java
@@ -3,65 +3,38 @@ package com.nanri.aiimage.config;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
-import java.util.ArrayList;
-import java.util.List;
-
@Data
@ConfigurationProperties(prefix = "aiimage.similar-asin")
public class SimilarAsinProperties {
- private String cozeBaseUrl = "https://api.coze.cn";
- private String cozeWorkflowPath = "/v1/workflow/run";
- private String cozeWorkflowHistoryPath = "/v1/workflows/{workflow_id}/run_histories/{execute_id}";
- private String cozeWorkflowId = "7635328462404583478";
- private String cozeToken = "";
- private List cozeCredentials = new ArrayList<>();
- private int cozeCredentialStripeSize = 0;
/**
- * P0-1：单次提交 Coze 工作流的 row 数量。
+ * P0-1：单次提交 LLM 批次的 row 数量。
* 历史值 10，在含 puzzle 多图行的场景下频繁触发 720712008
* "node executed out of limit: 1000"。降到 3 以避免节点上限被打爆。
* 出现持续 720712008 时还会被 P1-1 滑窗自适应再降到 1。
- * 不影响 AppearancePatentProperties 的同名值。
*/
- private int cozeBatchSize = 3;
+ private int llmBatchSize = 3;
/**
- * img_switch=false 时单次提交 Coze 的 row 数。
- * 不走图片检测时工作流压力小，恢复到 10 行一批以提高吞吐；开启图片检测时仍使用 cozeBatchSize。
+ * img_switch=false 时单次提交 LLM 的 row 数。
+ * 不走图片检测时压力小，恢复到 10 行一批以提高吞吐；开启图片检测时仍使用 llmBatchSize。
*/
- private int cozeTextOnlyBatchSize = 10;
- private int cozeConnectTimeoutMillis = 10000;
- private int cozeReadTimeoutMillis = 60000;
- private int cozePollIntervalMillis = 30000;
- private int cozePollTimeoutMillis = 1800000;
+ private int llmTextOnlyBatchSize = 10;
private long dbTaskTouchIntervalMillis = 120000L;
private long dbJobTouchIntervalMillis = 60000L;
private int staleTimeoutMinutes = 30;
private String staleFinalizeCron = "0 */2 * * * *";
/**
- * 同一 credential 两次提交之间的最小间隔（毫秒）。
- * 历史值硬编码 30000（持锁 sleep），导致单凭证仅 2 batch/分钟。
- * 几千行任务场景下成为提交吞吐瓶颈，下调到 5000ms 并改为锁外冷却。
- * 出现 Coze 限流加重时可通过 AIIMAGE_SIMILAR_ASIN_COZE_SUBMIT_MIN_INTERVAL_MILLIS 调高。
- */
- private long cozeSubmitMinIntervalMillis = 5000L;
-
- /**
- * 末尾零头 batch 的强制 flush 阈值（分钟）：当不足 cozeBatchSize 的零头 row
+ * 末尾零头 batch 的强制 flush 阈值（分钟）：当不足 llmBatchSize 的零头 row
* 长时间挂着（Python 慢回传）时触发提交。
* 任务级实测：345 行 / 4h 总耗时中，约 2-3 小时是 batch 永远凑不满 batchSize 在等下一波回传，
- * 把阈值从 15 调到 1：最多 60s 后 1-2 行也强制提交，让 Coze 提交侧持续进票，
- * 总耗时降到与 Python 回传节奏接近。配合 cozeBatchSize=3、cozeSubmitMinIntervalMillis=5000，
- * 实际不会触发 Coze 限流。出现限流加重再调回 5/10。
+ * 把阈值从 15 调到 1：最多 60s 后 1-2 行也强制提交，让 LLM 提交侧持续进票，
+ * 总耗时降到与 Python 回传节奏接近。
*/
- private int cozeFlushPendingMinutes = 1;
+ private int llmFlushPendingMinutes = 1;
/**
- * 同 batch retry + split retry 共享的最大重试次数。原硬编码 5。
+ * 图片下载、解码和缩放共享该池；4 核生产机默认 2，避免图片任务占满整机 CPU。
*/
- private int cozeSubmitMaxRetryCount = 5;
-
- /** 图片下载、解码和缩放共享该池；4 核生产机默认 2，避免图片任务占满整机 CPU。 */
private int imageDownloadPoolSize = 2;
/**
@@ -97,40 +70,11 @@ public class SimilarAsinProperties {
private boolean imageDbCacheEnabled = false;
/**
- * 是否在 Coze 请求 parameters 中附带 api_key 字段。
- * 默认 true：线上 Coze 工作流将该字段视为必填，缺失会得到 4000
- * "Missing required parameters"；前端传入的 api_key 必须透传到 coze。
- * 仅在工作流明确不再需要 api_key 时，可通过环境变量
- * AIIMAGE_SIMILAR_ASIN_COZE_INCLUDE_LEGACY_API_KEY=false 关闭。
- */
- private boolean cozeIncludeLegacyApiKey = true;
-
- /**
- * 是否使用旧的 item 字段顺序 {asin, sku, url, target_urls, title}。
- * 默认 false：当前实现使用 {asin, url, target_urls, title, sku}。
- * 出现兼容问题时可通过 AIIMAGE_SIMILAR_ASIN_COZE_USE_LEGACY_ITEM_ORDER=true
- * 切回旧顺序进行回归对比。
- */
- private boolean cozeUseLegacyItemFieldOrder = false;
-
- /**
- * 是否启用 P0-3 merge 增量缓冲：每个 batch DONE 时仅缓冲 cozeRows，
+ * 是否启用 merge 增量缓冲：每个 batch DONE 时仅缓冲 llmRows，
* 不立即合并到 chunk；finalize 前一次性按 chunkScopeHash 分组合并，
* 把 OSS chunk 读写从 1000+ 次降到 chunk 数量级。
- * 仅作用于"正常 poll DONE"路径；失败 batch / 单 batch 任务 / 其他
- * 11 个 mergeCozeRowsIntoChunk 调用点保留原立即 merge 行为。
- * 出现问题时可通过 AIIMAGE_SIMILAR_ASIN_COZE_RESULT_BUFFER_ENABLED=false
- * 一键回滚到老路径。
*/
- private boolean cozeResultBufferEnabled = true;
-
- /**
- * P0-4：单 credential 抢 Coze 提交锁的最长等待时间（毫秒）。
- * 原硬编码 1000ms，在高并发 split retry 时大量抛 "Coze submit throttle lock timeout"
- * 并把整批行 markFailed。应与 cozeSubmitMinIntervalMillis（5000ms）保持 1.5-2 倍关系，
- * 默认 10000ms 给抢锁更多时间。
- */
- private long cozeSubmitLockWaitMillis = 10000L;
+ private boolean llmResultBufferEnabled = true;
/**
* 解析接口返回的预览行/预览组数量上限。
@@ -193,15 +137,9 @@ public class SimilarAsinProperties {
*/
private int imagePrefetchBudgetSeconds = 60;
- /**
- * P0-4：抢 Coze 提交锁失败后下次重试间隔（毫秒）。
- * 原硬编码 500ms，会在指数退避算法中作为基础值（500/1000/2000/4000ms 上限 4000）。
- */
- private long cozeSubmitLockRetryDelayMillis = 500L;
-
/**
* 货源查询直连 LLM 模式开关（默认 true：新任务与存量 PENDING 批次都走直连 LLM，
- * 不再经过 Coze）。false 时回退到原 Coze 工作流链路（轮询/重试状态机保留）。
+ * 不再经过工作流中转）。
*/
private boolean directLlmEnabled = true;
@@ -230,11 +168,4 @@ public class SimilarAsinProperties {
/** 拼接图/主图下载超时（秒），慢源图片较多时放大该值。 */
private int llmImageDownloadTimeoutSeconds = 10;
-
- @Data
- public static class CozeCredential {
- private String name;
- private String workflowId;
- private String token;
- }
}
diff --git a/backend-java/src/main/java/com/nanri/aiimage/config/TaskFileJobConfig.java b/backend-java/src/main/java/com/nanri/aiimage/config/TaskFileJobConfig.java
index 017e7189..dbd0acb0 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/config/TaskFileJobConfig.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/config/TaskFileJobConfig.java
@@ -1,5 +1,34 @@
package com.nanri.aiimage.config;
+import com.nanri.aiimage.modules.appearancepatent.service.AppearancePatentTaskService;
+import com.nanri.aiimage.modules.brand.service.BrandTaskService;
+import com.nanri.aiimage.modules.collectdata.service.CollectDataService;
+import com.nanri.aiimage.modules.deletebrand.service.DeleteBrandRunService;
+import com.nanri.aiimage.modules.patroldelete.service.PatrolDeleteTaskService;
+import com.nanri.aiimage.modules.pricetrack.service.PriceTrackTaskService;
+import com.nanri.aiimage.modules.productrisk.service.ProductRiskTaskService;
+import com.nanri.aiimage.modules.publish.service.PublishTaskService;
+import com.nanri.aiimage.modules.queryasin.service.QueryAsinTaskService;
+import com.nanri.aiimage.modules.shopdatacrawl.service.ShopDataCrawlTaskService;
+import com.nanri.aiimage.modules.shopmatch.service.ShopMatchTaskService;
+import com.nanri.aiimage.modules.similarasin.service.SimilarAsinTaskService;
+import com.nanri.aiimage.modules.task.service.AppearancePatentResultFileJobHandler;
+import com.nanri.aiimage.modules.task.service.BrandResultFileJobHandler;
+import com.nanri.aiimage.modules.task.service.CollectDataResultFileJobHandler;
+import com.nanri.aiimage.modules.task.service.DeleteBrandResultFileJobHandler;
+import com.nanri.aiimage.modules.task.service.PatrolDeleteResultFileJobHandler;
+import com.nanri.aiimage.modules.task.service.PriceTrackResultFileJobHandler;
+import com.nanri.aiimage.modules.task.service.ProductRiskResultFileJobHandler;
+import com.nanri.aiimage.modules.task.service.PublishResultFileJobHandler;
+import com.nanri.aiimage.modules.task.service.QueryAsinResultFileJobHandler;
+import com.nanri.aiimage.modules.task.service.ResultFileJobHandler;
+import com.nanri.aiimage.modules.task.service.ResultFileJobHandlerRegistry;
+import com.nanri.aiimage.modules.task.service.ShopDataCrawlResultFileJobHandler;
+import com.nanri.aiimage.modules.task.service.ShopMatchResultFileJobHandler;
+import com.nanri.aiimage.modules.task.service.SimilarAsinResultFileJobHandler;
+import com.nanri.aiimage.modules.task.service.TaskResultPayloadService;
+import com.nanri.aiimage.modules.task.service.WithdrawResultFileJobHandler;
+import com.nanri.aiimage.modules.withdraw.service.WithdrawTaskService;
import io.micrometer.core.instrument.MeterRegistry;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.beans.factory.annotation.Value;
@@ -9,6 +38,8 @@ import org.springframework.core.task.TaskExecutor;
import org.springframework.scheduling.concurrent.ConcurrentTaskExecutor;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
+import java.util.List;
+import java.util.Set;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
@@ -16,6 +47,13 @@ import java.util.concurrent.Semaphore;
@Configuration
public class TaskFileJobConfig {
+ /** 结果文件 Job 支持的全部 moduleType（启动校验枚举源，见 ResultFileJobHandlerRegistry.validateCoverage） */
+ public static final Set RESULT_FILE_JOB_MODULE_TYPES = Set.of(
+ "SHOP_MATCH", "PRICE_TRACK", "PRODUCT_RISK_RESOLVE",
+ "PUBLISH", "QUERY_ASIN", "SHOP_DATA_CRAWL", "WITHDRAW",
+ "PATROL_DELETE", "APPEARANCE_PATENT", "SIMILAR_ASIN",
+ "DELETE_BRAND", "BRAND", "COLLECT_DATA");
+
@Bean("taskFileJobDispatchExecutor")
public TaskExecutor taskFileJobDispatchExecutor(
@Value("${aiimage.result-file-job.local-dispatch-pool-size:2}") int poolSize,
@@ -33,24 +71,24 @@ public class TaskFileJobConfig {
}
@Bean(destroyMethod = "shutdown")
- public ExecutorService cozeVirtualThreadExecutor() {
+ public ExecutorService taskQueueVirtualThreadExecutor() {
return Executors.newThreadPerTaskExecutor(Thread.ofVirtual()
- .name("coze-task-", 0)
+ .name("task-queue-", 0)
.factory());
}
- @Bean("cozeTaskExecutor")
- public TaskExecutor cozeTaskExecutor(
- ExecutorService cozeVirtualThreadExecutor,
+ @Bean("taskQueueExecutor")
+ public TaskExecutor taskQueueExecutor(
+ ExecutorService taskQueueVirtualThreadExecutor,
@Value("${aiimage.coze-task.max-concurrent:12}") int maxConcurrent,
@Value("${aiimage.coze-task.max-waiting:1000}") int maxWaiting,
ObjectProvider meterRegistryProvider) {
Semaphore semaphore = new Semaphore(Math.max(1, maxConcurrent));
TaskExecutor semaphoreLimited = new ConcurrentTaskExecutor(command -> {
if (command == null) {
- throw new IllegalArgumentException("coze 任务不能为 null");
+ throw new IllegalArgumentException("task 不能为 null");
}
- cozeVirtualThreadExecutor.execute(() -> {
+ taskQueueVirtualThreadExecutor.execute(() -> {
boolean acquired = false;
try {
semaphore.acquire();
@@ -65,6 +103,87 @@ public class TaskFileJobConfig {
}
});
});
- return new CozeTaskQueueGate(semaphoreLimited, maxWaiting, meterRegistryProvider);
+ return new TaskQueueGate(semaphoreLimited, maxWaiting, meterRegistryProvider);
+ }
+
+ @Bean
+ public ResultFileJobHandlerRegistry resultFileJobHandlerRegistry(List handlers) {
+ ResultFileJobHandlerRegistry registry = new ResultFileJobHandlerRegistry(handlers);
+ registry.validateCoverage(RESULT_FILE_JOB_MODULE_TYPES);
+ return registry;
+ }
+
+ @Bean
+ public ResultFileJobHandler appearancePatentResultFileJobHandler(
+ AppearancePatentTaskService appearancePatentTaskService) {
+ return new AppearancePatentResultFileJobHandler(appearancePatentTaskService);
+ }
+
+ @Bean
+ public ResultFileJobHandler brandResultFileJobHandler(
+ BrandTaskService brandTaskService, TaskResultPayloadService taskResultPayloadService) {
+ return new BrandResultFileJobHandler(brandTaskService, taskResultPayloadService);
+ }
+
+ @Bean
+ public ResultFileJobHandler collectDataResultFileJobHandler(CollectDataService collectDataService) {
+ return new CollectDataResultFileJobHandler(collectDataService);
+ }
+
+ @Bean
+ public ResultFileJobHandler deleteBrandResultFileJobHandler(DeleteBrandRunService deleteBrandRunService) {
+ return new DeleteBrandResultFileJobHandler(deleteBrandRunService);
+ }
+
+ @Bean
+ public ResultFileJobHandler patrolDeleteResultFileJobHandler(
+ PatrolDeleteTaskService patrolDeleteTaskService, TaskResultPayloadService taskResultPayloadService) {
+ return new PatrolDeleteResultFileJobHandler(patrolDeleteTaskService, taskResultPayloadService);
+ }
+
+ @Bean
+ public ResultFileJobHandler priceTrackResultFileJobHandler(
+ PriceTrackTaskService priceTrackTaskService, TaskResultPayloadService taskResultPayloadService) {
+ return new PriceTrackResultFileJobHandler(priceTrackTaskService, taskResultPayloadService);
+ }
+
+ @Bean
+ public ResultFileJobHandler productRiskResultFileJobHandler(
+ ProductRiskTaskService productRiskTaskService, TaskResultPayloadService taskResultPayloadService) {
+ return new ProductRiskResultFileJobHandler(productRiskTaskService, taskResultPayloadService);
+ }
+
+ @Bean
+ public ResultFileJobHandler publishResultFileJobHandler(PublishTaskService publishTaskService) {
+ return new PublishResultFileJobHandler(publishTaskService);
+ }
+
+ @Bean
+ public ResultFileJobHandler queryAsinResultFileJobHandler(
+ QueryAsinTaskService queryAsinTaskService, TaskResultPayloadService taskResultPayloadService) {
+ return new QueryAsinResultFileJobHandler(queryAsinTaskService, taskResultPayloadService);
+ }
+
+ @Bean
+ public ResultFileJobHandler shopDataCrawlResultFileJobHandler(
+ ShopDataCrawlTaskService shopDataCrawlTaskService, TaskResultPayloadService taskResultPayloadService) {
+ return new ShopDataCrawlResultFileJobHandler(shopDataCrawlTaskService, taskResultPayloadService);
+ }
+
+ @Bean
+ public ResultFileJobHandler shopMatchResultFileJobHandler(
+ ShopMatchTaskService shopMatchTaskService, TaskResultPayloadService taskResultPayloadService) {
+ return new ShopMatchResultFileJobHandler(shopMatchTaskService, taskResultPayloadService);
+ }
+
+ @Bean
+ public ResultFileJobHandler similarAsinResultFileJobHandler(SimilarAsinTaskService similarAsinTaskService) {
+ return new SimilarAsinResultFileJobHandler(similarAsinTaskService);
+ }
+
+ @Bean
+ public ResultFileJobHandler withdrawResultFileJobHandler(
+ WithdrawTaskService withdrawTaskService, TaskResultPayloadService taskResultPayloadService) {
+ return new WithdrawResultFileJobHandler(withdrawTaskService, taskResultPayloadService);
}
}
diff --git a/backend-java/src/main/java/com/nanri/aiimage/config/CozeTaskQueueGate.java b/backend-java/src/main/java/com/nanri/aiimage/config/TaskQueueGate.java
similarity index 87%
rename from backend-java/src/main/java/com/nanri/aiimage/config/CozeTaskQueueGate.java
rename to backend-java/src/main/java/com/nanri/aiimage/config/TaskQueueGate.java
index 82bb7373..4342b1e0 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/config/CozeTaskQueueGate.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/config/TaskQueueGate.java
@@ -11,7 +11,7 @@ import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
/**
- * Task 75：虚拟线程任务排队闸门。Coze 执行池的信号量只限制"正在执行"的
+ * Task 75：虚拟线程任务排队闸门。任务执行池的信号量只限制"正在执行"的
* 并发度，提交侧仍会在虚拟线程里无限排队。此闸门在提交时统计"已受理未启动"
* 的等待数，达到上限立即拒绝并记录指标，防止等待队列无界堆积：
*
@@ -21,14 +21,14 @@ import java.util.concurrent.atomic.AtomicInteger;
*
*/
@Slf4j
-public class CozeTaskQueueGate implements TaskExecutor {
+public class TaskQueueGate implements TaskExecutor {
private final TaskExecutor delegate;
private final int maxWaiting;
private final ObjectProvider meterRegistryProvider;
private final AtomicInteger waiting = new AtomicInteger();
- public CozeTaskQueueGate(TaskExecutor delegate, int maxWaiting,
+ public TaskQueueGate(TaskExecutor delegate, int maxWaiting,
ObjectProvider meterRegistryProvider) {
this.delegate = delegate;
this.maxWaiting = Math.max(1, maxWaiting);
@@ -43,13 +43,13 @@ public class CozeTaskQueueGate implements TaskExecutor {
public void execute(Runnable command) {
if (command == null) {
recordRejected("invalid-input");
- throw new IllegalArgumentException("coze 任务不能为 null");
+ throw new IllegalArgumentException("task 不能为 null");
}
if (waiting.get() >= maxWaiting) {
recordRejected("queue-full");
- log.warn("[coze-task][gate] waiting queue full, reject submit waiting={} limit={}",
+ log.warn("[task-queue][gate] waiting queue full, reject submit waiting={} limit={}",
waiting.get(), maxWaiting);
- throw new TaskRejectedException("coze 等待队列已满，limit=" + maxWaiting
+ throw new TaskRejectedException("task 等待队列已满，limit=" + maxWaiting
+ ", waiting=" + waiting.get());
}
waiting.incrementAndGet();
@@ -68,7 +68,7 @@ public class CozeTaskQueueGate implements TaskExecutor {
waiting.decrementAndGet();
recordQueueWait(System.nanoTime() - queuedAt);
recordRejected("delegate-rejected");
- log.warn("[coze-task][gate] delegate rejected submit waiting={} limit={} msg={}",
+ log.warn("[task-queue][gate] delegate rejected submit waiting={} limit={} msg={}",
waiting.get(), maxWaiting, ex.getMessage(), ex);
throw ex;
}
diff --git a/backend-java/src/main/java/com/nanri/aiimage/metrics/ExternalCallMetricsRecorder.java b/backend-java/src/main/java/com/nanri/aiimage/metrics/ExternalCallMetricsRecorder.java
index 22ca3e36..24fe0f3e 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/metrics/ExternalCallMetricsRecorder.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/metrics/ExternalCallMetricsRecorder.java
@@ -13,13 +13,12 @@ import java.util.concurrent.TimeUnit;
/**
* Task 78：外部调用统一指标记录器。
- * 所有外部 HTTP 客户端（Coze / 品牌检查 / 紫鸟）在构建 RestClient 时挂载
+ * 所有外部 HTTP 客户端（LLM / 品牌检查 / 紫鸟）在构建 RestClient 时挂载
* {@link #interceptor(String)} 拦截器，统一记录：
*
* - 耗时：{@code aiimage.external-call.duration}（client + result 标签）；
* - 失败率：{@code aiimage.external-call.total}（result=success/failure，2xx 之外计失败）；
- * - payload 字节：{@code aiimage.external-call.payload.bytes}（请求体字节数）；
- * - 重试次数：{@code aiimage.external-call.retry.total}（客户端重试循环内调用）。
+ * - payload 字节：{@code aiimage.external-call.payload.bytes}（请求体字节数）。
*
* 指标注册表通过 ObjectProvider 懒获取，未配置 Micrometer 时全部静默跳过，
* 不改变既有调用语义。
@@ -77,14 +76,6 @@ public class ExternalCallMetricsRecorder {
};
}
- /** 重试循环内每次进入下一次尝试前调用。 */
- public void recordRetry(String client) {
- MeterRegistry registry = meterRegistry();
- if (registry != null) {
- registry.counter("aiimage.external-call.retry.total", "client", client).increment();
- }
- }
-
private void record(String client, String result, long startedAt, long payloadBytes) {
MeterRegistry registry = meterRegistry();
if (registry == null) {
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/client/AppearancePatentCozeClient.java b/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/client/AppearancePatentLlmClient.java
similarity index 96%
rename from backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/client/AppearancePatentCozeClient.java
rename to backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/client/AppearancePatentLlmClient.java
index 9e458949..ce5ed5b4 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/client/AppearancePatentCozeClient.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/client/AppearancePatentLlmClient.java
@@ -30,12 +30,12 @@ import java.util.regex.Pattern;
/**
* 外观专利检测：直连 LLM（OpenAI 兼容 /v1/chat/completions），
- * 每行并发跑"商标关键词提取"与"外观侵权检测"两个请求，结果语义与原 Coze 工作流对齐。
+ * 每行并发跑"商标关键词提取"与"外观侵权检测"两个请求，结果语义与原 LLM 工作流对齐。
*/
@Component
@RequiredArgsConstructor
@Slf4j
-public class AppearancePatentCozeClient {
+public class AppearancePatentLlmClient {
private static final MediaType APPLICATION_JSON_UTF8 = new MediaType("application", "json", StandardCharsets.UTF_8);
private static final String INFRINGEMENT = "侵权";
@@ -44,7 +44,7 @@ public class AppearancePatentCozeClient {
private static final String APPEARANCE_ANOMALY = "外观识别异常";
private static final String MISSING_ROW_DATA = "爬虫数据缺失";
- /** 商标关键词提取系统提示词（与原 Coze 工作流一致） */
+ /** 商标关键词提取系统提示词（与原 LLM 工作流一致） */
private static final String TITLE_SYSTEM_PROMPT =
"你是品牌词提取工具。从用户输入的商品标题中，提取实际出现的品牌、商标、企业、平台名称及违规关键词。\n\n"
+ "硬性约束：\n"
@@ -57,7 +57,7 @@ public class AppearancePatentCozeClient {
+ "* **兜底输出**：如果文本中确实没有任何商标、品牌或违规词，直接输出 `\"无\"`。\n"
+ "* **零干扰输出**：**绝对不要**包含任何引言、解释、前缀、多余的空格或标点符号。";
- /** 外观专利检测系统提示词（与原 Coze 工作流一致） */
+ /** 外观专利检测系统提示词（与原 LLM 工作流一致） */
private static final String APPEARANCE_SYSTEM_PROMPT =
"# 角色定义\n"
+ "你是一位极其严谨的跨境电商知识产权（IP）律师兼视觉侵权鉴定专家。你的任务是基于用户提供的产品图片和描述，评估该产品在亚马逊等平台销售时的**外观设计（Design Patent）侵权风险**。\n\n"
@@ -158,7 +158,7 @@ public class AppearancePatentCozeClient {
}
/**
- * 单行检测：与原 Coze 工作流语义对齐。
+ * 单行检测：与原 LLM 工作流语义对齐。
* 任一 LLM 失败或数据缺失时走工作流"默认值"分支：appearance=外观识别异常、
* title 保留原始标题、title_reason/appearance_reason 填充对应错误信息。
*/
@@ -197,7 +197,7 @@ public class AppearancePatentCozeClient {
String titleReason = titleFailed ? titleError : firstNonBlank(rawTitle, MISSING_ROW_DATA);
return applyRowFallback(resultRow, rawTitle, titleReason, appearanceFailed ? appearanceReason : "");
}
- CozeResult result = new CozeResult(
+ LlmResult result = new LlmResult(
row.getGroupKey(),
row.getId(),
row.getAsin(),
@@ -219,7 +219,7 @@ public class AppearancePatentCozeClient {
String title,
String titleReason,
String appearanceReason) {
- CozeResult result = new CozeResult(
+ LlmResult result = new LlmResult(
row.getGroupKey(),
row.getId(),
row.getAsin(),
@@ -475,7 +475,7 @@ public class AppearancePatentCozeClient {
}
}
- private List parseResults(String raw) throws Exception {
+ private List parseResults(String raw) throws Exception {
JsonNode root = objectMapper.readTree(raw);
String dataText = extractResultDataText(root);
if (dataText.isBlank()) {
@@ -483,11 +483,11 @@ public class AppearancePatentCozeClient {
}
JsonNode dataRoot = objectMapper.readTree(dataText);
JsonNode array = dataRoot.isArray() ? dataRoot : dataRoot.path("data");
- List results = new ArrayList<>();
+ List results = new ArrayList<>();
if (array.isArray()) {
for (JsonNode node : array) {
JsonNode itemNode = resultItemNode(node);
- results.add(new CozeResult(
+ results.add(new LlmResult(
text(firstNonNull(
firstNonNull(node.get("group_key"), node.get("groupKey")),
firstNonNull(itemNode.get("group_key"), itemNode.get("groupKey")))),
@@ -543,13 +543,13 @@ public class AppearancePatentCozeClient {
return item;
}
- private List mergeRows(List rows, List results) {
- Map resultByGroupKey = new LinkedHashMap<>();
- Map resultByCompositeKey = new LinkedHashMap<>();
- Map resultByAsinCountry = new LinkedHashMap<>();
- Map resultByAsin = new LinkedHashMap<>();
- Map resultByRowId = new LinkedHashMap<>();
- for (CozeResult result : results) {
+ private List mergeRows(List rows, List results) {
+ Map resultByGroupKey = new LinkedHashMap<>();
+ Map resultByCompositeKey = new LinkedHashMap<>();
+ Map resultByAsinCountry = new LinkedHashMap<>();
+ Map resultByAsin = new LinkedHashMap<>();
+ Map resultByRowId = new LinkedHashMap<>();
+ for (LlmResult result : results) {
String groupKey = normalize(result.groupKey());
if (!groupKey.isBlank()) {
resultByGroupKey.putIfAbsent(groupKey, result);
@@ -576,7 +576,7 @@ public class AppearancePatentCozeClient {
boolean allowIndexFallback = results.size() == rows.size() && results.stream().noneMatch(this::hasIdentity);
for (int i = 0; i < rows.size(); i++) {
AppearancePatentResultRowDto row = copy(rows.get(i));
- CozeResult result = resultByGroupKey.get(normalize(row.getGroupKey()));
+ LlmResult result = resultByGroupKey.get(normalize(row.getGroupKey()));
if (result == null) {
result = resultByCompositeKey.get(rowKey(row.getId(), row.getAsin(), row.getCountry()));
}
@@ -606,7 +606,7 @@ public class AppearancePatentCozeClient {
return normalizedAsin + "::" + normalize(country);
}
- private boolean hasIdentity(CozeResult result) {
+ private boolean hasIdentity(LlmResult result) {
if (result == null) {
return false;
}
@@ -615,7 +615,7 @@ public class AppearancePatentCozeClient {
|| !normalize(result.asin()).isBlank();
}
- void applyResult(AppearancePatentResultRowDto row, CozeResult result) {
+ void applyResult(AppearancePatentResultRowDto row, LlmResult result) {
if (row == null || result == null) {
return;
}
@@ -637,21 +637,21 @@ public class AppearancePatentCozeClient {
row.setScore(result.score());
}
- private boolean isNoTitleRisk(CozeResult result) {
+ private boolean isNoTitleRisk(LlmResult result) {
return result != null
&& "无".equals(normalize(result.title()));
}
- private boolean shouldCheckBrand(CozeResult result) {
+ private boolean shouldCheckBrand(LlmResult result) {
return result != null
&& !normalize(result.title()).isBlank()
&& !normalize(result.appearance()).isBlank();
}
- String buildTitleRisk(String cozeTitle, BrandCheckClient.BrandCheckBatchResult brandCheck) {
+ String buildTitleRisk(String llmTitle, BrandCheckClient.BrandCheckBatchResult brandCheck) {
List brands = brandCheck == null ? List.of() : brandCheck.brands();
if (brands == null || brands.isEmpty()) {
- return firstNonBlank(cozeTitle, "");
+ return firstNonBlank(llmTitle, "");
}
if (brandCheck.hasFailedData()) {
return INFRINGEMENT;
@@ -922,7 +922,7 @@ public class AppearancePatentCozeClient {
return node == null || node.isNull() ? null : node.asText();
}
- private record CozeResult(
+ private record LlmResult(
String groupKey,
String rowId,
String asin,
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/model/dto/AppearancePatentResultRowDto.java b/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/model/dto/AppearancePatentResultRowDto.java
index 632a99cb..159f0dbc 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/model/dto/AppearancePatentResultRowDto.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/model/dto/AppearancePatentResultRowDto.java
@@ -20,7 +20,7 @@ public class AppearancePatentResultRowDto {
@Schema(description = "主数据分组 key。Python 应从解析结果原样透传，用于把同组子行补回。", example = "uploads/20260426/appearance_patent_17.xlsx::2@2")
private String groupKey;
- @Schema(description = "Excel 中的 id。代表行通常是整数 id 或 n_1，例如 2_1；最终生成 xlsx 时，2_2、2_3 会复用同组 2_1 的 Coze 检测结果。", example = "2_1")
+ @Schema(description = "Excel 中的 id。代表行通常是整数 id 或 n_1，例如 2_1；最终生成 xlsx 时，2_2、2_3 会复用同组 2_1 的 LLM 检测结果。", example = "2_1")
private String id;
@Schema(description = "亚马逊 ASIN。后端会统一按大写处理和匹配。", example = "B0CJ8SNXXV")
@@ -72,26 +72,26 @@ public class AppearancePatentResultRowDto {
private String appearanceRisk;
@JsonAlias({"patent ", "patent"})
- @Schema(description = "Java 调用 Coze 后生成的专利维度检测结果，对应最终 xlsx 的“专利维度（发明/实用新型专利）”列。兼容 Coze 返回字段 patent 和 patent 后带空格的情况；Python 回传请求中不要传该字段。", example = "未发现明显发明或实用新型专利侵权风险。", accessMode = Schema.AccessMode.READ_ONLY)
+ @Schema(description = "Java 调用 LLM 后生成的专利维度检测结果，对应最终 xlsx 的“专利维度（发明/实用新型专利）”列。兼容 LLM 返回字段 patent 和 patent 后带空格的情况；Python 回传请求中不要传该字段。", example = "未发现明显发明或实用新型专利侵权风险。", accessMode = Schema.AccessMode.READ_ONLY)
private String patentRisk;
- @Schema(description = "Java 调用 Coze 后生成的最终结论，对应最终 xlsx 的“结论”列。Python 回传请求中不要传该字段。", example = "未发现明显侵权风险", accessMode = Schema.AccessMode.READ_ONLY)
+ @Schema(description = "Java 调用 LLM 后生成的最终结论，对应最终 xlsx 的“结论”列。Python 回传请求中不要传该字段。", example = "未发现明显侵权风险", accessMode = Schema.AccessMode.READ_ONLY)
private String conclusion;
@JsonAlias({"title_reason", "titleReason"})
- @Schema(description = "Coze 返回的标题维度原因", accessMode = Schema.AccessMode.READ_ONLY)
+ @Schema(description = "LLM 返回的标题维度原因", accessMode = Schema.AccessMode.READ_ONLY)
private String titleReason;
@JsonAlias({"appearance_reason", "appearanceReason"})
- @Schema(description = "Coze 返回的外观维度原因", accessMode = Schema.AccessMode.READ_ONLY)
+ @Schema(description = "LLM 返回的外观维度原因", accessMode = Schema.AccessMode.READ_ONLY)
private String appearanceReason;
@JsonAlias({"patent_reason", "patentReason", "patent reason"})
- @Schema(description = "Coze 返回的专利维度原因", accessMode = Schema.AccessMode.READ_ONLY)
+ @Schema(description = "LLM 返回的专利维度原因", accessMode = Schema.AccessMode.READ_ONLY)
private String patentReason;
@JsonAlias({"score", "Score", "评分"})
- @Schema(description = "Coze 回流的评分（外观维度），仅保留回流值，不写入最终 xlsx。", accessMode = Schema.AccessMode.READ_ONLY)
+ @Schema(description = "LLM 回流的评分（外观维度），仅保留回流值，不写入最终 xlsx。", accessMode = Schema.AccessMode.READ_ONLY)
private String score;
/**
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/model/vo/AppearancePatentParsedRowVo.java b/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/model/vo/AppearancePatentParsedRowVo.java
index 87e7c276..581f930a 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/model/vo/AppearancePatentParsedRowVo.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/model/vo/AppearancePatentParsedRowVo.java
@@ -39,10 +39,10 @@ public class AppearancePatentParsedRowVo {
@Schema(description = "价格。", example = "12.99")
private String price;
- @Schema(description = "商品 SKU。Java 调用 Coze 时会放入 items[].sku。", example = "SKU-001")
+ @Schema(description = "商品 SKU。Java 调用 LLM 时会放入 items[].sku。", example = "SKU-001")
private String sku;
- @Schema(description = "商品图片 URL 或商品 URL，供 Coze 检测使用。", example = "https://webstatic.aiproxy.vip/output/demo.jpg")
+ @Schema(description = "商品图片 URL 或商品 URL，供 LLM 检测使用。", example = "https://webstatic.aiproxy.vip/output/demo.jpg")
private String url;
@Schema(description = "商品标题。", example = "Women Floral Dress Summer Casual")
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/service/AppearancePatentTaskCacheService.java b/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/service/AppearancePatentTaskCacheService.java
index bfb77d50..b7a46aec 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/service/AppearancePatentTaskCacheService.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/service/AppearancePatentTaskCacheService.java
@@ -146,7 +146,7 @@ public class AppearancePatentTaskCacheService {
return Boolean.TRUE.equals(first);
} catch (Exception ex) {
log.warn("[appearance-patent-cache] mark row processed degraded taskId={} rowKey={} msg={}", taskId, rowKey, ex.getMessage());
- // Redis 降级时放行，由持久化层的 hasResolvedCozeFields 判据兜底去重。
+ // Redis 降级时放行，由持久化层的 hasResolvedLlmFields 判据兜底去重。
return true;
}
}
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/service/AppearancePatentTaskService.java b/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/service/AppearancePatentTaskService.java
index 014f0318..a34c7fa8 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/service/AppearancePatentTaskService.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/service/AppearancePatentTaskService.java
@@ -9,12 +9,12 @@ import com.fasterxml.jackson.databind.ObjectMapper;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.exception.TaskOwnerMismatchException;
import com.nanri.aiimage.common.service.DistributedJobLockService;
-import com.nanri.aiimage.common.util.CozeGroupResultPropagator;
+import com.nanri.aiimage.common.util.GroupResultPropagator;
import com.nanri.aiimage.common.util.FailedStatusRowFilter;
import com.nanri.aiimage.config.AppearancePatentProperties;
import com.nanri.aiimage.config.InstanceMetadata;
import com.nanri.aiimage.config.StorageProperties;
-import com.nanri.aiimage.modules.appearancepatent.client.AppearancePatentCozeClient;
+import com.nanri.aiimage.modules.appearancepatent.client.AppearancePatentLlmClient;
import com.nanri.aiimage.modules.appearancepatent.model.dto.AppearancePatentParseRequest;
import com.nanri.aiimage.modules.appearancepatent.model.dto.AppearancePatentParsedGroupPageDto;
import com.nanri.aiimage.modules.appearancepatent.model.dto.AppearancePatentParsedPayloadDto;
@@ -128,7 +128,7 @@ public class AppearancePatentTaskService {
private final TaskScopeStateMapper taskScopeStateMapper;
private final TaskChunkMapper taskChunkMapper;
private final ObjectMapper objectMapper;
- private final AppearancePatentCozeClient cozeClient;
+ private final AppearancePatentLlmClient llmClient;
private final AppearancePatentTaskCacheService taskCacheService;
private final AppearancePatentProperties properties;
private final TaskFileJobService taskFileJobService;
@@ -413,7 +413,7 @@ public class AppearancePatentTaskService {
completeSubmittedChunk(context);
return null;
});
- scheduleCozePipelineForSubmittedChunk(context);
+ scheduleLlmPipelineForSubmittedChunk(context);
return;
}
FileTaskEntity task = fileTaskMapper.selectById(taskId);
@@ -484,7 +484,7 @@ public class AppearancePatentTaskService {
scope.setLastError(request.getError());
scope.setCompleted(Boolean.TRUE.equals(request.getDone()) ? 1 : 0);
scope.setUpdatedAt(LocalDateTime.now());
- scope.setStateJson("{\"phase\":\"RECEIVED\",\"coze\":\"PENDING\"}");
+ scope.setStateJson("{\"phase\":\"RECEIVED\",\"llm\":\"PENDING\"}");
if (scope.getId() == null) {
taskScopeStateMapper.insert(scope);
} else {
@@ -499,7 +499,7 @@ public class AppearancePatentTaskService {
task.setUpdatedAt(LocalDateTime.now());
fileTaskMapper.updateById(task);
}
- scheduleCozePipelineForSubmittedChunk(context);
+ scheduleLlmPipelineForSubmittedChunk(context);
}
@Transactional
@@ -758,12 +758,12 @@ public class AppearancePatentTaskService {
long startedAt = System.currentTimeMillis();
List llmRows;
try {
- llmRows = cozeClient.inspectRows(batchRows, prompt, apiKey);
+ llmRows = llmClient.inspectRows(batchRows, prompt, apiKey);
} catch (Exception ex) {
String message = firstNonBlank(ex.getMessage(), "LLM 检测失败");
log.warn("[appearance-patent] llm batch failed taskId={} jobId={} rows={} batch={}/{} err={}",
task.getId(), job.getId(), batchRows.size(), batchIndex, batchTotal, message);
- llmRows = cozeClient.markRowsFailed(batchRows, message);
+ llmRows = llmClient.markRowsFailed(batchRows, message);
}
mergeLlmRowsIntoChunks(task, allRowsByBaseId, llmRows, batchRows);
log.info("[appearance-patent] llm batch done taskId={} jobId={} rows={} batch={}/{} costMs={}",
@@ -794,11 +794,11 @@ public class AppearancePatentTaskService {
deduped.put(key, row);
}
}
- mergeCozeRowsIntoSubmittedChunks(task, new ArrayList<>(deduped.values()), allRowsByBaseId);
+ mergeLlmRowsIntoSubmittedChunks(task, new ArrayList<>(deduped.values()), allRowsByBaseId);
}
/**
- * 收集未检测的候选行（行级 Redis 去重 + 已解析字段过滤），与原 Coze 语义一致。
+ * 收集未检测的候选行（行级 Redis 去重 + 已解析字段过滤），与原 LLM 语义一致。
*/
private List loadSubmittedChunks(Long taskId) {
if (taskId == null || taskId <= 0) {
@@ -823,9 +823,9 @@ public class AppearancePatentTaskService {
if (persistedRows.isEmpty()) {
continue;
}
- for (AppearancePatentResultRowDto row : pickGroupRepresentativesForCoze(persistedRows.values())) {
+ for (AppearancePatentResultRowDto row : pickGroupRepresentativesForLlm(persistedRows.values())) {
String key = rowKey(row);
- if (key.isBlank() || hasResolvedCozeFields(row)) {
+ if (key.isBlank() || hasResolvedLlmFields(row)) {
continue;
}
if (taskCacheService.isRowProcessed(chunk.getTaskId(), key)) {
@@ -848,7 +848,7 @@ public class AppearancePatentTaskService {
if (persistedRows.isEmpty()) {
continue;
}
- int unresolved = pickGroupRepresentativesForCoze(persistedRows.values()).size();
+ int unresolved = pickGroupRepresentativesForLlm(persistedRows.values()).size();
if (unresolved > 0) {
total += Math.max(1, (unresolved + batchSize - 1) / batchSize);
}
@@ -860,7 +860,7 @@ public class AppearancePatentTaskService {
return Math.max(1, properties.getFlushPendingMinutes()) * 60_000L;
}
- private void submitCozeForSubmittedChunk(SubmitContext context) {
+ private void submitLlmForSubmittedChunk(SubmitContext context) {
if (context == null || context.task() == null || context.task().getId() == null) {
return;
}
@@ -898,7 +898,7 @@ public class AppearancePatentTaskService {
touchJavaSideTaskActivity(task.getId());
}
- private void scheduleCozePipelineForSubmittedChunk(SubmitContext context) {
+ private void scheduleLlmPipelineForSubmittedChunk(SubmitContext context) {
if (context == null || context.task() == null || context.task().getId() == null) {
return;
}
@@ -919,7 +919,7 @@ public class AppearancePatentTaskService {
if (job == null || "SUCCESS".equals(job.getStatus())) {
return;
}
- taskFileJobService.requeue(job.getId(), "Appearance patent result uploaded, scheduling Coze/file assembly");
+ taskFileJobService.requeue(job.getId(), "Appearance patent result uploaded, scheduling LLM/file assembly");
touchJavaSideTaskActivity(task.getId());
}
@@ -961,7 +961,7 @@ public class AppearancePatentTaskService {
log.warn("[appearance-patent] Python 超时恢复继续推进检测/文件收尾 taskId={} activeAssembleJobs={}",
taskId, activeAssembleJobs);
}
- submitCozeForSubmittedChunk(new SubmitContext(task, null, null, 0, true, null));
+ submitLlmForSubmittedChunk(new SubmitContext(task, null, null, 0, true, null));
touchJavaSideTaskActivity(taskId);
return true;
}
@@ -973,7 +973,7 @@ public class AppearancePatentTaskService {
List inputStates = taskScopeStateMapper.selectList(new LambdaQueryWrapper()
.eq(TaskScopeStateEntity::getTaskId, taskId)
.eq(TaskScopeStateEntity::getModuleType, MODULE_TYPE)
- .isNull(TaskScopeStateEntity::getCozeStatus)
+ .isNull(TaskScopeStateEntity::getLlmStatus)
.orderByDesc(TaskScopeStateEntity::getUpdatedAt));
if (inputStates == null || inputStates.isEmpty()) {
TaskChunkEntity latestChunk = taskChunkMapper.selectOne(new LambdaQueryWrapper()
@@ -1007,7 +1007,7 @@ public class AppearancePatentTaskService {
state.setLastChunkAt(now);
}
state.setUpdatedAt(now);
- state.setStateJson("{\"phase\":\"RECEIVED\",\"coze\":\"PENDING\"}");
+ state.setStateJson("{\"phase\":\"RECEIVED\",\"llm\":\"PENDING\"}");
taskScopeStateMapper.updateById(state);
updated++;
}
@@ -1020,7 +1020,7 @@ public class AppearancePatentTaskService {
Integer chunkTotal,
String error,
boolean completed,
- boolean cozeDone) {
+ boolean llmDone) {
TaskScopeStateEntity scope = taskScopeStateMapper.selectOne(new LambdaQueryWrapper()
.eq(TaskScopeStateEntity::getTaskId, taskId)
.eq(TaskScopeStateEntity::getModuleType, MODULE_TYPE)
@@ -1043,14 +1043,14 @@ public class AppearancePatentTaskService {
scope.setLastError(error);
scope.setCompleted(completed ? 1 : 0);
scope.setUpdatedAt(now);
- scope.setStateJson(cozeDone
- ? "{\"phase\":\"RECEIVED\",\"coze\":\"DONE\"}"
- : "{\"phase\":\"RECEIVED\",\"coze\":\"PENDING\"}");
+ scope.setStateJson(llmDone
+ ? "{\"phase\":\"RECEIVED\",\"llm\":\"DONE\"}"
+ : "{\"phase\":\"RECEIVED\",\"llm\":\"PENDING\"}");
if (scope.getId() == null) {
try {
taskScopeStateMapper.insert(scope);
- log.info("[appearance-patent] scope state inserted taskId={} scope={} scopeHash={} completed={} cozeDone={}",
- taskId, scopeKey, scopeHash, completed, cozeDone);
+ log.info("[appearance-patent] scope state inserted taskId={} scope={} scopeHash={} completed={} llmDone={}",
+ taskId, scopeKey, scopeHash, completed, llmDone);
return;
} catch (DuplicateKeyException ex) {
log.info("[appearance-patent] duplicate scope state inserted concurrently taskId={} scope={}", taskId, scopeKey);
@@ -1072,14 +1072,14 @@ public class AppearancePatentTaskService {
scope.setLastError(error);
scope.setCompleted(completed ? 1 : 0);
scope.setUpdatedAt(now);
- scope.setStateJson(cozeDone
- ? "{\"phase\":\"RECEIVED\",\"coze\":\"DONE\"}"
- : "{\"phase\":\"RECEIVED\",\"coze\":\"PENDING\"}");
+ scope.setStateJson(llmDone
+ ? "{\"phase\":\"RECEIVED\",\"llm\":\"DONE\"}"
+ : "{\"phase\":\"RECEIVED\",\"llm\":\"PENDING\"}");
}
}
taskScopeStateMapper.updateById(scope);
- log.info("[appearance-patent] scope state updated taskId={} scope={} scopeHash={} completed={} cozeDone={}",
- taskId, scopeKey, scopeHash, completed, cozeDone);
+ log.info("[appearance-patent] scope state updated taskId={} scope={} scopeHash={} completed={} llmDone={}",
+ taskId, scopeKey, scopeHash, completed, llmDone);
}
private T inNewTransaction(Supplier action) {
@@ -1209,7 +1209,7 @@ public class AppearancePatentTaskService {
}
}
- private List pickGroupRepresentativesForCoze(java.util.Collection rows) {
+ private List pickGroupRepresentativesForLlm(java.util.Collection rows) {
Map> groupedRows = new LinkedHashMap<>();
if (rows == null) {
return List.of();
@@ -1223,7 +1223,7 @@ public class AppearancePatentTaskService {
}
List representatives = new ArrayList<>();
for (List siblings : groupedRows.values()) {
- boolean alreadyResolved = siblings.stream().anyMatch(this::hasCompleteCozeResult);
+ boolean alreadyResolved = siblings.stream().anyMatch(this::hasCompleteLlmResult);
if (alreadyResolved) {
continue;
}
@@ -1525,11 +1525,11 @@ public class AppearancePatentTaskService {
saveFileBuildProgress(task, job, totalProgressUnits, Math.max(1, plannedLlmUnits), "等待 Python 继续回传数据");
return false;
}
- completeCozeFileJob(task, result, job, totalProgressUnits);
+ completeLlmFileJob(task, result, job, totalProgressUnits);
return true;
}
- private void completeCozeFileJob(FileTaskEntity task,
+ private void completeLlmFileJob(FileTaskEntity task,
FileResultEntity result,
TaskFileJobEntity job,
int totalProgressUnits) {
@@ -1552,18 +1552,18 @@ public class AppearancePatentTaskService {
saveFileBuildProgress(task, job, totalProgressUnits, totalProgressUnits, "结果文件已生成");
}
- private void mergeCozeRowsIntoSubmittedChunks(FileTaskEntity task,
- List cozeRows,
+ private void mergeLlmRowsIntoSubmittedChunks(FileTaskEntity task,
+ List llmRows,
Map> allRowsByBaseId) {
- mergeCozeRowsIntoSubmittedChunks(task, cozeRows, allRowsByBaseId, null, null);
+ mergeLlmRowsIntoSubmittedChunks(task, llmRows, allRowsByBaseId, null, null);
}
- private void mergeCozeRowsIntoSubmittedChunks(FileTaskEntity task,
- List cozeRows,
+ private void mergeLlmRowsIntoSubmittedChunks(FileTaskEntity task,
+ List llmRows,
Map> allRowsByBaseId,
String fallbackScopeHash,
Integer fallbackChunkIndex) {
- if (task == null || cozeRows == null || cozeRows.isEmpty()) {
+ if (task == null || llmRows == null || llmRows.isEmpty()) {
return;
}
List chunks = loadSubmittedChunks(task.getId());
@@ -1578,7 +1578,7 @@ public class AppearancePatentTaskService {
chunkByKey.put(chunkKey, chunk);
}
Map> mergeRowsByChunk = new LinkedHashMap<>();
- for (AppearancePatentResultRowDto resultRow : cozeRows) {
+ for (AppearancePatentResultRowDto resultRow : llmRows) {
for (AppearancePatentResultRowDto expandedRow : expandRows(List.of(resultRow), allRowsByBaseId)) {
String rowKey = rowKey(expandedRow);
if (rowKey.isBlank()) {
@@ -1601,7 +1601,7 @@ public class AppearancePatentTaskService {
}
}
if (!matched) {
- log.warn("[appearance-patent] coze row has no submitted chunk taskId={} rowKey={}",
+ log.warn("[appearance-patent] llm row has no submitted chunk taskId={} rowKey={}",
task.getId(), rowKey);
}
}
@@ -1626,7 +1626,7 @@ public class AppearancePatentTaskService {
Long count = taskScopeStateMapper.selectCount(new LambdaQueryWrapper()
.eq(TaskScopeStateEntity::getTaskId, taskId)
.eq(TaskScopeStateEntity::getModuleType, MODULE_TYPE)
- .isNull(TaskScopeStateEntity::getCozeStatus)
+ .isNull(TaskScopeStateEntity::getLlmStatus)
.isNotNull(TaskScopeStateEntity::getLastChunkAt)
.eq(TaskScopeStateEntity::getCompleted, 1));
return count != null && count > 0;
@@ -1839,8 +1839,8 @@ public class AppearancePatentTaskService {
reasonRows += resultMap.values().stream()
.filter(this::hasReasonFields)
.count();
- validateCompleteCozeCoverage(task.getId(), receivedRows, resultMap);
- conclusionPropagated += CozeGroupResultPropagator.propagateByGroup(
+ validateCompleteLlmCoverage(task.getId(), receivedRows, resultMap);
+ conclusionPropagated += GroupResultPropagator.propagateByGroup(
receivedRows,
AppearancePatentParsedRowVo::getDisplayId,
row -> findResultRow(row, resultMap),
@@ -2020,7 +2020,7 @@ public class AppearancePatentTaskService {
return receivedRows;
}
- private void validateCompleteCozeCoverage(Long taskId,
+ private void validateCompleteLlmCoverage(Long taskId,
List receivedRows,
Map resultMap) {
if (receivedRows == null || receivedRows.isEmpty()) {
@@ -2039,26 +2039,26 @@ public class AppearancePatentTaskService {
}
expectedRows++;
AppearancePatentResultRowDto resultRow = findResultRow(parsedRow, resultMap);
- if (resultRow == null || !hasCompleteCozeResult(resultRow)) {
+ if (resultRow == null || !hasCompleteLlmResult(resultRow)) {
missingRows++;
if (sampleAsins.size() < 5) {
sampleAsins.add(firstNonBlank(parsedRow.getAsin(), firstNonBlank(parsedRow.getDisplayId(), "")));
}
}
}
- boolean enforceCompleteCozeCoverage = false;
- if (enforceCompleteCozeCoverage && expectedRows > 0 && missingRows > 0) {
- log.warn("[appearance-patent] incomplete coze coverage taskId={} expectedRows={} missingRows={} samples={}",
+ boolean enforceCompleteLlmCoverage = false;
+ if (enforceCompleteLlmCoverage && expectedRows > 0 && missingRows > 0) {
+ log.warn("[appearance-patent] incomplete llm coverage taskId={} expectedRows={} missingRows={} samples={}",
taskId, expectedRows, missingRows, sampleAsins);
- throw new BusinessException("Coze 结果不完整：缺少 " + missingRows + "/" + expectedRows + " 条检测结果，请等待重试或重新运行任务");
+ throw new BusinessException("LLM 结果不完整：缺少 " + missingRows + "/" + expectedRows + " 条检测结果，请等待重试或重新运行任务");
}
}
- private boolean hasCompleteCozeResult(AppearancePatentResultRowDto row) {
- return hasUsableCozeField(row.getTitleRisk())
- && hasUsableCozeField(row.getAppearanceRisk())
- && hasUsableCozeField(row.getPatentRisk())
- && hasUsableCozeField(row.getConclusion());
+ private boolean hasCompleteLlmResult(AppearancePatentResultRowDto row) {
+ return hasUsableLlmField(row.getTitleRisk())
+ && hasUsableLlmField(row.getAppearanceRisk())
+ && hasUsableLlmField(row.getPatentRisk())
+ && hasUsableLlmField(row.getConclusion());
}
private boolean hasPersistedResultRows(Long taskId) {
@@ -2231,8 +2231,8 @@ public class AppearancePatentTaskService {
row.createCell(col++).setCellValue(resultRow == null ? firstNonBlank(parsedRow.getTitle(), "") : firstNonBlank(resultRow.getTitle(), parsedRow.getTitle()));
row.createCell(col++).setCellValue(resultRow == null ? firstNonBlank(parsedRow.getUrl(), "") : firstNonBlank(resultRow.getUrl(), parsedRow.getUrl()));
row.createCell(col++).setCellValue(resultRow == null ? firstNonBlank(parsedRow.getSku(), "") : firstNonBlank(resultRow.getSku(), parsedRow.getSku()));
- row.createCell(col++).setCellValue(resultRow == null ? "" : userFacingCozeCellValue(resultRow, resultRow.getTitleRisk()));
- row.createCell(col++).setCellValue(resultRow == null ? "" : userFacingCozeCellValue(resultRow, resultRow.getAppearanceRisk()));
+ row.createCell(col++).setCellValue(resultRow == null ? "" : userFacingLlmCellValue(resultRow, resultRow.getTitleRisk()));
+ row.createCell(col++).setCellValue(resultRow == null ? "" : userFacingLlmCellValue(resultRow, resultRow.getAppearanceRisk()));
row.createCell(col++).setCellValue(resultRow == null ? "" : userFacingConclusion(resultRow));
row.createCell(col).setCellValue(resultRow == null ? "" : userFacingStatus(resultRow));
}
@@ -2284,7 +2284,7 @@ public class AppearancePatentTaskService {
if (row == null || !normalizedAsin.equals(normalize(row.getAsin()).toUpperCase(Locale.ROOT))) {
continue;
}
- if (hasResolvedCozeFields(row) || hasReasonFields(row)) {
+ if (hasResolvedLlmFields(row) || hasReasonFields(row)) {
return row;
}
if (fallback == null) {
@@ -2484,19 +2484,19 @@ public class AppearancePatentTaskService {
return row != null && (!normalize(row.getTitle()).isBlank() || !normalize(row.getUrl()).isBlank());
}
- private boolean hasResolvedCozeFields(AppearancePatentResultRowDto row) {
+ private boolean hasResolvedLlmFields(AppearancePatentResultRowDto row) {
if (row == null) {
return false;
}
- return hasUsableCozeField(row.getTitleRisk())
- || hasUsableCozeField(row.getAppearanceRisk())
- || hasUsableCozeField(row.getPatentRisk())
- || hasUsableCozeField(row.getConclusion());
+ return hasUsableLlmField(row.getTitleRisk())
+ || hasUsableLlmField(row.getAppearanceRisk())
+ || hasUsableLlmField(row.getPatentRisk())
+ || hasUsableLlmField(row.getConclusion());
}
- private boolean hasUsableCozeField(String value) {
+ private boolean hasUsableLlmField(String value) {
String normalized = normalize(value);
- return !normalized.isBlank() && !isTechnicalCozeFailure(normalized);
+ return !normalized.isBlank() && !isTechnicalLlmFailure(normalized);
}
private Map buildHeaderMap(Row header, DataFormatter formatter) {
@@ -2808,8 +2808,8 @@ public class AppearancePatentTaskService {
return transientPayloadStorageService.storeChunkPayloadVersioned(MODULE_TYPE, taskId, scopeHash, chunkIndex, payloadJson);
}
- private String storeSharedCozeBatchPayload(Long taskId, String scopeHash, String payloadJson) {
- requireSharedTransientPayloadStorage("coze batch payload");
+ private String storeSharedLlmBatchPayload(Long taskId, String scopeHash, String payloadJson) {
+ requireSharedTransientPayloadStorage("llm batch payload");
return transientPayloadStorageService.storeParsedPayloadFast(MODULE_TYPE, taskId, scopeHash, payloadJson, true);
}
@@ -3048,13 +3048,13 @@ public class AppearancePatentTaskService {
return executionFailed ? STATUS_FAILED : STATUS_SUCCESS;
}
- private String userFacingCozeCellValue(AppearancePatentResultRowDto row, String value) {
+ private String userFacingLlmCellValue(AppearancePatentResultRowDto row, String value) {
String normalizedValue = normalize(value);
- if (!normalizedValue.isBlank() && !isTechnicalCozeFailure(normalizedValue)) {
+ if (!normalizedValue.isBlank() && !isTechnicalLlmFailure(normalizedValue)) {
return value;
}
- // coze 技术性失败：有错误信息则放入错误信息，没有则留空
- if (row != null && isTechnicalCozeFailure(row.getError())) {
+ // llm 技术性失败：有错误信息则放入错误信息，没有则留空
+ if (row != null && isTechnicalLlmFailure(row.getError())) {
return firstNonBlank(row.getError(), "");
}
return firstNonBlank(value, "");
@@ -3065,11 +3065,11 @@ public class AppearancePatentTaskService {
return "";
}
String conclusion = normalize(row.getConclusion());
- if (!conclusion.isBlank() && !isTechnicalCozeFailure(conclusion)) {
+ if (!conclusion.isBlank() && !isTechnicalLlmFailure(conclusion)) {
return row.getConclusion();
}
- // coze 技术性失败：有错误信息则放入错误信息，没有则留空
- if (isTechnicalCozeFailure(row.getError())) {
+ // llm 技术性失败：有错误信息则放入错误信息，没有则留空
+ if (isTechnicalLlmFailure(row.getError())) {
return firstNonBlank(row.getError(), "");
}
return firstNonBlank(row.getConclusion(), "");
@@ -3089,9 +3089,9 @@ public class AppearancePatentTaskService {
return normalized.isBlank() ? "\u5931\u8d25" : "\u6210\u529f";
}
- private boolean isTechnicalCozeFailure(String value) {
+ private boolean isTechnicalLlmFailure(String value) {
String normalized = normalize(value).toLowerCase(Locale.ROOT);
- return normalized.contains("coze")
+ return normalized.contains("coze") || normalized.contains("llm")
|| normalized.contains("结果不完整")
|| normalized.contains("工作流节点执行超限")
|| normalized.contains("调用超时")
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/coze/mapper/CozeCredentialMapper.java b/backend-java/src/main/java/com/nanri/aiimage/modules/coze/mapper/CozeCredentialMapper.java
deleted file mode 100644
index 608fda32..00000000
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/coze/mapper/CozeCredentialMapper.java
+++ /dev/null
@@ -1,9 +0,0 @@
-package com.nanri.aiimage.modules.coze.mapper;
-
-import com.baomidou.mybatisplus.core.mapper.BaseMapper;
-import com.nanri.aiimage.modules.coze.model.entity.CozeCredentialEntity;
-import org.apache.ibatis.annotations.Mapper;
-
-@Mapper
-public interface CozeCredentialMapper extends BaseMapper {
-}
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/coze/model/entity/CozeCredentialEntity.java b/backend-java/src/main/java/com/nanri/aiimage/modules/coze/model/entity/CozeCredentialEntity.java
deleted file mode 100644
index 3752f897..00000000
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/coze/model/entity/CozeCredentialEntity.java
+++ /dev/null
@@ -1,25 +0,0 @@
-package com.nanri.aiimage.modules.coze.model.entity;
-
-import com.baomidou.mybatisplus.annotation.IdType;
-import com.baomidou.mybatisplus.annotation.TableId;
-import com.baomidou.mybatisplus.annotation.TableName;
-import lombok.Data;
-
-import java.time.LocalDateTime;
-
-@Data
-@TableName("biz_coze_credential")
-public class CozeCredentialEntity {
-
- @TableId(type = IdType.AUTO)
- private Long id;
- private String moduleType;
- private String credentialName;
- private String workflowId;
- private String token;
- private Integer enabled;
- private Integer maxConcurrent;
- private Integer sortOrder;
- private LocalDateTime createdAt;
- private LocalDateTime updatedAt;
-}
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/coze/service/CozeCredentialPoolService.java b/backend-java/src/main/java/com/nanri/aiimage/modules/coze/service/CozeCredentialPoolService.java
deleted file mode 100644
index a9482a15..00000000
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/coze/service/CozeCredentialPoolService.java
+++ /dev/null
@@ -1,200 +0,0 @@
-package com.nanri.aiimage.modules.coze.service;
-
-import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
-import com.nanri.aiimage.modules.coze.mapper.CozeCredentialMapper;
-import com.nanri.aiimage.modules.coze.model.entity.CozeCredentialEntity;
-import lombok.RequiredArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.data.redis.core.StringRedisTemplate;
-import org.springframework.stereotype.Service;
-
-import java.time.Duration;
-import java.util.List;
-import java.util.Objects;
-import java.util.concurrent.ConcurrentHashMap;
-
-@Slf4j
-@Service
-@RequiredArgsConstructor
-public class CozeCredentialPoolService {
-
- private static final Duration INFLIGHT_TTL = Duration.ofMinutes(30);
-
- /**
- * 每个 moduleType 只 WARN 一次，避免高频日志噪音。
- * key = moduleType，value = 仅作占位，仅用 putIfAbsent 语义判断"是否已经 WARN 过"。
- */
- private final ConcurrentHashMap stripeWarnedModules = new ConcurrentHashMap<>();
-
- private final CozeCredentialMapper cozeCredentialMapper;
- private final StringRedisTemplate stringRedisTemplate;
-
- public List listEnabled(String moduleType) {
- if (moduleType == null || moduleType.isBlank()) {
- return List.of();
- }
- try {
- List rows = cozeCredentialMapper.selectList(new LambdaQueryWrapper()
- .eq(CozeCredentialEntity::getModuleType, moduleType)
- .eq(CozeCredentialEntity::getEnabled, 1)
- .orderByAsc(CozeCredentialEntity::getSortOrder)
- .orderByAsc(CozeCredentialEntity::getId));
- if (rows == null || rows.isEmpty()) {
- return List.of();
- }
- return rows.stream()
- .filter(Objects::nonNull)
- .filter(row -> !blank(row.getCredentialName())
- && !blank(row.getWorkflowId())
- && !blank(row.getToken()))
- .map(row -> new CozeCredential(
- row.getCredentialName().trim(),
- row.getWorkflowId().trim(),
- row.getToken().trim(),
- row.getMaxConcurrent() == null || row.getMaxConcurrent() <= 0
- ? Integer.MAX_VALUE
- : row.getMaxConcurrent()))
- .toList();
- } catch (Exception ex) {
- log.warn("[coze-credential] list enabled failed moduleType={} err={}", moduleType, ex.getMessage());
- return List.of();
- }
- }
-
- public CozeCredential chooseLeastInflight(String moduleType, List credentials) {
- return chooseRoundRobin(moduleType, credentials, 1);
- }
-
- public CozeCredential chooseRoundRobin(String moduleType, List credentials, int stripeSize) {
- if (credentials == null || credentials.isEmpty()) {
- return null;
- }
- // stripeSize ≤ 0 时自动按 credentials.size() 适配；正数则按配置走。
- // 注意：stripe=1 与 stripe=credentials.size() 在轮换正确性上等价，差异只在"每个凭据连续选中次数"。
- int safeStripeSize = stripeSize <= 0 ? credentials.size() : stripeSize;
- // 仅当 stripe>1 且小于凭据数时 WARN：此时凭据被切到下一张前会连续选 stripe 次，但未覆盖所有凭据就回到首张，存在偏向。
- if (safeStripeSize > 1 && safeStripeSize < credentials.size() && moduleType != null && !moduleType.isBlank()) {
- if (stripeWarnedModules.putIfAbsent(moduleType, Boolean.TRUE) == null) {
- log.warn("[coze-credential] stripeSize({}) < credentials.size({}) for moduleType={}, "
- + "round-robin may be biased; consider setting stripeSize == credentials.size() "
- + "or leave it 0/negative to auto-adapt",
- safeStripeSize, credentials.size(), moduleType);
- }
- }
- long cursor = nextCursor(moduleType);
- int index = (int) ((Math.max(0L, cursor) / safeStripeSize) % credentials.size());
- return credentials.get(index);
- }
-
- public BorrowedCredential borrow(String moduleType, CozeCredential credential) {
- if (credential == null) {
- return null;
- }
- String key = inflightKey(moduleType, credential.name());
- try {
- Long value = stringRedisTemplate.opsForValue().increment(key);
- stringRedisTemplate.expire(key, INFLIGHT_TTL);
- long inflight = value == null ? 0L : value;
- if (inflight > credential.maxConcurrent()) {
- release(moduleType, credential.name());
- return null;
- }
- return new BorrowedCredential(this, moduleType, credential.name());
- } catch (Exception ex) {
- log.warn("[coze-credential] borrow failed moduleType={} credential={} err={}",
- moduleType, credential.name(), ex.getMessage());
- return BorrowedCredential.noop();
- }
- }
-
- public void release(String moduleType, String credentialName) {
- if (blank(moduleType) || blank(credentialName)) {
- return;
- }
- try {
- Long value = stringRedisTemplate.opsForValue().decrement(inflightKey(moduleType, credentialName));
- if (value != null && value <= 0L) {
- stringRedisTemplate.delete(inflightKey(moduleType, credentialName));
- }
- } catch (Exception ex) {
- log.warn("[coze-credential] release failed moduleType={} credential={} err={}",
- moduleType, credentialName, ex.getMessage());
- }
- }
-
- private long inflight(String moduleType, String credentialName) {
- try {
- String raw = stringRedisTemplate.opsForValue().get(inflightKey(moduleType, credentialName));
- return raw == null || raw.isBlank() ? 0L : Long.parseLong(raw);
- } catch (Exception ex) {
- return 0L;
- }
- }
-
- private long nextCursor(String moduleType) {
- if (blank(moduleType)) {
- return 0L;
- }
- try {
- Long value = stringRedisTemplate.opsForValue().increment(cursorKey(moduleType));
- stringRedisTemplate.expire(cursorKey(moduleType), Duration.ofDays(7));
- return value == null ? 0L : Math.max(0L, value - 1L);
- } catch (Exception ex) {
- log.warn("[coze-credential] cursor increment failed moduleType={} err={}", moduleType, ex.getMessage());
- return System.nanoTime();
- }
- }
-
- private String inflightKey(String moduleType, String credentialName) {
- return "coze:credential:inflight:" + moduleType + ":" + credentialName;
- }
-
- private String cursorKey(String moduleType) {
- return "coze:credential:cursor:" + moduleType;
- }
-
- private boolean blank(String value) {
- return value == null || value.isBlank();
- }
-
- public record CozeCredential(String name,
- String workflowId,
- String token,
- int maxConcurrent) {
- }
-
- public static final class BorrowedCredential implements AutoCloseable {
- private final CozeCredentialPoolService owner;
- private final String moduleType;
- private final String credentialName;
- private final boolean noop;
- private boolean released;
-
- private BorrowedCredential(CozeCredentialPoolService owner, String moduleType, String credentialName) {
- this.owner = owner;
- this.moduleType = moduleType;
- this.credentialName = credentialName;
- this.noop = false;
- }
-
- private BorrowedCredential() {
- this.owner = null;
- this.moduleType = null;
- this.credentialName = null;
- this.noop = true;
- }
-
- private static BorrowedCredential noop() {
- return new BorrowedCredential();
- }
-
- @Override
- public void close() {
- if (released || noop) {
- return;
- }
- released = true;
- owner.release(moduleType, credentialName);
- }
- }
-}
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/imagevideo/service/ImageVideoAsyncTaskService.java b/backend-java/src/main/java/com/nanri/aiimage/modules/imagevideo/service/ImageVideoAsyncTaskService.java
index f33ae5d3..7ce5147a 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/imagevideo/service/ImageVideoAsyncTaskService.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/imagevideo/service/ImageVideoAsyncTaskService.java
@@ -64,7 +64,7 @@ public class ImageVideoAsyncTaskService {
private final ImageVideoWorkflowConfigService workflowConfigService;
private final ImageVideoArchiveService archiveService;
private final ObjectMapper objectMapper;
- private final TaskExecutor cozeTaskExecutor;
+ private final TaskExecutor taskQueueExecutor;
private final InstanceMetadata instanceMetadata;
public ImageVideoAsyncTaskService(
@@ -73,14 +73,14 @@ public class ImageVideoAsyncTaskService {
ImageVideoWorkflowConfigService workflowConfigService,
ImageVideoArchiveService archiveService,
ObjectMapper objectMapper,
- @Qualifier("cozeTaskExecutor") TaskExecutor cozeTaskExecutor,
+ @Qualifier("taskQueueExecutor") TaskExecutor taskQueueExecutor,
InstanceMetadata instanceMetadata) {
this.taskMapper = taskMapper;
this.cozeService = cozeService;
this.workflowConfigService = workflowConfigService;
this.archiveService = archiveService;
this.objectMapper = objectMapper;
- this.cozeTaskExecutor = cozeTaskExecutor;
+ this.taskQueueExecutor = taskQueueExecutor;
this.instanceMetadata = instanceMetadata;
}
@@ -137,7 +137,7 @@ public class ImageVideoAsyncTaskService {
.or().eq(ImageVideoAsyncTaskEntity::getOwnerInstanceId, ""))
.orderByAsc(ImageVideoAsyncTaskEntity::getId)
.last("LIMIT " + DISPATCH_BATCH_SIZE));
- tasks.forEach(task -> cozeTaskExecutor.execute(() -> executeTask(task.getId())));
+ tasks.forEach(task -> taskQueueExecutor.execute(() -> executeTask(task.getId())));
}
@Scheduled(fixedDelayString = "${aiimage.image-video.async-task-poll-delay-ms:5000}")
@@ -149,7 +149,7 @@ public class ImageVideoAsyncTaskService {
.or().eq(ImageVideoAsyncTaskEntity::getOwnerInstanceId, ""))
.orderByAsc(ImageVideoAsyncTaskEntity::getUpdatedAt)
.last("LIMIT " + POLL_BATCH_SIZE));
- tasks.forEach(task -> cozeTaskExecutor.execute(() -> pollTask(task.getId())));
+ tasks.forEach(task -> taskQueueExecutor.execute(() -> pollTask(task.getId())));
}
@EventListener(ApplicationReadyEvent.class)
@@ -190,7 +190,7 @@ public class ImageVideoAsyncTaskService {
taskMapper.insert(task);
log.info("[image-video] async task submitted taskId={} type={} owner={}",
task.getId(), task.getTaskType(), task.getOwnerInstanceId());
- cozeTaskExecutor.execute(() -> executeTask(task.getId()));
+ taskQueueExecutor.execute(() -> executeTask(task.getId()));
return toVo(task);
}
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/client/SimilarAsinCozeClient.java b/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/client/SimilarAsinCozeClient.java
deleted file mode 100644
index 2a93d042..00000000
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/client/SimilarAsinCozeClient.java
+++ /dev/null
@@ -1,1536 +0,0 @@
-package com.nanri.aiimage.modules.similarasin.client;
-
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.nanri.aiimage.config.SimilarAsinProperties;
-import com.nanri.aiimage.modules.coze.service.CozeCredentialPoolService;
-import com.nanri.aiimage.modules.similarasin.model.dto.SimilarAsinResultRowDto;
-import com.nanri.aiimage.modules.similarasin.util.SimilarAsinLogSupport;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.http.HttpHeaders;
-import org.springframework.http.MediaType;
-import org.springframework.http.client.SimpleClientHttpRequestFactory;
-import org.springframework.stereotype.Component;
-import org.springframework.util.StreamUtils;
-import org.springframework.web.client.RestClient;
-
-import com.nanri.aiimage.config.HttpClientPool;
-
-import java.math.BigDecimal;
-import java.nio.charset.StandardCharsets;
-import java.util.ArrayList;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Locale;
-import java.util.Map;
-import java.util.concurrent.atomic.AtomicLong;
-
-@Component
-@Slf4j
-public class SimilarAsinCozeClient {
-
- private static final String MODULE_TYPE = "SIMILAR_ASIN";
- private static final MediaType APPLICATION_JSON_UTF8 = new MediaType("application", "json", StandardCharsets.UTF_8);
- /** Task 19：history 轮询响应正文采样频率（每 N 次记一次完整正文，其余只记状态）。 */
- static final long HISTORY_RESPONSE_LOG_EVERY_N = 20L;
-
- private final SimilarAsinProperties properties;
- private final ObjectMapper objectMapper;
- private final CozeCredentialPoolService cozeCredentialPoolService;
- private final com.nanri.aiimage.metrics.ExternalCallMetricsRecorder externalCallMetrics;
- private final AtomicLong credentialCursor = new AtomicLong();
- private final AtomicLong historyResponseLogCounter = new AtomicLong();
- /**
- * P1-7：单例 RestClient。原 restClient() 每次提交/poll 都新建 SimpleClientHttpRequestFactory + RestClient，
- * 几千行任务并发时会反复创建短命对象造成不必要 GC 压力。RestClient 与 SimpleClientHttpRequestFactory
- * 都是线程安全的，复用一份即可；timeout 变更需要重启服务生效（与历史行为一致）。
- */
- private volatile RestClient sharedRestClient;
-
- public List inspect(List rows, String prompt, String apiKey) {
- return inspect(rows, prompt, apiKey, false);
- }
-
- public List inspect(List rows, String prompt, String apiKey, boolean imgSwitch) {
- return inspect(rows, prompt, apiKey, imgSwitch, false);
- }
-
- public List inspect(List rows,
- String prompt,
- String apiKey,
- boolean imgSwitch,
- boolean categorySwitch) {
- if (rows == null || rows.isEmpty()) {
- return List.of();
- }
- if (!hasConfiguredCredential()) {
- log.warn("[similar-asin] coze token not configured, keep raw rows size={}", rows.size());
- return rows.stream().map(this::copy).toList();
- }
- try {
- return inspectWithFallback(rows, prompt, apiKey, imgSwitch, categorySwitch);
- } catch (Exception ex) {
- String failureMessage = failureMessage(ex);
- log.warn("[similar-asin] coze batch failed size={} err={}", rows.size(), failureMessage);
- return rows.stream().map(this::copy).map(row -> markFailed(row, failureMessage)).toList();
- }
- }
-
- public CozeSubmitResponse submitWorkflow(List rows, String prompt, String apiKey) throws Exception {
- return submitWorkflow(rows, prompt, apiKey, false, nextCredential());
- }
-
- public CozeSubmitResponse submitWorkflow(List rows, String prompt, String apiKey, boolean imgSwitch) throws Exception {
- return submitWorkflow(rows, prompt, apiKey, imgSwitch, nextCredential());
- }
-
- public CozeSubmitResponse submitWorkflow(List rows,
- String prompt,
- String apiKey,
- boolean imgSwitch,
- boolean categorySwitch,
- CozeCredentialRef credential) throws Exception {
- CozeCredentialRef resolvedCredential = resolveCredential(credential);
- JsonNode submitRoot = objectMapper.readTree(postWorkflow(rows, prompt, apiKey, imgSwitch, categorySwitch, resolvedCredential));
- ensureSuccess(submitRoot);
- return new CozeSubmitResponse(
- extractExecuteId(submitRoot),
- extractResultDataText(submitRoot),
- writeJson(submitRoot),
- resolvedCredential.name()
- );
- }
-
- public CozeSubmitResponse submitWorkflow(List rows,
- String prompt,
- String apiKey,
- boolean imgSwitch,
- CozeCredentialRef credential) throws Exception {
- return submitWorkflow(rows, prompt, apiKey, imgSwitch, false, credential);
- }
-
- public CozePollResponse pollWorkflow(String executeId) throws Exception {
- return pollWorkflow(executeId, null);
- }
-
- public CozePollResponse pollWorkflow(String executeId, CozeCredentialRef credential) throws Exception {
- CozeCredentialRef resolvedCredential = resolveCredential(credential);
- JsonNode pollRoot = objectMapper.readTree(getWorkflowHistory(executeId, resolvedCredential));
- ensureSuccess(pollRoot);
- String status = normalize(resolveWorkflowStatus(pollRoot)).toUpperCase(Locale.ROOT);
- String dataText = extractResultDataText(pollRoot);
- String outputText = dataText.isBlank() ? extractWorkflowOutputText(pollRoot) : "";
- String failureMessage = isFailedWorkflowStatus(status)
- ? firstNonBlank(resolveFailureMessage(pollRoot), "Coze 异步工作流失败")
- : "";
- return new CozePollResponse(executeId, status, dataText, outputText, failureMessage, writeJson(pollRoot),
- resolvedCredential.name());
- }
-
- public List mergeRowsFromDataText(List rows, String dataText) throws Exception {
- if (dataText == null || dataText.isBlank()) {
- return rows == null ? List.of() : rows.stream().map(this::copy).toList();
- }
- return mergeRows(rows, parseResults(wrapDataPayload(dataText)));
- }
-
- public List markRowsFailed(List rows, String failureMessage) {
- if (rows == null || rows.isEmpty()) {
- return List.of();
- }
- return rows.stream().map(this::copy).map(row -> markFailed(row, failureMessage)).toList();
- }
-
- private List inspectWithFallback(List rows, String prompt, String apiKey, boolean imgSwitch, boolean categorySwitch) {
- try {
- if (rows.size() == 1) {
- return inspectSingleRowWithRetry(rows, prompt, apiKey, imgSwitch, categorySwitch);
- }
- InspectAttempt attempt = inspectOnce(rows, prompt, apiKey, imgSwitch, categorySwitch);
- if (attempt.resolvedCount() < rows.size()) {
- throw new PartialCozeResultException(attempt.resolvedCount(), rows.size(), attempt.rawResultCount());
- }
- return attempt.mergedRows();
- } catch (Exception ex) {
- if (shouldSplitBatch(rows, ex)) {
- int middle = rows.size() / 2;
- log.warn("[similar-asin] coze batch fallback split size={} left={} right={} err={}",
- rows.size(), middle, rows.size() - middle, failureMessage(ex));
- List merged = new ArrayList<>(rows.size());
- merged.addAll(inspectPartitionWithFailureFallback(rows.subList(0, middle), prompt, apiKey, imgSwitch, categorySwitch));
- merged.addAll(inspectPartitionWithFailureFallback(rows.subList(middle, rows.size()), prompt, apiKey, imgSwitch, categorySwitch));
- return merged;
- }
- throw propagate(ex);
- }
- }
-
- private List inspectPartitionWithFailureFallback(List rows, String prompt, String apiKey, boolean imgSwitch, boolean categorySwitch) {
- try {
- return inspectWithFallback(rows, prompt, apiKey, imgSwitch, categorySwitch);
- } catch (Exception ex) {
- String failureMessage = failureMessage(ex);
- log.warn("[similar-asin] coze partition failed size={} err={}", rows.size(), failureMessage);
- return rows.stream().map(this::copy).map(row -> markFailed(row, failureMessage)).toList();
- }
- }
-
- private List inspectSingleRowWithRetry(List rows, String prompt, String apiKey, boolean imgSwitch, boolean categorySwitch) throws Exception {
- SimilarAsinResultRowDto row = rows.getFirst();
- PartialCozeResultException lastFailure = null;
- for (int attemptIndex = 1; attemptIndex <= 3; attemptIndex++) {
- try {
- InspectAttempt attempt = inspectOnce(rows, prompt, apiKey, imgSwitch, categorySwitch);
- if (attempt.resolvedCount() == rows.size()) {
- return attempt.mergedRows();
- }
- log.warn("[similar-asin] coze single unresolved attempt={} rowId={} asin={} country={} title={} url={} raw={}",
- attemptIndex,
- row.getId(),
- row.getAsin(),
- row.getCountry(),
- abbreviate(row.getTitle(), 120),
- abbreviate(row.getUrl(), 120),
- abbreviate(attempt.raw(), 500));
- lastFailure = new PartialCozeResultException(attempt.resolvedCount(), rows.size(), attempt.rawResultCount());
- } catch (Exception ex) {
- if (attemptIndex >= 3 || !isRetryableBatchFailure(ex)) {
- throw ex;
- }
- log.warn("[similar-asin] coze single retryable failure attempt={} rowId={} asin={} country={} err={}",
- attemptIndex,
- row.getId(),
- row.getAsin(),
- row.getCountry(),
- failureMessage(ex));
- }
- if (attemptIndex < 3) {
- if (externalCallMetrics != null) {
- externalCallMetrics.recordRetry("coze");
- }
- sleepBeforeRetry(attemptIndex);
- }
- }
- throw lastFailure == null ? new PartialCozeResultException(0, rows.size(), 0) : lastFailure;
- }
-
- private InspectAttempt inspectOnce(List rows, String prompt, String apiKey, boolean imgSwitch, boolean categorySwitch) throws Exception {
- String raw = runWorkflowAsyncAndWait(rows, prompt, apiKey, imgSwitch, categorySwitch);
- List results = parseResults(raw);
- List merged = mergeRows(rows, results);
- return new InspectAttempt(raw, merged, resolvedCount(merged), results.size());
- }
-
- private String runWorkflowAsyncAndWait(List rows, String prompt, String apiKey, boolean imgSwitch, boolean categorySwitch) throws Exception {
- CozeCredentialRef credential = nextCredential();
- JsonNode submitRoot = objectMapper.readTree(postWorkflow(rows, prompt, apiKey, imgSwitch, categorySwitch, credential));
- ensureSuccess(submitRoot);
-
- String immediateData = extractResultDataText(submitRoot);
- if (!immediateData.isBlank()) {
- return wrapDataPayload(immediateData);
- }
-
- String executeId = extractExecuteId(submitRoot);
- if (executeId == null || executeId.isBlank()) {
- throw new IllegalStateException("Coze async execute_id missing");
- }
-
- long deadline = System.currentTimeMillis() + Math.max(10000, properties.getCozePollTimeoutMillis());
- while (System.currentTimeMillis() < deadline) {
- ensureNotInterrupted();
- JsonNode pollRoot = objectMapper.readTree(getWorkflowHistory(executeId, credential));
- ensureSuccess(pollRoot);
-
- String dataText = extractResultDataText(pollRoot);
- if (!dataText.isBlank()) {
- return wrapDataPayload(dataText);
- }
-
- String status = normalize(resolveWorkflowStatus(pollRoot)).toUpperCase(Locale.ROOT);
- if (isFailedWorkflowStatus(status)) {
- throw new IllegalStateException(firstNonBlank(resolveFailureMessage(pollRoot), "Coze 异步工作流失败"));
- }
- if (isSuccessfulWorkflowStatus(status)) {
- String outputText = extractWorkflowOutputText(pollRoot);
- if (!outputText.isBlank()) {
- return wrapDataPayload(outputText);
- }
- throw new IllegalStateException("Coze 异步工作流已完成但没有输出结果");
- }
- sleepQuietly(Math.max(200, properties.getCozePollIntervalMillis()));
- }
-
- throw new IllegalStateException("Coze 异步工作流轮询超时");
- }
-
- private String postWorkflow(List rows,
- String prompt,
- String apiKey,
- boolean imgSwitch,
- boolean categorySwitch,
- CozeCredentialRef credential) {
- Map parameters = buildParameters(rows, prompt, apiKey, imgSwitch, categorySwitch);
- Map body = new LinkedHashMap<>();
- body.put("workflow_id", credential.workflowId());
- body.put("parameters", parameters);
- body.put("is_async", Boolean.TRUE);
- log.debug("[similar-asin] coze request credential={} url={} body={}",
- credential.name(),
- joinUrl(properties.getCozeBaseUrl(), properties.getCozeWorkflowPath()),
- SimilarAsinLogSupport.truncate(writeJson(maskCozeRequestBody(body))));
-
- RestClient.RequestBodySpec request = restClient().post()
- .uri(joinUrl(properties.getCozeBaseUrl(), properties.getCozeWorkflowPath()))
- .headers(headers -> {
- headers.setBearerAuth(stripBearer(credential.token()));
- headers.setContentType(APPLICATION_JSON_UTF8);
- headers.set(HttpHeaders.ACCEPT_CHARSET, StandardCharsets.UTF_8.name());
- });
- request.body(body);
- return request.exchange((clientRequest, clientResponse) -> {
- byte[] responseBytes = StreamUtils.copyToByteArray(clientResponse.getBody());
- String responseText = responseBytes.length == 0 ? "" : new String(responseBytes, StandardCharsets.UTF_8);
- log.debug("[similar-asin] coze submit response status={} body={}",
- clientResponse.getStatusCode(),
- SimilarAsinLogSupport.truncate(responseText));
- return responseText;
- });
- }
-
- private String getWorkflowHistory(String executeId, CozeCredentialRef credential) {
- String path = properties.getCozeWorkflowHistoryPath()
- .replace("{workflow_id}", credential.workflowId())
- .replace("{execute_id}", executeId);
- long historyLogCounter = historyResponseLogCounter.getAndIncrement();
- return restClient().get()
- .uri(joinUrl(properties.getCozeBaseUrl(), path))
- .headers(headers -> {
- headers.setBearerAuth(stripBearer(credential.token()));
- headers.setContentType(APPLICATION_JSON_UTF8);
- headers.set(HttpHeaders.ACCEPT_CHARSET, StandardCharsets.UTF_8.name());
- })
- .exchange((clientRequest, clientResponse) -> {
- byte[] responseBytes = StreamUtils.copyToByteArray(clientResponse.getBody());
- String responseText = responseBytes.length == 0 ? "" : new String(responseBytes, StandardCharsets.UTF_8);
- log.debug("[similar-asin] coze history response credential={} executeId={} status={} body={}",
- credential.name(), executeId,
- clientResponse.getStatusCode(),
- SimilarAsinLogSupport.shouldLog(historyLogCounter, HISTORY_RESPONSE_LOG_EVERY_N)
- ? SimilarAsinLogSupport.truncate(responseText)
- : "[sampled out]");
- return responseText;
- });
- }
-
- public CozeCredentialRef nextCredential() {
- List pooledCredentials = cozeCredentialPoolService.listEnabled(MODULE_TYPE);
- CozeCredentialPoolService.CozeCredential pooledCredential =
- cozeCredentialPoolService.chooseRoundRobin(MODULE_TYPE, pooledCredentials, properties.getCozeCredentialStripeSize());
- if (pooledCredential != null) {
- return new CozeCredentialRef(pooledCredential.name(), pooledCredential.workflowId(), pooledCredential.token(),
- pooledCredential.maxConcurrent());
- }
- List credentials = configuredCredentials();
- int configuredStripe = properties.getCozeCredentialStripeSize();
- int stripeSize = configuredStripe <= 0 ? Math.max(1, credentials.size()) : configuredStripe;
- long cursor = Math.max(0L, credentialCursor.getAndIncrement());
- int index = (int) ((cursor / stripeSize) % credentials.size());
- return credentials.get(index);
- }
-
- public CozeCredentialRef credentialByName(String name) {
- if (name == null || name.isBlank()) {
- return nextCredential();
- }
- String normalizedName = normalize(name);
- for (CozeCredentialRef credential : configuredCredentials()) {
- if (normalize(credential.name()).equals(normalizedName)) {
- return credential;
- }
- }
- return nextCredential();
- }
-
- public boolean hasConfiguredCredential() {
- return !configuredCredentials().isEmpty();
- }
-
- public int configuredCredentialCount() {
- return configuredCredentials().size();
- }
-
- private CozeCredentialRef resolveCredential(CozeCredentialRef credential) {
- return credential == null ? nextCredential() : credential;
- }
-
- private List configuredCredentials() {
- List credentials = new ArrayList<>();
- for (CozeCredentialPoolService.CozeCredential credential : cozeCredentialPoolService.listEnabled(MODULE_TYPE)) {
- credentials.add(new CozeCredentialRef(credential.name(), credential.workflowId(), credential.token(),
- credential.maxConcurrent()));
- }
- if (!credentials.isEmpty()) {
- return credentials;
- }
- if (properties.getCozeCredentials() != null) {
- int index = 1;
- for (SimilarAsinProperties.CozeCredential credential : properties.getCozeCredentials()) {
- if (credential == null
- || normalize(credential.getWorkflowId()).isBlank()
- || normalize(credential.getToken()).isBlank()) {
- continue;
- }
- String name = firstNonBlank(credential.getName(), "credential-" + index);
- credentials.add(new CozeCredentialRef(name, credential.getWorkflowId(), credential.getToken(), Integer.MAX_VALUE));
- index++;
- }
- }
- if (credentials.isEmpty()
- && properties.getCozeWorkflowId() != null && !properties.getCozeWorkflowId().isBlank()
- && properties.getCozeToken() != null && !properties.getCozeToken().isBlank()) {
- credentials.add(new CozeCredentialRef("default", properties.getCozeWorkflowId(), properties.getCozeToken(), Integer.MAX_VALUE));
- }
- return credentials;
- }
-
- private Map buildParameters(List rows, String prompt, String apiKey, boolean imgSwitch) {
- return buildParameters(rows, prompt, apiKey, imgSwitch, false);
- }
-
- private Map buildParameters(List rows,
- String prompt,
- String apiKey,
- boolean imgSwitch,
- boolean categorySwitch) {
- List asins = rows.stream().map(row -> safeText(row.getAsin())).toList();
- List titles = rows.stream().map(row -> safeText(firstNonBlank(row.getTitle(), row.getAsin()))).toList();
- List skus = rows.stream().map(row -> safeText(row.getSku())).toList();
- List urls = rows.stream().map(this::primaryImageUrl).toList();
- List> urlLists = rows.stream().map(this::imageUrls).toList();
- List>> alibabaLists = rows.stream().map(this::alibabaItems).toList();
-
- List> items = buildItemObjects(asins, titles, skus, urls, urlLists, alibabaLists);
- logCozeItemsDiff(rows, items);
- Map parameters = new LinkedHashMap<>();
- parameters.put("items", items);
- // 前端没填 prompt 就一律不向 Coze 透传该字段，避免无关默认提示词污染工作流。
- if (prompt != null && !prompt.isBlank()) {
- parameters.put("prompt", prompt);
- }
- // legacy flag：当线上 coze 工作流回退到老契约时，把环境变量
- // AIIMAGE_SIMILAR_ASIN_COZE_INCLUDE_LEGACY_API_KEY=true 即可重新塞 api_key。
- boolean includeLegacyApiKey = properties.isCozeIncludeLegacyApiKey();
- if (includeLegacyApiKey && apiKey != null && !apiKey.isBlank()) {
- parameters.put("api_key", apiKey.trim());
- }
- parameters.put("img_switch", imgSwitch);
- parameters.put("category_switch", categorySwitch);
- return parameters;
- }
-
- /**
- * 打印每一行 row 在送入 Coze 前后的关键字段，便于排查 Python -> Java -> Coze 的字段是否被改写。
- * 对照点：asin / url / urls(size+样例) / title / sku；以及组装到 Coze 后的 url / target_urls。
- */
- private void logCozeItemsDiff(List rows, List> items) {
- if (rows == null || items == null) {
- return;
- }
- int size = Math.min(rows.size(), items.size());
- log.info("[similar-asin] coze items diff start batchSize={}", size);
- for (int i = 0; i < size; i++) {
- SimilarAsinResultRowDto row = rows.get(i);
- Map item = items.get(i);
- if (row == null || item == null) {
- continue;
- }
- List rowUrls = safeUrls(row.getUrls());
- String rowUrl = safeText(row.getUrl());
- Object outUrl = item.get("url");
- Object outAlibaba = item.get("alibaba");
- Object outTargetUrls = item.get("target_urls");
- int outTargetSize = (outTargetUrls instanceof List list) ? list.size() : 0;
- int outAlibabaSize = (outAlibaba instanceof List list) ? list.size() : 0;
- boolean urlMatch = String.valueOf(outUrl == null ? "" : outUrl).equals(rowUrl);
- boolean targetMatch = (outTargetUrls instanceof List outList)
- && outList.size() == rowUrls.size()
- && outList.equals(rowUrls);
- log.info("[similar-asin] coze item idx={} asin={} title={} sku={} price={} rowUrl={} rowUrlsSize={} rowUrlsHead={} rowUrlsTail={} outUrl={} outAlibabaSize={} outTargetSize={} outTargetHead={} outTargetTail={} urlMatch={} targetUrlsMatch={}",
- i,
- safeText(row.getAsin()),
- abbreviate(safeText(row.getTitle()), 80),
- safeText(row.getSku()),
- safeText(row.getPrice()),
- abbreviate(rowUrl, 200),
- rowUrls.size(),
- rowUrls.isEmpty() ? "" : abbreviate(rowUrls.get(0), 200),
- rowUrls.size() <= 1 ? "" : abbreviate(rowUrls.get(rowUrls.size() - 1), 200),
- abbreviate(String.valueOf(outUrl == null ? "" : outUrl), 200),
- outAlibabaSize,
- outTargetSize,
- (outTargetUrls instanceof List headList && !headList.isEmpty())
- ? abbreviate(String.valueOf(headList.get(0)), 200) : "",
- (outTargetUrls instanceof List tailList && tailList.size() > 1)
- ? abbreviate(String.valueOf(tailList.get(tailList.size() - 1)), 200) : "",
- urlMatch,
- targetMatch);
- }
- }
-
- @SuppressWarnings("unchecked")
- private Map maskCozeRequestBody(Map body) {
- Map masked = new LinkedHashMap<>(body);
- Object topLevelApiKey = masked.get("api_key");
- if (topLevelApiKey instanceof String apiKeyText && !apiKeyText.isBlank()) {
- masked.put("api_key", maskSecret(apiKeyText));
- }
- Object parametersObj = masked.get("parameters");
- if (parametersObj instanceof Map parameters) {
- Map maskedParameters = new LinkedHashMap<>((Map) parameters);
- Object apiKey = maskedParameters.get("api_key");
- if (apiKey instanceof String apiKeyText && !apiKeyText.isBlank()) {
- maskedParameters.put("api_key", maskSecret(apiKeyText));
- }
- masked.put("parameters", maskedParameters);
- }
- return masked;
- }
-
- private String maskSecret(String secret) {
- String normalized = secret == null ? "" : secret.trim();
- if (normalized.isBlank()) {
- return "";
- }
- if (normalized.length() <= 10) {
- return "***";
- }
- return normalized.substring(0, 6) + "***" + normalized.substring(normalized.length() - 4);
- }
-
- private List> buildItemObjects(List asins,
- List titles,
- List skus,
- List urls,
- List> urlLists,
- List>> alibabaLists) {
- // legacy flag：保留切回旧字段顺序 {asin, sku, url, target_urls, title} 的开关，
- // 默认 false 使用当前顺序 {asin, url, target_urls, title, sku}。
- boolean useLegacyOrder = properties.isCozeUseLegacyItemFieldOrder();
- List> items = new ArrayList<>(asins.size());
- for (int i = 0; i < asins.size(); i++) {
- String url = urls.get(i);
- List imageUrls = urlLists.get(i);
- List> alibabaItems = alibabaLists.get(i);
- Map item = new LinkedHashMap<>();
- if (useLegacyOrder) {
- item.put("asin", asins.get(i));
- item.put("sku", skus.get(i));
- item.put("url", url);
- item.put("alibaba", alibabaItems);
- item.put("target_urls", imageUrls);
- item.put("title", titles.get(i));
- } else {
- item.put("asin", asins.get(i));
- item.put("url", url);
- item.put("alibaba", alibabaItems);
- item.put("target_urls", imageUrls);
- item.put("title", titles.get(i));
- item.put("sku", skus.get(i));
- }
- items.add(item);
- }
- return items;
- }
-
- private List parseResults(String raw) throws Exception {
- JsonNode root = objectMapper.readTree(raw);
- ensureSuccess(root);
- String dataText = extractResultDataText(root);
- if (dataText.isBlank()) {
- return List.of();
- }
- JsonNode dataRoot = objectMapper.readTree(dataText);
- JsonNode array = dataRoot.isArray() ? dataRoot : dataRoot.path("data");
- List results = new ArrayList<>();
- if (array.isArray()) {
- for (JsonNode node : array) {
- JsonNode itemNode = resultItemNode(node);
- results.add(new CozeResult(
- text(firstNonNull(
- firstNonNull(node.get("group_key"), node.get("groupKey")),
- firstNonNull(itemNode.get("group_key"), itemNode.get("groupKey")))),
- text(firstNonNull(
- firstNonNull(node.get("row_token"), node.get("rowToken")),
- firstNonNull(itemNode.get("row_token"), itemNode.get("rowToken")))),
- text(firstNonNull(
- firstNonNull(node.get("row_id"), firstNonNull(node.get("rowId"), node.get("id"))),
- firstNonNull(itemNode.get("row_id"), firstNonNull(itemNode.get("rowId"), itemNode.get("id"))))),
- text(firstNonNull(node.get("asin"), itemNode.get("asin"))),
- text(firstNonNull(
- firstNonNull(node.get("country"), node.get("site")),
- firstNonNull(itemNode.get("country"), itemNode.get("site")))),
- text(firstNonNull(
- firstNonNull(node.get("sku"), firstNonNull(node.get("SKU"), firstNonNull(node.get("seller_sku"), node.get("sellerSku")))),
- firstNonNull(itemNode.get("sku"), firstNonNull(itemNode.get("SKU"), firstNonNull(itemNode.get("seller_sku"), itemNode.get("sellerSku")))))),
- text(firstNonNull(
- firstNonNull(node.get("price"), node.get("价格")),
- firstNonNull(itemNode.get("price"), itemNode.get("价格")))),
- text(firstNonNull(node.get("title"), firstNonNull(itemNode.get("title"), itemNode.get("title_risk")))),
- text(firstNonNull(
- firstNonNull(node.get("is_stock"), firstNonNull(node.get("isStock"), firstNonNull(node.get("stock"), node.get("是否有货")))),
- firstNonNull(itemNode.get("is_stock"), firstNonNull(itemNode.get("isStock"), firstNonNull(itemNode.get("stock"), itemNode.get("是否有货")))))),
- text(firstNonNull(
- firstNonNull(node.get("similarity"), firstNonNull(node.get("similarity_rate"), node.get("相似度"))),
- firstNonNull(itemNode.get("similarity"), firstNonNull(itemNode.get("similarity_rate"), itemNode.get("相似度"))))),
- text(firstNonNull(
- firstNonNull(node.get("is_conform"), firstNonNull(node.get("isConform"), firstNonNull(node.get("conform"), node.get("是否符合类目")))),
- firstNonNull(itemNode.get("is_conform"), firstNonNull(itemNode.get("isConform"), firstNonNull(itemNode.get("conform"), itemNode.get("是否符合类目")))))),
- text(firstNonNull(
- firstNonNull(node.get("reason"), firstNonNull(node.get("原因"), node.get("不符合理由"))),
- firstNonNull(itemNode.get("reason"), firstNonNull(itemNode.get("原因"), itemNode.get("不符合理由"))))),
- text(firstNonNull(
- firstNonNull(node.get("category"), firstNonNull(node.get("类目"), node.get("产品类目"))),
- firstNonNull(itemNode.get("category"), firstNonNull(itemNode.get("类目"), itemNode.get("产品类目"))))),
- text(firstNonNull(node.get("appearance"),
- firstNonNull(node.get("appearance_risk"),
- firstNonNull(itemNode.get("appearance"), itemNode.get("appearance_risk"))))),
- text(firstNonNull(firstNonNull(node.get("patent"), node.get("patent ")),
- firstNonNull(node.get("patent_risk"),
- firstNonNull(firstNonNull(itemNode.get("patent"), itemNode.get("patent ")), itemNode.get("patent_risk"))))),
- text(firstNonNull(node.get("result"),
- firstNonNull(node.get("conclusion"),
- firstNonNull(itemNode.get("result"), itemNode.get("conclusion"))))),
- text(firstNonNull(
- firstNonNull(node.get("status"), firstNonNull(node.get("row_status"), node.get("rowStatus"))),
- firstNonNull(itemNode.get("status"), firstNonNull(itemNode.get("row_status"), itemNode.get("rowStatus"))))),
- text(firstNonNull(node.get("title_reason"),
- firstNonNull(node.get("titleReason"),
- firstNonNull(itemNode.get("title_reason"), itemNode.get("titleReason"))))),
- text(firstNonNull(node.get("appearance_reason"),
- firstNonNull(node.get("appearanceReason"),
- firstNonNull(itemNode.get("appearance_reason"), itemNode.get("appearanceReason"))))),
- text(firstNonNull(node.get("patent_reason"),
- firstNonNull(firstNonNull(node.get("patentReason"), node.get("patent reason")),
- firstNonNull(itemNode.get("patent_reason"),
- firstNonNull(itemNode.get("patentReason"), itemNode.get("patent reason")))))),
- text(firstNonNull(
- firstNonNull(node.get("main_url"), firstNonNull(node.get("mainUrl"), firstNonNull(node.get("main_image_url"), firstNonNull(node.get("mainImageUrl"), firstNonNull(node.get("main_img"), node.get("mainImg")))))),
- firstNonNull(itemNode.get("main_url"), firstNonNull(itemNode.get("mainUrl"), firstNonNull(itemNode.get("main_image_url"), firstNonNull(itemNode.get("mainImageUrl"), firstNonNull(itemNode.get("main_img"), itemNode.get("mainImg")))))))),
- text(firstNonNull(
- firstNonNull(node.get("puzzle_img1"), firstNonNull(node.get("puzzleImg1"), firstNonNull(node.get("puzzle_img_1"), node.get("puzzleImg_1")))),
- firstNonNull(itemNode.get("puzzle_img1"), firstNonNull(itemNode.get("puzzleImg1"), firstNonNull(itemNode.get("puzzle_img_1"), itemNode.get("puzzleImg_1")))))),
- text(firstNonNull(
- firstNonNull(node.get("puzzle_img2"), firstNonNull(node.get("puzzleImg2"), firstNonNull(node.get("puzzle_img_2"), node.get("puzzleImg_2")))),
- firstNonNull(itemNode.get("puzzle_img2"), firstNonNull(itemNode.get("puzzleImg2"), firstNonNull(itemNode.get("puzzle_img_2"), itemNode.get("puzzleImg_2"))))))
- ));
- }
- }
- return results;
- }
-
- private JsonNode resultItemNode(JsonNode node) {
- if (node == null || node.isMissingNode() || node.isNull()) {
- return objectMapper.missingNode();
- }
- JsonNode item = firstNonNull(node.get("item"), node.get("items"));
- if (item == null || item.isMissingNode() || item.isNull()) {
- return objectMapper.missingNode();
- }
- if (item.isArray()) {
- return item.isEmpty() ? objectMapper.missingNode() : item.get(0);
- }
- return item;
- }
-
- private List mergeRows(List rows, List results) {
- Map resultByRowToken = new LinkedHashMap<>();
- Map resultByCompositeKey = new LinkedHashMap<>();
- Map resultByAsinCountry = new LinkedHashMap<>();
- Map resultByRowId = new LinkedHashMap<>();
- for (CozeResult result : results) {
- String rowToken = normalize(result.rowToken());
- if (!rowToken.isBlank()) {
- resultByRowToken.putIfAbsent(rowToken, result);
- }
- String compositeKey = rowKey(result.rowId(), result.asin(), result.country());
- if (!compositeKey.isBlank()) {
- resultByCompositeKey.putIfAbsent(compositeKey, result);
- }
- String asinCountryKey = asinCountryKey(result.asin(), result.country());
- if (!asinCountryKey.isBlank()) {
- resultByAsinCountry.putIfAbsent(asinCountryKey, result);
- }
- String rowIdKey = normalize(result.rowId());
- if (!rowIdKey.isBlank()) {
- resultByRowId.putIfAbsent(rowIdKey, result);
- }
- }
-
- List merged = new ArrayList<>(rows.size());
- boolean allowIndexFallback = results.size() == rows.size() && results.stream().noneMatch(this::hasIdentity);
- for (int i = 0; i < rows.size(); i++) {
- SimilarAsinResultRowDto row = copy(rows.get(i));
- CozeResult result = resultByRowToken.get(normalize(row.getRowToken()));
- if (result == null) {
- result = resultByCompositeKey.get(rowKey(row.getId(), row.getAsin(), row.getCountry()));
- }
- if (result == null && i < results.size() && isIndexedResultForRow(results.get(i), row)) {
- result = results.get(i);
- }
- if (result == null) {
- result = resultByAsinCountry.get(asinCountryKey(row.getAsin(), row.getCountry()));
- }
- if (result == null) {
- result = resultByRowId.get(normalize(row.getId()));
- }
- if (result == null && allowIndexFallback && i < results.size()) {
- result = results.get(i);
- }
- applyResult(row, result);
- merged.add(row);
- }
- return merged;
- }
-
- private String asinCountryKey(String asin, String country) {
- String normalizedAsin = normalize(asin).toUpperCase(Locale.ROOT);
- if (normalizedAsin.isBlank()) {
- return "";
- }
- return normalizedAsin + "::" + normalize(country);
- }
-
- private boolean hasIdentity(CozeResult result) {
- if (result == null) {
- return false;
- }
- return !normalize(result.rowToken()).isBlank()
- || !normalize(result.groupKey()).isBlank()
- || !normalize(result.rowId()).isBlank()
- || !normalize(result.asin()).isBlank();
- }
-
- private boolean isIndexedResultForRow(CozeResult result, SimilarAsinResultRowDto row) {
- if (result == null || row == null) {
- return false;
- }
- if (!normalize(result.rowToken()).isBlank() || !normalize(result.rowId()).isBlank()) {
- return false;
- }
- String resultAsin = normalize(result.asin()).toUpperCase(Locale.ROOT);
- return resultAsin.isBlank() || resultAsin.equals(normalize(row.getAsin()).toUpperCase(Locale.ROOT));
- }
-
- private void applyResult(SimilarAsinResultRowDto row, CozeResult result) {
- if (row == null || result == null) {
- return;
- }
- row.setTitleRisk(result.title());
- row.setSku(nonBlank(result.sku(), row.getSku()));
- row.setPrice(nonBlank(result.price(), row.getPrice()));
- row.setIsStock(result.isStock());
- row.setSimilarity(result.similarity());
- row.setIsConform(result.isConform());
- row.setReason(result.reason());
- row.setCategory(result.category());
- row.setAppearanceRisk(result.appearance());
- row.setPatentRisk(result.patent());
- row.setConclusion(result.result());
- row.setStatus(result.status());
- row.setTitleReason(result.titleReason());
- row.setAppearanceReason(result.appearanceReason());
- row.setPatentReason(result.patentReason());
- row.setMainUrl(result.mainUrl());
- row.setPuzzleImg1(result.puzzleImg1());
- row.setPuzzleImg2(result.puzzleImg2());
- }
-
- private RestClient restClient() {
- RestClient client = sharedRestClient;
- if (client != null) {
- return client;
- }
- synchronized (this) {
- if (sharedRestClient == null) {
- RestClient.Builder builder = RestClient.builder()
- .requestFactory(HttpClientPool.requestFactory(properties.getCozeReadTimeoutMillis()));
- if (externalCallMetrics != null) {
- builder.requestInterceptor(externalCallMetrics.interceptor("coze"));
- }
- sharedRestClient = builder.build();
- }
- return sharedRestClient;
- }
- }
-
- private SimilarAsinResultRowDto copy(SimilarAsinResultRowDto source) {
- SimilarAsinResultRowDto row = new SimilarAsinResultRowDto();
- row.setSourceFileKey(source.getSourceFileKey());
- row.setSourceFilename(source.getSourceFilename());
- row.setRowToken(source.getRowToken());
- row.setGroupKey(source.getGroupKey());
- row.setId(source.getId());
- row.setAsin(source.getAsin());
- row.setCountry(source.getCountry());
- row.setSku(source.getSku());
- row.setPrice(source.getPrice());
- row.setUrls(source.getUrls());
- row.setAlibaba(source.getAlibaba());
- row.setTitle(source.getTitle());
- row.setError(source.getError());
- row.setDone(source.getDone());
- row.setStatus(source.getStatus());
- row.setIsConform(source.getIsConform());
- row.setReason(source.getReason());
- row.setCategory(source.getCategory());
- row.setTitleRisk(source.getTitleRisk());
- row.setAppearanceRisk(source.getAppearanceRisk());
- row.setPatentRisk(source.getPatentRisk());
- row.setConclusion(source.getConclusion());
- row.setIsStock(source.getIsStock());
- row.setSimilarity(source.getSimilarity());
- row.setTitleReason(source.getTitleReason());
- row.setAppearanceReason(source.getAppearanceReason());
- row.setPatentReason(source.getPatentReason());
- row.setMainUrl(source.getMainUrl());
- row.setPuzzleImg1(source.getPuzzleImg1());
- row.setPuzzleImg2(source.getPuzzleImg2());
- return row;
- }
-
- private SimilarAsinResultRowDto markFailed(SimilarAsinResultRowDto row, String failureMessage) {
- String reviewMessage = failureMessage == null || failureMessage.isBlank()
- ? "Coze 检测失败"
- : "Coze 检测失败：" + failureMessage;
- if (row.getError() == null || row.getError().isBlank()) {
- row.setError(failureMessage);
- }
- if (row.getReason() == null || row.getReason().isBlank()) {
- row.setReason(failureMessage);
- }
- if (row.getStatus() == null || row.getStatus().isBlank()) {
- row.setStatus("FAILED");
- }
- if (row.getTitleRisk() == null || row.getTitleRisk().isBlank()) {
- row.setTitleRisk(reviewMessage);
- }
- if (row.getAppearanceRisk() == null || row.getAppearanceRisk().isBlank()) {
- row.setAppearanceRisk(reviewMessage);
- }
- if (row.getPatentRisk() == null || row.getPatentRisk().isBlank()) {
- row.setPatentRisk(reviewMessage);
- }
- if (row.getConclusion() == null || row.getConclusion().isBlank()) {
- row.setConclusion(failureMessage);
- }
- return row;
- }
-
- private boolean shouldSplitBatch(List rows, Exception ex) {
- return rows != null && rows.size() > 1 && isRetryableBatchFailure(ex);
- }
-
- private boolean isRetryableBatchFailure(Exception ex) {
- if (ex instanceof PartialCozeResultException) {
- return true;
- }
- String message = ex == null ? "" : nonBlank(ex.getMessage(), "");
- return message.contains("Workflow node execution limit exceeded")
- || message.contains("Read timed out")
- || message.contains("Connection reset")
- || message.contains("I/O error on POST request")
- || message.contains("429")
- || message.toLowerCase(Locale.ROOT).contains("rate limit")
- || message.toLowerCase(Locale.ROOT).contains("retry later")
- || message.contains("限流")
- || message.contains("稍后重试")
- || message.toLowerCase(Locale.ROOT).contains("timeout");
- }
-
- private int resolvedCount(List rows) {
- int resolved = 0;
- for (SimilarAsinResultRowDto row : rows) {
- if (hasResolvedCozeFields(row)) {
- resolved++;
- }
- }
- return resolved;
- }
-
- private boolean hasResolvedCozeFields(SimilarAsinResultRowDto row) {
- if (row == null) {
- return false;
- }
- return !normalize(row.getTitleRisk()).isBlank()
- || !normalize(row.getAppearanceRisk()).isBlank()
- || !normalize(row.getPatentRisk()).isBlank()
- || !normalize(row.getConclusion()).isBlank()
- || !normalize(row.getIsStock()).isBlank()
- || !normalize(row.getSimilarity()).isBlank()
- || !normalize(row.getIsConform()).isBlank()
- || !normalize(row.getReason()).isBlank()
- || !normalize(row.getCategory()).isBlank()
- || !normalize(row.getStatus()).isBlank()
- || !normalize(row.getMainUrl()).isBlank()
- || !normalize(row.getPuzzleImg1()).isBlank()
- || !normalize(row.getPuzzleImg2()).isBlank();
- }
-
- public SimilarAsinCozeClient(SimilarAsinProperties properties,
- ObjectMapper objectMapper,
- CozeCredentialPoolService cozeCredentialPoolService,
- com.nanri.aiimage.metrics.ExternalCallMetricsRecorder externalCallMetrics) {
- this.properties = properties;
- this.objectMapper = objectMapper;
- this.cozeCredentialPoolService = cozeCredentialPoolService;
- this.externalCallMetrics = externalCallMetrics;
- }
-
- private void ensureSuccess(JsonNode root) {
- if (root.path("code").asInt(-1) != 0) {
- throw new IllegalStateException(root.path("msg").asText("Coze response code is not 0"));
- }
- }
-
- private String extractResultDataText(JsonNode root) {
- if (root == null || root.isMissingNode() || root.isNull()) {
- return "";
- }
-
- JsonNode dataNode = root.path("data");
- if (dataNode.isTextual()) {
- String value = dataNode.asText("");
- if (looksLikeResultDataPayload(value)) {
- return value;
- }
- return discoverEmbeddedData(parseJsonOrMissing(value));
- }
- if (dataNode.isObject()) {
- String nested = text(firstNonNull(dataNode.get("data"), firstNonNull(dataNode.get("output"), dataNode.get("result"))));
- if (nested != null && !nested.isBlank() && looksLikeResultDataPayload(nested)) {
- return nested;
- }
- JsonNode outputs = firstNonNull(dataNode.get("outputs"), dataNode.get("details"));
- String discovered = discoverEmbeddedData(outputs);
- if (!discovered.isBlank()) {
- return discovered;
- }
- }
-
- return discoverEmbeddedData(root);
- }
-
- private String extractWorkflowOutputText(JsonNode root) {
- JsonNode outputNode = findFirstField(root, "output");
- if (outputNode == null || outputNode.isNull() || outputNode.isMissingNode()) {
- return "";
- }
- if (!outputNode.isTextual()) {
- String discovered = discoverEmbeddedData(outputNode);
- return discovered.isBlank() && isResultDataPayload(outputNode) ? outputNode.toString() : discovered;
- }
- String output = normalize(outputNode.asText(""));
- if (output.isBlank()) {
- return "";
- }
- if (looksLikeResultDataPayload(output)) {
- return output;
- }
- JsonNode parsedOutput = parseJsonOrMissing(output);
- String nestedOutput = text(firstNonNull(parsedOutput.get("Output"), parsedOutput.get("output")));
- if (nestedOutput != null && !nestedOutput.isBlank() && looksLikeResultDataPayload(nestedOutput)) {
- return nestedOutput;
- }
- return discoverEmbeddedData(parsedOutput);
- }
-
- private String discoverEmbeddedData(JsonNode node) {
- if (node == null || node.isNull() || node.isMissingNode()) {
- return "";
- }
- if (node.isTextual()) {
- String value = node.asText("");
- if (looksLikeResultDataPayload(value)) {
- return value;
- }
- return discoverEmbeddedData(parseJsonOrMissing(value));
- }
- if (node.isArray()) {
- for (JsonNode child : node) {
- String discovered = discoverEmbeddedData(child);
- if (!discovered.isBlank()) {
- return discovered;
- }
- }
- return "";
- }
- if (node.isObject()) {
- if (isResultDataPayload(node)) {
- return node.toString();
- }
- for (java.util.Iterator> it = node.fields(); it.hasNext(); ) {
- Map.Entry entry = it.next();
- String discovered = discoverEmbeddedData(entry.getValue());
- if (!discovered.isBlank()) {
- return discovered;
- }
- }
- }
- return "";
- }
-
- private boolean looksLikeResultDataPayload(String value) {
- JsonNode parsed = parseJsonOrMissing(value);
- return isResultDataPayload(parsed);
- }
-
- private boolean isResultDataPayload(JsonNode node) {
- if (node == null || node.isMissingNode() || node.isNull()) {
- return false;
- }
- JsonNode array = node.path("data");
- if (!array.isArray()) {
- return false;
- }
- for (JsonNode item : array) {
- JsonNode itemNode = resultItemNode(item);
- if (hasResultFields(item) || hasResultFields(itemNode)) {
- return true;
- }
- }
- return false;
- }
-
- private boolean hasResultFields(JsonNode item) {
- return item != null
- && (item.has("appearance")
- || item.has("appearance_risk")
- || item.has("patent")
- || item.has("patent ")
- || item.has("patent_risk")
- || item.has("result")
- || item.has("conclusion")
- || item.has("is_stock")
- || item.has("isStock")
- || item.has("stock")
- || item.has("是否有货")
- || item.has("similarity")
- || item.has("similarity_rate")
- || item.has("相似度")
- || item.has("is_conform")
- || item.has("isConform")
- || item.has("conform")
- || item.has("是否符合类目")
- || item.has("reason")
- || item.has("原因")
- || item.has("不符合理由")
- || item.has("category")
- || item.has("类目")
- || item.has("产品类目")
- || item.has("status")
- || item.has("title_reason")
- || item.has("titleReason")
- || item.has("appearance_reason")
- || item.has("appearanceReason")
- || item.has("patent_reason")
- || item.has("patentReason")
- || item.has("patent reason")
- || item.has("main_url")
- || item.has("mainUrl")
- || item.has("main_image_url")
- || item.has("mainImageUrl")
- || item.has("main_img")
- || item.has("mainImg")
- || item.has("puzzle_img1")
- || item.has("puzzleImg1")
- || item.has("puzzle_img_1")
- || item.has("puzzleImg_1")
- || item.has("puzzle_img2")
- || item.has("puzzleImg2")
- || item.has("puzzle_img_2")
- || item.has("puzzleImg_2"));
- }
-
- private boolean isSuccessfulWorkflowStatus(String status) {
- String normalized = normalize(status).toUpperCase(Locale.ROOT);
- return normalized.equals("SUCCESS")
- || normalized.equals("SUCCEEDED")
- || normalized.equals("COMPLETED")
- || normalized.equals("COMPLETE")
- || normalized.equals("DONE");
- }
-
- private boolean isFailedWorkflowStatus(String status) {
- String normalized = normalize(status).toUpperCase(Locale.ROOT);
- return normalized.contains("FAIL")
- || normalized.contains("ERROR")
- || normalized.contains("CANCEL");
- }
-
- private JsonNode parseJsonOrMissing(String value) {
- String normalized = normalize(value);
- if (!(normalized.startsWith("{") || normalized.startsWith("["))) {
- return objectMapper.missingNode();
- }
- try {
- return objectMapper.readTree(normalized);
- } catch (Exception ignored) {
- return objectMapper.missingNode();
- }
- }
-
- private String resolveWorkflowStatus(JsonNode root) {
- JsonNode dataNode = root.path("data");
- JsonNode statusNode = firstNonNull(
- firstNonNull(dataNode.get("status"), dataNode.get("execute_status")),
- firstNonNull(root.get("status"), root.get("execute_status")));
- String status = text(statusNode);
- if (status != null && !status.isBlank()) {
- return status;
- }
- return findTextByFieldName(root, "execute_status", "status");
- }
-
- private String resolveFailureMessage(JsonNode root) {
- JsonNode dataNode = root.path("data");
- String message = firstNonBlank(
- findTextByFieldName(dataNode, "error_message", "error", "msg"),
- findTextByFieldName(root, "error_message", "error", "msg"));
- return message == null ? "" : message;
- }
-
- private String extractExecuteId(JsonNode root) {
- return findTextByFieldName(root, "execute_id", "executeId");
- }
-
- private JsonNode findFirstField(JsonNode node, String name) {
- if (node == null || node.isMissingNode() || node.isNull() || name == null || name.isBlank()) {
- return objectMapper.missingNode();
- }
- if (node.isTextual()) {
- return findFirstField(parseJsonOrMissing(node.asText("")), name);
- }
- if (node.isArray()) {
- for (JsonNode child : node) {
- JsonNode found = findFirstField(child, name);
- if (found != null && !found.isMissingNode() && !found.isNull()) {
- return found;
- }
- }
- return objectMapper.missingNode();
- }
- if (node.isObject()) {
- JsonNode direct = node.get(name);
- if (direct != null && !direct.isMissingNode() && !direct.isNull()) {
- return direct;
- }
- for (java.util.Iterator> it = node.fields(); it.hasNext(); ) {
- Map.Entry entry = it.next();
- JsonNode found = findFirstField(entry.getValue(), name);
- if (found != null && !found.isMissingNode() && !found.isNull()) {
- return found;
- }
- }
- }
- return objectMapper.missingNode();
- }
-
- private String findTextByFieldName(JsonNode node, String... names) {
- if (node == null || node.isMissingNode() || node.isNull()) {
- return "";
- }
- if (node.isTextual()) {
- return findTextByFieldName(parseJsonOrMissing(node.asText("")), names);
- }
- if (node.isArray()) {
- for (JsonNode child : node) {
- String found = findTextByFieldName(child, names);
- if (!found.isBlank()) {
- return found;
- }
- }
- return "";
- }
- if (node.isObject()) {
- for (String name : names) {
- String value = text(node.get(name));
- if (value != null && !value.isBlank()) {
- return value;
- }
- }
- JsonNode dataNode = node.get("data");
- if (dataNode != null && dataNode.isTextual()) {
- String found = findTextByFieldName(parseJsonOrMissing(dataNode.asText("")), names);
- if (!found.isBlank()) {
- return found;
- }
- }
- for (java.util.Iterator> it = node.fields(); it.hasNext(); ) {
- Map.Entry entry = it.next();
- String found = findTextByFieldName(entry.getValue(), names);
- if (!found.isBlank()) {
- return found;
- }
- }
- }
- return "";
- }
-
- private String wrapDataPayload(String dataText) {
- Map payload = new LinkedHashMap<>();
- payload.put("code", 0);
- payload.put("data", dataText);
- return writeJson(payload);
- }
-
- private String writeJson(Object value) {
- try {
- return objectMapper.writeValueAsString(value);
- } catch (Exception ex) {
- throw new IllegalStateException("Coze 请求载荷序列化失败", ex);
- }
- }
-
- private String abbreviate(String value, int maxLength) {
- String normalized = value == null ? "" : value.trim();
- if (normalized.length() <= maxLength) {
- return normalized;
- }
- return normalized.substring(0, Math.max(0, maxLength - 3)) + "...";
- }
-
- private void sleepBeforeRetry(int attemptIndex) {
- long delayMillis = Math.max(1, attemptIndex) * 1500L;
- ensureNotInterrupted();
- sleepQuietly(delayMillis);
- }
-
- private void sleepQuietly(long delayMillis) {
- try {
- Thread.sleep(delayMillis);
- } catch (InterruptedException interruptedException) {
- Thread.currentThread().interrupt();
- throw new IllegalStateException("Coze 工作流被中断", interruptedException);
- }
- }
-
- private void ensureNotInterrupted() {
- if (Thread.currentThread().isInterrupted()) {
- throw new IllegalStateException("Coze 工作流被中断");
- }
- }
-
- private RuntimeException propagate(Exception ex) {
- if (ex instanceof RuntimeException runtimeException) {
- return runtimeException;
- }
- return new IllegalStateException(nonBlank(ex.getMessage(), "Coze 调用失败"), ex);
- }
-
- private JsonNode firstNonNull(JsonNode left, JsonNode right) {
- return left == null || left.isNull() ? right : left;
- }
-
- private String text(JsonNode node) {
- return node == null || node.isNull() ? null : node.asText();
- }
-
- private String nonBlank(String value, String fallback) {
- return value == null || value.isBlank() ? fallback : value;
- }
-
- private String firstNonBlank(String preferred, String fallback) {
- return preferred == null || preferred.isBlank() ? fallback : preferred.trim();
- }
-
- private String safeText(String value) {
- return value == null ? "" : value.trim();
- }
-
- private List safeUrls(List urls) {
- if (urls == null || urls.isEmpty()) {
- return List.of();
- }
- return urls.stream()
- .map(this::safeText)
- .filter(value -> !value.isBlank())
- .toList();
- }
-
- private void putIfPresent(Map item, String key, String value) {
- String normalized = safeText(value);
- if (!normalized.isBlank()) {
- item.put(key, normalized);
- }
- }
-
- private void putIfPresent(Map item, String key, List values) {
- if (values != null && !values.isEmpty()) {
- item.put(key, values);
- }
- }
-
- private String primaryImageUrl(SimilarAsinResultRowDto row) {
- if (row == null) {
- return "";
- }
- String url = safeText(row.getUrl());
- if (!url.isBlank()) {
- return url;
- }
- List urls = safeUrls(row.getUrls());
- return urls.isEmpty() ? "" : urls.get(0);
- }
-
- private List imageUrls(SimilarAsinResultRowDto row) {
- if (row == null) {
- return List.of();
- }
- List urls = safeUrls(row.getUrls());
- if (!urls.isEmpty()) {
- return urls;
- }
- String primaryUrl = primaryImageUrl(row);
- return primaryUrl.isBlank() ? List.of() : List.of(primaryUrl);
- }
-
- private List> alibabaItems(SimilarAsinResultRowDto row) {
- if (row == null) {
- return List.of();
- }
- List explicitItems = row.getAlibaba();
- if (explicitItems != null && !explicitItems.isEmpty()) {
- List> result = new ArrayList<>(explicitItems.size());
- for (SimilarAsinResultRowDto.AlibabaItem source : explicitItems) {
- if (source == null) {
- continue;
- }
- String sourceUrl = safeText(source.getUrl());
- Object sourcePrice = cozePrice(source.getRawPrice());
- if (sourceUrl.isBlank() && isBlankPrice(sourcePrice)) {
- continue;
- }
- Map item = new LinkedHashMap<>();
- item.put("url", sourceUrl);
- item.put("price", sourcePrice);
- result.add(item);
- }
- return result;
- }
- List imageUrls = imageUrls(row);
- if (imageUrls.isEmpty()) {
- return List.of();
- }
- Object rowPrice = cozePrice(row.getPrice());
- List> result = new ArrayList<>(imageUrls.size());
- for (String imageUrl : imageUrls) {
- Map item = new LinkedHashMap<>();
- item.put("url", imageUrl);
- item.put("price", rowPrice);
- result.add(item);
- }
- return result;
- }
-
- private Object cozePrice(Object value) {
- if (value == null) {
- return BigDecimal.ZERO;
- }
- if (value instanceof BigDecimal decimal) {
- return normalizeCozeDecimal(decimal);
- }
- if (value instanceof Number number) {
- return normalizeCozeDecimal(new BigDecimal(number.toString()));
- }
- String text = safeText(String.valueOf(value));
- if (text.isBlank()) {
- return BigDecimal.ZERO;
- }
- try {
- return normalizeCozeDecimal(new BigDecimal(text));
- } catch (NumberFormatException ex) {
- return text;
- }
- }
-
- private BigDecimal normalizeCozeDecimal(BigDecimal value) {
- BigDecimal normalized = value.stripTrailingZeros();
- if (normalized.scale() < 0) {
- return normalized.setScale(0);
- }
- return normalized;
- }
-
- private boolean isBlankPrice(Object value) {
- return value == null || value instanceof String text && text.isBlank();
- }
-
- private String cozeGroupKey(SimilarAsinResultRowDto row) {
- if (row == null) {
- return "";
- }
- String groupKey = safeText(row.getGroupKey());
- return groupKey.isBlank() ? rowKey(row) : groupKey;
- }
-
- private String normalize(String value) {
- return value == null ? "" : value.replace(String.valueOf((char) 0xFEFF), "").replace((char) 0x3000, ' ').trim();
- }
-
- private String rowKey(SimilarAsinResultRowDto row) {
- if (row == null) {
- return "";
- }
- return rowKey(row.getId(), row.getAsin(), row.getCountry());
- }
-
- private String rowKey(String rowId, String asin, String country) {
- return normalize(rowId) + "::" + normalize(asin).toUpperCase(Locale.ROOT) + "::" + normalize(country);
- }
-
- private String failureMessage(Exception ex) {
- if (ex instanceof PartialCozeResultException partial) {
- return "Coze 结果不完整（" + partial.resolvedCount() + "/" + partial.expectedCount() + "）";
- }
- String message = ex == null ? null : ex.getMessage();
- if (message == null || message.isBlank()) {
- return "Coze 调用失败";
- }
- if (message.contains("Workflow node execution limit exceeded")) {
- return "Coze 工作流节点执行超限";
- }
- if (message.contains("Read timed out")) {
- return "Coze 调用超时";
- }
- return "Coze 调用失败：" + message;
- }
-
- private String stripBearer(String token) {
- String normalized = token == null ? "" : token.trim();
- return normalized.regionMatches(true, 0, "Bearer ", 0, 7) ? normalized.substring(7).trim() : normalized;
- }
-
- private String joinUrl(String baseUrl, String path) {
- String base = baseUrl == null ? "" : baseUrl.trim();
- String suffix = path == null ? "" : path.trim();
- if (base.endsWith("/") && suffix.startsWith("/")) {
- return base + suffix.substring(1);
- }
- if (!base.endsWith("/") && !suffix.startsWith("/")) {
- return base + "/" + suffix;
- }
- return base + suffix;
- }
-
- private record CozeResult(
- String groupKey,
- String rowToken,
- String rowId,
- String asin,
- String country,
- String sku,
- String price,
- String title,
- String isStock,
- String similarity,
- String isConform,
- String reason,
- String category,
- String appearance,
- String patent,
- String result,
- String status,
- String titleReason,
- String appearanceReason,
- String patentReason,
- String mainUrl,
- String puzzleImg1,
- String puzzleImg2
- ) {
- }
-
- private record InspectAttempt(
- String raw,
- List mergedRows,
- int resolvedCount,
- int rawResultCount
- ) {
- }
-
- public record CozeSubmitResponse(
- String executeId,
- String immediateData,
- String rawResponse,
- String credentialName
- ) {
- }
-
- public record CozePollResponse(
- String executeId,
- String status,
- String dataText,
- String outputText,
- String failureMessage,
- String rawResponse,
- String credentialName
- ) {
- public boolean hasPayload() {
- return dataText != null && !dataText.isBlank() || outputText != null && !outputText.isBlank();
- }
-
- public String resolvedPayloadText() {
- return dataText != null && !dataText.isBlank() ? dataText : outputText;
- }
-
- public boolean isFailed() {
- String normalized = status == null ? "" : status.trim().toUpperCase(Locale.ROOT);
- return normalized.contains("FAIL") || normalized.contains("ERROR") || normalized.contains("CANCEL");
- }
-
- public boolean isFinished() {
- String normalized = status == null ? "" : status.trim().toUpperCase(Locale.ROOT);
- return isFailed()
- || normalized.contains("SUCCESS")
- || normalized.contains("SUCCEED")
- || normalized.contains("FINISH")
- || normalized.contains("DONE")
- || normalized.contains("COMPLET");
- }
- }
-
- public record CozeCredentialRef(
- String name,
- String workflowId,
- String token,
- int maxConcurrent
- ) {
- }
-
- private static final class PartialCozeResultException extends RuntimeException {
-
- private final int resolvedCount;
- private final int expectedCount;
- private final int rawResultCount;
-
- private PartialCozeResultException(int resolvedCount, int expectedCount, int rawResultCount) {
- super("partial-result resolved=" + resolvedCount + "/" + expectedCount + " raw=" + rawResultCount);
- this.resolvedCount = resolvedCount;
- this.expectedCount = expectedCount;
- this.rawResultCount = rawResultCount;
- }
-
- private int resolvedCount() {
- return resolvedCount;
- }
-
- private int expectedCount() {
- return expectedCount;
- }
-
- @SuppressWarnings("unused")
- private int rawResultCount() {
- return rawResultCount;
- }
- }
-}
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/client/SimilarAsinLlmClient.java b/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/client/SimilarAsinLlmClient.java
index a0aad228..8fdba1c7 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/client/SimilarAsinLlmClient.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/client/SimilarAsinLlmClient.java
@@ -22,7 +22,7 @@ import java.util.Map;
/**
* 货源查询直连 LLM 客户端：调用 OpenAI 兼容 /v1/chat/completions，
- * 替代原 Coze 工作流（similarity_asin -> similarity_image -> LLM_chat）链路，
+ * 替代原工作流（similarity_asin -> similarity_image -> LLM_chat）链路，
* 减少一次外部平台中转。链路对齐点见 SimilarAsinLlmService。
*/
@Component
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/controller/SimilarAsinController.java b/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/controller/SimilarAsinController.java
index ac0cf47a..f3eedc86 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/controller/SimilarAsinController.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/controller/SimilarAsinController.java
@@ -42,7 +42,7 @@ import java.util.List;
@RequestMapping("/api/similar-asin")
@Tag(
name = "相似 ASIN 检测",
- description = "前端上传 Excel 后由 Java 解析并创建任务；Python 按分组抓取商品数据并回传；Java 再按批调用 Coze 并生成最终 xlsx。"
+ description = "前端上传 Excel 后由 Java 解析并创建任务；Python 按分组抓取商品数据并回传；Java 再按批调用 LLM 并生成最终 xlsx。"
)
public class SimilarAsinController {
@@ -134,7 +134,7 @@ public class SimilarAsinController {
@PostMapping("/tasks/{taskId}/result")
@Operation(
summary = "提交 Python 回传结果",
- description = "Python 请通过 groups[].items[] 回传分组抓取结果；Java 先原样保存回传数据，再内部攒批调用 Coze。done=true 表示 Python 已完成全部回传，Java 会强制处理剩余未满批的数据并生成最终 xlsx。"
+ description = "Python 请通过 groups[].items[] 回传分组抓取结果；Java 先原样保存回传数据，再内部攒批调用 LLM。done=true 表示 Python 已完成全部回传，Java 会强制处理剩余未满批的数据并生成最终 xlsx。"
)
public ApiResponse result(
@Parameter(description = "相似 ASIN 检测任务 ID，任务必须处于 RUNNING 状态", required = true, example = "3938")
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/model/dto/SimilarAsinParseRequest.java b/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/model/dto/SimilarAsinParseRequest.java
index e3582921..35f5fd86 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/model/dto/SimilarAsinParseRequest.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/model/dto/SimilarAsinParseRequest.java
@@ -24,22 +24,22 @@ public class SimilarAsinParseRequest {
@JsonProperty("ai_prompt")
@JsonAlias({"aiPrompt", "prompt"})
- @Schema(description = "AI 提示词。非必填；为空时前端会使用默认提示词。后端会保存该提示词，并在调用 Coze workflow 时作为 prompt 参数传入。", example = "请排查这些亚马逊商品在英国及欧洲地区是否存在知识产权侵权风险。")
+ @Schema(description = "AI 提示词。非必填；为空时前端会使用默认提示词。后端会保存该提示词，并在调用 LLM 时作为 prompt 参数传入。", example = "请排查这些亚马逊商品在英国及欧洲地区是否存在知识产权侵权风险。")
private String aiPrompt;
@JsonProperty("api_key")
@JsonAlias({"apiKey"})
- @Schema(description = "传递给 Coze workflow parameters.api_key 的任务级密钥。")
+ @Schema(description = "传递给 LLM 的任务级 api_key。")
@NotBlank(message = "密钥不能为空")
private String apiKey;
@JsonProperty("img_switch")
@JsonAlias({"imgSwitch"})
- @Schema(description = "传递给 Coze workflow parameters.img_switch 的图片检测开关，true 为开启，false 为关闭。")
+ @Schema(description = "传递给 LLM 的 img_switch 图片检测开关，true 为开启，false 为关闭。")
private Boolean imgSwitch = Boolean.FALSE;
@JsonProperty("category_switch")
@JsonAlias({"categorySwitch"})
- @Schema(description = "传递给 Coze workflow parameters.category_switch 的类目检测开关，true 为开启，false 为关闭。")
+ @Schema(description = "传递给 LLM 的 category_switch 类目检测开关，true 为开启，false 为关闭。")
private Boolean categorySwitch = Boolean.FALSE;
}
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/model/dto/SimilarAsinParsedPayloadDto.java b/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/model/dto/SimilarAsinParsedPayloadDto.java
index 34d18b9b..a45da844 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/model/dto/SimilarAsinParsedPayloadDto.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/model/dto/SimilarAsinParsedPayloadDto.java
@@ -15,13 +15,13 @@ public class SimilarAsinParsedPayloadDto {
@Schema(description = "AI 提示词")
private String aiPrompt;
- @Schema(description = "传递给 Coze workflow parameters.api_key 的任务级密钥")
+ @Schema(description = "传递给 LLM 的任务级 api_key")
private String apiKey;
- @Schema(description = "传递给 Coze workflow parameters.img_switch 的图片检测开关")
+ @Schema(description = "传递给 LLM 的 img_switch 图片检测开关")
private Boolean imgSwitch = Boolean.FALSE;
- @Schema(description = "传递给 Coze workflow parameters.category_switch 的类目检测开关")
+ @Schema(description = "传递给 LLM 的 category_switch 类目检测开关")
private Boolean categorySwitch = Boolean.FALSE;
@Schema(description = "本次解析的源文件列表")
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/model/dto/SimilarAsinResultRowDto.java b/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/model/dto/SimilarAsinResultRowDto.java
index 20ea9e8f..008d05b1 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/model/dto/SimilarAsinResultRowDto.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/model/dto/SimilarAsinResultRowDto.java
@@ -27,7 +27,7 @@ public class SimilarAsinResultRowDto {
@Schema(description = "主数据分组 key。Python 应从解析结果原样透传，用于把同组子行补回。", example = "uploads/20260426/similar_asin_17.xlsx::2@2")
private String groupKey;
- @Schema(description = "Excel 中的 id。代表行通常是整数 id 或 n_1，例如 2_1；最终生成 xlsx 时，2_2、2_3 会复用同组 2_1 的 Coze 检测结果。", example = "2_1")
+ @Schema(description = "Excel 中的 id。代表行通常是整数 id 或 n_1，例如 2_1；最终生成 xlsx 时，2_2、2_3 会复用同组 2_1 的 LLM 检测结果。", example = "2_1")
private String id;
@Schema(description = "亚马逊 ASIN。后端会统一按大写处理和匹配。", example = "B0CJ8SNXXV")
@@ -54,75 +54,75 @@ public class SimilarAsinResultRowDto {
@Schema(description = "同类商品图 URL 列表。Python 端原样回传，后端不再去重/截断/与 url 互写。", example = "[\"https://webstatic.aiproxy.vip/output/20260425/103322/demo.jpg\"]")
private List urls = new ArrayList<>();
- @Schema(description = "商品标题。Java 调用 Coze 时会放入 title_list；为空时会回退使用 ASIN。", example = "Women Floral Dress Summer Casual")
+ @Schema(description = "商品标题。Java 调用 LLM 时会放入 title_list；为空时会回退使用 ASIN。", example = "Women Floral Dress Summer Casual")
@JsonAlias({"productTitle", "product_title", "itemTitle", "item_title", "商品标题", "商品名称", "标题"})
private String title;
@JsonAlias({"is_stock", "isStock", "stock", "是否有货"})
- @Schema(description = "Coze 返回的是否有货结果。", example = "有货", accessMode = Schema.AccessMode.READ_ONLY)
+ @Schema(description = "LLM 返回的是否有货结果。", example = "有货", accessMode = Schema.AccessMode.READ_ONLY)
private String isStock;
@JsonAlias({"similarity", "similarity_rate", "similarityRate", "相似度"})
- @Schema(description = "Coze 返回的相似度结果。", example = "80%", accessMode = Schema.AccessMode.READ_ONLY)
+ @Schema(description = "LLM 返回的相似度结果。", example = "80%", accessMode = Schema.AccessMode.READ_ONLY)
private String similarity;
@JsonAlias({"is_conform", "isConform", "conform", "是否符合类目"})
- @Schema(description = "Coze 返回的是否符合类目结果。", example = "符合", accessMode = Schema.AccessMode.READ_ONLY)
+ @Schema(description = "LLM 返回的是否符合类目结果。", example = "符合", accessMode = Schema.AccessMode.READ_ONLY)
private String isConform;
@JsonAlias({"reason", "原因", "不符合理由"})
- @Schema(description = "Coze 返回的不符合理由。", example = "类目不匹配", accessMode = Schema.AccessMode.READ_ONLY)
+ @Schema(description = "LLM 返回的不符合理由。", example = "类目不匹配", accessMode = Schema.AccessMode.READ_ONLY)
private String reason;
@JsonAlias({"category", "类目", "产品类目"})
- @Schema(description = "Coze 返回的产品类目。", example = "女装", accessMode = Schema.AccessMode.READ_ONLY)
+ @Schema(description = "LLM 返回的产品类目。", example = "女装", accessMode = Schema.AccessMode.READ_ONLY)
private String category;
- @Schema(description = "单行错误信息。通常用于记录 Python 单行处理异常；Coze 失败时后端会尽量保留原始行，不强行写入风险结果。", example = "图片地址为空")
+ @Schema(description = "单行错误信息。通常用于记录 Python 单行处理异常；LLM 失败时后端会尽量保留原始行，不强行写入风险结果。", example = "图片地址为空")
private String error;
@Schema(description = "单行完成标记。当前主要使用请求体顶层 done 控制任务收尾，该字段仅作兼容。", example = "true")
private Boolean done;
@JsonAlias({"row_status", "rowStatus", "Status"})
- @Schema(description = "Coze 行处理状态", example = "success", accessMode = Schema.AccessMode.READ_ONLY)
+ @Schema(description = "LLM 行处理状态", example = "success", accessMode = Schema.AccessMode.READ_ONLY)
private String status;
- @Schema(description = "兼容旧版 Coze 返回中的标题维度结果字段；当前相似 ASIN 结果文件不再输出该列。", example = "标题未发现明显商标侵权风险。", accessMode = Schema.AccessMode.READ_ONLY)
+ @Schema(description = "兼容旧版 LLM 返回中的标题维度结果字段；当前相似 ASIN 结果文件不再输出该列。", example = "标题未发现明显商标侵权风险。", accessMode = Schema.AccessMode.READ_ONLY)
private String titleRisk;
- @Schema(description = "兼容旧版 Coze 返回中的外观维度结果字段；当前相似 ASIN 结果文件不再输出该列。", example = "未发现明显外观设计专利侵权风险。", accessMode = Schema.AccessMode.READ_ONLY)
+ @Schema(description = "兼容旧版 LLM 返回中的外观维度结果字段；当前相似 ASIN 结果文件不再输出该列。", example = "未发现明显外观设计专利侵权风险。", accessMode = Schema.AccessMode.READ_ONLY)
private String appearanceRisk;
@JsonAlias({"patent ", "patent"})
- @Schema(description = "兼容旧版 Coze 返回中的专利维度结果字段；当前相似 ASIN 结果文件不再输出该列。", example = "未发现明显发明或实用新型专利侵权风险。", accessMode = Schema.AccessMode.READ_ONLY)
+ @Schema(description = "兼容旧版 LLM 返回中的专利维度结果字段；当前相似 ASIN 结果文件不再输出该列。", example = "未发现明显发明或实用新型专利侵权风险。", accessMode = Schema.AccessMode.READ_ONLY)
private String patentRisk;
- @Schema(description = "兼容旧版 Coze 返回中的结论字段；当前相似 ASIN 结果文件不再输出该列。", example = "未发现明显侵权风险", accessMode = Schema.AccessMode.READ_ONLY)
+ @Schema(description = "兼容旧版 LLM 返回中的结论字段；当前相似 ASIN 结果文件不再输出该列。", example = "未发现明显侵权风险", accessMode = Schema.AccessMode.READ_ONLY)
private String conclusion;
@JsonAlias({"title_reason", "titleReason"})
- @Schema(description = "Coze 返回的标题维度原因", accessMode = Schema.AccessMode.READ_ONLY)
+ @Schema(description = "LLM 返回的标题维度原因", accessMode = Schema.AccessMode.READ_ONLY)
private String titleReason;
@JsonAlias({"appearance_reason", "appearanceReason"})
- @Schema(description = "Coze 返回的外观维度原因", accessMode = Schema.AccessMode.READ_ONLY)
+ @Schema(description = "LLM 返回的外观维度原因", accessMode = Schema.AccessMode.READ_ONLY)
private String appearanceReason;
@JsonAlias({"patent_reason", "patentReason", "patent reason"})
- @Schema(description = "Coze 返回的专利维度原因", accessMode = Schema.AccessMode.READ_ONLY)
+ @Schema(description = "LLM 返回的专利维度原因", accessMode = Schema.AccessMode.READ_ONLY)
private String patentReason;
@JsonAlias({"main_url", "mainUrl", "main_image_url", "mainImageUrl", "main_img", "mainImg", "主图URL", "主图链接"})
- @Schema(description = "Coze 回包中的亚马逊主图 URL，最终 xlsx 中以嵌入图片形式呈现", example = "https://m.media-amazon.com/images/I/xxx.jpg", accessMode = Schema.AccessMode.READ_ONLY)
+ @Schema(description = "LLM 回包中的亚马逊主图 URL，最终 xlsx 中以嵌入图片形式呈现", example = "https://m.media-amazon.com/images/I/xxx.jpg", accessMode = Schema.AccessMode.READ_ONLY)
private String mainUrl;
@JsonAlias({"puzzle_img1", "puzzleImg1", "puzzle_img_1", "puzzleImg_1", "拼图1"})
- @Schema(description = "Coze 回包中阿里巴巴搜图候选 1 的 URL，最终 xlsx 中以嵌入图片形式呈现", example = "https://cbu01.alicdn.com/img/ibank/xxx.jpg", accessMode = Schema.AccessMode.READ_ONLY)
+ @Schema(description = "LLM 回包中阿里巴巴搜图候选 1 的 URL，最终 xlsx 中以嵌入图片形式呈现", example = "https://cbu01.alicdn.com/img/ibank/xxx.jpg", accessMode = Schema.AccessMode.READ_ONLY)
private String puzzleImg1;
@JsonAlias({"puzzle_img2", "puzzleImg2", "puzzle_img_2", "puzzleImg_2", "拼图2"})
- @Schema(description = "Coze 回包中阿里巴巴搜图候选 2 的 URL，最终 xlsx 中以嵌入图片形式呈现", example = "https://cbu01.alicdn.com/img/ibank/yyy.jpg", accessMode = Schema.AccessMode.READ_ONLY)
+ @Schema(description = "LLM 回包中阿里巴巴搜图候选 2 的 URL，最终 xlsx 中以嵌入图片形式呈现", example = "https://cbu01.alicdn.com/img/ibank/yyy.jpg", accessMode = Schema.AccessMode.READ_ONLY)
private String puzzleImg2;
public String getUrl() {
@@ -196,7 +196,7 @@ public class SimilarAsinResultRowDto {
}
public boolean hasImageUrl() {
- // url（主图）和 urls（同类商品图）任一存在即可作为可送 Coze 的素材。
+ // url（主图）和 urls（同类商品图）任一存在即可作为可送 LLM 的素材。
if (url != null && !url.isBlank()) {
return true;
}
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/model/vo/SimilarAsinParsedRowVo.java b/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/model/vo/SimilarAsinParsedRowVo.java
index d7848eda..0eed78d2 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/model/vo/SimilarAsinParsedRowVo.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/model/vo/SimilarAsinParsedRowVo.java
@@ -42,7 +42,7 @@ public class SimilarAsinParsedRowVo {
@Schema(description = "商品 SKU。", example = "SKU-001")
private String sku;
- @Schema(description = "商品图片 URL 或商品 URL，供 Coze 检测使用。", example = "https://webstatic.aiproxy.vip/output/demo.jpg")
+ @Schema(description = "商品图片 URL 或商品 URL，供 LLM 检测使用。", example = "https://webstatic.aiproxy.vip/output/demo.jpg")
private String url;
@Schema(description = "商品标题。", example = "Women Floral Dress Summer Casual")
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/service/SimilarAsinImagePrefetchService.java b/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/service/SimilarAsinImagePrefetchService.java
index dd78ca6c..9e61d25d 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/service/SimilarAsinImagePrefetchService.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/service/SimilarAsinImagePrefetchService.java
@@ -35,12 +35,12 @@ import java.util.concurrent.atomic.AtomicInteger;
/**
* P2-11：相似ASIN 图片异步预热服务。
*
- * 背景：assemble 阶段（{@code assembleResultWorkbook}）需要把 Coze 回包中的 main_url /
+ *
背景：assemble 阶段（{@code assembleResultWorkbook}）需要把 LLM 回包中的 main_url /
* puzzle_img1 / puzzle_img2 下载并 resize 后嵌入 xlsx。当任务行数到 1000+ 时，串行 +
* 短池下载会把整个 assemble 拖到 244s / 918s。改造点：
*
*
- * - 每次 {@code mergeCozeRowsIntoChunk} 拿到新 cozeRows 时，调用 {@link #enqueue}
+ *
- 每次 {@code mergeLlmRowsIntoChunk} 拿到新 llmRows 时，调用 {@link #enqueue}
* 立即丢入预热队列；同 task 串行排队（{@link #inflight}），避免多个 batch 同时打爆图片源站；
* - 预热成功的缩略图字节落表 {@code biz_task_image_cache}（由 P2-12 提供），跨任务复用；
* - 所有路径 best-effort：预热失败、DB 写入失败都吞掉，assemble 阶段会回退到原下载链路兜底。
@@ -125,7 +125,7 @@ public class SimilarAsinImagePrefetchService {
}
/**
- * P2-11：由 {@code mergeCozeRowsIntoChunk} 调用，把 cozeRows 中的图片 url 异步丢入预热队列。
+ * P2-11：由 {@code mergeLlmRowsIntoChunk} 调用，把 llmRows 中的图片 url 异步丢入预热队列。
* 同 task 串行入队（用 inflight map 排队），避免多个 batch 同时打爆图片源站。
*/
public void enqueue(Long taskId, List urls) {
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/service/SimilarAsinLlmService.java b/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/service/SimilarAsinLlmService.java
index fe6bf2b1..80bec3e3 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/service/SimilarAsinLlmService.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/service/SimilarAsinLlmService.java
@@ -28,8 +28,8 @@ import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
/**
- * 货源查询直连 LLM 编排服务：复刻 Coze 工作流 similarity_asin
- * （含 similarity_image、LLM_chat 子工作流）的完整语义，去掉 Coze 中转。
+ * 货源查询直连 LLM 编排服务：复刻原工作流 similarity_asin
+ * （含 similarity_image、LLM_chat 子工作流）的完整语义，去掉工作流中转。
*
* 链路对齐点（按工作流节点）：
* 1. 图片准备 batch（103226，无条件执行）：alibaba 前 8 张拼图1、8~16 张拼图2
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/service/SimilarAsinTaskService.java b/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/service/SimilarAsinTaskService.java
index a2df65a2..5a50b428 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/service/SimilarAsinTaskService.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/service/SimilarAsinTaskService.java
@@ -11,14 +11,12 @@ import com.fasterxml.jackson.databind.node.ObjectNode;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.exception.TaskOwnerMismatchException;
import com.nanri.aiimage.common.service.DistributedJobLockService;
-import com.nanri.aiimage.common.util.CozeGroupResultPropagator;
+import com.nanri.aiimage.common.util.GroupResultPropagator;
import com.nanri.aiimage.common.util.FailedStatusRowFilter;
import com.nanri.aiimage.config.InstanceMetadata;
import com.nanri.aiimage.config.SimilarAsinProperties;
import com.nanri.aiimage.config.StorageProperties;
-import com.nanri.aiimage.modules.coze.service.CozeCredentialPoolService;
import com.nanri.aiimage.modules.similarasin.mapper.SimilarAsinFilterConditionMapper;
-import com.nanri.aiimage.modules.similarasin.client.SimilarAsinCozeClient;
import com.nanri.aiimage.modules.similarasin.model.dto.SimilarAsinFilterConditionAddRequest;
import com.nanri.aiimage.modules.similarasin.model.dto.SimilarAsinParseRequest;
import com.nanri.aiimage.modules.similarasin.model.dto.SimilarAsinParsedPayloadDto;
@@ -127,14 +125,14 @@ public class SimilarAsinTaskService {
private static final String STATUS_RUNNING = "RUNNING";
private static final String STATUS_SUCCESS = "SUCCESS";
private static final String STATUS_FAILED = "FAILED";
- private static final String COZE_STATUS_SUBMITTED = "SUBMITTED";
- private static final String COZE_STATUS_RUNNING = "RUNNING";
- private static final String COZE_STATUS_DONE = "DONE";
- private static final String COZE_STATUS_FAILED = "FAILED";
- /** orphan-coze-rows: 跨 chunk merge 时未匹配到任何 chunk 的回流行兜底落库前缀。 */
- private static final String ORPHAN_SCOPE_KEY_PREFIX = "orphan-coze-rows:";
+ private static final String LLM_STATUS_SUBMITTED = "SUBMITTED";
+ private static final String LLM_STATUS_RUNNING = "RUNNING";
+ private static final String LLM_STATUS_DONE = "DONE";
+ private static final String LLM_STATUS_FAILED = "FAILED";
+ /** orphan-llm-rows: 跨 chunk merge 时未匹配到任何 chunk 的回流行兜底落库前缀。 */
+ private static final String ORPHAN_SCOPE_KEY_PREFIX = "orphan-llm-rows:";
/** orphan 行兜底状态，写入时直接置为 DONE，避免被 stale-recovery 扫描到。 */
- private static final String ORPHAN_COZE_ROW_ERROR = "orphan-coze-row(no submitted chunk)";
+ private static final String ORPHAN_LLM_ROW_ERROR = "orphan-llm-row(no submitted chunk)";
private static final String CONTENT_TYPE_XLSX = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
private static final String CONTENT_TYPE_ZIP = "application/zip";
private static final int RESULT_ROWS_READ_RETRY_LIMIT = 3;
@@ -143,10 +141,6 @@ public class SimilarAsinTaskService {
private static final long RESULT_ROWS_READ_RETRY_DELAY_MS = 500L;
private static final Duration TASK_LOCK_TTL = Duration.ofMinutes(5);
private static final long TASK_LOCK_WAIT_MILLIS = 10000L;
- private static final Duration COZE_SUBMIT_LOCK_TTL = Duration.ofMinutes(2);
- // P0-4：原 COZE_SUBMIT_LOCK_WAIT_MILLIS / COZE_SUBMIT_LOCK_RETRY_DELAY_MILLIS 已下沉到
- // SimilarAsinProperties.cozeSubmitLockWaitMillis / cozeSubmitLockRetryDelayMillis，
- // 由 acquireCozeSubmitLock 在方法内读取，并支持指数退避。
private static final int PARSE_RESPONSE_PREVIEW_LIMIT = 100;
/** 预览行/预览组配置上限：超过该值 clamp，避免响应体无界增长。 */
private static final int PARSE_RESPONSE_PREVIEW_LIMIT_MAX = 1000;
@@ -244,24 +238,6 @@ public class SimilarAsinTaskService {
}
}
}
- /**
- * P0-2 最小风险变体：poll 调度阶段并发预取 Coze HTTP 结果时，
- * 控制对单个 Coze 后端的并发度。8 与 cozeTaskExecutor 的 12 并发上限对齐留 4 余量，
- * 避免一次 poll 把所有凭证打满触发 720701002 / 限流。
- */
- private static final int COZE_POLL_PREFETCH_CONCURRENCY = 8;
- /**
- * P0-2：等待单个 stateId 预取响应的最大时间。
- * Coze pollWorkflow 自带读超时，这里再加 30s 兜底，避免一个慢请求阻塞整轮 apply。
- */
- private static final long COZE_POLL_PREFETCH_WAIT_MILLIS = 30_000L;
-
- /**
- * Per-credential 最近一次 Coze 提交完成时间戳。
- * submitCozeWorkflowThrottled 在提交前计算需要 sleep 的时间，
- * sleep 在锁外执行，避免持锁等待造成的单凭证吞吐瓶颈。
- */
- private final ConcurrentHashMap lastCozeSubmitAtByCredential = new ConcurrentHashMap<>();
/**
* P1-1：per-task 最近 10 次提交结果（true=720712008 命中）。
@@ -285,18 +261,10 @@ public class SimilarAsinTaskService {
private final ConcurrentHashMap> recentPoisonByTask = new ConcurrentHashMap<>();
private final ConcurrentHashMap recentPoisonCursorByTask = new ConcurrentHashMap<>();
- /**
- * P0-4 / P2-9：poll 调度链路上的"按 task 单次复用"上下文。
- * pollPendingCozeStatesForTask 在锁内一次性加载 FileTaskEntity + allRowsByBaseId（5000 行 JSON 反序列化只发生一次），
- * 之后 pollPendingCozeStateLocked / retryFailedCozeBatchState / splitRetryFailedCozeBatchState 等链路统一通过
- * pollScopeCache.get() 复用同一份对象，避免重复 selectById 与 deserialize。
- * stateScope 退出时务必 clear，防止异步线程间内容串号。
- */
- private final ThreadLocal pollScopeCache = new ThreadLocal<>();
/**
* 仅命中确定性输入失败：
- * - "fields cannot be extracted from null values"（Coze 工作流空输入兜底）
- * - 错误码 720712000（Coze 显式输入校验失败）
+ * - "fields cannot be extracted from null values"（工作流空输入兜底）
+ * - 错误码 720712000（显式输入校验失败）
* 注意：曾经裸串匹配 "null values" 会把 "got null values during merge" 等
* 非确定性场景误判成 deterministic，导致行被直接 markFailed 而不进 retry。
*/
@@ -326,7 +294,7 @@ public class SimilarAsinTaskService {
FailedStatusRowFilter.canonicalizeHeader("is_conform"),
FailedStatusRowFilter.canonicalizeHeader("conform")
);
- private static final Set COZE_RESULT_HEADER_ALIASES = Set.of(
+ private static final Set LLM_RESULT_HEADER_ALIASES = Set.of(
FailedStatusRowFilter.canonicalizeHeader("是否有货"),
FailedStatusRowFilter.canonicalizeHeader("is_stock"),
FailedStatusRowFilter.canonicalizeHeader("相似度"),
@@ -352,7 +320,6 @@ public class SimilarAsinTaskService {
private final TaskChunkMapper taskChunkMapper;
private final SimilarAsinFilterConditionMapper filterConditionMapper;
private final ObjectMapper objectMapper;
- private final SimilarAsinCozeClient cozeClient;
private final SimilarAsinLlmService similarAsinLlmService;
private final SimilarAsinTaskCacheService taskCacheService;
private final SimilarAsinProperties properties;
@@ -363,16 +330,15 @@ public class SimilarAsinTaskService {
private final PlatformTransactionManager transactionManager;
private final DistributedJobLockService distributedJobLockService;
private final InstanceMetadata instanceMetadata;
- private final CozeCredentialPoolService cozeCredentialPoolService;
private final SimilarAsinImageEmbedder imageEmbedder;
/**
- * P2-11：图片异步预热服务。merge cozeRows 时立即丢入预热队列，assemble 阶段优先消费 DB cache。
+ * P2-11：图片异步预热服务。merge LLM 结果行时立即丢入预热队列，assemble 阶段优先消费 DB cache。
* best-effort：service 内部所有异常都已吞掉，不影响主流程。
*/
private final SimilarAsinImagePrefetchService imagePrefetchService;
@Autowired
- @Qualifier("cozeTaskExecutor")
- private TaskExecutor cozeTaskExecutor;
+ @Qualifier("taskQueueExecutor")
+ private TaskExecutor taskQueueExecutor;
/**
* P3-1：assembleResultWorkbook 多源文件并发化使用的固定线程池。
@@ -387,25 +353,9 @@ public class SimilarAsinTaskService {
*/
private final ExecutorService assembleExecutor = Executors.newFixedThreadPool(2, namedThreadFactory("similar-asin-assemble"));
- /** Reused poll workers avoid creating/destroying a new executor every 30s. */
- private final ExecutorService cozePollPrefetchExecutor = Executors.newFixedThreadPool(
- COZE_POLL_PREFETCH_CONCURRENCY, namedThreadFactory("similar-asin-coze-prefetch"));
-
- @PreDestroy
- void shutdownAssembleExecutor() {
- assembleExecutor.shutdownNow();
- cozePollPrefetchExecutor.shutdownNow();
- }
-
- /**
- * Credential names normally come from configuration, but stale/rotated
- * credentials can otherwise leave throttle entries in the process forever.
- */
- @Scheduled(fixedDelayString = "${aiimage.similar-asin.coze-submit-throttle-cleanup-delay-ms:600000}")
- void cleanupCozeThrottleState() {
- long cutoff = System.currentTimeMillis() - Duration.ofHours(1).toMillis();
- lastCozeSubmitAtByCredential.entrySet().removeIf(entry ->
- entry.getValue() == null || entry.getValue() < cutoff);
+ /** 单元测试清理入口：关闭 assemble 固定线程池，避免测试进程残留线程。 */
+ public void shutdownAssembleExecutor() {
+ assembleExecutor.shutdown();
}
private static ThreadFactory namedThreadFactory(String prefix) {
@@ -791,7 +741,7 @@ public class SimilarAsinTaskService {
} else {
applyFinalizeSideEffects(persisted.finalizeResult());
}
- scheduleCozePipelineForSubmittedChunk(context);
+ scheduleLlmPipelineForSubmittedChunk(context);
}
public void deleteTask(Long taskId, Long userId) {
@@ -1055,7 +1005,7 @@ public class SimilarAsinTaskService {
/**
* 从解析载荷统一恢复全量行：优先 items（新规范结构），其次 allItems（旧结构），
* 最后 groups 展开（最旧结构）。新旧结构均可恢复完整行集合，供 rowCount、
- * Coze 候选加载与结果文件组装复用。
+ * LLM 候选加载与结果文件组装复用。
*/
static List resolveAllRows(SimilarAsinParsedPayloadDto payload) {
if (payload == null) {
@@ -1215,7 +1165,7 @@ public class SimilarAsinTaskService {
return null;
}
- private void submitCozeForSubmittedChunk(SubmitContext context) {
+ private void submitLlmForSubmittedChunk(SubmitContext context) {
if (context == null || context.task() == null || context.task().getId() == null) {
return;
}
@@ -1255,17 +1205,17 @@ public class SimilarAsinTaskService {
return;
}
Map> allRowsByBaseId = loadAllRowsByBaseId(task);
- boolean pendingCoze = submitCozeBatches(task, result, job, chunks, allRowsByBaseId);
- if (pendingCoze) {
+ boolean pendingLlm = submitLlmBatches(task, result, job, chunks, allRowsByBaseId);
+ if (pendingLlm) {
taskFileJobService.touchRunningIfStale(job.getId(), properties.getDbJobTouchIntervalMillis());
touchJavaSideTaskActivity(task.getId());
} else if (isResultSubmissionComplete(task.getId())) {
- maybeFinalizeCozeJobLocked(task.getId(), new CozeBatchContext(
+ maybeFinalizeLlmJobLocked(task.getId(), new LlmBatchContext(
job.getId(), result.getId(), context.scopeHash(), context.chunkIndex(), 1, 1, currentInstanceId(), 0, null, null));
}
}
- private void scheduleCozePipelineForSubmittedChunk(SubmitContext context) {
+ private void scheduleLlmPipelineForSubmittedChunk(SubmitContext context) {
if (context == null || context.task() == null || context.task().getId() == null) {
return;
}
@@ -1289,7 +1239,7 @@ public class SimilarAsinTaskService {
if (job == null || "SUCCESS".equals(job.getStatus())) {
return;
}
- taskFileJobService.requeue(job.getId(), "Similar ASIN result uploaded, scheduling Coze/file assembly");
+ taskFileJobService.requeue(job.getId(), "Similar ASIN result uploaded, scheduling LLM/file assembly");
touchJavaSideTaskActivity(task.getId());
}
@@ -1314,7 +1264,7 @@ public class SimilarAsinTaskService {
}
Long taskId = task.getId();
boolean uploadComplete = isResultSubmissionComplete(taskId);
- long pendingCozeStates = countPendingCozeStates(taskId);
+ long pendingLlmStates = countPendingLlmStates(taskId);
long activeAssembleJobs = taskFileJobService.countActiveAssembleJobs(taskId, MODULE_TYPE);
if (!hasPersistedResultRows(taskId)) {
return false;
@@ -1324,13 +1274,13 @@ public class SimilarAsinTaskService {
if (forcedScopes <= 0) {
return false;
}
- log.warn("[similar-asin] Python 回传心跳超时，已封口上传并继续 Coze/文件收尾 taskId={} pendingCozeStates={} activeAssembleJobs={} forcedScopes={}",
- taskId, pendingCozeStates, activeAssembleJobs, forcedScopes);
+ log.warn("[similar-asin] Python 回传心跳超时，已封口上传并继续 LLM/文件收尾 taskId={} pendingLlmStates={} activeAssembleJobs={} forcedScopes={}",
+ taskId, pendingLlmStates, activeAssembleJobs, forcedScopes);
} else {
- log.warn("[similar-asin] Python 超时恢复继续推进 Coze/文件收尾 taskId={} pendingCozeStates={} activeAssembleJobs={}",
- taskId, pendingCozeStates, activeAssembleJobs);
+ log.warn("[similar-asin] Python 超时恢复继续推进 LLM/文件收尾 taskId={} pendingLlmStates={} activeAssembleJobs={}",
+ taskId, pendingLlmStates, activeAssembleJobs);
}
- submitCozeForSubmittedChunk(new SubmitContext(task, null, null, null, true, null, null));
+ submitLlmForSubmittedChunk(new SubmitContext(task, null, null, null, true, null, null));
touchJavaSideTaskActivity(taskId);
return true;
}
@@ -1342,7 +1292,7 @@ public class SimilarAsinTaskService {
List inputStates = taskScopeStateMapper.selectList(new LambdaQueryWrapper()
.eq(TaskScopeStateEntity::getTaskId, taskId)
.eq(TaskScopeStateEntity::getModuleType, MODULE_TYPE)
- .isNull(TaskScopeStateEntity::getCozeStatus)
+ .isNull(TaskScopeStateEntity::getLlmStatus)
.orderByDesc(TaskScopeStateEntity::getUpdatedAt));
if (inputStates == null || inputStates.isEmpty()) {
TaskChunkEntity latestChunk = taskChunkMapper.selectOne(new LambdaQueryWrapper()
@@ -1373,7 +1323,7 @@ public class SimilarAsinTaskService {
state.setLastChunkAt(now);
}
state.setUpdatedAt(now);
- state.setStateJson("{\"phase\":\"RECEIVED\",\"coze\":\"PENDING\"}");
+ state.setStateJson("{\"phase\":\"RECEIVED\",\"llm\":\"PENDING\"}");
taskScopeStateMapper.updateById(state);
updated++;
}
@@ -1386,7 +1336,7 @@ public class SimilarAsinTaskService {
Integer chunkTotal,
String error,
boolean completed,
- boolean cozeDone) {
+ boolean llmDone) {
TaskScopeStateEntity scope = taskScopeStateMapper.selectOne(new LambdaQueryWrapper()
.eq(TaskScopeStateEntity::getTaskId, taskId)
.eq(TaskScopeStateEntity::getModuleType, MODULE_TYPE)
@@ -1409,9 +1359,9 @@ public class SimilarAsinTaskService {
scope.setLastError(error);
scope.setCompleted(completed || Integer.valueOf(1).equals(scope.getCompleted()) ? 1 : 0);
scope.setUpdatedAt(now);
- scope.setStateJson(cozeDone
- ? "{\"phase\":\"RECEIVED\",\"coze\":\"DONE\"}"
- : "{\"phase\":\"RECEIVED\",\"coze\":\"PENDING\"}");
+ scope.setStateJson(llmDone
+ ? "{\"phase\":\"RECEIVED\",\"llm\":\"DONE\"}"
+ : "{\"phase\":\"RECEIVED\",\"llm\":\"PENDING\"}");
if (scope.getId() == null) {
try {
taskScopeStateMapper.insert(scope);
@@ -1436,9 +1386,9 @@ public class SimilarAsinTaskService {
scope.setLastError(error);
scope.setCompleted(completed || Integer.valueOf(1).equals(scope.getCompleted()) ? 1 : 0);
scope.setUpdatedAt(now);
- scope.setStateJson(cozeDone
- ? "{\"phase\":\"RECEIVED\",\"coze\":\"DONE\"}"
- : "{\"phase\":\"RECEIVED\",\"coze\":\"PENDING\"}");
+ scope.setStateJson(llmDone
+ ? "{\"phase\":\"RECEIVED\",\"llm\":\"DONE\"}"
+ : "{\"phase\":\"RECEIVED\",\"llm\":\"PENDING\"}");
}
}
taskScopeStateMapper.updateById(scope);
@@ -1450,11 +1400,11 @@ public class SimilarAsinTaskService {
return template.execute(status -> action.get());
}
- private List applyCozeInBatches(List items, FileTaskEntity task) {
- return applyCozeInBatches(items, task, null);
+ private List applyLlmInBatches(List items, FileTaskEntity task) {
+ return applyLlmInBatches(items, task, null);
}
- private List applyCozeInBatches(List items,
+ private List applyLlmInBatches(List items,
FileTaskEntity task,
Runnable progressHook) {
if (items == null || items.isEmpty()) {
@@ -1464,10 +1414,10 @@ public class SimilarAsinTaskService {
String apiKey = readApiKey(task);
boolean imgSwitch = readImgSwitch(task);
boolean categorySwitch = readCategorySwitch(task);
- int batchSize = resolveCozeBatchSize(imgSwitch);
+ int batchSize = resolveLlmBatchSize(imgSwitch);
List result = new ArrayList<>();
for (int i = 0; i < items.size(); i += batchSize) {
- result.addAll(cozeClient.inspect(items.subList(i, Math.min(i + batchSize, items.size())), prompt, apiKey, imgSwitch, categorySwitch));
+ result.addAll(similarAsinLlmService.inspectRows(items.subList(i, Math.min(i + batchSize, items.size())), prompt, apiKey, imgSwitch, categorySwitch));
if (progressHook != null) {
progressHook.run();
}
@@ -1517,7 +1467,7 @@ public class SimilarAsinTaskService {
/**
* Task 10：把 chunk 结果行建立成 rowKey → chunkKey 的批量索引。
- * 供 assignCozeRowsToChunks 使用，把跨 chunk 线性扫描降为 O(1) 查找。
+ * 供 assignLlmRowsToChunks 使用，把跨 chunk 线性扫描降为 O(1) 查找。
* 同一 rowKey 出现在多个 chunk 时保留第一个（putIfAbsent），行为确定。
*/
Map indexRowsByChunkKey(Map> rowsByChunk) {
@@ -1540,17 +1490,17 @@ public class SimilarAsinTaskService {
}
/**
- * Task 11：Coze 结果合并前按稳定 rowKey 一次性去重。
+ * Task 11：LLM 结果合并前按稳定 rowKey 一次性去重。
* 优先 rowToken，缺失时回退归一化的 legacy key（id::ASIN::country），
* 保留首次出现顺序。合并路径此前对每个重复行都重复 expand/分配/写回，是 O(n²) 热点。
*/
- List dedupeRowsByRowKey(List cozeRows) {
+ List dedupeRowsByRowKey(List llmRows) {
List deduped = new ArrayList<>();
- if (cozeRows == null || cozeRows.isEmpty()) {
+ if (llmRows == null || llmRows.isEmpty()) {
return deduped;
}
Set seenKeys = new java.util.HashSet<>();
- for (SimilarAsinResultRowDto row : cozeRows) {
+ for (SimilarAsinResultRowDto row : llmRows) {
if (row == null) {
continue;
}
@@ -1564,26 +1514,26 @@ public class SimilarAsinTaskService {
}
/**
- * Task 10：基于 rowKey 索引为 coze 回传行分配归属 chunk。
+ * Task 10：基于 rowKey 索引为 llm 回传行分配归属 chunk。
* 命中索引 → 归属该 chunk；未命中且有有效 fallback（chunkScopeHash + chunkIndex）
* 且 fallback chunk 存在 → 归属 fallback；否则进 orphan 列表。
* 与原实现逐 chunk 线性扫描语义完全一致，但每个行查找降为 O(1)。
*/
- Map> assignCozeRowsToChunks(
+ Map> assignLlmRowsToChunks(
Map> rowsByChunk,
- List cozeRows,
+ List llmRows,
Map rowKeyIndex,
String chunkScopeHash,
Integer chunkIndex,
List orphans) {
Map> mergeRowsByChunk = new LinkedHashMap<>();
- if (cozeRows == null || cozeRows.isEmpty() || orphans == null) {
+ if (llmRows == null || llmRows.isEmpty() || orphans == null) {
return mergeRowsByChunk;
}
String fallbackKey = chunkScopeHash != null && !chunkScopeHash.isBlank() && chunkIndex != null
? chunkStorageKey(chunkScopeHash, chunkIndex) : null;
boolean fallbackValid = fallbackKey != null && rowsByChunk != null && rowsByChunk.containsKey(fallbackKey);
- for (SimilarAsinResultRowDto expandedRow : cozeRows) {
+ for (SimilarAsinResultRowDto expandedRow : llmRows) {
if (expandedRow == null) {
continue;
}
@@ -1600,14 +1550,14 @@ public class SimilarAsinTaskService {
.put(rowKey, expandedRow);
} else {
orphans.add(expandedRow);
- log.error("[similar-asin] coze row has no submitted chunk rowKey={} asin={} country={}",
+ log.error("[similar-asin] llm row has no submitted chunk rowKey={} asin={} country={}",
rowKey, expandedRow.getAsin(), expandedRow.getCountry());
}
}
return mergeRowsByChunk;
}
- private void applyCozeToPersistedChunks(FileTaskEntity task, Runnable progressHook) {
+ private void applyLlmToPersistedChunks(FileTaskEntity task, Runnable progressHook) {
if (task == null || task.getId() == null) {
return;
}
@@ -1616,20 +1566,20 @@ public class SimilarAsinTaskService {
.eq(TaskChunkEntity::getTaskId, task.getId())
.eq(TaskChunkEntity::getModuleType, MODULE_TYPE)
.orderByAsc(TaskChunkEntity::getChunkIndex));
- log.info("[similar-asin] async coze start taskId={} chunks={}", task.getId(), chunks.size());
+ log.info("[similar-asin] async llm start taskId={} chunks={}", task.getId(), chunks.size());
for (TaskChunkEntity chunk : chunks) {
Map persistedRows = readChunkRows(chunk);
if (persistedRows.isEmpty()) {
continue;
}
- List unresolvedRows = collectPendingCozeRows(persistedRows.values());
+ List unresolvedRows = collectPendingLlmRows(persistedRows.values());
if (unresolvedRows.isEmpty()) {
continue;
}
- List cozeRows = applyCozeInBatches(unresolvedRows, task, progressHook);
- mergeChunkPayload(task.getId(), chunk.getScopeHash(), chunk.getChunkIndex(), cozeRows);
- log.info("[similar-asin] async coze chunk merged taskId={} chunk={} unresolved={} merged={}",
- task.getId(), chunk.getChunkIndex(), unresolvedRows.size(), cozeRows.size());
+ List llmRows = applyLlmInBatches(unresolvedRows, task, progressHook);
+ mergeChunkPayload(task.getId(), chunk.getScopeHash(), chunk.getChunkIndex(), llmRows);
+ log.info("[similar-asin] async llm chunk merged taskId={} chunk={} unresolved={} merged={}",
+ task.getId(), chunk.getChunkIndex(), unresolvedRows.size(), llmRows.size());
}
}
@@ -1742,7 +1692,7 @@ public class SimilarAsinTaskService {
it.remove();
}
}
- persistOrphanCozeRows(taskId, demoted);
+ persistOrphanLlmRows(taskId, demoted);
log.warn("[similar-asin] chunk merge row-limit exceeded taskId={} chunk={} mergedRows={} limit={} demoted={}",
taskId, chunk.getChunkIndex(), mergedRowCountOf(persistedRows, rows), getChunkMergeMaxRows(), demoted.size());
}
@@ -1763,7 +1713,7 @@ public class SimilarAsinTaskService {
}
}
if (!demoted.isEmpty()) {
- persistOrphanCozeRows(taskId, demoted);
+ persistOrphanLlmRows(taskId, demoted);
log.warn("[similar-asin] chunk merge byte-limit exceeded taskId={} rows={} demoted={} releasedBytes={}",
taskId, demoted.size(), demoted.size(), releasedBytes);
}
@@ -1808,34 +1758,34 @@ public class SimilarAsinTaskService {
}
}
- private List collectPendingCozeRows(java.util.Collection rows) {
+ private List collectPendingLlmRows(java.util.Collection rows) {
if (rows == null) {
return List.of();
}
List pendingRows = new ArrayList<>();
for (SimilarAsinResultRowDto row : rows) {
- if (row != null && !hasResolvedCozeFields(row) && shouldInspectRow(row)) {
+ if (row != null && !hasResolvedLlmFields(row) && shouldInspectRow(row)) {
pendingRows.add(row);
}
}
return pendingRows;
}
- private List collectPendingCozeCandidates(List chunks,
+ private List collectPendingLlmCandidates(List chunks,
Map> allRowsByBaseId) {
if (chunks == null || chunks.isEmpty()) {
return List.of();
}
- List candidates = new ArrayList<>();
+ List candidates = new ArrayList<>();
for (TaskChunkEntity chunk : chunks) {
Map persistedRows = readChunkRows(chunk);
if (persistedRows.isEmpty()) {
continue;
}
List unresolvedRows =
- enrichRowsForCoze(collectPendingCozeRows(persistedRows.values()), allRowsByBaseId);
+ enrichRowsForLlm(collectPendingLlmRows(persistedRows.values()), allRowsByBaseId);
for (SimilarAsinResultRowDto row : unresolvedRows) {
- candidates.add(new CozeCandidate(chunk.getScopeHash(), chunk.getChunkIndex(), row));
+ candidates.add(new LlmCandidate(chunk.getScopeHash(), chunk.getChunkIndex(), row));
}
}
return candidates;
@@ -1984,8 +1934,8 @@ public class SimilarAsinTaskService {
/**
* 打印 Python 端回传给 Java 的每一行 row 关键字段，确认 url（主图）/ urls（同类商品图）/ title / sku
- * 是否按预期到达。该日志与 SimilarAsinCozeClient 的 coze items diff 日志成对，
- * 便于排查"Python 回传了什么、Java 又把什么发到 Coze"。
+ * 是否按预期到达。该日志与直连 LLM 的行级结果日志成对，
+ * 便于排查"Python 回传了什么、Java 又把什么提交给 LLM"。
* Task 19：改为 DEBUG 级别并按行采样（每 20 行记一行），减少大任务日志量。
*/
private void logPythonInboundRows(List rows) {
@@ -2066,8 +2016,8 @@ public class SimilarAsinTaskService {
}
}
- private int resolveCozeBatchSize(boolean imgSwitch) {
- int configured = imgSwitch ? properties.getCozeBatchSize() : properties.getCozeTextOnlyBatchSize();
+ private int resolveLlmBatchSize(boolean imgSwitch) {
+ int configured = imgSwitch ? properties.getLlmBatchSize() : properties.getLlmTextOnlyBatchSize();
return Math.max(1, configured);
}
@@ -2158,7 +2108,7 @@ public class SimilarAsinTaskService {
if (dispatchWhenIdle
&& job != null
&& "RUNNING".equals(job.getStatus())
- && countPendingCozeStates(task.getId()) == 0) {
+ && countPendingLlmStates(task.getId()) == 0) {
taskFileJobService.requeue(job.getId(), "Python 上传完成，正在组装 xlsx");
}
return job;
@@ -2214,48 +2164,48 @@ public class SimilarAsinTaskService {
.eq(TaskChunkEntity::getModuleType, MODULE_TYPE)
.orderByAsc(TaskChunkEntity::getChunkIndex));
Map> allRowsByBaseId = loadAllRowsByBaseId(task);
- int batchSize = resolveCozeBatchSize(readImgSwitch(task));
- int cozeWorkUnits = countCozeWorkUnits(chunks, batchSize);
- int totalProgressUnits = Math.max(3, cozeWorkUnits + 3);
- if (countPendingCozeStates(task.getId()) > 0) {
- finalizeTimedOutCozeStatesForTask(task.getId());
+ int batchSize = resolveLlmBatchSize(readImgSwitch(task));
+ int llmWorkUnits = countLlmWorkUnits(chunks, batchSize);
+ int totalProgressUnits = Math.max(3, llmWorkUnits + 3);
+ if (countPendingLlmStates(task.getId()) > 0) {
+ finalizeTimedOutLlmStatesForTask(task.getId());
}
- if (countPendingCozeStates(task.getId()) > 0) {
+ if (countPendingLlmStates(task.getId()) > 0) {
taskFileJobService.touchRunningIfStale(job.getId(), properties.getDbJobTouchIntervalMillis());
touchJavaSideTaskActivity(task.getId());
- saveFileBuildProgress(task, job, totalProgressUnits, 1, "Coze 已提交，等待结果");
+ saveFileBuildProgress(task, job, totalProgressUnits, 1, "LLM 已提交，等待结果");
return false;
}
- // P0-3：stale-recovery / 异常路径兜底 —— maybeFinalizeCozeJob 可能未能成功 flush
+ // P0-3：stale-recovery / 异常路径兜底 —— maybeFinalizeLlmJob 可能未能成功 flush
// （Redis 锁竞争 / 异常退出），在 assemble 阶段读 chunk 之前再 flush 一次，幂等。
try {
- flushBufferedCozeResults(task.getId());
+ flushLlmBufferedResults(task.getId());
chunks = taskChunkMapper.selectList(new LambdaQueryWrapper()
.eq(TaskChunkEntity::getTaskId, task.getId())
.eq(TaskChunkEntity::getModuleType, MODULE_TYPE)
.orderByAsc(TaskChunkEntity::getChunkIndex));
} catch (Exception flushEx) {
- log.warn("[相似ASIN] 结果文件任务刷新缓冲区 Coze 结果失败 任务ID={} 文件任务ID={} 错误={}",
+ log.warn("[相似ASIN] 结果文件任务刷新缓冲区 LLM 结果失败 任务ID={} 文件任务ID={} 错误={}",
task.getId(), job.getId(), flushEx.getMessage(), flushEx);
- throw new BusinessException("刷新缓冲区 Coze 结果失败："
+ throw new BusinessException("刷新缓冲区 LLM 结果失败："
+ firstNonBlank(flushEx.getMessage(), "未知错误"));
}
- saveFileBuildProgress(task, job, totalProgressUnits, 0, "正在提交 Coze");
- boolean pendingCoze = submitCozeBatches(task, result, job, chunks, allRowsByBaseId);
- if (pendingCoze) {
+ saveFileBuildProgress(task, job, totalProgressUnits, 0, "正在提交 LLM");
+ boolean pendingLlm = submitLlmBatches(task, result, job, chunks, allRowsByBaseId);
+ if (pendingLlm) {
taskFileJobService.touchRunningIfStale(job.getId(), properties.getDbJobTouchIntervalMillis());
touchJavaSideTaskActivity(task.getId());
- saveFileBuildProgress(task, job, totalProgressUnits, 1, "Coze 已提交，等待结果");
+ saveFileBuildProgress(task, job, totalProgressUnits, 1, "LLM 已提交，等待结果");
return false;
}
if (STATUS_RUNNING.equals(task.getStatus()) && !isResultSubmissionComplete(task.getId())) {
taskFileJobService.touchRunningIfStale(job.getId(), properties.getDbJobTouchIntervalMillis());
touchJavaSideTaskActivity(task.getId());
- saveFileBuildProgress(task, job, totalProgressUnits, Math.max(1, cozeWorkUnits),
- "等待 Python 上传，每 " + batchSize + " 行提交一次 Coze");
+ saveFileBuildProgress(task, job, totalProgressUnits, Math.max(1, llmWorkUnits),
+ "等待 Python 上传，每 " + batchSize + " 行提交一次 LLM");
return false;
}
- completeCozeFileJob(task, result, job, totalProgressUnits, cozeWorkUnits);
+ completeLlmFileJob(task, result, job, totalProgressUnits, llmWorkUnits);
return true;
}
@@ -2326,27 +2276,25 @@ public class SimilarAsinTaskService {
taskFileJobService.markFailureFinalized(job.getId(), message);
}
- @Scheduled(fixedDelayString = "${aiimage.similar-asin.coze-poll-delay-ms:30000}")
- public void pollPendingCozeJobs() {
+ @Scheduled(fixedDelayString = "${aiimage.similar-asin.llm-poll-delay-ms:30000}")
+ public void pollPendingLlmJobs() {
DistributedJobLockService.LockHandle lockHandle =
- distributedJobLockService.tryLock("similar-asin:coze-poll", Duration.ofMinutes(1));
+ distributedJobLockService.tryLock("similar-asin:llm-poll", Duration.ofMinutes(1));
if (lockHandle == null) {
return;
}
try (lockHandle) {
- if (properties.isDirectLlmEnabled()) {
- // 直连模式：轮询器退化为"兜底调度器"，把还挂着 PENDING 的任务
- // 重新调度一次批量提交（submitLlmBatch 同步直连），新任务本就走直连。
- schedulePendingLlmBatches();
- }
- List states = listOwnedPendingCozeStates();
+ // 直连模式：轮询器退化为"兜底调度器"，把还挂着 PENDING 的任务
+ // 重新调度一次批量提交（submitLlmBatch 同步直连），新任务本就走直连。
+ schedulePendingLlmBatches();
+ List states = listOwnedPendingLlmStates();
if (states == null || states.isEmpty()) {
return;
}
- log.info("[similar-asin] coze poll picked pending states count={}", states.size());
+ log.info("[similar-asin] llm poll fallback picked pending states count={}", states.size());
Map> stateIdsByTaskId = new LinkedHashMap<>();
for (TaskScopeStateEntity state : states) {
- if (state == null || state.getId() == null || state.getTaskId() == null || !isCozeStateOwnedByCurrentInstance(state)) {
+ if (state == null || state.getId() == null || state.getTaskId() == null || !isLlmStateOwnedByCurrentInstance(state)) {
continue;
}
stateIdsByTaskId.computeIfAbsent(state.getTaskId(), key -> new ArrayList<>()).add(state.getId());
@@ -2354,7 +2302,7 @@ public class SimilarAsinTaskService {
for (Map.Entry> entry : stateIdsByTaskId.entrySet()) {
Long taskId = entry.getKey();
List stateIds = new ArrayList<>(entry.getValue());
- cozeTaskExecutor.execute(() -> pollPendingCozeStatesForTask(taskId, stateIds));
+ taskQueueExecutor.execute(() -> resubmitPendingLlmStates(taskId, stateIds));
}
}
}
@@ -2364,7 +2312,7 @@ public class SimilarAsinTaskService {
* 批量提交，新批次走 submitLlmBatch 同步直连，由提交路径落 DONE 缓冲/merge。
*/
private void schedulePendingLlmBatches() {
- List states = listOwnedPendingCozeStates();
+ List states = listOwnedPendingLlmStates();
if (states == null || states.isEmpty()) {
return;
}
@@ -2377,7 +2325,7 @@ public class SimilarAsinTaskService {
log.info("[similar-asin] direct-llm poll fallback scheduling pending tasks count={}",
taskIds.size());
for (Long taskId : taskIds) {
- cozeTaskExecutor.execute(() -> {
+ taskQueueExecutor.execute(() -> {
TaskDistributedLockService.LockHandle taskLockHandle = acquireTaskLock(taskId, 0L);
if (taskLockHandle == null) {
return;
@@ -2397,13 +2345,13 @@ public class SimilarAsinTaskService {
.eq(TaskChunkEntity::getTaskId, task.getId())
.eq(TaskChunkEntity::getModuleType, MODULE_TYPE)
.orderByAsc(TaskChunkEntity::getChunkIndex));
- submitCozeBatches(task, result, job, chunks, loadAllRowsByBaseId(task));
+ submitLlmBatches(task, result, job, chunks, loadAllRowsByBaseId(task));
}
});
}
}
- private void pollPendingCozeStatesForTask(Long taskId, List stateIds) {
+ private void resubmitPendingLlmStates(Long taskId, List stateIds) {
if (taskId == null || stateIds == null || stateIds.isEmpty()) {
return;
}
@@ -2411,161 +2359,37 @@ public class SimilarAsinTaskService {
if (taskLockHandle == null) {
return;
}
- // P0-4 / P2-9：注册 thread-local cache，下游 task / allRowsByBaseId 走 cache 单一来源。
- PollScopeCache previous = pollScopeCache.get();
- pollScopeCache.set(new PollScopeCache(taskId));
try (taskLockHandle) {
- // P0-2 最小风险变体：先并发预取所有 stateId 的 Coze HTTP 响应（受 COZE_POLL_PREFETCH_CONCURRENCY 限流），
- // 把单 state ≈1.5s 的 HTTP RTT 从 N 次串行压缩到 ≈1.5s 一轮；预取结果存入 thread-local cache，
- // 由后续 pollPendingCozeStateLocked → pollWorkflowCached 直接复用，不破坏现有 task 锁/状态机/merge 顺序语义。
- prefetchCozePollResponses(stateIds);
- try {
- for (Long stateId : stateIds) {
- if (stateId == null) {
- continue;
- }
- // The task lock is already held here. The outer wrapper
- // would perform an extra selectById for every state before
- // entering this method.
- pollPendingCozeStateLocked(stateId);
+ for (Long stateId : stateIds) {
+ if (stateId == null) {
+ continue;
+ }
+ TaskScopeStateEntity state = taskScopeStateMapper.selectById(stateId);
+ if (state == null) {
+ continue;
+ }
+ try {
+ submitLlmBatchForPendingState(state);
+ } catch (Exception ex) {
+ log.warn("[similar-asin] llm pending state resubmit failed taskId={} stateId={} err={}",
+ taskId, stateId, firstNonBlank(ex.getMessage(), ex.getClass().getSimpleName()));
}
- } finally {
- clearPollPrefetchCache();
- }
- } finally {
- if (previous == null) {
- pollScopeCache.remove();
- } else {
- pollScopeCache.set(previous);
}
}
}
-
- /**
- * P0-2 最小风险变体：在持有 task 锁、未推进状态机的前提下，先并发执行
- * cozeClient.pollWorkflow 的 HTTP 调用，把响应缓存到当前 PollScopeCache。
- *
- * 设计要点：
- * - 不在此处 claim / mark RUNNING / merge / markTerminal —— 只做"读 HTTP 响应"，所有持久化在锁内串行 apply 阶段。
- * - 任意 stateId 预取失败仅记录日志，apply 阶段会继续走原同步分支（catch 块走 updateCozeStateRunning 兜底）。
- * - 用独立 ExecutorService 而不是 cozeTaskExecutor，避免与外层 Semaphore(12) 嵌套死锁
- * （pollPendingCozeStatesForTask 自身在 cozeTaskExecutor 中执行）。
- */
- private void prefetchCozePollResponses(List stateIds) {
- if (stateIds == null || stateIds.size() <= 1) {
- return;
- }
- PollScopeCache cache = pollScopeCache.get();
- if (cache == null) {
- return;
- }
- // 先批量加载 state，避免每个预取线程各自查 DB；同时筛掉 claim 之前就不可能 poll 的状态。
- List candidates = new ArrayList<>(stateIds.size());
- List refreshedStates = taskScopeStateMapper.selectList(
- new LambdaQueryWrapper()
- .in(TaskScopeStateEntity::getId, stateIds)
- .eq(TaskScopeStateEntity::getModuleType, MODULE_TYPE)
- .in(TaskScopeStateEntity::getCozeStatus,
- List.of(COZE_STATUS_SUBMITTED, COZE_STATUS_RUNNING)));
- for (TaskScopeStateEntity state : refreshedStates == null
- ? List.of()
- : refreshedStates) {
- if (state == null
- || state.getCozeExecuteId() == null
- || state.getCozeExecuteId().isBlank()) {
- continue;
- }
- if (!(COZE_STATUS_SUBMITTED.equals(state.getCozeStatus()) || COZE_STATUS_RUNNING.equals(state.getCozeStatus()))) {
- continue;
- }
- if (!isCozeStateOwnedByCurrentInstance(state)) {
- continue;
- }
- candidates.add(state);
- }
- if (candidates.size() <= 1) {
- return;
- }
- // 复用固定大小的预取线程池，限制并发并避免每轮调度反复创建线程池。
- Map> futures = new LinkedHashMap<>();
- long prefetchStart = System.currentTimeMillis();
- for (TaskScopeStateEntity state : candidates) {
- final Long stateId = state.getId();
- final String executeId = state.getCozeExecuteId();
- final CozeBatchContext context = readCozeBatchContext(state);
- if (context == null) {
- continue;
- }
- final String credentialName = context.credentialName();
- Future future = cozePollPrefetchExecutor.submit(
- () -> cozeClient.pollWorkflow(executeId, cozeClient.credentialByName(credentialName)));
- futures.put(stateId, future);
- }
- for (Map.Entry> entry : futures.entrySet()) {
- Long stateId = entry.getKey();
- Future future = entry.getValue();
- try {
- SimilarAsinCozeClient.CozePollResponse response =
- future.get(COZE_POLL_PREFETCH_WAIT_MILLIS, java.util.concurrent.TimeUnit.MILLISECONDS);
- if (response != null) {
- cache.cozePollResponseCache.put(stateId, response);
- }
- } catch (java.util.concurrent.TimeoutException timeoutEx) {
- future.cancel(true);
- log.warn("[similar-asin] coze poll prefetch timeout stateId={} waitMs={}",
- stateId, COZE_POLL_PREFETCH_WAIT_MILLIS);
- } catch (Exception ex) {
- log.warn("[similar-asin] coze poll prefetch failed stateId={} err={}",
- stateId, firstNonBlank(ex.getMessage(), ex.getClass().getSimpleName()));
- }
- }
- log.info("[similar-asin] coze poll prefetch finished candidates={} cached={} costMs={}",
- candidates.size(), cache.cozePollResponseCache.size(),
- System.currentTimeMillis() - prefetchStart);
- }
-
- /**
- * P0-2 最小风险变体：apply 阶段调用，命中预取缓存则直接返回；未命中走原同步 HTTP（兜底）。
- */
- private SimilarAsinCozeClient.CozePollResponse pollWorkflowCached(TaskScopeStateEntity state,
- String credentialName) throws Exception {
- PollScopeCache cache = pollScopeCache.get();
- if (cache != null && state != null && state.getId() != null) {
- SimilarAsinCozeClient.CozePollResponse cached = cache.cozePollResponseCache.remove(state.getId());
- if (cached != null) {
- return cached;
- }
- }
- return cozeClient.pollWorkflow(
- state.getCozeExecuteId(),
- cozeClient.credentialByName(credentialName));
- }
-
- private void clearPollPrefetchCache() {
- PollScopeCache cache = pollScopeCache.get();
- if (cache != null) {
- cache.cozePollResponseCache.clear();
- }
- }
-
- private boolean submitCozeBatches(FileTaskEntity task,
+ private boolean submitLlmBatches(FileTaskEntity task,
FileResultEntity result,
TaskFileJobEntity job,
List chunks,
Map> allRowsByBaseId) {
if (chunks == null || chunks.isEmpty()) {
- return countPendingCozeStates(task.getId()) > 0;
- }
- if (!cozeClient.hasConfiguredCredential()) {
- log.warn("[similar-asin] coze token not configured, skip async coze taskId={} jobId={}",
- task.getId(), job.getId());
- return false;
+ return countPendingLlmStates(task.getId()) > 0;
}
String prompt = readAiPrompt(task);
String apiKey = readApiKey(task);
boolean imgSwitch = readImgSwitch(task);
boolean categorySwitch = readCategorySwitch(task);
- int batchSize = resolveCozeBatchSize(imgSwitch);
+ int batchSize = resolveLlmBatchSize(imgSwitch);
// P1-1：检测到 720712008 风暴时强制把 batch 降到 1，隔离毒行；
// 持续 5+ 次提交命中率 ≥ 40% 才会触发，正常波动不影响吞吐。
if (isPoisonStormActive(task.getId())) {
@@ -2573,45 +2397,45 @@ public class SimilarAsinTaskService {
task.getId(), batchSize);
batchSize = 1;
}
- List candidates = collectPendingCozeCandidates(chunks, allRowsByBaseId);
+ List candidates = collectPendingLlmCandidates(chunks, allRowsByBaseId);
if (candidates.isEmpty()) {
- return countPendingCozeStates(task.getId()) > 0;
+ return countPendingLlmStates(task.getId()) > 0;
}
// P1-2：把"仅过滤 hasImageUrl"扩展为必填字段集中校验。
- // 缺失 asin / title / 图片 url 任意一项即直接 markFailed，不进入 Coze 提交链路。
+ // 缺失 asin / title / 图片 url 任意一项即直接 markFailed，不进入 LLM 提交链路。
// 原因：Python 端偶发空字段会触发 720701002 "fields cannot be extracted from null values"，
- // 浪费 Coze 配额且把整 batch 拖垮；提前过滤更显式、易于排错。
- // 不打算把"必填字段集合"做成 properties——Coze 工作流签名固定，过度可配置反而把错配藏起来。
+ // 浪费 LLM 配额且把整 batch 拖垮；提前过滤更显式、易于排错。
+ // 不打算把"必填字段集合"做成 properties——LLM 工作流签名固定，过度可配置反而把错配藏起来。
java.util.function.Predicate isMissingRequired = row ->
row == null
|| !row.hasImageUrl()
|| normalize(row.getAsin()).isBlank()
|| normalize(row.getTitle()).isBlank();
- List missingFieldCandidates = candidates.stream()
+ List missingFieldCandidates = candidates.stream()
.filter(candidate -> candidate != null && isMissingRequired.test(candidate.row()))
.toList();
if (!missingFieldCandidates.isEmpty()) {
- mergeCozeRowsIntoChunk(task,
+ mergeLlmRowsIntoChunk(task,
null,
null,
- cozeClient.markRowsFailed(missingFieldCandidates.stream().map(CozeCandidate::row).toList(),
- "required field missing (asin/title/url), skip Coze"),
+ markRowsFailed(missingFieldCandidates.stream().map(LlmCandidate::row).toList(),
+ "required field missing (asin/title/url), skip LLM"),
allRowsByBaseId);
- log.warn("[similar-asin] skip coze rows missing required fields taskId={} jobId={} rows={}",
+ log.warn("[similar-asin] skip llm rows missing required fields taskId={} jobId={} rows={}",
task.getId(), job.getId(), missingFieldCandidates.size());
}
- List readyCandidates = candidates.stream()
+ List readyCandidates = candidates.stream()
.filter(candidate -> candidate != null && !isMissingRequired.test(candidate.row()))
.toList();
boolean flushRemainder = isResultSubmissionComplete(task.getId());
- // P1-6: 防止 Python 端长时间慢回传时零头永久挂着：job.updatedAt 距今 ≥ cozeFlushPendingMinutes 分钟则强制 flush。
+ // P1-6: 防止 Python 端长时间慢回传时零头永久挂着：job.updatedAt 距今 ≥ llmFlushPendingMinutes 分钟则强制 flush。
if (!flushRemainder && readyCandidates.size() > 0) {
LocalDateTime jobUpdatedAt = job.getUpdatedAt();
- long pendingFlushMillis = cozeFlushPendingMillis();
+ long pendingFlushMillis = llmFlushPendingMillis();
if (jobUpdatedAt != null
&& Duration.between(jobUpdatedAt, LocalDateTime.now()).toMillis() >= pendingFlushMillis) {
flushRemainder = true;
- log.warn("[similar-asin] coze batch flush triggered by stale timer taskId={} jobId={} pendingRows={} batchSize={} jobUpdatedAt={} flushAfterMillis={}",
+ log.warn("[similar-asin] llm batch flush triggered by stale timer taskId={} jobId={} pendingRows={} batchSize={} jobUpdatedAt={} flushAfterMillis={}",
task.getId(), job.getId(), readyCandidates.size(), batchSize, jobUpdatedAt, pendingFlushMillis);
}
}
@@ -2620,34 +2444,34 @@ public class SimilarAsinTaskService {
submitLimit = readyCandidates.size();
}
if (submitLimit <= 0) {
- log.info("[similar-asin] coze batch waiting for more rows taskId={} jobId={} pendingRows={} batchSize={} finalUpload={}",
+ log.info("[similar-asin] llm batch waiting for more rows taskId={} jobId={} pendingRows={} batchSize={} finalUpload={}",
task.getId(), job.getId(), readyCandidates.size(), batchSize, flushRemainder);
- return countPendingCozeStates(task.getId()) > 0;
+ return countPendingLlmStates(task.getId()) > 0;
}
boolean pending = false;
int batchTotal = Math.max(1, (submitLimit + batchSize - 1) / batchSize);
int batchIndex = 1;
for (int i = 0; i < submitLimit; i += batchSize) {
- List batchCandidates = readyCandidates.subList(i, Math.min(i + batchSize, submitLimit));
- pending |= submitCozeBatch(task, result, job, batchCandidates, batchIndex, batchTotal, prompt, apiKey, imgSwitch, categorySwitch, allRowsByBaseId);
+ List