704 lines
21 KiB
TypeScript
704 lines
21 KiB
TypeScript
import { NextRequest, NextResponse } from "next/server";
|
|
import { execFileSync } from "node:child_process";
|
|
import { createCipheriv, createHash } from "node:crypto";
|
|
import { z } from "zod";
|
|
import { auth } from "@/app/(auth)/auth";
|
|
import { getSystemSetting } from "@/lib/db/queries";
|
|
import {
|
|
AGENT_WORKFLOW_MATERIAL_API_CONFIG_KEY,
|
|
normalizeAgentWorkflowMaterialApiConfig,
|
|
} from "@/lib/agents/workflow-material-config";
|
|
import {
|
|
AGENT_WORKFLOW_GOODS_INFO_API_CONFIG_KEY,
|
|
normalizeAgentWorkflowGoodsInfoApiConfig,
|
|
} from "@/lib/agents/workflow-goods-info-config";
|
|
import type {
|
|
AgentDetailReplacementReferenceItem,
|
|
AgentModeReferenceCandidate,
|
|
AgentWorkflowMaterialQueryType,
|
|
} from "@/types/agent";
|
|
|
|
export const maxDuration = 180;
|
|
|
|
const querySchema = z.object({
|
|
keyword: z.string().trim().min(1).max(64),
|
|
queryType: z.enum(["sku", "spu"]).default("spu"),
|
|
target: z.enum(["main", "detail", "sku"]),
|
|
brandName: z.string().trim().max(64).optional(),
|
|
});
|
|
|
|
function jsonNoStore(
|
|
body: Parameters<typeof NextResponse.json>[0],
|
|
init?: ResponseInit
|
|
) {
|
|
return NextResponse.json(body, {
|
|
...init,
|
|
headers: {
|
|
"Cache-Control": "no-store, max-age=0",
|
|
...(init?.headers || {}),
|
|
},
|
|
});
|
|
}
|
|
|
|
type ExternalTaskDetailCandidate = {
|
|
materialId?: string;
|
|
taskNo?: string;
|
|
productModel?: string;
|
|
brandName?: string;
|
|
brand?: string;
|
|
productBrand?: string;
|
|
brand_name?: string;
|
|
brand_name_cn?: string;
|
|
brandTitle?: string;
|
|
brand_title?: string;
|
|
categoryName?: string;
|
|
shopName?: string;
|
|
sceneName?: string;
|
|
uploadedAt?: string;
|
|
isFullSet?: boolean;
|
|
downloadUrls?: {
|
|
main?: string[];
|
|
sku?: string[];
|
|
detail?: string[];
|
|
all?: string[];
|
|
};
|
|
};
|
|
|
|
type ExternalTaskDetailResponse = {
|
|
success?: boolean;
|
|
data?: {
|
|
resourceType?: string;
|
|
spu?: string | null;
|
|
sku?: string | null;
|
|
brandName?: string | null;
|
|
brand?: string | null;
|
|
productBrand?: string | null;
|
|
brand_name?: string | null;
|
|
brand_name_cn?: string | null;
|
|
brandTitle?: string | null;
|
|
brand_title?: string | null;
|
|
categoryName?: string | null;
|
|
shopName?: string | null;
|
|
candidateCount?: number;
|
|
candidates?: ExternalTaskDetailCandidate[];
|
|
};
|
|
error?: {
|
|
code?: string;
|
|
message?: string;
|
|
};
|
|
};
|
|
|
|
type ExternalGoodsInfoResponse = {
|
|
success?: boolean;
|
|
errMsg?: string | null;
|
|
data?: Record<string, unknown> | null;
|
|
};
|
|
|
|
function normalizeBaseUrl(value: string) {
|
|
return String(value || "").trim().replace(/\/+$/, "");
|
|
}
|
|
|
|
function sanitizeText(value: unknown, maxLength: number) {
|
|
return String(value || "").trim().slice(0, maxLength);
|
|
}
|
|
|
|
function normalizeComparableName(value: unknown) {
|
|
return String(value || "")
|
|
.trim()
|
|
.toLowerCase()
|
|
.replace(/\s+/g, "");
|
|
}
|
|
|
|
function normalizeUrlList(value: unknown) {
|
|
if (!Array.isArray(value)) return [] as string[];
|
|
return Array.from(
|
|
new Set(
|
|
value
|
|
.map((item) => String(item || "").trim())
|
|
.filter((item) => /^https?:\/\//i.test(item))
|
|
)
|
|
).slice(0, 64);
|
|
}
|
|
|
|
function getExternalBrandName(value: {
|
|
brandName?: string | null;
|
|
brand?: string | null;
|
|
productBrand?: string | null;
|
|
brand_name?: string | null;
|
|
brand_name_cn?: string | null;
|
|
brandTitle?: string | null;
|
|
brand_title?: string | null;
|
|
}) {
|
|
return (
|
|
String(
|
|
value.brandName ||
|
|
value.brand ||
|
|
value.productBrand ||
|
|
value.brand_name ||
|
|
value.brand_name_cn ||
|
|
value.brandTitle ||
|
|
value.brand_title ||
|
|
""
|
|
).trim() || null
|
|
);
|
|
}
|
|
|
|
function createGoodsInfoSignature(timespan: string, secret: string) {
|
|
const secretBuffer = Buffer.from(String(secret || "").trim(), "utf8");
|
|
if (secretBuffer.length !== 8) {
|
|
throw new Error("商品信息接口 Secret 长度必须为 8 位");
|
|
}
|
|
|
|
const plaintext = String(timespan || "").trim();
|
|
let encryptedHex = "";
|
|
|
|
try {
|
|
const cipher = createCipheriv("des-cbc", secretBuffer, secretBuffer);
|
|
cipher.setAutoPadding(true);
|
|
const encrypted = Buffer.concat([
|
|
cipher.update(plaintext, "utf8"),
|
|
cipher.final(),
|
|
]);
|
|
encryptedHex = encrypted.toString("hex").toUpperCase();
|
|
} catch (error) {
|
|
const opensslOutput = execFileSync(
|
|
"openssl",
|
|
[
|
|
"enc",
|
|
"-des-cbc",
|
|
"-provider",
|
|
"legacy",
|
|
"-K",
|
|
secretBuffer.toString("hex"),
|
|
"-iv",
|
|
secretBuffer.toString("hex"),
|
|
"-nosalt",
|
|
],
|
|
{
|
|
input: Buffer.from(plaintext, "utf8"),
|
|
}
|
|
);
|
|
encryptedHex = Buffer.from(opensslOutput).toString("hex").toUpperCase();
|
|
console.warn(
|
|
"[Agent Workflow Reference Search] Fallback to openssl legacy DES for goods info signature:",
|
|
error instanceof Error ? error.message : error
|
|
);
|
|
}
|
|
|
|
return createHash("md5").update(encryptedHex, "utf8").digest("hex").toUpperCase();
|
|
}
|
|
|
|
function getGoodsInfoBrandName(data: Record<string, unknown>) {
|
|
return (
|
|
sanitizeText(data["品牌"], 64) ||
|
|
sanitizeText(data["品牌名称"], 64) ||
|
|
sanitizeText(data["商品品牌"], 64) ||
|
|
sanitizeText(data["品牌名"], 64) ||
|
|
sanitizeText(data["所属品牌"], 64) ||
|
|
sanitizeText(data["brandName"], 64) ||
|
|
sanitizeText(data["brand"], 64) ||
|
|
sanitizeText(data["productBrand"], 64) ||
|
|
null
|
|
);
|
|
}
|
|
|
|
async function fetchGoodsBrandByKeyword(params: {
|
|
keyword: string;
|
|
config: ReturnType<typeof normalizeAgentWorkflowGoodsInfoApiConfig>;
|
|
}) {
|
|
const baseUrl = normalizeBaseUrl(params.config.baseUrl);
|
|
const clientKey = String(params.config.clientKey || "").trim();
|
|
const secret = String(params.config.secret || "").trim();
|
|
|
|
if (!params.config.enabled || !baseUrl || !clientKey || !secret) {
|
|
return null;
|
|
}
|
|
|
|
const timespan = String(Math.floor(Date.now() / 1000));
|
|
const sign = createGoodsInfoSignature(timespan, secret);
|
|
const commonHeaders = {
|
|
Key: clientKey,
|
|
Timespan: timespan,
|
|
Sign: sign,
|
|
Accept: "application/json",
|
|
};
|
|
const requestPaths = [
|
|
`/api/GoodsInfo/SearchByProcode?procode=${encodeURIComponent(params.keyword)}`,
|
|
`/api/GoodsInfo/SearchBySkuoid?skuoid=${encodeURIComponent(params.keyword)}`,
|
|
];
|
|
|
|
for (const requestPath of requestPaths) {
|
|
try {
|
|
const response = await fetch(`${baseUrl}${requestPath}`, {
|
|
method: "GET",
|
|
headers: commonHeaders,
|
|
cache: "no-store",
|
|
});
|
|
const result = (await response.json().catch(() => ({}))) as ExternalGoodsInfoResponse;
|
|
if (response.ok && result.success === true && result.data) {
|
|
const brandName = getGoodsInfoBrandName(result.data);
|
|
if (brandName) {
|
|
return brandName;
|
|
}
|
|
}
|
|
} catch (error) {
|
|
console.warn("[Agent Workflow Reference Search] Goods brand query failed:", {
|
|
requestPath,
|
|
error,
|
|
});
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
function mapUpstreamErrorStatus(code: string) {
|
|
if (
|
|
code === "SKU_NOT_FOUND" ||
|
|
code === "SPU_NOT_FOUND" ||
|
|
code === "TASK_DETAIL_NOT_FOUND" ||
|
|
code === "FULL_SET_NOT_FOUND"
|
|
) {
|
|
return 404;
|
|
}
|
|
if (code === "INVALID_API_KEY") {
|
|
return 500;
|
|
}
|
|
if (code === "SKU_NOT_UNIQUE") {
|
|
return 409;
|
|
}
|
|
return 502;
|
|
}
|
|
|
|
function normalizeCandidate(
|
|
value: ExternalTaskDetailCandidate,
|
|
index: number,
|
|
fallbackBrandName?: string | null
|
|
): AgentModeReferenceCandidate {
|
|
const uploadedAt = String(value.uploadedAt || "").trim() || null;
|
|
const taskNo = String(value.taskNo || "").trim() || null;
|
|
const materialId = String(value.materialId || "").trim() || null;
|
|
const sceneName = String(value.sceneName || "").trim() || null;
|
|
const id = taskNo || materialId || `candidate-${index + 1}`;
|
|
const brandName = getExternalBrandName(value) || fallbackBrandName || null;
|
|
|
|
return {
|
|
id,
|
|
materialId,
|
|
taskNo,
|
|
productModel: String(value.productModel || "").trim() || null,
|
|
brandName,
|
|
categoryName: String(value.categoryName || "").trim() || null,
|
|
shopName: String(value.shopName || "").trim() || null,
|
|
sceneName,
|
|
uploadedAt,
|
|
isFullSet: value.isFullSet !== false,
|
|
mainImageUrls: normalizeUrlList(value.downloadUrls?.main),
|
|
skuImageUrls: normalizeUrlList(value.downloadUrls?.sku),
|
|
detailImageUrls: normalizeUrlList(value.downloadUrls?.detail),
|
|
allImageUrls: normalizeUrlList(value.downloadUrls?.all),
|
|
};
|
|
}
|
|
|
|
function getCandidateTargetUrls(
|
|
candidate: AgentModeReferenceCandidate,
|
|
target: "main" | "detail" | "sku"
|
|
) {
|
|
if (target === "main") return candidate.mainImageUrls;
|
|
return target === "detail" ? candidate.detailImageUrls : candidate.skuImageUrls;
|
|
}
|
|
|
|
function getRenderableCandidateTargetUrls(
|
|
candidate: AgentModeReferenceCandidate,
|
|
target: "main" | "detail" | "sku"
|
|
) {
|
|
return getCandidateTargetUrls(candidate, target);
|
|
}
|
|
|
|
function buildReferenceItems(params: {
|
|
candidate: AgentModeReferenceCandidate;
|
|
target: "main" | "detail" | "sku";
|
|
}): AgentDetailReplacementReferenceItem[] {
|
|
const urls = getRenderableCandidateTargetUrls(params.candidate, params.target);
|
|
const targetLabel =
|
|
params.target === "main"
|
|
? "主图参考图"
|
|
: params.target === "detail"
|
|
? "详情参考图"
|
|
: "SKU参考图";
|
|
const prefix =
|
|
params.candidate.sceneName ||
|
|
params.candidate.taskNo ||
|
|
params.candidate.productModel ||
|
|
"候选整套";
|
|
|
|
return urls.map((url, index) => ({
|
|
id: `${params.candidate.id}-${params.target}-${index + 1}`,
|
|
label: `${prefix} ${targetLabel} ${String(index + 1).padStart(2, "0")}`,
|
|
imageUrl: url,
|
|
candidateId: params.candidate.id,
|
|
sortOrder: index,
|
|
passthrough: false,
|
|
}));
|
|
}
|
|
|
|
function sortCandidatesByUploadedAtDesc(candidates: AgentModeReferenceCandidate[]) {
|
|
return candidates.slice().sort((left, right) => {
|
|
const leftTime = left.uploadedAt ? new Date(left.uploadedAt).getTime() : 0;
|
|
const rightTime = right.uploadedAt ? new Date(right.uploadedAt).getTime() : 0;
|
|
return rightTime - leftTime;
|
|
});
|
|
}
|
|
|
|
function isCandidateMatchedBrand(
|
|
candidate: AgentModeReferenceCandidate,
|
|
brandName?: string
|
|
) {
|
|
return (
|
|
isBrandNameMatched(candidate.brandName, brandName) ||
|
|
isBrandNameMatched(candidate.shopName, brandName)
|
|
);
|
|
}
|
|
|
|
function isBrandNameMatched(
|
|
candidateBrandName?: string | null,
|
|
brandName?: string
|
|
) {
|
|
const normalizedRequestedBrand = normalizeComparableName(brandName);
|
|
if (!normalizedRequestedBrand) return true;
|
|
|
|
const normalizedBrandName = normalizeComparableName(candidateBrandName);
|
|
if (!normalizedBrandName) return false;
|
|
|
|
if (normalizedBrandName === normalizedRequestedBrand) return true;
|
|
|
|
// 只允许“候选品牌包含当前品牌”的弱匹配，避免短品牌名反向包含导致串品牌。
|
|
return (
|
|
normalizedRequestedBrand.length >= 2 &&
|
|
normalizedBrandName.includes(normalizedRequestedBrand)
|
|
);
|
|
}
|
|
|
|
function filterCandidatesByBrand(
|
|
candidates: AgentModeReferenceCandidate[],
|
|
brandName?: string
|
|
) {
|
|
const normalizedRequestedBrand = normalizeComparableName(brandName);
|
|
if (!normalizedRequestedBrand) return candidates;
|
|
|
|
return candidates.filter((candidate) =>
|
|
isCandidateMatchedBrand(candidate, normalizedRequestedBrand)
|
|
);
|
|
}
|
|
|
|
async function requestTaskDetailAttempt(params: {
|
|
keyword: string;
|
|
queryType: AgentWorkflowMaterialQueryType;
|
|
target: "main" | "detail" | "sku";
|
|
requestedBrandName: string;
|
|
verifiedGoodsBrandName?: string | null;
|
|
config: ReturnType<typeof normalizeAgentWorkflowMaterialApiConfig>;
|
|
}) {
|
|
const upstreamParams = new URLSearchParams({
|
|
resourceType: "task-detail",
|
|
[params.queryType]: params.keyword,
|
|
});
|
|
const upstreamUrl = `${normalizeBaseUrl(
|
|
params.config.baseUrl
|
|
)}/standard-model-white-background?${upstreamParams.toString()}`;
|
|
|
|
const upstreamResponse = await fetch(upstreamUrl, {
|
|
method: "GET",
|
|
headers: {
|
|
"X-API-Key": params.config.apiKey,
|
|
},
|
|
cache: "no-store",
|
|
});
|
|
const upstreamResult = (await upstreamResponse.json().catch(() => ({}))) as ExternalTaskDetailResponse;
|
|
const upstreamBrandName = getExternalBrandName(upstreamResult.data || {});
|
|
const rawCandidates = upstreamResult.data?.candidates || [];
|
|
const candidateBrandSamples = Array.from(
|
|
new Set(
|
|
rawCandidates
|
|
.flatMap((candidate) => [
|
|
getExternalBrandName(candidate),
|
|
String(candidate.shopName || "").trim() || null,
|
|
])
|
|
.filter((brandName): brandName is string => Boolean(brandName))
|
|
)
|
|
).slice(0, 8);
|
|
|
|
const hasVerifiedRequestedBrand =
|
|
Boolean(params.verifiedGoodsBrandName) &&
|
|
isBrandNameMatched(params.verifiedGoodsBrandName, params.requestedBrandName);
|
|
const hasUpstreamRequestedBrand =
|
|
Boolean(upstreamBrandName) &&
|
|
isBrandNameMatched(upstreamBrandName, params.requestedBrandName);
|
|
|
|
let fallbackBrandName: string | null = null;
|
|
if (params.requestedBrandName) {
|
|
if (hasVerifiedRequestedBrand) {
|
|
fallbackBrandName = params.verifiedGoodsBrandName || null;
|
|
} else if (hasUpstreamRequestedBrand) {
|
|
fallbackBrandName = upstreamBrandName || null;
|
|
}
|
|
} else {
|
|
fallbackBrandName = upstreamBrandName;
|
|
}
|
|
|
|
const normalizedCandidates =
|
|
upstreamResponse.ok && upstreamResult.success === true && upstreamResult.data
|
|
? filterCandidatesByBrand(
|
|
sortCandidatesByUploadedAtDesc(
|
|
rawCandidates.map((item, index) =>
|
|
normalizeCandidate(item, index, fallbackBrandName)
|
|
)
|
|
),
|
|
params.requestedBrandName,
|
|
).filter(
|
|
(candidate) => getRenderableCandidateTargetUrls(candidate, params.target).length > 0
|
|
)
|
|
: [];
|
|
|
|
return {
|
|
queryType: params.queryType,
|
|
upstreamResponse,
|
|
upstreamResult,
|
|
upstreamBrandName,
|
|
rawCandidates,
|
|
candidateBrandSamples,
|
|
fallbackBrandName,
|
|
normalizedCandidates,
|
|
};
|
|
}
|
|
|
|
export async function GET(request: NextRequest) {
|
|
try {
|
|
const session = await auth();
|
|
if (!session?.user?.id) {
|
|
return jsonNoStore({ error: "未登录" }, { status: 401 });
|
|
}
|
|
|
|
const parsed = querySchema.parse({
|
|
keyword: request.nextUrl.searchParams.get("keyword"),
|
|
queryType: request.nextUrl.searchParams.get("queryType") || "spu",
|
|
target: request.nextUrl.searchParams.get("target"),
|
|
brandName: request.nextUrl.searchParams.get("brandName") || undefined,
|
|
});
|
|
|
|
const setting = await getSystemSetting({ key: AGENT_WORKFLOW_MATERIAL_API_CONFIG_KEY });
|
|
const config = normalizeAgentWorkflowMaterialApiConfig(setting?.value);
|
|
const goodsInfoSetting = await getSystemSetting({
|
|
key: AGENT_WORKFLOW_GOODS_INFO_API_CONFIG_KEY,
|
|
});
|
|
const goodsInfoConfig = normalizeAgentWorkflowGoodsInfoApiConfig(
|
|
goodsInfoSetting?.value
|
|
);
|
|
if (!config.enabled) {
|
|
return jsonNoStore(
|
|
{ error: "素材搜索功能未开启，请先在系统设置中启用" },
|
|
{ status: 400 }
|
|
);
|
|
}
|
|
if (!config.apiKey) {
|
|
return jsonNoStore(
|
|
{ error: "素材搜索 API Key 未配置，请先在系统设置中保存" },
|
|
{ status: 500 }
|
|
);
|
|
}
|
|
|
|
const normalizedKeyword = parsed.keyword.trim().toUpperCase();
|
|
const queryType = parsed.queryType as AgentWorkflowMaterialQueryType;
|
|
const requestedBrandName = String(parsed.brandName || "").trim();
|
|
const verifiedGoodsBrandName = requestedBrandName
|
|
? await fetchGoodsBrandByKeyword({
|
|
keyword: normalizedKeyword,
|
|
config: goodsInfoConfig,
|
|
}).catch((error) => {
|
|
console.warn("[Agent Workflow Reference Search] Goods brand lookup failed:", error);
|
|
return null;
|
|
})
|
|
: null;
|
|
if (
|
|
requestedBrandName &&
|
|
verifiedGoodsBrandName &&
|
|
!isBrandNameMatched(verifiedGoodsBrandName, requestedBrandName)
|
|
) {
|
|
console.warn("[Agent Workflow Reference Search] Goods brand hint mismatched selected brand, keep searching with upstream data:", {
|
|
keyword: normalizedKeyword,
|
|
requestedBrandName,
|
|
verifiedGoodsBrandName,
|
|
});
|
|
}
|
|
|
|
const queryTypesToTry = Array.from(
|
|
new Set<AgentWorkflowMaterialQueryType>([
|
|
queryType,
|
|
queryType === "spu" ? "sku" : "spu",
|
|
])
|
|
);
|
|
|
|
let selectedAttempt:
|
|
| Awaited<ReturnType<typeof requestTaskDetailAttempt>>
|
|
| null = null;
|
|
let firstUpstreamFailure:
|
|
| Awaited<ReturnType<typeof requestTaskDetailAttempt>>
|
|
| null = null;
|
|
let firstEmptyAttempt:
|
|
| Awaited<ReturnType<typeof requestTaskDetailAttempt>>
|
|
| null = null;
|
|
|
|
for (const currentQueryType of queryTypesToTry) {
|
|
const attempt = await requestTaskDetailAttempt({
|
|
keyword: normalizedKeyword,
|
|
queryType: currentQueryType,
|
|
target: parsed.target,
|
|
requestedBrandName,
|
|
verifiedGoodsBrandName,
|
|
config,
|
|
});
|
|
|
|
if (requestedBrandName) {
|
|
console.info("[Agent Workflow Reference Search] Brand gate:", {
|
|
keyword: normalizedKeyword,
|
|
queryType: currentQueryType,
|
|
target: parsed.target,
|
|
requestedBrandName,
|
|
verifiedGoodsBrandName,
|
|
upstreamBrandName: attempt.upstreamBrandName,
|
|
candidateCount: attempt.rawCandidates.length,
|
|
candidateBrandSamples: attempt.candidateBrandSamples,
|
|
});
|
|
}
|
|
|
|
if (
|
|
attempt.upstreamResponse.ok &&
|
|
attempt.upstreamResult.success === true &&
|
|
attempt.upstreamResult.data
|
|
) {
|
|
if (!firstEmptyAttempt) {
|
|
firstEmptyAttempt = attempt;
|
|
}
|
|
if (attempt.normalizedCandidates.length > 0) {
|
|
selectedAttempt = attempt;
|
|
break;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (!firstUpstreamFailure) {
|
|
firstUpstreamFailure = attempt;
|
|
}
|
|
}
|
|
|
|
if (!selectedAttempt) {
|
|
if (firstEmptyAttempt) {
|
|
return jsonNoStore(
|
|
{
|
|
success: false,
|
|
error: {
|
|
code: requestedBrandName
|
|
? "BRAND_REFERENCE_NOT_FOUND"
|
|
: parsed.target === "main"
|
|
? "MAIN_REFERENCE_NOT_FOUND"
|
|
: parsed.target === "detail"
|
|
? "DETAIL_REFERENCE_NOT_FOUND"
|
|
: "SKU_REFERENCE_NOT_FOUND",
|
|
message: requestedBrandName
|
|
? `当前品牌「${requestedBrandName}」下没有可用的${
|
|
parsed.target === "main"
|
|
? "主图参考图"
|
|
: parsed.target === "detail"
|
|
? "详情参考图"
|
|
: "SKU参考图"
|
|
}`
|
|
: parsed.target === "main"
|
|
? "当前整套素材中没有可用的主图参考图"
|
|
: parsed.target === "detail"
|
|
? "当前整套素材中没有可用的详情参考图"
|
|
: "当前整套素材中没有可用的 SKU 参考图",
|
|
},
|
|
},
|
|
{ status: 404 }
|
|
);
|
|
}
|
|
|
|
const errorCode = String(
|
|
firstUpstreamFailure?.upstreamResult.error?.code || "UPSTREAM_ERROR"
|
|
).trim();
|
|
const errorMessage =
|
|
String(firstUpstreamFailure?.upstreamResult.error?.message || "").trim() ||
|
|
`参考图搜索失败(${firstUpstreamFailure?.upstreamResponse.status || 500})`;
|
|
|
|
return jsonNoStore(
|
|
{
|
|
success: false,
|
|
error: {
|
|
code: errorCode,
|
|
message: errorMessage,
|
|
},
|
|
},
|
|
{ status: mapUpstreamErrorStatus(errorCode) }
|
|
);
|
|
}
|
|
|
|
if (selectedAttempt.queryType !== queryType) {
|
|
console.info("[Agent Workflow Reference Search] Query type fallback succeeded:", {
|
|
keyword: normalizedKeyword,
|
|
requestedQueryType: queryType,
|
|
resolvedQueryType: selectedAttempt.queryType,
|
|
target: parsed.target,
|
|
});
|
|
}
|
|
|
|
const normalizedCandidates = selectedAttempt.normalizedCandidates;
|
|
const selectedCandidate = normalizedCandidates[0];
|
|
const references = buildReferenceItems({
|
|
candidate: selectedCandidate,
|
|
target: parsed.target,
|
|
});
|
|
|
|
return jsonNoStore({
|
|
success: true,
|
|
data: {
|
|
query: normalizedKeyword,
|
|
queryType: selectedAttempt.queryType,
|
|
target: parsed.target,
|
|
matchedSpu: String(selectedAttempt.upstreamResult.data?.spu || "").trim() || null,
|
|
matchedSku: String(selectedAttempt.upstreamResult.data?.sku || "").trim() || null,
|
|
brandName:
|
|
selectedCandidate.brandName ||
|
|
selectedAttempt.fallbackBrandName ||
|
|
selectedCandidate.shopName ||
|
|
null,
|
|
categoryName:
|
|
selectedCandidate.categoryName ||
|
|
String(selectedAttempt.upstreamResult.data?.categoryName || "").trim() ||
|
|
null,
|
|
shopName:
|
|
selectedCandidate.shopName ||
|
|
String(selectedAttempt.upstreamResult.data?.shopName || "").trim() ||
|
|
null,
|
|
candidateCount: normalizedCandidates.length,
|
|
candidates: normalizedCandidates,
|
|
selectedCandidateId: selectedCandidate.id,
|
|
references,
|
|
},
|
|
});
|
|
} catch (error) {
|
|
console.error("[Agent Workflow Reference Search] Error:", error);
|
|
|
|
if (error instanceof z.ZodError) {
|
|
return jsonNoStore(
|
|
{ error: "搜索参数无效", details: error.errors },
|
|
{ status: 400 }
|
|
);
|
|
}
|
|
|
|
return jsonNoStore(
|
|
{ error: "参考图搜索失败，请稍后重试" },
|
|
{ status: 500 }
|
|
);
|
|
}
|
|
}
|