feat: 新增主动拉取与多类型回调功能

- 新增 ActivePull 实体、DAO、DTO 及 Service，支持主动拉取任务管理
- 新增 ComposeCallback、VideoCallback、HttpNodeCallback 多类型回调接口
- FlowExecution 增加 NodeGroupId 和 TotalTokens 字段，支持节点组追踪与 Token 统计
- ExecutedNodes 结构由字符串列表改为包含执行状态的节点对象列表
- 重构回调通知机制，统一 Notify 函数调用
- 优化输出项类型判断逻辑，新增文件类型标识

workflow/service/flow/lambda_node_util.go

@@ -1,24 +1,74 @@
 package flow
 
 import (
+	"ai-agent/workflow/consts/node"
+	nodeDao "ai-agent/workflow/dao/node"
 	"ai-agent/workflow/model/dto"
 	flowDto "ai-agent/workflow/model/dto/flow"
+	nodeDto "ai-agent/workflow/model/dto/node"
+	"ai-agent/workflow/model/entity"
 	"bytes"
 	"context"
 	"fmt"
 	"io"
 	"mime/multipart"
 	"net/http"
+	"net/url"
+	"path/filepath"
 	"regexp"
 	"strconv"
 	"strings"
+	"sync"
 
 	commonHttp "gitea.com/red-future/common/http"
 	"gitea.com/red-future/common/utils"
+	"github.com/gogf/gf/v2/errors/gerror"
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/util/gconv"
+	"github.com/tidwall/sjson"
 )
 
