forked from lunanting/cangku
956 lines
45 KiB
JavaScript
956 lines
45 KiB
JavaScript
'use strict';
|
||
|
||
const axios = require('axios');
|
||
const database = require('../config/database');
|
||
|
||
const CONFIG_KEY = 'selection_fission_ai_analysis_config';
|
||
const DEFAULT_BASE_URL = 'https://dashscope.aliyuncs.com/compatible-mode/v1';
|
||
const DEFAULT_MODEL = 'qwen3.7-max-2026-06-08';
|
||
const DEFAULT_PDD_PROPERTY_MODEL = 'qwen3.8-max';
|
||
const DEFAULT_TIMEOUT_MS = 120000;
|
||
const DEFAULT_IMAGE_GENERATION_TIMEOUT_MS = 15 * 60 * 1000;
|
||
const DEFAULT_EXTERNAL_IMAGE_BASE_URL = 'https://ai.yydd.ai';
|
||
const DEFAULT_EXTERNAL_IMAGE_MODEL = 'provider-default';
|
||
const DEFAULT_QWEN_IMAGE_BASE_URL = 'https://dashscope.aliyuncs.com';
|
||
const DEFAULT_QWEN_IMAGE_MODEL = 'qwen-image-3.0-pro';
|
||
const MAX_SKUS_PER_REQUEST = 8;
|
||
const REQUIRED_NAME_COUNT = 5;
|
||
const MAX_SKU_NAME_ATTEMPTS = 3;
|
||
const MIN_PRODUCT_TITLE_LENGTH = 28;
|
||
const MAX_PRODUCT_TITLE_LENGTH = 30;
|
||
|
||
const DEFAULT_SKU_NAME_PROMPT = [
|
||
'你是中国电商平台的SKU命名专家。请基于公司原始SKU名称、规格、颜色、SPU和市场商品信息，为每个SKU生成5个新的中文SKU名称。',
|
||
'名称需要准确区分规格和颜色，保留影响用户选择的核心属性，表达自然简洁，不得虚构材质、功能、品牌、尺寸或赠品。',
|
||
'尺寸和规格以公司原始SKU名称为最高优先级；接口中的独立size字段可能是物流包装尺寸，与原始名称冲突时必须忽略。',
|
||
'每个名称不超过60个汉字，不要带序号，5个名称互不重复，也不得与原始SKU名称完全相同。',
|
||
'只输出JSON对象，格式为：{"items":[{"skuCode":"SKU编码","names":["名称1","名称2","名称3","名称4","名称5"]}]}。',
|
||
].join('\n');
|
||
|
||
const DEFAULT_PRODUCT_TITLE_PROMPT = [
|
||
'你是中国电商平台的商品标题策略专家。请根据平台标题规则、结构化关键词、竞品标题和公司商品真实信息，先推荐分类关键词，再生成5个中文商品标题。',
|
||
'关键词结构为：品牌（可选）、品类（必填）、材质（可选）、功能卖点（必填）、场景（必填）、热搜词（必填）、飙升词（必填）、修饰词（可选）。',
|
||
'竞品关键词优先从选中的榜单Top20商品标题拆分；品类关键词从系统提供的10个品类词中选择。合并后按出现频次和搜索意图确定优先级。',
|
||
'组题时删除与前置品牌、品类、材质、功能词语义重复的词；所有飙升词必须出现，品类词必须出现。',
|
||
'参考链接标题只用于提取通用品类、材质、功能、场景和搜索词。必须识别其中的第三方品牌、系列名和品牌型号，写入forbiddenBrandTerms，并确保所有候选标题完全不包含这些词。',
|
||
'每个标题必须为28至30个汉字，在不重复堆砌的前提下优先写满30字；不要空格、标点或序号。不得虚构或复制第三方品牌、材质、功能、尺寸、赠品或认证。',
|
||
'只输出JSON对象，格式为：{"keywordStrategy":{"brand":"","category":"品类词","material":"材质词","functionalSellingPoints":["功能词"],"scenes":["场景词"],"hotKeywords":["热搜词"],"surgingKeywords":["飙升词"],"modifiers":["修饰词"],"forbiddenBrandTerms":["参考标题中的第三方品牌或型号"]},"titles":["标题1","标题2","标题3","标题4","标题5"]}。',
|
||
].join('\n');
|
||
const PREVIOUS_PRODUCT_TITLE_PROMPT = [
|
||
'你是中国电商平台的商品标题策略专家。请根据平台标题规则、结构化关键词、竞品标题和公司商品真实信息，生成5个中文商品标题。',
|
||
'关键词结构为：品牌（可选）、品类（必填）、材质（可选）、功能卖点（必填）、场景（必填）、热搜词（必填）、飙升词（必填）、修饰词（可选）。',
|
||
'竞品关键词优先从选中的榜单Top20商品标题拆分；品类关键词从系统提供的10个品类词中选择。合并后按出现频次和搜索意图确定优先级。',
|
||
'组题时删除与前置品牌、品类、材质、功能词语义重复的词；所有飙升词必须出现，品类词必须出现。',
|
||
'每个标题最多30个字符，不要空格、标点、序号或重复堆砌。不得虚构品牌、材质、功能、尺寸、赠品或认证。',
|
||
'只输出JSON对象，格式为：{"titles":["标题1","标题2","标题3","标题4","标题5"]}。',
|
||
].join('\n');
|
||
const RECENT_PRODUCT_TITLE_PROMPT = [
|
||
'你是中国电商平台的商品标题策略专家。请根据平台标题规则、结构化关键词、竞品标题和公司商品真实信息，先推荐分类关键词，再生成5个中文商品标题。',
|
||
'关键词结构为：品牌（可选）、品类（必填）、材质（可选）、功能卖点（必填）、场景（必填）、热搜词（必填）、飙升词（必填）、修饰词（可选）。',
|
||
'竞品关键词优先从选中的榜单Top20商品标题拆分；品类关键词从系统提供的10个品类词中选择。合并后按出现频次和搜索意图确定优先级。',
|
||
'组题时删除与前置品牌、品类、材质、功能词语义重复的词；所有飙升词必须出现，品类词必须出现。',
|
||
'每个标题必须为26至30个汉字，在不重复堆砌的前提下尽量接近30字；不要空格、标点或序号。不得虚构品牌、材质、功能、尺寸、赠品或认证。',
|
||
'只输出JSON对象，格式为：{"keywordStrategy":{"brand":"","category":"品类词","material":"材质词","functionalSellingPoints":["功能词"],"scenes":["场景词"],"hotKeywords":["热搜词"],"surgingKeywords":["飙升词"],"modifiers":["修饰词"]},"titles":["标题1","标题2","标题3","标题4","标题5"]}。',
|
||
].join('\n');
|
||
const LEGACY_PRODUCT_TITLE_PROMPT = [
|
||
'你是中国电商平台的商品标题优化专家。请根据市场商品标题、公司SPU、类目和商品图片生成5个新的中文商品标题。',
|
||
'标题需要覆盖核心品类词、主要规格、颜色和真实卖点，表达自然并适合电商搜索，不得虚构品牌、材质、功能、尺寸、赠品或认证。',
|
||
'每个标题不超过60个汉字，不要带序号，不要重复。',
|
||
'只输出JSON对象，格式为：{"titles":["标题1","标题2","标题3","标题4","标题5"]}。',
|
||
].join('\n');
|
||
|
||
const LEGACY_MAIN_IMAGE_PROMPT = [
|
||
'第一张图是市场参考图，第二张图是公司商品白底图。',
|
||
'彻底移除市场参考图中的原商品、文字、图标、标签、角标、价格、水印和品牌标识，只保留干净的场景、构图、视角、光线与真实阴影。',
|
||
'将第二张图中的公司商品完整替换到市场参考图原商品位置，保持商品结构、颜色和比例准确，边缘自然，不新增任何文字或图标。',
|
||
'参考市场图的陈设风格，在商品上或周围布置与品类和场景协调的书籍、摆件、收纳盒、绿植等生活化装饰品，画面饱满但不过度堆砌，不能输出光秃秃的裸产品。',
|
||
'所有装饰品必须采用无文字、无Logo设计，书籍封面和书脊只保留纯色或自然纹理，不得出现任何字符、符号或伪文字。',
|
||
'装饰品仅作为场景陈设，不得改变、遮挡或虚构商品的层板、柜门、五金、尺寸和其他主体结构，也不得表现为随商品赠送的配件。',
|
||
'输出一张可直接用于电商主图的正方形高清图片。',
|
||
].join('\n');
|
||
|
||
const PREVIOUS_MAIN_IMAGE_PROMPT = [
|
||
'第一张图是公司商品白底图或干净商品图，第二张图是同品类市场参考图。第一张图决定商品身份，第二张图决定商业摄影构图与视觉风格。',
|
||
'第一张图是唯一商品主体，禁止保留、复刻或混合市场商品主体。',
|
||
'必须准确保留公司商品的外形、结构、颜色、材质细节、比例、接口、层数、配件和数量；如果公司图带原始场景，只清理背景，不得改变商品本体。',
|
||
'强参考市场图的机位、视角、裁切、主体占比、空间布局、陈列方式、景深、灯光方向、色温、背景材质和接触阴影，把公司商品放入市场图原商品的位置。',
|
||
'彻底移除市场图中的原商品、文字、图标、标签、角标、价格、水印和品牌标识，但保留其场景道具与氛围。最终效果是公司商品主体加市场图的构图风格，不要生成白底棚拍或泛化背景。',
|
||
'参考市场图的陈设风格，在商品上或周围布置与品类和场景协调的书籍、摆件、收纳盒、绿植等生活化装饰品，画面饱满但不过度堆砌，不能输出光秃秃的裸产品。',
|
||
'所有装饰品必须采用无文字、无Logo设计，书籍封面和书脊只保留纯色或自然纹理，不得出现任何字符、符号或伪文字。',
|
||
'装饰品仅作为场景陈设，不得改变、遮挡或虚构商品的层板、柜门、五金、尺寸和其他主体结构，也不得表现为随商品赠送的配件。',
|
||
'输出一张可直接用于电商主图的正方形高清图片。',
|
||
].join('\n');
|
||
|
||
const DEFAULT_MAIN_IMAGE_PROMPT = [
|
||
'第一张图是目标商品图，也是唯一商品身份来源；第二张图是同品类市场参考图，只提供商业摄影场景、机位、构图、裁切、灯光、阴影和道具。',
|
||
'彻底移除第二张图中的市场商品及其品牌信息，把第一张图的完整目标商品作为一个刚性整体放入相同场景，禁止拆分重绘或复制市场商品结构。',
|
||
'目标商品的轮廓、几何结构、长宽高比例、厚度、开口、边缘、连接关系、层数、部件位置与精确数量、颜色、材质、纹理、五金和配件必须与第一张图完全一致。',
|
||
'若市场图的机位会迫使商品变形，优先保持目标商品外观结构不变，只采用最接近的有效机位。',
|
||
'参考市场图的陈设风格，在商品上或周围布置与品类和场景协调的书籍、摆件、收纳盒、绿植等生活化装饰品，画面饱满但不过度堆砌，不能输出光秃秃的裸产品。',
|
||
'所有装饰品必须采用无文字、无Logo设计，书籍封面和书脊只保留纯色或自然纹理，不得出现任何字符、符号或伪文字。',
|
||
'装饰品仅作为场景陈设，不得改变、遮挡或虚构商品结构，不得表现为随商品赠送的配件。输出前逐项核对腿、抽屉、层板、柜门、面板、横梁、把手、孔位、轮子、接口和附件。',
|
||
'输出一张可直接用于电商主图的正方形高清图片。',
|
||
].join('\n');
|
||
|
||
const LEGACY_SKU_IMAGE_PROMPT = [
|
||
'第一张图是已完成产品替换的市场主图场景，第二张图是公司SKU产品图。',
|
||
'把第二张图的SKU商品自然放入第一张图相同的场景、构图、视角和光线中，准确保留SKU结构、颜色、尺寸比例与细节。',
|
||
'沿用第一张图的装饰风格，在SKU商品上或周围合理布置书籍、摆件、收纳盒、绿植等生活化场景道具；如果参考图装饰不足，需要主动补充，不能输出光秃秃的裸产品。',
|
||
'所有装饰品必须采用无文字、无Logo设计，书籍封面和书脊只保留纯色或自然纹理，不得出现任何字符、符号或伪文字。',
|
||
'装饰品不能遮挡或改变SKU主体结构，不得虚构商品组件或暗示装饰品随商品赠送；不新增文字、图标、水印或品牌标识。',
|
||
'输出一张正方形高清电商SKU图。',
|
||
].join('\n');
|
||
|
||
const PREVIOUS_SKU_IMAGE_PROMPT = [
|
||
'第一张图是当前SKU唯一商品身份图，必须准确保留该SKU的结构、规格、颜色、材质、尺寸比例、部件和配件数量。',
|
||
'只有在参考市场图生成模式下才会提供第二张图；第二张只提供场景、构图、机位、裁切和光线参考，必须完全移除其原商品。',
|
||
'禁止引用主图商品、其他SKU或参考图原商品，禁止修改当前SKU的规格、颜色、结构和配件。',
|
||
'清除文字图标模式下只移除文字、品牌、店铺标识、价格、促销标签、角标、水印、二维码和图标覆盖物，不得重绘商品。',
|
||
'输出一张且仅一张无文字、无Logo、无水印的高清电商SKU图。',
|
||
].join('\n');
|
||
|
||
const DEFAULT_SKU_IMAGE_PROMPT = [
|
||
'第一张图是当前SKU唯一商品身份图；必须把该SKU作为不可拆分、不可重新设计的刚性整体，禁止引用主图商品、同SPU其他SKU或市场参考图商品。',
|
||
'只有在参考市场图生成模式下才会提供第二张图；第二张只提供场景、构图、机位、裁切、灯光、阴影和道具，必须彻底移除其原商品及品牌信息。',
|
||
'当前SKU的轮廓、几何结构、规格、长宽高比例、厚度、开口、连接关系、部件位置与精确数量、颜色、材质、纹理、五金和配件必须与第一张图完全一致。',
|
||
'若市场图机位会导致SKU变形或零部件变化，优先保持SKU外观结构不变，只采用最接近的有效机位；输出前逐项核对所有可见部件和附件。',
|
||
'清除文字图标模式下只移除文字、品牌、店铺标识、价格、促销标签、角标、水印、二维码和图标覆盖物，不得重绘商品。',
|
||
'输出一张且仅一张无文字、无Logo、无水印的高清电商SKU图。',
|
||
].join('\n');
|
||
|
||
function normalizeText(value, maxLength = 1000) {
|
||
return String(value ?? '').trim().slice(0, maxLength);
|
||
}
|
||
|
||
function normalizeBoolean(value, fallback = false) {
|
||
if (value === true || value === false) return value;
|
||
const text = String(value ?? '').trim().toLowerCase();
|
||
if (['1', 'true', 'yes', 'on', 'enabled'].includes(text)) return true;
|
||
if (['0', 'false', 'no', 'off', 'disabled'].includes(text)) return false;
|
||
return fallback;
|
||
}
|
||
|
||
function normalizePositiveInteger(value, fallback, min = 1000, max = 10 * 60 * 1000) {
|
||
const number = Number(value);
|
||
if (!Number.isFinite(number)) return fallback;
|
||
return Math.min(Math.max(Math.trunc(number), min), max);
|
||
}
|
||
|
||
function normalizeBaseUrl(value) {
|
||
return normalizeText(value, 500).replace(/\/+$/, '');
|
||
}
|
||
|
||
function getFirstEnvValue(names = [], fallback = '') {
|
||
for (const name of names) {
|
||
const value = normalizeText(process.env[name], 4000);
|
||
if (value) return value;
|
||
}
|
||
return fallback;
|
||
}
|
||
|
||
function preserveSecret(input, previous, fallback = '') {
|
||
return input === undefined || input === ''
|
||
? normalizeText(previous || fallback, 4000)
|
||
: normalizeText(input, 4000);
|
||
}
|
||
|
||
function normalizeImageSize() {
|
||
return '1K';
|
||
}
|
||
|
||
function normalizeImageGenerationConfig(value, existing = {}) {
|
||
const raw = value && typeof value === 'object' && !Array.isArray(value) ? value : {};
|
||
const previous = existing && typeof existing === 'object' && !Array.isArray(existing) ? existing : {};
|
||
const rawExternal = raw.external && typeof raw.external === 'object' ? raw.external : {};
|
||
const previousExternal = previous.external && typeof previous.external === 'object' ? previous.external : {};
|
||
const rawQwen = raw.qwen && typeof raw.qwen === 'object' ? raw.qwen : {};
|
||
const previousQwen = previous.qwen && typeof previous.qwen === 'object' ? previous.qwen : {};
|
||
const provider = normalizeText(raw.provider || previous.provider, 40) === 'qwen'
|
||
? 'qwen'
|
||
: 'external';
|
||
|
||
return {
|
||
provider,
|
||
timeoutMs: normalizePositiveInteger(
|
||
raw.timeoutMs || raw.timeout_ms || previous.timeoutMs || previous.timeout_ms,
|
||
normalizePositiveInteger(
|
||
process.env.SELECTION_IMAGE_GEN_TIMEOUT_MS,
|
||
DEFAULT_IMAGE_GENERATION_TIMEOUT_MS,
|
||
10000,
|
||
30 * 60 * 1000
|
||
),
|
||
10000,
|
||
30 * 60 * 1000
|
||
),
|
||
external: {
|
||
baseUrl: normalizeBaseUrl(
|
||
rawExternal.baseUrl
|
||
|| rawExternal.base_url
|
||
|| previousExternal.baseUrl
|
||
|| previousExternal.base_url
|
||
|| getFirstEnvValue(['SELECTION_IMAGE_GEN_BASE_URL', 'IMAGE_GEN_BASE_URL'], DEFAULT_EXTERNAL_IMAGE_BASE_URL)
|
||
) || DEFAULT_EXTERNAL_IMAGE_BASE_URL,
|
||
apiKey: preserveSecret(
|
||
rawExternal.apiKey ?? rawExternal.api_key,
|
||
previousExternal.apiKey || previousExternal.api_key,
|
||
getFirstEnvValue(['SELECTION_IMAGE_GEN_API_KEY', 'IMAGE_GEN_API_KEY', 'EXTERNAL_IMAGE_GEN_API_KEY'])
|
||
),
|
||
model: normalizeText(
|
||
rawExternal.model || previousExternal.model || process.env.SELECTION_IMAGE_GEN_MODEL || DEFAULT_EXTERNAL_IMAGE_MODEL,
|
||
160
|
||
) || DEFAULT_EXTERNAL_IMAGE_MODEL,
|
||
imageSize: normalizeImageSize(
|
||
rawExternal.imageSize
|
||
|| rawExternal.image_size
|
||
|| previousExternal.imageSize
|
||
|| previousExternal.image_size
|
||
|| process.env.SELECTION_IMAGE_GEN_IMAGE_SIZE,
|
||
'1K'
|
||
),
|
||
},
|
||
qwen: {
|
||
baseUrl: normalizeBaseUrl(
|
||
rawQwen.baseUrl
|
||
|| rawQwen.base_url
|
||
|| previousQwen.baseUrl
|
||
|| previousQwen.base_url
|
||
|| process.env.QWEN_IMAGE_BASE_URL
|
||
|| DEFAULT_QWEN_IMAGE_BASE_URL
|
||
) || DEFAULT_QWEN_IMAGE_BASE_URL,
|
||
apiKey: preserveSecret(
|
||
rawQwen.apiKey ?? rawQwen.api_key,
|
||
previousQwen.apiKey || previousQwen.api_key,
|
||
process.env.QWEN_IMAGE_API_KEY
|
||
),
|
||
model: normalizeText(
|
||
rawQwen.model || previousQwen.model || process.env.QWEN_IMAGE_MODEL || DEFAULT_QWEN_IMAGE_MODEL,
|
||
160
|
||
) || DEFAULT_QWEN_IMAGE_MODEL,
|
||
imageSize: normalizeImageSize(
|
||
rawQwen.imageSize || rawQwen.image_size || previousQwen.imageSize || previousQwen.image_size,
|
||
'1K'
|
||
),
|
||
promptExtend: normalizeBoolean(
|
||
rawQwen.promptExtend ?? rawQwen.prompt_extend,
|
||
normalizeBoolean(previousQwen.promptExtend ?? previousQwen.prompt_extend, true)
|
||
),
|
||
watermark: normalizeBoolean(
|
||
rawQwen.watermark,
|
||
normalizeBoolean(previousQwen.watermark, false)
|
||
),
|
||
},
|
||
};
|
||
}
|
||
|
||
function maskSecret(value) {
|
||
const text = String(value || '');
|
||
if (!text) return '';
|
||
if (text.length <= 8) return `${text.slice(0, 2)}******`;
|
||
return `${text.slice(0, 4)}${'*'.repeat(Math.min(10, text.length - 8))}${text.slice(-4)}`;
|
||
}
|
||
|
||
function safeJsonParse(value, fallback = null) {
|
||
if (!value) return fallback;
|
||
if (typeof value === 'object') return value;
|
||
try {
|
||
return JSON.parse(value);
|
||
} catch (_error) {
|
||
return fallback;
|
||
}
|
||
}
|
||
|
||
function normalizeMainImagePrompt(value) {
|
||
const prompt = normalizeText(value, 8000);
|
||
const isPreviousDefaultPrompt = prompt.startsWith('第一张图是公司商品白底图，第二张图是市场参考图。');
|
||
return !prompt
|
||
|| prompt === LEGACY_MAIN_IMAGE_PROMPT
|
||
|| prompt === PREVIOUS_MAIN_IMAGE_PROMPT
|
||
|| isPreviousDefaultPrompt
|
||
? DEFAULT_MAIN_IMAGE_PROMPT
|
||
: prompt;
|
||
}
|
||
|
||
function normalizeSkuImagePrompt(value) {
|
||
const prompt = normalizeText(value, 8000);
|
||
const isPreviousDefaultPrompt = prompt.startsWith('参考已替换完成的市场主图场景');
|
||
return !prompt
|
||
|| prompt === LEGACY_SKU_IMAGE_PROMPT
|
||
|| prompt === PREVIOUS_SKU_IMAGE_PROMPT
|
||
|| isPreviousDefaultPrompt
|
||
? DEFAULT_SKU_IMAGE_PROMPT
|
||
: prompt;
|
||
}
|
||
|
||
async function getSystemConfigValue() {
|
||
const rows = await database.local.query(
|
||
'SELECT config_value AS configValue FROM system_config WHERE config_key = ? LIMIT 1',
|
||
[CONFIG_KEY]
|
||
);
|
||
return rows[0]?.configValue ?? null;
|
||
}
|
||
|
||
async function upsertSystemConfig(value) {
|
||
const configValue = JSON.stringify(value ?? null);
|
||
const rows = await database.local.query(
|
||
'SELECT id FROM system_config WHERE config_key = ? LIMIT 1',
|
||
[CONFIG_KEY]
|
||
);
|
||
if (rows[0]) {
|
||
await database.local.query(
|
||
'UPDATE system_config SET config_value = ?, config_type = ? WHERE config_key = ?',
|
||
[configValue, 'json', CONFIG_KEY]
|
||
);
|
||
return;
|
||
}
|
||
await database.local.insert('system_config', {
|
||
config_key: CONFIG_KEY,
|
||
config_value: configValue,
|
||
config_type: 'json',
|
||
});
|
||
}
|
||
|
||
function normalizeConfig(value, existing = {}) {
|
||
const raw = value && typeof value === 'object' && !Array.isArray(value) ? value : {};
|
||
const previous = existing && typeof existing === 'object' && !Array.isArray(existing) ? existing : {};
|
||
const apiKeyInput = raw.apiKey ?? raw.api_key;
|
||
const apiKey = apiKeyInput === undefined || apiKeyInput === ''
|
||
? normalizeText(previous.apiKey || previous.api_key || process.env.DASHSCOPE_API_KEY, 4000)
|
||
: normalizeText(apiKeyInput, 4000);
|
||
|
||
const requestedProductTitlePrompt = normalizeText(
|
||
raw.productTitlePrompt
|
||
|| raw.product_title_prompt
|
||
|| previous.productTitlePrompt
|
||
|| previous.product_title_prompt,
|
||
8000
|
||
);
|
||
const requestedMainImagePrompt = normalizeText(
|
||
raw.mainImagePrompt
|
||
|| raw.main_image_prompt
|
||
|| previous.mainImagePrompt
|
||
|| previous.main_image_prompt,
|
||
8000
|
||
);
|
||
const imageGenerationInput = raw.imageGeneration || raw.image_generation;
|
||
const previousImageGeneration = previous.imageGeneration || previous.image_generation;
|
||
return {
|
||
enabled: normalizeBoolean(raw.enabled, normalizeBoolean(previous.enabled, true)),
|
||
provider: 'aliyun-model-studio',
|
||
baseUrl: normalizeBaseUrl(
|
||
raw.baseUrl || raw.base_url || previous.baseUrl || previous.base_url || DEFAULT_BASE_URL
|
||
) || DEFAULT_BASE_URL,
|
||
apiKey,
|
||
model: normalizeText(raw.model || previous.model || DEFAULT_MODEL, 160) || DEFAULT_MODEL,
|
||
skuNamePrompt: normalizeText(
|
||
raw.skuNamePrompt || raw.sku_name_prompt || previous.skuNamePrompt || previous.sku_name_prompt || DEFAULT_SKU_NAME_PROMPT,
|
||
8000
|
||
) || DEFAULT_SKU_NAME_PROMPT,
|
||
productTitlePrompt: !requestedProductTitlePrompt
|
||
|| requestedProductTitlePrompt === LEGACY_PRODUCT_TITLE_PROMPT
|
||
|| requestedProductTitlePrompt === PREVIOUS_PRODUCT_TITLE_PROMPT
|
||
|| requestedProductTitlePrompt === RECENT_PRODUCT_TITLE_PROMPT
|
||
? DEFAULT_PRODUCT_TITLE_PROMPT
|
||
: requestedProductTitlePrompt,
|
||
mainImagePrompt: normalizeMainImagePrompt(requestedMainImagePrompt),
|
||
skuImagePrompt: normalizeSkuImagePrompt(
|
||
raw.skuImagePrompt
|
||
|| raw.sku_image_prompt
|
||
|| previous.skuImagePrompt
|
||
|| previous.sku_image_prompt
|
||
|| DEFAULT_SKU_IMAGE_PROMPT,
|
||
),
|
||
timeoutMs: normalizePositiveInteger(
|
||
raw.timeoutMs || raw.timeout_ms || previous.timeoutMs || previous.timeout_ms,
|
||
DEFAULT_TIMEOUT_MS,
|
||
10000,
|
||
10 * 60 * 1000
|
||
),
|
||
imageGeneration: normalizeImageGenerationConfig(
|
||
imageGenerationInput,
|
||
previousImageGeneration
|
||
),
|
||
};
|
||
}
|
||
|
||
function toAdminConfig(config) {
|
||
const imageGeneration = config.imageGeneration || normalizeImageGenerationConfig();
|
||
return {
|
||
enabled: Boolean(config.enabled),
|
||
provider: config.provider,
|
||
baseUrl: config.baseUrl,
|
||
model: config.model,
|
||
skuNamePrompt: config.skuNamePrompt,
|
||
productTitlePrompt: config.productTitlePrompt,
|
||
mainImagePrompt: config.mainImagePrompt,
|
||
skuImagePrompt: config.skuImagePrompt,
|
||
timeoutMs: config.timeoutMs,
|
||
apiKeyConfigured: Boolean(config.apiKey),
|
||
apiKeyPreview: maskSecret(config.apiKey),
|
||
imageGeneration: {
|
||
provider: imageGeneration.provider,
|
||
timeoutMs: imageGeneration.timeoutMs,
|
||
external: {
|
||
baseUrl: imageGeneration.external.baseUrl,
|
||
model: imageGeneration.external.model,
|
||
imageSize: imageGeneration.external.imageSize,
|
||
apiKeyConfigured: Boolean(imageGeneration.external.apiKey),
|
||
apiKeyPreview: maskSecret(imageGeneration.external.apiKey),
|
||
},
|
||
qwen: {
|
||
baseUrl: imageGeneration.qwen.baseUrl,
|
||
model: imageGeneration.qwen.model,
|
||
imageSize: imageGeneration.qwen.imageSize,
|
||
promptExtend: imageGeneration.qwen.promptExtend,
|
||
watermark: imageGeneration.qwen.watermark,
|
||
apiKeyConfigured: Boolean(imageGeneration.qwen.apiKey),
|
||
apiKeyPreview: maskSecret(imageGeneration.qwen.apiKey),
|
||
},
|
||
},
|
||
};
|
||
}
|
||
|
||
async function getSelectionFissionAiConfig() {
|
||
const raw = await getSystemConfigValue().catch(() => null);
|
||
return normalizeConfig(safeJsonParse(raw, {}));
|
||
}
|
||
|
||
async function getSelectionFissionAiAdminSettings() {
|
||
return toAdminConfig(await getSelectionFissionAiConfig());
|
||
}
|
||
|
||
async function getSelectionFissionImageGenerationConfig() {
|
||
const config = await getSelectionFissionAiConfig();
|
||
return config.imageGeneration;
|
||
}
|
||
|
||
async function saveSelectionFissionAiConfig(input = {}) {
|
||
const raw = await getSystemConfigValue().catch(() => null);
|
||
const existing = safeJsonParse(raw, {});
|
||
const config = normalizeConfig(input, existing);
|
||
await upsertSystemConfig(config);
|
||
return toAdminConfig(config);
|
||
}
|
||
|
||
function parseFirstJsonObject(text) {
|
||
const raw = String(text || '').trim();
|
||
if (!raw) return null;
|
||
const fenced = raw.match(/```(?:json)?\s*([\s\S]*?)```/i);
|
||
for (const candidate of [fenced?.[1], raw].filter(Boolean)) {
|
||
try {
|
||
return JSON.parse(candidate);
|
||
} catch (_error) {
|
||
const start = candidate.indexOf('{');
|
||
const end = candidate.lastIndexOf('}');
|
||
if (start >= 0 && end > start) {
|
||
try {
|
||
return JSON.parse(candidate.slice(start, end + 1));
|
||
} catch (_nestedError) {
|
||
// Try the next candidate.
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
|
||
function normalizeGeneratedName(value) {
|
||
return normalizeText(value, 120)
|
||
.replace(/^[\d一二三四五]+[.、:：)\]]\s*/, '')
|
||
.replace(/^["'“”]|["'“”]$/g, '')
|
||
.trim();
|
||
}
|
||
|
||
function normalizeSkuNameCandidatesPayload(payload, skuRows = []) {
|
||
const rawItems = Array.isArray(payload)
|
||
? payload
|
||
: Array.isArray(payload?.items)
|
||
? payload.items
|
||
: [];
|
||
const itemBySku = new Map();
|
||
for (const item of rawItems) {
|
||
const skuCode = normalizeText(item?.skuCode || item?.sku_code || item?.sku, 160);
|
||
const names = Array.isArray(item?.names)
|
||
? item.names
|
||
: Array.isArray(item?.skuNames)
|
||
? item.skuNames
|
||
: Array.isArray(item?.sku_names)
|
||
? item.sku_names
|
||
: [];
|
||
const uniqueNames = Array.from(new Set(names.map(normalizeGeneratedName).filter(Boolean)));
|
||
if (skuCode) itemBySku.set(skuCode.toUpperCase(), uniqueNames);
|
||
}
|
||
|
||
return skuRows.map((row) => {
|
||
const skuCode = normalizeText(row.skuCode || row.sku_code, 160);
|
||
const originalSkuName = normalizeGeneratedName(
|
||
row.originalSkuName || row.original_sku_name || row.skuName || row.sku_name
|
||
);
|
||
const names = (itemBySku.get(skuCode.toUpperCase()) || [])
|
||
.filter((name) => !originalSkuName || name !== originalSkuName);
|
||
if (names.length !== REQUIRED_NAME_COUNT) {
|
||
const error = new Error(
|
||
`AI未能为SKU ${skuCode} 返回恰好${REQUIRED_NAME_COUNT}个与原名不同的有效名称`
|
||
);
|
||
error.status = 502;
|
||
error.code = 'AI_SKU_NAME_INVALID_RESPONSE';
|
||
throw error;
|
||
}
|
||
return { skuCode, originalSkuName, names };
|
||
});
|
||
}
|
||
|
||
function buildSkuNameRequestContent(context, skuRows, prompt) {
|
||
const rowsForPrompt = skuRows.map((row) => ({
|
||
skuCode: row.skuCode,
|
||
originalSkuName: row.originalSkuName || row.skuName,
|
||
size: row.size || '',
|
||
color: row.colorName || '',
|
||
}));
|
||
const content = [{
|
||
type: 'text',
|
||
text: [
|
||
prompt,
|
||
'',
|
||
`SPU编码：${normalizeText(context.spuCode, 160) || '未提供'}`,
|
||
`SPU名称：${normalizeText(context.spuName, 255) || '未提供'}`,
|
||
`市场商品标题：${normalizeText(context.marketTitle, 500) || '未提供'}`,
|
||
`待处理SKU：${JSON.stringify(rowsForPrompt)}`,
|
||
].join('\n'),
|
||
}];
|
||
for (const row of skuRows) {
|
||
const imageUrl = normalizeText(row.imageUrl || row.generatedImageUrl || row.skuImageUrl, 2000);
|
||
if (imageUrl) {
|
||
content.push({ type: 'text', text: `SKU ${row.skuCode} 参考图片：` });
|
||
content.push({ type: 'image_url', image_url: { url: imageUrl } });
|
||
}
|
||
}
|
||
return content;
|
||
}
|
||
|
||
function buildSkuNameRepairInstruction(skuRows = [], attempt = 1) {
|
||
return [
|
||
`上一次输出未通过校验，这是第${attempt + 1}次生成。`,
|
||
`必须为下列每个SKU分别返回恰好${REQUIRED_NAME_COUNT}个名称，不能遗漏任何SKU：${skuRows.map((row) => row.skuCode).join('、')}。`,
|
||
'同一SKU的名称必须互不重复，且不能与originalSkuName完全相同；只返回约定的JSON对象，不要解释。',
|
||
].join('\n');
|
||
}
|
||
|
||
async function requestChatCompletion(config, messages, maxCompletionTokens = 1800) {
|
||
if (!config.enabled) {
|
||
const error = new Error('选品AI分析模型未启用');
|
||
error.status = 409;
|
||
error.code = 'SELECTION_AI_DISABLED';
|
||
throw error;
|
||
}
|
||
if (!config.apiKey) {
|
||
const error = new Error('选品AI分析模型尚未配置API Key');
|
||
error.status = 409;
|
||
error.code = 'SELECTION_AI_API_KEY_MISSING';
|
||
throw error;
|
||
}
|
||
|
||
try {
|
||
const response = await axios.post(`${config.baseUrl}/chat/completions`, {
|
||
model: config.model,
|
||
messages,
|
||
response_format: { type: 'json_object' },
|
||
max_completion_tokens: maxCompletionTokens,
|
||
enable_thinking: false,
|
||
temperature: 0.7,
|
||
}, {
|
||
timeout: config.timeoutMs,
|
||
headers: {
|
||
Authorization: `Bearer ${config.apiKey}`,
|
||
'Content-Type': 'application/json',
|
||
},
|
||
maxBodyLength: 20 * 1024 * 1024,
|
||
});
|
||
return response.data;
|
||
} catch (error) {
|
||
const message = normalizeText(
|
||
error.response?.data?.error?.message || error.response?.data?.message || error.message,
|
||
1000
|
||
);
|
||
const wrapped = new Error(`阿里云模型请求失败：${message || '未知错误'}`);
|
||
wrapped.status = error.response?.status || 502;
|
||
wrapped.code = error.response?.data?.error?.code || 'ALIYUN_MODEL_REQUEST_FAILED';
|
||
throw wrapped;
|
||
}
|
||
}
|
||
|
||
function normalizePddPropertyRecommendations(payload, categoryRule = {}) {
|
||
const inputRows = Array.isArray(payload?.properties)
|
||
? payload.properties
|
||
: Array.isArray(payload?.items)
|
||
? payload.items
|
||
: [];
|
||
const ruleById = new Map((categoryRule.properties || []).map((row) => [Number(row.refPid), row]));
|
||
const normalized = [];
|
||
for (const row of inputRows) {
|
||
const refPid = Number(row.refPid || row.ref_pid);
|
||
const rule = ruleById.get(refPid);
|
||
if (!rule) continue;
|
||
const requestedVid = Number(row.vid || 0);
|
||
const requestedValue = normalizeText(row.value, 500);
|
||
const enumValue = requestedVid
|
||
? (rule.values || []).find((value) => Number(value.vid) === requestedVid)
|
||
: (rule.values || []).find((value) => normalizeText(value.value, 500) === requestedValue);
|
||
if ((rule.values || []).length > 0 && !enumValue) continue;
|
||
const value = enumValue?.value || requestedValue;
|
||
if (!value) continue;
|
||
normalized.push({
|
||
refPid,
|
||
vid: enumValue?.vid || 0,
|
||
value,
|
||
propertyName: rule.name,
|
||
evidence: normalizeText(row.evidence || row.reason, 1000),
|
||
confidence: Math.min(Math.max(Number(row.confidence) || 0, 0), 1),
|
||
});
|
||
}
|
||
return normalized;
|
||
}
|
||
|
||
async function generatePddPropertyRecommendations(context = {}) {
|
||
const config = await getSelectionFissionAiConfig();
|
||
const model = normalizeText(
|
||
process.env.PDD_PROPERTY_AI_MODEL || DEFAULT_PDD_PROPERTY_MODEL,
|
||
160
|
||
) || DEFAULT_PDD_PROPERTY_MODEL;
|
||
const categoryRule = context.categoryRule || { properties: [] };
|
||
const lockedRefPids = new Set((context.lockedRefPids || []).map(Number));
|
||
const propertyRules = (categoryRule.properties || []).map((property) => ({
|
||
refPid: property.refPid,
|
||
name: property.name,
|
||
required: Boolean(property.required),
|
||
important: Boolean(property.important),
|
||
chooseMaxNum: Number(property.chooseMaxNum || 1),
|
||
valueType: property.valueType,
|
||
valueUnit: property.valueUnit,
|
||
values: (property.values || []).slice(0, 200),
|
||
lockedByExcel: lockedRefPids.has(Number(property.refPid)),
|
||
}));
|
||
const prompt = [
|
||
'你是拼多多商品发布属性分析专家。根据1688结构化商品参数、图片OCR文字和拼多多实时类目规则，推荐商品属性。',
|
||
'只能使用输入中真实存在的事实，不得猜测品牌、认证、环保等级、产地、材质或功能。证据不足的属性不要输出。',
|
||
'有枚举值的属性只能从给定values中选择，并同时返回对应refPid、vid和value；没有枚举值时才可填写文本value。',
|
||
'lockedByExcel=true的属性已由人工Excel规则确定，禁止输出或覆盖。优先处理必填和重要属性。',
|
||
'只输出JSON对象：{"properties":[{"refPid":123,"vid":456,"value":"枚举文本","confidence":0.95,"evidence":"来源证据"}]}。',
|
||
`拼多多叶子类目：${normalizeText(context.categoryName, 255)}`,
|
||
`拼多多类目路径：${JSON.stringify(context.categoryPath || [])}`,
|
||
`1688商品标题：${normalizeText(context.productTitle, 500)}`,
|
||
`1688类目：${normalizeText(context.sourceCategory, 500)}`,
|
||
`1688商品参数文案：${normalizeText(context.sourceDescription, 8000)}`,
|
||
`1688商品参数：${JSON.stringify(context.sourceAttributes || [])}`,
|
||
`图片OCR结果：${JSON.stringify((context.ocrResults || []).map((row) => ({
|
||
kind: row.kind,
|
||
index: row.index,
|
||
text: normalizeText(row.fullText, 3000),
|
||
})))}`,
|
||
`拼多多实时属性规则：${JSON.stringify(propertyRules)}`,
|
||
].join('\n');
|
||
const response = await requestChatCompletion({ ...config, model }, [{
|
||
role: 'user',
|
||
content: prompt,
|
||
}], Math.max(2000, Math.min(8000, propertyRules.length * 180)));
|
||
const parsed = parseFirstJsonObject(response?.choices?.[0]?.message?.content);
|
||
if (!parsed) {
|
||
const error = new Error('qwen3.8-max未返回可解析的拼多多属性JSON');
|
||
error.status = 502;
|
||
error.code = 'PDD_PROPERTY_AI_JSON_MISSING';
|
||
throw error;
|
||
}
|
||
return {
|
||
model,
|
||
generatedAt: new Date().toISOString(),
|
||
properties: normalizePddPropertyRecommendations(parsed, categoryRule),
|
||
usage: {
|
||
promptTokens: Number(response?.usage?.prompt_tokens || 0),
|
||
completionTokens: Number(response?.usage?.completion_tokens || 0),
|
||
totalTokens: Number(response?.usage?.total_tokens || 0),
|
||
},
|
||
};
|
||
}
|
||
|
||
async function generateSkuNameCandidates(context = {}, skuRows = []) {
|
||
const normalizedRows = (Array.isArray(skuRows) ? skuRows : [])
|
||
.filter((row) => normalizeText(row?.skuCode || row?.sku_code, 160));
|
||
if (normalizedRows.length === 0) {
|
||
const error = new Error('没有可生成名称的SKU定价行');
|
||
error.status = 400;
|
||
throw error;
|
||
}
|
||
|
||
const config = await getSelectionFissionAiConfig();
|
||
const results = [];
|
||
let usage = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
|
||
for (let offset = 0; offset < normalizedRows.length; offset += MAX_SKUS_PER_REQUEST) {
|
||
const chunk = normalizedRows.slice(offset, offset + MAX_SKUS_PER_REQUEST);
|
||
let chunkRows = null;
|
||
let lastValidationError = null;
|
||
for (let attempt = 0; attempt < MAX_SKU_NAME_ATTEMPTS; attempt += 1) {
|
||
const requestContent = buildSkuNameRequestContent(context, chunk, config.skuNamePrompt);
|
||
if (attempt > 0) {
|
||
requestContent.push({
|
||
type: 'text',
|
||
text: buildSkuNameRepairInstruction(chunk, attempt),
|
||
});
|
||
}
|
||
const response = await requestChatCompletion(config, [{
|
||
role: 'user',
|
||
content: requestContent,
|
||
}], Math.max(1200, chunk.length * 450));
|
||
usage = {
|
||
promptTokens: usage.promptTokens + Number(response?.usage?.prompt_tokens || 0),
|
||
completionTokens: usage.completionTokens + Number(response?.usage?.completion_tokens || 0),
|
||
totalTokens: usage.totalTokens + Number(response?.usage?.total_tokens || 0),
|
||
};
|
||
const content = response?.choices?.[0]?.message?.content;
|
||
const parsed = parseFirstJsonObject(content);
|
||
try {
|
||
if (!parsed) {
|
||
const error = new Error('阿里云模型未返回可解析的SKU名称JSON');
|
||
error.status = 502;
|
||
error.code = 'AI_SKU_NAME_JSON_MISSING';
|
||
throw error;
|
||
}
|
||
chunkRows = normalizeSkuNameCandidatesPayload(parsed, chunk);
|
||
break;
|
||
} catch (error) {
|
||
lastValidationError = error;
|
||
if (attempt === MAX_SKU_NAME_ATTEMPTS - 1) throw error;
|
||
}
|
||
}
|
||
if (!chunkRows) throw lastValidationError;
|
||
results.push(...chunkRows);
|
||
}
|
||
|
||
return {
|
||
model: config.model,
|
||
generatedAt: new Date().toISOString(),
|
||
rows: results,
|
||
usage,
|
||
};
|
||
}
|
||
|
||
function normalizeKeywordList(value, limit = 20) {
|
||
const rows = Array.isArray(value) ? value : String(value || '').split(/[,，、\s]+/);
|
||
return Array.from(new Set(rows.map((item) => normalizeText(item, 40)).filter(Boolean))).slice(0, limit);
|
||
}
|
||
|
||
function normalizeProductTitleCategoryTerm(value) {
|
||
const categoryPath = normalizeText(value, 255);
|
||
if (!categoryPath) return '';
|
||
const segments = categoryPath
|
||
.split(/\s*(?:>|＞|》|\/|\\|→|-)\s*/)
|
||
.map((item) => normalizeText(item, 40))
|
||
.filter(Boolean);
|
||
const leaf = segments.at(-1) || categoryPath;
|
||
const parentMatch = segments
|
||
.slice(0, -1)
|
||
.reverse()
|
||
.find((item) => item.length >= 2 && leaf.endsWith(item));
|
||
if (parentMatch) return parentMatch;
|
||
return leaf.replace(/^(?:单个|单件|单只|一体式)/, '') || leaf;
|
||
}
|
||
|
||
function normalizeProductTitleStrategy(value = {}, context = {}) {
|
||
const raw = value && typeof value === 'object' && !Array.isArray(value) ? value : {};
|
||
const category = normalizeProductTitleCategoryTerm(context.categoryName || raw.category);
|
||
const fallbackKeyword = category || normalizeText(context.spuName, 40) || '商品';
|
||
return {
|
||
brand: normalizeText(raw.brand, 40),
|
||
category: fallbackKeyword,
|
||
material: normalizeText(raw.material, 40),
|
||
functionalSellingPoints: normalizeKeywordList(
|
||
raw.functionalSellingPoints || raw.functional_selling_points || [fallbackKeyword],
|
||
5
|
||
),
|
||
scenes: normalizeKeywordList(raw.scenes || ['家用'], 3),
|
||
hotKeywords: normalizeKeywordList(raw.hotKeywords || raw.hot_keywords || [fallbackKeyword], 5),
|
||
surgingKeywords: normalizeKeywordList(
|
||
raw.surgingKeywords || raw.surging_keywords || [fallbackKeyword],
|
||
2
|
||
),
|
||
modifiers: normalizeKeywordList(raw.modifiers, 4),
|
||
categoryKeywords: normalizeKeywordList(raw.categoryKeywords || raw.category_keywords, 10),
|
||
competitorTitles: normalizeKeywordList(raw.competitorTitles || raw.competitor_titles || context.competitorTitles, 20),
|
||
forbiddenBrandTerms: normalizeKeywordList(
|
||
raw.forbiddenBrandTerms
|
||
|| raw.forbidden_brand_terms
|
||
|| context.forbiddenBrandTerms,
|
||
20
|
||
),
|
||
};
|
||
}
|
||
|
||
function normalizeProductTitleCandidatesPayload(payload, strategy = {}) {
|
||
const titles = Array.isArray(payload)
|
||
? payload
|
||
: Array.isArray(payload?.titles)
|
||
? payload.titles
|
||
: Array.isArray(payload?.items)
|
||
? payload.items
|
||
: [];
|
||
const normalized = Array.from(new Set(titles
|
||
.map((item) => normalizeGeneratedName(
|
||
typeof item === 'string' ? item : item?.title || item?.name
|
||
))
|
||
.filter(Boolean)
|
||
.map((title) => title.replace(/[\s,，。；;、|/]+/g, ''))
|
||
.filter((title) => title.length >= MIN_PRODUCT_TITLE_LENGTH && title.length <= MAX_PRODUCT_TITLE_LENGTH)));
|
||
if (normalized.length !== REQUIRED_NAME_COUNT) {
|
||
const error = new Error(`AI未能返回恰好${REQUIRED_NAME_COUNT}个有效商品标题（每个28至30字）`);
|
||
error.status = 502;
|
||
error.code = 'AI_PRODUCT_TITLE_INVALID_RESPONSE';
|
||
throw error;
|
||
}
|
||
const category = normalizeText(strategy.category, 40);
|
||
const requiredWords = normalizeKeywordList(strategy.surgingKeywords);
|
||
if (category && normalized.some((title) => !title.includes(category))) {
|
||
const error = new Error(`AI生成的标题未全部包含品类词“${category}”`);
|
||
error.status = 502;
|
||
error.code = 'AI_PRODUCT_TITLE_CATEGORY_MISSING';
|
||
throw error;
|
||
}
|
||
const missingSurging = requiredWords.find((word) => normalized.some((title) => !title.includes(word)));
|
||
if (missingSurging) {
|
||
const error = new Error(`AI生成的标题未全部包含飙升词“${missingSurging}”`);
|
||
error.status = 502;
|
||
error.code = 'AI_PRODUCT_TITLE_SURGING_MISSING';
|
||
throw error;
|
||
}
|
||
const forbiddenBrandTerm = normalizeKeywordList(strategy.forbiddenBrandTerms, 20)
|
||
.find((term) => normalized.some((title) => title.toLowerCase().includes(term.toLowerCase())));
|
||
if (forbiddenBrandTerm) {
|
||
const error = new Error(`AI生成的标题包含参考商品品牌或型号“${forbiddenBrandTerm}”`);
|
||
error.status = 502;
|
||
error.code = 'AI_PRODUCT_TITLE_REFERENCE_BRAND_LEAK';
|
||
throw error;
|
||
}
|
||
return normalized;
|
||
}
|
||
|
||
async function generateProductTitleCandidates(context = {}) {
|
||
const config = await getSelectionFissionAiConfig();
|
||
const strategy = normalizeProductTitleStrategy(context.keywordStrategy, context);
|
||
const baseText = [
|
||
config.productTitlePrompt,
|
||
'',
|
||
`市场商品标题：${normalizeText(context.marketTitle, 500) || '未提供'}`,
|
||
`公司SPU编码：${normalizeText(context.spuCode, 160) || '未提供'}`,
|
||
`公司SPU名称：${normalizeText(context.spuName, 255) || '未提供'}`,
|
||
`商品类目：${normalizeText(context.categoryName, 255) || '未提供'}`,
|
||
`关键词策略：${JSON.stringify(strategy)}`,
|
||
`榜单竞品标题（最多20条）：${JSON.stringify(strategy.competitorTitles)}`,
|
||
`品类候选词（最多10个）：${JSON.stringify(strategy.categoryKeywords)}`,
|
||
`禁用的参考品牌或型号：${JSON.stringify(strategy.forbiddenBrandTerms)}`,
|
||
'请先基于商品事实、竞品标题和候选词优化 keywordStrategy 中各分类推荐词，再用推荐结果组题。不得虚构商品属性。',
|
||
'参考标题里的第三方品牌、系列名和品牌型号只能写入forbiddenBrandTerms，严禁出现在任何候选标题中。',
|
||
'硬性长度要求：每个标题必须为28至30个汉字，在语义自然且不重复堆砌的前提下优先写满30字。',
|
||
].join('\n');
|
||
const imageUrl = normalizeText(context.imageUrl, 2000);
|
||
let lastValidationError = null;
|
||
for (let attempt = 1; attempt <= 3; attempt += 1) {
|
||
const content = [{
|
||
type: 'text',
|
||
text: attempt === 1
|
||
? baseText
|
||
: `${baseText}\n\n上次输出未通过校验：${lastValidationError?.message || '格式不合规'}。请重新生成，严格保证5个标题各自为28至30字、优先写满30字，并包含品类词和全部飙升词。`,
|
||
}];
|
||
if (imageUrl) {
|
||
content.push({ type: 'text', text: '商品主图：' });
|
||
content.push({ type: 'image_url', image_url: { url: imageUrl } });
|
||
}
|
||
const response = await requestChatCompletion(config, [{ role: 'user', content }], 1000);
|
||
const parsed = parseFirstJsonObject(response?.choices?.[0]?.message?.content);
|
||
try {
|
||
if (!parsed) {
|
||
const error = new Error('阿里云模型未返回可解析的商品标题JSON');
|
||
error.status = 502;
|
||
error.code = 'AI_PRODUCT_TITLE_JSON_MISSING';
|
||
throw error;
|
||
}
|
||
const recommendedRaw = parsed.keywordStrategy || parsed.keyword_strategy || {};
|
||
const recommendedStrategy = normalizeProductTitleStrategy({
|
||
...strategy,
|
||
...recommendedRaw,
|
||
category: strategy.category,
|
||
categoryKeywords: strategy.categoryKeywords,
|
||
competitorTitles: strategy.competitorTitles,
|
||
forbiddenBrandTerms: [
|
||
...strategy.forbiddenBrandTerms,
|
||
...normalizeKeywordList(
|
||
recommendedRaw.forbiddenBrandTerms || recommendedRaw.forbidden_brand_terms,
|
||
20
|
||
),
|
||
],
|
||
}, context);
|
||
return {
|
||
model: config.model,
|
||
generatedAt: new Date().toISOString(),
|
||
strategy: recommendedStrategy,
|
||
titles: normalizeProductTitleCandidatesPayload(parsed, recommendedStrategy),
|
||
usage: {
|
||
promptTokens: Number(response?.usage?.prompt_tokens || 0),
|
||
completionTokens: Number(response?.usage?.completion_tokens || 0),
|
||
totalTokens: Number(response?.usage?.total_tokens || 0),
|
||
},
|
||
};
|
||
} catch (error) {
|
||
lastValidationError = error;
|
||
if (attempt === 3) throw error;
|
||
}
|
||
}
|
||
throw lastValidationError;
|
||
}
|
||
|
||
async function testSelectionFissionAiConfig() {
|
||
const config = await getSelectionFissionAiConfig();
|
||
const response = await requestChatCompletion(config, [{
|
||
role: 'user',
|
||
content: '只返回JSON：{"ok":true,"message":"连接成功"}',
|
||
}], 100);
|
||
const parsed = parseFirstJsonObject(response?.choices?.[0]?.message?.content);
|
||
if (parsed?.ok !== true) {
|
||
const error = new Error('模型已响应，但未返回预期的连接测试结果');
|
||
error.status = 502;
|
||
throw error;
|
||
}
|
||
return {
|
||
provider: config.provider,
|
||
model: config.model,
|
||
message: normalizeText(parsed.message, 100) || '连接成功',
|
||
};
|
||
}
|
||
|
||
module.exports = {
|
||
CONFIG_KEY,
|
||
DEFAULT_BASE_URL,
|
||
DEFAULT_EXTERNAL_IMAGE_BASE_URL,
|
||
DEFAULT_EXTERNAL_IMAGE_MODEL,
|
||
DEFAULT_MAIN_IMAGE_PROMPT,
|
||
DEFAULT_MODEL,
|
||
DEFAULT_PDD_PROPERTY_MODEL,
|
||
DEFAULT_PRODUCT_TITLE_PROMPT,
|
||
DEFAULT_QWEN_IMAGE_BASE_URL,
|
||
DEFAULT_QWEN_IMAGE_MODEL,
|
||
DEFAULT_SKU_IMAGE_PROMPT,
|
||
DEFAULT_SKU_NAME_PROMPT,
|
||
buildSkuNameRepairInstruction,
|
||
generateProductTitleCandidates,
|
||
generatePddPropertyRecommendations,
|
||
generateSkuNameCandidates,
|
||
getSelectionFissionAiAdminSettings,
|
||
getSelectionFissionAiConfig,
|
||
getSelectionFissionImageGenerationConfig,
|
||
normalizeImageGenerationConfig,
|
||
normalizeProductTitleCandidatesPayload,
|
||
normalizeProductTitleCategoryTerm,
|
||
normalizePddPropertyRecommendations,
|
||
normalizeMainImagePrompt,
|
||
normalizeSkuImagePrompt,
|
||
normalizeSkuNameCandidatesPayload,
|
||
saveSelectionFissionAiConfig,
|
||
testSelectionFissionAiConfig,
|
||
};
|