feat: 新增执行记录实体与文件上传能力

2026-08-18 09:47:51 +08:00
parent 155a5cad0c
commit a939c45508
67 changed files with 7341 additions and 4001 deletions
@@ -0,0 +1,287 @@
+package flow
+
+import (
+	"ai-agent/workflow/consts/node"
+	flowDto "ai-agent/workflow/model/dto/flow"
+	"regexp"
+
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/util/gconv"
+	"github.com/tidwall/gjson"
+)
+
+var (
+	// 匹配 [数字]
+	regNumIndex = regexp.MustCompile(`\[\d+\]`)
+	// 匹配 .attrs
+	regAttrs = regexp.MustCompile(`\.attrs`)
+)
+
+// CleanFieldPath 清理字段路径：移除 .attrs、数字下标转为 [*]
+// 示例：usage.attrs.total_tokens → usage.total_tokens
+// 示例：choices.attrs[0].attrs.message.attrs.content → choices[*].message.content
+func CleanFieldPath(path string) string {
+	// 1. 替换 [数字] 为 [*]
+	s := regNumIndex.ReplaceAllString(path, `.#`)
+	// 2. 移除所有 .attrs
+	s = regAttrs.ReplaceAllString(s, "")
+	return s
+}
+
+// UnwrapSchemaWrapper 递归剥掉 json-schema-editor 输出的 {type, value/attrs} 包裹层，
+// 只保留干净的 key/value 嵌套结构。
+// 示例：
+//
+//	{"a": {"type":"string","value":"hi"}}                    → {"a": "hi"}
+//	{"b": {"type":"object","attrs":{"c":1}}}                 → {"b": {"c": 1}}
+//	{"arr": {"type":"array","attrs":[{"type":"number","value":1}]}} → {"arr": [1]}
+func UnwrapSchemaWrapper(v any) any {
+	switch val := v.(type) {
+	case map[string]any:
+		// 识别包裹节点：{type: "<jsonType>", value/attrs: <实际值>, ...}
+		if t, ok := val["type"].(string); ok && isSchemaEditorType(t) {
+			dataKey := "value"
+			if t == "object" || t == "array" {
+				dataKey = "attrs"
+			}
+			if raw, has := val[dataKey]; has {
+				return UnwrapSchemaWrapper(raw)
+			}
+		}
+		res := make(map[string]any, len(val))
+		for k, child := range val {
+			res[k] = UnwrapSchemaWrapper(child)
+		}
+		return res
+	case []any:
+		res := make([]any, len(val))
+		for i, item := range val {
+			res[i] = UnwrapSchemaWrapper(item)
+		}
+		return res
+	default:
+		return val
+	}
+}
+
+// isSchemaEditorType 是否为 json-schema-editor 的 6 种类型标识
+func isSchemaEditorType(t string) bool {
+	switch t {
+	case "string", "number", "boolean", "null", "object", "array":
+		return true
+	}
+	return false
+}
+
+// MapResultByTemplate 按 template 定义的结构，从 source 中拷贝对应字段的值。
+// 只保留 template 里出现的字段：对象字段按同名字段递归拷贝，标量/数组字段直接拷贝 source 的值。
+func MapResultByTemplate(template map[string]any, source map[string]any) map[string]any {
+	result := make(map[string]any, len(template))
+	for key, tmplVal := range template {
+		srcVal, ok := source[key]
+		if !ok {
+			continue
+		}
+		if tmplMap, isMap := tmplVal.(map[string]any); isMap {
+			if srcMap, isMap := srcVal.(map[string]any); isMap {
+				result[key] = MapResultByTemplate(tmplMap, srcMap)
+			}
+			continue
+		}
+		result[key] = srcVal
+	}
+	return result
+}
+
+// ProcessValueSourceRecursive 递归遍历map，同级同时存在value和valueSource则把value设置为"AA"
+func ProcessValueSourceRecursive(rawParams map[string]interface{}, globalParams *flowDto.FlowExecutionInput) {
+	walkMap(rawParams, globalParams)
+}
+
+// resolveValueSource 解析 valueSource {nodeId, fieldName} 引用的实际值。
+// 返回 (value, refsName, ok)；ok=false 表示引用节点不存在或引用值仍为空。
+//   - 开始/表单节点：OutputConfig 平铺条目按 field == fieldName 匹配（前端约定以 field 为主，
+//     不兼容 path），直接读 entry 的 value / refsName
+//   - scriptTranscribe 节点：读 OutputResult 的 shots
+//   - 其他节点：读 OutputResult 中 fieldName 路径对应的值
+func resolveValueSource(global *flowDto.FlowExecutionInput, nodeId, fieldName string) (value any, refsName any, ok bool) {
+	if global == nil || global.ConfigMap == nil {
+		return nil, nil, false
+	}
+	nodeConfig := global.ConfigMap[nodeId]
+	if nodeConfig == nil {
+		return nil, nil, false
+	}
+	switch nodeConfig.NodeCode {
+	case node.NodeTypeStart, node.NodeTypeForm:
+		for _, output := range nodeConfig.OutputConfig {
+			if gconv.String(output["field"]) != fieldName {
+				continue
+			}
+			if !g.IsEmpty(output["value"]) {
+				return output["value"], output["refsName"], true
+			}
+		}
+	case node.NodeTypeScriptTranscribe:
+		for _, output := range nodeConfig.OutputResult {
+			value := gjson.Get(gconv.String(output), CleanFieldPath("shots")).Value()
+			if !g.IsEmpty(value) {
+				return value, gjson.Get(gconv.String(output), CleanFieldPath("refsName")).Value(), true
+			}
+		}
+	default:
+		for _, output := range nodeConfig.OutputResult {
+			value := gjson.Get(gconv.String(output), CleanFieldPath(fieldName)).Value()
+			if !g.IsEmpty(value) {
+				return value, gjson.Get(gconv.String(output), CleanFieldPath("refsName")).Value(), true
+			}
+		}
+	}
+	return nil, nil, false
+}
+
+// walkMap 递归处理map/数组
+func walkMap(data interface{}, globalParams *flowDto.FlowExecutionInput) {
+	switch v := data.(type) {
+	case map[string]interface{}:
+		// 当前对象同时存在 value 和 valueSource
+		if valueSource, hasSource := v["valueSource"]; hasSource {
+			mapValueSource := gconv.Map(valueSource)
+			nodeId := gconv.String(mapValueSource["nodeId"])
+			fieldName := gconv.String(mapValueSource["fieldName"])
+			if fieldName == "" {
+				fieldName = gconv.String(mapValueSource["field"])
+			}
+			if nodeId != "" && fieldName != "" {
+				if value, refsName, ok := resolveValueSource(globalParams, nodeId, fieldName); ok {
+					v["value"] = value
+					if !g.IsEmpty(refsName) {
+						v["refsName"] = refsName
+					}
+					return
+				}
+			}
+		}
+		// 递归遍历所有子元素
+		for _, child := range v {
+			walkMap(child, globalParams)
+		}
+	case []interface{}:
+		// 数组遍历
+		for _, item := range v {
+			walkMap(item, globalParams)
+		}
+	}
+}
+
+// CleanEmptyModelParams 剔除模型请求参数中 value 为空的字段；
+// 数组/枚举（attrs / enumValues）元素整体为空时移除整个元素。0/false 视为有效值。
+func CleanEmptyModelParams(params map[string]interface{}) {
+	cleanSchemaMap(params)
+}
+
+// cleanSchemaMap 递归清理普通 map：包装节点按 schema 语义清理，空字段删除
+func cleanSchemaMap(m map[string]interface{}) {
+	for key, val := range m {
+		switch v := val.(type) {
+		case map[string]interface{}:
+			if isSchemaWrapperNode(v) {
+				cleanSchemaWrapper(v)
+				if isSchemaNodeEmpty(v) {
+					delete(m, key)
+				}
+			} else {
+				cleanSchemaMap(v)
+			}
+		case []interface{}:
+			m[key] = cleanSchemaSlice(v)
+		}
+	}
+}
+
+// cleanSchemaWrapper 清理单个 {type,...} 包装节点：递归 value / attrs / enumValues 容器
+func cleanSchemaWrapper(node map[string]interface{}) {
+	if mv, ok := node["value"].(map[string]interface{}); ok {
+		cleanSchemaMap(mv)
+	}
+	if lv, ok := node["value"].([]interface{}); ok {
+		node["value"] = cleanSchemaSlice(lv)
+	}
+	if attrs, ok := node["attrs"].(map[string]interface{}); ok {
+		cleanSchemaMap(attrs)
+	}
+	if attrs, ok := node["attrs"].([]interface{}); ok {
+		node["attrs"] = cleanSchemaSlice(attrs)
+	}
+	if evs, ok := node["enumValues"].([]interface{}); ok {
+		node["enumValues"] = cleanSchemaSlice(evs)
+	}
+}
+
+// cleanSchemaSlice 清理数组/枚举元素，元素为包装节点且整体为空时移除
+func cleanSchemaSlice(list []interface{}) []interface{} {
+	i := 0
+	for i < len(list) {
+		if item, ok := list[i].(map[string]interface{}); ok {
+			if isSchemaWrapperNode(item) {
+				cleanSchemaWrapper(item)
+				if isSchemaNodeEmpty(item) {
+					list = append(list[:i], list[i+1:]...)
+					continue
+				}
+			} else {
+				cleanSchemaMap(item)
+			}
+		}
+		i++
+	}
+	return list
+}
+
+// isSchemaWrapperNode 是否为 {type: <schemaEditorType>} 包装节点
+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
+	}
+}