包裹的内容
- re := regexp.MustCompile(`
([\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(`
]*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}`)
-}
diff --git a/workflow/service/flow/flow_graph_builder.go b/workflow/service/flow/graph_build.go
similarity index 65%
rename from workflow/service/flow/flow_graph_builder.go
rename to workflow/service/flow/graph_build.go
index 651fbed..04bde00 100644
--- a/workflow/service/flow/flow_graph_builder.go
+++ b/workflow/service/flow/graph_build.go
@@ -14,9 +14,9 @@ import (
"github.com/gogf/gf/v2/util/gconv"
)
-// BuildGraph 根据 FlowInfo 构建完整的 Eino Graph 拓扑
-func BuildGraph(ctx context.Context, flowContent *entity.FlowInfo) ([]entity.FlowNode, *compose.Graph[any, any]) {
- // 注册自定义合并函数：处理 *flowDto.FlowExecutionInput 类型合并
+// init 注册自定义合并函数：处理 *flowDto.FlowExecutionInput 类型合并。
+// 合并函数全局唯一且与图内容无关，放包级 init 注册一次（避免每次 BuildGraph 重注册全局状态）。
+func init() {
compose.RegisterValuesMergeFunc(func(values []*flowDto.FlowExecutionInput) (*flowDto.FlowExecutionInput, error) {
if len(values) == 0 {
return nil, nil
@@ -59,7 +59,10 @@ func BuildGraph(ctx context.Context, flowContent *entity.FlowInfo) ([]entity.Flo
}
return base, nil
})
+}
+// BuildGraph 根据 FlowInfo 构建完整的 Eino Graph 拓扑
+func BuildGraph(ctx context.Context, flowContent *entity.FlowInfo) ([]entity.FlowNode, *compose.Graph[any, any]) {
graph := compose.NewGraph[any, any](
// 本地状态初始化
compose.WithGenLocalState(func(ctx context.Context) *flowDto.NodeExecutionState {
@@ -68,12 +71,8 @@ func BuildGraph(ctx context.Context, flowContent *entity.FlowInfo) ([]entity.Flo
)
// 注册所有节点
- nodeMap := make(map[string]entity.FlowNode)
for _, item := range flowContent.Nodes {
- nodeMap[item.Id] = item
- //if item.NodeCode != node.NodeTypeJudge {
registerNodeToGraph(graph, item)
- //}
}
// 注册开始节点
@@ -102,71 +101,15 @@ func BuildGraph(ctx context.Context, flowContent *entity.FlowInfo) ([]entity.Flo
}
// 构建边关系
- upstreamMap := make(map[string][]string)
edgeMap := make(map[string][]entity.FlowEdge)
for _, edge := range flowContent.Edges {
edgeMap[edge.From] = append(edgeMap[edge.From], edge)
- upstreamMap[edge.To] = append(upstreamMap[edge.To], edge.From)
}
// 处理连线 & 分支
for _, edges := range edgeMap {
- //fromNode := nodeMap[fromNodeID]
-
- // 判断节点 → 分支处理
- //if fromNode.NodeCode == node.NodeTypeJudge {
- // branchMap := make(map[string]bool)
- // for _, e := range edges {
- // branchMap[e.To] = true
- // }
- //
- // judgeLambda := func(ctx context.Context, input any) (string, error) {
- // execInput, ok := input.(*flowDto.FlowExecutionInput)
- // if !ok {
- // return "", fmt.Errorf("入参类型错误")
- // }
- //
- // currentConfig := execInput.ConfigMap[fromNodeID]
- // if currentConfig == nil {
- // return "", fmt.Errorf("判断节点%s无配置", fromNodeID)
- // }
- //
- // branchIdNameMap := make(map[string]string)
- // var branchIDs []string
- // for nodeID := range branchMap {
- // branchIDs = append(branchIDs, nodeID)
- // // 从configMap获取分支节点的名称
- // if branchNodeCfg, ok := execInput.ConfigMap[nodeID]; ok {
- // branchIdNameMap[nodeID] = branchNodeCfg.Name
- // } else {
- // branchIdNameMap[nodeID] = "未命名节点" // 兜底
- // }
- // }
- //
- // // 把分支ID-名称映射塞进 ModelConfig，带给意图节点
- // m := make(map[string]interface{})
- // m["branch_ids"] = branchIDs
- // m["branch_id_name_map"] = branchIdNameMap
- // currentConfig.Config = m
- //
- // // 构造 NodeExecutionInput 传入 JudgeLambda
- // nodeExecInput := &flowDto.NodeExecutionInput{
- // Config: currentConfig,
- // Global: execInput,
- // }
- // return JudgeLambda(ctx, nodeExecInput)
- // }
- //
- // _ = graph.AddBranch(upstreamMap[fromNodeID][0], compose.NewGraphBranch(judgeLambda, branchMap))
- // continue
- //}
-
// 普通节点连线
for _, e := range edges {
- //toNode := nodeMap[e.To]
- //if toNode.NodeCode == node.NodeTypeJudge {
- // continue
- //}
_ = graph.AddEdge(e.From, e.To)
}
}
@@ -176,10 +119,40 @@ func BuildGraph(ctx context.Context, flowContent *entity.FlowInfo) ([]entity.Flo
// BuildGraphFromFlowContent 根据前端保存的工作流JSON，自动构建执行图并编译
func BuildGraphFromFlowContent(ctx context.Context, flowContent *entity.FlowInfo) ([]entity.FlowNode, compose.Runnable[any, any], error) {
nodeList, graph := BuildGraph(ctx, flowContent)
- compile, err := graph.Compile(ctx, compose.WithGraphName("auto_build_workflow"), compose.WithCheckPointStore(NewDbCheckPointStore()), compose.WithNodeTriggerMode(compose.AllPredecessor))
+ // BuildGraph 已把 summary(保存结果)节点追加进 flowContent.Nodes，此时是全部已注册节点的完整集合。
+ // 方案: 每个业务节点正常完成后自动暂停并落 checkpoint(编译期 WithInterruptAfterNodes),
+ // 崩溃恢复(BuildExecution(false)续跑)即跳过已完成的同步节点, 不再重跑/重复计费。
+ // 详见根目录《工作流节点断点续跑技术设计.md》。Start 型空载节点不为它落 cp; 只接 END 的节点
+ // Eino 不落暂停(无下游续跑点), 列了也无副作用。
+ interruptAfter := make([]string, 0, len(flowContent.Nodes))
+ for _, n := range flowContent.Nodes {
+ if n.NodeCode == node.NodeTypeStart {
+ continue
+ }
+ interruptAfter = append(interruptAfter, n.Id)
+ }
+ compile, err := graph.Compile(ctx,
+ compose.WithGraphName("auto_build_workflow"),
+ compose.WithCheckPointStore(NewDbCheckPointStore()),
+ compose.WithNodeTriggerMode(compose.AllPredecessor),
+ compose.WithInterruptAfterNodes(interruptAfter),
+ )
return nodeList, compile, err
}
+// buildConfigMap 由 FlowInfo + 图节点列表构建 ConfigMap：先放流程配置节点，再放图中补充节点
+// （保存结果节点等），供节点执行时按 nodeId 查配置。nodeList 取自 BuildGraph 返回值。
+func buildConfigMap(flowContent *entity.FlowInfo, nodeList []entity.FlowNode) map[string]*entity.FlowNode {
+ configMap := make(map[string]*entity.FlowNode)
+ for _, cfg := range ExtractFlowNodeFrom(flowContent) {
+ configMap[cfg.Id] = cfg
+ }
+ for i := range nodeList {
+ configMap[nodeList[i].Id] = &nodeList[i]
+ }
+ return configMap
+}
+
// registerNodeToGraph 将单个节点注册到图中（包含通用包装逻辑）
func registerNodeToGraph(graph *compose.Graph[any, any], flowNode entity.FlowNode) {
// 通用包装：全程入参都是 *FlowExecutionInput
@@ -200,11 +173,7 @@ func registerNodeToGraph(graph *compose.Graph[any, any], flowNode entity.FlowNod
// 上报节点执行进度（WebSocket场景下推送进度给前端）
if reporter := GetProgressReporter(ctx); reporter != nil {
- nodeIndex := len(execInput.ExecutedNodes) + 1
- if IndexOf(execInput.ExecutedNodes, flowNode.Id) != -1 {
- nodeIndex = IndexOf(execInput.ExecutedNodes, flowNode.Id)
- }
- reporter.ReportStart(flowNode.Id, flowNodeDesc, nodeIndex, len(execInput.ConfigMap))
+ reporter.ReportStart(flowNode.Id, flowNodeDesc, nodeReportIndex(execInput, flowNode.Id, 1), len(execInput.ConfigMap))
}
// 上传入参到OSS
@@ -236,11 +205,7 @@ func registerNodeToGraph(graph *compose.Graph[any, any], flowNode entity.FlowNod
// 上报节点执行进度（WebSocket场景下推送进度给前端）
if reporter := GetProgressReporter(ctx); reporter != nil {
- nodeIndex := len(execInput.ExecutedNodes)
- if IndexOf(execInput.ExecutedNodes, flowNode.Id) != -1 {
- nodeIndex = IndexOf(execInput.ExecutedNodes, flowNode.Id)
- }
- reporter.ReportComplete(flowNode.Id, flowNodeDesc, nodeIndex, len(execInput.ConfigMap))
+ reporter.ReportComplete(flowNode.Id, flowNodeDesc, nodeReportIndex(execInput, flowNode.Id, 0), len(execInput.ConfigMap))
}
// 返回整个 execInput，让下一个节点继续用
@@ -265,25 +230,18 @@ func registerNodeToGraph(graph *compose.Graph[any, any], flowNode entity.FlowNod
_ = graph.AddLambdaNode(flowNode.Id, compose.InvokableLambda(wrapLambda(HttpLambda)))
case node.NodeTypeScriptTranscribe:
_ = graph.AddLambdaNode(flowNode.Id, compose.InvokableLambda(wrapLambda(ScriptTranscribeLambda)))
- //case node.NodeTypeTextModel:
- // _ = graph.AddLambdaNode(flowNode.Id, compose.InvokableLambda(wrapLambda(TextModelLambda)))
- //case node.NodeTypeImageModel:
- // _ = graph.AddLambdaNode(flowNode.Id, compose.InvokableLambda(wrapLambda(ImageModelLambda)))
- //case node.NodeTypeVideoModel:
- // _ = graph.AddLambdaNode(flowNode.Id, compose.InvokableLambda(wrapLambda(VideoModelLambda)))
- //case node.NodeTypeAudioModel:
- // _ = graph.AddLambdaNode(flowNode.Id, compose.InvokableLambda(wrapLambda(AudioModelLambda)))
- //case node.NodeTypeBatchModel:
- // _ = graph.AddLambdaNode(flowNode.Id, compose.InvokableLambda(wrapLambda(BatchModelLambda)))
- //case node.NodeTypeDataConversionModel:
- // _ = graph.AddLambdaNode(flowNode.Id, compose.InvokableLambda(wrapLambda(DataConversionLambda)))
- //case node.NodeTypeCustomNode:
- // _ = graph.AddLambdaNode(flowNode.Id, compose.InvokableLambda(wrapLambda(CustomLambda)))
- //case node.NodeTypeMerge:
- // _ = graph.AddLambdaNode(flowNode.Id, compose.InvokableLambda(wrapLambda(MergeLambda)))
}
}
+// nodeReportIndex 计算节点在进度上报中的序号：节点已在已执行列表则取其位置，
+// 否则按当前已执行数 + offset（start 上报时节点尚未入列 offset=1；complete 后已入列命中 IndexOf）
+func nodeReportIndex(execInput *flowDto.FlowExecutionInput, nodeId string, offset int) int {
+ if idx := IndexOf(execInput.ExecutedNodes, nodeId); idx != -1 {
+ return idx
+ }
+ return len(execInput.ExecutedNodes) + offset
+}
+
// IndexOf 返回元素第一次出现的下标，不存在返回 -1
func IndexOf(slice []flowDto.ExecutedNode, target string) int {
for i, v := range slice {
diff --git a/workflow/service/flow/lambda_core.go b/workflow/service/flow/lambda_core.go
new file mode 100644
index 0000000..a32566c
--- /dev/null
+++ b/workflow/service/flow/lambda_core.go
@@ -0,0 +1,252 @@
+package flow
+
+import (
+ "ai-agent/gateway"
+ flowDao "ai-agent/workflow/dao/flow"
+ nodeDao "ai-agent/workflow/dao/node"
+ flowDto "ai-agent/workflow/model/dto/flow"
+ nodeDto "ai-agent/workflow/model/dto/node"
+ "ai-agent/workflow/model/entity"
+ "ai-agent/workflow/service/flow/processor/builtin/media"
+ "ai-agent/workflow/service/flow/values"
+ "context"
+ "fmt"
+ "sync"
+
+ "github.com/gogf/gf/v2/util/gconv"
+)
+
+// StartLambda 启动节点
+func StartLambda(ctx context.Context, input any) (any, error) {
+ return input, nil
+}
+
+// FormLambda 表单调用节点
+func FormLambda(ctx context.Context, input any) (any, error) {
+ nodeInput, ok := input.(*flowDto.NodeExecutionInput)
+ if !ok {
+ return nil, fmt.Errorf("入参类型错误")
+ }
+ // 解析 valueSource 引用，填充表单节点输出配置（供下游引用）
+ for _, output := range nodeInput.Config.OutputConfig {
+ values.ProcessValueSourceRecursive(output, nodeInput.Global)
+ }
+ return nodeInput, nil
+}
+
+// ModelLambda 模型调用节点
+func ModelLambda(ctx context.Context, input any) (any, error) {
+ nodeInput, ok := input.(*flowDto.NodeExecutionInput)
+ if !ok {
+ return nil, fmt.Errorf("入参类型错误")
+ }
+
+ modelParams, err := values.BuildModelRequestBody(nodeInput.Config.ModelConfig.ModelRequestParamsPath, nodeInput.Global)
+ if err != nil {
+ return nil, err
+ }
+
+ // 2. 前置工具：决定模型调用入参（单次/多次）
+ // 入参统一为扁平模型请求体（BuildModelRequestBody 输出，key 为点分路径）。
+ // 分批处理器按默认上限拆分集合字段，其余前置工具（如 split_shots_pipeline）读取扁平参数。
+ preToolParams := modelParams
+ paramsList, err := invokePreTool(ctx, nodeInput.Config.PreTool, preToolParams)
+ if err != nil {
+ return nil, err
+ }
+
+ // 3. 逐批调用模型，汇总输出（保持请求顺序），累计 token/费用供节点记录落库
+ var outputRes []map[string]any
+ var totalTokens int64
+ var totalPrompt int64
+ var totalCompletion int64
+ var totalCost float64
+ var totalDuration int64
+ // 计价用生效模型 id：引用行由 model-gateway 解析为系统模型 id（ModelCallRes.ModelId，计价按系统模型）；
+ // 未返回（model-gateway 旧版本）时回落节点配置的模型 id。media_type 供 per_token 命中媒体价。
+ effModelID := nodeInput.Config.ModelConfig.ModelId
+ var effMediaType string
+ if len(paramsList) > 1 {
+ // 段级续跑仅在"多段 + 视频模型"启用；非视频分段（批量文本等）走原逻辑零影响。
+ // 段身份 = 列表位置（0-based）：paramsList 顺序即段序，concat 按列表顺序拼接；
+ // 位置互不重复且跨 reExecute 稳定（参数一致 → 段数/顺序不变）。不依赖 params 里的
+ // segment_index——真实链路（上游 split_shots_pipeline 转写 → 下游 split_segment 按
+ // __segment_fields 拆分，invokePreTool 剥离 __ 内部键）下 paramsList 只有模型参数。
+ // segVideo=false 时走既有非段级合并路径（全量生成、不落库、不复用），全新执行行为不变，
+ // 后续自动 concat 判断（独立的 isVideoModel 调用）仍正常执行。
+ segVideo := isVideoModel(ctx, nodeInput.Config.ModelConfig.ModelId)
+
+ // 续跑（!ForceNewRun）时读取该节点已成功段；全新执行不查（BuildExecution 已清旧段），saved 为 nil → 全量重生成
+ var saved map[int]entity.SegmentRef
+ if !nodeInput.Global.ForceNewRun && segVideo {
+ saved, err = flowDao.FlowSegmentResultDao.ListByNode(ctx, nodeInput.Global.ExecutionId, nodeInput.Config.Id)
+ if err != nil {
+ return nil, err
+ }
+ }
+
+ idxList, needGen := planSegmentResume(paramsList, saved)
+
+ results := make([][]map[string]any, len(paramsList))
+ tokenRes := make([]*gateway.ModelCallRes, len(paramsList))
+ errs := make([]error, len(paramsList))
+ saveErrs := make([]error, len(paramsList))
+ isInference := make([]bool, len(paramsList))
+ var wg sync.WaitGroup
+ for i, params := range paramsList {
+ if !needGen[i] {
+ continue
+ }
+ wg.Add(1)
+ go func(i int, params map[string]any) {
+ defer wg.Done()
+ // 每段单次调用，不原地重试：段失败即走节点失败收口（HandleFailedNodeExecution → Interrupt），
+ // 下次 reExecute 由 planSegmentResume 复用已成功段、仅重生成失败段
+ results[i], tokenRes[i], isInference[i], errs[i] = ModelCallResultLambda(ctx, nodeInput.Config.ModelConfig.ModelId, nodeInput.Global.SessionId, params, nodeInput.Config.Prompt, nodeInput.Global.ExecutionId, nodeInput.Config.Id, idxList[i])
+ // 每段成功立即落库：该段刚成功即持久化，其他段仍在跑时已成功段也不丢；
+ // 后续段失败或进程崩溃（panic/OOM/kill）时，已完成段已在库中，reExecute 可直接复用
+ if segVideo && errs[i] == nil {
+ for _, rec := range results[i] {
+ key := media.FindVideoKey(rec)
+ url := media.FindVideoURL(ctx, rec)
+ if key == "" || url == "" {
+ continue
+ }
+ if err := flowDao.FlowSegmentResultDao.Save(ctx, nodeInput.Global.ExecutionId, nodeInput.Config.Id, idxList[i], key, url); err != nil {
+ saveErrs[i] = err
+ }
+ }
+ }
+ }(i, params)
+ }
+ wg.Wait()
+
+ // 仍有失败段或落库失败 → 节点失败（成功段已立即落库，供下次 reExecute 复用）
+ for i := range results {
+ if saveErrs[i] != nil {
+ return nil, saveErrs[i]
+ }
+ if needGen[i] && errs[i] != nil {
+ return nil, errs[i]
+ }
+ if needGen[i] && tokenRes[i] != nil {
+ totalTokens += tokenRes[i].TotalTokens
+ totalPrompt += tokenRes[i].PromptTokens
+ totalCompletion += tokenRes[i].CompletionTokens
+ totalCost += tokenRes[i].Cost
+ if isVideoModel(ctx, nodeInput.Config.ModelConfig.ModelId) {
+ totalDuration += tokenRes[i].Duration
+ }
+ if tokenRes[i].ModelId > 0 {
+ effModelID = tokenRes[i].ModelId
+ }
+ if effMediaType == "" {
+ effMediaType = tokenRes[i].MediaType
+ }
+ }
+ }
+
+ if segVideo {
+ // 复用段 + 新生段按段序号升序合并，concat 按列表顺序拼接 → 顺序保证
+ outputRes = mergeSegmentOutputs(idxList, needGen, results, saved)
+ } else {
+ if isInference[0] {
+ outputRes = mergeInferenceBatchResults(results)
+ } else {
+ for _, res := range results {
+ outputRes = append(outputRes, res...)
+ }
+ }
+ }
+ } else {
+ for _, params := range paramsList {
+ res, modelRes, _, err := ModelCallResultLambda(ctx, nodeInput.Config.ModelConfig.ModelId, nodeInput.Global.SessionId, params, nodeInput.Config.Prompt, nodeInput.Global.ExecutionId, nodeInput.Config.Id, flowDao.FlowAsyncSegSentinel)
+ if err != nil {
+ return nil, err
+ }
+ if modelRes != nil {
+ totalTokens += modelRes.TotalTokens
+ totalPrompt += modelRes.PromptTokens
+ totalCompletion += modelRes.CompletionTokens
+ totalCost += modelRes.Cost
+ if isVideoModel(ctx, nodeInput.Config.ModelConfig.ModelId) {
+ totalDuration += modelRes.Duration
+ }
+ if modelRes.ModelId > 0 {
+ effModelID = modelRes.ModelId
+ }
+ if effMediaType == "" {
+ effMediaType = modelRes.MediaType
+ }
+ }
+ outputRes = append(outputRes, res...)
+ }
+ }
+
+ // 3.5 把本次节点消耗的 token/费用/生成视频时长写入节点执行记录，供汇总节点聚合到 exec_workflow
+ // model_id 供 per_token 结算按模型聚合 token；total_duration 供 per_item/per_second 按生成视频总时长计费；
+ // per_char 模型把输出字数映射到 completion_tokens 传输，随 token 拆分一并落库
+ if nodeInput.NodeExecutionId > 0 && (totalTokens > 0 || totalCost > 0 || totalDuration > 0) {
+ if _, err = nodeDao.NodeExecutionDao.Update(ctx, &nodeDto.UpdateNodeExecutionReq{
+ Id: nodeInput.NodeExecutionId,
+ TokenInfo: []map[string]any{{
+ // model_id 写字符串：token_info 为 JSONB，int64 落库成 JSON 数字，读回是 float64，
+ // billing 侧按 model 聚合时 (string) 断言会失败导致 per_token 永远记 0。
+ // 与 ModelItem.ModelId 的 json:"modelId,string" 约定一致，字符串精确回环（雪花id>2^53 无损）。
+ // effModelID 为解析后的系统模型 id（引用行），per_token 结算按此查价。
+ "model_id": gconv.String(effModelID),
+ "prompt_tokens": totalPrompt,
+ "completion_tokens": totalCompletion,
+ "media_type": effMediaType,
+ "total_tokens": totalTokens,
+ "total_fee": totalCost,
+ "total_duration": totalDuration,
+ }},
+ }); err != nil {
+ return nil, fmt.Errorf("节点：%v 写入token信息失败: %v", nodeInput.Config.Name, err)
+ }
+ }
+
+ // 4.5 视频模型节点返回多个视频时，自动调用视频合成工具（concat_videos）合并为单条；
+ // 已显式配置 concat_videos 后置工具时跳过，避免重复合并
+ if nodeInput.Config.PostTool != media.ProcessorName && len(outputRes) > 1 && isVideoModel(ctx, nodeInput.Config.ModelConfig.ModelId) {
+ outputRes, err = invokePostTool(ctx, media.ProcessorName, outputRes, map[string]any{"callback_url": "callback_url", "upload": true})
+ if err != nil {
+ return nil, err
+ }
+ } else {
+ // 4. 后置工具：加工模型输出（透传原始请求参数，供后置工具读取合并配置等）
+ outputRes, err = invokePostTool(ctx, nodeInput.Config.PostTool, outputRes, modelParams)
+ if err != nil {
+ return nil, err
+ }
+ }
+ nodeInput.Config.OutputResult = outputRes
+ return nodeInput, nil
+}
+
+// mergeInferenceBatchResults 推理模型分批结果拼接为单条输出记录：
+// 各批结果按批序对同名 key 的值做字符串拼接（"拼到一个字段"），最终返回单条 {key:值} 记录。
+// 非字符串值（如结构/数组字段）取最后一份，避免误拼接。
+func mergeInferenceBatchResults(results [][]map[string]any) []map[string]any {
+ merged := make(map[string]any)
+ for _, res := range results {
+ for _, record := range res {
+ for key, val := range record {
+ prev, has := merged[key]
+ if !has {
+ merged[key] = val
+ continue
+ }
+ sPrev, pOK := prev.(string)
+ sVal, vOK := val.(string)
+ if pOK && vOK {
+ merged[key] = sPrev + "\n" + sVal
+ continue
+ }
+ merged[key] = val
+ }
+ }
+ }
+ return []map[string]any{merged}
+}
diff --git a/workflow/service/flow/lambda_http.go b/workflow/service/flow/lambda_http.go
new file mode 100644
index 0000000..1f7a0dd
--- /dev/null
+++ b/workflow/service/flow/lambda_http.go
@@ -0,0 +1,21 @@
+package flow
+
+import (
+ flowDto "ai-agent/workflow/model/dto/flow"
+ "context"
+ "fmt"
+)
+
+// HttpLambda 构建HTTP(S)接口
+func HttpLambda(ctx context.Context, input any) (any, error) {
+ nodeInput, ok := input.(*flowDto.NodeExecutionInput)
+ if !ok {
+ return nil, fmt.Errorf("入参类型错误")
+ }
+ outputRes, err := HttpCallResultLambda(ctx, nodeInput)
+ if err != nil {
+ return nil, err
+ }
+ nodeInput.Config.OutputResult = outputRes
+ return nodeInput, nil
+}
diff --git a/workflow/service/flow/lambda_node.go b/workflow/service/flow/lambda_node.go
deleted file mode 100644
index 583e0c9..0000000
--- a/workflow/service/flow/lambda_node.go
+++ /dev/null
@@ -1,742 +0,0 @@
-package flow
-
-import (
- "ai-agent/gateway"
- "ai-agent/workflow/consts/flow"
- "ai-agent/workflow/consts/model"
- "ai-agent/workflow/consts/node"
- "ai-agent/workflow/consts/public"
- flowDao "ai-agent/workflow/dao/flow"
- nodeDao "ai-agent/workflow/dao/node"
- sessionDao "ai-agent/workflow/dao/session"
- flowDto "ai-agent/workflow/model/dto/flow"
- nodeDto "ai-agent/workflow/model/dto/node"
- sessionDto "ai-agent/workflow/model/dto/session"
- "ai-agent/workflow/model/entity"
- "ai-agent/workflow/service/flow/processor"
- "ai-agent/workflow/service/flow/processor/builtin/media"
- "context"
- "encoding/base64"
- "encoding/json"
- "fmt"
- "strings"
- "sync"
-
- "gitea.redpowerfuture.com/red-future/common/db/gfdb"
- "gitea.redpowerfuture.com/red-future/common/oss"
- "github.com/cloudwego/eino-examples/compose/batch/batch"
- "github.com/cloudwego/eino/compose"
- "github.com/gogf/gf/v2/database/gdb"
- "github.com/gogf/gf/v2/frame/g"
- "github.com/gogf/gf/v2/util/gconv"
- "github.com/google/uuid"
-)
-
-// StartLambda 启动节点
-func StartLambda(ctx context.Context, input any) (any, error) {
- return input, nil
-}
-
-// FormLambda 表单调用节点
-func FormLambda(ctx context.Context, input any) (any, error) {
- nodeInput, ok := input.(*flowDto.NodeExecutionInput)
- if !ok {
- return nil, fmt.Errorf("入参类型错误")
- }
- // 解析 valueSource 引用，填充表单节点输出配置（供下游引用）
- for _, output := range nodeInput.Config.OutputConfig {
- ProcessValueSourceRecursive(output, nodeInput.Global)
- }
- return nodeInput, nil
-}
-
-// ModelLambda 模型调用节点
-func ModelLambda(ctx context.Context, input any) (any, error) {
- nodeInput, ok := input.(*flowDto.NodeExecutionInput)
- if !ok {
- return nil, fmt.Errorf("入参类型错误")
- }
-
- modelParams, err := BuildModelRequestBody(nodeInput.Config.ModelConfig.ModelRequestParamsPath, nodeInput.Global)
- if err != nil {
- return nil, err
- }
-
- // 2. 前置工具：决定模型调用入参（单次/多次）
- // 入参统一为扁平模型请求体（BuildModelRequestBody 输出，key 为点分路径）。
- // 分批处理器按默认上限拆分集合字段，其余前置工具（如 split_shots_pipeline）读取扁平参数。
- preToolParams := modelParams
- paramsList, err := invokePreTool(ctx, nodeInput.Config.PreTool, preToolParams)
- if err != nil {
- return nil, err
- }
-
- // 3. 逐批调用模型，汇总输出（保持请求顺序），累计 token/费用供节点记录落库
- var outputRes []map[string]any
- var totalTokens int64
- var totalCost float64
- if len(paramsList) > 1 {
- // 段级续跑仅在"多段 + 视频模型"启用；非视频分段（批量文本等）走原逻辑零影响。
- // 段身份 = 列表位置（0-based）：paramsList 顺序即段序，concat 按列表顺序拼接；
- // 位置互不重复且跨 reExecute 稳定（参数一致 → 段数/顺序不变）。不依赖 params 里的
- // segment_index——真实链路（上游 split_shots_pipeline 转写 → 下游 split_segment 按
- // __segment_fields 拆分，invokePreTool 剥离 __ 内部键）下 paramsList 只有模型参数。
- // segVideo=false 时走既有非段级合并路径（全量生成、不落库、不复用），全新执行行为不变，
- // 后续自动 concat 判断（独立的 isVideoModel 调用）仍正常执行。
- segVideo := isVideoModel(ctx, nodeInput.Config.ModelConfig.ModelId)
-
- // 续跑（!ForceNewRun）时读取该节点已成功段；全新执行不查（BuildExecution 已清旧段），saved 为 nil → 全量重生成
- var saved map[int]entity.SegmentRef
- if !nodeInput.Global.ForceNewRun && segVideo {
- saved, err = flowDao.FlowSegmentResultDao.ListByNode(ctx, nodeInput.Global.ExecutionId, nodeInput.Config.Id)
- if err != nil {
- return nil, err
- }
- }
-
- idxList, needGen := planSegmentResume(paramsList, saved)
-
- results := make([][]map[string]any, len(paramsList))
- tokenRes := make([]*gateway.ModelCallRes, len(paramsList))
- errs := make([]error, len(paramsList))
- saveErrs := make([]error, len(paramsList))
- isInference := make([]bool, len(paramsList))
- var wg sync.WaitGroup
- for i, params := range paramsList {
- if !needGen[i] {
- continue
- }
- wg.Add(1)
- go func(i int, params map[string]any) {
- defer wg.Done()
- // 视频段每段失败自动重试 1 次（共 2 次尝试）；非视频保持单次调用
- for attempt := 0; attempt < segmentGenerateMaxAttempts; attempt++ {
- results[i], tokenRes[i], isInference[i], errs[i] = ModelCallResultLambda(ctx, nodeInput.Config.ModelConfig.ModelId, nodeInput.Global.SessionId, params, nodeInput.Config.Prompt, nodeInput.Global.ExecutionId, nodeInput.Config.Id, idxList[i])
- if errs[i] == nil || !segVideo {
- break
- }
- }
- // 每段成功立即落库：该段刚成功即持久化，其他段仍在跑/重试时已成功段也不丢；
- // 后续段失败或进程崩溃（panic/OOM/kill）时，已完成段已在库中，reExecute 可直接复用
- if segVideo && errs[i] == nil {
- for _, rec := range results[i] {
- key := media.FindVideoKey(rec)
- url := media.FindVideoURL(ctx, rec)
- if key == "" || url == "" {
- continue
- }
- if err := flowDao.FlowSegmentResultDao.Save(ctx, nodeInput.Global.ExecutionId, nodeInput.Config.Id, idxList[i], key, url); err != nil {
- saveErrs[i] = err
- }
- }
- }
- }(i, params)
- }
- wg.Wait()
-
- // 仍有失败段或落库失败 → 节点失败（成功段已立即落库，供下次 reExecute 复用）
- for i := range results {
- if saveErrs[i] != nil {
- return nil, saveErrs[i]
- }
- if needGen[i] && errs[i] != nil {
- return nil, errs[i]
- }
- if needGen[i] && tokenRes[i] != nil {
- totalTokens += tokenRes[i].TotalTokens
- totalCost += tokenRes[i].Cost
- }
- }
-
- if segVideo {
- // 复用段 + 新生段按段序号升序合并，concat 按列表顺序拼接 → 顺序保证
- outputRes = mergeSegmentOutputs(idxList, needGen, results, saved)
- } else {
- if isInference[0] {
- outputRes = mergeInferenceBatchResults(results)
- } else {
- for _, res := range results {
- outputRes = append(outputRes, res...)
- }
- }
- }
- } else {
- for _, params := range paramsList {
- res, modelRes, _, err := ModelCallResultLambda(ctx, nodeInput.Config.ModelConfig.ModelId, nodeInput.Global.SessionId, params, nodeInput.Config.Prompt, nodeInput.Global.ExecutionId, nodeInput.Config.Id, flowDao.FlowAsyncSegSentinel)
- if err != nil {
- return nil, err
- }
- if modelRes != nil {
- totalTokens += modelRes.TotalTokens
- totalCost += modelRes.Cost
- }
- outputRes = append(outputRes, res...)
- }
- }
-
- // 3.5 把本次节点消耗的 token/费用写入节点执行记录，供汇总节点聚合到 exec_workflow
- if nodeInput.NodeExecutionId > 0 && (totalTokens > 0 || totalCost > 0) {
- if _, err = nodeDao.NodeExecutionDao.Update(ctx, &nodeDto.UpdateNodeExecutionReq{
- Id: nodeInput.NodeExecutionId,
- TokenInfo: []map[string]any{{
- "total_tokens": totalTokens,
- "total_fee": totalCost,
- }},
- }); err != nil {
- return nil, fmt.Errorf("节点：%v 写入token信息失败: %v", nodeInput.Config.Name, err)
- }
- }
-
- // 4.5 视频模型节点返回多个视频时，自动调用视频合成工具（concat_videos）合并为单条；
- // 已显式配置 concat_videos 后置工具时跳过，避免重复合并
- if nodeInput.Config.PostTool != media.ProcessorName && len(outputRes) > 1 && isVideoModel(ctx, nodeInput.Config.ModelConfig.ModelId) {
- g.Log().Debugf(ctx, "modelId1:%v ,outputRes: %v", nodeInput.Config.ModelConfig.ModelId, outputRes)
- outputRes, err = invokePostTool(ctx, media.ProcessorName, outputRes, map[string]any{"callback_url": "callback_url", "upload": true})
- g.Log().Debugf(ctx, "modelId2:%v ,outputRes: %v", nodeInput.Config.ModelConfig.ModelId, outputRes)
- if err != nil {
- return nil, err
- }
- } else {
- // 4. 后置工具：加工模型输出（透传原始请求参数，供后置工具读取合并配置等）
- outputRes, err = invokePostTool(ctx, nodeInput.Config.PostTool, outputRes, modelParams)
- if err != nil {
- return nil, err
- }
- }
- g.Log().Debugf(ctx, "modelId3:%v ,outputRes: %v", nodeInput.Config.ModelConfig.ModelId, outputRes)
- nodeInput.Config.OutputResult = outputRes
- return nodeInput, nil
-}
-
-// isVideoModel 判断模型是否为视频模型（模型类型 TypeVideo=600），用于视频节点多视频自动合成判断
-func isVideoModel(ctx context.Context, modelId int64) bool {
- modelInfo, err := gateway.GetModelInfoById(ctx, &gateway.GetModelInfoByIdReq{ModelId: modelId})
- if err != nil {
- g.Log().Warningf(ctx, "查询模型配置失败，跳过自动视频合成 modelId=%d err=%v", modelId, err)
- return false
- }
- return modelInfo.ModelManage.ModelType != nil && *modelInfo.ModelManage.ModelType == model.TypeVideo
-}
-
-// mergeInferenceBatchResults 推理模型分批结果拼接为单条输出记录：
-// 各批结果按批序对同名 key 的值做字符串拼接（"拼到一个字段"），最终返回单条 {key:值} 记录。
-// 非字符串值（如结构/数组字段）取最后一份，避免误拼接。
-func mergeInferenceBatchResults(results [][]map[string]any) []map[string]any {
- merged := make(map[string]any)
- for _, res := range results {
- for _, record := range res {
- for key, val := range record {
- prev, has := merged[key]
- if !has {
- merged[key] = val
- continue
- }
- sPrev, pOK := prev.(string)
- sVal, vOK := val.(string)
- if pOK && vOK {
- merged[key] = sPrev + "\n" + sVal
- continue
- }
- merged[key] = val
- }
- }
- }
- return []map[string]any{merged}
-}
-
-// invokePreTool 执行前置处理器，把模型请求参数转换为模型调用入参列表。
-// 前置处理器契约：入参即模型请求参数本体；返回值：
-// - map[string]any 一次模型调用，入参为返回值
-// - []map[string]any 多次模型调用，逐个入参请求
-// - nil 视为异常，节点失败（不允许静默跳过模型调用）
-func invokePreTool(ctx context.Context, processorName string, modelParams map[string]any) (paramsList []map[string]any, err error) {
- if processorName == "" {
- return []map[string]any{stripInternalKeys(modelParams)}, nil
- }
- data, err := processor.Call(ctx, processorName, modelParams)
- if err != nil {
- return nil, fmt.Errorf("执行前置处理器[%s]失败: %v", processorName, err)
- }
- switch v := data.(type) {
- case nil:
- return nil, fmt.Errorf("前置处理器[%s]返回空", processorName)
- case map[string]any:
- return []map[string]any{stripInternalKeys(v)}, nil
- case []map[string]any:
- list := make([]map[string]any, 0, len(v))
- for _, m := range v {
- list = append(list, stripInternalKeys(m))
- }
- return list, nil
- default:
- return nil, fmt.Errorf("前置处理器[%s]返回类型不支持: %T", processorName, data)
- }
-}
-
-// stripInternalKeys 剥离 __ 前缀的内部键（如 __segment_fields/__produced），
-// 模型网关做参数严格校验（CheckParams strictUnknown）会拒绝未知字段，内部标记不得随请求体下发。
-func stripInternalKeys(params map[string]any) map[string]any {
- if params == nil {
- return params
- }
- for k := range params {
- if strings.HasPrefix(k, "__") {
- delete(params, k)
- }
- }
- return params
-}
-
-// invokePostTool 执行后置处理器，加工模型调用结果。
-// 后置处理器契约：入参 {"output": 模型输出结果列表, "request": 原始模型请求参数}（列表须包成对象传入）；返回值：
-// - []map[string]any 替换模型输出
-// - map[string]any 替换为单条输出
-// - nil 保留原输出
-func invokePostTool(ctx context.Context, processorName string, outputRes []map[string]any, requestParams map[string]any) ([]map[string]any, error) {
- if processorName == "" {
- return outputRes, nil
- }
- data, err := processor.Call(ctx, processorName, map[string]any{"output": outputRes, "request": requestParams})
- if err != nil {
- return nil, fmt.Errorf("执行后置处理器[%s]失败: %v", processorName, err)
- }
- switch v := data.(type) {
- case nil:
- return outputRes, nil
- case []map[string]any:
- return v, nil
- case map[string]any:
- return []map[string]any{v}, nil
- default:
- return nil, fmt.Errorf("后置处理器[%s]返回类型不支持: %T", processorName, data)
- }
-}
-
-func SubFlowLambda(ctx context.Context, input any) (any, error) {
- // 1. 类型断言（和其他节点保持一致的入参结构）
- nodeExecInput, ok := input.(*flowDto.NodeExecutionInput)
- if !ok {
- return nil, fmt.Errorf("子流程节点入参类型错误，期望*flowDto.NodeExecutionInput，实际%T", input)
- }
- // 2. 解析子流程配置
- subFlowConfig := nodeExecInput.Config.SubConfig
- if subFlowConfig == nil {
- return nil, fmt.Errorf("子流程节点缺少配置")
- }
- getRes, err := FlowUserService.Get(ctx, &flowDto.GetFlowUserReq{
- Id: subFlowConfig.WorkflowId,
- })
- if err != nil {
- return nil, err
- }
- // 3. 引入参数解析：把首页表单值/上游引用值/静态默认值写入子流程开始节点 outputConfig。
- // 须在 BuildGraph / ExtractFlowNodeFrom 之前执行，batchInputs 深拷贝的才是注入后的开始节点。
- injectSubFlowFields(nodeExecInput.Global, getRes.FlowContent, subFlowConfig.Fields)
- // 4. 并发数：从主流程开始节点 outputConfig 的 maxConcurrency 字段读取（前端把子流程节点生成次数表单字段聚合到主流程开始节点），读不到再用子流程节点配置兜底
- maxConcurrency := mainFlowMaxConcurrency(nodeExecInput.Global, subFlowConfig.MaxConcurrency)
- // 4. 编译子流程Graph（复用现有 BuildGraphFromFlowContent 逻辑）
- nodeList, subGraph := BuildGraph(ctx, getRes.FlowContent)
- // 4. 构建子流程Workflow（绑定START/END，和示例对齐）
- innerWorkflow := compose.NewWorkflow[*flowDto.FlowExecutionInput, *flowDto.FlowExecutionInput]()
- // 挂载子图节点并绑定全局START
- innerWorkflow.AddGraphNode("sub_flow_graph", subGraph).AddInput(compose.START)
- // 绑定子图输出到全局END
- innerWorkflow.End().AddInput("sub_flow_graph")
- // 生成次数（批量条数）：maxConcurrency<=0 时按 1 次兜底
- batchCount := maxConcurrency
- if batchCount <= 0 {
- batchCount = 1
- }
- // 5. 构建BatchNode（批量执行子流程，复用示例逻辑）
- batchNode := batch.NewBatchNode(&batch.NodeConfig[*flowDto.FlowExecutionInput, *flowDto.FlowExecutionInput]{
- Name: fmt.Sprintf("sub_flow_batch_%s", nodeExecInput.Config.Id),
- InnerTask: innerWorkflow,
- MaxConcurrency: batchCount,
- })
-
- // 6. 提取批量输入：按生成次数生成 N 份（每份独立克隆 ConfigMap，避免并发执行时节点输出写串）
- nodeInputParams := ExtractFlowNodeFrom(getRes.FlowContent)
- configMap := make(map[string]*entity.FlowNode)
- for _, cfg := range nodeInputParams {
- configMap[cfg.Id] = cfg
- }
- for _, i := range nodeList {
- configMap[i.Id] = &i
- }
- batchInputs := make([]*flowDto.FlowExecutionInput, 0, batchCount)
- for j := 0; j < batchCount; j++ {
- batchInputs = append(batchInputs, &flowDto.FlowExecutionInput{
- NodeGroupId: nodeExecInput.Global.NodeGroupId,
- ExecutionId: nodeExecInput.Global.ExecutionId,
- FlowId: nodeExecInput.Global.FlowId,
- ConfigMap: cloneConfigMap(configMap),
- SessionId: nodeExecInput.Global.SessionId,
- })
- }
- // 7. 执行批量子流程
- batchOutput, err := batchNode.Invoke(ctx, batchInputs)
- if err != nil {
- return nil, fmt.Errorf("执行子流程BatchNode失败: %v", err)
- }
- // 8. 展平每份子流程执行的节点输出，写回当前节点 OutputResult 供下游引用
- var outputRes []map[string]any
- for _, single := range batchOutput {
- if single == nil {
- continue
- }
- outputRes = append(outputRes, collectFlowNodeResults(single)...)
- }
- g.Log().Info(ctx, fmt.Sprintf("子流程执行完成，共 %d 次，输出 %d 条", batchCount, len(outputRes)))
- nodeExecInput.Config.OutputResult = outputRes
- return nodeExecInput, nil
-}
-
-// injectSubFlowFields 将子流程节点引入参数（subConfig.Fields）解析后写入子流程开始节点
-// outputConfig，使子流程启动时能读到首页表单值/上游引用值/静态默认值。
-// 每个字段的取值优先级：valueSource 引用解析成功 → field.value → field.defaultValue；
-// 匹配键为 field（前端约定以 field 为主，不兼容 path）。
-func injectSubFlowFields(global *flowDto.FlowExecutionInput, subFlowContent *entity.FlowInfo, fields []map[string]any) {
- if global == nil || subFlowContent == nil || len(fields) == 0 {
- return
- }
- startNode := subFlowStartNode(subFlowContent)
- if startNode == nil {
- return
- }
- byField := make(map[string]map[string]any, len(startNode.OutputConfig))
- for _, output := range startNode.OutputConfig {
- byField[gconv.String(output["field"])] = output
- }
- for _, field := range fields {
- entry := byField[gconv.String(field["field"])]
- if entry == nil {
- continue
- }
- value := field["value"]
- if vs, has := field["valueSource"]; has && vs != nil {
- if vsNodeId, vsField := firstValueSource(vs); vsNodeId != "" && vsField != "" {
- if v, _, ok := resolveValueSource(global, vsNodeId, vsField); ok {
- value = v
- }
- }
- }
- if value == nil {
- value = field["defaultValue"]
- }
- if value != nil {
- entry["value"] = value
- }
- }
-}
-
-// firstValueSource 从 valueSource 提取第一个引用源 (nodeId, field)。
-// 前端统一发送数组 [{nodeId, field}]（见 serializeSubFlowConfig），旧 DSL 可能是单对象
-// {nodeId, fieldName}，两种形态都兼容；子流程字段与引用源一一对应，只取第一个。
-func firstValueSource(vs any) (nodeId, field string) {
- if vs == nil {
- return
- }
- switch v := vs.(type) {
- case []any:
- if len(v) > 0 {
- return firstValueSource(v[0])
- }
- return
- case []map[string]any:
- if len(v) > 0 {
- return firstValueSource(v[0])
- }
- return
- }
- m := gconv.Map(vs)
- nodeId = gconv.String(m["nodeId"])
- field = gconv.String(m["fieldName"])
- if field == "" {
- field = gconv.String(m["field"])
- }
- return
-}
-
-// subFlowStartNode 返回工作流开始节点
-func subFlowStartNode(content *entity.FlowInfo) *entity.FlowNode {
- if content == nil {
- return nil
- }
- for i := range content.Nodes {
- if content.Nodes[i].Id == content.StartNodeId {
- return &content.Nodes[i]
- }
- }
- return nil
-}
-
-// mainFlowMaxConcurrency 取子流程批量执行并发数：从主流程开始节点 outputConfig
-// 的 maxConcurrency 字段读取（前端把子流程节点的生成次数表单字段聚合到主流程开始节点），
-// 读不到再用子流程节点配置的兜底值。
-func mainFlowMaxConcurrency(global *flowDto.FlowExecutionInput, fallback int) int {
- if global == nil {
- return fallback
- }
- for _, n := range global.ConfigMap {
- if n == nil || n.NodeCode != node.NodeTypeStart {
- continue
- }
- for _, output := range n.OutputConfig {
- if gconv.String(output["field"]) != "maxConcurrency" && gconv.String(output["path"]) != "maxConcurrency" {
- continue
- }
- if v := gconv.Int(output["value"]); v > 0 {
- return v
- }
- }
- return fallback
- }
- return fallback
-}
-
-// cloneConfigMap 深拷贝 ConfigMap，保证各批次子流程并发执行时节点输出互不串扰。
-// 浅拷贝会共享 *entity.FlowNode，并发写 OutputResult 产生竞态。
-func cloneConfigMap(src map[string]*entity.FlowNode) map[string]*entity.FlowNode {
- dst := make(map[string]*entity.FlowNode, len(src))
- for k, v := range src {
- data, err := json.Marshal(v)
- if err != nil {
- dst[k] = v
- continue
- }
- n := new(entity.FlowNode)
- if err = json.Unmarshal(data, n); err != nil {
- dst[k] = v
- continue
- }
- dst[k] = n
- }
- return dst
-}
-
-// collectFlowNodeResults 收集一次子流程执行中所有已执行节点的输出，展平成 {字段:值} 列表
-func collectFlowNodeResults(execInput *flowDto.FlowExecutionInput) []map[string]any {
- var res []map[string]any
- for _, executed := range execInput.ExecutedNodes {
- if nodeConfig := execInput.ConfigMap[executed.NodeId]; nodeConfig != nil {
- res = append(res, nodeConfig.OutputResult...)
- }
- }
- return res
-}
-
-// HttpLambda 构建HTTP(S)接口
-func HttpLambda(ctx context.Context, input any) (any, error) {
- nodeInput, ok := input.(*flowDto.NodeExecutionInput)
- if !ok {
- return nil, fmt.Errorf("入参类型错误")
- }
- outputRes, err := HttpCallResultLambda(ctx, nodeInput)
- if err != nil {
- return nil, err
- }
- nodeInput.Config.OutputResult = outputRes
- return nodeInput, nil
-}
-
-func DataMergeLambda(ctx context.Context, input any) (res any, err error) {
- nodeInput, ok := input.(*flowDto.NodeExecutionInput)
- if !ok {
- return nil, fmt.Errorf("参数合并入参类型错误")
- }
- return nodeInput, nil
-}
-
-func SummaryLambda(ctx context.Context, input any) (any, error) {
- execInput, ok := input.(*flowDto.NodeExecutionInput)
- if !ok {
- return nil, fmt.Errorf("汇总节点入参类型错误，实际是 %T", input)
- }
-
- // 聚合所有已执行节点中需入库的文件结果（两层规则）
- summaryResult := collectSaveFileResults(ctx, execInput.Global)
-
- // 把汇总结果存入当前节点的输出
- g.Log().Info(ctx, fmt.Sprintf("结果汇总完成，汇总数据：%+v", summaryResult))
-
- err := gfdb.DB(ctx, public.DbNameBlackDeacon).Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
- res, _, err := nodeDao.NodeExecutionDao.ListByFlowExecutionId(ctx, &nodeDto.ListNodeExecutionByFlowReq{
- NodeGroupId: execInput.Global.NodeGroupId,
- }, entity.NodeExecutionCol.TokenInfo)
- if err != nil {
- return err
- }
- var totalTokens int
- var totalFee float64
- for _, item := range res {
- for _, itemToken := range item.TokenInfo {
- m := gconv.Map(itemToken)
- totalTokens += gconv.Int(m["total_tokens"])
- totalFee += gconv.Float64(m["total_fee"])
- }
- }
- _, err = sessionDao.ExecWorkflowDao.Update(ctx, &sessionDto.UpdateWorkflowReq{
- Id: execInput.Global.ExecutionId,
- Status: flow.FlowExecutionStatusSuccess.Code(),
- TotalTokens: totalTokens,
- TotalFee: totalFee,
- })
- if err != nil {
- return err
- }
- if len(summaryResult) > 0 {
- _, err = sessionDao.ExecWorkflowResultDao.BatchInsert(ctx, summaryResult)
- if err != nil {
- return err
- }
- }
- return nil
- })
-
- return execInput, err
-}
-
-// collectSaveFileResults 按两层规则收集需入库的文件结果：
-// 第一层：节点须开启"保存文件"（IsSaveFile）；
-// 第二层：key 取自节点 OutputResult 的各字段，命中 ModelResponseBodyMapping 才入库；
-// 原始响应体 key（respBody）恒入库（不要求映射声明）；HTTP 节点产出以 http_file_url:{key}
-// 标记的字段（IsSaveFile 时由 HttpCallResultLambda 生成）恒入库（无模型响应映射可查）。
-// 结果值为 http(s) URL 或 MinIO 对象裸路径直接使用；非路径值（base64 图片/文本）先上传 OSS 换取 URL，
-// 文本内容以 .inc 扩展名存储。
-func collectSaveFileResults(ctx context.Context, execInput *flowDto.FlowExecutionInput) []*sessionDto.CreateWorkflowResultReq {
- if execInput == nil {
- return nil
- }
- var summaryResult []*sessionDto.CreateWorkflowResultReq
- for _, executedNode := range execInput.ExecutedNodes {
- nodeConfig := execInput.ConfigMap[executedNode.NodeId]
- if nodeConfig == nil || len(nodeConfig.OutputResult) == 0 || !nodeConfig.IsSaveFile {
- continue
- }
- // 第二层：key 取自节点 OutputResult 的各字段，
- // 命中 ModelResponseBodyMapping 才入库；respBody 与 HTTP 节点 http_file_url:{key} 标记恒入库
- saveKeys := nodeConfig.ModelConfig.ModelResponseBodyMapping
- for _, respBody := range nodeConfig.OutputResult {
- for key, val := range gconv.Map(respBody) {
- isHTTPFile := strings.HasPrefix(key, "http_file_url:")
- if !isHTTPFile {
- if _, ok := saveKeys[key]; !ok && key != "respBody" {
- continue
- }
- }
- fileUrl, err := resolveSaveFileResult(ctx, val)
- if err != nil {
- g.Log().Warningf(ctx, "collectSaveFileResults 上传结果文件失败 key=%s err=%v", key, err)
- continue
- }
- summaryResult = append(summaryResult, &sessionDto.CreateWorkflowResultReq{
- SessionId: execInput.SessionId,
- FlowId: execInput.FlowId,
- ExecId: execInput.ExecutionId,
- ResultFileUrl: fileUrl,
- })
- }
- }
- }
- return summaryResult
-}
-
-// resolveSaveFileResult 解析结果值为可入库的 URL：
-// - 已是 http(s) URL 或 MinIO 对象裸路径 → 直接返回
-// - 非路径（base64 图片/文本）→ 上传 OSS 换取 URL
-func resolveSaveFileResult(ctx context.Context, val any) (string, error) {
- isPath, path, fileBytes, ext := resolveFileContent(val)
- if isPath {
- return path, nil
- }
- if ext == "" {
- ext = ".png"
- }
- fileUrl, err := gateway.Upload(ctx, fmt.Sprintf("workflow_result_%s%s", uuid.NewString(), ext), fileBytes)
- if err != nil {
- return "", err
- }
- return fileUrl, nil
-}
-
-// resolveFileContent 判断结果值形态：
-// - 已是 URL 路径（http/https 开头）→ 直接使用
-// - data URI（data:;base64,）→ 解码为字节，扩展名按 mime 推断
-// - 纯 base64（可解码且长度足以认为是编码数据）→ 解码为字节，默认 .png
-// - 其余（文本）→ 以 .inc 扩展名上传原文
-func resolveFileContent(val any) (isPath bool, path string, fileBytes []byte, ext string) {
- s := gconv.String(val)
- if isFileURL(s) {
- return true, s, nil, ""
- }
- // MinIO 对象裸路径（无 http 前缀，模型网关转存 OSS 后返回）
- if oss.IsOSSPath(s) {
- return true, s, nil, ""
- }
- // data URI：data:;base64,
- if b, mime, ok := parseDataURI(s); ok {
- return false, "", b, extOfMime(mime)
- }
- // 纯 base64：可解码且长度足够，视为编码后的文件内容
- trimmed := strings.TrimSpace(s)
- if len(trimmed) >= 64 {
- if b, err := base64.StdEncoding.DecodeString(trimmed); err == nil && len(b) > 0 {
- return false, "", b, ".png"
- }
- }
- // 文本：以 .inc 存储
- return false, "", []byte(s), ".inc"
-}
-
-// isFileURL 判断字符串是否已是对外可访问的 URL 路径（http/https 开头）
-func isFileURL(s string) bool {
- lower := strings.ToLower(s)
- return strings.HasPrefix(lower, "http://") || strings.HasPrefix(lower, "https://")
-}
-
-// extOfMime 按 MIME 类型推断文件扩展名
-func extOfMime(mime string) string {
- switch strings.ToLower(strings.TrimSpace(mime)) {
- case "image/png", "png":
- return ".png"
- case "image/jpeg", "image/jpg", "jpeg", "jpg":
- return ".jpg"
- case "image/webp":
- return ".webp"
- case "image/gif":
- return ".gif"
- case "audio/mpeg", "audio/mp3", "mp3":
- return ".mp3"
- case "audio/wav", "wav":
- return ".wav"
- case "video/mp4", "mp4":
- return ".mp4"
- case "application/json", "json":
- return ".json"
- default:
- return ""
- }
-}
-
-// parseDataURI 解析 data URI：data:;base64,，返回解码字节与 mime
-func parseDataURI(s string) ([]byte, string, bool) {
- const prefix = "data:"
- if !strings.HasPrefix(s, prefix) {
- return nil, "", false
- }
- rest := s[len(prefix):]
- comma := strings.Index(rest, ",")
- if comma < 0 {
- return nil, "", false
- }
- mime := rest[:comma]
- if semicolon := strings.Index(mime, ";"); semicolon >= 0 {
- mime = mime[:semicolon]
- }
- payload := strings.TrimPrefix(rest[comma+1:], "base64,")
- b, err := base64.StdEncoding.DecodeString(payload)
- if err != nil {
- return nil, "", false
- }
- return b, mime, true
-}
diff --git a/workflow/service/flow/lambda_savefile.go b/workflow/service/flow/lambda_savefile.go
new file mode 100644
index 0000000..a97a2bb
--- /dev/null
+++ b/workflow/service/flow/lambda_savefile.go
@@ -0,0 +1,113 @@
+package flow
+
+import (
+ "ai-agent/gateway"
+ "context"
+ "encoding/base64"
+ "fmt"
+ "strings"
+
+ "gitea.redpowerfuture.com/red-future/common/oss"
+ "github.com/gogf/gf/v2/util/gconv"
+ "github.com/google/uuid"
+)
+
+// resolveSaveFileResult 解析结果值为可入库的 URL：
+// - 已是 http(s) URL 或 MinIO 对象裸路径 → 直接返回
+// - 非路径（base64 图片/文本）→ 上传 OSS 换取 URL
+func resolveSaveFileResult(ctx context.Context, val any) (string, error) {
+ isPath, path, fileBytes, ext := resolveFileContent(val)
+ if isPath {
+ return path, nil
+ }
+ if ext == "" {
+ ext = ".png"
+ }
+ fileUrl, err := gateway.Upload(ctx, fmt.Sprintf("workflow_result_%s%s", uuid.NewString(), ext), fileBytes)
+ if err != nil {
+ return "", err
+ }
+ return fileUrl, nil
+}
+
+// resolveFileContent 判断结果值形态：
+// - 已是 URL 路径（http/https 开头）→ 直接使用
+// - data URI（data:;base64,）→ 解码为字节，扩展名按 mime 推断
+// - 纯 base64（可解码且长度足以认为是编码数据）→ 解码为字节，默认 .png
+// - 其余（文本）→ 以 .inc 扩展名上传原文
+func resolveFileContent(val any) (isPath bool, path string, fileBytes []byte, ext string) {
+ s := gconv.String(val)
+ if isFileURL(s) {
+ return true, s, nil, ""
+ }
+ // MinIO 对象裸路径（无 http 前缀，模型网关转存 OSS 后返回）
+ if oss.IsOSSPath(s) {
+ return true, s, nil, ""
+ }
+ // data URI：data:;base64,
+ if b, mime, ok := parseDataURI(s); ok {
+ return false, "", b, extOfMime(mime)
+ }
+ // 纯 base64：可解码且长度足够，视为编码后的文件内容
+ trimmed := strings.TrimSpace(s)
+ if len(trimmed) >= 64 {
+ if b, err := base64.StdEncoding.DecodeString(trimmed); err == nil && len(b) > 0 {
+ return false, "", b, ".png"
+ }
+ }
+ // 文本：以 .inc 存储
+ return false, "", []byte(s), ".inc"
+}
+
+// isFileURL 判断字符串是否已是对外可访问的 URL 路径（http/https 开头）
+func isFileURL(s string) bool {
+ lower := strings.ToLower(s)
+ return strings.HasPrefix(lower, "http://") || strings.HasPrefix(lower, "https://")
+}
+
+// extOfMime 按 MIME 类型推断文件扩展名
+func extOfMime(mime string) string {
+ switch strings.ToLower(strings.TrimSpace(mime)) {
+ case "image/png", "png":
+ return ".png"
+ case "image/jpeg", "image/jpg", "jpeg", "jpg":
+ return ".jpg"
+ case "image/webp":
+ return ".webp"
+ case "image/gif":
+ return ".gif"
+ case "audio/mpeg", "audio/mp3", "mp3":
+ return ".mp3"
+ case "audio/wav", "wav":
+ return ".wav"
+ case "video/mp4", "mp4":
+ return ".mp4"
+ case "application/json", "json":
+ return ".json"
+ default:
+ return ""
+ }
+}
+
+// parseDataURI 解析 data URI：data:;base64,，返回解码字节与 mime
+func parseDataURI(s string) ([]byte, string, bool) {
+ const prefix = "data:"
+ if !strings.HasPrefix(s, prefix) {
+ return nil, "", false
+ }
+ rest := s[len(prefix):]
+ comma := strings.Index(rest, ",")
+ if comma < 0 {
+ return nil, "", false
+ }
+ mime := rest[:comma]
+ if semicolon := strings.Index(mime, ";"); semicolon >= 0 {
+ mime = mime[:semicolon]
+ }
+ payload := strings.TrimPrefix(rest[comma+1:], "base64,")
+ b, err := base64.StdEncoding.DecodeString(payload)
+ if err != nil {
+ return nil, "", false
+ }
+ return b, mime, true
+}
diff --git a/workflow/service/flow/lambda_script_transcribe.go b/workflow/service/flow/lambda_script_transcribe.go
index 52dcbc5..ea433b9 100644
--- a/workflow/service/flow/lambda_script_transcribe.go
+++ b/workflow/service/flow/lambda_script_transcribe.go
@@ -4,6 +4,7 @@ import (
"ai-agent/workflow/consts/node"
"ai-agent/workflow/service/flow/processor"
"ai-agent/workflow/service/flow/processor/builtin/split_shots_pipeline"
+ "ai-agent/workflow/service/flow/values"
"context"
"encoding/json"
"fmt"
@@ -81,7 +82,7 @@ func ScriptTranscribeLambda(ctx context.Context, input any) (any, error) {
}
}
- modelParams, err := BuildModelRequestBody(nodeInput.Config.ModelConfig.ModelRequestParamsPath, nodeInput.Global)
+ modelParams, err := values.BuildModelRequestBody(nodeInput.Config.ModelConfig.ModelRequestParamsPath, nodeInput.Global)
if err != nil {
return nil, err
}
diff --git a/workflow/service/flow/lambda_segment_resume.go b/workflow/service/flow/lambda_segment_resume.go
index 92a6fff..70f6616 100644
--- a/workflow/service/flow/lambda_segment_resume.go
+++ b/workflow/service/flow/lambda_segment_resume.go
@@ -6,9 +6,6 @@ import (
"ai-agent/workflow/model/entity"
)
-// segmentGenerateMaxAttempts 视频段生成最大尝试次数（失败自动重试 1 次，共 2 次尝试），参数化可调
-const segmentGenerateMaxAttempts = 2
-
// planSegmentResume 段级续跑决策：段身份取列表位置（0-based，paramsList 顺序即段序），
// 把各段映射到"是否需重新生成"。savedMap 为该节点已成功段（段序号 → {key,url}）；
// 段在表中缺失或地址为空则需重新生成。返回值与 paramsList 对齐。
diff --git a/workflow/service/flow/lambda_subflow.go b/workflow/service/flow/lambda_subflow.go
new file mode 100644
index 0000000..debd14c
--- /dev/null
+++ b/workflow/service/flow/lambda_subflow.go
@@ -0,0 +1,219 @@
+package flow
+
+import (
+ "ai-agent/workflow/consts/node"
+ flowDto "ai-agent/workflow/model/dto/flow"
+ "ai-agent/workflow/model/entity"
+ "ai-agent/workflow/service/flow/values"
+ "context"
+ "encoding/json"
+ "fmt"
+
+ "github.com/cloudwego/eino-examples/compose/batch/batch"
+ "github.com/cloudwego/eino/compose"
+ "github.com/gogf/gf/v2/frame/g"
+ "github.com/gogf/gf/v2/util/gconv"
+)
+
+func SubFlowLambda(ctx context.Context, input any) (any, error) {
+ // 1. 类型断言（和其他节点保持一致的入参结构）
+ nodeExecInput, ok := input.(*flowDto.NodeExecutionInput)
+ if !ok {
+ return nil, fmt.Errorf("子流程节点入参类型错误，期望*flowDto.NodeExecutionInput，实际%T", input)
+ }
+ // 2. 解析子流程配置
+ subFlowConfig := nodeExecInput.Config.SubConfig
+ if subFlowConfig == nil {
+ return nil, fmt.Errorf("子流程节点缺少配置")
+ }
+ getRes, err := FlowUserService.Get(ctx, &flowDto.GetFlowUserReq{
+ Id: subFlowConfig.WorkflowId,
+ })
+ if err != nil {
+ return nil, err
+ }
+ // 3. 引入参数解析：把首页表单值/上游引用值/静态默认值写入子流程开始节点 outputConfig。
+ // 须在 BuildGraph / ExtractFlowNodeFrom 之前执行，batchInputs 深拷贝的才是注入后的开始节点。
+ injectSubFlowFields(nodeExecInput.Global, getRes.FlowContent, subFlowConfig.Fields)
+ // 4. 并发数：从主流程开始节点 outputConfig 的 maxConcurrency 字段读取（前端把子流程节点生成次数表单字段聚合到主流程开始节点），读不到再用子流程节点配置兜底
+ maxConcurrency := mainFlowMaxConcurrency(nodeExecInput.Global, subFlowConfig.MaxConcurrency)
+ // 4. 编译子流程Graph（复用现有 BuildGraphFromFlowContent 逻辑）
+ nodeList, subGraph := BuildGraph(ctx, getRes.FlowContent)
+ // 4. 构建子流程Workflow（绑定START/END，和示例对齐）
+ innerWorkflow := compose.NewWorkflow[*flowDto.FlowExecutionInput, *flowDto.FlowExecutionInput]()
+ // 挂载子图节点并绑定全局START
+ innerWorkflow.AddGraphNode("sub_flow_graph", subGraph).AddInput(compose.START)
+ // 绑定子图输出到全局END
+ innerWorkflow.End().AddInput("sub_flow_graph")
+ // 生成次数（批量条数）：maxConcurrency<=0 时按 1 次兜底
+ batchCount := maxConcurrency
+ if batchCount <= 0 {
+ batchCount = 1
+ }
+ // 5. 构建BatchNode（批量执行子流程，复用示例逻辑）
+ batchNode := batch.NewBatchNode(&batch.NodeConfig[*flowDto.FlowExecutionInput, *flowDto.FlowExecutionInput]{
+ Name: fmt.Sprintf("sub_flow_batch_%s", nodeExecInput.Config.Id),
+ InnerTask: innerWorkflow,
+ MaxConcurrency: batchCount,
+ })
+
+ // 6. 提取批量输入：按生成次数生成 N 份（每份独立克隆 ConfigMap，避免并发执行时节点输出写串）
+ configMap := buildConfigMap(getRes.FlowContent, nodeList)
+ batchInputs := make([]*flowDto.FlowExecutionInput, 0, batchCount)
+ for j := 0; j < batchCount; j++ {
+ batchInputs = append(batchInputs, &flowDto.FlowExecutionInput{
+ NodeGroupId: nodeExecInput.Global.NodeGroupId,
+ ExecutionId: nodeExecInput.Global.ExecutionId,
+ FlowId: nodeExecInput.Global.FlowId,
+ ConfigMap: cloneConfigMap(configMap),
+ SessionId: nodeExecInput.Global.SessionId,
+ })
+ }
+ // 7. 执行批量子流程
+ batchOutput, err := batchNode.Invoke(ctx, batchInputs)
+ if err != nil {
+ return nil, fmt.Errorf("执行子流程BatchNode失败: %v", err)
+ }
+ // 8. 展平每份子流程执行的节点输出，写回当前节点 OutputResult 供下游引用
+ var outputRes []map[string]any
+ for _, single := range batchOutput {
+ if single == nil {
+ continue
+ }
+ outputRes = append(outputRes, collectFlowNodeResults(single)...)
+ }
+ g.Log().Info(ctx, fmt.Sprintf("子流程执行完成，共 %d 次，输出 %d 条", batchCount, len(outputRes)))
+ nodeExecInput.Config.OutputResult = outputRes
+ return nodeExecInput, nil
+}
+
+// injectSubFlowFields 将子流程节点引入参数（subConfig.Fields）解析后写入子流程开始节点
+// outputConfig，使子流程启动时能读到首页表单值/上游引用值/静态默认值。
+// 每个字段的取值优先级：valueSource 引用解析成功 → field.value → field.defaultValue；
+// 匹配键为 field（前端约定以 field 为主，不兼容 path）。
+func injectSubFlowFields(global *flowDto.FlowExecutionInput, subFlowContent *entity.FlowInfo, fields []map[string]any) {
+ if global == nil || subFlowContent == nil || len(fields) == 0 {
+ return
+ }
+ startNode := subFlowStartNode(subFlowContent)
+ if startNode == nil {
+ return
+ }
+ byField := make(map[string]map[string]any, len(startNode.OutputConfig))
+ for _, output := range startNode.OutputConfig {
+ byField[gconv.String(output["field"])] = output
+ }
+ for _, field := range fields {
+ entry := byField[gconv.String(field["field"])]
+ if entry == nil {
+ continue
+ }
+ value := field["value"]
+ if vs, has := field["valueSource"]; has && vs != nil {
+ if vsNodeId, vsField := firstValueSource(vs); vsNodeId != "" && vsField != "" {
+ if v, _, ok := values.ResolveValueSource(global, vsNodeId, vsField); ok {
+ value = v
+ }
+ }
+ }
+ if value == nil {
+ value = field["defaultValue"]
+ }
+ if value != nil {
+ entry["value"] = value
+ }
+ }
+}
+
+// firstValueSource 从 valueSource 提取第一个引用源 (nodeId, field)。
+// 前端契约统一数组 [{nodeId, field}]，旧 DSL 可能是单对象 {nodeId, field}，两种形态都兼容；
+// 子流程字段与引用源一一对应，只取第一个。
+func firstValueSource(vs any) (nodeId, field string) {
+ if vs == nil {
+ return
+ }
+ switch v := vs.(type) {
+ case []any:
+ if len(v) > 0 {
+ return firstValueSource(v[0])
+ }
+ return
+ case []map[string]any:
+ if len(v) > 0 {
+ return firstValueSource(v[0])
+ }
+ return
+ }
+ m := gconv.Map(vs)
+ nodeId = gconv.String(m["nodeId"])
+ field = gconv.String(m["field"])
+ return
+}
+
+// subFlowStartNode 返回工作流开始节点
+func subFlowStartNode(content *entity.FlowInfo) *entity.FlowNode {
+ if content == nil {
+ return nil
+ }
+ for i := range content.Nodes {
+ if content.Nodes[i].Id == content.StartNodeId {
+ return &content.Nodes[i]
+ }
+ }
+ return nil
+}
+
+// mainFlowMaxConcurrency 取子流程批量执行并发数：从主流程开始节点 outputConfig
+// 的 maxConcurrency 字段读取（前端把子流程节点的生成次数表单字段聚合到主流程开始节点），
+// 读不到再用子流程节点配置的兜底值。
+func mainFlowMaxConcurrency(global *flowDto.FlowExecutionInput, fallback int) int {
+ if global == nil {
+ return fallback
+ }
+ for _, n := range global.ConfigMap {
+ if n == nil || n.NodeCode != node.NodeTypeStart {
+ continue
+ }
+ for _, output := range n.OutputConfig {
+ if gconv.String(output["field"]) != "maxConcurrency" && gconv.String(output["path"]) != "maxConcurrency" {
+ continue
+ }
+ if v := gconv.Int(output["value"]); v > 0 {
+ return v
+ }
+ }
+ return fallback
+ }
+ return fallback
+}
+
+// cloneConfigMap 深拷贝 ConfigMap，保证各批次子流程并发执行时节点输出互不串扰。
+// 浅拷贝会共享 *entity.FlowNode，并发写 OutputResult 产生竞态。
+func cloneConfigMap(src map[string]*entity.FlowNode) map[string]*entity.FlowNode {
+ dst := make(map[string]*entity.FlowNode, len(src))
+ for k, v := range src {
+ data, err := json.Marshal(v)
+ if err != nil {
+ dst[k] = v
+ continue
+ }
+ n := new(entity.FlowNode)
+ if err = json.Unmarshal(data, n); err != nil {
+ dst[k] = v
+ continue
+ }
+ dst[k] = n
+ }
+ return dst
+}
+
+// collectFlowNodeResults 收集一次子流程执行中所有已执行节点的输出，展平成 {字段:值} 列表
+func collectFlowNodeResults(execInput *flowDto.FlowExecutionInput) []map[string]any {
+ var res []map[string]any
+ for _, executed := range execInput.ExecutedNodes {
+ if nodeConfig := execInput.ConfigMap[executed.NodeId]; nodeConfig != nil {
+ res = append(res, nodeConfig.OutputResult...)
+ }
+ }
+ return res
+}
diff --git a/workflow/service/flow/lambda_summary.go b/workflow/service/flow/lambda_summary.go
new file mode 100644
index 0000000..fdaae14
--- /dev/null
+++ b/workflow/service/flow/lambda_summary.go
@@ -0,0 +1,122 @@
+package flow
+
+import (
+ "ai-agent/workflow/consts/flow"
+ "ai-agent/workflow/consts/public"
+ nodeDao "ai-agent/workflow/dao/node"
+ sessionDao "ai-agent/workflow/dao/session"
+ flowDto "ai-agent/workflow/model/dto/flow"
+ nodeDto "ai-agent/workflow/model/dto/node"
+ sessionDto "ai-agent/workflow/model/dto/session"
+ "ai-agent/workflow/model/entity"
+ "context"
+ "fmt"
+ "strings"
+
+ "gitea.redpowerfuture.com/red-future/common/db/gfdb"
+ "github.com/gogf/gf/v2/database/gdb"
+ "github.com/gogf/gf/v2/frame/g"
+ "github.com/gogf/gf/v2/util/gconv"
+)
+
+func DataMergeLambda(ctx context.Context, input any) (res any, err error) {
+ nodeInput, ok := input.(*flowDto.NodeExecutionInput)
+ if !ok {
+ return nil, fmt.Errorf("参数合并入参类型错误")
+ }
+ return nodeInput, nil
+}
+
+func SummaryLambda(ctx context.Context, input any) (any, error) {
+ execInput, ok := input.(*flowDto.NodeExecutionInput)
+ if !ok {
+ return nil, fmt.Errorf("汇总节点入参类型错误，实际是 %T", input)
+ }
+
+ // 聚合所有已执行节点中需入库的文件结果（两层规则）
+ summaryResult := collectSaveFileResults(ctx, execInput.Global)
+
+ // 把汇总结果存入当前节点的输出
+ g.Log().Info(ctx, fmt.Sprintf("结果汇总完成，汇总数据：%+v", summaryResult))
+
+ err := gfdb.DB(ctx, public.DbNameBlackDeacon).Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
+ res, _, err := nodeDao.NodeExecutionDao.ListByFlowExecutionId(ctx, &nodeDto.ListNodeExecutionByFlowReq{
+ NodeGroupId: execInput.Global.NodeGroupId,
+ }, entity.NodeExecutionCol.TokenInfo)
+ if err != nil {
+ return err
+ }
+ var totalTokens int
+ var totalFee float64
+ for _, item := range res {
+ for _, itemToken := range item.TokenInfo {
+ m := gconv.Map(itemToken)
+ totalTokens += gconv.Int(m["total_tokens"])
+ totalFee += gconv.Float64(m["total_fee"])
+ }
+ }
+ _, err = sessionDao.ExecWorkflowDao.Update(ctx, &sessionDto.UpdateWorkflowReq{
+ Id: execInput.Global.ExecutionId,
+ Status: flow.FlowExecutionStatusSuccess.Code(),
+ TotalTokens: totalTokens,
+ TotalFee: totalFee,
+ })
+ if err != nil {
+ return err
+ }
+ if len(summaryResult) > 0 {
+ _, err = sessionDao.ExecWorkflowResultDao.BatchInsert(ctx, summaryResult)
+ if err != nil {
+ return err
+ }
+ }
+ return nil
+ })
+
+ return execInput, err
+}
+
+// collectSaveFileResults 按两层规则收集需入库的文件结果：
+// 第一层：节点须开启"保存文件"（IsSaveFile）；
+// 第二层：key 取自节点 OutputResult 的各字段，命中 ModelResponseBodyMapping 才入库；
+// 原始响应体 key（respBody）恒入库（不要求映射声明）；HTTP 节点产出以 http_file_url:{key}
+// 标记的字段（IsSaveFile 时由 HttpCallResultLambda 生成）恒入库（无模型响应映射可查）。
+// 结果值为 http(s) URL 或 MinIO 对象裸路径直接使用；非路径值（base64 图片/文本）先上传 OSS 换取 URL，
+// 文本内容以 .inc 扩展名存储。
+func collectSaveFileResults(ctx context.Context, execInput *flowDto.FlowExecutionInput) []*sessionDto.CreateWorkflowResultReq {
+ if execInput == nil {
+ return nil
+ }
+ var summaryResult []*sessionDto.CreateWorkflowResultReq
+ for _, executedNode := range execInput.ExecutedNodes {
+ nodeConfig := execInput.ConfigMap[executedNode.NodeId]
+ if nodeConfig == nil || len(nodeConfig.OutputResult) == 0 || !nodeConfig.IsSaveFile {
+ continue
+ }
+ // 第二层：key 取自节点 OutputResult 的各字段，
+ // 命中 ModelResponseBodyMapping 才入库；respBody 与 HTTP 节点 http_file_url:{key} 标记恒入库
+ saveKeys := nodeConfig.ModelConfig.ModelResponseBodyMapping
+ for _, respBody := range nodeConfig.OutputResult {
+ for key, val := range gconv.Map(respBody) {
+ isHTTPFile := strings.HasPrefix(key, "http_file_url:")
+ if !isHTTPFile {
+ if _, ok := saveKeys[key]; !ok && key != "respBody" {
+ continue
+ }
+ }
+ fileUrl, err := resolveSaveFileResult(ctx, val)
+ if err != nil {
+ g.Log().Warningf(ctx, "collectSaveFileResults 上传结果文件失败 key=%s err=%v", key, err)
+ continue
+ }
+ summaryResult = append(summaryResult, &sessionDto.CreateWorkflowResultReq{
+ SessionId: execInput.SessionId,
+ FlowId: execInput.FlowId,
+ ExecId: execInput.ExecutionId,
+ ResultFileUrl: fileUrl,
+ })
+ }
+ }
+ }
+ return summaryResult
+}
diff --git a/workflow/service/flow/lambda_tool.go b/workflow/service/flow/lambda_tool.go
new file mode 100644
index 0000000..0b26218
--- /dev/null
+++ b/workflow/service/flow/lambda_tool.go
@@ -0,0 +1,90 @@
+package flow
+
+import (
+ "ai-agent/gateway"
+ "ai-agent/workflow/consts/model"
+ "ai-agent/workflow/service/flow/processor"
+ "context"
+ "fmt"
+ "strings"
+
+ "github.com/gogf/gf/v2/frame/g"
+)
+
+// isVideoModel 判断模型是否为视频模型（模型类型 TypeVideo=600），用于视频节点多视频自动合成判断
+func isVideoModel(ctx context.Context, modelId int64) bool {
+ modelInfo, err := gateway.GetModelInfoById(ctx, &gateway.GetModelInfoByIdReq{ModelId: modelId})
+ if err != nil {
+ g.Log().Warningf(ctx, "查询模型配置失败，跳过自动视频合成 modelId=%d err=%v", modelId, err)
+ return false
+ }
+ return modelInfo.ModelManage.ModelType != nil && *modelInfo.ModelManage.ModelType == model.TypeVideo
+}
+
+// invokePreTool 执行前置处理器，把模型请求参数转换为模型调用入参列表。
+// 前置处理器契约：入参即模型请求参数本体；返回值：
+// - map[string]any 一次模型调用，入参为返回值
+// - []map[string]any 多次模型调用，逐个入参请求
+// - nil 视为异常，节点失败（不允许静默跳过模型调用）
+func invokePreTool(ctx context.Context, processorName string, modelParams map[string]any) (paramsList []map[string]any, err error) {
+ if processorName == "" {
+ return []map[string]any{stripInternalKeys(modelParams)}, nil
+ }
+ data, err := processor.Call(ctx, processorName, modelParams)
+ if err != nil {
+ return nil, fmt.Errorf("执行前置处理器[%s]失败: %v", processorName, err)
+ }
+ switch v := data.(type) {
+ case nil:
+ return nil, fmt.Errorf("前置处理器[%s]返回空", processorName)
+ case map[string]any:
+ return []map[string]any{stripInternalKeys(v)}, nil
+ case []map[string]any:
+ list := make([]map[string]any, 0, len(v))
+ for _, m := range v {
+ list = append(list, stripInternalKeys(m))
+ }
+ return list, nil
+ default:
+ return nil, fmt.Errorf("前置处理器[%s]返回类型不支持: %T", processorName, data)
+ }
+}
+
+// stripInternalKeys 剥离 __ 前缀的内部键（如 __segment_fields/__produced），
+// 模型网关做参数严格校验（CheckParams strictUnknown）会拒绝未知字段，内部标记不得随请求体下发。
+func stripInternalKeys(params map[string]any) map[string]any {
+ if params == nil {
+ return params
+ }
+ for k := range params {
+ if strings.HasPrefix(k, "__") {
+ delete(params, k)
+ }
+ }
+ return params
+}
+
+// invokePostTool 执行后置处理器，加工模型调用结果。
+// 后置处理器契约：入参 {"output": 模型输出结果列表, "request": 原始模型请求参数}（列表须包成对象传入）；返回值：
+// - []map[string]any 替换模型输出
+// - map[string]any 替换为单条输出
+// - nil 保留原输出
+func invokePostTool(ctx context.Context, processorName string, outputRes []map[string]any, requestParams map[string]any) ([]map[string]any, error) {
+ if processorName == "" {
+ return outputRes, nil
+ }
+ data, err := processor.Call(ctx, processorName, map[string]any{"output": outputRes, "request": requestParams})
+ if err != nil {
+ return nil, fmt.Errorf("执行后置处理器[%s]失败: %v", processorName, err)
+ }
+ switch v := data.(type) {
+ case nil:
+ return outputRes, nil
+ case []map[string]any:
+ return v, nil
+ case map[string]any:
+ return []map[string]any{v}, nil
+ default:
+ return nil, fmt.Errorf("后置处理器[%s]返回类型不支持: %T", processorName, data)
+ }
+}
diff --git a/workflow/service/flow/lambda_value_source.go b/workflow/service/flow/lambda_value_source.go
deleted file mode 100644
index e0f90c9..0000000
--- a/workflow/service/flow/lambda_value_source.go
+++ /dev/null
@@ -1,703 +0,0 @@
-package flow
-
-import (
- "ai-agent/workflow/consts/node"
- flowDto "ai-agent/workflow/model/dto/flow"
- "ai-agent/workflow/model/entity"
- "context"
- "encoding/json"
- "reflect"
- "regexp"
- "strconv"
- "strings"
-
- "github.com/gogf/gf/v2/frame/g"
- "github.com/gogf/gf/v2/os/glog"
- "github.com/gogf/gf/v2/util/gconv"
- "github.com/tidwall/gjson"
-)
-
-var (
- // 匹配 [数字]
- regNumIndex = regexp.MustCompile(`\[\d+\]`)
- // 匹配 .attrs
- regAttrs = regexp.MustCompile(`\.attrs`)
- // 匹配带捕获组的数组下标，转扁平点分路径用
- arrayIndexPath = regexp.MustCompile(`\[(\d+)\]`)
-)
-
-// 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, "")
- index := CleanFieldPathReplaceNumIndex(path)
- attrs := CleanFieldPathRemoveAttrs(index)
- return attrs
-}
-
-func CleanFieldPathReplaceNumIndex(path string) string {
- // 1. 替换 [数字] 为 [*]
- s := regNumIndex.ReplaceAllString(path, `.#`)
- return s
-}
-
-func CleanFieldPathRemoveAttrs(path string) string {
- // 2. 移除所有 .attrs
- s := regAttrs.ReplaceAllString(path, "")
- 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
- }
- if tmplArr, isArr := tmplVal.([]any); isArr {
- result[key] = mapTemplateArray(tmplArr, srcVal)
- continue
- }
- result[key] = srcVal
- }
- return result
-}
-
-// mapTemplateArray 按模板数组的元素结构映射 source 数组：
-// 模板首元素为对象时，逐元素按 MapResultByTemplate 过滤只保留模板字段；
-// 模板数组为空或首元素非对象（无法确定元素结构）时，原样拷贝 source 数组。
-func mapTemplateArray(tmplArr []any, srcVal any) any {
- srcList, ok := srcVal.([]any)
- if !ok || len(tmplArr) == 0 {
- return srcVal
- }
- elemTmpl, ok := tmplArr[0].(map[string]any)
- if !ok {
- return srcVal
- }
- result := make([]any, 0, len(srcList))
- for _, srcElem := range srcList {
- if srcMap, isMap := srcElem.(map[string]any); isMap {
- result = append(result, MapResultByTemplate(elemTmpl, srcMap))
- } else {
- result = append(result, srcElem)
- }
- }
- 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 是各段扁平请求参数，按段序收集字段为数组（段位留 nil）
-// - 其他节点：读 OutputResult 中 fieldName 路径对应的值
-func resolveValueSource(global *flowDto.FlowExecutionInput, nodeId, field 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"]) != field {
- continue
- }
- if !g.IsEmpty(output["value"]) {
- return output["value"], output["refsName"], true
- }
- }
- case node.NodeTypeScriptTranscribe:
- // 脚本转写节点 OutputResult 是各段扁平请求参数（split_shots_pipeline 产出，key 为字面量
- // prompt/duration/seed 等），按段序读取 output[field] 收集为数组，供分段模型节点整体引用。
- // 每段都占一位（字段缺失/为空留 nil），保证数组与段序对齐，供 split_segment 按段取值。
- var list []any
- for _, output := range nodeConfig.OutputResult {
- list = append(list, output[field])
- }
- for _, v := range list {
- if !g.IsEmpty(v) {
- return list, "", true
- }
- }
- default:
- // templates 是模型节点在前端配置的静态输出模板，不在 OutputResult 中，需单独取
- if field == "templates" {
- if !g.IsEmpty(nodeConfig.Templates) {
- return nodeConfig.Templates, "", true
- }
- return nil, nil, false
- }
- for _, output := range nodeConfig.OutputResult {
- // 模型节点输出记录是单 key 的字面量扁平 key（如 "choices.attrs[0].attrs.delta.attrs.content"），
- // gjson 会把 . 和 [0] 当结构路径解析，无法命中字面量 key，故先按字面量 key 直接取值；
- // 未命中再回退 gjson 路径查询（兼容真正嵌套的输出结构）。
- if v, has := output[field]; has {
- value = v
- } else {
- value = gjson.Get(gconv.String(output), field).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{}:
- // 有 valueSource：解析引用节点值
- if valueSource, hasSource := v["valueSource"]; hasSource {
- sources := new([]entity.ValueSource)
- gconv.Structs(valueSource, sources)
-
- // 多个引用源：把各源解析出的值拼成 "label: value"（无 label 只拼值），逗号分隔
- if len(*sources) > 1 {
- parts := make([]string, 0, len(*sources))
- var refsName any
- for _, src := range *sources {
- value, rn, ok := resolveValueSource(globalParams, src.NodeId, src.Field)
- if !ok || schemaValueEmpty(value) {
- continue
- }
- // 引用非模型节点（开始/表单/HTTP/脚本转写等）时，值按当前字段声明的 type 做类型化转换；
- // 模型节点值由模型网关处理，复制时不需要转换
- if !isModelSourceNode(globalParams, src.NodeId) {
- value = assignBySchemaType(v, value)
- }
- text := toPlainString(value)
- if src.Label != "" {
- text = src.Label + ": " + text
- }
- parts = append(parts, text)
- if !g.IsEmpty(rn) && g.IsEmpty(refsName) {
- refsName = rn
- }
- }
- if len(parts) > 0 {
- v["value"] = strings.Join(parts, ", ")
- if !g.IsEmpty(refsName) {
- v["refsName"] = refsName
- }
- return
- }
- } else if len(*sources) == 1 {
- // 单个引用源：保持旧行为，值按原样赋值（非模型节点按声明 type 转换）
- src := (*sources)[0]
- value, refsName, ok := resolveValueSource(globalParams, src.NodeId, src.Field)
- if ok && !isModelSourceNode(globalParams, src.NodeId) {
- value = assignBySchemaType(v, value)
- }
- if ok && !schemaValueEmpty(value) {
- v["value"] = value
- if !g.IsEmpty(refsName) {
- v["refsName"] = refsName
- }
- return
- }
- }
- }
- // 统一兜底：无 valueSource（或解析失败/值为空）时，value 为空或 0 则取 defaultValue
- if defaultValue, hasDefault := v["defaultValue"]; hasDefault && isEmptyForFallback(v["value"]) && !schemaValueEmpty(defaultValue) {
- v["value"] = defaultValue
- }
- // 递归遍历所有子元素
- for _, child := range v {
- walkMap(child, globalParams)
- }
- case []interface{}:
- // 数组遍历
- for _, item := range v {
- walkMap(item, globalParams)
- }
- }
-}
-
-// isEmptyForFallback 兜底场景判空：除 schemaValueEmpty 规则外，数字 0 也视为未填写，
-// 便于配置了 defaultValue 的字段在值为 0 时用默认值兜底。
-// 覆盖 json.Number（gconv 反序列化数字的运行时类型）与字符串 "0"/"0.0"。
-func isEmptyForFallback(v interface{}) bool {
- if schemaValueEmpty(v) {
- return true
- }
- switch val := v.(type) {
- case float32:
- return val == 0
- case float64:
- return val == 0
- case int:
- return val == 0
- case int8:
- return val == 0
- case int16:
- return val == 0
- case int32:
- return val == 0
- case int64:
- return val == 0
- case uint:
- return val == 0
- case uint8:
- return val == 0
- case uint16:
- return val == 0
- case uint32:
- return val == 0
- case uint64:
- return val == 0
- case json.Number:
- if f, err := val.Float64(); err == nil {
- return f == 0
- }
- case string:
- if f, err := strconv.ParseFloat(val, 64); err == nil {
- return f == 0
- }
- }
- return false
-}
-
-// isModelSourceNode 判断引用源节点是否为模型节点（值由模型网关处理，复制时不转换）
-func isModelSourceNode(global *flowDto.FlowExecutionInput, nodeId string) bool {
- if global == nil || global.ConfigMap == nil {
- return false
- }
- nodeConfig := global.ConfigMap[nodeId]
- return nodeConfig != nil && nodeConfig.NodeCode == node.NodeTypeModel
-}
-
-// assignBySchemaType 按当前字段声明的 schema 类型把值类型化：
-// string 遇数组/对象转 JSON 字符串；number/boolean 解析字符串；object/array 解析 JSON 字符串；其余原样返回
-func assignBySchemaType(node map[string]interface{}, value any) any {
- t, _ := node["type"].(string)
- return assignByType(t, value)
-}
-
-// assignByType 按字段声明的 type 把值类型化；walkMap 的 schema 节点与 parseMap 的模型参数共用
-func assignByType(t string, value any) any {
- switch t {
- case "string":
- return toSchemaString(value)
- case "number":
- return toSchemaNumber(value)
- case "boolean":
- return toSchemaBool(value)
- case "object", "array":
- return toSchemaStruct(value)
- default:
- return value
- }
-}
-
-// toSchemaString 转 string：字符串原样，数组元素拼成字符串（单元素取元素本身，多元素逗号连接），对象序列化为 JSON 字符串
-func toSchemaString(v any) any {
- switch val := v.(type) {
- case []interface{}:
- parts := make([]string, 0, len(val))
- for _, item := range val {
- parts = append(parts, toPlainString(item))
- }
- return strings.Join(parts, ",")
- case map[string]interface{}:
- if b, err := json.Marshal(val); err == nil {
- return string(b)
- }
- }
- return v
-}
-
-// toPlainString 把数组元素转成不带括号的纯字符串：
-// 数组（[]any / 类型化切片）逐元素取纯字符串，单元素取元素本身，多元素逗号连接；
-// 对象序列化为 JSON 字符串；其余原样字符串化。
-func toPlainString(v any) string {
- if s, ok := v.(string); ok {
- return s
- }
- switch val := v.(type) {
- case []interface{}:
- parts := make([]string, 0, len(val))
- for _, item := range val {
- parts = append(parts, toPlainString(item))
- }
- return strings.Join(parts, ",")
- case map[string]interface{}:
- if b, err := json.Marshal(val); err == nil {
- return string(b)
- }
- }
- rv := reflect.ValueOf(v)
- if rv.IsValid() && (rv.Kind() == reflect.Slice || rv.Kind() == reflect.Array) {
- parts := make([]string, 0, rv.Len())
- for i := 0; i < rv.Len(); i++ {
- parts = append(parts, toPlainString(rv.Index(i).Interface()))
- }
- return strings.Join(parts, ",")
- }
- if b, err := json.Marshal(v); err == nil {
- return string(b)
- }
- return gconv.String(v)
-}
-
-// toSchemaNumber 转 number：数字原样，字符串尝试解析为 float64，失败原样返回
-func toSchemaNumber(v any) any {
- if s, ok := v.(string); ok {
- if f, err := strconv.ParseFloat(s, 64); err == nil {
- return f
- }
- }
- return v
-}
-
-// toSchemaBool 转 boolean：布尔原样，字符串尝试解析为 bool，失败原样返回
-func toSchemaBool(v any) any {
- if s, ok := v.(string); ok {
- if b, err := strconv.ParseBool(s); err == nil {
- return b
- }
- }
- return v
-}
-
-// toSchemaStruct 转 object/array：合法 JSON 字符串解析为结构化数据，否则原样返回
-func toSchemaStruct(v any) any {
- s, ok := v.(string)
- if !ok {
- return v
- }
- if !json.Valid([]byte(s)) {
- return v
- }
- var out any
- if err := json.Unmarshal([]byte(s), &out); err != nil {
- return v
- }
- return out
-}
-
-// 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
- }
-}
-
-// BuildModelRequestBody 从参数定义 + 全局执行上下文构建最终嵌套 JSON 请求体。
-func BuildModelRequestBody(params []entity.FlowModelParams, globalParams *flowDto.FlowExecutionInput) (map[string]interface{}, error) {
- // 1. 解析引用、过滤空值
- resolved := parseMap(params, globalParams)
-
- // 2. 转扁平路径映射
- flat := toFlatMap(resolved)
-
- // 3. 引用了脚本转写节点的字段打内部标记 __segment_fields（逗号分隔的扁平路径），
- // 供前置处理器 split_segment 按段拆批；__ 前缀内部键由 invokePreTool 统一剥离，不传给模型网关
- if seg := segmentFields(resolved, globalParams); len(seg) > 0 {
- flat["__segment_fields"] = strings.Join(seg, ",")
- }
-
- return flat, nil
-}
-
-// segmentFields 收集引用了脚本转写节点的字段扁平路径（分段字段）。
-// 脚本转写节点按段产出一份扁平参数列表，下游模型节点单源引用其字段时，
-// 值按段序聚合成数组（见 resolveValueSource 的 scriptTranscribe 分支），需随批拆分。
-func segmentFields(resolved []entity.FlowModelParams, globalParams *flowDto.FlowExecutionInput) []string {
- if globalParams == nil || globalParams.ConfigMap == nil {
- return nil
- }
- var fields []string
- for _, p := range resolved {
- if g.IsEmpty(p.Path) || len(p.ValueSource) != 1 {
- continue
- }
- src := p.ValueSource[0]
- if nodeConfig := globalParams.ConfigMap[src.NodeId]; nodeConfig != nil &&
- nodeConfig.NodeCode == node.NodeTypeScriptTranscribe {
- fields = append(fields, flatPath(p.Path))
- }
- }
- return fields
-}
-
-// parseMap 解析模型请求参数
-func parseMap(data []entity.FlowModelParams, globalParams *flowDto.FlowExecutionInput) []entity.FlowModelParams {
- newData := make([]entity.FlowModelParams, 0, len(data))
- for _, item := range data {
- var d entity.FlowModelParams
- d.Path = item.Path
- d.Type = item.Type
-
- // 无引用源：直接取静态值
- if g.IsEmpty(item.ValueSource) {
- if isParamEmpty(item.Value) {
- continue
- }
- d = item
- newData = append(newData, d)
- continue
- }
-
- // 有引用源：单源保持旧行为；多源把各源解析出的值拼成 "label: value"（无 label 只拼值），逗号分隔
- var value, refsName any
- if len(item.ValueSource) > 1 {
- parts := make([]string, 0, len(item.ValueSource))
- for _, src := range item.ValueSource {
- v, rn, ok := resolveValueSource(globalParams, src.NodeId, src.Field)
- if !ok || isParamEmpty(v) {
- continue
- }
- // 模型解析时引用其他节点的值不做类型化转换；
- // 多引用源需拼接为字符串，用 toPlainString 渲染（数组取元素去括号）
- text := toPlainString(v)
- if src.Label != "" {
- text = src.Label + ": " + text
- }
- parts = append(parts, text)
- if !g.IsEmpty(rn) && g.IsEmpty(refsName) {
- refsName = rn
- }
- }
- if len(parts) == 0 {
- // 解析失败不静默，留日志便于排查引用丢失
- glog.Debugf(context.Background(),
- "resolve value source failed, nodeId=%+v path=%s",
- item.ValueSource, item.Path)
- continue
- }
- d.Value = strings.Join(parts, ", ")
- d.RefsName = gconv.String(refsName)
- d.ValueSource = item.ValueSource
- newData = append(newData, d)
- continue
- }
-
- // 单个引用源：解析取非空值；模型解析时引用其他节点的数组值不做类型化转换，整体传给模型
- src := item.ValueSource[0]
- value, refsName, ok := resolveValueSource(globalParams, src.NodeId, src.Field)
- if !ok || isParamEmpty(value) {
- // 解析失败不静默，留日志便于排查引用丢失
- glog.Debugf(context.Background(),
- "resolve value source failed, nodeId=%+v path=%s",
- item.ValueSource, item.Path)
- continue
- }
- d.Value = value
- d.RefsName = gconv.String(refsName)
- d.ValueSource = item.ValueSource
- newData = append(newData, d)
- }
- return newData
-}
-
-// toFlatMap 将解析后的参数列表转为 sjson 可用的扁平路径映射。
-// key 为 Path，value 为参数值；保留 RefsName 供上层追踪引用来源。
-func toFlatMap(params []entity.FlowModelParams) map[string]interface{} {
- m := make(map[string]interface{}, len(params))
- for _, p := range params {
- if g.IsEmpty(p.Path) {
- continue
- }
- m[flatPath(p.Path)] = p.Value
- }
- return m
-}
-
-// flatPath 把数组下标路径转扁平点分路径：a[0].b → a.0.b。
-func flatPath(path string) string {
- return arrayIndexPath.ReplaceAllString(path, `.$1`)
-}
-
-// isParamEmpty 判断参数值是否为"空"。
-// 仅 nil、空字符串、空切片/映射视为空；0、false 等零值是合法值，保留。
-func isParamEmpty(v interface{}) bool {
- if v == nil {
- return true
- }
- switch val := v.(type) {
- case string:
- return val == ""
- case []byte:
- return len(val) == 0
- case []interface{}:
- return len(val) == 0
- case map[string]interface{}:
- return len(val) == 0
- default:
- // 数字、布尔、结构体等一律视为非空
- return false
- }
-}
diff --git a/workflow/service/flow/lambda_node_util.go b/workflow/service/flow/model_call.go
similarity index 55%
rename from workflow/service/flow/lambda_node_util.go
rename to workflow/service/flow/model_call.go
index 8d0fc3b..27e756e 100644
--- a/workflow/service/flow/lambda_node_util.go
+++ b/workflow/service/flow/model_call.go
@@ -5,12 +5,10 @@ import (
"ai-agent/workflow/consts/model"
"ai-agent/workflow/consts/node"
flowDto "ai-agent/workflow/model/dto/flow"
+ "ai-agent/workflow/service/flow/values"
"context"
"fmt"
- "regexp"
"strings"
- "sync"
- "unicode/utf8"
commonHttp "gitea.redpowerfuture.com/red-future/common/http"
"gitea.redpowerfuture.com/red-future/common/oss"
@@ -21,47 +19,6 @@ import (
"github.com/google/uuid"
)
-// 全局等待任务回调的工具
-var (
- asyncMu sync.Mutex
- asyncTasks = make(map[string]chan any)
-)
-
-// Wait 阻塞等待回调结果
-// 调用后会一直卡住，直到 Notify 唤醒 或 超时/取消
-func Wait(ctx context.Context, taskId string) (any, error) {
- asyncMu.Lock()
- ch := make(chan any, 1)
- asyncTasks[taskId] = ch
- asyncMu.Unlock()
-
- defer close(ch)
- for {
- select {
- case result := <-ch:
- return result, nil
- case <-ctx.Done():
- asyncMu.Lock()
- delete(asyncTasks, taskId)
- asyncMu.Unlock()
- return nil, ctx.Err()
- }
- }
-}
-
-// Notify 回调时调用，唤醒等待的任务
-func Notify(taskId string, result any) {
- asyncMu.Lock()
- defer asyncMu.Unlock()
-
- ch, exist := asyncTasks[taskId]
- if !exist {
- return
- }
- ch <- result
- delete(asyncTasks, taskId)
-}
-
// ModelCallResultLambda 调用模型并返回输出内容列表，同时回传本次调用的 token/费用（*gateway.ModelCallRes）
// 与是否推理模型（供 ModelLambda 决定分批结果是否拼接），供调用方（ModelLambda）累计写入节点执行记录
// token_info，最后由汇总节点聚合到 exec_workflow。
@@ -126,7 +83,7 @@ func HttpCallResultLambda(ctx context.Context, nodeInput *flowDto.NodeExecutionI
body = gconv.Map(item.Value)
case "response":
// 先剥掉 {type, value/attrs} 包裹层，得到干净的输出结构模板
- responseMapping = gconv.Map(UnwrapSchemaWrapper(gconv.Map(item.Value)))
+ responseMapping = gconv.Map(values.UnwrapSchemaWrapper(gconv.Map(item.Value)))
case "responseType":
responseType = gconv.String(item.Value)
if responseType == "callback" {
@@ -143,38 +100,18 @@ func HttpCallResultLambda(ctx context.Context, nodeInput *flowDto.NodeExecutionI
}
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]
- }
- }
- }
- // 后台恢复续跑无 HTTP 请求时（ctx 携带合成 user、无 token），补充 X-User-Info 供下游内部服务
- // GetUserInfo 识别租户；正常执行 ctx 无 user（仅 request 有 Authorization），不会注入，
- // 避免把内部身份透传给任意外部 URL。与 gateway/model.go requestHeaders 的恢复兜底保持一致
- if headers["X-User-Info"] == "" {
- if u := ctx.Value("user"); u != nil {
- headers["X-User-Info"] = gconv.String(u)
- }
- }
+ headers = utils.HeadersFromCtx(ctx)
}
- g.Log().Debugf(ctx, "httpCallResultLambda: body: %v", body)
-
// 构建请求参数
- ProcessValueSourceRecursive(body, nodeInput.Global)
+ values.ProcessValueSourceRecursive(body, nodeInput.Global)
// 递归剥掉 {type, value/attrs} 包裹层，只保留 key/value
- wrapper := UnwrapSchemaWrapper(body)
+ wrapper := values.UnwrapSchemaWrapper(body)
newBody := gconv.Map(wrapper)
// body 值若为 MinIO 裸路径（模型网关转存 OSS 后返回，无 http 前缀），
// 补上前缀供目标 HTTP 服务直接下载文件
addFilePathPrefix(ctx, url, newBody)
- // 打印入参
- g.Log().Debugf(ctx, "httpCallResultLambda: newBody: %v", newBody)
-
// 1. 自己生成唯一 taskId（不用前端给）
taskId := "my_task_" + uuid.New().String() // 自己生成唯一ID
if responseType == "callback" {
@@ -205,7 +142,7 @@ func HttpCallResultLambda(ctx context.Context, nodeInput *flowDto.NodeExecutionI
if responseType == "sync" {
httpResultJson := gconv.String(rawHttpResult)
// 按 responseMapping 定义的结构，从 http 返回结果中拷贝对应字段
- finalResult = MapResultByTemplate(responseMapping, rawHttpResult)
+ finalResult = values.MapResultByTemplate(responseMapping, rawHttpResult)
e = httpResultJson
}
if responseType == "callback" {
@@ -221,7 +158,7 @@ func HttpCallResultLambda(ctx context.Context, nodeInput *flowDto.NodeExecutionI
bodyStr := request.GetBodyString()
// 按 responseMapping 定义的结构，从回调结果中拷贝对应字段
- finalResult = MapResultByTemplate(responseMapping, gconv.Map(bodyStr))
+ finalResult = values.MapResultByTemplate(responseMapping, gconv.Map(bodyStr))
e = bodyStr
}
if responseType == "pull" {
@@ -320,161 +257,3 @@ func prependFilePathPrefix(prefix string, v any) any {
return val
}
}
-
-// punctRe 切分/剥离用的中文标点（含顿号、）
-var punctRe = regexp.MustCompile(`[，。；！？、]`)
-
-// BuildSubtitles 核心工具：单个sentence生成多条subtitle
-func BuildSubtitles(sents *[]flowDto.Sentence) ([]flowDto.Subtitle, error) {
- var subtitles []flowDto.Subtitle
-
- for _, sent := range *sents {
- // 1. 先按标点把文本拆成多个片段
- segList := splitTextByPunct(sent.Text)
- if len(segList) == 0 {
- continue
- }
-
- // 去标点后得到纯净片段（纯空白/纯标点片段跳过）
- var cleans []string
- for _, seg := range segList {
- c := strings.TrimSpace(cleanPunct(seg))
- if c != "" {
- cleans = append(cleans, c)
- }
- }
- if len(cleans) == 0 || len(sent.Words) == 0 {
- continue
- }
-
- // 2. 词级文本与句子文本一致时，按词精确对齐取首尾词时间（最准）
- if spans, ok := alignAllSegments(sent.Words, cleans); ok {
- for i, span := range spans {
- subtitles = append(subtitles, flowDto.Subtitle{
- Start: sent.Words[span[0]].StartTime,
- End: sent.Words[span[1]].EndTime,
- Text: cleans[i],
- })
- }
- continue
- }
-
- // 3. ASR 词级转写与句子文本不一致时（如 血→谑、数字写法不一），
- // 整句回退为按片段字符占比分配时间，避免整句被吞成一条字幕
- segWords := allocWordsByProportion(sent.Words, cleans)
- for i, ws := range segWords {
- if len(ws) == 0 {
- continue
- }
- subtitles = append(subtitles, flowDto.Subtitle{
- Start: ws[0].StartTime,
- End: ws[len(ws)-1].EndTime,
- Text: cleans[i],
- })
- }
- }
-
- return subtitles, nil
-}
-
-// splitTextByPunct 按中文标点分割句子，同时保留标点在分段内
-// 例如："这个叫高血压调理方，注意是根源调理不是临时缓解，"
-// 会变成：["这个叫高血压调理方，", "注意是根源调理不是临时缓解，"]
-func splitTextByPunct(raw string) []string {
- // 匹配中文标点并保留在文本中，按标点位置切分
- indexes := punctRe.FindAllStringIndex(raw, -1)
- if len(indexes) == 0 {
- return []string{raw}
- }
-
- var res []string
- prev := 0
- for _, idx := range indexes {
- end := idx[1] // 标点的结束位置
- seg := raw[prev:end]
- res = append(res, seg)
- prev = end
- }
- // 处理最后一段没有标点的文本
- if prev < len(raw) {
- res = append(res, raw[prev:])
- }
- return res
-}
-
-// cleanPunct 去掉中文标点，得到纯净文本
-func cleanPunct(raw string) string {
- return punctRe.ReplaceAllString(raw, "")
-}
-
-// alignAllSegments 按顺序把各纯净片段与词级文本逐字符对齐（允许个别字符不一致）。
-// 全部片段对齐成功且词被完整覆盖时返回各片段对应的词区间，否则 ok=false，
-// 由调用方回退到时间占比分配。
-func alignAllSegments(words []flowDto.Word, cleans []string) ([][2]int, bool) {
- spans := make([][2]int, len(cleans))
- wordIdx := 0
- for i, seg := range cleans {
- start := wordIdx
- segRunes := []rune(seg)
- s := 0
- for wordIdx < len(words) && s < len(segRunes) {
- for _, r := range []rune(words[wordIdx].Word) {
- if s < len(segRunes) && r == segRunes[s] {
- s++
- }
- }
- wordIdx++
- }
- // 片段文本没被完整匹配，或该片段没吃到任何词 → 无法精确对齐
- if s < len(segRunes) || start == wordIdx {
- return nil, false
- }
- spans[i] = [2]int{start, wordIdx - 1}
- }
- // 有剩余词未被任何片段覆盖，说明对齐失败，避免吞掉剩余时间
- if wordIdx < len(words) {
- return nil, false
- }
- return spans, true
-}
-
-// allocWordsByProportion 按纯净片段字符占比把整句时间区间切成段，再按时间中点把
-// 每个 word 归属到所属片段（对词级转写与句子文本不一致的情况兜底）。
-func allocWordsByProportion(words []flowDto.Word, cleans []string) [][]flowDto.Word {
- runes := make([]int, len(cleans))
- totalChars := 0
- for i, c := range cleans {
- runes[i] = utf8.RuneCountInString(c)
- totalChars += runes[i]
- }
-
- sentStart := words[0].StartTime
- sentEnd := words[len(words)-1].EndTime
- duration := sentEnd - sentStart
- if duration < 0 {
- duration = 0
- }
-
- bounds := make([]float64, len(cleans)+1)
- bounds[0] = sentStart
- accum := 0.0
- for i := range cleans {
- if totalChars > 0 {
- accum += float64(runes[i]) / float64(totalChars)
- }
- bounds[i+1] = sentStart + accum*duration
- }
-
- segWords := make([][]flowDto.Word, len(cleans))
- for _, w := range words {
- mid := (w.StartTime + w.EndTime) / 2
- idx := 0
- for b := 0; b < len(bounds)-1; b++ {
- if mid >= bounds[b+1] {
- idx = b + 1
- }
- }
- segWords[idx] = append(segWords[idx], w)
- }
- return segWords
-}
diff --git a/workflow/service/flow/processor/builtin/media/media.go b/workflow/service/flow/processor/builtin/media/media.go
index f54e1be..6981053 100644
--- a/workflow/service/flow/processor/builtin/media/media.go
+++ b/workflow/service/flow/processor/builtin/media/media.go
@@ -9,6 +9,7 @@ import (
commonHttp "gitea.redpowerfuture.com/red-future/common/http"
"gitea.redpowerfuture.com/red-future/common/oss"
+ "gitea.redpowerfuture.com/red-future/common/utils"
"github.com/gogf/gf/v2/frame/g"
"github.com/gogf/gf/v2/util/gconv"
)
@@ -158,7 +159,7 @@ func SubmitMergeAsync(ctx context.Context, videoURLs, audioURLs []string, upload
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 {
+ if err := commonHttp.Post(ctx, path, utils.HeadersFromCtx(ctx), res, req); err != nil {
return "", fmt.Errorf("提交%s任务失败: %v", kind, err)
}
if res.TaskID == "" {
@@ -199,31 +200,12 @@ func WaitMediaTask(ctx context.Context, kind TaskKind, taskID string, timeout ti
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 {
+ if err := commonHttp.Get(ctx, path, utils.HeadersFromCtx(ctx), res); err != nil {
return nil, err
}
return res, nil
}
-// requestHeaders 透传当前请求头（含 Authorization / X-User-Info），供内部服务鉴权使用；
-// 后台恢复续跑无 HTTP 请求时（ctx 携带合成 user），补充 X-User-Info 供下游 GetUserInfo 识别租户
-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]
- }
- }
- }
- if headers["X-User-Info"] == "" {
- if u := ctx.Value("user"); u != nil {
- headers["X-User-Info"] = gconv.String(u)
- }
- }
- return headers
-}
-
// segmentResult 一段视频生成的产出（原 ai-agent/video/plan.SegmentResult，plan 包已并入处理器树）。
type segmentResult struct {
SegmentIndex int `json:"segment_index"`
diff --git a/workflow/service/flow/react_ws_exec.go b/workflow/service/flow/react_ws_exec.go
index a1ba55d..67fa326 100644
--- a/workflow/service/flow/react_ws_exec.go
+++ b/workflow/service/flow/react_ws_exec.go
@@ -21,7 +21,7 @@ import (
)
func init() {
- // 普通对话消息处理器（会话服务器 SessionWsService 见 ws_server.go）
+ // 普通对话消息处理器（会话服务器 SessionWsService 在 exec_ws.go 定义）
SessionWsService.OnMessage("agent", handleToolAgent)
SessionWsService.OnMessage("agent_cancel", handleToolAgentCancel)
}
diff --git a/workflow/service/flow/subtitle.go b/workflow/service/flow/subtitle.go
new file mode 100644
index 0000000..8f8b9f4
--- /dev/null
+++ b/workflow/service/flow/subtitle.go
@@ -0,0 +1,166 @@
+package flow
+
+import (
+ flowDto "ai-agent/workflow/model/dto/flow"
+ "regexp"
+ "strings"
+ "unicode/utf8"
+)
+
+// punctRe 切分/剥离用的中文标点（含顿号、）
+var punctRe = regexp.MustCompile(`[，。；！？、]`)
+
+// BuildSubtitles 核心工具：单个sentence生成多条subtitle
+func BuildSubtitles(sents *[]flowDto.Sentence) ([]flowDto.Subtitle, error) {
+ var subtitles []flowDto.Subtitle
+
+ for _, sent := range *sents {
+ // 1. 先按标点把文本拆成多个片段
+ segList := splitTextByPunct(sent.Text)
+ if len(segList) == 0 {
+ continue
+ }
+
+ // 去标点后得到纯净片段（纯空白/纯标点片段跳过）
+ var cleans []string
+ for _, seg := range segList {
+ c := strings.TrimSpace(cleanPunct(seg))
+ if c != "" {
+ cleans = append(cleans, c)
+ }
+ }
+ if len(cleans) == 0 || len(sent.Words) == 0 {
+ continue
+ }
+
+ // 2. 词级文本与句子文本一致时，按词精确对齐取首尾词时间（最准）
+ if spans, ok := alignAllSegments(sent.Words, cleans); ok {
+ for i, span := range spans {
+ subtitles = append(subtitles, flowDto.Subtitle{
+ Start: sent.Words[span[0]].StartTime,
+ End: sent.Words[span[1]].EndTime,
+ Text: cleans[i],
+ })
+ }
+ continue
+ }
+
+ // 3. ASR 词级转写与句子文本不一致时（如 血→谑、数字写法不一），
+ // 整句回退为按片段字符占比分配时间，避免整句被吞成一条字幕
+ segWords := allocWordsByProportion(sent.Words, cleans)
+ for i, ws := range segWords {
+ if len(ws) == 0 {
+ continue
+ }
+ subtitles = append(subtitles, flowDto.Subtitle{
+ Start: ws[0].StartTime,
+ End: ws[len(ws)-1].EndTime,
+ Text: cleans[i],
+ })
+ }
+ }
+
+ return subtitles, nil
+}
+
+// splitTextByPunct 按中文标点分割句子，同时保留标点在分段内
+// 例如："这个叫高血压调理方，注意是根源调理不是临时缓解，"
+// 会变成：["这个叫高血压调理方，", "注意是根源调理不是临时缓解，"]
+func splitTextByPunct(raw string) []string {
+ // 匹配中文标点并保留在文本中，按标点位置切分
+ indexes := punctRe.FindAllStringIndex(raw, -1)
+ if len(indexes) == 0 {
+ return []string{raw}
+ }
+
+ var res []string
+ prev := 0
+ for _, idx := range indexes {
+ end := idx[1] // 标点的结束位置
+ seg := raw[prev:end]
+ res = append(res, seg)
+ prev = end
+ }
+ // 处理最后一段没有标点的文本
+ if prev < len(raw) {
+ res = append(res, raw[prev:])
+ }
+ return res
+}
+
+// cleanPunct 去掉中文标点，得到纯净文本
+func cleanPunct(raw string) string {
+ return punctRe.ReplaceAllString(raw, "")
+}
+
+// alignAllSegments 按顺序把各纯净片段与词级文本逐字符对齐（允许个别字符不一致）。
+// 全部片段对齐成功且词被完整覆盖时返回各片段对应的词区间，否则 ok=false，
+// 由调用方回退到时间占比分配。
+func alignAllSegments(words []flowDto.Word, cleans []string) ([][2]int, bool) {
+ spans := make([][2]int, len(cleans))
+ wordIdx := 0
+ for i, seg := range cleans {
+ start := wordIdx
+ segRunes := []rune(seg)
+ s := 0
+ for wordIdx < len(words) && s < len(segRunes) {
+ for _, r := range []rune(words[wordIdx].Word) {
+ if s < len(segRunes) && r == segRunes[s] {
+ s++
+ }
+ }
+ wordIdx++
+ }
+ // 片段文本没被完整匹配，或该片段没吃到任何词 → 无法精确对齐
+ if s < len(segRunes) || start == wordIdx {
+ return nil, false
+ }
+ spans[i] = [2]int{start, wordIdx - 1}
+ }
+ // 有剩余词未被任何片段覆盖，说明对齐失败，避免吞掉剩余时间
+ if wordIdx < len(words) {
+ return nil, false
+ }
+ return spans, true
+}
+
+// allocWordsByProportion 按纯净片段字符占比把整句时间区间切成段，再按时间中点把
+// 每个 word 归属到所属片段（对词级转写与句子文本不一致的情况兜底）。
+func allocWordsByProportion(words []flowDto.Word, cleans []string) [][]flowDto.Word {
+ runes := make([]int, len(cleans))
+ totalChars := 0
+ for i, c := range cleans {
+ runes[i] = utf8.RuneCountInString(c)
+ totalChars += runes[i]
+ }
+
+ sentStart := words[0].StartTime
+ sentEnd := words[len(words)-1].EndTime
+ duration := sentEnd - sentStart
+ if duration < 0 {
+ duration = 0
+ }
+
+ bounds := make([]float64, len(cleans)+1)
+ bounds[0] = sentStart
+ accum := 0.0
+ for i := range cleans {
+ if totalChars > 0 {
+ accum += float64(runes[i]) / float64(totalChars)
+ }
+ bounds[i+1] = sentStart + accum*duration
+ }
+
+ segWords := make([][]flowDto.Word, len(cleans))
+ for _, w := range words {
+ mid := (w.StartTime + w.EndTime) / 2
+ idx := 0
+ for b := 0; b < len(bounds)-1; b++ {
+ if mid >= bounds[b+1] {
+ idx = b + 1
+ }
+ }
+ segWords[idx] = append(segWords[idx], w)
+ }
+ return segWords
+}
diff --git a/workflow/service/flow/values/value_request.go b/workflow/service/flow/values/value_request.go
new file mode 100644
index 0000000..4b5df2c
--- /dev/null
+++ b/workflow/service/flow/values/value_request.go
@@ -0,0 +1,140 @@
+package values
+
+import (
+ "ai-agent/workflow/consts/node"
+ flowDto "ai-agent/workflow/model/dto/flow"
+ "ai-agent/workflow/model/entity"
+ "context"
+ "strings"
+
+ "github.com/gogf/gf/v2/frame/g"
+ "github.com/gogf/gf/v2/os/glog"
+ "github.com/gogf/gf/v2/util/gconv"
+)
+
+// BuildModelRequestBody 从参数定义 + 全局执行上下文构建最终嵌套 JSON 请求体。
+func BuildModelRequestBody(params []entity.FlowModelParams, globalParams *flowDto.FlowExecutionInput) (map[string]interface{}, error) {
+ // 1. 解析引用、过滤空值
+ resolved := parseMap(params, globalParams)
+
+ // 2. 转扁平路径映射
+ flat := toFlatMap(resolved)
+
+ // 3. 引用了脚本转写节点的字段打内部标记 __segment_fields（逗号分隔的扁平路径），
+ // 供前置处理器 split_segment 按段拆批；__ 前缀内部键由 invokePreTool 统一剥离，不传给模型网关
+ if seg := segmentFields(resolved, globalParams); len(seg) > 0 {
+ flat["__segment_fields"] = strings.Join(seg, ",")
+ }
+
+ return flat, nil
+}
+
+// segmentFields 收集引用了脚本转写节点的字段扁平路径（分段字段）。
+// 脚本转写节点按段产出一份扁平参数列表，下游模型节点单源引用其字段时，
+// 值按段序聚合成数组（见 ResolveValueSource 的 scriptTranscribe 分支），需随批拆分。
+func segmentFields(resolved []entity.FlowModelParams, globalParams *flowDto.FlowExecutionInput) []string {
+ if globalParams == nil || globalParams.ConfigMap == nil {
+ return nil
+ }
+ var fields []string
+ for _, p := range resolved {
+ if g.IsEmpty(p.Path) || len(p.ValueSource) != 1 {
+ continue
+ }
+ src := p.ValueSource[0]
+ if nodeConfig := globalParams.ConfigMap[src.NodeId]; nodeConfig != nil &&
+ nodeConfig.NodeCode == node.NodeTypeScriptTranscribe {
+ fields = append(fields, flatPath(p.Path))
+ }
+ }
+ return fields
+}
+
+// parseMap 解析模型请求参数
+func parseMap(data []entity.FlowModelParams, globalParams *flowDto.FlowExecutionInput) []entity.FlowModelParams {
+ newData := make([]entity.FlowModelParams, 0, len(data))
+ for _, item := range data {
+ var d entity.FlowModelParams
+ d.Path = item.Path
+ d.Type = item.Type
+
+ // 无引用源：直接取静态值
+ if g.IsEmpty(item.ValueSource) {
+ if isParamEmpty(item.Value) {
+ continue
+ }
+ d = item
+ newData = append(newData, d)
+ continue
+ }
+
+ // 有引用源：单源解析取非空值（模型解析引用其他节点的数组值不做类型化转换，整体传给模型）；
+ // 多源把各源解析出的值拼成 "label: value"（无 label 只拼值），逗号分隔
+ var value, refsName any
+ if len(item.ValueSource) > 1 {
+ text, rn, ok := joinValueSources(globalParams, item.ValueSource, isParamEmpty, nil)
+ if !ok {
+ parseMapLogFail(item)
+ continue
+ }
+ value, refsName = text, rn
+ } else {
+ src := item.ValueSource[0]
+ var ok bool
+ value, refsName, ok = ResolveValueSource(globalParams, src.NodeId, src.Field)
+ if !ok || isParamEmpty(value) {
+ parseMapLogFail(item)
+ continue
+ }
+ }
+ d.Value = value
+ d.RefsName = gconv.String(refsName)
+ d.ValueSource = item.ValueSource
+ newData = append(newData, d)
+ }
+ return newData
+}
+
+// parseMapLogFail 引用解析失败留日志（单源/多源共用，不静默，便于排查引用丢失）
+func parseMapLogFail(item entity.FlowModelParams) {
+ glog.Debugf(context.Background(), "resolve value source failed, nodeId=%+v path=%s", item.ValueSource, item.Path)
+}
+
+// toFlatMap 将解析后的参数列表转为 sjson 可用的扁平路径映射。
+// key 为 Path，value 为参数值；保留 RefsName 供上层追踪引用来源。
+func toFlatMap(params []entity.FlowModelParams) map[string]interface{} {
+ m := make(map[string]interface{}, len(params))
+ for _, p := range params {
+ if g.IsEmpty(p.Path) {
+ continue
+ }
+ m[flatPath(p.Path)] = p.Value
+ }
+ return m
+}
+
+// flatPath 把数组下标路径转扁平点分路径：a[0].b → a.0.b。
+func flatPath(path string) string {
+ return arrayIndexPath.ReplaceAllString(path, `.$1`)
+}
+
+// isParamEmpty 判断参数值是否为"空"。
+// 仅 nil、空字符串、空切片/映射视为空；0、false 等零值是合法值，保留。
+func isParamEmpty(v interface{}) bool {
+ if v == nil {
+ return true
+ }
+ switch val := v.(type) {
+ case string:
+ return val == ""
+ case []byte:
+ return len(val) == 0
+ case []interface{}:
+ return len(val) == 0
+ case map[string]interface{}:
+ return len(val) == 0
+ default:
+ // 数字、布尔、结构体等一律视为非空
+ return false
+ }
+}
diff --git a/workflow/service/flow/values/value_resolve.go b/workflow/service/flow/values/value_resolve.go
new file mode 100644
index 0000000..a32a509
--- /dev/null
+++ b/workflow/service/flow/values/value_resolve.go
@@ -0,0 +1,254 @@
+package values
+
+import (
+ "ai-agent/workflow/consts/node"
+ flowDto "ai-agent/workflow/model/dto/flow"
+ "ai-agent/workflow/model/entity"
+ "encoding/json"
+ "regexp"
+ "strconv"
+ "strings"
+
+ "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`)
+ // 匹配带捕获组的数组下标，转扁平点分路径用
+ arrayIndexPath = regexp.MustCompile(`\[(\d+)\]`)
+)
+
+// CleanFieldPath 清理字段路径：移除 .attrs、数字下标转为 .#（gjson 数组通配符）
+// 示例：usage.attrs.total_tokens → usage.total_tokens
+// 示例：choices.attrs[0].attrs.message.attrs.content → choices.#.message.content
+func CleanFieldPath(path string) string {
+ index := CleanFieldPathReplaceNumIndex(path)
+ attrs := CleanFieldPathRemoveAttrs(index)
+ return attrs
+}
+
+func CleanFieldPathReplaceNumIndex(path string) string {
+ // 1. 替换 [数字] 为 [*]
+ s := regNumIndex.ReplaceAllString(path, `.#`)
+ return s
+}
+
+func CleanFieldPathRemoveAttrs(path string) string {
+ // 2. 移除所有 .attrs
+ s := regAttrs.ReplaceAllString(path, "")
+ return s
+}
+
+// ProcessValueSourceRecursive 递归遍历map，同级同时存在value和valueSource则把value设置为"AA"
+func ProcessValueSourceRecursive(rawParams map[string]interface{}, globalParams *flowDto.FlowExecutionInput) {
+ walkMap(rawParams, globalParams)
+}
+
+// ResolveValueSource 解析 valueSource {nodeId, field} 引用的实际值。
+// 返回 (value, refsName, ok)；ok=false 表示引用节点不存在或引用值仍为空。
+// - 开始/表单节点：OutputConfig 平铺条目按 field == 引用字段匹配（前端约定以 field 为主，
+// 不兼容 path），直接读 entry 的 value / refsName
+// - scriptTranscribe 节点：OutputResult 是各段扁平请求参数，按段序收集字段为数组（段位留 nil）
+// - 其他节点：读 OutputResult 中引用字段 field 路径对应的值
+func ResolveValueSource(global *flowDto.FlowExecutionInput, nodeId, field 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"]) != field {
+ continue
+ }
+ if !g.IsEmpty(output["value"]) {
+ return output["value"], output["refsName"], true
+ }
+ }
+ case node.NodeTypeScriptTranscribe:
+ // 脚本转写节点 OutputResult 是各段扁平请求参数（split_shots_pipeline 产出，key 为字面量
+ // prompt/duration/seed 等），按段序读取 output[field] 收集为数组，供分段模型节点整体引用。
+ // 每段都占一位（字段缺失/为空留 nil），保证数组与段序对齐，供 split_segment 按段取值。
+ var list []any
+ for _, output := range nodeConfig.OutputResult {
+ list = append(list, output[field])
+ }
+ for _, v := range list {
+ if !g.IsEmpty(v) {
+ return list, "", true
+ }
+ }
+ default:
+ // templates 是模型节点在前端配置的静态输出模板，不在 OutputResult 中，需单独取
+ if field == "templates" {
+ if !g.IsEmpty(nodeConfig.Templates) {
+ return nodeConfig.Templates, "", true
+ }
+ return nil, nil, false
+ }
+ for _, output := range nodeConfig.OutputResult {
+ // 模型节点输出记录是单 key 的字面量扁平 key（如 "choices.attrs[0].attrs.delta.attrs.content"），
+ // gjson 会把 . 和 [0] 当结构路径解析，无法命中字面量 key，故先按字面量 key 直接取值；
+ // 未命中再回退 gjson 路径查询（兼容真正嵌套的输出结构）。
+ if v, has := output[field]; has {
+ value = v
+ } else {
+ value = gjson.Get(gconv.String(output), field).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{}:
+ // 有 valueSource：解析引用节点值
+ if valueSource, hasSource := v["valueSource"]; hasSource {
+ sources := new([]entity.ValueSource)
+ gconv.Structs(valueSource, sources)
+
+ // 多个引用源：把各源解析出的值拼成 "label: value"（无 label 只拼值），逗号分隔
+ if len(*sources) > 1 {
+ text, refsName, ok := joinValueSources(globalParams, *sources, schemaValueEmpty,
+ func(src entity.ValueSource, value any) any {
+ // 引用非模型节点（开始/表单/HTTP/脚本转写等）时，值按当前字段声明的 type 做类型化转换；
+ // 模型节点值由模型网关处理，复制时不需要转换
+ if !isModelSourceNode(globalParams, src.NodeId) {
+ return assignBySchemaType(v, value)
+ }
+ return value
+ })
+ if ok {
+ v["value"] = text
+ if !g.IsEmpty(refsName) {
+ v["refsName"] = refsName
+ }
+ return
+ }
+ } else if len(*sources) == 1 {
+ // 单个引用源：保持旧行为，值按原样赋值（非模型节点按声明 type 转换）
+ src := (*sources)[0]
+ value, refsName, ok := ResolveValueSource(globalParams, src.NodeId, src.Field)
+ if ok && !isModelSourceNode(globalParams, src.NodeId) {
+ value = assignBySchemaType(v, value)
+ }
+ if ok && !schemaValueEmpty(value) {
+ v["value"] = value
+ if !g.IsEmpty(refsName) {
+ v["refsName"] = refsName
+ }
+ return
+ }
+ }
+ }
+ // 统一兜底：无 valueSource（或解析失败/值为空）时，value 为空或 0 则取 defaultValue
+ if defaultValue, hasDefault := v["defaultValue"]; hasDefault && isEmptyForFallback(v["value"]) && !schemaValueEmpty(defaultValue) {
+ v["value"] = defaultValue
+ }
+ // 递归遍历所有子元素
+ for _, child := range v {
+ walkMap(child, globalParams)
+ }
+ case []interface{}:
+ // 数组遍历
+ for _, item := range v {
+ walkMap(item, globalParams)
+ }
+ }
+}
+
+// isEmptyForFallback 兜底场景判空：除 schemaValueEmpty 规则外，数字 0 也视为未填写，
+// 便于配置了 defaultValue 的字段在值为 0 时用默认值兜底。
+// 覆盖 json.Number（gconv 反序列化数字的运行时类型）与字符串 "0"/"0.0"。
+func isEmptyForFallback(v interface{}) bool {
+ if schemaValueEmpty(v) {
+ return true
+ }
+ switch val := v.(type) {
+ case float32:
+ return val == 0
+ case float64:
+ return val == 0
+ case int:
+ return val == 0
+ case int8:
+ return val == 0
+ case int16:
+ return val == 0
+ case int32:
+ return val == 0
+ case int64:
+ return val == 0
+ case uint:
+ return val == 0
+ case uint8:
+ return val == 0
+ case uint16:
+ return val == 0
+ case uint32:
+ return val == 0
+ case uint64:
+ return val == 0
+ case json.Number:
+ if f, err := val.Float64(); err == nil {
+ return f == 0
+ }
+ case string:
+ if f, err := strconv.ParseFloat(val, 64); err == nil {
+ return f == 0
+ }
+ }
+ return false
+}
+
+// isModelSourceNode 判断引用源节点是否为模型节点（值由模型网关处理，复制时不转换）
+func isModelSourceNode(global *flowDto.FlowExecutionInput, nodeId string) bool {
+ if global == nil || global.ConfigMap == nil {
+ return false
+ }
+ nodeConfig := global.ConfigMap[nodeId]
+ return nodeConfig != nil && nodeConfig.NodeCode == node.NodeTypeModel
+}
+
+// joinValueSources 拼接多个 valueSource 的解析值为 "label: value"（无 label 只拼值），逗号分隔。
+// 返回拼接文本与第一个非空 refsName；所有源都为空/解析失败时 ok=false。
+// isEmpty 为各场景的空值判断（walkMap 用 schemaValueEmpty，模型请求解析用 isParamEmpty）；
+// transform 对每个非空解析值做转换（walkMap 按声明 type 类型化、模型源不转换；模型请求场景传 nil）。
+func joinValueSources(global *flowDto.FlowExecutionInput, sources []entity.ValueSource,
+ isEmpty func(any) bool, transform func(src entity.ValueSource, value any) any) (text string, refsName any, ok bool) {
+ var parts []string
+ for _, src := range sources {
+ value, rn, ok := ResolveValueSource(global, src.NodeId, src.Field)
+ if !ok || isEmpty(value) {
+ continue
+ }
+ if transform != nil {
+ value = transform(src, value)
+ }
+ s := toPlainString(value)
+ if src.Label != "" {
+ s = src.Label + ": " + s
+ }
+ parts = append(parts, s)
+ if !g.IsEmpty(rn) && g.IsEmpty(refsName) {
+ refsName = rn
+ }
+ }
+ if len(parts) == 0 {
+ return "", nil, false
+ }
+ return strings.Join(parts, ", "), refsName, true
+}
diff --git a/workflow/service/flow/values/value_schema.go b/workflow/service/flow/values/value_schema.go
new file mode 100644
index 0000000..3c21bfd
--- /dev/null
+++ b/workflow/service/flow/values/value_schema.go
@@ -0,0 +1,227 @@
+package values
+
+import (
+ "encoding/json"
+ "reflect"
+ "strconv"
+ "strings"
+
+ "github.com/gogf/gf/v2/util/gconv"
+)
+
+// 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
+ }
+ if tmplArr, isArr := tmplVal.([]any); isArr {
+ result[key] = mapTemplateArray(tmplArr, srcVal)
+ continue
+ }
+ result[key] = srcVal
+ }
+ return result
+}
+
+// mapTemplateArray 按模板数组的元素结构映射 source 数组：
+// 模板首元素为对象时，逐元素按 MapResultByTemplate 过滤只保留模板字段；
+// 模板数组为空或首元素非对象（无法确定元素结构）时，原样拷贝 source 数组。
+func mapTemplateArray(tmplArr []any, srcVal any) any {
+ srcList, ok := srcVal.([]any)
+ if !ok || len(tmplArr) == 0 {
+ return srcVal
+ }
+ elemTmpl, ok := tmplArr[0].(map[string]any)
+ if !ok {
+ return srcVal
+ }
+ result := make([]any, 0, len(srcList))
+ for _, srcElem := range srcList {
+ if srcMap, isMap := srcElem.(map[string]any); isMap {
+ result = append(result, MapResultByTemplate(elemTmpl, srcMap))
+ } else {
+ result = append(result, srcElem)
+ }
+ }
+ return result
+}
+
+// assignBySchemaType 按当前字段声明的 schema 类型把值类型化：
+// string 遇数组/对象转 JSON 字符串；number/boolean 解析字符串；object/array 解析 JSON 字符串；其余原样返回
+func assignBySchemaType(node map[string]interface{}, value any) any {
+ t, _ := node["type"].(string)
+ return assignByType(t, value)
+}
+
+// assignByType 按字段声明的 type 把值类型化；walkMap 的 schema 节点与 parseMap 的模型参数共用
+func assignByType(t string, value any) any {
+ switch t {
+ case "string":
+ return toSchemaString(value)
+ case "number":
+ return toSchemaNumber(value)
+ case "boolean":
+ return toSchemaBool(value)
+ case "object", "array":
+ return toSchemaStruct(value)
+ default:
+ return value
+ }
+}
+
+// toSchemaString 转 string：字符串原样，数组元素拼成字符串（单元素取元素本身，多元素逗号连接），对象序列化为 JSON 字符串
+func toSchemaString(v any) any {
+ switch val := v.(type) {
+ case []interface{}:
+ parts := make([]string, 0, len(val))
+ for _, item := range val {
+ parts = append(parts, toPlainString(item))
+ }
+ return strings.Join(parts, ",")
+ case map[string]interface{}:
+ if b, err := json.Marshal(val); err == nil {
+ return string(b)
+ }
+ }
+ return v
+}
+
+// toPlainString 把数组元素转成不带括号的纯字符串：
+// 数组（[]any / 类型化切片）逐元素取纯字符串，单元素取元素本身，多元素逗号连接；
+// 对象序列化为 JSON 字符串；其余原样字符串化。
+func toPlainString(v any) string {
+ if s, ok := v.(string); ok {
+ return s
+ }
+ switch val := v.(type) {
+ case []interface{}:
+ parts := make([]string, 0, len(val))
+ for _, item := range val {
+ parts = append(parts, toPlainString(item))
+ }
+ return strings.Join(parts, ",")
+ case map[string]interface{}:
+ if b, err := json.Marshal(val); err == nil {
+ return string(b)
+ }
+ }
+ rv := reflect.ValueOf(v)
+ if rv.IsValid() && (rv.Kind() == reflect.Slice || rv.Kind() == reflect.Array) {
+ parts := make([]string, 0, rv.Len())
+ for i := 0; i < rv.Len(); i++ {
+ parts = append(parts, toPlainString(rv.Index(i).Interface()))
+ }
+ return strings.Join(parts, ",")
+ }
+ if b, err := json.Marshal(v); err == nil {
+ return string(b)
+ }
+ return gconv.String(v)
+}
+
+// toSchemaNumber 转 number：数字原样，字符串尝试解析为 float64，失败原样返回
+func toSchemaNumber(v any) any {
+ if s, ok := v.(string); ok {
+ if f, err := strconv.ParseFloat(s, 64); err == nil {
+ return f
+ }
+ }
+ return v
+}
+
+// toSchemaBool 转 boolean：布尔原样，字符串尝试解析为 bool，失败原样返回
+func toSchemaBool(v any) any {
+ if s, ok := v.(string); ok {
+ if b, err := strconv.ParseBool(s); err == nil {
+ return b
+ }
+ }
+ return v
+}
+
+// toSchemaStruct 转 object/array：合法 JSON 字符串解析为结构化数据，否则原样返回
+func toSchemaStruct(v any) any {
+ s, ok := v.(string)
+ if !ok {
+ return v
+ }
+ if !json.Valid([]byte(s)) {
+ return v
+ }
+ var out any
+ if err := json.Unmarshal([]byte(s), &out); err != nil {
+ return v
+ }
+ return out
+}
+
+// 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/ws_server.go b/workflow/service/flow/ws_server.go
deleted file mode 100644
index 0c22140..0000000
--- a/workflow/service/flow/ws_server.go
+++ /dev/null
@@ -1,41 +0,0 @@
-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/session/session_service.go b/workflow/service/session/session_service.go
index 8df79ca..9b83079 100644
--- a/workflow/service/session/session_service.go
+++ b/workflow/service/session/session_service.go
@@ -211,6 +211,7 @@ func workflowExecVO(w *entity.ExecWorkflow, resultFileUrl string) *sessionDto.VO
ResultFileUrl: resultFileUrl,
TotalTokens: w.TotalTokens,
TotalFee: w.TotalFee,
+ ActualAmount: w.ActualAmount,
ErrorMsg: w.ErrorMessage,
Error: w.Error,
CreatedAt: w.CreatedAt,
diff --git a/workflow/service/util_service.go b/workflow/service/util_service.go
index 531b514..8824817 100644
--- a/workflow/service/util_service.go
+++ b/workflow/service/util_service.go
@@ -4,7 +4,7 @@ import (
"context"
commonHttp "gitea.redpowerfuture.com/red-future/common/http"
- "github.com/gogf/gf/v2/frame/g"
+ "gitea.redpowerfuture.com/red-future/common/utils"
)
var UtilService = &utilService{}
@@ -13,16 +13,8 @@ type utilService struct{}
// IsAdmin 调用admin-go服务检查是否是管理员
func (s *utilService) IsAdmin(ctx context.Context) (res bool, 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]
- }
- }
- }
var r = make(map[string]bool)
- if err = commonHttp.Get(ctx, "admin-go/api/v1/system/user/checkIsSuperAdmin", headers, &r); err != nil {
+ if err = commonHttp.Get(ctx, "admin-go/api/v1/system/user/checkIsSuperAdmin", utils.HeadersFromCtx(ctx), &r); err != nil {
return false, err
}
return r["isSuperAdmin"], err