664 lines
22 KiB
Go
664 lines
22 KiB
Go
package runner
|
||
|
||
import (
|
||
"fmt"
|
||
"math"
|
||
"strings"
|
||
|
||
"github.com/easyai/easyai-ai-gateway/apps/api/internal/store"
|
||
)
|
||
|
||
type contentFilterProcessor struct{}
|
||
|
||
func (contentFilterProcessor) Name() string { return "ContentFilterProcessor" }
|
||
|
||
func (contentFilterProcessor) ShouldProcess(params map[string]any, modelType string, context *paramProcessContext) bool {
|
||
_, ok := params["content"]
|
||
return ok
|
||
}
|
||
|
||
func (contentFilterProcessor) Process(params map[string]any, modelType string, context *paramProcessContext) bool {
|
||
content := contentItems(params["content"])
|
||
if len(content) == 0 {
|
||
return true
|
||
}
|
||
|
||
if isOmniVideoLike(context) {
|
||
filtered := filterUnsupportedOmniVideoContent(content, context)
|
||
params["content"] = mapsToAnySlice(filtered)
|
||
syncVideoConvenienceFields(params, filtered, context)
|
||
return true
|
||
}
|
||
|
||
if err := downgradeReferenceImageIfNeeded(params, content, modelType, context); err != nil {
|
||
return false
|
||
}
|
||
if modelType == "video_generate" || modelType == "text_to_video" {
|
||
next := make([]map[string]any, 0, len(content))
|
||
for index, item := range content {
|
||
if isImageContent(item) {
|
||
reason, path, value := imageContentRemovalEvidence(item, modelType, context)
|
||
context.recordChange(
|
||
"ContentFilterProcessor",
|
||
"remove",
|
||
fmt.Sprintf("content[%d]", index),
|
||
item,
|
||
nil,
|
||
reason,
|
||
path,
|
||
value,
|
||
)
|
||
continue
|
||
}
|
||
next = append(next, item)
|
||
}
|
||
content = next
|
||
}
|
||
if modelType == "image_to_video" || modelType == "omni_video" || modelType == "omni" {
|
||
if !supportsFirstAndLastFrame(context.modelCapability, modelType) {
|
||
next := make([]map[string]any, 0, len(content))
|
||
for index, item := range content {
|
||
if stringFromAny(item["role"]) == "last_frame" {
|
||
context.recordChange(
|
||
"ContentFilterProcessor",
|
||
"remove",
|
||
fmt.Sprintf("content[%d]", index),
|
||
item,
|
||
nil,
|
||
"模型不支持首尾帧输入，已移除 last_frame。",
|
||
capabilityPath(modelType, "input_first_last_frame"),
|
||
map[string]any{
|
||
"input_first_last_frame": capabilityValue(context.modelCapability, modelType, "input_first_last_frame"),
|
||
"max_images_for_last_frame": capabilityValue(context.modelCapability, modelType, "max_images_for_last_frame"),
|
||
},
|
||
)
|
||
continue
|
||
}
|
||
next = append(next, item)
|
||
}
|
||
content = next
|
||
deleteFieldsWithLog(params, context, "ContentFilterProcessor", []string{"last_frame", "lastFrame"}, "模型不支持首尾帧输入，已移除快捷字段。", capabilityPath(modelType, "input_first_last_frame"), map[string]any{
|
||
"input_first_last_frame": capabilityValue(context.modelCapability, modelType, "input_first_last_frame"),
|
||
"max_images_for_last_frame": capabilityValue(context.modelCapability, modelType, "max_images_for_last_frame"),
|
||
})
|
||
}
|
||
}
|
||
params["content"] = mapsToAnySlice(content)
|
||
return true
|
||
}
|
||
|
||
func imageContentRemovalEvidence(item map[string]any, modelType string, context *paramProcessContext) (string, string, any) {
|
||
role := stringFromAny(item["role"])
|
||
switch role {
|
||
case "first_frame":
|
||
return "模型能力未开启首帧输入，已移除 first_frame。", capabilityPath(modelType, "input_first_frame"), map[string]any{
|
||
"input_first_frame": capabilityValue(context.modelCapability, modelType, "input_first_frame"),
|
||
"input_first_last_frame": capabilityValue(context.modelCapability, modelType, "input_first_last_frame"),
|
||
}
|
||
case "last_frame":
|
||
return "模型能力未开启尾帧或首尾帧输入，已移除 last_frame。", capabilityPath(modelType, "input_first_last_frame"), map[string]any{
|
||
"input_last_frame": capabilityValue(context.modelCapability, modelType, "input_last_frame"),
|
||
"input_first_last_frame": capabilityValue(context.modelCapability, modelType, "input_first_last_frame"),
|
||
"max_images_for_last_frame": capabilityValue(context.modelCapability, modelType, "max_images_for_last_frame"),
|
||
"max_images_for_first_frame": capabilityValue(context.modelCapability, modelType, "max_images_for_first_frame"),
|
||
"max_images_for_middle_frame": capabilityValue(context.modelCapability, modelType, "max_images_for_middle_frame"),
|
||
}
|
||
case "reference_image":
|
||
return "模型能力未开启参考图输入，已移除 reference_image。", capabilityPath(modelType, "input_reference_generate_single"), map[string]any{
|
||
"input_reference_generate_single": capabilityValue(context.modelCapability, modelType, "input_reference_generate_single"),
|
||
"input_reference_generate_multiple": capabilityValue(context.modelCapability, modelType, "input_reference_generate_multiple"),
|
||
"max_images": capabilityValue(context.modelCapability, modelType, "max_images"),
|
||
}
|
||
default:
|
||
return "当前模型能力未开启图像输入，已移除 image_url。", capabilityPath(modelType, "input_first_frame"), map[string]any{
|
||
"input_first_frame": capabilityValue(context.modelCapability, modelType, "input_first_frame"),
|
||
"input_first_last_frame": capabilityValue(context.modelCapability, modelType, "input_first_last_frame"),
|
||
"input_reference_generate_single": capabilityValue(context.modelCapability, modelType, "input_reference_generate_single"),
|
||
"input_reference_generate_multiple": capabilityValue(context.modelCapability, modelType, "input_reference_generate_multiple"),
|
||
}
|
||
}
|
||
}
|
||
|
||
func ensureVideoContent(params map[string]any, context *paramProcessContext) {
|
||
if len(contentItems(params["content"])) > 0 {
|
||
return
|
||
}
|
||
content := make([]map[string]any, 0)
|
||
if prompt := firstNonEmptyString(stringFromAny(params["prompt"]), stringFromAny(params["input"])); prompt != "" {
|
||
content = append(content, map[string]any{"type": "text", "text": prompt})
|
||
}
|
||
appendURL := func(kind string, role string, url string) {
|
||
url = strings.TrimSpace(url)
|
||
if url == "" {
|
||
return
|
||
}
|
||
item := map[string]any{"type": kind, "role": role}
|
||
switch kind {
|
||
case "image_url":
|
||
item["image_url"] = map[string]any{"url": url}
|
||
case "video_url":
|
||
item["video_url"] = map[string]any{"url": url}
|
||
case "audio_url":
|
||
item["audio_url"] = map[string]any{"url": url}
|
||
}
|
||
content = append(content, item)
|
||
}
|
||
|
||
firstFrame := firstNonEmptyStringValue(params, "first_frame", "firstFrame")
|
||
appendURL("image_url", "first_frame", firstFrame)
|
||
appendURL("image_url", "last_frame", firstNonEmptyStringValue(params, "last_frame", "lastFrame"))
|
||
imageURLs := firstNonEmptyStringListFromAny(params["image"], params["images"], params["image_url"], params["imageUrl"], params["image_urls"], params["imageUrls"])
|
||
if firstFrame == "" && len(imageURLs) > 0 {
|
||
appendURL("image_url", "first_frame", imageURLs[0])
|
||
imageURLs = imageURLs[1:]
|
||
}
|
||
for _, url := range imageURLs {
|
||
appendURL("image_url", "reference_image", url)
|
||
}
|
||
for _, url := range firstNonEmptyStringListFromAny(params["reference_image"], params["referenceImage"]) {
|
||
appendURL("image_url", "reference_image", url)
|
||
}
|
||
for _, url := range firstNonEmptyStringListFromAny(params["video"], params["video_url"], params["videoUrl"], params["reference_video"], params["referenceVideo"]) {
|
||
appendURL("video_url", "reference_video", url)
|
||
}
|
||
for _, url := range firstNonEmptyStringListFromAny(params["audio_url"], params["audioUrl"], params["reference_audio"], params["referenceAudio"]) {
|
||
appendURL("audio_url", "reference_audio", url)
|
||
}
|
||
if len(content) > 0 {
|
||
params["content"] = mapsToAnySlice(content)
|
||
context.recordChange(
|
||
"ContentBuildProcessor",
|
||
"set",
|
||
"content",
|
||
nil,
|
||
params["content"],
|
||
"将 prompt/first_frame/reference_* 等快捷字段转换为 content 数组，后续处理器可按模型能力逐项过滤。",
|
||
"",
|
||
nil,
|
||
)
|
||
}
|
||
}
|
||
|
||
func effectiveModelCapability(candidate store.RuntimeModelCandidate) map[string]any {
|
||
base := cloneMap(candidate.Capabilities)
|
||
for key, value := range candidate.CapabilityOverride {
|
||
if baseChild, ok := base[key].(map[string]any); ok {
|
||
if overrideChild, ok := value.(map[string]any); ok {
|
||
base[key] = mergeMap(baseChild, overrideChild)
|
||
continue
|
||
}
|
||
}
|
||
base[key] = cloneAny(value)
|
||
}
|
||
return base
|
||
}
|
||
|
||
func filterUnsupportedOmniVideoContent(content []map[string]any, context *paramProcessContext) []map[string]any {
|
||
capability := omniVideoCapability(context)
|
||
maxVideos := math.Inf(1)
|
||
if capability != nil {
|
||
if value, ok := numericField(capability, "max_videos"); ok {
|
||
maxVideos = value
|
||
}
|
||
}
|
||
maxAudios := 0.0
|
||
if capability != nil {
|
||
if value, ok := numericField(capability, "max_audios"); ok {
|
||
maxAudios = value
|
||
} else if supportsOmniAudioReference(context) {
|
||
maxAudios = math.Inf(1)
|
||
}
|
||
}
|
||
|
||
videoCount := 0.0
|
||
audioCount := 0.0
|
||
out := make([]map[string]any, 0, len(content))
|
||
for index, item := range content {
|
||
if isVideoContent(item) {
|
||
if !supportsOmniVideoReference(item, capability) {
|
||
path, value := omniCapabilityEvidence(context, "supported_modes")
|
||
context.recordChange(
|
||
"ContentFilterProcessor",
|
||
"remove",
|
||
fmt.Sprintf("content[%d]", index),
|
||
item,
|
||
nil,
|
||
"视频参考类型不在 omni_video.supported_modes 允许范围内。",
|
||
path,
|
||
value,
|
||
)
|
||
continue
|
||
}
|
||
if videoCount >= maxVideos {
|
||
path, value := omniCapabilityEvidence(context, "max_videos")
|
||
context.recordChange(
|
||
"ContentFilterProcessor",
|
||
"remove",
|
||
fmt.Sprintf("content[%d]", index),
|
||
item,
|
||
nil,
|
||
"视频参考数量超过 omni_video.max_videos 限制。",
|
||
path,
|
||
value,
|
||
)
|
||
continue
|
||
}
|
||
videoCount++
|
||
out = append(out, item)
|
||
continue
|
||
}
|
||
if isAudioContent(item) {
|
||
if !supportsOmniAudioReference(context) {
|
||
path, value := omniCapabilityEvidence(context, "input_audio")
|
||
context.recordChange(
|
||
"ContentFilterProcessor",
|
||
"remove",
|
||
fmt.Sprintf("content[%d]", index),
|
||
item,
|
||
nil,
|
||
"模型能力不支持音频参考，已移除 audio_url。",
|
||
path,
|
||
mergeMetrics(map[string]any{"input_audio": value}, omniCapabilityBundle(context, "max_audios")),
|
||
)
|
||
continue
|
||
}
|
||
if audioCount >= maxAudios {
|
||
path, value := omniCapabilityEvidence(context, "max_audios")
|
||
context.recordChange(
|
||
"ContentFilterProcessor",
|
||
"remove",
|
||
fmt.Sprintf("content[%d]", index),
|
||
item,
|
||
nil,
|
||
"音频参考数量超过 omni_video.max_audios 限制。",
|
||
path,
|
||
value,
|
||
)
|
||
continue
|
||
}
|
||
audioCount++
|
||
out = append(out, item)
|
||
continue
|
||
}
|
||
out = append(out, item)
|
||
}
|
||
return out
|
||
}
|
||
|
||
func isOmniVideoLike(context *paramProcessContext) bool {
|
||
modelType := strings.TrimSpace(context.candidate.ModelType)
|
||
return modelType == "omni_video" ||
|
||
modelType == "omni" ||
|
||
context.modelCapability["omni_video"] != nil ||
|
||
context.modelCapability["omni"] != nil
|
||
}
|
||
|
||
func omniVideoCapability(context *paramProcessContext) map[string]any {
|
||
if capability := capabilityForType(context.modelCapability, "omni_video"); capability != nil {
|
||
return capability
|
||
}
|
||
return capabilityForType(context.modelCapability, "omni")
|
||
}
|
||
|
||
func supportsOmniAudioReference(context *paramProcessContext) bool {
|
||
capability := omniVideoCapability(context)
|
||
return capability != nil && (boolFromAny(capability["input_audio"]) || floatFromAny(capability["max_audios"]) > 0)
|
||
}
|
||
|
||
func supportsOmniVideoReference(item map[string]any, capability map[string]any) bool {
|
||
if capability == nil {
|
||
return true
|
||
}
|
||
if value, ok := numericField(capability, "max_videos"); ok && value == 0 {
|
||
return false
|
||
}
|
||
supportedModes := stringListFromAny(capability["supported_modes"])
|
||
supportsReference := containsString(supportedModes, "video_reference")
|
||
supportsEdit := containsString(supportedModes, "video_edit")
|
||
video, _ := item["video_url"].(map[string]any)
|
||
referType := stringFromAny(video["refer_type"])
|
||
isEditVideo := stringFromAny(item["role"]) == "video_base" || referType == "base"
|
||
isReferenceVideo := stringFromAny(item["role"]) == "video_feature" ||
|
||
stringFromAny(item["role"]) == "reference_video" ||
|
||
referType == "feature"
|
||
if isEditVideo {
|
||
return supportsEdit
|
||
}
|
||
if isReferenceVideo {
|
||
return supportsReference
|
||
}
|
||
return supportsReference || supportsEdit
|
||
}
|
||
|
||
func downgradeReferenceImageIfNeeded(params map[string]any, content []map[string]any, modelType string, context *paramProcessContext) error {
|
||
if !isVideoModelType(modelType) {
|
||
return nil
|
||
}
|
||
if supportsReferenceImage(context.modelCapability, modelType) {
|
||
return nil
|
||
}
|
||
|
||
imageIndexes := make([]int, 0)
|
||
referenceIndexes := make([]int, 0)
|
||
hasVideoOrAudioReference := false
|
||
for index, item := range content {
|
||
if isVideoContent(item) || isAudioContent(item) {
|
||
hasVideoOrAudioReference = true
|
||
continue
|
||
}
|
||
if !isImageContent(item) {
|
||
continue
|
||
}
|
||
imageIndexes = append(imageIndexes, index)
|
||
role := stringFromAny(item["role"])
|
||
if role == "" || role == "reference_image" {
|
||
referenceIndexes = append(referenceIndexes, index)
|
||
}
|
||
}
|
||
if len(referenceIndexes) == 0 {
|
||
return nil
|
||
}
|
||
|
||
evidence := referenceImageDowngradeCapabilityEvidence(context.modelCapability, modelType)
|
||
if hasVideoOrAudioReference {
|
||
context.reject(
|
||
"ContentFilterProcessor",
|
||
"content",
|
||
content,
|
||
"当前模型不支持多模态参考，不能将视频或音频参考降级为首尾帧，请移除视频/音频参考或选择支持多模态参考的模型。",
|
||
evidence.path,
|
||
evidence.value,
|
||
)
|
||
return context.err
|
||
}
|
||
if len(imageIndexes) > 2 {
|
||
context.reject(
|
||
"ContentFilterProcessor",
|
||
"content",
|
||
content,
|
||
"当前模型不支持多参考图输入，最多只允许 2 张图片降级为首尾帧。",
|
||
evidence.path,
|
||
evidence.value,
|
||
)
|
||
return context.err
|
||
}
|
||
if len(imageIndexes) == 2 && !supportsFirstAndLastFrame(context.modelCapability, modelType) {
|
||
context.reject(
|
||
"ContentFilterProcessor",
|
||
"content",
|
||
content,
|
||
"当前模型不支持首尾帧输入，不能将 2 张参考图降级为首尾帧。",
|
||
evidence.path,
|
||
evidence.value,
|
||
)
|
||
return context.err
|
||
}
|
||
if len(imageIndexes) == 1 && !supportsFirstFrame(context.modelCapability, modelType) {
|
||
context.reject(
|
||
"ContentFilterProcessor",
|
||
"content",
|
||
content,
|
||
"当前模型不支持首帧输入，不能将参考图降级为首帧。",
|
||
evidence.path,
|
||
evidence.value,
|
||
)
|
||
return context.err
|
||
}
|
||
|
||
if len(imageIndexes) == 1 {
|
||
adjustImageContentRole(content, imageIndexes[0], "first_frame", context, modelType, "模型不支持 reference_image，且只有 1 张图片，已降级为 first_frame。")
|
||
appendParamWarning(params, "reference_image is unsupported by the selected model and was downgraded to first_frame")
|
||
return nil
|
||
}
|
||
|
||
firstIndex, lastIndex := firstLastFrameIndexes(content, imageIndexes)
|
||
adjustImageContentRole(content, firstIndex, "first_frame", context, modelType, "模型不支持 reference_image，2 张图片已降级为首尾帧的 first_frame。")
|
||
adjustImageContentRole(content, lastIndex, "last_frame", context, modelType, "模型不支持 reference_image，2 张图片已降级为首尾帧的 last_frame。")
|
||
appendParamWarning(params, "reference_image is unsupported by the selected model and was downgraded to first/last frame")
|
||
return nil
|
||
}
|
||
|
||
type capabilityEvidenceValue struct {
|
||
path string
|
||
value any
|
||
}
|
||
|
||
func referenceImageDowngradeCapabilityEvidence(modelCapability map[string]any, modelType string) capabilityEvidenceValue {
|
||
actualType, capability := firstVideoInputCapability(modelCapability, modelType)
|
||
if actualType == "" {
|
||
actualType = modelType
|
||
}
|
||
value := map[string]any{}
|
||
if capability != nil {
|
||
for _, key := range []string{
|
||
"input_reference_generate_single",
|
||
"input_reference_generate_multiple",
|
||
"max_images",
|
||
"input_first_frame",
|
||
"input_first_last_frame",
|
||
"max_images_for_last_frame",
|
||
} {
|
||
value[key] = cloneAny(capability[key])
|
||
}
|
||
}
|
||
return capabilityEvidenceValue{path: capabilityPath(actualType, ""), value: value}
|
||
}
|
||
|
||
func adjustImageContentRole(content []map[string]any, index int, role string, context *paramProcessContext, modelType string, reason string) {
|
||
if index < 0 || index >= len(content) {
|
||
return
|
||
}
|
||
item := content[index]
|
||
if stringFromAny(item["role"]) == role {
|
||
return
|
||
}
|
||
before := cloneMap(item)
|
||
item["role"] = role
|
||
context.recordChange(
|
||
"ContentFilterProcessor",
|
||
"adjust",
|
||
fmt.Sprintf("content[%d].role", index),
|
||
before,
|
||
item,
|
||
reason,
|
||
capabilityPath(modelType, "input_reference_generate_single"),
|
||
referenceImageDowngradeCapabilityEvidence(context.modelCapability, modelType).value,
|
||
)
|
||
}
|
||
|
||
func firstLastFrameIndexes(content []map[string]any, imageIndexes []int) (int, int) {
|
||
firstIndex := -1
|
||
lastIndex := -1
|
||
for _, index := range imageIndexes {
|
||
switch stringFromAny(content[index]["role"]) {
|
||
case "first_frame":
|
||
if firstIndex == -1 {
|
||
firstIndex = index
|
||
}
|
||
case "last_frame":
|
||
if lastIndex == -1 {
|
||
lastIndex = index
|
||
}
|
||
}
|
||
}
|
||
if firstIndex == -1 && lastIndex == -1 {
|
||
return imageIndexes[0], imageIndexes[1]
|
||
}
|
||
if firstIndex == -1 {
|
||
for _, index := range imageIndexes {
|
||
if index != lastIndex {
|
||
firstIndex = index
|
||
break
|
||
}
|
||
}
|
||
}
|
||
if lastIndex == -1 {
|
||
for _, index := range imageIndexes {
|
||
if index != firstIndex {
|
||
lastIndex = index
|
||
break
|
||
}
|
||
}
|
||
}
|
||
if firstIndex == lastIndex {
|
||
return imageIndexes[0], imageIndexes[1]
|
||
}
|
||
return firstIndex, lastIndex
|
||
}
|
||
|
||
type videoInputCapabilityValue struct {
|
||
modelType string
|
||
capability map[string]any
|
||
}
|
||
|
||
func firstVideoInputCapability(modelCapability map[string]any, modelType string) (string, map[string]any) {
|
||
for _, candidate := range videoInputCapabilityCandidates(modelCapability, modelType) {
|
||
return candidate.modelType, candidate.capability
|
||
}
|
||
return "", nil
|
||
}
|
||
|
||
func videoInputCapabilityCandidates(modelCapability map[string]any, modelType string) []videoInputCapabilityValue {
|
||
keys := []string{modelType, "image_to_video", "video_first_last_frame"}
|
||
if modelType == "omni_video" || modelType == "omni" {
|
||
keys = append(keys, "omni_video", "omni")
|
||
}
|
||
seen := map[string]bool{}
|
||
out := make([]videoInputCapabilityValue, 0, len(keys))
|
||
for _, key := range keys {
|
||
key = strings.TrimSpace(key)
|
||
if key == "" || seen[key] {
|
||
continue
|
||
}
|
||
seen[key] = true
|
||
if capability := capabilityForType(modelCapability, key); capability != nil {
|
||
out = append(out, videoInputCapabilityValue{modelType: key, capability: capability})
|
||
}
|
||
}
|
||
return out
|
||
}
|
||
|
||
func supportsReferenceImage(modelCapability map[string]any, modelType string) bool {
|
||
candidates := videoInputCapabilityCandidates(modelCapability, modelType)
|
||
if len(candidates) == 0 {
|
||
return true
|
||
}
|
||
for _, candidate := range candidates {
|
||
capability := candidate.capability
|
||
_, hasSingle := capability["input_reference_generate_single"]
|
||
_, hasMultiple := capability["input_reference_generate_multiple"]
|
||
if hasSingle || hasMultiple {
|
||
if boolFromAny(capability["input_reference_generate_single"]) || boolFromAny(capability["input_reference_generate_multiple"]) {
|
||
return true
|
||
}
|
||
continue
|
||
}
|
||
if value, ok := numericField(capability, "max_images"); ok {
|
||
if value > 1 {
|
||
return true
|
||
}
|
||
continue
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
|
||
func supportsFirstFrame(modelCapability map[string]any, modelType string) bool {
|
||
for _, candidate := range videoInputCapabilityCandidates(modelCapability, modelType) {
|
||
capability := candidate.capability
|
||
if boolFromAny(capability["input_first_frame"]) ||
|
||
boolFromAny(capability["input_first_last_frame"]) ||
|
||
floatFromAny(capability["max_images_for_first_frame"]) > 0 ||
|
||
floatFromAny(capability["max_images_for_last_frame"]) > 0 {
|
||
return true
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
|
||
func supportsFirstAndLastFrame(modelCapability map[string]any, modelType string) bool {
|
||
for _, candidate := range videoInputCapabilityCandidates(modelCapability, modelType) {
|
||
capability := candidate.capability
|
||
if boolFromAny(capability["input_first_last_frame"]) || floatFromAny(capability["max_images_for_last_frame"]) > 0 {
|
||
return true
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
|
||
func videoModeKey(params map[string]any) string {
|
||
content := contentItems(params["content"])
|
||
hasFirstFrame := false
|
||
hasLastFrame := false
|
||
for _, item := range content {
|
||
switch stringFromAny(item["role"]) {
|
||
case "first_frame":
|
||
hasFirstFrame = true
|
||
case "last_frame":
|
||
hasLastFrame = true
|
||
}
|
||
}
|
||
switch {
|
||
case hasFirstFrame && hasLastFrame:
|
||
return "input_first_last_frame"
|
||
case hasFirstFrame:
|
||
return "input_first_frame"
|
||
case hasLastFrame:
|
||
return "input_last_frame"
|
||
default:
|
||
return ""
|
||
}
|
||
}
|
||
|
||
func syncDurationSeconds(params map[string]any) {
|
||
if params["duration_seconds"] != nil {
|
||
params["duration_seconds"] = params["duration"]
|
||
}
|
||
}
|
||
|
||
func syncVideoConvenienceFields(params map[string]any, content []map[string]any, context *paramProcessContext) {
|
||
hasVideo := false
|
||
hasAudio := false
|
||
for _, item := range content {
|
||
hasVideo = hasVideo || isVideoContent(item)
|
||
hasAudio = hasAudio || isAudioContent(item)
|
||
}
|
||
if !hasVideo {
|
||
path, value := omniCapabilityEvidence(context, "supported_modes")
|
||
deleteFieldsWithLog(params, context, "ContentFilterProcessor", []string{"video", "video_url", "videoUrl", "reference_video", "referenceVideo"}, "对应视频 content 已被模型能力过滤，移除视频参考快捷字段。", path, value)
|
||
}
|
||
if !hasAudio {
|
||
path, value := omniCapabilityEvidence(context, "input_audio")
|
||
deleteFieldsWithLog(params, context, "ContentFilterProcessor", []string{"audio_url", "audioUrl", "reference_audio", "referenceAudio"}, "对应音频 content 已被模型能力过滤，移除音频参考快捷字段。", path, mergeMetrics(map[string]any{"input_audio": value}, omniCapabilityBundle(context, "max_audios")))
|
||
}
|
||
}
|
||
|
||
func deleteFieldsWithLog(params map[string]any, context *paramProcessContext, processor string, keys []string, reason string, capabilityPath string, capabilityValue any) {
|
||
for _, key := range keys {
|
||
if before, ok := params[key]; ok {
|
||
delete(params, key)
|
||
context.recordChange(processor, "remove", key, before, nil, reason, capabilityPath, capabilityValue)
|
||
}
|
||
}
|
||
}
|
||
|
||
func appendParamWarning(params map[string]any, warning string) {
|
||
warnings, _ := params["_param_warnings"].([]any)
|
||
for _, item := range warnings {
|
||
if stringFromAny(item) == warning {
|
||
return
|
||
}
|
||
}
|
||
params["_param_warnings"] = append(warnings, warning)
|
||
}
|
||
|
||
func filterContent(content []map[string]any, keep func(map[string]any) bool) []map[string]any {
|
||
out := make([]map[string]any, 0, len(content))
|
||
for _, item := range content {
|
||
if keep(item) {
|
||
out = append(out, item)
|
||
}
|
||
}
|
||
return out
|
||
}
|