+// 全局等待任务回调的工具
+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)
+}
+
 func GetIsChatModel(ctx context.Context) (res *flowDto.GetIsChatModelRes, err error) {
 	headers := make(map[string]string)
 	if r := g.RequestFromCtx(ctx); r != nil {
@@ -33,7 +83,7 @@ func GetIsChatModel(ctx context.Context) (res *flowDto.GetIsChatModelRes, err er
 	return
 }
 
-func ComposeMessages(ctx context.Context, req *flowDto.ComposeMessagesReq) (res *flowDto.ComposeMessagesRes, err error) {
+func GetModelInfo(ctx context.Context, req *flowDto.GetModelInfoReq) (res *flowDto.GetModelInfoRes, err error) {
 	headers := make(map[string]string)
 	if r := g.RequestFromCtx(ctx); r != nil {
 		for k, v := range r.Request.Header {
@@ -42,58 +92,71 @@ func ComposeMessages(ctx context.Context, req *flowDto.ComposeMessagesReq) (res
 			}
 		}
 	}
-	res = new(flowDto.ComposeMessagesRes)
-	err = commonHttp.Post(ctx, "prompts-core/prompt/composeMessages", headers, res, &req)
+	res = new(flowDto.GetModelInfoRes)
+	err = commonHttp.Get(ctx, "model-gateway/model/getModel", headers, res, req)
 	return
 }
 
-func GetModelResult(ctx context.Context, modelName, skillName string, form, userFrom map[string]any, fileUrl []string, sessionId string, cause string) (mapTaskResult map[string]any, err error) {
+func GetComposeResult(ctx context.Context, buildType int, modelName, promptContent, skillName string, form []map[string]any, userForm []map[string]any, fileUrl []string, sessionId, nodeId string, cause string) (res *flowDto.ComposeCallbackReq, err error) {
+	if !g.IsEmpty(promptContent) {
+		userForm = append(userForm, map[string]any{
+			"prompt": promptContent,
+		})
+	}
+	var callbackUrl = utils.GetCallbackURL(ctx, "/flow/execution/composeCallBack")
+	var consult = make([]flowDto.Consult, 0)
+	var collectFileUrls func(val any)
+	collectFileUrls = func(val any) {
+		switch {
+		case g.NewVar(val).IsSlice():
+			slice := gconv.SliceAny(val)
+			for _, item := range slice {
+				collectFileUrls(item)
+			}
+		case g.NewVar(val).IsMap():
+			m := gconv.Map(val)
+			for _, item := range m {
+				collectFileUrls(item)
+			}
+		default:
+			s := gconv.String(val)
+			if s != "" {
+				getFileTypeByPath := GetFileTypeByPath(s)
+				if getFileTypeByPath != "" {
+					consult = append(consult, flowDto.Consult{
+						Type: getFileTypeByPath,
+						Url:  s,
+					})
+				}
+			}
+		}
+	}
+	for _, m := range userForm {
+		for _, v := range gconv.Map(m) {
+			collectFileUrls(v)
+		}
+	}
+	for _, v := range fileUrl {
+		getFileTypeByPath := GetFileTypeByPath(gconv.String(v))
+		if getFileTypeByPath != "" {
+			consult = append(consult, flowDto.Consult{
+				Type: getFileTypeByPath,
+				Url:  gconv.String(v),
+			})
+		}
+	}
 	msgReq := flowDto.ComposeMessagesReq{
-		BuildType: 1,
-		ModelName: modelName,
-		SkillName: skillName,
-		Cause:     cause,
-		Form:      form,
-		UserForm:  userFrom,
-		UserFiles: fileUrl,
-		SessionId: sessionId,
+		BuildType:   buildType,
+		ModelName:   modelName,
+		SkillName:   skillName,
+		CallbackUrl: callbackUrl,
+		Cause:       cause,
+		Form:        form,
+		UserForm:    userForm,
+		Consult:     consult,
+		SessionId:   sessionId,
+		NodeId:      nodeId,
 	}
-	msg, err := ComposeMessages(ctx, &msgReq)
-	if err != nil {
-		return
-	}
-	if g.IsEmpty(msg.Messages) {
-		return nil, fmt.Errorf("msg is empty")
-	}
-	var taskResult any
-	taskResult, err = GatewayTask(ctx, msg.EpicycleId, modelName, msg.Messages)
-	if err != nil {
-		return
-	}
-	var getTaskResult *flowDto.TaskCallback
-	getTaskResult, err = GetTaskResult(ctx, taskResult)
-	if err != nil {
-		return
-	}
-	mapTaskResult = gconv.Map(getTaskResult.Text)
-	return mapTaskResult, nil
-}
-
-func GatewayTask(ctx context.Context, epicycleId int64, model string, content map[string]any) (any, error) {
-	modelTaskId, err := CreateGatewayTask(ctx, &flowDto.CreateTaskReq{
-		ModelName:      model,
-		BizName:        g.Cfg().MustGet(ctx, "server.name").String(),
-		CallbackUrl:    "/flow/execution/modelCallback",
-		RequestPayload: content,
-		EpicycleId:     epicycleId,
-	})
-	if err != nil {
-		return nil, err
-	}
-	return Wait(ctx, modelTaskId)
-}
-
-func CreateGatewayTask(ctx context.Context, req *flowDto.CreateTaskReq) (string, error) {
 	headers := make(map[string]string)
 	if r := g.RequestFromCtx(ctx); r != nil {
 		for k, v := range r.Request.Header {
@@ -102,69 +165,330 @@ func CreateGatewayTask(ctx context.Context, req *flowDto.CreateTaskReq) (string,
 			}
 		}
 	}
-	res := new(flowDto.CreateTaskRes)
+	msgRes := new(flowDto.ComposeMessagesRes)
+	err = commonHttp.Post(ctx, "prompts-core/prompt/composeMessages", headers, msgRes, &msgReq)
+	if err != nil {
+		return
+	}
+	if g.IsEmpty(msgRes.TaskId) {
+		return nil, fmt.Errorf("msg is empty")
+	}
+	waitRes, err := Wait(ctx, msgRes.TaskId)
+	if err != nil {
+		return nil, err
+	}
+	msg := new(flowDto.ComposeCallbackReq)
+	if err = gconv.Struct(waitRes, msg); err != nil {
+		return nil, err
+	}
+	if !g.IsEmpty(msg.ErrorMsg) {
+		return nil, fmt.Errorf(msg.ErrorMsg)
+	}
+	return msg, nil
+}
+
+func CreateGatewayTask(ctx context.Context, epicycleId int64, model string, content map[string]any) (map[string]any, error) {
+	taskId, err := createGatewayTaskOnly(ctx, epicycleId, model, content)
+	if err != nil {
+		return nil, err
+	}
+	return waitGatewayResult(ctx, taskId)
+}
+
+// createGatewayTaskOnly creates a gateway task and returns the taskId only
+// doesn't wait for completion
+func createGatewayTaskOnly(ctx context.Context, epicycleId int64, model string, content map[string]any) (string, error) {
+	callbackUrl := utils.GetCallbackURL(ctx, "/flow/execution/modelCallback")
+	req := flowDto.ModelGatewayReq{
+		ModelName:      model,
+		BizName:        g.Cfg().MustGet(ctx, "server.name").String(),
+		CallbackUrl:    callbackUrl,
+		RequestPayload: content,
+		EpicycleId:     epicycleId,
+	}
+
+	headers := make(map[string]string)
+	if r := g.RequestFromCtx(ctx); r != nil {
+		for k, v := range r.Request.Header {
+			if len(v) > 0 {
+				headers[k] = v[0]
+			}
+		}
+	}
+
+	res := new(flowDto.ModelGatewayRes)
 	err := commonHttp.Post(ctx, "model-gateway/task/createTask", headers, res, &req)
 	if err != nil {
 		return "", err
 	}
+	if g.IsEmpty(res.TaskId) {
+		return "", fmt.Errorf("创建模型任务失败，taskId为空")
+	}
 
 	return res.TaskId, nil
 }
 
-func GetTaskResult(ctx context.Context, result any) (*flowDto.TaskCallback, error) {
-	task := new(flowDto.TaskCallback)
-	if err := gconv.Struct(result, task); err != nil {
-		return nil, err
-	}
-
-	url, err := utils.GetFileAddressPrefix(ctx)
+// waitGatewayResult waits for a created gateway task to complete and returns the result
+func waitGatewayResult(ctx context.Context, taskId string) (map[string]any, error) {
+	waitRes, err := Wait(ctx, taskId)
 	if err != nil {
 		return nil, err
 	}
 
-	// 获取远程文件内容
-	file, err := FetchRemoteJsonFile(ctx, url+task.OssFile)
-	if err != nil {
+	task := new(flowDto.ModelCallbackReq)
+	if err := gconv.Struct(waitRes, task); err != nil {
 		return nil, err
 	}
 
-	task.Text = gconv.String(file)
+	if task.State == 3 || !g.IsEmpty(task.ErrorMsg) {
+		return nil, fmt.Errorf("模型执行失败：%s", task.ErrorMsg)
+	}
+	if g.IsEmpty(task.Messages) {
+		return nil, fmt.Errorf("模型返回结果为空")
+	}
 
-	return task, nil
+	return task.Messages, nil
 }
 
-func FetchRemoteJsonFile(ctx context.Context, fileUrl string) ([]byte, error) {
-	// 1. 下载文件
+// updateTokenCount updates the token count in node execution
+func updateTokenCount(ctx context.Context, nodeExecutionId int64, responseField string, result map[string]any) {
+	if responseField == "" {
+		return
+	}
+	_, _ = nodeDao.NodeExecutionDao.Update(ctx, &nodeDto.UpdateNodeExecutionReq{
+		Id:               nodeExecutionId,
+		CompletionTokens: gconv.Int(result[responseField]),
+		TotalTokens:      gconv.Int(result[responseField]),
+	})
+}
+
+func GetModelResult(ctx context.Context, sessionId string, nodeInput *flowDto.NodeExecutionInput, skillName string, form []map[string]any, userForm []map[string]any) (mapTaskResult []map[string]any, err error) {
+	buildType := 1
+	if nodeInput.Config.NodeCode == node.NodeTypeDataConversionModel {
+		buildType = 3
+	}
+
+	composeResult, err := GetComposeResult(ctx, buildType, nodeInput.Config.ModelConfig.ModelName, nodeInput.Config.PromptContent, skillName, form, userForm, nodeInput.Global.FileUrl, sessionId, nodeInput.Config.Id, nodeInput.Config.Name)
+	if err != nil {
+		return nil, err
+	}
+
+	modelInfo, err := GetModelInfo(ctx, &flowDto.GetModelInfoReq{ModelName: nodeInput.Config.ModelConfig.ModelName})
+	if err != nil {
+		return nil, err
+	}
+
+	mapTaskResult = make([]map[string]any, len(composeResult.Messages.Rounds))
+	var taskResultMap map[string]any
+
+	needSequential := false
+	if buildType == 1 {
+		if needSequential {
+			for idx, item := range composeResult.Messages.Rounds {
+				if !g.IsEmpty(taskResultMap) {
+					var set string
+					set, err = sjson.Set(gconv.String(item), modelInfo.Model.LastFrame, gconv.String(taskResultMap[modelInfo.Model.ResponseBody]))
+					if err != nil {
+						return nil, err
+					}
+					item = gconv.Map(set)
+				}
+
+				var taskResult map[string]any
+				taskResult, err = CreateGatewayTask(ctx, composeResult.EpicycleId, nodeInput.Config.ModelConfig.ModelName, item)
+				if err != nil {
+					return nil, err
+				}
+				if g.IsEmpty(taskResult) {
+					return nil, fmt.Errorf("模型返回结果为空")
+				}
+
+				// Update taskResultMap for next round (used by VideoModel)
+				if nodeInput.Config.NodeCode == node.NodeTypeVideoModel {
+					ext := GetFileTypeByPath(gconv.String(taskResult[modelInfo.Model.ResponseBody]))
+					if ext == "image" {
+						taskResultMap = taskResult
+					} else {
+						taskResultMap = make(map[string]any)
+					}
+				} else {
+					taskResultMap = make(map[string]any)
+				}
+
+				mapTaskResult[idx] = taskResult
+				updateTokenCount(ctx, nodeInput.NodeExecutionId, modelInfo.Model.ResponseTokenField, taskResult)
+			}
+		} else {
+			taskIdList := make([]string, len(composeResult.Messages.Rounds))
+
+			for idx, item := range composeResult.Messages.Rounds {
+				var taskId string
+				taskId, err = createGatewayTaskOnly(ctx, composeResult.EpicycleId, nodeInput.Config.ModelConfig.ModelName, item)
+				if err != nil {
+					return nil, err
+				}
+				taskIdList[idx] = taskId
+			}
+
+			// Step 2: Wait for all tasks in parallel
+			var wg sync.WaitGroup
+			errChan := make(chan error, len(taskIdList))
+
+			for idx, taskId := range taskIdList {
+				wg.Add(1)
+
+				// Pass idx and taskId as parameters to avoid loop variable capture bug
+				// This guarantees results are stored in the correct order matching original requests
+				go func(idx int, taskId string) {
+					defer wg.Done()
+
+					var taskResult map[string]any
+					taskResult, err = waitGatewayResult(ctx, taskId)
+					if err != nil {
+						errChan <- err
+						return
+					}
+
+					mapTaskResult[idx] = taskResult
+					updateTokenCount(ctx, nodeInput.NodeExecutionId, modelInfo.Model.ResponseTokenField, taskResult)
+				}(idx, taskId)
+			}
+
+			wg.Wait()
+			close(errChan)
+
+			if len(errChan) > 0 {
+				return nil, <-errChan
+			}
+		}
+	} else {
+		for idx, item := range composeResult.Messages.Rounds {
+			mapTaskResult[idx] = item
+			updateTokenCount(ctx, nodeInput.NodeExecutionId, modelInfo.Model.ResponseTokenField, item)
+		}
+	}
+
+	return mapTaskResult, nil
+}
+
+func BuildNestedJson(body g.Map, mockConfigMap map[string]*entity.FlowNode) g.Map {
+	jsonStr := "{}"
+	for originKey, originItem := range body {
+		bodyItemMap := gconv.Map(originItem)
+		val := bodyItemMap["value"]
+		if v, ok := bodyItemMap["value"]; ok {
+			jsonStr, _ = sjson.Set(jsonStr, originKey, v)
+		}
+		// 判断 value 是不是引用结构（map）
+		if g.NewVar(val).IsMap() {
+			valMap := gconv.Map(val)
+			nodeId := gconv.String(valMap["nodeId"])
+			fieldName := gconv.String(valMap["field"])
+			if configValue, ok := mockConfigMap[nodeId]; ok {
+				if !g.IsEmpty(configValue.OutputResult) {
+					for _, v := range configValue.OutputResult {
+						if strings.Contains(v.Field, fieldName) {
+							if configValue.NodeCode == node.NodeTypeDataConversionModel {
+								switch {
+								case g.NewVar(v.Value).IsSlice() || g.NewVar(v.Value).IsMap():
+									// 核心：自动判断两种结构，精准赋值
+									vm := gconv.Map(v.Value)
+									// 先判断是否是 单个key包裹的对象（如 {"subtitle_style": {...}}）
+									if len(vm) == 1 {
+										// 遍历取出唯一的 key 和 真实值
+										for innerKey, innerVal := range vm {
+											// 直接用 innerKey（subtitle_style）赋值
+											jsonStr, _ = sjson.Set(jsonStr, innerKey, innerVal)
+										}
+									} else {
+										// 直接是对象，用 originKey 赋值
+										jsonStr, _ = sjson.Set(jsonStr, originKey, v.Value)
+									}
+								default:
+									jsonStr, _ = sjson.Set(jsonStr, originKey, v.Value)
+								}
+							} else {
+								jsonStr, _ = sjson.Set(jsonStr, originKey, v.Value)
+							}
+						}
+					}
+				}
+				if !g.IsEmpty(configValue.FormConfig) {
+					for _, v := range configValue.FormConfig {
+						if v.Field == fieldName {
+							if v.Type == "uploadMultiple" {
+								if g.NewVar(v.FieldConstraint).IsMap() {
+									mapFieldConstraint := gconv.Map(v.FieldConstraint)
+									for key, value := range mapFieldConstraint {
+										if key == "maxFileCount" {
+											if gconv.Int(value) == 1 {
+												// 如果是单文件上传，则替换成字符串重新赋值给v.Value
+												if g.NewVar(v.Value).IsSlice() {
+													sliceVal := gconv.SliceAny(v.Value)
+													if len(sliceVal) > 0 {
+														v.Value = sliceVal[0]
+													}
+												}
+											}
+										}
+									}
+								}
+							}
+							jsonStr, _ = sjson.Set(jsonStr, originKey, v.Value)
+						}
+					}
+				}
+			}
+		}
+	}
+	return gconv.Map(jsonStr)
+}
+
+func VideoConcat(ctx context.Context, videoUrls []string) (r any, err error) {
+	var httpUrl = "media/video/concat/async"
+	headers := make(map[string]string)
+	if r := g.RequestFromCtx(ctx); r != nil {
+		for k, v := range r.Request.Header {
+			if len(v) > 0 {
+				headers[k] = v[0]
+			}
+		}
+	}
+	var callbackUrl = utils.GetCallbackURL(ctx, "/flow/execution/videoCallback")
+	var newBody = flowDto.VideoConcatReq{
+		VideoUrls:   videoUrls,
+		Method:      "auto",
+		Upload:      true,
+		CallbackUrl: callbackUrl,
+	}
+	res := new(flowDto.VideoConcatRes)
+	err = commonHttp.Post(ctx, httpUrl, headers, &res, newBody)
+	if err != nil {
+		return nil, err
+	}
+	return Wait(ctx, res.TaskId)
+}
+
+func GetFileBytesFromURL(ctx context.Context, fileUrl string) ([]byte, error) {
+	// 使用 GoFrame 客户端（自带超时、追踪、日志等能力）
 	resp, err := g.Client().Get(ctx, fileUrl)
 	if err != nil {
-		return nil, fmt.Errorf("get file failed: %w", err)
+		return nil, gerror.Wrapf(err, "failed to request url: %s", fileUrl)
 	}
 	defer resp.Close()
 
+	// 校验状态码
 	if resp.StatusCode != http.StatusOK {
-		return nil, fmt.Errorf("http status error: %d", resp.StatusCode)
+		return nil, gerror.Newf("request failed with status code: %d, url: %s", resp.StatusCode, fileUrl)
 	}
 
-	return io.ReadAll(resp.Body)
-}
+	// 读取全部内容
+	allBytes, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, gerror.Wrapf(err, "failed to read response body, url: %s", fileUrl)
+	}
 
-func GetFileBytesFromURL(url string) (all []byte, err error) {
-	resp, err := http.Get(url)
-	if err != nil {
-		fmt.Printf("请求失败 %s: %v", url, err)
-		return
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode != http.StatusOK {
-		fmt.Printf("请求失败，状态码: %d\n", resp.StatusCode)
-		return
-	}
-	all, err = io.ReadAll(resp.Body)
-	if err != nil {
-		fmt.Printf("读取内容失败 %s: %v", url, err)
-		return
-	}
-	return
+	return allBytes, nil
 }
 
 func Upload(ctx context.Context, req *dto.UploadFileBytesReq) (*dto.UploadFileBytesRes, error) {
@@ -192,8 +516,8 @@ func Upload(ctx context.Context, req *dto.UploadFileBytesReq) (*dto.UploadFileBy
 
 	// 发起上传请求
 	res := &dto.UploadFileBytesRes{}
-	url := "oss/file/uploadFile"
-	if err = commonHttp.Post(ctx, url, headers, res, body.Bytes()); err != nil {
+	httpUrl := "oss/file/uploadFile"
+	if err = commonHttp.Post(ctx, httpUrl, headers, res, body.Bytes()); err != nil {
 		return nil, err
 	}
 
@@ -201,6 +525,40 @@ func Upload(ctx context.Context, req *dto.UploadFileBytesReq) (*dto.UploadFileBy
 	return res, nil
 }
 
+func GetFileTypeByPath(filePath string) string {
+	if filePath == "" {
+		return ""
+	}
+
+	// 解析 URL，获取真实路径（兼容 http 链接）
+	u, err := url.Parse(filePath)
+	if err == nil {
+		filePath = u.Path
+	}
+
+	// 获取后缀（小写）
+	ext := filepath.Ext(filePath)
+	ext = strings.ToLower(ext)
+
+	// 判断类型
+	switch ext {
+	case ".jpg", ".jpeg", ".png", ".gif", ".bmp", ".webp":
+		return "image"
+	case ".mp4", ".mov", ".avi", ".flv", ".wmv", ".mkv":
+		return "video"
+	case ".mp3", ".wav", ".m4a", ".flac", ".aac", ".ogg":
+		return "audio"
+	case ".txt", ".md", ".log", ".json", ".xml", ".inc":
+		return "text"
+	case ".html":
+		return "html"
+	case ".pdf", ".doc", ".docx", ".xls", ".xlsx", ".ppt", ".pptx":
+		return "document"
+	default:
+		return ""
+	}
+}
+
 func BuildText(text string) string {
 	// 生成单条HTML
 	var htmlBuilder strings.Builder
@@ -354,7 +712,7 @@ func BuildHtml(text string, images []string) string {
             border-radius: 12px;
             box-shadow: 0 2px 10px rgba(0, 0, 0, 0.06);
         }
-     
+
     </style>
 </head>
 <body>
@@ -457,8 +815,8 @@ func SplitMultiContents(htmlContent string) []string {
 func GetAllImgSrcFromHtml(html string) []string {
 	var imgSrcList []string
 	re := regexp.MustCompile(`<img[^>]*src\s*=\s*["']([^"']+)["']`)
-	matchs := re.FindAllStringSubmatch(html, -1)
-	for _, match := range matchs {
+	submatch := re.FindAllStringSubmatch(html, -1)
+	for _, match := range submatch {
 		if len(match) >= 2 {
 			imgSrcList = append(imgSrcList, match[1])
 		}
@@ -468,7 +826,7 @@ func GetAllImgSrcFromHtml(html string) []string {
 
 // ReplaceImgSrc 替换img src的方法
 func ReplaceImgSrc(html string, oldSrc string, newSrc string) string {
-	// 精准替换：找到 <img  xxx src="oldSrc"  xxx> 并替换
+	// 精准替换：找到 <img  xxx src="oldSrc"  xxx>
 	re := regexp.MustCompile(`(<img[^>]*src\s*=\s*["'])` + regexp.QuoteMeta(oldSrc) + `(["'])`)
 	return re.ReplaceAllString(html, `${1}`+newSrc+`${2}`)
 }