@lingjingai/lj-awb-cli-pre 0.3.18 → 0.4.0

package/packages/awb-core/src/services.js

@@ -680,6 +680,31 @@ function modelListMetadata(kind, paramKeys = [], rulesByKey = new Map()) {
   };
 }
 
+function normalizeRateValue(value) {
+  if (value === undefined || value === null || value === '') return null;
+  const text = String(value).trim();
+  const isPercent = text.endsWith('%');
+  const parsed = Number(isPercent ? text.slice(0, -1) : text);
+  if (!Number.isFinite(parsed)) return null;
+  const rate = isPercent || parsed > 1 ? parsed / 100 : parsed;
+  if (rate < 0 || rate > 1) return null;
+  return rate;
+}
+
+function modelSuccessRate(item = {}) {
+  const ext = item?.modelExtInfo || {};
+  return normalizeRateValue(
+    item?.successRate
+    ?? item?.success_rate
+    ?? item?.successRatio
+    ?? item?.success_ratio
+    ?? ext?.successRate
+    ?? ext?.success_rate
+    ?? ext?.successRatio
+    ?? ext?.success_ratio,
+  );
+}
+
 function normalizeModelRows(payload, kind, options = {}) {
   const includeRaw = Boolean(options.includeRaw);
   const includeInternal = Boolean(options.includeInternal);
@@ -702,6 +727,7 @@ function normalizeModelRows(payload, kind, options = {}) {
       enabled: item?.enabled ?? item?.available ?? item?.status ?? null,
       modelStatus: item?.modelStatus ?? null,
       taskQueueNum: item?.taskQueueNum ?? null,
+      successRate: modelSuccessRate(item),
       feeCalcType: item?.feeCalcType ?? item?.feeType ?? null,
       inputModes: metadata.inputModes,
       params: metadata.controls,
@@ -917,6 +943,68 @@ function normalizeModelConstraints(constraintSchema = [], taskKind = 'image') {
   }).filter((constraint) => constraint.target || constraint.targetConfigCode);
 }
 
+function resourceConstraintTarget(mediaType, usage = 'reference') {
+  const media = String(mediaType || '').toLowerCase();
+  const normalizedUsage = String(usage || 'reference');
+  return media ? `resource.${media}.${normalizedUsage}` : '';
+}
+
+function countRangeValue(minCount, maxCount) {
+  if (minCount != null && maxCount != null && minCount === maxCount) return String(minCount);
+  if (minCount != null && maxCount != null) return `${minCount}..${maxCount}`;
+  if (minCount != null) return `>=${minCount}`;
+  if (maxCount != null) return `<=${maxCount}`;
+  return undefined;
+}
+
+function normalizeLimitProfileCondition(condition = {}) {
+  const mediaType = String(condition?.mediaType || '').toUpperCase();
+  const usage = condition?.usage || 'reference';
+  const minCount = ruleNumber(condition?.minCount);
+  const maxCount = ruleNumber(condition?.maxCount);
+  const target = resourceConstraintTarget(mediaType, usage);
+  return compactRecord({
+    key: target ? `${target}.count` : undefined,
+    mediaType,
+    usage,
+    minCount,
+    maxCount,
+    value: countRangeValue(minCount, maxCount),
+    meaning: 'count',
+  });
+}
+
+function normalizeResourceLimitProfileConstraints(options = []) {
+  const constraints = [];
+  for (const option of Array.isArray(options) ? options : []) {
+    const profiles = Array.isArray(option?.rules?.limitProfiles) ? option.rules.limitProfiles : [];
+    for (const [profileIndex, profile] of profiles.entries()) {
+      const condition = normalizeLimitProfileCondition(profile?.condition);
+      const overrides = Array.isArray(profile?.overrides) ? profile.overrides : [];
+      for (const [overrideIndex, override] of overrides.entries()) {
+        const mediaType = String(override?.mediaType || '').toUpperCase();
+        if (!mediaType) continue;
+        const usage = override?.usage || condition.usage || 'reference';
+        const limits = compactRecord({
+          usage,
+          ...normalizeMediaRule({ ...override, mediaType }),
+        });
+        constraints.push(compactRecord({
+          id: `${option.paramKey || 'resource'}.limitProfiles[${profileIndex}].overrides[${overrideIndex}]`,
+          name: '素材联动限制',
+          target: resourceConstraintTarget(mediaType, usage),
+          targetConfigCode: option.paramKey,
+          effect: 'resource_limit_overrides',
+          priority: option.rank,
+          conditions: condition.key ? [condition] : [],
+          limits,
+        }));
+      }
+    }
+  }
+  return constraints;
+}
+
 function resourceUsageList(usage) {
   return (Array.isArray(usage) ? usage : [usage])
     .map((item) => trimToNull(item))
@@ -1161,6 +1249,58 @@ function assertResourceCountsAgainstModel(resourceDetails = [], resourceRules =
   }
 }
 
