541 lines
16 KiB
TypeScript
541 lines
16 KiB
TypeScript
export type AgentPresetMessageImagePart = {
|
||
type: "file";
|
||
url: string;
|
||
name: string;
|
||
mediaType: string;
|
||
assetId?: string;
|
||
};
|
||
|
||
export function extractCurrentMessageImageParts(
|
||
parts: Array<Record<string, any>>,
|
||
): AgentPresetMessageImagePart[] {
|
||
return parts
|
||
.filter(
|
||
(part): part is AgentPresetMessageImagePart =>
|
||
part?.type === "file" &&
|
||
typeof part?.url === "string" &&
|
||
/^https?:\/\//i.test(part.url) &&
|
||
typeof part?.mediaType === "string" &&
|
||
part.mediaType.startsWith("image/")
|
||
)
|
||
.map((part) => ({
|
||
type: "file",
|
||
url: String(part.url).trim(),
|
||
name: String(part.name || "图片").trim() || "图片",
|
||
mediaType: String(part.mediaType || "image/jpeg").trim() || "image/jpeg",
|
||
assetId:
|
||
typeof part.assetId === "string" && part.assetId.trim() ? part.assetId.trim() : undefined,
|
||
}));
|
||
}
|
||
|
||
export function getSceneUploadedImageBreakdown(params: {
|
||
uploadedImageParts: AgentPresetMessageImagePart[];
|
||
fallbackPrimaryCount: number;
|
||
fallbackIncludeModelImage: boolean;
|
||
}) {
|
||
const normalizedNames = params.uploadedImageParts.map((part) => String(part.name || "").trim());
|
||
const primaryCountFromNames = normalizedNames.filter((name) => name.startsWith("主SKU参考图")).length;
|
||
const secondaryCountFromNames = normalizedNames.filter((name) => name.startsWith("搭配SKU参考图")).length;
|
||
const hasModelFromNames = normalizedNames.some((name) => name.startsWith("品牌模特图"));
|
||
const hasNamedBreakdown =
|
||
primaryCountFromNames > 0 || secondaryCountFromNames > 0 || hasModelFromNames;
|
||
|
||
if (hasNamedBreakdown) {
|
||
return {
|
||
primaryProductImageCount: primaryCountFromNames,
|
||
bundleProductImageCount: secondaryCountFromNames,
|
||
includeModelImage: hasModelFromNames,
|
||
};
|
||
}
|
||
|
||
const uploadedImageCount = params.uploadedImageParts.length;
|
||
const includeModelImage =
|
||
params.fallbackIncludeModelImage && uploadedImageCount > params.fallbackPrimaryCount;
|
||
const bundleProductImageCount = Math.max(
|
||
0,
|
||
uploadedImageCount - params.fallbackPrimaryCount - (includeModelImage ? 1 : 0)
|
||
);
|
||
const primaryProductImageCount = Math.max(
|
||
0,
|
||
Math.min(
|
||
params.fallbackPrimaryCount,
|
||
uploadedImageCount - bundleProductImageCount - (includeModelImage ? 1 : 0)
|
||
)
|
||
);
|
||
|
||
return {
|
||
primaryProductImageCount,
|
||
bundleProductImageCount,
|
||
includeModelImage,
|
||
};
|
||
}
|
||
|
||
export function resolveScenePromptOptimizationImageUrls(params: {
|
||
uploadedImageParts: AgentPresetMessageImagePart[];
|
||
primaryProductImageCount: number;
|
||
bundleProductImageCount: number;
|
||
includeModelImage: boolean;
|
||
}) {
|
||
const namedPrimaryParts = params.uploadedImageParts.filter((part) =>
|
||
String(part.name || "").trim().startsWith("主SKU参考图")
|
||
);
|
||
const namedModelPart = params.uploadedImageParts.find((part) =>
|
||
String(part.name || "").trim().startsWith("品牌模特图")
|
||
);
|
||
|
||
if (namedPrimaryParts.length > 0 || namedModelPart) {
|
||
return {
|
||
primaryImageUrl: namedPrimaryParts[0]?.url || "",
|
||
modelImageUrl: namedModelPart?.url || null,
|
||
};
|
||
}
|
||
|
||
const primaryImageUrl =
|
||
params.uploadedImageParts.slice(0, Math.max(0, params.primaryProductImageCount))[0]?.url || "";
|
||
const modelIndex = params.primaryProductImageCount + params.bundleProductImageCount;
|
||
|
||
return {
|
||
primaryImageUrl,
|
||
modelImageUrl:
|
||
params.includeModelImage && modelIndex < params.uploadedImageParts.length
|
||
? params.uploadedImageParts[modelIndex]?.url || null
|
||
: null,
|
||
};
|
||
}
|
||
|
||
export function normalizeAgentSupplementPrompt(text: string, presetName?: string | null) {
|
||
const normalized = String(text || "").trim();
|
||
if (!normalized) return "";
|
||
const escapedPresetName = String(presetName || "").replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
|
||
const genericPattern = escapedPresetName
|
||
? new RegExp(`^请按「${escapedPresetName}」风格化配置顺序处理这\\d+张图片。?$`)
|
||
: /^请按「.+」风格化配置顺序处理这\d+张图片。?$/;
|
||
if (genericPattern.test(normalized)) {
|
||
return "";
|
||
}
|
||
return normalized;
|
||
}
|
||
|
||
export function normalizeAgentWorkflowPrompt(text: string) {
|
||
return String(text || "")
|
||
.split(/\n+/)
|
||
.map((line) => line.replace(/\s+/g, " ").trim())
|
||
.filter(Boolean)
|
||
.join("\n")
|
||
.trim();
|
||
}
|
||
|
||
export function parseAgentWorkflowPromptSections(text: string) {
|
||
const sectionMap = new Map<string, string[]>();
|
||
let activeSection = "__root__";
|
||
const normalizedPrompt = normalizeAgentWorkflowPrompt(text);
|
||
if (!normalizedPrompt) {
|
||
return sectionMap;
|
||
}
|
||
|
||
normalizedPrompt.split("\n").forEach((line) => {
|
||
const trimmedLine = line.trim();
|
||
if (!trimmedLine) {
|
||
return;
|
||
}
|
||
const headerMatch = trimmedLine.match(/^【([^】]{1,30})】$/);
|
||
if (headerMatch) {
|
||
activeSection = headerMatch[1].trim();
|
||
if (!sectionMap.has(activeSection)) {
|
||
sectionMap.set(activeSection, []);
|
||
}
|
||
return;
|
||
}
|
||
|
||
const currentLines = sectionMap.get(activeSection) || [];
|
||
currentLines.push(trimmedLine);
|
||
sectionMap.set(activeSection, currentLines);
|
||
});
|
||
|
||
return sectionMap;
|
||
}
|
||
|
||
export function buildAgentPromptSectionText(
|
||
title: string,
|
||
lines: string[],
|
||
options?: { bullet?: boolean }
|
||
) {
|
||
const normalizedLines = lines
|
||
.map((line) => String(line || "").trim())
|
||
.filter(Boolean);
|
||
if (normalizedLines.length === 0) {
|
||
return "";
|
||
}
|
||
|
||
const sectionBody = options?.bullet
|
||
? normalizedLines.map((line) => (line.startsWith("- ") ? line : `- ${line}`)).join("\n")
|
||
: normalizedLines.join("\n");
|
||
|
||
return `【${title}】\n${sectionBody}`;
|
||
}
|
||
|
||
export function buildOptimizedAgentSceneWorkflowPrompt(params: {
|
||
workflowPrompt: string;
|
||
optimizationResult?: {
|
||
sceneGoal: string;
|
||
environmentSummary: string;
|
||
propSummary: string;
|
||
cameraLightingSummary: string;
|
||
characterSummary: string;
|
||
negativeConstraints: string[];
|
||
conflicts: string[];
|
||
} | null;
|
||
}) {
|
||
const normalizedWorkflowPrompt = normalizeAgentWorkflowPrompt(params.workflowPrompt);
|
||
if (!normalizedWorkflowPrompt) {
|
||
return "";
|
||
}
|
||
|
||
const optimizationResult = params.optimizationResult || null;
|
||
if (!optimizationResult) {
|
||
return normalizedWorkflowPrompt;
|
||
}
|
||
|
||
const sectionMap = parseAgentWorkflowPromptSections(normalizedWorkflowPrompt);
|
||
const sceneGoalLines = [optimizationResult.sceneGoal, optimizationResult.environmentSummary].filter(
|
||
Boolean
|
||
);
|
||
const propLines = [optimizationResult.propSummary].filter(Boolean);
|
||
const cameraLightingLines = [optimizationResult.cameraLightingSummary].filter(Boolean);
|
||
const characterLines = [optimizationResult.characterSummary].filter(Boolean);
|
||
const negativeLines = Array.from(
|
||
new Set([
|
||
...optimizationResult.negativeConstraints,
|
||
...optimizationResult.conflicts.map((item) => `冲突校正：${item}`),
|
||
])
|
||
);
|
||
|
||
const optimizedSections = [
|
||
buildAgentPromptSectionText("项目背景", sectionMap.get("项目背景") || sectionMap.get("__root__") || []),
|
||
buildAgentPromptSectionText("主SKU锁定", sectionMap.get("主SKU锁定") || []),
|
||
buildAgentPromptSectionText("搭配SKU锁定", sectionMap.get("搭配SKU锁定") || []),
|
||
buildAgentPromptSectionText("参考图", sectionMap.get("参考图") || []),
|
||
buildAgentPromptSectionText("场景创作总纲", sceneGoalLines),
|
||
buildAgentPromptSectionText("陈列与道具", propLines),
|
||
buildAgentPromptSectionText("机位与光线", cameraLightingLines),
|
||
buildAgentPromptSectionText("人物规则", characterLines),
|
||
buildAgentPromptSectionText("负面约束", negativeLines, { bullet: true }),
|
||
].filter(Boolean);
|
||
|
||
return optimizedSections.join("\n\n").trim();
|
||
}
|
||
|
||
const AGENT_PROMPT_STRUCTURAL_LABELS = new Set([
|
||
"角色",
|
||
"技能",
|
||
"目标",
|
||
"约束条件",
|
||
"流程",
|
||
"输出",
|
||
]);
|
||
|
||
const AGENT_PROMPT_LABEL_SEMANTIC_ALIASES = new Map<string, string>([
|
||
["角色", "role"],
|
||
["技能", "skills"],
|
||
["目标", "goal"],
|
||
["约束条件", "constraints"],
|
||
["流程", "process"],
|
||
["输出", "output"],
|
||
["人群选择", "audience"],
|
||
["人物", "audience"],
|
||
["主题风格", "style"],
|
||
["整体风格", "style"],
|
||
["空间选择", "space"],
|
||
["空间布局", "space"],
|
||
["主空间", "space"],
|
||
["子空间选择", "subspace"],
|
||
["子空间", "subspace"],
|
||
["硬装方案", "hardDecoration"],
|
||
["硬装", "hardDecoration"],
|
||
["软装方案", "softDecoration"],
|
||
["软装", "softDecoration"],
|
||
["光氛选择", "lighting"],
|
||
["光源布置", "lighting"],
|
||
["灯具", "lighting"],
|
||
["机位选择", "camera"],
|
||
["拍摄角度", "camera"],
|
||
["配饰陈列", "accessories"],
|
||
["放在产品内的小件配饰", "accessories"],
|
||
["前景", "sceneLayout"],
|
||
["中景", "sceneLayout"],
|
||
["背景", "sceneLayout"],
|
||
]);
|
||
|
||
const AGENT_SCENE_WORKFLOW_OWNED_SEMANTICS = new Set([
|
||
"role",
|
||
"skills",
|
||
"goal",
|
||
"constraints",
|
||
"process",
|
||
"output",
|
||
"audience",
|
||
"style",
|
||
"space",
|
||
"subspace",
|
||
"hardDecoration",
|
||
"softDecoration",
|
||
"lighting",
|
||
"camera",
|
||
"accessories",
|
||
"sceneLayout",
|
||
]);
|
||
|
||
export function normalizePromptLineForCompare(line: string) {
|
||
return String(line || "")
|
||
.replace(/\s+/g, " ")
|
||
.replace(/[：:]/g, ":")
|
||
.replace(/[。；;，,、!！?？]+$/g, "")
|
||
.trim()
|
||
.toLowerCase();
|
||
}
|
||
|
||
export function parsePromptLineLabel(line: string) {
|
||
const normalized = String(line || "").replace(/\s+/g, " ").trim();
|
||
if (!normalized) return { label: "", value: "" };
|
||
|
||
const headerOnlyMatch = normalized.match(/^([^:：]{1,20})[:：]\s*$/);
|
||
if (headerOnlyMatch) {
|
||
return {
|
||
label: headerOnlyMatch[1].trim(),
|
||
value: "",
|
||
};
|
||
}
|
||
|
||
const colonMatch = normalized.match(/^([^:：]{1,20})[:：]\s*(.+)$/);
|
||
if (colonMatch) {
|
||
return {
|
||
label: colonMatch[1].trim(),
|
||
value: colonMatch[2].trim(),
|
||
};
|
||
}
|
||
|
||
const whitespaceMatch = normalized.match(/^([^\s]{1,20})\s+(.+)$/);
|
||
if (whitespaceMatch) {
|
||
return {
|
||
label: whitespaceMatch[1].trim(),
|
||
value: whitespaceMatch[2].trim(),
|
||
};
|
||
}
|
||
|
||
return { label: "", value: normalized };
|
||
}
|
||
|
||
export function normalizePromptLabel(label: string) {
|
||
return String(label || "")
|
||
.replace(/\s+/g, "")
|
||
.replace(/[：:]/g, "")
|
||
.trim();
|
||
}
|
||
|
||
export function getPromptSemanticLabel(label: string) {
|
||
const normalized = normalizePromptLabel(label);
|
||
return AGENT_PROMPT_LABEL_SEMANTIC_ALIASES.get(normalized) || normalized;
|
||
}
|
||
|
||
export function collectPromptSemanticLabelsFromText(text: string) {
|
||
const semanticLabels = new Set<string>();
|
||
const normalizedText = String(text || "").replace(/\s+/g, " ").trim();
|
||
if (!normalizedText) {
|
||
return semanticLabels;
|
||
}
|
||
|
||
for (const [label, semantic] of AGENT_PROMPT_LABEL_SEMANTIC_ALIASES.entries()) {
|
||
if (!label) {
|
||
continue;
|
||
}
|
||
if (normalizedText.includes(`${label}：`) || normalizedText.includes(`${label}:`)) {
|
||
semanticLabels.add(semantic);
|
||
continue;
|
||
}
|
||
if (normalizedText.includes(`${label} `) || normalizedText.includes(label)) {
|
||
semanticLabels.add(semantic);
|
||
}
|
||
}
|
||
|
||
return semanticLabels;
|
||
}
|
||
|
||
export function shouldDropSceneSlotSemanticLine(
|
||
slotSemanticLabel: string,
|
||
workflowSemanticLabels: Set<string>,
|
||
) {
|
||
if (!slotSemanticLabel || !AGENT_SCENE_WORKFLOW_OWNED_SEMANTICS.has(slotSemanticLabel)) {
|
||
return false;
|
||
}
|
||
|
||
if (slotSemanticLabel === "sceneLayout") {
|
||
return [
|
||
"style",
|
||
"space",
|
||
"subspace",
|
||
"hardDecoration",
|
||
"softDecoration",
|
||
"accessories",
|
||
"camera",
|
||
"lighting",
|
||
].some((semantic) => workflowSemanticLabels.has(semantic));
|
||
}
|
||
|
||
return workflowSemanticLabels.has(slotSemanticLabel);
|
||
}
|
||
|
||
export function dedupeAgentSlotPromptAgainstWorkflow(params: {
|
||
workflowPrompt?: string | null;
|
||
slotPrompt?: string | null;
|
||
modeType?: "scene_generation" | "detail_replacement" | "sku_replacement" | "generic";
|
||
}) {
|
||
const dedupedSlotLines: string[] = [];
|
||
const seenExactLines = new Set<string>();
|
||
const workflowStructuralValues = new Map<string, string>();
|
||
const workflowSemanticLabels = new Set<string>();
|
||
|
||
const rememberLine = (line: string) => {
|
||
const normalizedLine = normalizePromptLineForCompare(line);
|
||
if (!normalizedLine) {
|
||
return;
|
||
}
|
||
seenExactLines.add(normalizedLine);
|
||
};
|
||
|
||
const normalizedWorkflowLines = normalizeAgentWorkflowPrompt(params.workflowPrompt || "")
|
||
.split("\n")
|
||
.map((line) => line.trim())
|
||
.filter(Boolean);
|
||
normalizedWorkflowLines.forEach((line) => {
|
||
const parsed = parsePromptLineLabel(line);
|
||
if (parsed.label) {
|
||
workflowSemanticLabels.add(getPromptSemanticLabel(parsed.label));
|
||
}
|
||
collectPromptSemanticLabelsFromText(line).forEach((semantic) => {
|
||
workflowSemanticLabels.add(semantic);
|
||
});
|
||
collectPromptSemanticLabelsFromText(parsed.value || "").forEach((semantic) => {
|
||
workflowSemanticLabels.add(semantic);
|
||
});
|
||
if (parsed.label && AGENT_PROMPT_STRUCTURAL_LABELS.has(parsed.label)) {
|
||
workflowStructuralValues.set(
|
||
parsed.label,
|
||
normalizePromptLineForCompare(parsed.value || "")
|
||
);
|
||
}
|
||
rememberLine(line);
|
||
});
|
||
|
||
const normalizedSlotLines = String(params.slotPrompt || "")
|
||
.split(/\n+/)
|
||
.map((line) => line.replace(/\s+/g, " ").trim())
|
||
.filter(Boolean);
|
||
let activeSlotSemanticLabel = "";
|
||
normalizedSlotLines.forEach((line) => {
|
||
const normalizedLine = normalizePromptLineForCompare(line);
|
||
if (!normalizedLine || seenExactLines.has(normalizedLine)) {
|
||
return;
|
||
}
|
||
const parsed = parsePromptLineLabel(line);
|
||
const slotSemanticLabel = parsed.label ? getPromptSemanticLabel(parsed.label) : "";
|
||
if (slotSemanticLabel) {
|
||
activeSlotSemanticLabel = slotSemanticLabel;
|
||
}
|
||
if (
|
||
params.modeType === "scene_generation" &&
|
||
shouldDropSceneSlotSemanticLine(
|
||
slotSemanticLabel || activeSlotSemanticLabel,
|
||
workflowSemanticLabels,
|
||
)
|
||
) {
|
||
return;
|
||
}
|
||
if (parsed.label && AGENT_PROMPT_STRUCTURAL_LABELS.has(parsed.label)) {
|
||
const normalizedValue = normalizePromptLineForCompare(parsed.value || "");
|
||
const workflowValue = workflowStructuralValues.get(parsed.label);
|
||
if (workflowValue && workflowValue === normalizedValue) {
|
||
return;
|
||
}
|
||
}
|
||
seenExactLines.add(normalizedLine);
|
||
dedupedSlotLines.push(line);
|
||
});
|
||
|
||
return dedupedSlotLines.join("\n").trim();
|
||
}
|
||
|
||
export function buildAgentSlotPrompt(params: {
|
||
workflowPrompt?: string | null;
|
||
slotPrompt: string;
|
||
slotTitle?: string | null;
|
||
userSupplementPrompt?: string | null;
|
||
includeSlotTitle?: boolean;
|
||
modeType?: "scene_generation" | "detail_replacement" | "sku_replacement" | "generic";
|
||
}) {
|
||
const lines: string[] = [];
|
||
const workflowPrompt = normalizeAgentWorkflowPrompt(params.workflowPrompt || "");
|
||
if (workflowPrompt) {
|
||
lines.push(workflowPrompt);
|
||
}
|
||
const slotTitle = String(params.slotTitle || "").trim();
|
||
if (params.includeSlotTitle !== false && slotTitle) {
|
||
lines.push(`【槽位】${slotTitle}`);
|
||
}
|
||
const dedupedSlotPrompt = dedupeAgentSlotPromptAgainstWorkflow({
|
||
workflowPrompt,
|
||
slotPrompt: params.slotPrompt,
|
||
modeType: params.modeType || "generic",
|
||
});
|
||
if (dedupedSlotPrompt) {
|
||
lines.push(dedupedSlotPrompt);
|
||
}
|
||
const supplement = String(params.userSupplementPrompt || "").trim();
|
||
if (supplement) {
|
||
lines.push(`【补充要求】${supplement}`);
|
||
}
|
||
return lines.join("\n\n").trim();
|
||
}
|
||
|
||
export function buildAgentSceneWorkflowPrompt(params: {
|
||
workflowPrompt?: string | null;
|
||
slotPrompt?: string | null;
|
||
userSupplementPrompt?: string | null;
|
||
imageRolePrompt?: string | null;
|
||
}) {
|
||
const lines: string[] = [];
|
||
const workflowPrompt = normalizeAgentWorkflowPrompt(params.workflowPrompt || "");
|
||
if (workflowPrompt) {
|
||
lines.push(workflowPrompt);
|
||
}
|
||
const slotPrompt = String(params.slotPrompt || "")
|
||
.split(/\n+/)
|
||
.map((line) => line.replace(/\s+/g, " ").trim())
|
||
.filter(Boolean)
|
||
.join("\n")
|
||
.trim();
|
||
if (slotPrompt) {
|
||
lines.push(slotPrompt);
|
||
}
|
||
let imageRolePrompt = String(params.imageRolePrompt || "").trim();
|
||
if (workflowPrompt.includes("品牌模特图：已选") || workflowPrompt.includes("固定模特图")) {
|
||
imageRolePrompt = imageRolePrompt
|
||
.replace(
|
||
/^如当前请求未附带固定模特图，仅在工作流明确要求人物时再安排辅助人物，且人物不能喧宾夺主。$/m,
|
||
""
|
||
)
|
||
.replace(/^当前没有固定模特图，不要凭空生成强人物主体。$/m, "")
|
||
.split(/\n+/)
|
||
.map((line) => line.trim())
|
||
.filter(Boolean)
|
||
.join("\n");
|
||
}
|
||
if (imageRolePrompt) {
|
||
lines.push(imageRolePrompt);
|
||
}
|
||
const supplement = String(params.userSupplementPrompt || "").trim();
|
||
if (supplement) {
|
||
lines.push(`【补充要求】${supplement}`);
|
||
}
|
||
return lines.join("\n\n").trim();
|
||
}
|