feat(model): 添加流式配置支持并优化响应处理

common/util/mapping.go

@@ -1,6 +1,7 @@
 package util
 
 import (
+	"encoding/json"
 	"fmt"
 	"model-gateway/model/entity"
 	"net/url"
@@ -9,6 +10,7 @@ import (
 	"github.com/gogf/gf/v2/encoding/gjson"
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/util/gconv"
+	tgjson "github.com/tidwall/gjson"
 )
 
 // ValidatePromptResult 校验模型返回结果的 JSON 结构完整性
@@ -67,27 +69,40 @@ func ReverseMap(mapping map[string]any, payload map[string]any) map[string]any {
 }
 
 // MapResponsePayload 映射模型响应为标准格式
-func MapResponsePayload(mapping map[string]any, responseBytes []byte) ([]byte, error) {
+func MapResponsePayload(mapping map[string]any, result map[string]any) (map[string]any, error) {
 	if len(mapping) == 0 {
-		return responseBytes, nil
+		return result, nil
 	}
 
-	responseJson := gjson.New(responseBytes)
-	resultJson := gjson.New("{}")
+	// 把 result 转成 JSON 字符串，tidwall/gjson 需要字符串输入
+	resultBytes, _ := json.Marshal(result)
+	resultStr := string(resultBytes)
+
+	mapped := make(map[string]any)
 
 	for standardField, modelPath := range mapping {
 		path := gconv.String(modelPath)
 		if path == "" {
 			continue
 		}
-		val := responseJson.Get(path)
-		if val.IsNil() {
+
+		value := tgjson.Get(resultStr, path)
+		if !value.Exists() {
 			continue
 		}
-		resultJson.Set(standardField, val.Val())
+		// 如果是数组路径（含 #），取 Array；否则取单值
+		if strings.Contains(path, "#") {
+			var arr []any
+			for _, v := range value.Array() {
+				arr = append(arr, v.Value())
+			}
+			mapped[standardField] = arr
+		} else {
+			mapped[standardField] = value.Value()
+		}
 	}
 
-	return []byte(resultJson.String()), nil
+	return mapped, nil
 }
 
 // ParseHeadMsgHeaders 支持多个 header 绑定，逗号分隔：

common/util/streaming.go

@@ -0,0 +1,150 @@
+package util
+
+import (
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"sort"
+	"strings"
+
+	"github.com/gogf/gf/v2/encoding/gjson"
+)
+
+// ================================================================
+
+// ParseStreamResponse 流式响应解析（通用入口）
+func ParseStreamResponse(rawBytes []byte, streamConfig map[string]any) (map[string]any, error) {
+	enabled, _ := streamConfig["enabled"].(bool)
+	if !enabled {
+		return gjson.New(string(rawBytes)).Map(), nil
+	}
+
+	parser, _ := streamConfig["parser"].(string)
+	if parser == "base64_concat" {
+		return parseBase64Stream(rawBytes)
+	}
+
+	return parseSSEStream(rawBytes, streamConfig)
+}
+
+// parseBase64Stream 拼接流式 base64 并解码为二进制（TTS 等音频模型）
+func parseBase64Stream(rawBytes []byte) (map[string]any, error) {
+	lines := strings.Split(string(rawBytes), "\n")
+	var audioBase64 strings.Builder
+
+	for _, line := range lines {
+		line = strings.TrimSpace(line)
+		if line == "" {
+			continue
+		}
+
+		var chunk map[string]any
+		if err := json.Unmarshal([]byte(line), &chunk); err != nil {
+			continue
+		}
+
+		if data, ok := chunk["data"].(string); ok && data != "" {
+			audioBase64.WriteString(data)
+		}
+	}
+
+	cleanBase64 := strings.Map(func(r rune) rune {
+		if r == ' ' || r == '\n' || r == '\r' || r == '\t' {
+			return -1
+		}
+		return r
+	}, audioBase64.String())
+
+	audioBytes, err := base64.StdEncoding.DecodeString(cleanBase64)
+	if err != nil {
+		audioBytes, err = base64.RawStdEncoding.DecodeString(cleanBase64)
+		if err != nil {
+			return nil, fmt.Errorf("base64 解码失败: %w", err)
+		}
+	}
+
+	return map[string]any{"audio": audioBytes}, nil
+}
+
+// parseSSEStream SSE 流式解析（图片模型等）
+func parseSSEStream(rawBytes []byte, streamConfig map[string]any) (map[string]any, error) {
+	events, _ := streamConfig["events"].([]any)
+	if len(events) == 0 {
+		return gjson.New(string(rawBytes)).Map(), nil
+	}
+
+	lines := strings.Split(string(rawBytes), "\n")
+	result := make(map[string]any)
+	var partials []map[string]any
+
+	for _, line := range lines {
+		line = strings.TrimSpace(line)
+		if line == "" || line == "[DONE]" {
+			continue
+		}
+		if strings.HasPrefix(line, "event:") {
+			continue
+		}
+		if strings.HasPrefix(line, "data:") {
+			line = strings.TrimPrefix(line, "data:")
+			line = strings.TrimSpace(line)
+		}
+
+		var chunk map[string]any
+		if err := json.Unmarshal([]byte(line), &chunk); err != nil {
+			continue
+		}
+
+		chunkType, _ := chunk["type"].(string)
+
+		for _, evt := range events {
+			e, _ := evt.(map[string]any)
+			match, _ := e["match"].(string)
+			if !strings.Contains(chunkType, match) {
+				continue
+			}
+
+			fields, _ := e["fields"].(map[string]any)
+			aggregateTo, _ := e["aggregate_to"].(string)
+			evtType, _ := e["type"].(string)
+
+			switch evtType {
+			case "partial":
+				item := make(map[string]any)
+				for localKey, chunkKey := range fields {
+					item[localKey] = chunk[chunkKey.(string)]
+				}
+				partials = append(partials, item)
+
+			case "final":
+				for localKey, chunkKey := range fields {
+					val := gjson.New(chunk).Get(chunkKey.(string))
+					if !val.IsNil() {
+						if _, exists := result[aggregateTo]; !exists {
+							result[aggregateTo] = make(map[string]any)
+						}
+						result[aggregateTo].(map[string]any)[localKey] = val.Val()
+					}
+				}
+			}
+		}
+	}
+
+	if len(partials) > 0 {
+		for _, evt := range events {
+			e, _ := evt.(map[string]any)
+			if e["type"] == "partial" {
+				if orderBy, ok := e["order_by"].(string); ok {
+					sort.Slice(partials, func(i, j int) bool {
+						return fmt.Sprint(partials[i][orderBy]) < fmt.Sprint(partials[j][orderBy])
+					})
+				}
+				result[e["aggregate_to"].(string)] = partials
+				break
+			}
+		}
+	}
+
+	mergedBytes, _ := json.Marshal(result)
+	return gjson.New(mergedBytes).Map(), nil
+}