([\s\S]*?)
`)
+ matches := re.FindAllStringSubmatch(htmlContent, -1)
+ for _, match := range matches {
+ if len(match) > 1 {
+ // 清理空内容
+ trimmed := strings.TrimSpace(match[1])
+ if trimmed != "" {
+ contents = append(contents, trimmed)
+ }
+ }
+ }
+ // 兜底：如果没有匹配到结构化内容，按换行/分隔符拆分
+ if len(contents) == 0 {
+ contents = strings.Split(htmlContent, "===分隔符===") // 提示词中可新增此兜底规则
+ }
+ return contents
+}
+
+// GetAllImgSrcFromHtml 先把提取img src的工具方法放在外面
+func GetAllImgSrcFromHtml(html string) []string {
+ var imgSrcList []string
+ re := regexp.MustCompile(` 包裹，3、主标题使用 ，4、章节标题使用
，4、章节标题使用 ，5、正文段落使用
，6、列表使用
- ...
包裹（序号从1开始），10、每条文案内部必须在最上方添加一行固定格式：
需要配图：N 张
N 是这条文案需要的图片数量，只能是数字，不能是其他文字，11、只输出 HTML 结构，不输出任何额外文字" - - mapTaskResult, err := GetModelResult(ctx, nodeInput.Global.SessionId, nodeInput, skillName, form, userForm) - if err != nil { - return nil, err - } - if g.IsEmpty(mapTaskResult) { - return nil, fmt.Errorf("生成内容为空") - } - - outputRes := make([]node.NodeFormField, 0) - for _, item := range mapTaskResult { - for k, v := range item { - // 拆分多条文案 - contentList := SplitMultiContents(gconv.String(v)) - for i, contentItem := range contentList { - if nodeInput.Config.IsSaveFile { - // 1. 构建html文本 - plainText := BuildText(contentItem) - // 2. 上传纯文本到 OSS - textFileName := fmt.Sprintf("ai_text_%d_%d.inc", time.Now().UnixMilli(), i) - var textUrl *dto.UploadFileBytesRes - textUrl, err = Upload(ctx, &dto.UploadFileBytesReq{ - FileBytes: []byte(plainText), - FileName: textFileName, - }) - if err != nil { - return nil, err - } - // 3. 把纯文本地址存入输出 - outputRes = append(outputRes, node.NodeFormField{ - Field: fmt.Sprintf("text_url:%v:%d", k, i), - Value: textUrl.FileURL, - Label: fmt.Sprintf("text_url:%v:%d", k, i), - Type: "string", - Expand: ExtractImageCount(contentItem), - }) - } - outputRes = append(outputRes, node.NodeFormField{ - Field: fmt.Sprintf("text_content:%v:%d", k, i), - Value: contentItem, - Label: fmt.Sprintf("文案内容%v:%d", k, i), - Type: "string", - Expand: ExtractImageCount(gconv.String(v)), - }) - } - } - } - return outputRes, nil -} - -func ImgNode(ctx context.Context, nodeInput *flowDto.NodeExecutionInput, skillName string, form []map[string]any, userForm []map[string]any) ([]node.NodeFormField, error) { - mapTaskResult, err := GetModelResult(ctx, nodeInput.Global.SessionId, nodeInput, skillName, form, userForm) - if err != nil { - return nil, err - } - if g.IsEmpty(mapTaskResult) { - return nil, fmt.Errorf("生成内容为空") - } - outputRes := make([]node.NodeFormField, 0) - for i, item := range mapTaskResult { - for k, v := range item { - if nodeInput.Config.IsSaveFile { - outputRes = append(outputRes, node.NodeFormField{ - Field: fmt.Sprintf("img_oss_url:%v:%d", k, i), - Value: v, - Label: fmt.Sprintf("img_oss_url%v:%d", k, i), - Type: "string", - }) - } - outputRes = append(outputRes, node.NodeFormField{ - Field: fmt.Sprintf("img_url:%v:%d", k, i), - Value: v, - Label: fmt.Sprintf("图片内容%v:%d", k, i), - Type: "string", - }) - } - } - - //var resultContent []string - //for _, item := range mapTaskResult { - // for _, i := range gconv.Strings(item[modelInfo.Model.ResponseBody]) { - // resultContent = append(resultContent, i) - // } - //} - //var images []string - //for _, item := range resultContent { - // mapItem := gconv.Map(item) - // for _, value := range mapItem { - // values, ok := value.(string) - // if !ok { - // return nil, fmt.Errorf("图片地址类型错误") - // } - // // 下载官方临时图片 - // var imgBytes []byte - // imgBytes, err = GetFileBytesFromURL(ctx, values) - // if err != nil { - // return nil, fmt.Errorf("下载图片失败: %w", err) - // } - // // 构造文件名 - // fileName := fmt.Sprintf("ai_image_%d.png", time.Now().UnixMilli()) - // // 上传到你的OSS（你项目已有的Upload方法） - // var upResp *dto.UploadFileBytesRes - // upResp, err = Upload(ctx, &dto.UploadFileBytesReq{ - // FileName: fileName, - // FileBytes: imgBytes, - // }) - // if err != nil { - // return nil, fmt.Errorf("上传OSS失败: %w", err) - // } - // images = append(images, upResp.FileURL) - // } - //} - // - //var url string - //url, err = utils.GetFileAddressPrefix(ctx) - //if err != nil { - // return nil, err - //} - //outputRes := make([]node.NodeFormField, 0) - // - //for i, item := range images { - // // 额外存储关联关系 - // outputRes = append(outputRes, node.NodeFormField{ - // Field: fmt.Sprintf("img_url:%d", i), - // Value: fmt.Sprintf("%s%s", url, item), - // Label: fmt.Sprintf("图片路径:%d", i), - // Type: "string", - // }) - //} - - return outputRes, nil -} - -func AudioOptimizeNode(ctx context.Context, nodeInput *flowDto.NodeExecutionInput, skillName string, form []map[string]any, userForm []map[string]any) ([]node.NodeFormField, error) { - mapTaskResult, err := GetModelResult(ctx, "", nodeInput, skillName, form, userForm) - if err != nil { - return nil, err - } - if g.IsEmpty(mapTaskResult) { - return nil, fmt.Errorf("生成内容为空") - } - outputRes := make([]node.NodeFormField, 0) - for i, item := range mapTaskResult { - for k, v := range item { - if nodeInput.Config.IsSaveFile { - outputRes = append(outputRes, node.NodeFormField{ - Field: fmt.Sprintf("audio_oss_url:%v:%d", k, i), - Value: v, - Label: fmt.Sprintf("audio_oss_url:%v:%d", k, i), - Type: "string", - }) - } - if k == "sentences" { - a := new([]flowDto.Sentence) - err = gconv.Structs(v, a) - v, err = BuildSubtitles(a) - if err != nil { - return nil, err - } - } - outputRes = append(outputRes, node.NodeFormField{ - Field: fmt.Sprintf("audio_url:%v:%d", k, i), - Value: v, - Label: fmt.Sprintf("音频内容:%v:%d", k, i), - Type: "string", - }) - } - } - - return outputRes, nil -} - -func splitTextByPunct(raw string) []string { - // 按标点切分+拼接标点 - slice := regexp.MustCompile(`([，。；！？])`).Split(raw, -1) - var res []string - var builder strings.Builder - for idx, s := range slice { - if s == "" { - continue - } - builder.WriteString(s) - // 偶数位是分隔标点（split后规律：文本、标点、文本、标点...） - if idx%2 == 1 { - res = append(res, builder.String()) - builder.Reset() - } - } - if builder.Len() > 0 { - res = append(res, builder.String()) - } - return res -} - -// BuildSubtitles 核心工具：单个sentence生成多条subtitle -func BuildSubtitles(sents *[]flowDto.Sentence) ([]flowDto.Subtitle, error) { - var subtitles []flowDto.Subtitle - for _, sent := range *sents { - segList := splitTextByPunct(sent.Text) - if len(segList) == 0 { - return nil, nil - } - - var subs []flowDto.Subtitle - wordIdx := 0 - allWords := sent.Words - - for _, seg := range segList { - var collectWords []flowDto.Word - currentText := "" - // 循环取 word，直到拼接内容 包含/匹配 seg - for { - if wordIdx >= len(allWords) { - break - } - word := allWords[wordIdx] - currentText += word.Word - collectWords = append(collectWords, word) - wordIdx++ - - // 只要包含分段文本，就认为匹配（无视末尾标点差异） - if strings.Contains(currentText, seg) { - break - } - } - if len(collectWords) == 0 { - continue - } - // 生成字幕 - sub := flowDto.Subtitle{ - Start: collectWords[0].StartTime, - End: collectWords[len(collectWords)-1].EndTime, - Text: seg, - } - subs = append(subs, sub) - } - subtitles = append(subtitles, subs...) - } - - return subtitles, nil -} - -func VideoOptimizeNode(ctx context.Context, nodeInput *flowDto.NodeExecutionInput, skillName string, form []map[string]any, userForm []map[string]any) ([]node.NodeFormField, error) { - mapTaskResult, err := GetModelResult(ctx, nodeInput.Global.SessionId, nodeInput, skillName, form, userForm) - if err != nil { - return nil, err - } - if g.IsEmpty(mapTaskResult) { - return nil, fmt.Errorf("生成内容为空") - } - outputRes := make([]node.NodeFormField, 0) - for i, item := range mapTaskResult { - for k, v := range item { - outputRes = append(outputRes, node.NodeFormField{ - Field: fmt.Sprintf("video_url:%v:%d", k, i), - Value: v, - Label: fmt.Sprintf("video_url:%v:%d", k, i), - Type: "string", - }) - } - } - return outputRes, nil -} - -func DataConversionNode(ctx context.Context, nodeInput *flowDto.NodeExecutionInput, skillName string, form []map[string]any, userForm []map[string]any) ([]node.NodeFormField, error) { - jsonStr := `` - jsonVal := "输出字段规范：" - for _, field := range nodeInput.Config.OutputConfig { - jsonStr, _ = sjson.Set(jsonStr, field.Field, "") - jsonVal += fmt.Sprintf("%s:%s;", field.Field, field.Value) - } - jsonVal += fmt.Sprintf("输出模板结构,仅修改每个字段对应数值：%s", jsonStr) - nodeInput.Config.PromptContent = fmt.Sprintf("%s;%s", nodeInput.Config.PromptContent, jsonVal) - - mapTaskResult, err := GetModelResult(ctx, "", nodeInput, skillName, form, userForm) - if err != nil { - return nil, err - } - if g.IsEmpty(mapTaskResult) { - return nil, fmt.Errorf("生成内容为空") - } - outputRes := make([]node.NodeFormField, 0) - for i, item := range mapTaskResult { - for k, v := range item { - outputRes = append(outputRes, node.NodeFormField{ - Field: fmt.Sprintf("data_conversion:%v:%d", k, i), - Value: v, - Label: fmt.Sprintf("data_conversion:%v:%d", k, i), - Type: "string", - }) - } - } - return outputRes, nil -} - -func HttpNode(ctx context.Context, nodeInput *flowDto.NodeExecutionInput) ([]node.NodeFormField, error) { - var method, url, responseType, callbackUrl string - var headers map[string]string - var body map[string]any - var responseMapping map[string]any - for _, item := range nodeInput.Config.FormConfig { - switch item.Field { - case "method": - method = gconv.String(item.Value) - case "url": - url = gconv.String(item.Value) - case "headers": - headers = gconv.MapStrStr(item.Value) - case "body": - body = gconv.Map(item.Value) - case "response": - responseMapping = gconv.Map(item.Value) - case "responseType": - responseType = gconv.String(item.Value) - case "callbackUrl": - callbackUrl = gconv.String(item.Value) - } - } - - if method == "" { - return nil, fmt.Errorf("method为空") - } - if url == "" { - return nil, fmt.Errorf("url为空") - } - - if headers == nil { - headers = make(map[string]string) - if r := g.RequestFromCtx(ctx); r != nil { - for k, v := range r.Request.Header { - if len(v) > 0 { - headers[k] = v[0] - } - } - } - } - - // 构建请求参数 - newBody := BuildNestedJson(body, nodeInput.Global.ConfigMap) - // 1. 自己生成唯一 taskId（不用前端给） - taskId := "my_task_" + uuid.New().String() // 自己生成唯一ID - if responseType == "callback" { - newBody[callbackUrl] = utils.GetCallbackURL(ctx, "/httpNodeCallback?task_id="+taskId) - } - // ====================== 核心改动 ====================== - // 1. 定义一个空map接收原始HTTP返回结果 - var rawHttpResult map[string]any - // 2. 发送请求（不变） - var err error - if method == "GET" { - err = commonHttp.Get(ctx, url, headers, &rawHttpResult, newBody) - } else if method == "POST" { - err = commonHttp.Post(ctx, url, headers, &rawHttpResult, newBody) - } else if method == "PUT" { - err = commonHttp.Put(ctx, url, headers, &rawHttpResult, newBody) - } else if method == "DELETE" { - err = commonHttp.Delete(ctx, url, headers, &rawHttpResult, newBody) - } else { - return nil, fmt.Errorf("method 不支持") - } - if err != nil { - return nil, err - } - - finalResult := make(map[string]any) - if responseType == "sync" { - httpResultJson := gconv.String(rawHttpResult) - for key, jsonPath := range responseMapping { - path := gconv.String(jsonPath) - if !g.IsEmpty(gjson.Get(httpResultJson, path).Value()) { - finalResult[key] = gjson.Get(httpResultJson, path).Value() - } - } - } - if responseType == "callback" { - var waitResult any - waitResult, err = Wait(ctx, taskId) - if err != nil { - return nil, err - } - request, ok := waitResult.(*ghttp.Request) - if !ok { - return nil, fmt.Errorf("入参类型错误") - } - - bodyStr := request.GetBodyString() - for key, jsonPath := range responseMapping { - path := gconv.String(jsonPath) - val := gjson.Get(bodyStr, path) - // 如果是数组，直接返回整个数组 - if val.IsArray() { - finalResult[key] = val.Value() - } else { - // 普通值，非空才赋值 - if !g.IsEmpty(val.Value()) { - finalResult[key] = val.Value() - } - } - } - } - if responseType == "pull" { - - } - - outputRes := make([]node.NodeFormField, 0) - for i, item := range finalResult { - if nodeInput.Config.IsSaveFile { - outputRes = append(outputRes, node.NodeFormField{ - Field: fmt.Sprintf("http_file_url:%v", i), - Value: item, - Label: fmt.Sprintf("http_file_url:%v", i), - Type: "string", - }) - } - outputRes = append(outputRes, node.NodeFormField{ - Field: fmt.Sprintf("%v", i), - Value: item, - Label: fmt.Sprintf("%v", i), - Type: "string", - }) - } - - return outputRes, nil -} - -func BuildParam(nodeInput *flowDto.NodeExecutionInput) (skillName string, resultFrom []map[string]any, resultUserFrom []map[string]any) { - inputMap, outputMap, modelMap := GetNodeContextContent(nodeInput.Global, nodeInput.Config) - var outputResult []node.NodeFormField - outputResult = append(outputResult, inputMap...) - - resultUserFrom = []map[string]any{} - for _, field := range outputMap { - if !strings.Contains(field.Field, "text_url") && !strings.Contains(field.Field, "img_url") { - if strings.Contains(field.Field, "text_content") { - field.Value = StripHtmlTags(gconv.String(field.Value)) - } - resultUserFrom = append(resultUserFrom, map[string]any{ - field.Label: field.Value, - }) - } - } - for _, valueAny := range modelMap { - if field, ok := valueAny.(node.NodeFormField); ok { - outputResult = append(outputResult, field) - } - } - if !nodeInput.Global.IsDialogue { - for _, item := range outputResult { - resultUserFrom = append(resultUserFrom, map[string]any{ - item.Label: item.Value, - }) - } - } - if !g.IsEmpty(nodeInput.Global.Desc) { - resultUserFrom = append(resultUserFrom, map[string]any{ - "desc": nodeInput.Global.Desc, - }) - } - - resultFrom = []map[string]any{} - for _, item := range nodeInput.Config.ModelConfig.ModelForm { - if g.IsEmpty(item.Value) { - continue - } - resultFrom = append(resultFrom, map[string]any{ - item.Label: item.Value, - }) - } - skillName = nodeInput.Config.SkillName - if g.IsEmpty(nodeInput.Config.SkillName) { - skillName = nodeInput.Global.SkillName - } - - return skillName, resultFrom, resultUserFrom -} - -func GetNodeContextContent(execInput *flowDto.FlowExecutionInput, nodeEntity *entity.FlowNode) ([]node.NodeFormField, []node.NodeFormField, map[string]any) { - var input []node.NodeFormField - var output []node.NodeFormField - model := make(map[string]any) - if len(nodeEntity.InputSource) > 0 { - for _, source := range nodeEntity.InputSource { - refNode, ok := execInput.ConfigMap[source.NodeId] - if !ok { - continue - } - if len(source.Field) > 0 { - // 取指定字段 - for _, f := range source.Field { - for _, v := range refNode.FormConfig { - if strings.Contains(v.Label, f) { - input = append(input, v) - } - } - for _, v := range refNode.ModelConfig.ModelForm { - if g.IsEmpty(v.Value) { - continue - } - if strings.Contains(v.Label, f) { - model[f] = v - } - } - for _, v := range refNode.OutputResult { - if strings.Contains(v.Label, f) { - output = append(output, v) - } - } - } - } - } - } - return input, output, model -} diff --git a/workflow/service/flow/lambda_node_util.go b/workflow/service/flow/lambda_node_util.go index 923dc08..3686ba7 100644 --- a/workflow/service/flow/lambda_node_util.go +++ b/workflow/service/flow/lambda_node_util.go @@ -1,31 +1,19 @@ package flow import ( + "ai-agent/gateway" "ai-agent/workflow/consts/node" - nodeDao "ai-agent/workflow/dao/node" - "ai-agent/workflow/model/dto" flowDto "ai-agent/workflow/model/dto/flow" - nodeDto "ai-agent/workflow/model/dto/node" - "ai-agent/workflow/model/entity" - "bytes" "context" "fmt" - "io" - "mime/multipart" - "net/http" - "net/url" - "path/filepath" - "regexp" - "strconv" - "strings" "sync" commonHttp "gitea.redpowerfuture.com/red-future/common/http" "gitea.redpowerfuture.com/red-future/common/utils" - "github.com/gogf/gf/v2/errors/gerror" "github.com/gogf/gf/v2/frame/g" + "github.com/gogf/gf/v2/net/ghttp" "github.com/gogf/gf/v2/util/gconv" - "github.com/tidwall/sjson" + "github.com/google/uuid" ) // 全局等待任务回调的工具 @@ -69,804 +57,155 @@ func Notify(taskId string, result any) { delete(asyncTasks, taskId) } -func GetIsChatModel(ctx context.Context) (res *flowDto.GetIsChatModelRes, err error) { - headers := make(map[string]string) - if r := g.RequestFromCtx(ctx); r != nil { - for k, v := range r.Request.Header { - if len(v) > 0 { - headers[k] = v[0] - } - } +// ModelCallResultLambda 调用模型并返回输出内容列表，同时回传本次调用的 token/费用（*gateway.ModelCallRes）， +// 供调用方（ModelLambda）累计写入节点执行记录 token_info，最后由汇总节点聚合到 exec_workflow。 +func ModelCallResultLambda(ctx context.Context, modelId int64, sessionId string, modelRequestParams map[string]any) ([]map[string]any, *gateway.ModelCallRes, error) { + modelInfo, err := gateway.GetModelInfoById(ctx, &gateway.GetModelInfoByIdReq{ModelId: modelId}) + if err != nil { + return nil, nil, fmt.Errorf("获取模型配置失败: %w", err) } - res = new(flowDto.GetIsChatModelRes) - err = commonHttp.Get(ctx, "model-gateway/model/getIsChatModel", headers, res, nil) - return -} - -func GetModelInfo(ctx context.Context, req *flowDto.GetModelInfoReq) (res *flowDto.GetModelInfoRes, err error) { - headers := make(map[string]string) - if r := g.RequestFromCtx(ctx); r != nil { - for k, v := range r.Request.Header { - if len(v) > 0 { - headers[k] = v[0] - } - } + // 异步模型 msgTopic 由 gateway.ModelCallResult 在为空时自动生成（唯一、带业务标识），调用方无需管理 + responseParams, err := gateway.ModelCallResult(ctx, modelId, modelInfo.ModelManage.ResponseType, sessionId, modelRequestParams, nil) + if err != nil { + return nil, nil, err } - res = new(flowDto.GetModelInfoRes) - err = commonHttp.Get(ctx, "model-gateway/model/getModel", headers, res, req) - return -} - -func GetComposeResult(ctx context.Context, buildType int, modelName, promptContent, skillName string, form []map[string]any, userForm []map[string]any, fileUrl []string, sessionId, nodeId string, cause string) (res *flowDto.ComposeCallbackReq, err error) { - if !g.IsEmpty(promptContent) { - userForm = append(userForm, map[string]any{ - "prompt": promptContent, + if g.IsEmpty(responseParams) { + return nil, nil, fmt.Errorf("生成内容为空") + } + outputRes := make([]map[string]any, 0) + for key, val := range responseParams.Content { + outputRes = append(outputRes, map[string]any{ + key: val, }) } - var callbackUrl = utils.GetCallbackURL(ctx, "/flow/execution/composeCallBack") - var consult = make([]flowDto.Consult, 0) - var collectFileUrls func(val any) (fullyConsumed bool) - collectFileUrls = func(val any) (fullyConsumed bool) { - switch { - case g.NewVar(val).IsSlice(): - slice := gconv.SliceAny(val) - allConsumed := false - for _, item := range slice { - if collectFileUrls(item) { - allConsumed = true - } + return outputRes, responseParams, nil +} + +func HttpCallResultLambda(ctx context.Context, nodeInput *flowDto.NodeExecutionInput) ([]map[string]any, error) { + var method, url, responseType, callbackUrl string + var headers map[string]string + var body map[string]any + var responseMapping map[string]any + + n := new([]node.NodePresetField) + err := gconv.Structs(nodeInput.Config.OutputConfig, n) + if err != nil { + return nil, err + } + + for _, item := range *n { + switch item.Field { + case "method": + method = gconv.String(item.Value) + case "url": + url = gconv.String(item.Value) + case "headers": + headers = gconv.MapStrStr(item.Value) + case "body": + body = gconv.Map(item.Value) + case "response": + // 先剥掉 {type, value/attrs} 包裹层，得到干净的输出结构模板 + responseMapping = gconv.Map(UnwrapSchemaWrapper(gconv.Map(item.Value))) + case "responseType": + responseType = gconv.String(item.Value) + if responseType == "callback" { + callbackUrl = item.Options[0].Config[0].Value } - return allConsumed - case g.NewVar(val).IsMap(): - m := gconv.Map(val) - allConsumed := false - for _, item := range m { - if collectFileUrls(item) { - allConsumed = true - } - } - return allConsumed - default: - s := gconv.String(val) - if s != "" { - getFileTypeByPath := GetFileTypeByPath(s) - if getFileTypeByPath != "" { - consult = append(consult, flowDto.Consult{ - Type: getFileTypeByPath, - Url: s, - }) - return true - } - } - return false } } - var newUserForm []map[string]any - for _, m := range userForm { - for k, v := range m { - if collectFileUrls(v) { - delete(m, k) + + if method == "" { + return nil, fmt.Errorf("method为空") + } + if url == "" { + return nil, fmt.Errorf("url为空") + } + + if headers == nil { + headers = make(map[string]string) + if r := g.RequestFromCtx(ctx); r != nil { + for k, v := range r.Request.Header { + if len(v) > 0 { + headers[k] = v[0] + } } } - if len(m) > 0 { - newUserForm = append(newUserForm, m) - } } - for _, v := range fileUrl { - getFileTypeByPath := GetFileTypeByPath(gconv.String(v)) - if getFileTypeByPath != "" { - consult = append(consult, flowDto.Consult{ - Type: getFileTypeByPath, - Url: gconv.String(v), + + // 构建请求参数 + ProcessValueSourceRecursive(body, nodeInput.Global) + // 递归剥掉 {type, value/attrs} 包裹层，只保留 key/value + wrapper := UnwrapSchemaWrapper(body) + newBody := gconv.Map(wrapper) + + // 1. 自己生成唯一 taskId（不用前端给） + taskId := "my_task_" + uuid.New().String() // 自己生成唯一ID + if responseType == "callback" { + newBody[callbackUrl] = utils.GetCallbackURL(ctx, "/httpNodeCallback?task_id="+taskId) + } + // ====================== 核心改动 ====================== + // 1. 定义一个空map接收原始HTTP返回结果 + var rawHttpResult map[string]any + // 2. 发送请求（不变） + if method == "GET" { + err = commonHttp.Get(ctx, url, headers, &rawHttpResult, newBody) + } else if method == "POST" { + err = commonHttp.Post(ctx, url, headers, &rawHttpResult, newBody) + } else if method == "PUT" { + err = commonHttp.Put(ctx, url, headers, &rawHttpResult, newBody) + } else if method == "DELETE" { + err = commonHttp.Delete(ctx, url, headers, &rawHttpResult, newBody) + } else { + return nil, fmt.Errorf("method 不支持") + } + if err != nil { + return nil, err + } + + var e = "" + + finalResult := make(map[string]any) + if responseType == "sync" { + httpResultJson := gconv.String(rawHttpResult) + // 按 responseMapping 定义的结构，从 http 返回结果中拷贝对应字段 + finalResult = MapResultByTemplate(responseMapping, rawHttpResult) + e = httpResultJson + } + if responseType == "callback" { + var waitResult any + waitResult, err = Wait(ctx, taskId) + if err != nil { + return nil, err + } + request, ok := waitResult.(*ghttp.Request) + if !ok { + return nil, fmt.Errorf("入参类型错误") + } + + bodyStr := request.GetBodyString() + // 按 responseMapping 定义的结构，从回调结果中拷贝对应字段 + finalResult = MapResultByTemplate(responseMapping, gconv.Map(bodyStr)) + e = bodyStr + } + if responseType == "pull" { + return nil, fmt.Errorf("pull 暂不支持") + } + + if g.IsEmpty(finalResult) { + return nil, fmt.Errorf("http请求异常，返回结果为空：%v", e) + } + + outputRes := make([]map[string]any, 0) + for i, item := range finalResult { + if nodeInput.Config.IsSaveFile { + outputRes = append(outputRes, map[string]any{ + fmt.Sprintf("http_file_url:%v", i): item, }) } + outputRes = append(outputRes, map[string]any{ + fmt.Sprintf("%v", i): item, + }) } - msgReq := flowDto.ComposeMessagesReq{ - BuildType: buildType, - ModelName: modelName, - SkillName: skillName, - CallbackUrl: callbackUrl, - Cause: cause, - Form: form, - UserForm: newUserForm, - Consult: consult, - SessionId: sessionId, - NodeId: nodeId, - } - headers := make(map[string]string) - if r := g.RequestFromCtx(ctx); r != nil { - for k, v := range r.Request.Header { - if len(v) > 0 { - headers[k] = v[0] - } - } - } - msgRes := new(flowDto.ComposeMessagesRes) - err = commonHttp.Post(ctx, "prompts-core/prompt/composeMessages", headers, msgRes, &msgReq) - if err != nil { - return - } - if g.IsEmpty(msgRes.TaskId) { - return nil, fmt.Errorf("msg is empty") - } - waitRes, err := Wait(ctx, msgRes.TaskId) - if err != nil { - return nil, err - } - msg := new(flowDto.ComposeCallbackReq) - if err = gconv.Struct(waitRes, msg); err != nil { - return nil, err - } - if !g.IsEmpty(msg.ErrorMsg) { - return nil, fmt.Errorf(msg.ErrorMsg) - } - return msg, nil -} -func CreateGatewayTask(ctx context.Context, epicycleId int64, model string, content map[string]any) (map[string]any, error) { - taskId, err := createGatewayTaskOnly(ctx, epicycleId, model, content) - if err != nil { - return nil, err - } - return waitGatewayResult(ctx, taskId) -} - -// createGatewayTaskOnly creates a gateway task and returns the taskId only -// doesn't wait for completion -func createGatewayTaskOnly(ctx context.Context, epicycleId int64, model string, content map[string]any) (string, error) { - callbackUrl := utils.GetCallbackURL(ctx, "/flow/execution/modelCallback") - req := flowDto.ModelGatewayReq{ - ModelName: model, - BizName: g.Cfg().MustGet(ctx, "server.name").String(), - CallbackUrl: callbackUrl, - RequestPayload: content, - EpicycleId: epicycleId, - } - - headers := make(map[string]string) - if r := g.RequestFromCtx(ctx); r != nil { - for k, v := range r.Request.Header { - if len(v) > 0 { - headers[k] = v[0] - } - } - } - - res := new(flowDto.ModelGatewayRes) - err := commonHttp.Post(ctx, "model-gateway/task/createTask", headers, res, &req) - if err != nil { - return "", err - } - if g.IsEmpty(res.TaskId) { - return "", fmt.Errorf("创建模型任务失败，taskId为空") - } - - return res.TaskId, nil -} - -// waitGatewayResult waits for a created gateway task to complete and returns the result -func waitGatewayResult(ctx context.Context, taskId string) (map[string]any, error) { - waitRes, err := Wait(ctx, taskId) - if err != nil { - return nil, err - } - - task := new(flowDto.ModelCallbackReq) - if err = gconv.Struct(waitRes, task); err != nil { - return nil, err - } - if task.State == 3 || !g.IsEmpty(task.ErrorMsg) { - return nil, fmt.Errorf("模型执行失败：%s", task.ErrorMsg) - } - if g.IsEmpty(task.OssFile) { - return nil, fmt.Errorf("模型返回结果为空") - } - // 获取远程文件内容 - file, err := GetFileBytesFromURL(ctx, task.OssFile) - if err != nil { - return nil, err - } - return gconv.Map(file), nil -} - -// updateTokenCount updates the token count in node execution -func updateTokenCount(ctx context.Context, nodeExecutionId int64, responseField string, result map[string]any) { - if responseField == "" { - return - } - _, _ = nodeDao.NodeExecutionDao.Update(ctx, &nodeDto.UpdateNodeExecutionReq{ - Id: nodeExecutionId, - CompletionTokens: gconv.Int(result[responseField]), - TotalTokens: gconv.Int(result[responseField]), - }) -} - -func GetModelResult(ctx context.Context, sessionId string, nodeInput *flowDto.NodeExecutionInput, skillName string, form []map[string]any, userForm []map[string]any) (mapTaskResult []map[string]any, err error) { - buildType := 1 - if nodeInput.Config.NodeCode == node.NodeTypeDataConversionModel { - buildType = 3 - } - - if !nodeInput.Global.IsDialogue { - sessionId = "" - } - - composeResult, err := GetComposeResult(ctx, buildType, nodeInput.Config.ModelConfig.ModelName, nodeInput.Config.PromptContent, skillName, form, userForm, nodeInput.Global.FileUrl, sessionId, nodeInput.Config.Id, nodeInput.Config.Name) - if err != nil { - return nil, err - } - if composeResult.Status != "success" { - return nil, fmt.Errorf("模型提示词构建错误") - } - - modelInfo, err := GetModelInfo(ctx, &flowDto.GetModelInfoReq{ModelName: nodeInput.Config.ModelConfig.ModelName}) - if err != nil { - return nil, err - } - - mapTaskResult = make([]map[string]any, len(composeResult.Messages.Rounds)) - var taskResultMap map[string]any - - needSequential := false - if buildType == 1 { - if needSequential { - for idx, item := range composeResult.Messages.Rounds { - if !g.IsEmpty(taskResultMap) { - var set string - set, err = sjson.Set(gconv.String(item), modelInfo.Model.LastFrame, gconv.String(taskResultMap[modelInfo.Model.ResponseBody])) - if err != nil { - return nil, err - } - item = gconv.Map(set) - } - - var taskResult map[string]any - taskResult, err = CreateGatewayTask(ctx, composeResult.EpicycleId, nodeInput.Config.ModelConfig.ModelName, item) - if err != nil { - return nil, err - } - if g.IsEmpty(taskResult) { - return nil, fmt.Errorf("模型返回结果为空") - } - - if nodeInput.Config.NodeCode == node.NodeTypeVideoModel { - ext := GetFileTypeByPath(gconv.String(taskResult[modelInfo.Model.ResponseBody])) - if ext == "image" { - taskResultMap = taskResult - } else { - taskResultMap = make(map[string]any) - } - } else { - taskResultMap = make(map[string]any) - } - - mapTaskResult[idx] = taskResult - updateTokenCount(ctx, nodeInput.NodeExecutionId, modelInfo.Model.ResponseTokenField, taskResult) - } - } else { - taskIdList := make([]string, len(composeResult.Messages.Rounds)) - - for idx, item := range composeResult.Messages.Rounds { - taskId, err := createGatewayTaskOnly(ctx, composeResult.EpicycleId, nodeInput.Config.ModelConfig.ModelName, item) - if err != nil { - return nil, err - } - taskIdList[idx] = taskId - } - - // 全局共享子上下文，实现一处报错全部终止 - subCtx, globalCancel := context.WithCancel(ctx) - defer globalCancel() // 函数退出兜底释放 - - var wg sync.WaitGroup - errChan := make(chan error, len(taskIdList)) - - // 加互斥锁保护结果map - var mu sync.Mutex - - for idx, taskId := range taskIdList { - wg.Add(1) - - go func(idx int, taskId string) { - defer wg.Done() - - taskResult, err := waitGatewayResult(subCtx, taskId) - if err != nil { - errChan <- err - globalCancel() // 全局取消，所有协程收到ctx取消信号快速退出 - return - } - - // 加锁写入map，解决并发竞态 - mu.Lock() - mapTaskResult[idx] = taskResult - mu.Unlock() - - updateTokenCount(ctx, nodeInput.NodeExecutionId, modelInfo.Model.ResponseTokenField, taskResult) - }(idx, taskId) - } - - wg.Wait() - close(errChan) - - // 收集全部错误，而非只读一条 - var errs []error - for len(errChan) > 0 { - errs = append(errs, <-errChan) - } - - if len(errs) > 0 { - // 返回第一个错误；如需汇总所有错误可拼接 - return nil, errs[0] - } - } - } else { - for idx, item := range composeResult.Messages.Rounds { - mapTaskResult[idx] = item - updateTokenCount(ctx, nodeInput.NodeExecutionId, modelInfo.Model.ResponseTokenField, item) - } - } - - return mapTaskResult, nil -} - -func BuildNestedJson(body g.Map, mockConfigMap map[string]*entity.FlowNode) g.Map { - jsonStr := "{}" - for originKey, originItem := range body { - bodyItemMap := gconv.Map(originItem) - val := bodyItemMap["value"] - if v, ok := bodyItemMap["value"]; ok { - jsonStr, _ = sjson.Set(jsonStr, originKey, v) - } - // 判断 value 是不是引用结构（map） - if g.NewVar(val).IsMap() { - valMap := gconv.Map(val) - nodeId := gconv.String(valMap["nodeId"]) - fieldName := gconv.String(valMap["field"]) - if configValue, ok := mockConfigMap[nodeId]; ok { - if !g.IsEmpty(configValue.OutputResult) { - for _, v := range configValue.OutputResult { - if strings.Contains(v.Field, fieldName) { - if configValue.NodeCode == node.NodeTypeDataConversionModel { - switch { - case g.NewVar(v.Value).IsSlice() || g.NewVar(v.Value).IsMap(): - // 核心：自动判断两种结构，精准赋值 - vm := gconv.Map(v.Value) - // 先判断是否是 单个key包裹的对象（如 {"subtitle_style": {...}}） - if len(vm) == 1 { - // 遍历取出唯一的 key 和 真实值 - for innerKey, innerVal := range vm { - // 直接用 innerKey（subtitle_style）赋值 - jsonStr, _ = sjson.Set(jsonStr, innerKey, innerVal) - } - } else { - // 直接是对象，用 originKey 赋值 - jsonStr, _ = sjson.Set(jsonStr, originKey, v.Value) - } - default: - jsonStr, _ = sjson.Set(jsonStr, originKey, v.Value) - } - } else { - jsonStr, _ = sjson.Set(jsonStr, originKey, v.Value) - } - } - } - } - if !g.IsEmpty(configValue.FormConfig) { - for _, v := range configValue.FormConfig { - if v.Field == fieldName { - if v.Type == "uploadMultiple" { - if g.NewVar(v.FieldConstraint).IsMap() { - mapFieldConstraint := gconv.Map(v.FieldConstraint) - for key, value := range mapFieldConstraint { - if key == "maxFileCount" { - if gconv.Int(value) == 1 { - // 如果是单文件上传，则替换成字符串重新赋值给v.Value - if g.NewVar(v.Value).IsSlice() { - sliceVal := gconv.SliceAny(v.Value) - if len(sliceVal) > 0 { - v.Value = sliceVal[0] - } - } - } - } - } - } - } - jsonStr, _ = sjson.Set(jsonStr, originKey, v.Value) - } - } - } - } - } - } - return gconv.Map(jsonStr) -} - -func VideoConcat(ctx context.Context, videoUrls []string) (r any, err error) { - var httpUrl = "media/video/concat/async" - headers := make(map[string]string) - if r := g.RequestFromCtx(ctx); r != nil { - for k, v := range r.Request.Header { - if len(v) > 0 { - headers[k] = v[0] - } - } - } - var callbackUrl = utils.GetCallbackURL(ctx, "/flow/execution/videoCallback") - var newBody = flowDto.VideoConcatReq{ - VideoUrls: videoUrls, - Method: "auto", - Upload: true, - CallbackUrl: callbackUrl, - } - res := new(flowDto.VideoConcatRes) - err = commonHttp.Post(ctx, httpUrl, headers, &res, newBody) - if err != nil { - return nil, err - } - return Wait(ctx, res.TaskId) -} - -func GetFileBytesFromURL(ctx context.Context, fileUrl string) ([]byte, error) { - newS := strings.ReplaceAll(fileUrl, g.Cfg().MustGet(ctx, "filePrefix").String(), g.Cfg().MustGet(ctx, "minioPrefix").String()) - // 使用 GoFrame 客户端（自带超时、追踪、日志等能力） - resp, err := g.Client().Get(ctx, newS) - if err != nil { - return nil, gerror.Wrapf(err, "failed to request url: %s", newS) - } - defer resp.Close() - - // 校验状态码 - if resp.StatusCode != http.StatusOK { - return nil, gerror.Newf("request failed with status code: %d, url: %s", resp.StatusCode, newS) - } - - // 读取全部内容 - allBytes, err := io.ReadAll(resp.Body) - if err != nil { - return nil, gerror.Wrapf(err, "failed to read response body, url: %s", fileUrl) - } - - return allBytes, nil -} - -func Upload(ctx context.Context, req *dto.UploadFileBytesReq) (*dto.UploadFileBytesRes, error) { - body := &bytes.Buffer{} - writer := multipart.NewWriter(body) - - part, err := writer.CreateFormFile("file", req.FileName) - if err != nil { - return nil, err - } - if _, err = part.Write(req.FileBytes); err != nil { - return nil, err - } - if err = writer.Close(); err != nil { - return nil, err - } - - headers := make(map[string]string) - headers["Content-Type"] = writer.FormDataContentType() - if r := g.RequestFromCtx(ctx); r != nil { - if auth := r.Header.Get("Authorization"); auth != "" { - headers["Authorization"] = auth - } - } - - // 发起上传请求 - res := &dto.UploadFileBytesRes{} - httpUrl := "oss/file/uploadFile" - if err = commonHttp.Post(ctx, httpUrl, headers, res, body.Bytes()); err != nil { - return nil, err - } - - g.Log().Infof(ctx, "[Upload] success url=%s size=%d", res.FileURL, res.FileSize) - return res, nil -} - -func GetFileTypeByPath(filePath string) string { - if filePath == "" { - return "" - } - - // 解析 URL，获取真实路径（兼容 http 链接） - u, err := url.Parse(filePath) - if err == nil { - filePath = u.Path - } - - // 获取后缀（小写） - ext := filepath.Ext(filePath) - ext = strings.ToLower(ext) - - // 判断类型 - switch ext { - case ".jpg", ".jpeg", ".png", ".gif", ".bmp", ".webp": - return "image" - case ".mp4", ".mov", ".avi", ".flv", ".wmv", ".mkv": - return "video" - case ".mp3", ".wav", ".m4a", ".flac", ".aac", ".ogg": - return "audio" - case ".txt", ".md", ".log", ".json", ".xml", ".inc": - return "text" - case ".html": - return "html" - case ".pdf", ".doc", ".docx", ".xls", ".xlsx", ".ppt", ".pptx": - return "document" - default: - return "" - } -} - -func BuildText(text string) string { - // 生成单条HTML - var htmlBuilder strings.Builder - htmlBuilder.WriteString(` - - - - - - - - -
-
-
-`)
-
- return htmlBuilder.String()
-}
-
-func BuildHtml(text string, images []string) string {
- var htmlBuilder strings.Builder
- htmlBuilder.WriteString(`
-
-
-
-
-
-
-
-
-`)
- // 🔥 写入文案前：删除
- 需要配图：X 张
- if text != "" { - // 写入清理后的文案 - htmlBuilder.WriteString(fmt.Sprintf(`%s
`, ImageTagRegex(text)))
- }
- htmlBuilder.WriteString(`
-`)
- // 写入图片（支持0张、1张、多张）
- if len(images) > 0 {
- htmlBuilder.WriteString(`
-
-
-
-`)
-
- return htmlBuilder.String()
-}
-
-// ExtractImageCount 修复：支持单引号/双引号 + 换行 + 空格
-func ExtractImageCount(content string) int {
- // 🔥 关键：支持 class='image-count' （单引号）
- re := regexp.MustCompile(``)
- for _, imgUrl := range images {
- htmlBuilder.WriteString(fmt.Sprintf(`
`, imgUrl))
- }
- htmlBuilder.WriteString(`
`)
- }
- htmlBuilder.WriteString(`
-加载中...
- ]*>.*?(\d+).*?
`) - match := re.FindStringSubmatch(content) - if len(match) >= 2 { - num, err := strconv.Atoi(match[1]) - if err == nil { - return num - } - } - return 0 -} - -func ImageTagRegex(html string) string { - // 🔥 修复：支持单引号、双引号、空格、换行，100% 删除- imageTagRegex := regexp.MustCompile(`
]*>[\s\S]*?
`) - return imageTagRegex.ReplaceAllString(html, "") -} - -// StripHtmlTags 去掉所有HTML标签，保留换行和文本结构，并删除配图标记行 -func StripHtmlTags(html string) string { - // 1. 替换块级标签为换行，保证排版 - blockTags := regexp.MustCompile(`]*>`) - text := blockTags.ReplaceAllString(html, "\n") - - // 2. 去掉所有剩余的 HTML 标签 - allTags := regexp.MustCompile(`<[^>]+>`) - text = allTags.ReplaceAllString(text, "") - - // 4. 清理多余空行（多个换行只保留一个） - text = regexp.MustCompile(`\n\s*\n`).ReplaceAllString(text, "\n") - - // 5. 只去掉首尾空白，中间换行保留 - text = strings.TrimSpace(text) - - return text -} - -// SplitMultiContents 拆分模型返回的多条文案（基于HTML标签分隔） -func SplitMultiContents(htmlContent string) []string { - var contents []string - // 正则匹配包裹的内容
- re := regexp.MustCompile(`]*src\s*=\s*["']([^"']+)["']`)
- submatch := re.FindAllStringSubmatch(html, -1)
- for _, match := range submatch {
- if len(match) >= 2 {
- imgSrcList = append(imgSrcList, match[1])
- }
- }
- return imgSrcList
-}
-
-// ReplaceImgSrc 替换img src的方法
-func ReplaceImgSrc(html string, oldSrc string, newSrc string) string {
- // 精准替换：找到 
- re := regexp.MustCompile(`(]*src\s*=\s*["'])` + regexp.QuoteMeta(oldSrc) + `(["'])`)
- return re.ReplaceAllString(html, `${1}`+newSrc+`${2}`)
+ return outputRes, nil
}
diff --git a/workflow/service/flow/lambda_script_transcribe.go b/workflow/service/flow/lambda_script_transcribe.go
new file mode 100644
index 0000000..8ad5c45
--- /dev/null
+++ b/workflow/service/flow/lambda_script_transcribe.go
@@ -0,0 +1,309 @@
+package flow
+
+import (
+ "ai-agent/workflow/consts/node"
+ "ai-agent/workflow/service/flow/processor"
+ "ai-agent/workflow/service/flow/processor/builtin/split_shots_pipeline"
+ "context"
+ "encoding/json"
+ "fmt"
+ "strings"
+
+ "ai-agent/gateway"
+ flowDto "ai-agent/workflow/model/dto/flow"
+ "ai-agent/workflow/service/flow/processor/builtin/split_shots_pipeline/pipeline"
+
+ "github.com/gogf/gf/v2/frame/g"
+ "github.com/gogf/gf/v2/util/gconv"
+)
+
+// 脚本转写节点默认系统提示词（字段与 domain.Shot 的 JSON tag 对齐，结构化输出与 content 兜底两条路径一致）
+const defaultScriptTranscribeSystemPrompt = `你是短剧分镜脚本师。请根据提供的文案/视频分析结果，把内容拆分为连续的分镜镜头脚本。
+每个镜头输出一个 JSON 对象，字段固定为：
+- index：镜头序号（数字）
+- startTime：开始时间，格式 MM:SS
+- endTime：结束时间，格式 MM:SS
+- event：事件描述/动作描写
+- narration：旁白/画外音，没有则省略
+- dialogue：角色开口说的主台词，没有则省略
+- ambientSound：环境音，没有则省略
+- cameraMovement：运镜描述
+- shotSize：景别
+- characters：出演人物名列表（字符串数组）
+- scene：场景名
+- props：道具名列表（字符串数组）
+时间码需前后衔接、覆盖整个内容时长。直接输出 JSON 数组，不要输出其他文字。`
+
+// ScriptTranscribeLambda 脚本转写节点：
+// 把节点输入（文案/视频分析结果，经 valueSource 解析）通过大模型转写为固定结构的 []domain.Shot，
+// 产出为 [{"shots": [...]}]，供视频生成节点的 ModelRequestParams.shots 引用。
+func ScriptTranscribeLambda(ctx context.Context, input any) (any, error) {
+ nodeInput, ok := input.(*flowDto.NodeExecutionInput)
+ if !ok {
+ return nil, fmt.Errorf("入参类型错误")
+ }
+
+ n := new([]node.NodePresetField)
+ err := gconv.Structs(nodeInput.Config.OutputConfig, n)
+ if err != nil {
+ return nil, err
+ }
+ var totalDuration int
+ var modelId int64
+ for _, item := range *n {
+ switch item.Field {
+ case "totalDuration":
+ totalDuration = gconv.Int(item.Value)
+ case "modelId":
+ modelId = gconv.Int64(item.Value)
+ }
+ }
+
+ // 1. 解析 valueSource 引用，填充节点输入
+ ProcessValueSourceRecursive(nodeInput.Config.ModelConfig.ModelRequestParams, nodeInput.Global)
+
+ // 2. 构建系统提示词 + 用户输入
+ systemPrompt := nodeInput.Config.Prompt
+ if systemPrompt == "" {
+ systemPrompt = defaultScriptTranscribeSystemPrompt
+ }
+ // 参考素材名单注入：转写模型只从名单选名，保证镜头里的角色/场景/道具名与参考素材精确一致
+ // （名字绑定/类别推断都依赖名字对上）
+ refsName, refsItem := pipeline.ExtractRefs(nodeInput.Config.ModelConfig.ModelRequestParams)
+ if len(refsName) > 0 {
+ systemPrompt += "\n\n参考素材名单：" + strings.Join(refsName, "、") +
+ "\n约束：镜头里的 characters/scene/props 必须原样使用名单中的名字，不得改写、不得加修饰（如“主角小明”）、不得造新名；名单外的名字按原文输出。"
+ }
+ if totalDuration > 0 {
+ systemPrompt += fmt.Sprintf("\n\n视频总时长 %d 秒（MM:SS 为 %s）：所有镜头的时间码需前后衔接并完整覆盖该总时长，最后一镜的 endTime 对齐到总时长。", totalDuration, formatSecondsToMMSS(totalDuration))
+ }
+ // 单镜头时长上限约束：按视频模型推导单段最大时长注入转写提示词，从源头避免超长镜头
+ //（SplitOversized 仍是机械兜底）；推导失败仅降级跳过约束注入，不影响转写主流程。
+ if maxSeg, _, err := split_shots_pipeline.SegmentBounds(ctx, modelId); err != nil {
+ g.Log().Warningf(ctx, "获取视频模型单段时长约束失败，跳过单镜时长约束注入: %v", err)
+ } else {
+ systemPrompt += shotDurationConstraintPrompt(maxSeg)
+ }
+
+ info, err := gateway.GetModelInfoById(ctx, &gateway.GetModelInfoByIdReq{ModelId: nodeInput.Config.ModelConfig.ModelId})
+ if err != nil {
+ return nil, err
+ }
+ params := map[string]any{
+ "system_prompt": systemPrompt,
+ }
+ // 结构化输出：chat 模型映射配置了 response_format（StructuredOutput）即走原生 json_schema 保证结构；
+ // 否则模型 content 直接出 JSON，靠容错解析兜底
+ val, ok := info.ModelManage.RequestBusinessFieldMapping["response_format"]
+ if ok {
+ if !g.IsEmpty(val) {
+ params["response_format"] = pipeline.ShotsStructuredFormat()
+ }
+ }
+ modelInfo, err := gateway.GetModelInfoById(ctx, &gateway.GetModelInfoByIdReq{ModelId: nodeInput.Config.ModelConfig.ModelId})
+ if err != nil {
+ return "", fmt.Errorf("获取模型配置失败: %w", err)
+ }
+ result, err := gateway.ModelCallResult(ctx, nodeInput.Config.ModelConfig.ModelId, modelInfo.ModelManage.ResponseType, nodeInput.Global.SessionId, nodeInput.Config.ModelConfig.ModelRequestParams, params)
+ if err != nil {
+ return nil, err
+ }
+
+ var content string
+ for _, v := range gconv.Map(result.Content) {
+ content += v.(string)
+ }
+ // 4. 解析镜头数组（兼容英文键结构化输出与中文键 content 兜底）
+ shots, err := unmarshalShots(content)
+ if err != nil {
+ return nil, err
+ }
+
+ // 5. 产出固定结构 {"shots": [...]}
+ var arr []any
+ if b, err := json.Marshal(shots); err == nil {
+ _ = json.Unmarshal(b, &arr)
+ }
+
+ args := split_shots_pipeline.SplitShotsInput{
+ ModelID: modelId,
+ Shots: shots,
+ TotalDuration: totalDuration,
+ FlatRefs: refsItem,
+ Seed: nodeInput.Global.ExecutionId % 1000000,
+ NegativePrompt: nodeInput.Config.NegativePrompt,
+ }
+ data, err := processor.Call(ctx, "split_shots_pipeline", gconv.Map(args))
+ if err != nil {
+ return nil, err
+ }
+ nodeInput.Config.OutputResult = gconv.Maps(data)
+ return nodeInput, nil
+}
+
+// unmarshalShots 解析镜头数组 JSON，容忍 markdown 代码围栏、json_schema 结构化输出的 {"shots":[...]} 包装，
+// 以及模型按中文键输出（时间码/事件/台词旁白/景别/运镜/出演角色/场景/道具）的容错映射。
+func unmarshalShots(s string) ([]pipeline.Shot, error) {
+ s = strings.TrimSpace(s)
+ if strings.HasPrefix(s, "```") {
+ s = strings.TrimPrefix(s, "```json")
+ s = strings.TrimPrefix(s, "```")
+ s = strings.TrimSuffix(s, "```")
+ s = strings.TrimSpace(s)
+ }
+ var raw []map[string]any
+ if err := json.Unmarshal([]byte(s), &raw); err == nil && len(raw) > 0 {
+ return parseShots(raw)
+ }
+ var wrapped struct {
+ Shots []map[string]any `json:"shots"`
+ }
+ if err := json.Unmarshal([]byte(s), &wrapped); err == nil && len(wrapped.Shots) > 0 {
+ return parseShots(wrapped.Shots)
+ }
+ return nil, fmt.Errorf("解析分镜脚本失败: %v", s)
+}
+
+// parseShots 把原始镜头对象数组归一为 domain.Shot，跳过没有内容字段的镜头。
+func parseShots(raw []map[string]any) ([]pipeline.Shot, error) {
+ shots := make([]pipeline.Shot, 0, len(raw))
+ for i, m := range raw {
+ shot := shotFromMap(m)
+ if shot.Index == 0 {
+ shot.Index = i + 1
+ }
+ if isEmptyShot(shot) {
+ continue
+ }
+ shots = append(shots, shot)
+ }
+ if len(shots) == 0 {
+ return nil, fmt.Errorf("解析分镜脚本失败: 镜头内容为空")
+ }
+ return shots, nil
+}
+
+// isEmptyShot 镜头是否没有可用内容（仅有时间码/序号，或字段名对不上导致全空）。
+func isEmptyShot(s pipeline.Shot) bool {
+ return s.Event == "" && s.Dialogue == "" && s.Narration == "" && s.AmbientSound == "" &&
+ s.CameraMovement == "" && s.ShotSize == "" && s.Scene == "" &&
+ len(s.Characters) == 0 && len(s.Props) == 0
+}
+
+// shotFromMap 把单个镜头对象映射为 domain.Shot，兼容英文键（结构化输出）与中文键（提示词兜底输出）。
+func shotFromMap(m map[string]any) pipeline.Shot {
+ get := func(keys ...string) string {
+ for _, k := range keys {
+ switch v := m[k].(type) {
+ case string:
+ if t := strings.TrimSpace(v); t != "" {
+ return t
+ }
+ case float64:
+ return gconv.String(v)
+ }
+ }
+ return ""
+ }
+ getSlice := func(keys ...string) []string {
+ for _, k := range keys {
+ switch v := m[k].(type) {
+ case []any:
+ var out []string
+ for _, e := range v {
+ if t, ok := e.(string); ok && strings.TrimSpace(t) != "" {
+ out = append(out, strings.TrimSpace(t))
+ }
+ }
+ if len(out) > 0 {
+ return out
+ }
+ case string:
+ if out := splitList(v); len(out) > 0 {
+ return out
+ }
+ }
+ }
+ return nil
+ }
+
+ shot := pipeline.Shot{
+ Index: gconv.Int(m["index"]),
+ StartTime: get("startTime", "开始时间"),
+ EndTime: get("endTime", "结束时间"),
+ Event: get("event", "事件"),
+ Dialogue: get("dialogue", "台词"),
+ Narration: get("narration", "旁白"),
+ AmbientSound: get("ambientSound", "环境音"),
+ CameraMovement: get("cameraMovement", "运镜"),
+ ShotSize: get("shotSize", "景别"),
+ Scene: get("scene", "场景"),
+ Characters: getSlice("characters", "出演角色"),
+ Props: getSlice("props", "道具"),
+ }
+ if shot.StartTime == "" && shot.EndTime == "" {
+ shot.StartTime, shot.EndTime = splitTimeRange(get("时间码"))
+ }
+ if shot.Dialogue == "" && shot.Narration == "" {
+ shot.Dialogue, shot.Narration = splitDialogueNarration(get("台词/旁白"))
+ }
+ return shot
+}
+
+// formatSecondsToMMSS 秒转 MM:SS 时间码。
+func formatSecondsToMMSS(sec int) string {
+ if sec < 0 {
+ sec = 0
+ }
+ return fmt.Sprintf("%02d:%02d", sec/60, sec%60)
+}
+
+// splitTimeRange 解析时间码 "MM:SS-MM:SS"（兼容 "—"/"~"/"到" 等分隔，或单个时间点）。
+func splitTimeRange(s string) (start, end string) {
+ if s == "" {
+ return "", ""
+ }
+ normalized := strings.NewReplacer("—", "-", "–", "-", "～", "-", "~", "-", "到", "-", "至", "-").Replace(s)
+ parts := strings.Split(normalized, "-")
+ start = strings.TrimSpace(parts[0])
+ if len(parts) > 1 {
+ end = strings.TrimSpace(parts[1])
+ } else {
+ end = start
+ }
+ return start, end
+}
+
+// splitDialogueNarration 把"台词/旁白"合字段拆成 dialogue 与 narration：
+// 以"旁白"/"画外音"开头的内容归为旁白，其余视为角色开口的主台词。
+func splitDialogueNarration(s string) (dialogue, narration string) {
+ s = strings.TrimSpace(s)
+ switch {
+ case strings.HasPrefix(s, "旁白"):
+ return "", strings.TrimSpace(strings.TrimLeft(strings.TrimPrefix(s, "旁白"), "：:"))
+ case strings.HasPrefix(s, "画外音"):
+ return "", strings.TrimSpace(strings.TrimLeft(strings.TrimPrefix(s, "画外音"), "：:"))
+ default:
+ return s, ""
+ }
+}
+
+// splitList 按常见分隔符拆分人名/道具列表（兼容中英文顿号、逗号、分号、"和""及"等）。
+func splitList(s string) []string {
+ repl := strings.NewReplacer("、", "|", "，", "|", ",", "|", "；", "|", ";", "|", "和", "|", "及", "|", "&", "|", "/", "|", " ", "|")
+ var out []string
+ for _, p := range strings.Split(repl.Replace(strings.TrimSpace(s)), "|") {
+ if t := strings.TrimSpace(p); t != "" {
+ out = append(out, t)
+ }
+ }
+ return out
+}
+
+// shotDurationConstraintPrompt 生成"单个镜头时长不超过 maxSeg 秒"的转写约束提示词片段；maxSeg<=0 返回空串。
+func shotDurationConstraintPrompt(maxSeg int) string {
+ if maxSeg <= 0 {
+ return ""
+ }
+ return fmt.Sprintf("\n\n单个镜头时长不超过 %d 秒：每镜的 startTime 与 endTime 之差必须 ≤ %d 秒。", maxSeg, maxSeg)
+}
diff --git a/workflow/service/flow/lambda_value_source.go b/workflow/service/flow/lambda_value_source.go
new file mode 100644
index 0000000..90df922
--- /dev/null
+++ b/workflow/service/flow/lambda_value_source.go
@@ -0,0 +1,287 @@
+package flow
+
+import (
+ "ai-agent/workflow/consts/node"
+ flowDto "ai-agent/workflow/model/dto/flow"
+ "regexp"
+
+ "github.com/gogf/gf/v2/frame/g"
+ "github.com/gogf/gf/v2/util/gconv"
+ "github.com/tidwall/gjson"
+)
+
+var (
+ // 匹配 [数字]
+ regNumIndex = regexp.MustCompile(`\[\d+\]`)
+ // 匹配 .attrs
+ regAttrs = regexp.MustCompile(`\.attrs`)
+)
+
+// CleanFieldPath 清理字段路径：移除 .attrs、数字下标转为 [*]
+// 示例：usage.attrs.total_tokens → usage.total_tokens
+// 示例：choices.attrs[0].attrs.message.attrs.content → choices[*].message.content
+func CleanFieldPath(path string) string {
+ // 1. 替换 [数字] 为 [*]
+ s := regNumIndex.ReplaceAllString(path, `.#`)
+ // 2. 移除所有 .attrs
+ s = regAttrs.ReplaceAllString(s, "")
+ return s
+}
+
+// UnwrapSchemaWrapper 递归剥掉 json-schema-editor 输出的 {type, value/attrs} 包裹层，
+// 只保留干净的 key/value 嵌套结构。
+// 示例：
+//
+// {"a": {"type":"string","value":"hi"}} → {"a": "hi"}
+// {"b": {"type":"object","attrs":{"c":1}}} → {"b": {"c": 1}}
+// {"arr": {"type":"array","attrs":[{"type":"number","value":1}]}} → {"arr": [1]}
+func UnwrapSchemaWrapper(v any) any {
+ switch val := v.(type) {
+ case map[string]any:
+ // 识别包裹节点：{type: "", value/attrs: <实际值>, ...}
+ if t, ok := val["type"].(string); ok && isSchemaEditorType(t) {
+ dataKey := "value"
+ if t == "object" || t == "array" {
+ dataKey = "attrs"
+ }
+ if raw, has := val[dataKey]; has {
+ return UnwrapSchemaWrapper(raw)
+ }
+ }
+ res := make(map[string]any, len(val))
+ for k, child := range val {
+ res[k] = UnwrapSchemaWrapper(child)
+ }
+ return res
+ case []any:
+ res := make([]any, len(val))
+ for i, item := range val {
+ res[i] = UnwrapSchemaWrapper(item)
+ }
+ return res
+ default:
+ return val
+ }
+}
+
+// isSchemaEditorType 是否为 json-schema-editor 的 6 种类型标识
+func isSchemaEditorType(t string) bool {
+ switch t {
+ case "string", "number", "boolean", "null", "object", "array":
+ return true
+ }
+ return false
+}
+
+// MapResultByTemplate 按 template 定义的结构，从 source 中拷贝对应字段的值。
+// 只保留 template 里出现的字段：对象字段按同名字段递归拷贝，标量/数组字段直接拷贝 source 的值。
+func MapResultByTemplate(template map[string]any, source map[string]any) map[string]any {
+ result := make(map[string]any, len(template))
+ for key, tmplVal := range template {
+ srcVal, ok := source[key]
+ if !ok {
+ continue
+ }
+ if tmplMap, isMap := tmplVal.(map[string]any); isMap {
+ if srcMap, isMap := srcVal.(map[string]any); isMap {
+ result[key] = MapResultByTemplate(tmplMap, srcMap)
+ }
+ continue
+ }
+ result[key] = srcVal
+ }
+ return result
+}
+
+// ProcessValueSourceRecursive 递归遍历map，同级同时存在value和valueSource则把value设置为"AA"
+func ProcessValueSourceRecursive(rawParams map[string]interface{}, globalParams *flowDto.FlowExecutionInput) {
+ walkMap(rawParams, globalParams)
+}
+
+// resolveValueSource 解析 valueSource {nodeId, fieldName} 引用的实际值。
+// 返回 (value, refsName, ok)；ok=false 表示引用节点不存在或引用值仍为空。
+// - 开始/表单节点：OutputConfig 平铺条目按 field == fieldName 匹配（前端约定以 field 为主，
+// 不兼容 path），直接读 entry 的 value / refsName
+// - scriptTranscribe 节点：读 OutputResult 的 shots
+// - 其他节点：读 OutputResult 中 fieldName 路径对应的值
+func resolveValueSource(global *flowDto.FlowExecutionInput, nodeId, fieldName string) (value any, refsName any, ok bool) {
+ if global == nil || global.ConfigMap == nil {
+ return nil, nil, false
+ }
+ nodeConfig := global.ConfigMap[nodeId]
+ if nodeConfig == nil {
+ return nil, nil, false
+ }
+ switch nodeConfig.NodeCode {
+ case node.NodeTypeStart, node.NodeTypeForm:
+ for _, output := range nodeConfig.OutputConfig {
+ if gconv.String(output["field"]) != fieldName {
+ continue
+ }
+ if !g.IsEmpty(output["value"]) {
+ return output["value"], output["refsName"], true
+ }
+ }
+ case node.NodeTypeScriptTranscribe:
+ for _, output := range nodeConfig.OutputResult {
+ value := gjson.Get(gconv.String(output), CleanFieldPath("shots")).Value()
+ if !g.IsEmpty(value) {
+ return value, gjson.Get(gconv.String(output), CleanFieldPath("refsName")).Value(), true
+ }
+ }
+ default:
+ for _, output := range nodeConfig.OutputResult {
+ value := gjson.Get(gconv.String(output), CleanFieldPath(fieldName)).Value()
+ if !g.IsEmpty(value) {
+ return value, gjson.Get(gconv.String(output), CleanFieldPath("refsName")).Value(), true
+ }
+ }
+ }
+ return nil, nil, false
+}
+
+// walkMap 递归处理map/数组
+func walkMap(data interface{}, globalParams *flowDto.FlowExecutionInput) {
+ switch v := data.(type) {
+ case map[string]interface{}:
+ // 当前对象同时存在 value 和 valueSource
+ if valueSource, hasSource := v["valueSource"]; hasSource {
+ mapValueSource := gconv.Map(valueSource)
+ nodeId := gconv.String(mapValueSource["nodeId"])
+ fieldName := gconv.String(mapValueSource["fieldName"])
+ if fieldName == "" {
+ fieldName = gconv.String(mapValueSource["field"])
+ }
+ if nodeId != "" && fieldName != "" {
+ if value, refsName, ok := resolveValueSource(globalParams, nodeId, fieldName); ok {
+ v["value"] = value
+ if !g.IsEmpty(refsName) {
+ v["refsName"] = refsName
+ }
+ return
+ }
+ }
+ }
+ // 递归遍历所有子元素
+ for _, child := range v {
+ walkMap(child, globalParams)
+ }
+ case []interface{}:
+ // 数组遍历
+ for _, item := range v {
+ walkMap(item, globalParams)
+ }
+ }
+}
+
+// CleanEmptyModelParams 剔除模型请求参数中 value 为空的字段；
+// 数组/枚举（attrs / enumValues）元素整体为空时移除整个元素。0/false 视为有效值。
+func CleanEmptyModelParams(params map[string]interface{}) {
+ cleanSchemaMap(params)
+}
+
+// cleanSchemaMap 递归清理普通 map：包装节点按 schema 语义清理，空字段删除
+func cleanSchemaMap(m map[string]interface{}) {
+ for key, val := range m {
+ switch v := val.(type) {
+ case map[string]interface{}:
+ if isSchemaWrapperNode(v) {
+ cleanSchemaWrapper(v)
+ if isSchemaNodeEmpty(v) {
+ delete(m, key)
+ }
+ } else {
+ cleanSchemaMap(v)
+ }
+ case []interface{}:
+ m[key] = cleanSchemaSlice(v)
+ }
+ }
+}
+
+// cleanSchemaWrapper 清理单个 {type,...} 包装节点：递归 value / attrs / enumValues 容器
+func cleanSchemaWrapper(node map[string]interface{}) {
+ if mv, ok := node["value"].(map[string]interface{}); ok {
+ cleanSchemaMap(mv)
+ }
+ if lv, ok := node["value"].([]interface{}); ok {
+ node["value"] = cleanSchemaSlice(lv)
+ }
+ if attrs, ok := node["attrs"].(map[string]interface{}); ok {
+ cleanSchemaMap(attrs)
+ }
+ if attrs, ok := node["attrs"].([]interface{}); ok {
+ node["attrs"] = cleanSchemaSlice(attrs)
+ }
+ if evs, ok := node["enumValues"].([]interface{}); ok {
+ node["enumValues"] = cleanSchemaSlice(evs)
+ }
+}
+
+// cleanSchemaSlice 清理数组/枚举元素，元素为包装节点且整体为空时移除
+func cleanSchemaSlice(list []interface{}) []interface{} {
+ i := 0
+ for i < len(list) {
+ if item, ok := list[i].(map[string]interface{}); ok {
+ if isSchemaWrapperNode(item) {
+ cleanSchemaWrapper(item)
+ if isSchemaNodeEmpty(item) {
+ list = append(list[:i], list[i+1:]...)
+ continue
+ }
+ } else {
+ cleanSchemaMap(item)
+ }
+ }
+ i++
+ }
+ return list
+}
+
+// isSchemaWrapperNode 是否为 {type: } 包装节点
+func isSchemaWrapperNode(m map[string]interface{}) bool {
+ t, ok := m["type"].(string)
+ return ok && isSchemaEditorType(t)
+}
+
+// isSchemaNodeEmpty 判断 schema 节点是否已无有效内容：
+// 标量看 value（0/false 有效）；object/array 看 value/attrs/enumValues 容器是否都为空
+func isSchemaNodeEmpty(node map[string]interface{}) bool {
+ t, _ := node["type"].(string)
+ switch t {
+ case "object":
+ return schemaContainerEmpty(node, "value") && schemaContainerEmpty(node, "attrs")
+ case "array":
+ return schemaContainerEmpty(node, "value") && schemaContainerEmpty(node, "attrs") && schemaContainerEmpty(node, "enumValues")
+ default:
+ return schemaValueEmpty(node["value"])
+ }
+}
+
+// schemaContainerEmpty 容器（value/attrs/enumValues）是否为空
+func schemaContainerEmpty(node map[string]interface{}, key string) bool {
+ switch v := node[key].(type) {
+ case []interface{}:
+ return len(v) == 0
+ case map[string]interface{}:
+ return len(v) == 0
+ default:
+ return v == nil
+ }
+}
+
+// schemaValueEmpty 值是否为空；0/false 视为有效值不剔除
+func schemaValueEmpty(v interface{}) bool {
+ switch val := v.(type) {
+ case nil:
+ return true
+ case string:
+ return val == ""
+ case []interface{}:
+ return len(val) == 0
+ case map[string]interface{}:
+ return len(val) == 0
+ default:
+ return false
+ }
+}
diff --git a/workflow/service/flow/processor/builtin/media/media.go b/workflow/service/flow/processor/builtin/media/media.go
new file mode 100644
index 0000000..bc65a45
--- /dev/null
+++ b/workflow/service/flow/processor/builtin/media/media.go
@@ -0,0 +1,261 @@
+package video
+
+import (
+ "ai-agent/workflow/service/flow/processor"
+ "context"
+ "fmt"
+ "strings"
+ "time"
+
+ commonHttp "gitea.redpowerfuture.com/red-future/common/http"
+ "github.com/gogf/gf/v2/frame/g"
+ "github.com/gogf/gf/v2/util/gconv"
+)
+
+// TaskKind 媒体任务类型（拼接/拼接+混音），决定提交与查询的接口路径
+type TaskKind string
+
+const (
+ TaskKindConcat TaskKind = "concat" // 纯拼接，无 BGM
+ TaskKindMerge TaskKind = "merge" // 拼接+混音，有 BGM
+)
+
+// MergeTask media 服务异步任务状态
+type MergeTask struct {
+ TaskID string `json:"taskId"`
+ Status string `json:"status"` // pending/running/success/failed
+ FileURL string `json:"fileURL,omitempty"`
+ ErrorMessage string `json:"errorMessage,omitempty"`
+ DurationStr string `json:"durationStr,omitempty"`
+}
+
+type mergeSubmitReq struct {
+ VideoURLs []string `json:"video_urls"`
+ AudioURLs []string `json:"audio_urls,omitempty"`
+ Method string `json:"method,omitempty"`
+ Upload bool `json:"upload"`
+ CallbackURL string `json:"callback_url"`
+}
+
+type mergeSubmitRes struct {
+ TaskID string `json:"taskId"`
+}
+
+func init() {
+ processor.Register(ConcatVideosProcessor())
+}
+
+// ConcatVideosProcessor 合并视频
+func ConcatVideosProcessor() *processor.Processor {
+ return &processor.Processor{
+ Name: "concat_videos",
+ Description: "合并视频",
+ Func: func(ctx context.Context, args map[string]any) (any, error) {
+ outputRes := parseOutputList(args)
+ segments, err := collectSegmentResults(outputRes)
+ if err != nil {
+ return nil, err
+ }
+
+ videoURLs := make([]string, 0, len(segments))
+ for _, seg := range segments {
+ videoURLs = append(videoURLs, seg.VideoURL)
+ }
+
+ reqParams := gconv.Map(args["request"])
+ bgmURLs := gconv.Strings(reqParams["bgm_urls"])
+ if len(bgmURLs) == 0 {
+ // 兼容串行结果把 bgm 带回 output 的情况
+ for _, m := range outputRes {
+ bgmURLs = append(bgmURLs, gconv.Strings(m["bgm_urls"])...)
+ }
+ }
+ upload := gconv.Bool(reqParams["upload"])
+ callback := gconv.String(reqParams["callback_url"])
+
+ merged, err := MergeSegments(ctx, videoURLs, bgmURLs, upload, callback, 30*time.Minute)
+ if err != nil {
+ return nil, err
+ }
+ return map[string]any{
+ "video_url": merged.FileURL,
+ "duration_str": merged.DurationStr,
+ "task_id": merged.TaskID,
+ }, nil
+ },
+ }
+}
+
+// parseOutputList 兼容不同反序列化形态的 output 列表
+func parseOutputList(args map[string]any) []map[string]any {
+ switch v := args["output"].(type) {
+ case []map[string]any:
+ return v
+ case []any:
+ out := make([]map[string]any, 0, len(v))
+ for _, it := range v {
+ if m, ok := it.(map[string]any); ok {
+ out = append(out, m)
+ } else if m := gconv.Map(it); m != nil {
+ out = append(out, m)
+ }
+ }
+ return out
+ }
+ return nil
+}
+
+// MergeSegments 把分段视频按序合并：有 BGM 走拼接+混音（merge），否则纯拼接（concat）。
+// 返回最终合并结果（FileURL）。
+func MergeSegments(ctx context.Context, videoURLs, bgmURLs []string, upload bool, callbackURL string, timeout time.Duration) (*MergeTask, error) {
+ var kind TaskKind
+ var taskID string
+ var err error
+ if len(bgmURLs) > 0 {
+ kind = TaskKindMerge
+ taskID, err = SubmitMergeAsync(ctx, videoURLs, bgmURLs, upload, callbackURL)
+ } else {
+ kind = TaskKindConcat
+ taskID, err = SubmitConcatAsync(ctx, videoURLs, upload, callbackURL)
+ }
+ if err != nil {
+ return nil, err
+ }
+ return WaitMediaTask(ctx, kind, taskID, timeout)
+}
+
+// SubmitConcatAsync 提交纯拼接异步任务
+func SubmitConcatAsync(ctx context.Context, videoURLs []string, upload bool, callbackURL string) (string, error) {
+ return submitMediaTask(ctx, TaskKindConcat, &mergeSubmitReq{
+ VideoURLs: videoURLs,
+ Method: "auto",
+ Upload: upload,
+ CallbackURL: callbackURL,
+ })
+}
+
+// SubmitMergeAsync 提交拼接+混音异步任务
+func SubmitMergeAsync(ctx context.Context, videoURLs, audioURLs []string, upload bool, callbackURL string) (string, error) {
+ return submitMediaTask(ctx, TaskKindMerge, &mergeSubmitReq{
+ VideoURLs: videoURLs,
+ AudioURLs: audioURLs,
+ Upload: upload,
+ CallbackURL: callbackURL,
+ })
+}
+
+func submitMediaTask(ctx context.Context, kind TaskKind, req *mergeSubmitReq) (string, error) {
+ path := "media/video/" + string(kind) + "/async"
+ res := new(mergeSubmitRes)
+ if err := commonHttp.Post(ctx, path, requestHeaders(ctx), res, req); err != nil {
+ return "", fmt.Errorf("提交%s任务失败: %v", kind, err)
+ }
+ if res.TaskID == "" {
+ return "", fmt.Errorf("media 返回空 taskId")
+ }
+ return res.TaskID, nil
+}
+
+// WaitMediaTask 轮询媒体任务直到 success/failed，或超时。
+func WaitMediaTask(ctx context.Context, kind TaskKind, taskID string, timeout time.Duration) (*MergeTask, error) {
+ deadline := time.Now().Add(timeout)
+ ticker := time.NewTicker(15 * time.Second)
+ defer ticker.Stop()
+ for {
+ t, err := getMediaTask(ctx, kind, taskID)
+ if err == nil {
+ switch t.Status {
+ case "success":
+ if t.FileURL == "" {
+ return nil, fmt.Errorf("%s任务成功但未返回文件URL", kind)
+ }
+ return t, nil
+ case "failed":
+ return nil, fmt.Errorf("%s任务失败: %s", kind, t.ErrorMessage)
+ }
+ }
+ if time.Now().After(deadline) {
+ return nil, fmt.Errorf("%s任务[%s]超时", kind, taskID)
+ }
+ select {
+ case <-ctx.Done():
+ return nil, ctx.Err()
+ case <-ticker.C:
+ }
+ }
+}
+
+func getMediaTask(ctx context.Context, kind TaskKind, taskID string) (*MergeTask, error) {
+ path := "media/video/" + string(kind) + "/task/" + taskID
+ res := new(MergeTask)
+ if err := commonHttp.Get(ctx, path, requestHeaders(ctx), res); err != nil {
+ return nil, err
+ }
+ return res, nil
+}
+
+// requestHeaders 透传当前请求头（含 Authorization / X-User-Info），供内部服务鉴权使用
+func requestHeaders(ctx context.Context) map[string]string {
+ headers := make(map[string]string)
+ if r := g.RequestFromCtx(ctx); r != nil {
+ for k, v := range r.Request.Header {
+ if len(v) > 0 {
+ headers[k] = v[0]
+ }
+ }
+ }
+ return headers
+}
+
+// segmentResult 一段视频生成的产出（原 ai-agent/video/plan.SegmentResult，plan 包已并入处理器树）。
+type segmentResult struct {
+ SegmentIndex int `json:"segment_index"`
+ VideoURL string `json:"video_url"`
+ Duration int `json:"duration"`
+}
+
+// collectSegmentResults 把模型节点/串行工具的产出（[]map[string]any）收敛为有序的分段结果列表。
+// 兼容两种形状：串行工具产出的 {segment_index, video_url, duration}；
+// 并行模型调用产出的 {: url}（按列表顺序对应各段）。
+func collectSegmentResults(outputRes []map[string]any) ([]segmentResult, error) {
+ if len(outputRes) == 0 {
+ return nil, fmt.Errorf("没有可合并的分段视频")
+ }
+ var segs []segmentResult
+ for i, m := range outputRes {
+ seg := segmentResult{
+ SegmentIndex: i,
+ Duration: gconv.Int(m["duration"]),
+ VideoURL: findVideoURL(m),
+ }
+ if idx := gconv.Int(m["segment_index"]); len(outputRes) > 1 && idx > 0 {
+ seg.SegmentIndex = idx
+ }
+ if seg.VideoURL == "" {
+ return nil, fmt.Errorf("第 %d 段未获取到视频URL", i)
+ }
+ segs = append(segs, seg)
+ }
+ return segs, nil
+}
+
+// findVideoURL 从模型返回参数中提取视频 URL：优先命中常见键，再兜底任意含 url 的 http 字段。
+func findVideoURL(params map[string]any) string {
+ if params == nil {
+ return ""
+ }
+ for _, key := range []string{"video_url", "video_oss_url", "http_file_url", "file_url", "url"} {
+ if v := gconv.String(params[key]); v != "" {
+ return v
+ }
+ }
+ for k, v := range params {
+ if !strings.Contains(strings.ToLower(k), "url") {
+ continue
+ }
+ if s := gconv.String(v); s != "" && strings.HasPrefix(s, "http") {
+ return s
+ }
+ }
+ return ""
+}
diff --git a/workflow/service/flow/processor/builtin/split_batch/split_batch.go b/workflow/service/flow/processor/builtin/split_batch/split_batch.go
new file mode 100644
index 0000000..466ce59
--- /dev/null
+++ b/workflow/service/flow/processor/builtin/split_batch/split_batch.go
@@ -0,0 +1,207 @@
+// Package split_batch 工作流前置处理器：按各字段 constraint.uploadTotalMaxCount 拆分模型请求参数。
+// 处理器实现自包含（算法随处理器走，不依赖业务包），通过 init 注册进 processor 注册表。
+package split_batch
+
+import (
+ "context"
+ "fmt"
+ "sort"
+
+ "github.com/gogf/gf/v2/util/gconv"
+
+ "ai-agent/workflow/service/flow/processor"
+)
+
+func init() {
+ processor.Register(SplitBatchModelParamsProcessor())
+}
+
+// SplitBatchModelParamsProcessor 将模型请求参数按各字段 constraint.uploadTotalMaxCount 分批的前置处理器。
+// 入参 args 即模型请求参数本体（需已解析好 valueSource，value 已填充）。
+func SplitBatchModelParamsProcessor() *processor.Processor {
+ return &processor.Processor{
+ Name: "split_batch_model_params",
+ Description: "按 constraint.uploadTotalMaxCount 分批模型请求参数",
+ Func: func(ctx context.Context, args map[string]any) (any, error) {
+ if args == nil {
+ return nil, fmt.Errorf("缺少模型请求参数")
+ }
+ return SplitBatchModelParams(args), nil
+ },
+ }
+}
+
+// splitBatchField 描述一个需要按 constraint.uploadTotalMaxCount 分批的字段
+type splitBatchField struct {
+ path []any // 从参数根节点到该字段 value 的路径（map 用 key，数组用下标）
+ items []any // 该字段 value 拆出的待分批元素列表
+ maxCount int // 每批最大元素数（constraint.uploadTotalMaxCount）
+}
+
+// SplitBatchModelParams 把模型请求参数拆成多批，供分批请求模型使用。
+// 处理流程：
+// 1. 深拷贝入参，避免污染调用方数据；
+// 2. 递归解析 valueSource，把引用节点输出的字段值写入对应字段的 value；
+// 3. 找出所有带 constraint.uploadTotalMaxCount 且 value 为集合（map/slice）的字段，
+// map 按 key 排序取 value 列表作为元素；总批数 = 各字段 (元素数/上限) 向上取整的最大值；
+// 4. 每批 = 整份参数深拷贝 + 各分批字段 value 替换为对应切片。
+//
+// 未超量时返回单份（value 已被解析填充）参数。调用方可遍历返回值逐个请求模型。
+func SplitBatchModelParams(rawParams map[string]any) []map[string]any {
+ params, ok := deepCopyAny(rawParams).(map[string]any)
+ if !ok {
+ params = make(map[string]any)
+ }
+
+ fields := make([]splitBatchField, 0)
+ collectBatchFields(params, nil, &fields)
+
+ batchCount := 1
+ for _, f := range fields {
+ n := (len(f.items) + f.maxCount - 1) / f.maxCount
+ if n > batchCount {
+ batchCount = n
+ }
+ }
+ if batchCount <= 1 {
+ return []map[string]any{params}
+ }
+
+ batches := make([]map[string]any, 0, batchCount)
+ for i := 0; i < batchCount; i++ {
+ batch, _ := deepCopyAny(params).(map[string]any)
+ for _, f := range fields {
+ start := i * f.maxCount
+ if start >= len(f.items) {
+ setValueAtPath(batch, f.path, []any{})
+ continue
+ }
+ end := start + f.maxCount
+ if end > len(f.items) {
+ end = len(f.items)
+ }
+ setValueAtPath(batch, f.path, f.items[start:end])
+ }
+ batches = append(batches, batch)
+ }
+ return batches
+}
+
+// collectBatchFields 递归收集所有带 constraint.uploadTotalMaxCount 且 value 为集合的分批字段
+func collectBatchFields(node any, path []any, out *[]splitBatchField) {
+ switch v := node.(type) {
+ case map[string]any:
+ if maxCount, ok := uploadTotalMaxCountOf(v); ok {
+ if items, has := toItems(v["value"]); has {
+ *out = append(*out, splitBatchField{
+ path: append(append([]any{}, path...), "value"),
+ items: items,
+ maxCount: maxCount,
+ })
+ }
+ }
+ for key, child := range v {
+ collectBatchFields(child, append(append([]any{}, path...), key), out)
+ }
+ case []any:
+ for i, child := range v {
+ collectBatchFields(child, append(append([]any{}, path...), i), out)
+ }
+ }
+}
+
+// uploadTotalMaxCountOf 读取 schema 节点 constraint.uploadTotalMaxCount
+func uploadTotalMaxCountOf(m map[string]any) (int, bool) {
+ c, ok := m["constraint"]
+ if !ok {
+ return 0, false
+ }
+ cm := gconv.Map(c)
+ if cm == nil {
+ return 0, false
+ }
+ n := gconv.Int(cm["uploadTotalMaxCount"])
+ if n <= 0 {
+ return 0, false
+ }
+ return n, true
+}
+
+// toItems 把集合 value 转成元素列表：切片原样返回；map 按 key 排序取 value，保证分批顺序稳定
+func toItems(v any) ([]any, bool) {
+ switch val := v.(type) {
+ case []any:
+ return val, len(val) > 0
+ case map[string]any:
+ if len(val) == 0 {
+ return nil, false
+ }
+ keys := make([]string, 0, len(val))
+ for k := range val {
+ keys = append(keys, k)
+ }
+ sort.Strings(keys)
+ items := make([]any, 0, len(keys))
+ for _, k := range keys {
+ items = append(items, val[k])
+ }
+ return items, true
+ }
+ return nil, false
+}
+
+// setValueAtPath 沿 path 逐级导航（map 用 key、数组用下标），在最后一级写入 value
+func setValueAtPath(root map[string]any, path []any, value any) {
+ if len(path) == 0 {
+ return
+ }
+ var cur any = root
+ for i := 0; i < len(path)-1; i++ {
+ switch step := path[i].(type) {
+ case string:
+ m, ok := cur.(map[string]any)
+ if !ok {
+ return
+ }
+ cur = m[step]
+ case int:
+ s, ok := cur.([]any)
+ if !ok || step < 0 || step >= len(s) {
+ return
+ }
+ cur = s[step]
+ default:
+ return
+ }
+ }
+ switch last := path[len(path)-1].(type) {
+ case string:
+ if m, ok := cur.(map[string]any); ok {
+ m[last] = value
+ }
+ case int:
+ if s, ok := cur.([]any); ok && last >= 0 && last < len(s) {
+ s[last] = value
+ }
+ }
+}
+
+// deepCopyAny 深拷贝 map[string]any / []any 嵌套结构，避免批次之间互相影响
+func deepCopyAny(v any) any {
+ switch val := v.(type) {
+ case map[string]any:
+ res := make(map[string]any, len(val))
+ for k, child := range val {
+ res[k] = deepCopyAny(child)
+ }
+ return res
+ case []any:
+ res := make([]any, len(val))
+ for i, child := range val {
+ res[i] = deepCopyAny(child)
+ }
+ return res
+ default:
+ return val
+ }
+}
diff --git a/workflow/service/flow/processor/builtin/split_shots_pipeline/pipeline/errors.go b/workflow/service/flow/processor/builtin/split_shots_pipeline/pipeline/errors.go
new file mode 100644
index 0000000..a2f3c55
--- /dev/null
+++ b/workflow/service/flow/processor/builtin/split_shots_pipeline/pipeline/errors.go
@@ -0,0 +1,29 @@
+package pipeline
+
+import "fmt"
+
+// 业务错误码（设计 §8.1）。上层可据 Code 差异化处理。
+const (
+ ErrEmptyShots = "ERR_EMPTY_SHOTS" // 镜头为空
+ ErrInvalidInput = "ERR_INVALID_INPUT" // 参数非法（TotalDuration/Max/Min 等）
+ ErrSegmentInfeasible = "ERR_SEGMENT_INFEASIBLE" // 时长拆分不可行
+ ErrTimelineInvariant = "ERR_TIMELINE_INVARIANT" // 时间线不变量破坏
+)
+
+// PipelineError 带业务分类码的错误。Segment 关联段序号，-1 表示不特定于某段。
+type PipelineError struct {
+ Code string
+ Message string
+ Segment int
+}
+
+func (e *PipelineError) Error() string {
+ if e.Segment >= 0 {
+ return fmt.Sprintf("[%s] 段%d: %s", e.Code, e.Segment, e.Message)
+ }
+ return fmt.Sprintf("[%s] %s", e.Code, e.Message)
+}
+
+func pipeErr(code, msg string) *PipelineError {
+ return &PipelineError{Code: code, Message: msg, Segment: -1}
+}
diff --git a/workflow/service/flow/processor/builtin/split_shots_pipeline/pipeline/pipeline.go b/workflow/service/flow/processor/builtin/split_shots_pipeline/pipeline/pipeline.go
new file mode 100644
index 0000000..d20c641
--- /dev/null
+++ b/workflow/service/flow/processor/builtin/split_shots_pipeline/pipeline/pipeline.go
@@ -0,0 +1,244 @@
+// Package pipeline 分镜 → 时间线 → 模型语言 Pipeline（设计文档 docs/superpowers/specs/2026-08-11-shots-timeline-pipeline-design.md）。
+//
+// 纯函数包：只依赖 video/domain + 标准库，零 I/O、零 workflow 依赖。
+// 入口 PlanSegments 编排 ①时间线构建 → ②prompt 构建；各阶段函数均可独立调用/单测。
+package pipeline
+
+import (
+ "strconv"
+ "strings"
+)
+
+// Input 外部直接传入的生成请求参数。
+type Input struct {
+ Shots []Shot // 镜头脚本（调用方已归一为 domain.Shot）
+ TotalDuration int // 目标总时长（秒），<=0 按镜头时间码累加兜底，仍<=0 默认 60
+ MaxSegmentDur int // 单段最大时长（秒），<=0 默认 15
+ MinSegmentDur int // 单段最小时长（秒），<=0 默认 5
+ Refs Refs // 参考素材（角色/场景/道具/产品，具名）
+ Seed int64 // 随机种子基数，各段 = Seed + 段序号
+ NegativePrompt string // 全局负面 prompt（单段可覆盖，见 §7.5）
+ Cfg Config // 阈值/语速/容差等统一配置，零值取 DefaultConfig()
+ TokenCfg TokenConfig // 实体名替换 token 的生成配置
+}
+
+// TokenConfig token 前缀策略：按素材媒体类型（视频/图片/音频）分别配置。
+type TokenConfig struct {
+ // 视频素材前缀模板，如 "video%d"。为空用默认前缀 "video" + 独立编号。
+ VideoTemplate string
+ // 图片素材前缀模板，如 "img%d"。为空用默认前缀 "image" + 独立编号。
+ ImageTemplate string
+ // 音频素材前缀模板，如 "audio%d"。为空用默认前缀 "audio" + 独立编号。
+ AudioTemplate string
+}
+
+// Refs 参考素材，与 domain/plan 的 Refs 概念一致（自包含定义，不依赖 plan）。
+type Refs struct {
+ Characters []RefItem `json:"characters,omitempty"`
+ Scenes []RefItem `json:"scenes,omitempty"`
+ Props []RefItem `json:"props,omitempty"`
+ Products []RefItem `json:"products,omitempty"`
+}
+
+// RefItem 一个具名参考素材。Weight 选择权重（缺省按类别 演员4/场景3/道具2/产品1）。
+type RefItem struct {
+ Name string `json:"name"`
+ URL string `json:"url"`
+ Weight int `json:"weight,omitempty"`
+}
+
+// Lookup 按类别和名称查找参考图 URL，未找到返回空串。
+func (r Refs) Lookup(category, name string) string {
+ var list []RefItem
+ switch category {
+ case catCharacter:
+ list = r.Characters
+ case catScene:
+ list = r.Scenes
+ case catProp:
+ list = r.Props
+ case catProduct:
+ list = r.Products
+ }
+ for _, it := range list {
+ if it.Name == name {
+ return it.URL
+ }
+ }
+ return ""
+}
+
+// ExtractRefs 递归收集请求参数中散布的参考素材对象（{refsName: 名称, value: URL}，无固定数组 key）。
+// 返回名称列表（去重保序，供转写提示词注入参考素材名单）与具名素材列表（RefItem{Name,URL}）。
+// 处理器解析与转写节点取素材复用同一入口。
+func ExtractRefs(v any) (names []string, items []RefItem) {
+ seenName := map[string]bool{}
+ seenItem := map[string]bool{}
+ var walk func(any)
+ walk = func(v any) {
+ switch val := v.(type) {
+ case map[string]any:
+ if name := refString(val["refsName"]); name != "" {
+ if !seenName[name] {
+ seenName[name] = true
+ names = append(names, name)
+ }
+ url := refString(val["value"])
+ if url == "" {
+ url = refString(val["url"])
+ }
+ key := name + "\x00" + url
+ if !seenItem[key] {
+ seenItem[key] = true
+ items = append(items, RefItem{Name: name, URL: url})
+ }
+ }
+ for _, child := range val {
+ walk(child)
+ }
+ case []any:
+ for _, item := range val {
+ walk(item)
+ }
+ }
+ }
+ walk(v)
+ return names, items
+}
+
+// refString 从 JSON/gconv 值中取字符串，数字按原样转串（避免 URL 被科学计数法破坏）。
+func refString(v any) string {
+ switch t := v.(type) {
+ case string:
+ return strings.TrimSpace(t)
+ case float64:
+ return strconv.FormatFloat(t, 'f', -1, 64)
+ }
+ return ""
+}
+
+// RefBinding token 与参考素材的显式绑定（设计 P0-4）。
+type RefBinding struct {
+ Token string // "video1"（媒体类型前缀 + 独立编号）
+ Entity string // 原始实体名（归一前）
+ Category string // 演员/场景/道具/产品
+ URL string
+}
+
+// Segment 一个视频生成段：时间轴、段内镜头、prompt、参考素材。
+type Segment struct {
+ Index int // 段序号（从 0 起）
+ StartSec int // 段在全局时间轴上的起点（秒）
+ Duration int // 段时长（秒）
+ Shots []Shot // 段内镜头（已回写对齐，不跨段）
+ Prompt string // 实体名→token 替换后的 prompt 文本
+ Refs []RefBinding // 参考素材显式绑定（token→URL），reference_urls/reference_labels 与 prompt 都由它生成
+ NegativePrompt string // 本段负面 prompt（默认继承 Input.NegativePrompt，可被段内镜头覆盖）
+ Seed int64
+}
+
+const (
+ catCharacter = "演员"
+ catScene = "场景"
+ catProp = "道具"
+ catProduct = "产品"
+)
+
+// NormalizeInput 补齐时长/阈值零值：总时长<=0 按镜头时间码累加兜底（仍<=0 默认 60），
+// MaxSegmentDur<=0 默认 15、MinSegmentDur<=0 默认 5，且 min>max 时收敛 min=max。
+func NormalizeInput(in Input) Input {
+ total := in.TotalDuration
+ if total <= 0 {
+ total = sumShotDurations(in.Shots)
+ }
+ if total <= 0 {
+ total = 60
+ }
+ maxSeg := in.MaxSegmentDur
+ if maxSeg <= 0 {
+ maxSeg = 15
+ }
+ minSeg := in.MinSegmentDur
+ if minSeg <= 0 {
+ minSeg = 5
+ }
+ if minSeg > maxSeg {
+ minSeg = maxSeg
+ }
+ in.TotalDuration = total
+ in.MaxSegmentDur = maxSeg
+ in.MinSegmentDur = minSeg
+ return in
+}
+
+// PlanSegments 编排①时间线构建 → ②prompt 构建（含参考素材绑定），产出各段。
+// 适配层（workflow 前置处理器）产出 FLAT 请求参数、不产嵌套请求体，直接调用本函数。
+func PlanSegments(in Input) ([]Segment, error) {
+ if len(in.Shots) == 0 {
+ return nil, pipeErr(ErrEmptyShots, "镜头为空")
+ }
+ segShots, segDurs, err := BuildTimeline(in)
+ if err != nil {
+ return nil, err
+ }
+
+ var allShots []Shot
+ for _, ss := range segShots {
+ allShots = append(allShots, ss...)
+ }
+ registry := NewTokenRegistry(allShots, in.Refs, in.TokenCfg)
+
+ segs := make([]Segment, 0, len(segShots))
+ startSec := 0
+ for i, ss := range segShots {
+ prompt, segRefs := BuildSegmentPrompt(ss, registry, in)
+ segs = append(segs, Segment{
+ Index: i,
+ StartSec: startSec,
+ Duration: segDurs[i],
+ Shots: ss,
+ Prompt: prompt,
+ Refs: segRefs,
+ NegativePrompt: buildSegmentNegativePrompt(ss, in.NegativePrompt),
+ Seed: in.Seed + int64(i),
+ })
+ startSec += segDurs[i]
+ }
+ return segs, nil
+}
+
+func sumShotDurations(shots []Shot) int {
+ total := 0
+ for _, sh := range shots {
+ total += parseSec(sh.EndTime) - parseSec(sh.StartTime)
+ }
+ return total
+}
+
+// buildSegmentNegativePrompt 按 §7.5 计算本段负面 prompt：
+// 默认继承全局；段内镜头带负面时叠加；镜头负面以 "-" 前缀开头时仅用镜头自身的（抑制全局）。
+func buildSegmentNegativePrompt(shots []Shot, global string) string {
+ var shotNps []string
+ useOnlyShot := false
+ for _, sh := range shots {
+ np := strings.TrimSpace(sh.NegativePrompt)
+ if np == "" {
+ continue
+ }
+ if strings.HasPrefix(np, "-") {
+ shotNps = append(shotNps, strings.TrimPrefix(np, "-"))
+ useOnlyShot = true
+ } else {
+ shotNps = append(shotNps, np)
+ }
+ }
+ if len(shotNps) == 0 {
+ return global
+ }
+ var parts []string
+ if !useOnlyShot && global != "" {
+ parts = append(parts, global)
+ }
+ parts = append(parts, shotNps...)
+ return strings.Join(parts, "\n")
+}
diff --git a/workflow/service/flow/processor/builtin/split_shots_pipeline/pipeline/prompt.go b/workflow/service/flow/processor/builtin/split_shots_pipeline/pipeline/prompt.go
new file mode 100644
index 0000000..e75cdf7
--- /dev/null
+++ b/workflow/service/flow/processor/builtin/split_shots_pipeline/pipeline/prompt.go
@@ -0,0 +1,473 @@
+package pipeline
+
+import (
+ "fmt"
+ "sort"
+ "strconv"
+ "strings"
+ "unicode/utf8"
+)
+
+// ---------- 实体名归一（四审 P0-1）----------
+
+// 素材媒体类型（token 前缀与独立编号基准）。
+const (
+ mediaVideo = "video"
+ mediaImage = "image"
+ mediaAudio = "audio"
+)
+
+// MediaTypeOf 按 URL 扩展名判定素材媒体类型；无法判定返回 ("", false)。
+func MediaTypeOf(url string) (string, bool) {
+ u := url
+ if i := strings.IndexAny(u, "?#"); i >= 0 {
+ u = u[:i]
+ }
+ switch strings.ToLower(pathExt(u)) {
+ case ".mp4", ".mov", ".avi", ".webm", ".mkv":
+ return mediaVideo, true
+ case ".jpg", ".jpeg", ".png", ".gif", ".webp", ".bmp":
+ return mediaImage, true
+ case ".mp3", ".wav", ".ogg", ".aac", ".m4a", ".flac":
+ return mediaAudio, true
+ }
+ return "", false
+}
+
+// pathExt 提取路径最后一段的扩展名（含点），无则返回空串。
+func pathExt(url string) string {
+ for i := len(url) - 1; i >= 0; i-- {
+ if url[i] == '/' {
+ break
+ }
+ if url[i] == '.' {
+ return url[i:]
+ }
+ }
+ return ""
+}
+
+// normalizeEntityName 归一清洗实体名，返回注册表唯一标准名：
+// 去括号注释 → 统一全半角 → 去首尾标点 → 英文小写。
+func normalizeEntityName(name string) string {
+ name = strings.TrimSpace(name)
+ name = toHalfWidth(name)
+ name = stripBrackets(name)
+ name = strings.Trim(name, "。，！？；：、（）【】「」《》…,.!?;:\"'` \t\n\r")
+ return strings.ToLower(name)
+}
+
+// toHalfWidth 全角字母数字/符号转半角，全角空格转半角空格。
+func toHalfWidth(s string) string {
+ var b strings.Builder
+ b.Grow(len(s))
+ for _, r := range s {
+ switch {
+ case r == ' ':
+ b.WriteRune(' ')
+ case r >= '！' && r <= '～':
+ b.WriteRune(r - 0xfee0)
+ default:
+ b.WriteRune(r)
+ }
+ }
+ return b.String()
+}
+
+// stripBrackets 剔除括号注释，如 "小红(女主)" → "小红"。
+func stripBrackets(s string) string {
+ for {
+ next := stripBracketsOnce(s)
+ if next == s {
+ return s
+ }
+ s = next
+ }
+}
+
+var bracketPairs = []struct{ open, close rune }{
+ {'(', ')'}, {'（', '）'}, {'[', ']'}, {'【', '】'}, {'「', '」'}, {'《', '》'},
+}
+
+func stripBracketsOnce(s string) string {
+ rs := []rune(s)
+ for i := 0; i < len(rs); i++ {
+ for _, p := range bracketPairs {
+ if rs[i] != p.open {
+ continue
+ }
+ depth := 1
+ for j := i + 1; j < len(rs); j++ {
+ if rs[j] == p.open {
+ depth++
+ }
+ if rs[j] == p.close {
+ depth--
+ if depth == 0 {
+ out := make([]rune, 0, len(rs)-(j-i+1))
+ out = append(out, rs[:i]...)
+ out = append(out, rs[j+1:]...)
+ return string(out)
+ }
+ }
+ }
+ // 无匹配闭合 → 去掉从此处到末尾
+ return string(rs[:i])
+ }
+ }
+ return s
+}
+
+// ---------- TokenRegistry（全局稳定编号，设计 §6.1 + P2-4）----------
+
+type entity struct {
+ Category string // 演员/场景/道具/产品
+ Canonical string // 归一化标准名（注册表唯一 key 的一部分）
+ Aliases []string // 原始异形体（供文本替换匹配）
+ URL string
+ Weight int
+ MediaType string // 素材媒体类型：video/image/audio（注册时按 URL 判定）
+ order int // 全局首次出现顺序
+}
+
+func entKey(ent *entity) string {
+ return ent.Category + "/" + ent.Canonical
+}
+
+// TokenRegistry 一次执行内的全局 token 注册表：同一实体在所有段使用同一 token。
+type TokenRegistry struct {
+ entities map[string]*entity // key = 类别/标准名
+ order []*entity // 注册顺序（token 编号基准）
+ tokenByKey map[string]string // key → token
+ aliasToToken map[string]string // 原始异形体 → token
+ tc TokenConfig
+ refs Refs
+}
+
+// NewTokenRegistry 遍历全部镜头（+ refs 产品）建立注册表。无 URL 的实体不进注册表（§6.3 保留原名）。
+func NewTokenRegistry(allShots []Shot, refs Refs, tc TokenConfig) *TokenRegistry {
+ reg := &TokenRegistry{
+ entities: map[string]*entity{},
+ tokenByKey: map[string]string{},
+ aliasToToken: map[string]string{},
+ tc: tc,
+ refs: refs,
+ }
+ for _, sh := range allShots {
+ for _, c := range sh.Characters {
+ reg.register(catCharacter, c)
+ }
+ if sh.Scene != "" {
+ reg.register(catScene, sh.Scene)
+ }
+ for _, p := range sh.Props {
+ reg.register(catProp, p)
+ }
+ }
+ // 分析替换业务：产品图常驻注册表
+ for _, p := range refs.Products {
+ reg.register(catProduct, p.Name)
+ }
+ return reg
+}
+
+func (r *TokenRegistry) register(category, raw string) {
+ raw = strings.TrimSpace(raw)
+ if raw == "" {
+ return
+ }
+ canonical := normalizeEntityName(raw)
+ if canonical == "" {
+ return
+ }
+ key := category + "/" + canonical
+ if ent, ok := r.entities[key]; ok {
+ r.recordAlias(ent, raw)
+ return
+ }
+ url := r.refs.Lookup(category, raw)
+ if url == "" {
+ url = r.refs.Lookup(category, canonical)
+ }
+ if url == "" {
+ return
+ }
+ media, ok := MediaTypeOf(url)
+ if !ok {
+ return // 无法判定媒体类型：不进注册表，保留原名
+ }
+ weight := r.weightOf(category, raw)
+ if weight <= 0 {
+ weight = r.weightOf(category, canonical)
+ }
+ ent := &entity{
+ Category: category,
+ Canonical: canonical,
+ URL: url,
+ Weight: weight,
+ MediaType: media,
+ order: len(r.order),
+ }
+ r.entities[key] = ent
+ r.tokenByKey[key] = r.nextToken(ent)
+ r.order = append(r.order, ent)
+ r.recordAlias(ent, raw)
+}
+
+func (r *TokenRegistry) recordAlias(ent *entity, raw string) {
+ for _, a := range ent.Aliases {
+ if a == raw {
+ return
+ }
+ }
+ ent.Aliases = append(ent.Aliases, raw)
+ r.aliasToToken[raw] = r.tokenByKey[entKey(ent)]
+}
+
+func (r *TokenRegistry) nextToken(ent *entity) string {
+ tpl, base := tokenBase(r.tc, ent.MediaType)
+ n := 1
+ for _, e := range r.order {
+ if e.MediaType == ent.MediaType {
+ n++
+ }
+ }
+ if tpl != "" {
+ if strings.Contains(tpl, "%d") {
+ return fmt.Sprintf(tpl, n)
+ }
+ return tpl + strconv.Itoa(n)
+ }
+ return fmt.Sprintf("%s%d", base, n)
+}
+
+// tokenBase 返回该媒体类型的前置模板（可为空）与默认前缀。
+func tokenBase(tc TokenConfig, media string) (tpl, base string) {
+ switch media {
+ case mediaVideo:
+ return tc.VideoTemplate, mediaVideo
+ case mediaImage:
+ return tc.ImageTemplate, mediaImage
+ case mediaAudio:
+ return tc.AudioTemplate, mediaAudio
+ }
+ return "", media
+}
+
+func (r *TokenRegistry) entityFor(category, name string) *entity {
+ canonical := normalizeEntityName(name)
+ if canonical == "" {
+ return nil
+ }
+ return r.entities[category+"/"+canonical]
+}
+
+func (r *TokenRegistry) weightOf(category, name string) int {
+ if it, ok := r.refs.findItem(category, name); ok && it.Weight > 0 {
+ return it.Weight
+ }
+ switch category {
+ case catCharacter:
+ return 4
+ case catScene:
+ return 3
+ case catProp:
+ return 2
+ case catProduct:
+ return 1
+ }
+ return 0
+}
+
+func (r Refs) findItem(category, name string) (RefItem, bool) {
+ var list []RefItem
+ switch category {
+ case catCharacter:
+ list = r.Characters
+ case catScene:
+ list = r.Scenes
+ case catProp:
+ list = r.Props
+ case catProduct:
+ list = r.Products
+ }
+ for _, it := range list {
+ if it.Name == name {
+ return it, true
+ }
+ }
+ return RefItem{}, false
+}
+
+// ---------- BuildSegmentPrompt（设计 §6 + P0-4/P2-3/P3-1）----------
+
+// BuildSegmentPrompt 构建单段 prompt 与参考素材显式绑定。
+// 加权筛选（开口角色必选 + 权重降序）选取 ≤ MaxRefs 个实体；prompt 用选中的 token 替换。
+func BuildSegmentPrompt(segShots []Shot, reg *TokenRegistry, in Input) (string, []RefBinding) {
+ cfg := resolveConfig(in.Cfg, in.MaxSegmentDur)
+
+ type cand struct {
+ ent *entity
+ appOrder int
+ }
+ var cands []cand
+ seen := map[string]bool{}
+ speaking := map[string]bool{}
+ app := 0
+
+ add := func(category, name string) {
+ ent := reg.entityFor(category, name)
+ if ent == nil {
+ return
+ }
+ key := entKey(ent)
+ if seen[key] {
+ return
+ }
+ seen[key] = true
+ cands = append(cands, cand{ent: ent, appOrder: app})
+ app++
+ }
+
+ for _, sh := range segShots {
+ for _, c := range sh.Characters {
+ add(catCharacter, c)
+ }
+ if sh.Scene != "" {
+ add(catScene, sh.Scene)
+ }
+ for _, p := range sh.Props {
+ add(catProp, p)
+ }
+ if sh.Dialogue != "" || sh.Narration != "" {
+ for _, c := range sh.Characters {
+ if ent := reg.entityFor(catCharacter, c); ent != nil {
+ speaking[entKey(ent)] = true
+ }
+ }
+ }
+ }
+ // 产品图常驻候选
+ for _, e := range reg.order {
+ if e.Category == catProduct {
+ key := entKey(e)
+ if !seen[key] {
+ seen[key] = true
+ cands = append(cands, cand{ent: e, appOrder: app})
+ app++
+ }
+ }
+ }
+
+ // 硬优先级：开口角色；其余按权重降序、同权重按出现顺序
+ var speakCands, otherCands []cand
+ for _, c := range cands {
+ if speaking[entKey(c.ent)] {
+ speakCands = append(speakCands, c)
+ } else {
+ otherCands = append(otherCands, c)
+ }
+ }
+ sort.SliceStable(otherCands, func(i, j int) bool {
+ if otherCands[i].ent.Weight != otherCands[j].ent.Weight {
+ return otherCands[i].ent.Weight > otherCands[j].ent.Weight
+ }
+ return otherCands[i].appOrder < otherCands[j].appOrder
+ })
+
+ var chosen []*entity
+ for _, c := range speakCands {
+ if len(chosen) >= cfg.MaxRefs {
+ break
+ }
+ chosen = append(chosen, c.ent)
+ }
+ for _, c := range otherCands {
+ if len(chosen) >= cfg.MaxRefs {
+ break
+ }
+ chosen = append(chosen, c.ent)
+ }
+
+ // 显式绑定：token→URL 一一对应
+ segRefs := make([]RefBinding, 0, len(chosen))
+ for _, e := range chosen {
+ segRefs = append(segRefs, RefBinding{
+ Token: reg.tokenByKey[entKey(e)],
+ Entity: e.Aliases[0],
+ Category: e.Category,
+ URL: e.URL,
+ })
+ }
+
+ // 文本替换：按别名长度降序，命中任一异形体即替换为该 token
+ prompt := ShotsToPromptText(segShots)
+ type repl struct {
+ alias string
+ token string
+ }
+ var repls []repl
+ for _, e := range chosen {
+ token := reg.tokenByKey[entKey(e)]
+ for _, a := range e.Aliases {
+ repls = append(repls, repl{alias: a, token: token})
+ }
+ }
+ sort.SliceStable(repls, func(i, j int) bool {
+ return utf8.RuneCountInString(repls[i].alias) > utf8.RuneCountInString(repls[j].alias)
+ })
+ for _, r := range repls {
+ prompt = strings.ReplaceAll(prompt, r.alias, r.token)
+ }
+
+ prompt = truncatePrompt(prompt, cfg)
+ return prompt, segRefs
+}
+
+// truncatePrompt 语义保护截断（设计 §6.4 / P3-1）：
+// 先裁环境音/运镜/景别块，再从尾部最近句子边界截断，保底 MinPromptFloor 字符。
+func truncatePrompt(p string, cfg Config) string {
+ max := cfg.MaxPromptChars
+ if max <= 0 {
+ return p
+ }
+ if utf8.RuneCountInString(p) <= max {
+ return p
+ }
+ var kept []string
+ for _, ln := range strings.Split(p, "\n") {
+ if strings.HasPrefix(ln, "环境音：") || strings.HasPrefix(ln, "运镜：") || strings.HasPrefix(ln, "景别：") {
+ continue
+ }
+ kept = append(kept, ln)
+ }
+ p2 := strings.Join(kept, "\n")
+ if utf8.RuneCountInString(p2) <= max {
+ return p2
+ }
+ rs := []rune(p2)
+ floor := cfg.MinPromptFloor
+ if floor <= 0 {
+ floor = 50
+ }
+ if floor >= len(rs) {
+ floor = len(rs) - 1
+ }
+ cut := max
+ if cut > len(rs) {
+ cut = len(rs)
+ }
+ for i := cut; i > floor; i-- {
+ if isSentenceEnd(rs[i-1]) {
+ cut = i
+ break
+ }
+ }
+ out := strings.TrimRight(string(rs[:cut]), " \t\n")
+ if out == "" {
+ out = "…"
+ } else {
+ out += "…"
+ }
+ return out
+}
diff --git a/workflow/service/flow/processor/builtin/split_shots_pipeline/pipeline/shot.go b/workflow/service/flow/processor/builtin/split_shots_pipeline/pipeline/shot.go
new file mode 100644
index 0000000..aeb2b8a
--- /dev/null
+++ b/workflow/service/flow/processor/builtin/split_shots_pipeline/pipeline/shot.go
@@ -0,0 +1,134 @@
+// 镜头模型（原 video/domain.Shot，随处理器自包含并入本包）：脚本与视频模型之间的统一中间契约。
+package pipeline
+
+import (
+ "encoding/json"
+ "fmt"
+ "strings"
+)
+
+// Shot 单个镜头。文生视频 / 分析替换两种模式产出的脚本都归一为该结构，
+// 后续拆段、prompt 构建、参考素材筛选都以它为准。
+type Shot struct {
+ Index int `json:"index"`
+ StartTime string `json:"startTime"` // "MM:SS"
+ EndTime string `json:"endTime"` // "MM:SS"
+ Event string `json:"event"` // 事件描述/动作描写
+ Narration string `json:"narration,omitempty"` // 旁白/画外音
+ Dialogue string `json:"dialogue,omitempty"` // 主台词
+ AmbientSound string `json:"ambientSound,omitempty"` // 环境音
+ CameraMovement string `json:"cameraMovement"` // 运镜描述
+ ShotSize string `json:"shotSize"` // 景别
+ Characters []string `json:"characters"` // 出演人物名列表
+ Scene string `json:"scene"` // 场景名
+ Props []string `json:"props"` // 道具名列表
+ NegativePrompt string `json:"negativePrompt,omitempty"` // 本镜头负面 prompt（可选，见 video/pipeline §7.5）
+}
+
+// ShotsToText 将镜头数组转回纯文本格式（带【镜头X】标题），供需要完整脚本文本的场景使用。
+func ShotsToText(shots []Shot) string {
+ var b strings.Builder
+ if len(shots) == 0 {
+ return ""
+ }
+ for _, s := range shots {
+ fmt.Fprintf(&b, "【镜头%d】（%s-%s）\n", s.Index, s.StartTime, s.EndTime)
+ writeShotFields(&b, s)
+ }
+ return strings.TrimRight(b.String(), "\n")
+}
+
+// ShotsToPromptText 将镜头数组转为纯文本格式（不含【镜头X】标题），用于构建视频模型请求的 prompt。
+func ShotsToPromptText(shots []Shot) string {
+ var b strings.Builder
+ if len(shots) == 0 {
+ return ""
+ }
+ for _, s := range shots {
+ fmt.Fprintf(&b, "（%s-%s）\n", s.StartTime, s.EndTime)
+ writeShotFields(&b, s)
+ }
+ return strings.TrimRight(b.String(), "\n")
+}
+
+func writeShotFields(b *strings.Builder, s Shot) {
+ if s.Event != "" {
+ fmt.Fprintf(b, "事件：%s\n", s.Event)
+ }
+ if s.Dialogue != "" {
+ fmt.Fprintf(b, "台词：%s（角色开口说）\n", s.Dialogue)
+ }
+ if s.Narration != "" {
+ fmt.Fprintf(b, "画外音：%s（角色不开口，仅播放旁白配音）\n", s.Narration)
+ }
+ if s.AmbientSound != "" {
+ fmt.Fprintf(b, "环境音：%s\n", s.AmbientSound)
+ }
+ if s.ShotSize != "" {
+ fmt.Fprintf(b, "景别：%s\n", s.ShotSize)
+ }
+ if s.CameraMovement != "" {
+ fmt.Fprintf(b, "运镜：%s\n", s.CameraMovement)
+ }
+ b.WriteString("\n")
+}
+
+// ShotsJSONSchema 返回 []Shot 的 JSON Schema，供"脚本转写"节点作为模型 function 定义的 InputSchema，
+// 让模型以 function calling 形式产出固定结构的镜头数组。
+func ShotsJSONSchema() map[string]any {
+ item := map[string]any{
+ "type": "object",
+ "properties": map[string]any{
+ "index": map[string]any{"type": "integer"},
+ "startTime": map[string]any{"type": "string", "description": "开始时间，格式 MM:SS"},
+ "endTime": map[string]any{"type": "string", "description": "结束时间，格式 MM:SS"},
+ "event": map[string]any{"type": "string", "description": "事件描述/动作描写"},
+ "narration": map[string]any{"type": "string", "description": "旁白/画外音"},
+ "dialogue": map[string]any{"type": "string", "description": "主台词"},
+ "ambientSound": map[string]any{"type": "string", "description": "环境音"},
+ "cameraMovement": map[string]any{"type": "string", "description": "运镜描述"},
+ "shotSize": map[string]any{"type": "string", "description": "景别"},
+ "characters": map[string]any{"type": "array", "items": map[string]any{"type": "string"}, "description": "出演人物名列表"},
+ "scene": map[string]any{"type": "string", "description": "场景名"},
+ "props": map[string]any{"type": "array", "items": map[string]any{"type": "string"}, "description": "道具名列表"},
+ },
+ "required": []string{"index", "startTime", "endTime", "event", "cameraMovement", "shotSize", "characters", "scene"},
+ }
+ return map[string]any{
+ "type": "array",
+ "items": item,
+ }
+}
+
+// ShotsStructuredFormat 返回 []Shot 的原生结构化输出（response_format）值：
+// OpenAI 兼容 json_schema 模式，object 包装 {shots:[...]}。模型是否支持由 chat 模型
+// RequestBusinessFieldMapping 是否配置 response_format 决定（见 gateway.ModelConfig.StructuredOutput）。
+func ShotsStructuredFormat() map[string]any {
+ return map[string]any{
+ "type": "json_schema",
+ "json_schema": map[string]any{
+ "name": "shots",
+ "schema": map[string]any{
+ "type": "object",
+ "properties": map[string]any{"shots": ShotsJSONSchema()},
+ "required": []string{"shots"},
+ },
+ },
+ }
+}
+
+// IsShotsJSON 判断 script 内容是否为 JSON 镜头数组
+func IsShotsJSON(script string) bool {
+ if len(script) == 0 {
+ return false
+ }
+ trimmed := strings.TrimSpace(script)
+ if !strings.HasPrefix(trimmed, "[") {
+ return false
+ }
+ var shots []Shot
+ if err := json.Unmarshal([]byte(trimmed), &shots); err != nil {
+ return false
+ }
+ return len(shots) > 0
+}
diff --git a/workflow/service/flow/processor/builtin/split_shots_pipeline/pipeline/timeline.go b/workflow/service/flow/processor/builtin/split_shots_pipeline/pipeline/timeline.go
new file mode 100644
index 0000000..2f52285
--- /dev/null
+++ b/workflow/service/flow/processor/builtin/split_shots_pipeline/pipeline/timeline.go
@@ -0,0 +1,706 @@
+package pipeline
+
+import (
+ "fmt"
+ "math"
+ "strconv"
+ "strings"
+ "unicode/utf8"
+)
+
+// ---------- 时间工具 ----------
+
+func parseSec(t string) int {
+ parts := strings.Split(t, ":")
+ if len(parts) != 2 {
+ return 0
+ }
+ m, err1 := strconv.Atoi(parts[0])
+ s, err2 := strconv.Atoi(parts[1])
+ if err1 != nil || err2 != nil {
+ return 0
+ }
+ return m*60 + s
+}
+
+func mmss(total int) string {
+ return fmt.Sprintf("%02d:%02d", total/60, total%60)
+}
+
+func shotDur(sh Shot) int {
+ return parseSec(sh.EndTime) - parseSec(sh.StartTime)
+}
+
+func absInt(v int) int {
+ if v < 0 {
+ return -v
+ }
+ return v
+}
+
+// ---------- 断句（SplitOversized 与 GroupSegments 共用的语义原语，设计 P0-2/四审 P0-1）----------
+
+func isSentenceEnd(r rune) bool {
+ switch r {
+ case '。', '！', '？', '；', '\n', '!', '?', '.':
+ return true
+ }
+ return false
+}
+
+// sentenceEnds 返回 text 中所有句子结束位置（rune 下标，end-exclusive）。
+func sentenceEnds(text string) []int {
+ var out []int
+ rs := []rune(text)
+ for i, r := range rs {
+ if isSentenceEnd(r) {
+ out = append(out, i+1)
+ }
+ }
+ return out
+}
+
+// findBoundary 在 rune 序列中寻找离 pos 最近（窗口内）的句末断点，返回 end-exclusive 下标。
+func findBoundary(rs []rune, pos int, forwardFirst bool, window int) int {
+ if len(rs) == 0 || pos <= 0 {
+ return 0
+ }
+ if pos >= len(rs) {
+ return len(rs)
+ }
+ if window <= 0 {
+ window = 60
+ }
+ if forwardFirst {
+ end := pos + window
+ if end > len(rs) {
+ end = len(rs)
+ }
+ for i := pos; i < end; i++ {
+ if isSentenceEnd(rs[i]) {
+ return i + 1
+ }
+ }
+ start := pos - window
+ if start < 0 {
+ start = 0
+ }
+ for i := pos - 1; i >= start; i-- {
+ if isSentenceEnd(rs[i]) {
+ return i + 1
+ }
+ }
+ } else {
+ start := pos - window
+ if start < 0 {
+ start = 0
+ }
+ for i := pos - 1; i >= start; i-- {
+ if isSentenceEnd(rs[i]) {
+ return i + 1
+ }
+ }
+ end := pos + window
+ if end > len(rs) {
+ end = len(rs)
+ }
+ for i := pos; i < end; i++ {
+ if isSentenceEnd(rs[i]) {
+ return i + 1
+ }
+ }
+ }
+ return pos
+}
+
+// ---------- ① RebuildDurations（尊重 AI 时间码，设计 §5.1 修订 + P1-1 + 四审 P0-3）----------
+
+// RebuildDurations 优先保留 AI 的 startTime/endTime：时间码可用且可容纳时按相对时长整体缩放对齐到
+// TotalDuration（normalizeAIDurations，整数化 + 均衡修正，构造即 Σ==total）；否则回退按文本量重建
+// （rebuildFromText，旧算法保留）。AI 时间码是模型对镜头节奏的真实意图，文本量重建只作兜底。
+func RebuildDurations(in Input) ([]Shot, error) {
+ shots := append([]Shot(nil), in.Shots...)
+ if len(shots) == 0 {
+ return nil, pipeErr(ErrEmptyShots, "镜头为空")
+ }
+ total := in.TotalDuration
+ if total <= 0 {
+ total = sumShotDurations(shots)
+ }
+ if total <= 0 {
+ total = 60
+ }
+ if aiDurationsUsable(shots) && total >= len(shots) {
+ return normalizeAIDurations(shots, total)
+ }
+ return rebuildFromText(shots, total, resolveConfig(in.Cfg, in.MaxSegmentDur))
+}
+
+// aiDurationsUsable AI 时间码是否值得保留：所有镜头时间码非空且时长之和 > 0。
+// 单镜零/负时长在 normalizeAIDurations 中防御性钳到 1（设计决策：零时长镜头不应出现）。
+func aiDurationsUsable(shots []Shot) bool {
+ sum := 0
+ for _, sh := range shots {
+ if strings.TrimSpace(sh.StartTime) == "" || strings.TrimSpace(sh.EndTime) == "" {
+ return false
+ }
+ sum += parseSec(sh.EndTime) - parseSec(sh.StartTime)
+ }
+ return sum > 0
+}
+
+// normalizeAIDurations 保留 AI 镜头相对时长，整体缩放对齐到目标总时长：
+// 各镜时长 d[i] 按 total/Σd 等比缩放并四舍五入整数化，再做整体均衡修正（±1s 逐段抹平）保证
+// Σscaled == total 构造即成立；随后按累积偏移重排连续时间码，末镜 endTime 精确对齐 total。
+func normalizeAIDurations(shots []Shot, total int) ([]Shot, error) {
+ n := len(shots)
+ if n == 0 {
+ return nil, pipeErr(ErrEmptyShots, "镜头为空")
+ }
+ if total <= 0 {
+ return shots, nil
+ }
+ raw := make([]int, n)
+ rawSum := 0
+ for i, sh := range shots {
+ d := parseSec(sh.EndTime) - parseSec(sh.StartTime)
+ if d < 1 {
+ d = 1
+ }
+ raw[i] = d
+ rawSum += d
+ }
+ if rawSum <= 0 {
+ return nil, pipeErr(ErrInvalidInput, "AI 时间码时长之和为 0")
+ }
+ scaled := make([]int, n)
+ sum := 0
+ for i := 0; i < n; i++ {
+ s := int(math.Round(float64(raw[i]) * float64(total) / float64(rawSum)))
+ if s < 1 {
+ s = 1
+ }
+ scaled[i] = s
+ sum += s
+ }
+ // 均衡修正：把缩放舍入偏差逐段抹平，保证 Σscaled == total（调用方保证 total >= n 可行）
+ balance := total - sum
+ for i := n - 1; i >= 0 && balance != 0; i-- {
+ if balance > 0 {
+ scaled[i]++
+ balance--
+ } else if scaled[i] > 1 {
+ scaled[i]--
+ balance++
+ }
+ }
+ current := 0
+ for i := 0; i < n; i++ {
+ shots[i].StartTime = mmss(current)
+ current += scaled[i]
+ shots[i].EndTime = mmss(current)
+ }
+ if n > 0 {
+ shots[n-1].EndTime = mmss(total)
+ }
+ return shots, nil
+}
+
+// rebuildFromText 丢弃 AI 时间码、按文本量重建镜头时长（旧 RebuildDurations 算法）：
+// 有文字镜头按语速算最小时长，纯视觉镜头以 AI 时长意图为基准，盈余按弹性权重分配，
+// 超出目标先压视觉再等比压有声最后截尾；整数化 + 整体均衡修正保证 Σ == total 构造即恒等。
+func rebuildFromText(shots []Shot, total int, cfg Config) ([]Shot, error) {
+ n := len(shots)
+ base := make([]int, n)
+ weights := make([]float64, n)
+ totalBase := 0
+
+ for i, sh := range shots {
+ textLen := utf8.RuneCountInString(sh.Dialogue) + utf8.RuneCountInString(sh.Narration)
+ aiDur := parseSec(sh.EndTime) - parseSec(sh.StartTime)
+ if aiDur <= 0 {
+ aiDur = 1
+ }
+ if textLen == 0 {
+ d := aiDur
+ if float64(d) < cfg.MinVisualDur {
+ d = int(cfg.MinVisualDur)
+ }
+ if d < 1 {
+ d = 1
+ }
+ base[i] = d
+ weights[i] = cfg.VisualWeight
+ } else {
+ cps := inferCharPerSecond(sh.Dialogue+" "+sh.Narration, cfg)
+ speaking := math.Ceil(float64(textLen) / cps)
+ minDur := speaking + cfg.MinDurBuffer
+ if minDur < 2 {
+ minDur = 2
+ }
+ base[i] = int(minDur)
+ weights[i] = cfg.SpokenWeight
+ }
+ totalBase += base[i]
+ }
+
+ if totalBase <= total {
+ // 盈余按弹性权重分配（float64），整数化后整体均衡修正
+ surplus := total - totalBase
+ var totalWeight float64
+ for _, w := range weights {
+ totalWeight += w
+ }
+ extra := make([]int, n)
+ sumExtra := 0
+ if totalWeight > 0 {
+ for i := 0; i < n; i++ {
+ e := int(math.Floor(float64(surplus) * weights[i] / totalWeight))
+ extra[i] = e
+ sumExtra += e
+ }
+ }
+ // 均衡修正：把舍入偏差逐段抹平，保证 sum(extra) == surplus
+ balance := surplus - sumExtra
+ for i := n - 1; i >= 0 && balance != 0; i-- {
+ if balance > 0 {
+ extra[i]++
+ balance--
+ } else if extra[i] > 0 {
+ extra[i]--
+ balance++
+ }
+ }
+ current := 0
+ for i := 0; i < n; i++ {
+ shots[i].StartTime = mmss(current)
+ current += base[i] + extra[i]
+ shots[i].EndTime = mmss(current)
+ }
+ if n > 0 {
+ shots[n-1].EndTime = mmss(total)
+ }
+ } else {
+ // 总最小时长超出目标 → 压缩
+ overshoot := totalBase - total
+
+ // 1) 压缩纯视觉镜头
+ for i := 0; i < n && overshoot > 0; i++ {
+ if weights[i] >= cfg.VisualWeight && base[i] > 1 {
+ maxReduce := base[i] - 1
+ reduce := overshoot
+ if reduce > maxReduce {
+ reduce = maxReduce
+ }
+ base[i] -= reduce
+ overshoot -= reduce
+ }
+ }
+
+ if overshoot > 0 {
+ // 2) 重建有声镜头底线，等比压缩
+ reBase := make([]int, n)
+ newTotal := 0
+ for i, sh := range shots {
+ if weights[i] >= cfg.VisualWeight {
+ reBase[i] = base[i]
+ } else {
+ textLen := utf8.RuneCountInString(sh.Dialogue) + utf8.RuneCountInString(sh.Narration)
+ cps := inferCharPerSecond(sh.Dialogue+" "+sh.Narration, cfg)
+ speaking := math.Ceil(float64(textLen) / cps)
+ minDur := speaking + cfg.MinDurBuffer
+ if minDur < 2 {
+ minDur = 2
+ }
+ reBase[i] = int(minDur)
+ }
+ newTotal += reBase[i]
+ }
+
+ if newTotal > total {
+ ratio := float64(total) / float64(newTotal)
+ current := 0
+ keep := n
+ for i := 0; i < n; i++ {
+ d := int(float64(reBase[i]) * ratio)
+ if d < 1 {
+ d = 1
+ }
+ if current+d > total {
+ d = total - current
+ }
+ if d < 1 {
+ d = 1
+ }
+ shots[i].StartTime = mmss(current)
+ current += d
+ shots[i].EndTime = mmss(current)
+ if current >= total {
+ keep = i + 1
+ break
+ }
+ }
+ if keep < n {
+ shots = shots[:keep]
+ }
+ if len(shots) > 0 && current < total {
+ shots[len(shots)-1].EndTime = mmss(total)
+ }
+ } else {
+ current := 0
+ for i := 0; i < n; i++ {
+ shots[i].StartTime = mmss(current)
+ current += reBase[i]
+ shots[i].EndTime = mmss(current)
+ }
+ if current < total && n > 0 {
+ shots[n-1].EndTime = mmss(total)
+ }
+ }
+ } else {
+ // 仅压缩视觉镜头就够了
+ current := 0
+ for i := 0; i < n; i++ {
+ shots[i].StartTime = mmss(current)
+ current += base[i]
+ shots[i].EndTime = mmss(current)
+ }
+ if current < total && n > 0 {
+ shots[n-1].EndTime = mmss(total)
+ }
+ }
+ }
+
+ for i := range shots {
+ shots[i].Index = i + 1
+ }
+ return shots, nil
+}
+
+// inferCharPerSecond 根据文本情绪推断语速：感叹/疑问多→快，低落→慢。
+func inferCharPerSecond(text string, cfg Config) float64 {
+ runes := utf8.RuneCountInString(text)
+ if runes == 0 {
+ return cfg.CharPerSecond
+ }
+ excl := strings.Count(text, "！") + strings.Count(text, "!")
+ ques := strings.Count(text, "？") + strings.Count(text, "?")
+ emotion := excl + ques
+ if emotion >= 2 && emotion*100/runes >= 8 {
+ return cfg.FastCharPerSecond
+ }
+ if strings.Contains(text, "…") || strings.Contains(text, "唉") {
+ return cfg.SlowCharPerSecond
+ }
+ return cfg.CharPerSecond
+}
+
+// ---------- ② SplitOversized（设计 §5.2 + 四审 P0-4）----------
+
+// SplitOversized 超 MaxSegmentDur 的镜头按句末断句切子镜头，避免"说话说一半"。
+// 每个子镜头按「基础起点 + 子段序号×Max」重算全局 StartTime/EndTime（末段延伸到原终点），
+// 保证子镜头全局时间轴连续、无重叠、无缝隙。
+func SplitOversized(shots []Shot, in Input) ([]Shot, error) {
+ maxDur := in.MaxSegmentDur
+ if maxDur <= 0 || len(shots) == 0 {
+ return shots, nil
+ }
+ cfg := resolveConfig(in.Cfg, maxDur)
+ window := cfg.SplitWindow
+ fragMin := int(cfg.ShortFragmentDur)
+ if fragMin < 1 {
+ fragMin = 1
+ }
+
+ var result []Shot
+ for _, sh := range shots {
+ dur := parseSec(sh.EndTime) - parseSec(sh.StartTime)
+ if dur <= maxDur {
+ result = append(result, sh)
+ continue
+ }
+ parts := (dur + maxDur - 1) / maxDur
+ // 最后一片段 < 短残片阈值时减少拆分段数
+ remainder := dur - (parts-1)*maxDur
+ if remainder < fragMin && parts > 1 {
+ parts--
+ }
+ dRunes := []rune(sh.Dialogue)
+ nRunes := []rune(sh.Narration)
+ baseStart := parseSec(sh.StartTime)
+
+ dPos, nPos := 0, 0
+ for p := 0; p < parts; p++ {
+ sub := sh
+ pStart := baseStart + p*maxDur
+ pEnd := pStart + maxDur
+ if p > 0 {
+ sub.StartTime = mmss(pStart)
+ }
+ if p == parts-1 {
+ pEnd = baseStart + dur
+ }
+ sub.EndTime = mmss(pEnd)
+
+ if p < parts-1 {
+ dTarget := len(dRunes) * (p + 1) / parts
+ if dTarget > dPos && dTarget <= len(dRunes) {
+ dEnd := findBoundary(dRunes, dTarget, true, window)
+ if dEnd <= dPos {
+ dEnd = dPos + 1
+ }
+ if dEnd > len(dRunes) {
+ dEnd = len(dRunes)
+ }
+ sub.Dialogue = string(dRunes[dPos:dEnd])
+ dPos = dEnd
+ }
+ nTarget := len(nRunes) * (p + 1) / parts
+ if nTarget > nPos && nTarget <= len(nRunes) {
+ nEnd := findBoundary(nRunes, nTarget, true, window)
+ if nEnd <= nPos {
+ nEnd = nPos + 1
+ }
+ if nEnd > len(nRunes) {
+ nEnd = len(nRunes)
+ }
+ sub.Narration = string(nRunes[nPos:nEnd])
+ nPos = nEnd
+ }
+ } else {
+ sub.Dialogue = string(dRunes[dPos:])
+ sub.Narration = string(nRunes[nPos:])
+ }
+ result = append(result, sub)
+ }
+ }
+
+ for i := range result {
+ result[i].Index = i + 1
+ }
+ return result, nil
+}
+
+// ---------- ③ GroupSegments（2026-08-12 修订，取代 CalcSegmentDurations/AlignSegments）----------
+
+// GroupSegments 按镜头边界贪心分组：段内镜头时长之和不超过 MaxSegmentDur；min 为硬约束
+// （段不足 MinSegmentDur 时从下一镜头头部按句末断点咬取补齐，模型不能容忍更短的段）。
+// 镜头时间码已在 RebuildDurations 归一为连续覆盖 [0,total)，分组只做切片、不改写时间码；
+// 末段为残余可短于 min（无后续镜头可咬）。前置条件：单镜时长 ≤ MaxSegmentDur（由 SplitOversized 保证）。
+func GroupSegments(shots []Shot, in Input) ([][]Shot, []int, error) {
+ if len(shots) == 0 {
+ return nil, nil, pipeErr(ErrEmptyShots, "镜头为空")
+ }
+ cfg := resolveConfig(in.Cfg, in.MaxSegmentDur)
+ maxSeg := in.MaxSegmentDur
+ if maxSeg <= 0 {
+ maxSeg = 15
+ }
+ minSeg := in.MinSegmentDur
+
+ remaining := append([]Shot(nil), shots...)
+ var segs [][]Shot
+ var durs []int
+
+ for len(remaining) > 0 {
+ var seg []Shot
+ segDur := 0
+
+ // 贪心拉入整镜头，直到加入下一镜会超过 max（首镜总是可入；单镜 ≤ max 由 SplitOversized 保证）
+ for len(remaining) > 0 {
+ d := shotDur(remaining[0])
+ if segDur > 0 && segDur+d > maxSeg {
+ break
+ }
+ seg = append(seg, remaining[0])
+ segDur += d
+ remaining = remaining[1:]
+ }
+
+ // min 硬约束：段不足 min 且还有镜头时，从下一镜头头部咬取补齐
+ if minSeg > 0 && segDur < minSeg && len(remaining) > 0 {
+ sh := remaining[0]
+ s := parseSec(sh.StartTime)
+ e := parseSec(sh.EndTime)
+ need := minSeg - segDur
+ // segDur+d > maxSeg ≥ minSeg ⇒ need < shotDur(sh)，必走咬取分支
+ if need > 0 && need < e-s {
+ cut := s + need
+ cutRune := -1
+ if c, r, ok := sentenceCut(sh, cut, cfg); ok && c > s && c < e {
+ cut, cutRune = c, r
+ }
+ // 吸附后钳制：min≈max 且句末断点在 need 点之后时，句末吸附会把段推过 max
+ //（例 max=10,min=9,segDur=8,断点在 +3s → 段 11s>10）。钳回 s+(maxSeg-segDur) 保 max
+ //（≥ min 恒成立，因 segDur < minSeg ≤ maxSeg），并回退纯时间切，避免 rune 与钳制后时间码错位。
+ if maxSeg > segDur && cut > s+(maxSeg-segDur) {
+ cut = s + (maxSeg - segDur)
+ cutRune = -1
+ }
+ if cut <= s {
+ cut = s + 1
+ }
+ if cut >= e {
+ cut = e - 1
+ }
+ s1, s2 := splitShotAt(sh, cut, cutRune)
+ seg = append(seg, s1)
+ segDur += parseSec(s1.EndTime) - parseSec(s1.StartTime)
+ remaining[0] = s2
+ } else if need > 0 {
+ // 防御：整镜补入（理论不可达，见上）
+ seg = append(seg, sh)
+ segDur += shotDur(sh)
+ remaining = remaining[1:]
+ }
+ }
+
+ segs = append(segs, seg)
+ durs = append(durs, segDur)
+ }
+ return segs, durs, nil
+}
+
+// sentenceCut 在镜头内寻找离 target 最近、且位移 ≤ BoundaryTolerance 的句末断点，
+// 返回断点时间（秒）与断点 rune 下标（在 "台词\n旁白" 合并串中的位置）。找不到返回 (target,-1,false)。
+func sentenceCut(sh Shot, target int, cfg Config) (int, int, bool) {
+ s := parseSec(sh.StartTime)
+ e := parseSec(sh.EndTime)
+ dur := e - s
+ if dur <= 0 {
+ return target, -1, false
+ }
+ text := sh.Dialogue + "\n" + sh.Narration
+ rs := []rune(text)
+ if len(rs) == 0 {
+ return target, -1, false
+ }
+ tol := int(cfg.BoundaryTolerance)
+ if tol < 0 {
+ tol = 0
+ }
+ best := target
+ bestRune := -1
+ bestDist := tol + 1
+ found := false
+ for _, p := range sentenceEnds(text) {
+ t := s + int(math.Round(float64(p)*float64(dur)/float64(len(rs))))
+ if t < s+1 || t > e-1 {
+ continue
+ }
+ dist := absInt(t - target)
+ if dist < bestDist {
+ bestDist = dist
+ best = t
+ bestRune = p
+ found = true
+ }
+ }
+ if !found {
+ return target, -1, false
+ }
+ return best, bestRune, true
+}
+
+// splitShotAt 把镜头按时间 cut 切成两个子镜头；cutRune >= 0 时按合并文本 rune 位置切分文本。
+func splitShotAt(sh Shot, cut, cutRune int) (Shot, Shot) {
+ s1, s2 := sh, sh
+ s1.EndTime = mmss(cut)
+ s2.StartTime = mmss(cut)
+ if cutRune >= 0 {
+ d := []rune(sh.Dialogue)
+ n := []rune(sh.Narration)
+ switch {
+ case cutRune <= len(d):
+ s1.Dialogue = string(d[:cutRune])
+ s2.Dialogue = string(d[cutRune:])
+ s1.Narration = ""
+ s2.Narration = string(n)
+ case cutRune <= len(d)+1+len(n):
+ s1.Dialogue = string(d)
+ nsplit := cutRune - len(d) - 1
+ if nsplit < 0 {
+ nsplit = 0
+ }
+ if nsplit > len(n) {
+ nsplit = len(n)
+ }
+ s1.Narration = string(n[:nsplit])
+ s2.Dialogue = ""
+ s2.Narration = string(n[nsplit:])
+ default:
+ s1.Dialogue = string(d)
+ s1.Narration = string(n)
+ s2.Dialogue = ""
+ s2.Narration = ""
+ }
+ }
+ return s1, s2
+}
+
+// BuildTimeline 编排 RebuildDurations → SplitOversized → GroupSegments，收尾做 assertTimeline 不变量校验。
+func BuildTimeline(in Input) ([][]Shot, []int, error) {
+ in = NormalizeInput(in)
+ if len(in.Shots) == 0 {
+ return nil, nil, pipeErr(ErrEmptyShots, "镜头为空")
+ }
+ shots, err := RebuildDurations(in)
+ if err != nil {
+ return nil, nil, err
+ }
+ shots, err = SplitOversized(shots, in)
+ if err != nil {
+ return nil, nil, err
+ }
+ segs, durs, err := GroupSegments(shots, in)
+ if err != nil {
+ return nil, nil, err
+ }
+ if err := assertTimeline(segs, durs, in.TotalDuration, in.MinSegmentDur, in.MaxSegmentDur, in.Cfg.StrictInvariant); err != nil {
+ return nil, nil, err
+ }
+ return segs, durs, nil
+}
+
+// ---------- assertTimeline（设计 §5.5 + P0-1）----------
+
+// assertTimeline 校验时间线不变量：
+// 段时长总和精确等于 total；每个镜头只属于一个段；段内镜头时间码落在段窗口内且连续无重叠；
+// 每段时长 ∈ [min, max]（strict=false 时该条仅告警，结构性不变量始终强制）。
+func assertTimeline(segShots [][]Shot, segDurs []int, total, minSeg, maxSeg int, strict bool) error {
+ sum := 0
+ for _, d := range segDurs {
+ sum += d
+ }
+ if sum != total {
+ return pipeErr(ErrTimelineInvariant, fmt.Sprintf("段时长总和 %d != TotalDuration %d", sum, total))
+ }
+ start := 0
+ for i, seg := range segShots {
+ dur := segDurs[i]
+ if strict && (dur < minSeg || dur > maxSeg) {
+ return pipeErr(ErrTimelineInvariant, fmt.Sprintf("段%d 时长 %d 不在 [%d,%d] 内", i, dur, minSeg, maxSeg))
+ }
+ if len(seg) == 0 {
+ start += dur
+ continue
+ }
+ prev := start
+ for _, sh := range seg {
+ s := parseSec(sh.StartTime)
+ e := parseSec(sh.EndTime)
+ if s != prev || e < s {
+ return pipeErr(ErrTimelineInvariant, fmt.Sprintf("段%d 镜头时间不连续/重叠（镜头%d %s-%s）", i, sh.Index, sh.StartTime, sh.EndTime))
+ }
+ if s < start || e > start+dur {
+ return pipeErr(ErrTimelineInvariant, fmt.Sprintf("段%d 镜头%d 时间码超出段窗口", i, sh.Index))
+ }
+ prev = e
+ }
+ if prev != start+dur {
+ return pipeErr(ErrTimelineInvariant, fmt.Sprintf("段%d 镜头未覆盖段窗口 [%d,%d)", i, start, start+dur))
+ }
+ start += dur
+ }
+ return nil
+}
diff --git a/workflow/service/flow/processor/builtin/split_shots_pipeline/split_shots_pipeline.go b/workflow/service/flow/processor/builtin/split_shots_pipeline/split_shots_pipeline.go
new file mode 100644
index 0000000..e369504
--- /dev/null
+++ b/workflow/service/flow/processor/builtin/split_shots_pipeline/split_shots_pipeline.go
@@ -0,0 +1,199 @@
+// Package split_shots_pipeline 工作流前置处理器：用 pipeline 时间线算法拆段，产出各段模型请求参数。
+// 与旧 split_shots 并存：节点 preTool 指向本处理器即灰度启用新算法（设计 §8.2/§10，开关即"用哪个 preTool"）。
+//
+// 处理器自包含：纯拆段算法随处理器走（pipeline 子包，零外部依赖）；唯一 I/O 是按 model_id 查模型网关
+// 推导单段时长约束（模型配置是唯一事实来源）。产出与旧链路一致的 FLAT 请求参数——model-gateway 按
+// requestBodyMapping/requestBusinessFieldMapping 对 flat 业务参数做字段映射，故不产嵌套请求体（会二次嵌套）。
+package split_shots_pipeline
+
+import (
+ "context"
+ "fmt"
+ "sort"
+ "strconv"
+ "strings"
+
+ "ai-agent/gateway"
+ "ai-agent/workflow/service/flow/processor"
+ "ai-agent/workflow/service/flow/processor/builtin/split_shots_pipeline/pipeline"
+
+ "github.com/gogf/gf/v2/util/gconv"
+)
+
+func init() {
+ processor.Register(SplitShotsPipelineProcessor())
+}
+
+// SplitShotsInput 视频生成模型节点的请求参数（ModelRequestParams）结构，处理器入参即它。
+// 只含拆段与透传字段：serial/session_id/callback_url/bgm_urls 不参与拆段（串并行由节点 IsBatchExec、
+// session 由 Global.SessionId 提供、合并字段由后置处理器读原始 request），故不入结构。
+// 参考素材是散布在请求参数中的 {refsName,value} 对象，parseRefs 递归提取，类别由 categorizeRefs 按名字推断。
+type SplitShotsInput struct {
+ ModelID int64 `json:"model_id"` // 视频模型 ID（走网关 modelCall）
+ Shots []pipeline.Shot `json:"shots"` // 已归一化的镜头脚本
+ TotalDuration int `json:"total_duration"` // 目标总时长（秒）
+ FlatRefs []pipeline.RefItem `json:"flat_refs"` // 参考素材（平铺形态，类别由 categorizeRefs 推断）
+ Seed int64 `json:"seed"` // 随机种子基数，各段 = baseSeed + 段序号
+ NegativePrompt string `json:"negative_prompt,omitempty"`
+}
+
+// SplitShotsPipelineProcessor 新拆段前置处理器。入参 args 即模型请求参数（SplitShotsInput 形状），
+// 按 model_id 查模型网关推导单段时长约束 → pipeline 时间线算法拆段 → 输出每段 FLAT 模型请求参数。
+func SplitShotsPipelineProcessor() *processor.Processor {
+ return &processor.Processor{
+ Name: "split_shots_pipeline",
+ Description: "按 pipeline 时间线算法拆段，产出各段模型请求参数（与 split_shots 并存，灰度用）",
+ Func: func(ctx context.Context, args map[string]any) (any, error) {
+ input, err := parseSplitShotsInput(args)
+ if err != nil {
+ return nil, err
+ }
+ refs := categorizeRefs(input.Shots, input.FlatRefs)
+ maxSeg, minSeg, err := SegmentBounds(ctx, input.ModelID)
+ if err != nil {
+ return nil, err
+ }
+
+ segs, err := pipeline.PlanSegments(pipeline.NormalizeInput(pipeline.Input{
+ Shots: input.Shots,
+ TotalDuration: input.TotalDuration,
+ MaxSegmentDur: maxSeg,
+ MinSegmentDur: minSeg,
+ Refs: refs,
+ Seed: input.Seed,
+ NegativePrompt: input.NegativePrompt,
+ TokenCfg: pipeline.TokenConfig{},
+ }))
+ if err != nil {
+ return nil, err
+ }
+
+ list := make([]map[string]any, 0, len(segs))
+ for _, seg := range segs {
+ list = append(list, segmentParamsMap(input, seg))
+ }
+ return list, nil
+ },
+ }
+}
+
+func parseSplitShotsInput(args map[string]any) (*SplitShotsInput, error) {
+ if args == nil {
+ return nil, fmt.Errorf("缺少视频生成请求参数")
+ }
+ input := new(SplitShotsInput)
+ if err := gconv.Struct(args, input); err != nil {
+ return nil, fmt.Errorf("解析视频生成请求参数失败: %v", err)
+ }
+ if input.ModelID <= 0 {
+ return nil, fmt.Errorf("缺少 model_id")
+ }
+ if len(input.Shots) == 0 {
+ return nil, fmt.Errorf("缺少 shots 镜头脚本")
+ }
+ return input, nil
+}
+
+// categorizeRefs 按名字在镜头中出现的字段推断平铺参考素材的类别（角色/场景/道具），
+// 都命不中归产品（产品常驻注册表，见 pipeline.NewTokenRegistry）。类别只决定 token 前缀与权重，不改变 URL 绑定。
+func categorizeRefs(shots []pipeline.Shot, items []pipeline.RefItem) pipeline.Refs {
+ var refs pipeline.Refs
+ charNames := map[string]bool{}
+ sceneNames := map[string]bool{}
+ propNames := map[string]bool{}
+ for _, sh := range shots {
+ for _, c := range sh.Characters {
+ charNames[strings.TrimSpace(c)] = true
+ }
+ if sh.Scene != "" {
+ sceneNames[strings.TrimSpace(sh.Scene)] = true
+ }
+ for _, p := range sh.Props {
+ propNames[strings.TrimSpace(p)] = true
+ }
+ }
+ for _, it := range items {
+ name := strings.TrimSpace(it.Name)
+ switch {
+ case charNames[name]:
+ refs.Characters = append(refs.Characters, it)
+ case sceneNames[name]:
+ refs.Scenes = append(refs.Scenes, it)
+ case propNames[name]:
+ refs.Props = append(refs.Props, it)
+ default:
+ refs.Products = append(refs.Products, it)
+ }
+ }
+ return refs
+}
+
+// SegmentBounds 查模型网关推导单段时长约束：兜底 max/min = 10/4 秒；模型配置的
+// MaxDuration/MinDuration 字段（>0）可覆盖兜底值，min 收敛到 ≤ max。
+// 导出供脚本转写节点注入"单镜时长 ≤ max"约束（源头预防超长镜头）。
+func SegmentBounds(ctx context.Context, modelID int64) (maxSeg, minSeg int, err error) {
+ maxSeg, minSeg = 10, 4
+ info, err := gateway.GetModelInfoById(ctx, &gateway.GetModelInfoByIdReq{ModelId: modelID})
+ if err != nil {
+ return 0, 0, fmt.Errorf("获取模型信息失败: %v", err)
+ }
+ if info.ModelManage.MaxDuration > 0 {
+ maxSeg = info.ModelManage.MaxDuration
+ }
+ if info.ModelManage.MinDuration > 0 {
+ minSeg = info.ModelManage.MinDuration
+ }
+ if minSeg > maxSeg {
+ minSeg = maxSeg
+ }
+ return maxSeg, minSeg, nil
+}
+
+// segmentParamsMap 把一段 pipeline 产出序列化为 FLAT 模型请求参数（对齐旧 plan.SegmentParamsToMap 语义）。
+// reference_urls 按 token 编号排序，保证媒体数组顺序与 prompt 中的 token 编号一致（位置识别模型兼容）。
+func segmentParamsMap(input *SplitShotsInput, seg pipeline.Segment) map[string]any {
+ m := map[string]any{
+ "segment_index": seg.Index,
+ "prompt": seg.Prompt,
+ "duration": seg.Duration,
+ "seed": seg.Seed,
+ }
+ if seg.NegativePrompt != "" {
+ m["negative_prompt"] = seg.NegativePrompt
+ }
+ if refs := sortedRefs(seg.Refs); len(refs) > 0 {
+ urls := make([]string, 0, len(refs))
+ labels := make(map[string]string, len(refs))
+ for _, rb := range refs {
+ if rb.URL == "" {
+ continue
+ }
+ urls = append(urls, rb.URL)
+ labels[rb.Entity] = rb.Token
+ }
+ if len(urls) > 0 {
+ m["reference_urls"] = urls
+ m["reference_labels"] = labels
+ }
+ }
+ return m
+}
+
+// sortedRefs 按 token 编号（video3→3、image10→10）升序稳定排序，
+// 让 reference_urls 顺序尽量贴近 prompt 中 token 的编号顺序。
+func sortedRefs(refs []pipeline.RefBinding) []pipeline.RefBinding {
+ out := append([]pipeline.RefBinding(nil), refs...)
+ sort.SliceStable(out, func(i, j int) bool {
+ return tokenNum(out[i].Token) < tokenNum(out[j].Token)
+ })
+ return out
+}
+
+func tokenNum(tok string) int {
+ i := 0
+ for i < len(tok) && (tok[i] < '0' || tok[i] > '9') {
+ i++
+ }
+ n, _ := strconv.Atoi(tok[i:])
+ return n
+}
diff --git a/workflow/service/flow/processor/processor.go b/workflow/service/flow/processor/processor.go
new file mode 100644
index 0000000..1d28d56
--- /dev/null
+++ b/workflow/service/flow/processor/processor.go
@@ -0,0 +1,73 @@
+// Package processor 工作流节点的前置/后置处理器注册表。
+//
+// 与模型工具（common/tools）区分：处理器是绑定固定业务场景的处理函数，按名注册与分发，
+// 供节点配置（preTool/postTool）引用，不由模型 function calling 调用。
+package processor
+
+import (
+ "context"
+ "fmt"
+ "sort"
+)
+
+// Processor 工作流前置/后置处理函数。按名注册与分发，供节点配置引用。
+type Processor struct {
+ Name string
+ Description string
+ Func func(ctx context.Context, args map[string]any) (any, error)
+}
+
+// registry 处理器注册表
+var registry = make(map[string]*Processor)
+
+// Register 注册处理器，同名覆盖
+func Register(list ...*Processor) {
+ for _, p := range list {
+ if p == nil || p.Name == "" {
+ continue
+ }
+ registry[p.Name] = p
+ }
+}
+
+// Call 按名调用处理器。未知处理器返回错误。
+func Call(ctx context.Context, name string, args map[string]any) (any, error) {
+ if err := ctx.Err(); err != nil {
+ return nil, err
+ }
+ p := registry[name]
+ if p == nil || p.Func == nil {
+ return nil, fmt.Errorf("处理器[%s]不存在或未实现", name)
+ }
+ return p.Func(ctx, args)
+}
+
+func List(ctx context.Context) ([]*Processor, error) {
+ list := make([]*Processor, 0, len(registry))
+ for _, t := range registry {
+ list = append(list, t)
+ }
+ sort.Slice(list, func(i, j int) bool { return list[i].Name < list[j].Name })
+ return list, nil
+}
+
+// ProducedKey 前置处理器已完成模型调用、直接产出最终结果时，在返回列表的每个 map 上打的标记键。
+// 模型调用节点识别到该标记后跳过模型调用循环，把前置处理器的结果直接交给后置处理器。
+// 用于"串行视频生成"这类无法用并发循环表达的前置处理器。
+const ProducedKey = "__produced"
+
+// IsProduced 判断前置处理器返回列表是否全部带已产出标记（列表中每个 map 的标记值都须为 true）
+func IsProduced(list []map[string]any) bool {
+ if len(list) == 0 {
+ return false
+ }
+ for _, m := range list {
+ if m == nil {
+ return false
+ }
+ if v, ok := m[ProducedKey].(bool); !ok || !v {
+ return false
+ }
+ }
+ return true
+}
diff --git a/workflow/service/flow/react_ws_exec.go b/workflow/service/flow/react_ws_exec.go
new file mode 100644
index 0000000..df06c33
--- /dev/null
+++ b/workflow/service/flow/react_ws_exec.go
@@ -0,0 +1,183 @@
+package flow
+
+import (
+ "ai-agent/gateway"
+ sessionDao "ai-agent/workflow/dao/session"
+ sessionDto "ai-agent/workflow/model/dto/session"
+ "ai-agent/workflow/model/entity"
+ "context"
+ "errors"
+ "fmt"
+ "time"
+
+ "ai-agent/tools/runner"
+
+ "gitea.redpowerfuture.com/red-future/common/tools"
+ wsCommon "gitea.redpowerfuture.com/red-future/common/websocket"
+
+ "github.com/gogf/gf/v2/os/glog"
+ "github.com/gogf/gf/v2/util/gconv"
+)
+
+func init() {
+ // 普通对话消息处理器（会话服务器 SessionWsService 见 ws_server.go）
+ SessionWsService.OnMessage("agent", handleToolAgent)
+ SessionWsService.OnMessage("agent_cancel", handleToolAgentCancel)
+}
+
+// 工具对话默认系统提示词
+const defaultAgentSystemPrompt = "你是一个智能助手，可以调用工具完成任务。请根据任务需要选择合适的工具，参考工具返回结果，最终给出完整回答。"
+
+// 工具对话 ReAct 最大循环步数
+const defaultAgentMaxStep = 15
+
+// handleToolAgent 处理工具对话消息：解析 payload 后异步运行 ReAct 循环，逐步推送过程事件。
+// 首条消息惰性建会话（复用已存在会话），跑完后把问答/token 写入 exec_chat 落库。
+func handleToolAgent(ctx context.Context, conn *wsCommon.WsConnection, payload interface{}) {
+ var p sessionDto.WebSocketExecChatReq
+ if err := gconv.Struct(payload, &p); err != nil {
+ pushAgentEvent(conn, runner.ReActEvent{Type: runner.ReActEventError, Message: "参数解析失败", Error: err.Error()})
+ return
+ }
+ if p.Question == "" {
+ pushAgentEvent(conn, runner.ReActEvent{Type: runner.ReActEventError, Message: "内容不能为空", Error: "提问内容不能为空"})
+ return
+ }
+
+ modelTools, err := tools.Default.List(ctx)
+ if err != nil {
+ pushAgentEvent(conn, runner.ReActEvent{Type: runner.ReActEventError, Message: "工具列表获取失败", Error: err.Error()})
+ return
+ }
+ systemPrompt := p.SystemPrompt
+ if systemPrompt == "" {
+ systemPrompt = defaultAgentSystemPrompt
+ }
+
+ // 支持前端终止：agent 上下文可取消；落库用不带取消的 ctx（保留 request 值），保证终止后 token 仍能记录
+ agentCtx, agentCancel := context.WithCancel(ctx)
+ if oldCancel := getToolCancel(conn); oldCancel != nil {
+ oldCancel()
+ }
+ conn.SetMeta("toolCancel", agentCancel)
+ defer conn.SetMeta("toolCancel", nil)
+ defer agentCancel()
+ saveCtx := context.WithoutCancel(ctx)
+
+ // 会话落库：前端临时 sessionId 对应已存在会话则复用，否则新建
+ err = ensureSession(saveCtx, conn.SessionId, p.Question)
+ if err != nil {
+ pushAgentEvent(conn, runner.ReActEvent{Type: runner.ReActEventError, Message: "会话创建失败", Error: err.Error()})
+ }
+
+ agent := runner.NewReActAgent(p.ModelId, conn.SessionId, modelTools, systemPrompt, defaultAgentMaxStep)
+ agent.OnEvent = func(ev runner.ReActEvent) {
+ pushAgentEvent(conn, ev)
+ }
+
+ start := time.Now()
+ answer, runErr := agent.Run(agentCtx, p.Question)
+ duration := int64(time.Since(start).Seconds())
+
+ // 前端终止：结果/错误不推前端，仅把已产生的 token 正常落库（错误记「用户已终止对话」）
+ terminated := runErr != nil && errors.Is(runErr, context.Canceled)
+ if terminated {
+ runErr = errChatTerminated
+ } else if runErr != nil {
+ pushAgentEvent(conn, runner.ReActEvent{Type: runner.ReActEventError, Message: "对话运行失败", Error: runErr.Error()})
+ }
+ recordChat(saveCtx, conn.SessionId, p.Question, answer, runErr, agent.TotalTokens, agent.TotalCost, duration)
+}
+
+// handleToolAgentCancel 终止正在运行的对话（前端停止按钮发送 agent_cancel）
+func handleToolAgentCancel(ctx context.Context, conn *wsCommon.WsConnection, _ interface{}) {
+ if cancel := getToolCancel(conn); cancel != nil {
+ cancel()
+ }
+ _ = conn.WriteJSON(&wsCommon.WsPushMsg{Type: "ack", Message: "已终止对话"})
+}
+
+// getToolCancel 获取当前 agent 运行的取消函数
+func getToolCancel(conn *wsCommon.WsConnection) context.CancelFunc {
+ cancel, _ := wsCommon.GetMetaT[context.CancelFunc](conn, "toolCancel")
+ return cancel
+}
+
+// errChatTerminated 前端终止对话的错误标记（写入 exec_chat.error_message）
+var errChatTerminated = errors.New("用户已终止对话")
+
+// recordChat 把一次普通对话写入 exec_chat：答案传 OSS 存 result_file_url，错误写 error_message，
+// token 与费用（模型网关返回的累计 cost）落库
+func recordChat(ctx context.Context, sessionId string, question, answer string, runErr error, totalTokens int64, totalCost float64, duration int64) {
+ var resultFileUrl, errorMessage string
+ if runErr == nil && answer != "" {
+ //answerJSON := gjson.New(map[string]any{"answer": answer}).MustToJson()
+ url, uploadErr := gateway.Upload(ctx, fmt.Sprintf("chat_%v_%d.txt", sessionId, time.Now().UnixMilli()), []byte(answer))
+ if uploadErr != nil {
+ glog.Errorf(ctx, "普通对话答案上传OSS失败: %v", uploadErr)
+ } else {
+ resultFileUrl = url
+ }
+ } else if runErr != nil {
+ errorMessage = runErr.Error()
+ }
+ _, err := sessionDao.ExecChatDao.Insert(ctx, &sessionDto.CreateExecChatReq{
+ SessionId: sessionId,
+ Duration: duration,
+ RequestParams: entity.ExecChatRequestParams{Question: question},
+ ResultFileUrl: resultFileUrl,
+ TotalTokens: int(totalTokens),
+ TotalFee: totalCost,
+ ErrorMessage: errorMessage,
+ })
+ if err != nil {
+ glog.Errorf(ctx, "普通对话落库失败: %v", err)
+ }
+}
+
+// pushAgentEvent 把 ReAct 过程事件转为 WS 推送消息
+func pushAgentEvent(conn *wsCommon.WsConnection, ev runner.ReActEvent) {
+ if conn.IsClosed() {
+ return
+ }
+ switch ev.Type {
+ case runner.ReActEventModelCall:
+ _ = conn.WriteJSON(&wsCommon.WsPushMsg{
+ Type: string(ev.Type),
+ Message: "模型思考中",
+ Data: map[string]interface{}{"step": ev.Step, "maxStep": ev.MaxStep},
+ })
+ case runner.ReActEventToolCall:
+ _ = conn.WriteJSON(&wsCommon.WsPushMsg{
+ Type: string(ev.Type),
+ Message: "调用工具",
+ Data: map[string]interface{}{"description": ev.Description},
+ })
+ case runner.ReActEventToolResult:
+ _ = conn.WriteJSON(&wsCommon.WsPushMsg{
+ Type: string(ev.Type),
+ Message: "工具返回",
+ Data: map[string]interface{}{"description": ev.Description},
+ })
+ case runner.ReActEventAnswerChunk:
+ _ = conn.WriteJSON(&wsCommon.WsPushMsg{
+ Type: string(ev.Type),
+ Message: "思考中",
+ Data: map[string]interface{}{"delta": ev.Delta},
+ })
+ case runner.ReActEventReasoningChunk:
+ _ = conn.WriteJSON(&wsCommon.WsPushMsg{
+ Type: string(ev.Type),
+ Message: "思考中",
+ Data: map[string]interface{}{"delta": ev.Delta},
+ })
+ case runner.ReActEventAnswer:
+ _ = conn.WriteJSON(&wsCommon.WsPushMsg{
+ Type: string(ev.Type),
+ Message: "作答完成",
+ Data: map[string]interface{}{"answer": ev.Answer},
+ })
+ case runner.ReActEventError:
+ _ = conn.WriteJSON(&wsCommon.WsPushMsg{Type: string(ev.Type), Message: ev.Message, Error: ev.Error})
+ }
+}
diff --git a/workflow/service/flow/ws_server.go b/workflow/service/flow/ws_server.go
new file mode 100644
index 0000000..0c22140
--- /dev/null
+++ b/workflow/service/flow/ws_server.go
@@ -0,0 +1,41 @@
+package flow
+
+import (
+ "context"
+
+ sessionDao "ai-agent/workflow/dao/session"
+ sessionDto "ai-agent/workflow/model/dto/session"
+
+ wsCommon "gitea.redpowerfuture.com/red-future/common/websocket"
+ "github.com/gogf/gf/v2/net/ghttp"
+)
+
+// SessionWsService 会话 WebSocket 服务器：普通对话与工作流共用一条连接，
+// 首次连接仅升级，后续按消息 type 路由到对话/工作流处理器
+// （对话处理器在 react_ws_exec.go 注册，工作流处理器在 flow_ws_exec.go 注册）。
+var SessionWsService = wsCommon.NewWsServer(
+ wsCommon.WithConnKeyPrefix("ws:session:"),
+)
+
+// WsConnect 控制器统一入口：升级 WebSocket（普通对话/工作流均由消息 type 区分，此处不区分）
+func WsConnect(ctx context.Context, r *ghttp.Request, req *sessionDto.WebSocketConnectReq) error {
+ _, err := SessionWsService.Upgrade(ctx, r, req.SessionId)
+ return err
+}
+
+// ensureSession 解析前端 sessionId 并确保会话存在：命中已存在会话则复用其 id，否则按 name 新建。
+// 普通对话（react_ws_exec.go）与工作流（flow_ws_exec.go）共用。
+func ensureSession(ctx context.Context, sessionId string, name string) error {
+ exist, err := sessionDao.SessionDao.GetById(ctx, sessionId)
+ if err != nil {
+ return err
+ }
+ if exist != nil {
+ return nil
+ }
+ if r := []rune(name); len(r) > 128 { // session_name VARCHAR(128)
+ name = string(r[:128])
+ }
+ _, err = sessionDao.SessionDao.Insert(ctx, &sessionDto.CreateSessionReq{SessionId: sessionId, SessionName: name})
+ return err
+}
diff --git a/workflow/service/node/node_library_service.go b/workflow/service/node/node_library_service.go
index c7c553d..8a01936 100644
--- a/workflow/service/node/node_library_service.go
+++ b/workflow/service/node/node_library_service.go
@@ -1,14 +1,14 @@
package node
import (
+ "context"
+ "strconv"
+
+ "ai-agent/gateway"
+ "ai-agent/workflow/consts/model"
"ai-agent/workflow/consts/node"
nodeDto "ai-agent/workflow/model/dto/node"
- "context"
- "fmt"
- "gitea.redpowerfuture.com/red-future/common/beans"
- commonHttp "gitea.redpowerfuture.com/red-future/common/http"
- "github.com/gogf/gf/v2/encoding/gjson"
"github.com/gogf/gf/v2/frame/g"
)
@@ -16,370 +16,55 @@ var NodeLibraryService = &nodeLibraryService{}
type nodeLibraryService struct{}
-func GetModelType(ctx context.Context) (mainTypeMap map[int]string, err error) {
- headers := make(map[string]string)
- if r := g.RequestFromCtx(ctx); r != nil {
- for k, v := range r.Request.Header {
- if len(v) > 0 {
- headers[k] = v[0]
- }
- }
- }
- res := new(nodeDto.ModelTypeResponse)
- err = commonHttp.Get(ctx, "model-gateway/model/listType", headers, res, nil)
- // 通用过滤：只保留 能被 100 整除的主类型（100/200/300...）
- mainTypeMap = make(map[int]string)
- for typ, name := range res.Type {
- if typ%100 == 0 {
- mainTypeMap[typ] = name
- }
- }
- return
-}
-
func (s *nodeLibraryService) GetNodeLibrary(ctx context.Context, req *nodeDto.WorkflowNodeTreeReq) (*nodeDto.WorkflowNodeTreeRes, error) {
- WorkflowNodeGroups := []node.NodeGroupItem{
- {
- Group: node.NodeGroupComponent,
- Label: node.NodeGroupNameComponent,
- Items: []node.NodeItem{
- {
- NodeCode: node.NodeTypeTextModel,
- NodeName: node.NodeNameTextModel,
- ModelType: node.ModelTypeText,
- SkillOption: false,
- PromptOption: true,
- IsSaveFile: true,
- FormConfig: []node.NodeFormField{},
- ModelConfig: []node.ModelItem{},
- },
- {
- NodeCode: node.NodeTypeImageModel,
- NodeName: node.NodeNameImageModel,
- ModelType: node.ModelTypeImage,
- SkillOption: false,
- PromptOption: true,
- IsSaveFile: true,
- FormConfig: []node.NodeFormField{},
- ModelConfig: []node.ModelItem{},
- },
- {
- NodeCode: node.NodeTypeVideoModel,
- NodeName: node.NodeNameVideoModel,
- ModelType: node.ModelTypeVideo,
- SkillOption: false,
- PromptOption: true,
- IsSaveFile: true,
- FormConfig: []node.NodeFormField{},
- ModelConfig: []node.ModelItem{},
- },
- {
- NodeCode: node.NodeTypeAudioModel,
- NodeName: node.NodeNameAudioModel,
- ModelType: node.ModelTypeAudio,
- SkillOption: false,
- PromptOption: true,
- IsSaveFile: true,
- FormConfig: []node.NodeFormField{},
- ModelConfig: []node.ModelItem{},
- },
- {
- NodeCode: node.NodeTypeBatchModel,
- NodeName: node.NodeNameBatchModel,
- ModelType: node.ModelTypeText,
- SkillOption: false,
- PromptOption: true,
- IsSaveFile: true,
- FormConfig: []node.NodeFormField{},
- ModelConfig: []node.ModelItem{},
- },
- },
- },
- {
- Group: node.NodeGroupBase,
- Label: node.NodeGroupNameBase,
- Items: []node.NodeItem{
- {
- NodeCode: node.NodeTypeSubFlow,
- NodeName: node.NodeSubFlow,
- SkillOption: false,
- PromptOption: false,
- IsSaveFile: false,
- FormConfig: []node.NodeFormField{
- {Field: "maxConcurrency", Label: "最大并发数", Type: "input", Required: true},
- },
- ModelConfig: []node.ModelItem{},
- },
- {
- NodeCode: node.NodeTypeDataConversionModel,
- NodeName: node.NodeNameDataConversionModel,
- ModelType: node.ModelTypeText,
- SkillOption: false,
- PromptOption: true,
- FormConfig: []node.NodeFormField{},
- ModelConfig: []node.ModelItem{},
- },
- {
- NodeCode: node.NodeTypeMerge,
- NodeName: node.NodeNameMerge,
- SkillOption: false,
- FormConfig: []node.NodeFormField{},
- ModelConfig: []node.ModelItem{},
- },
- {
- NodeCode: node.NodeTypeDataMerge,
- NodeName: node.NodeNameDataMerge,
- SkillOption: false,
- FormConfig: []node.NodeFormField{},
- ModelConfig: []node.ModelItem{},
- },
- {
- NodeCode: node.NodeTypeJudge,
- NodeName: node.NodeNameJudge,
- SkillOption: false,
- FormConfig: []node.NodeFormField{
- {Field: "condition", Label: node.FormLabelCondition, Type: "input", Required: true},
- },
- ModelConfig: []node.ModelItem{},
- },
- {
- NodeCode: node.NodeTypeForm,
- NodeName: node.NodeNameForm,
- SkillOption: false,
- FormConfig: []node.NodeFormField{},
- ModelConfig: []node.ModelItem{},
- },
- {
- NodeCode: node.NodeTypeHttp,
- NodeName: node.NodeNameHttp,
- SkillOption: false,
- IsSaveFile: true,
- FormConfig: []node.NodeFormField{
- {
- Field: "method",
- Label: "请求方式",
- Type: "select",
- Required: true,
- Options: []node.SelectOption{
- {Label: "GET", Value: "GET"},
- {Label: "POST", Value: "POST"},
- {Label: "PUT", Value: "PUT"},
- {Label: "DELETE", Value: "DELETE"},
- },
- },
- {
- Field: "url",
- Label: "请求地址",
- Type: "input",
- Required: true,
- },
- {
- Field: "headers",
- Label: "请求头（支持Authorization鉴权）",
- Type: "keyValue",
- Required: false,
- },
- {
- Field: "bodyType",
- Label: "请求体类型",
- Type: "select",
- Required: true,
- Options: []node.SelectOption{
- {Label: "无", Value: "None"},
- {Label: "JSON", Value: "JSON"},
- //{Label: "表单", Value: "FormUrlEncoded"},
- //{Label: "文件上传", Value: "FormData"},
- //{Label: "原生文本", Value: "Raw"},
- },
- },
- {
- Field: "body",
- Label: "请求体内容",
- Type: "keyValue",
- Required: false,
- },
- {
- Field: "response",
- Label: "结果返回结构",
- Type: "keyValue",
- Required: false,
- },
- {
- Field: "responseType",
- Label: "结果返回方式",
- Type: "select",
- Required: true,
- Options: []node.SelectOption{
- {Label: "同步返回", Value: "sync"},
- {Label: "等候回调", Value: "callback"},
- {Label: "主动拉取", Value: "pull"},
- },
- Expand: []node.NodeFormField{
- {
- Field: "method",
- Label: "请求方式",
- Type: "select",
- Required: true,
- Options: []node.SelectOption{
- {Label: "GET", Value: "GET"},
- {Label: "POST", Value: "POST"},
- {Label: "PUT", Value: "PUT"},
- {Label: "DELETE", Value: "DELETE"},
- },
- },
- {
- Field: "url",
- Label: "请求地址",
- Type: "input",
- Required: true,
- },
- {
- Field: "headers",
- Label: "请求头（支持Authorization鉴权）",
- Type: "keyValue",
- Required: false,
- },
- {
- Field: "bodyType",
- Label: "请求体类型",
- Type: "select",
- Required: true,
- Options: []node.SelectOption{
- {Label: "无", Value: "None"},
- {Label: "JSON", Value: "JSON"},
- //{Label: "表单", Value: "FormUrlEncoded"},
- //{Label: "文件上传", Value: "FormData"},
- //{Label: "原生文本", Value: "Raw"},
- },
- },
- {
- Field: "body",
- Label: "请求体内容",
- Type: "keyValue",
- Required: false,
- },
- {
- Field: "response",
- Label: "结果返回结构",
- Type: "keyValue",
- Required: false,
- },
- {
- Field: "timeout",
- Label: "超时时间(秒)",
- Type: "inputNumber",
- Required: false,
- Default: 30,
- },
- {
- Field: "insecureSkipVerify",
- Label: "跳过HTTPS证书校验",
- Type: "switch",
- Required: false,
- Default: false,
- },
- },
- },
- {
- Field: "callbackUrl",
- Label: "回调地址（只需要填写字段名称）",
- Type: "input",
- Required: false,
- Default: "",
- },
- {
- Field: "timeout",
- Label: "超时时间(秒)",
- Type: "inputNumber",
- Required: false,
- Default: 30,
- },
- {
- Field: "insecureSkipVerify",
- Label: "跳过HTTPS证书校验",
- Type: "switch",
- Required: false,
- Default: false,
- },
- },
- ModelConfig: []node.ModelItem{},
- },
- //{
- // NodeCode: node.NodeTypeModel,
- // NodeName: node.NodeNameModel,
- // SkillOption: true,
- // FormConfig: []node.NodeFormField{},
- // ModelConfig: []node.ModelItem{},
- //},
- },
- },
- //{
- // Group: node.NodeGroupCustom,
- // Label: node.NodeGroupNameCustom,
- // Items: []node.NodeItem{
- // {
- // NodeCode: node.NodeTypeCustomNode,
- // NodeName: node.NodeNameCustomNode,
- // SkillOption: true,
- // FormConfig: []node.NodeFormField{
- // {Field: "nodeName", Label: node.FormLabelApiKey, Type: "input", Required: true},
- // {Field: "nodeType", Label: node.FormLabelModel, Type: "input", Required: true},
- // },
- // ModelConfig: []node.ModelItem{},
- // },
- // },
- //},
+ tree := node.GetFilterNodeTree([]node.NodeGroup{node.NodeGroupBase})
+ if opts, err := videoModelOptions(ctx); err != nil {
+ g.Log().Warningf(ctx, "加载视频模型选项失败，节点库降级返回: %v", err)
+ } else {
+ applyVideoModelOptions(tree, opts)
}
- tree := &nodeDto.WorkflowNodeTreeRes{
- Groups: WorkflowNodeGroups,
- }
-
- // 3. 遍历分组，根据 typeId=1 给【文本模型节点】追加固定表单
- for gIdx := range tree.Groups {
- group := &tree.Groups[gIdx]
-
- // 遍历分组下的每个节点
- for itemIdx := range group.Items {
- item := &group.Items[itemIdx]
- if item.NodeCode == node.NodeTypeTextModel ||
- item.NodeCode == node.NodeTypeImageModel ||
- item.NodeCode == node.NodeTypeVideoModel ||
- item.NodeCode == node.NodeTypeAudioModel ||
- item.NodeCode == node.NodeTypeBatchModel ||
- item.NodeCode == node.NodeTypeDataConversionModel {
- item.ModelConfig = append(item.ModelConfig, node.ModelItem{
- ModelName: "自定义",
- })
- }
- }
- }
-
- return tree, nil
+ return &nodeDto.WorkflowNodeTreeRes{
+ Groups: tree,
+ }, nil
}
-// SetUserInfo 设置用户信息
-func (s *nodeLibraryService) SetUserInfo(ctx context.Context, creator string, tenantId uint64) (headers map[string]string, err error) {
- // 创建完整的用户信息
- userInfo := &beans.User{
- UserName: creator,
- TenantId: tenantId,
- }
- ctx = context.WithValue(ctx, "user", *userInfo)
- // 提取并保存请求头（在连接升级前）
- headers = make(map[string]string)
- // 提取其他headers
- if r := g.RequestFromCtx(ctx); r != nil {
- for k, v := range r.Request.Header {
- if len(v) > 0 {
- headers[k] = v[0]
- }
- }
- }
- // 将完整用户信息序列化为JSON，放到X-User-Info请求头
- userInfoJson, err := gjson.Encode(userInfo)
+// videoModelOptions 按视频模型类型（600）查模型网关，转成 modelId 下拉选项：key=模型ID，value=模型名称。
+func videoModelOptions(ctx context.Context) ([]node.SelectOption, error) {
+ res, err := gateway.ListModelManage(ctx, &gateway.ListModelManageReq{ModelType: model.TypeVideo})
if err != nil {
- return nil, fmt.Errorf("用户信息序列化失败: %w", err)
+ return nil, err
+ }
+ opts := make([]node.SelectOption, 0, len(res.List))
+ for _, item := range res.List {
+ if item == nil || item.Id <= 0 || item.ModelName == "" {
+ continue
+ }
+ opts = append(opts, node.SelectOption{
+ Key: strconv.FormatInt(item.Id, 10),
+ Value: item.ModelName,
+ })
+ }
+ return opts, nil
+}
+
+// applyVideoModelOptions 把 script_transcribe 节点的 modelId 预设下拉替换为视频模型选项。
+// 深拷贝 PresetOption 后再改，避免改写全局 NodeTypeMetaList。
+func applyVideoModelOptions(tree []node.NodeGroupTree, opts []node.SelectOption) {
+ for gi := range tree {
+ for ni := range tree[gi].Nodes {
+ n := &tree[gi].Nodes[ni]
+ if n.Key != node.NodeTypeScriptTranscribe {
+ continue
+ }
+ presets := append([]node.NodePresetField(nil), n.PresetOption...)
+ for pi := range presets {
+ if presets[pi].Field == "modelId" {
+ presets[pi].Options = opts
+ break
+ }
+ }
+ n.PresetOption = presets
+ return
+ }
}
- headers["X-User-Info"] = string(userInfoJson)
- return
}
diff --git a/workflow/service/session/session_service.go b/workflow/service/session/session_service.go
index 5c7c779..fa96184 100644
--- a/workflow/service/session/session_service.go
+++ b/workflow/service/session/session_service.go
@@ -1,14 +1,23 @@
package session
import (
+ "ai-agent/gateway"
+ "ai-agent/workflow/consts/flow"
+ flowDao "ai-agent/workflow/dao/flow"
sessionDao "ai-agent/workflow/dao/session"
+ flowDto "ai-agent/workflow/model/dto/flow"
sessionDto "ai-agent/workflow/model/dto/session"
"ai-agent/workflow/model/entity"
+ flowService "ai-agent/workflow/service/flow"
"context"
+ "fmt"
"sort"
"strings"
+ "gitea.redpowerfuture.com/red-future/common/beans"
"gitea.redpowerfuture.com/red-future/common/utils"
+ "github.com/gogf/gf/v2/os/glog"
+ "github.com/gogf/gf/v2/util/gconv"
)
var SessionService = &sessionService{}
@@ -19,6 +28,7 @@ type sessionService struct{}
const (
resultStatusSuccess = 2
resultStatusFailed = 3
+ resultStatusCancel = 4
)
func (s *sessionService) List(ctx context.Context, req *sessionDto.ListSessionReq) (res *sessionDto.ListSessionRes, err error) {
@@ -26,14 +36,18 @@ func (s *sessionService) List(ctx context.Context, req *sessionDto.ListSessionRe
if err != nil {
return
}
- list, total, err := sessionDao.SessionDao.List(ctx, user.UserName, req.Page)
+ var page *beans.Page
+ if req.PageSize > 0 {
+ page = &beans.Page{PageNum: req.PageNum, PageSize: req.PageSize}
+ }
+ list, total, err := sessionDao.SessionDao.List(ctx, user.UserName, page)
if err != nil {
return
}
res = &sessionDto.ListSessionRes{Total: total}
for _, item := range list {
res.List = append(res.List, &sessionDto.VOSession{
- Id: item.Id,
+ SessionId: item.SessionId,
SessionName: item.SessionName,
CreatedAt: item.CreatedAt,
})
@@ -46,6 +60,28 @@ func (s *sessionService) Delete(ctx context.Context, req *sessionDto.DeleteSessi
return
}
+func (s *sessionService) DeleteRecord(ctx context.Context, req *sessionDto.DeleteSessionRecordReq) (err error) {
+ var chatIds, wfIds []int64
+ for _, item := range req.Ids {
+ if item.Type == "chat" {
+ chatIds = append(chatIds, item.Id)
+ } else {
+ wfIds = append(wfIds, item.Id)
+ }
+ }
+ if len(chatIds) > 0 {
+ if _, e := sessionDao.ExecChatDao.Delete(ctx, &sessionDto.DeleteExecChatReq{Id: chatIds}); e != nil {
+ return e
+ }
+ }
+ if len(wfIds) > 0 {
+ if _, e := sessionDao.ExecWorkflowDao.Delete(ctx, &sessionDto.DeleteExecWorkflowReq{Id: wfIds}); e != nil {
+ return e
+ }
+ }
+ return
+}
+
// Get 会话内结果：普通对话 + 工作流执行混排，按创建时间倒序，分页
func (s *sessionService) Get(ctx context.Context, req *sessionDto.GetSessionInfoReq) (res *sessionDto.GetSessionInfoRes, err error) {
chatList, err := sessionDao.ExecChatDao.ListBySession(ctx, req.SessionId)
@@ -60,16 +96,18 @@ func (s *sessionService) Get(ctx context.Context, req *sessionDto.GetSessionInfo
if err != nil {
return
}
+ prefix, _ := utils.GetFileAddressPrefix(ctx)
// 工作流结果按 exec_id 分组，合并到对应执行记录的结果文件URL
resultByExec := make(map[int64][]string)
for _, wr := range wfResultList {
if wr.ResultFileUrl != "" {
- resultByExec[wr.ExecId] = append(resultByExec[wr.ExecId], wr.ResultFileUrl)
+ resultByExec[wr.ExecId] = append(resultByExec[wr.ExecId], prefix+wr.ResultFileUrl)
}
}
res = &sessionDto.GetSessionInfoRes{}
for _, c := range chatList {
+ c.ResultFileUrl = prefix + c.ResultFileUrl
res.List = append(res.List, chatExecVO(c))
}
for _, w := range wfList {
@@ -87,8 +125,8 @@ func (s *sessionService) Get(ctx context.Context, req *sessionDto.GetSessionInfo
})
res.Total = len(res.List)
- if req.Page != nil && req.Page.PageSize > 0 {
- start := int((req.Page.PageNum - 1) * req.Page.PageSize)
+ if req.PageSize > 0 {
+ start := int((req.PageNum - 1) * req.PageSize)
if start < 0 {
start = 0
}
@@ -96,15 +134,41 @@ func (s *sessionService) Get(ctx context.Context, req *sessionDto.GetSessionInfo
res.List = nil
return
}
- end := start + int(req.Page.PageSize)
+ end := start + int(req.PageSize)
if end > res.Total {
end = res.Total
}
res.List = res.List[start:end]
}
+
+ // 读取结果文件内容（仅 .txt）放入 ResultContent（仅当前页），供前端直接展示；路径仍保留在 ResultFileUrl
+ for _, vo := range res.List {
+ vo.ResultContent = readResultFileContent(ctx, vo.ResultFileUrl)
+ }
return
}
+// readResultFileContent 读取结果 txt 文件内容（支持逗号分隔的多个 URL），仅 .txt 文件被读取，多个内容用换行连接
+func readResultFileContent(ctx context.Context, fileUrl string) string {
+ if fileUrl == "" {
+ return ""
+ }
+ var parts []string
+ for _, u := range strings.Split(fileUrl, ",") {
+ u = strings.TrimSpace(u)
+ if u == "" || !strings.HasSuffix(strings.ToLower(u), ".txt") {
+ continue
+ }
+ fileBytes, err := gateway.GetFileBytesFromURL(ctx, u)
+ if err != nil {
+ glog.Warningf(ctx, "读取结果 txt 文件失败: %v", err)
+ continue
+ }
+ parts = append(parts, string(fileBytes))
+ }
+ return strings.Join(parts, "\n")
+}
+
func chatExecVO(c *entity.ExecChat) *sessionDto.VOSessionInfoResult {
status := resultStatusSuccess
if c.ErrorMessage != "" {
@@ -124,12 +188,20 @@ func chatExecVO(c *entity.ExecChat) *sessionDto.VOSessionInfoResult {
}
func workflowExecVO(w *entity.ExecWorkflow, resultFileUrl string) *sessionDto.VOSessionInfoResult {
+ status := 1
+ if w.Status == flow.FlowExecutionStatusFailed.Code() {
+ status = resultStatusFailed
+ } else if w.Status == flow.FlowExecutionStatusSuccess.Code() {
+ status = resultStatusSuccess
+ } else if w.Status == flow.FlowExecutionStatusCancel.Code() {
+ status = resultStatusCancel
+ }
return &sessionDto.VOSessionInfoResult{
Id: w.Id,
Type: "workflow",
- Status: w.Status,
+ Status: status,
FlowId: w.FlowId,
- RequestParams: w.RequestParams,
+ RequestParams: gconv.Map(w.RequestParams),
ResultFileUrl: resultFileUrl,
TotalTokens: w.TotalTokens,
TotalFee: w.TotalFee,
@@ -137,3 +209,120 @@ func workflowExecVO(w *entity.ExecWorkflow, resultFileUrl string) *sessionDto.VO
CreatedAt: w.CreatedAt,
}
}
+
+// ResultList 工作流执行结果树：按创建人分页查询工作流执行记录，返回按天分组的树结构（日期→流程→结果文件）。
+// 分页单位为"天"：每页返回 pageSize 个完整日期，同一天内的流程与文件不会被拆到不同页；pageSize 为 0 时返回全部。
+func (s *sessionService) ResultList(ctx context.Context, req *sessionDto.ListWorkflowResultReq) (res *flowDto.ListFlowExecutionTreeRes, err error) {
+ user, err := utils.GetUserInfo(ctx)
+ if err != nil {
+ return
+ }
+ dates, err := sessionDao.ExecWorkflowDao.ListDates(ctx, user.UserName, req.Page)
+ if err != nil {
+ return
+ }
+ res = &flowDto.ListFlowExecutionTreeRes{}
+ res.ImgAddressPrefix, _ = utils.GetFileAddressPrefix(ctx)
+ if len(dates) == 0 {
+ return
+ }
+
+ execs, err := sessionDao.ExecWorkflowDao.ListByDates(ctx, user.UserName, dates)
+ if err != nil {
+ return
+ }
+
+ // 汇总本页所有执行的 id 与去重后的流程 id，一次取回结果文件与流程名
+ var execIds []int64
+ flowIdSet := make(map[int64]struct{})
+ for _, e := range execs {
+ execIds = append(execIds, e.Id)
+ flowIdSet[e.FlowId] = struct{}{}
+ }
+ results, err := sessionDao.ExecWorkflowResultDao.ListByExecIds(ctx, execIds)
+ if err != nil {
+ return
+ }
+ flowNameMap := make(map[int64]string)
+ for fid := range flowIdSet {
+ if fu, e := flowDao.FlowUserDao.Get(ctx, &flowDto.GetFlowUserReq{Id: fid}); e == nil && fu != nil && fu.FlowName != "" {
+ flowNameMap[fid] = fu.FlowName
+ }
+ }
+
+ resultsByExec := make(map[int64][]*entity.ExecWorkflowResult)
+ for _, r := range results {
+ resultsByExec[r.ExecId] = append(resultsByExec[r.ExecId], r)
+ }
+ execsByDate := make(map[string][]*entity.ExecWorkflow)
+ for _, e := range execs {
+ date := ""
+ if e.CreatedAt != nil {
+ date = e.CreatedAt.Format("Y-m-d")
+ }
+ execsByDate[date] = append(execsByDate[date], e)
+ }
+
+ prefix := res.ImgAddressPrefix
+ for _, d := range dates {
+ execList := execsByDate[d]
+ if len(execList) == 0 {
+ continue
+ }
+ var flows []flowDto.FlowNode
+ for _, e := range execList {
+ flowName := flowNameMap[e.FlowId]
+ if flowName == "" {
+ flowName = "工作流"
+ }
+ var items []flowDto.OutputItem
+ suffixCount := make(map[string]int)
+ for _, rf := range resultsByExec[e.Id] {
+ if rf.ResultFileUrl == "" {
+ continue
+ }
+ content := prefix + rf.ResultFileUrl
+ ext := flowService.GetFileTypeByPath(content)
+ suffix := outputItemSuffix(ext)
+ suffixCount[suffix]++
+ items = append(items, flowDto.OutputItem{
+ Content: content,
+ Type: ext,
+ Label: fmt.Sprintf("%s_%d", suffix, suffixCount[suffix]),
+ })
+ }
+ if len(items) == 0 {
+ continue
+ }
+ flows = append(flows, flowDto.FlowNode{
+ FlowName: flowName,
+ Id: e.Id,
+ SessionId: e.SessionId,
+ Items: items,
+ })
+ }
+ if len(flows) == 0 {
+ continue
+ }
+ res.Tree = append(res.Tree, flowDto.DateNode{CreateDate: d, Flows: flows})
+ }
+ return
+}
+
+// outputItemSuffix 按文件类型映射结果项的中文标签前缀（与 flow 侧旧逻辑保持一致）
+func outputItemSuffix(ext string) string {
+ switch ext {
+ case "image":
+ return "图片"
+ case "video":
+ return "视频"
+ case "audio":
+ return "音频"
+ case "text":
+ return "文案"
+ case "html":
+ return "HTML"
+ default:
+ return "内容"
+ }
+}
diff --git a/workflow/service/tool/tool_service.go b/workflow/service/tool/tool_service.go
new file mode 100644
index 0000000..d7cebc3
--- /dev/null
+++ b/workflow/service/tool/tool_service.go
@@ -0,0 +1,26 @@
+package tool
+
+import (
+ toolDto "ai-agent/workflow/model/dto/tool"
+ "ai-agent/workflow/service/flow/processor"
+ "context"
+)
+
+var ToolService = &toolService{}
+
+type toolService struct{}
+
+func (s *toolService) List(ctx context.Context, req *toolDto.ToolListReq) (*toolDto.ToolListRes, error) {
+ list, err := processor.List(ctx)
+ if err != nil {
+ return nil, err
+ }
+ voList := make([]*toolDto.ToolVO, 0, len(list))
+ for _, t := range list {
+ voList = append(voList, &toolDto.ToolVO{
+ Name: t.Name,
+ Description: t.Description,
+ })
+ }
+ return &toolDto.ToolListRes{List: voList}, nil
+}
([\s\S]*?)
`)
- matches := re.FindAllStringSubmatch(htmlContent, -1)
- for _, match := range matches {
- if len(match) > 1 {
- // 清理空内容
- trimmed := strings.TrimSpace(match[1])
- if trimmed != "" {
- contents = append(contents, trimmed)
- }
- }
- }
- // 兜底：如果没有匹配到结构化内容，按换行/分隔符拆分
- if len(contents) == 0 {
- contents = strings.Split(htmlContent, "===分隔符===") // 提示词中可新增此兜底规则
- }
- return contents
-}
-
-// GetAllImgSrcFromHtml 先把提取img src的工具方法放在外面
-func GetAllImgSrcFromHtml(html string) []string {
- var imgSrcList []string
- re := regexp.MustCompile(`