+function resourceCountForCondition(resourceDetails = [], condition = {}) {
+  return resourceDetails.filter((detail) => {
+    const resource = detail.resource || {};
+    if (condition.mediaType && resourceMediaType(resource) !== String(condition.mediaType).toUpperCase()) return false;
+    if (condition.usage && resource.usage !== condition.usage) return false;
+    return true;
+  }).length;
+}
+
+function resourceLimitConditionMatches(resourceDetails = [], condition = {}) {
+  if (condition.meaning !== 'count') return false;
+  const count = resourceCountForCondition(resourceDetails, condition);
+  if (condition.minCount != null && count < condition.minCount) return false;
+  if (condition.maxCount != null && count > condition.maxCount) return false;
+  return true;
+}
+
+function validationResourceLimitOverrides(limits = {}) {
+  const validatesResourceDuration = resourceUsageList(limits.usage).includes('keyframe');
+  return compactRecord({
+    mediaType: limits.mediaType,
+    usage: limits.usage,
+    fileTypes: limits.fileTypes,
+    minFiles: limits.minFiles,
+    maxFiles: limits.maxFiles,
+    maxSizeKB: limits.maxSizeKB,
+    minItems: limits.minItems,
+    maxItems: limits.maxItems,
+    supportLastFrameOnly: limits.supportLastFrameOnly,
+    minDurationMs: validatesResourceDuration ? limits.minDurationMs : undefined,
+    maxDurationMs: validatesResourceDuration ? limits.maxDurationMs : undefined,
+    maxPromptLength: validatesResourceDuration ? limits.maxPromptLength : undefined,
+  });
+}
+
+function applyResourceLimitProfileConstraints(resourceRules = [], constraints = [], resourceDetails = []) {
+  const effective = resourceRules.map((rule) => ({ ...rule }));
+  const profiles = constraints.filter((constraint) => constraint.effect === 'resource_limit_overrides' && constraint.limits);
+  for (const profile of profiles) {
+    const conditions = Array.isArray(profile.conditions) ? profile.conditions : [];
+    if (conditions.length && !conditions.every((condition) => resourceLimitConditionMatches(resourceDetails, condition))) continue;
+    const validationLimits = validationResourceLimitOverrides(profile.limits);
+    if (!Object.keys(validationLimits).some((key) => !['mediaType', 'usage'].includes(key))) continue;
+    const index = effective.findIndex((rule) => (
+      String(rule.mediaType || '').toUpperCase() === String(validationLimits.mediaType || '').toUpperCase()
+      && resourceUsageList(rule.usage).includes(validationLimits.usage || 'reference')
+    ));
+    if (index >= 0) effective[index] = compactRecord({ ...effective[index], ...validationLimits });
+  }
+  return effective;
+}
+
 function promptParamValue(promptParams = {}, key) {
   if (key === 'duration') return promptParams.duration;
   if (key === 'generateNum') return promptParams.generate_num;
@@ -1239,9 +1379,10 @@ async function validateCreateRequestAgainstModel(kind, modelGroupCode, promptPar
   }
   const params = modelOptionParams(context.options, context.taskKind);
   const resources = modelOptionsResources(context.inputModes);
+  const effectiveResources = applyResourceLimitProfileConstraints(resources, context.constraints, resourceDetails);
   assertParamsAgainstModel(promptParams, params, context.constraints);
-  assertResourceShapeAgainstModel(resourceDetails, resources);
-  assertResourceCountsAgainstModel(resourceDetails, resources);
+  assertResourceShapeAgainstModel(resourceDetails, effectiveResources);
+  assertResourceCountsAgainstModel(resourceDetails, effectiveResources);
   if (kind === 'video') {
     const supportedIntents = createSpecSupportedIntents(context.inputModes, context.taskKind);
     const inputRequirement = createSpecInputRequirement(context.taskKind, context.inputModes, supportedIntents);
@@ -1274,12 +1415,16 @@ async function loadModelOptionContext(modelGroupCode, options = {}) {
   const constraintSchema = options.includeConstraintSchema
     ? await fetchModelConstraintSchema(rawModel, modelGroupCode)
     : [];
+  const constraints = [
+    ...normalizeModelConstraints(constraintSchema, taskKind),
+    ...normalizeResourceLimitProfileConstraints(mergedOptions),
+  ];
   return {
     rawModel,
     model: modelSummaryFromRaw(rawModel, modelGroupCode, taskKind),
     options: mergedOptions,
     constraintSchema,
-    constraints: normalizeModelConstraints(constraintSchema, taskKind),
+    constraints,
     optionKeys,
     rulesByKey,
     taskKind,
@@ -2073,6 +2218,7 @@ function modelOptionsResources(inputModes = []) {
           mediaType: 'IMAGE',
           usage: supportedFrameMode.optionResourceUsages,
           valueShapes: supportedFrameMode.sourceKinds,
+          sources: supportedFrameMode.sourceKinds,
           ...supportedFrameMode.optionResourceLimits,
           formatPolicy: framePolicy.summary,
           webpSupported: framePolicy.webpSupported,
@@ -2090,6 +2236,7 @@ function modelOptionsResources(inputModes = []) {
       mediaType,
       usage: optionResourceUsage(sourceMode),
       valueShapes: item.valueShapes,
+      sources: item.valueShapes,
       fileTypes: sourceMode === 'subject_reference' ? undefined : item.fileTypes,
       formatPolicy: imagePolicy?.summary,
       webpSupported: imagePolicy?.webpSupported,