Feature/range price

common/endpoint_defaults.go

@@ -25,6 +25,7 @@ var defaultEndpointInfoMap = map[constant.EndpointType]EndpointInfo{
 	constant.EndpointTypeJinaRerank:            {Path: "/v1/rerank", Method: "POST"},
 	constant.EndpointTypeImageGeneration:       {Path: "/v1/images/generations", Method: "POST"},
 	constant.EndpointTypeEmbeddings:            {Path: "/v1/embeddings", Method: "POST"},
+	constant.EndpointTypeOpenAIVideo:           {Path: "/v1/videos", Method: "POST"},
 }
 
 // GetDefaultEndpointInfo 返回指定端点类型的默认信息以及是否存在

controller/channel-test.go

@@ -42,6 +42,18 @@ type testResult struct {
 	newAPIError *types.NewAPIError
 }
 
+func isImageOrVideoGenerationModel(model string) bool {
+	lower := strings.ToLower(model)
+	return strings.Contains(model, "gpt-image") ||
+		strings.Contains(model, "dall-e") ||
+		strings.Contains(lower, "stable-diffusion") ||
+		strings.Contains(lower, "flux") ||
+		strings.HasPrefix(lower, "veo-") ||
+		strings.HasPrefix(lower, "sora-") ||
+		strings.Contains(lower, "imagen") ||
+		strings.Contains(lower, "seedream")
+}
+
 func normalizeChannelTestEndpoint(channel *model.Channel, modelName, endpointType string) string {
 	normalized := strings.TrimSpace(endpointType)
 	if normalized != "" {
@@ -116,8 +128,8 @@ func testChannel(channel *model.Channel, testModel string, endpointType string,
 			requestPath = "/v1/embeddings" // 修改请求路径
 		}
 
-		// VolcEngine 图像生成模型
-		if channel.Type == constant.ChannelTypeVolcEngine && strings.Contains(testModel, "seedream") {
+		// 通用图像/视频生成模型检测
+		if isImageOrVideoGenerationModel(testModel) {
 			requestPath = "/v1/images/generations"
 		}
 
@@ -685,6 +697,16 @@ func buildTestRequest(model string, endpointType string, channel *model.Channel,
 		}
 	}
 
+	// 图像/视频生成模型
+	if isImageOrVideoGenerationModel(model) {
+		return &dto.ImageRequest{
+			Model:  model,
+			Prompt: "a cute cat",
+			N:      lo.ToPtr(uint(1)),
+			Size:   "1024x1024",
+		}
+	}
+
 	// Responses compaction models (must use /v1/responses/compact)
 	if strings.HasSuffix(model, ratio_setting.CompactModelSuffix) {
 		return &dto.OpenAIResponsesCompactionRequest{

controller/playground.go

@@ -3,9 +3,14 @@ package controller
 import (
 	"errors"
 	"fmt"
+	"io"
+	"net/http"
+	"strconv"
+	"strings"
 
 	"github.com/QuantumNous/new-api/middleware"
 	"github.com/QuantumNous/new-api/model"
+	"github.com/QuantumNous/new-api/relay"
 	relaycommon "github.com/QuantumNous/new-api/relay/common"
 	"github.com/QuantumNous/new-api/types"
 
@@ -54,3 +59,101 @@ func Playground(c *gin.Context) {
 
 	Relay(c, types.RelayFormatOpenAI)
 }
+
+// PlaygroundVideoProxy proxies an authenticated video content request to the upstream.
+// Route: GET /pg/video/:channelId/:videoId/content
+// The backend fetches the video binary with the channel's Bearer token and streams it back.
+func PlaygroundVideoProxy(c *gin.Context) {
+	channelIdStr := c.Param("channelId")
+	videoId := c.Param("videoId")
+
+	if channelIdStr == "" || videoId == "" {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "missing channelId or videoId"})
+		return
+	}
+
+	channelId, err := strconv.Atoi(channelIdStr)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid channelId"})
+		return
+	}
+
+	channel, err := model.GetChannelById(channelId, true)
+	if err != nil {
+		c.JSON(http.StatusNotFound, gin.H{"error": "channel not found"})
+		return
+	}
+
+	baseURL := ""
+	if channel.BaseURL != nil {
+		baseURL = strings.TrimRight(*channel.BaseURL, "/")
+	}
+	if baseURL == "" {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "channel has no base URL"})
+		return
+	}
+
+	keys := channel.GetKeys()
+	if len(keys) == 0 {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "channel has no API key"})
+		return
+	}
+	apiKey := keys[0]
+
+	upstreamURL := fmt.Sprintf("%s/videos/%s/content", baseURL, videoId)
+
+	req, err := http.NewRequestWithContext(c.Request.Context(), http.MethodGet, upstreamURL, nil)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to create upstream request"})
+		return
+	}
+	req.Header.Set("Authorization", "Bearer "+apiKey)
+
+	client := &http.Client{}
+	resp, err := client.Do(req)
+	if err != nil {
+		c.JSON(http.StatusBadGateway, gin.H{"error": "upstream request failed: " + err.Error()})
+		return
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		c.Data(resp.StatusCode, resp.Header.Get("Content-Type"), body)
+		return
+	}
+
+	contentType := resp.Header.Get("Content-Type")
+	if contentType == "" {
+		contentType = "video/mp4"
+	}
+	c.Header("Content-Type", contentType)
+	if cl := resp.Header.Get("Content-Length"); cl != "" {
+		c.Header("Content-Length", cl)
+	}
+	c.Header("Cache-Control", "no-store")
+
+	c.Status(http.StatusOK)
+	io.Copy(c.Writer, resp.Body) //nolint:errcheck
+}
+
+// PlaygroundAudioProxy serves a cached TTS audio file by its UUID.
+// Route: GET /pg/audio/:audioId
+func PlaygroundAudioProxy(c *gin.Context) {
+	audioId := c.Param("audioId")
+
+	// Strip any file extension from the ID (e.g. "uuid.mp3" → "uuid")
+	if idx := strings.LastIndex(audioId, "."); idx != -1 {
+		audioId = audioId[:idx]
+	}
+
+	data, contentType, ok := relay.GetCachedAudio(audioId)
+	if !ok {
+		c.JSON(http.StatusNotFound, gin.H{"error": "audio not found or expired"})
+		return
+	}
+
+	c.Header("Cache-Control", "no-store")
+	c.Data(http.StatusOK, contentType, data)
+}
+

middleware/request_logger.go

@@ -0,0 +1,89 @@
+package middleware
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+
+	"github.com/QuantumNous/new-api/common"
+	"github.com/QuantumNous/new-api/logger"
+	"github.com/gin-gonic/gin"
+)
+
+// responseBodyWriter wraps gin.ResponseWriter to capture the response body.
+type responseBodyWriter struct {
+	gin.ResponseWriter
+	buf *bytes.Buffer
+}
+
+func (w *responseBodyWriter) Write(b []byte) (int, error) {
+	w.buf.Write(b)
+	return w.ResponseWriter.Write(b)
+}
+
+func (w *responseBodyWriter) WriteString(s string) (int, error) {
+	w.buf.WriteString(s)
+	return w.ResponseWriter.WriteString(s)
+}
+
+// RequestLogger logs the inbound request (URL, headers, body) and the
+// outbound response body when DEBUG=true.
+func RequestLogger() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		if !common.DebugEnabled {
+			c.Next()
+			return
+		}
+
+		// --- request ---
+		var sb strings.Builder
+		sb.WriteString("\n========== Inbound Request ==========\n")
+		sb.WriteString(fmt.Sprintf("%s %s\n", c.Request.Method, c.Request.URL.String()))
+
+		sb.WriteString("--- Headers ---\n")
+		for key, values := range c.Request.Header {
+			for _, v := range values {
+				if strings.EqualFold(key, "Authorization") || strings.EqualFold(key, "x-api-key") {
+					if len(v) > 12 {
+						v = v[:12] + "***"
+					}
+				}
+				sb.WriteString(fmt.Sprintf("%s: %s\n", key, v))
+			}
+		}
+
+		sb.WriteString("--- Body ---\n")
+		bodyStorage, err := common.GetBodyStorage(c)
+		if err == nil {
+			bodyBytes, err := bodyStorage.Bytes()
+			if err == nil {
+				sb.Write(bodyBytes)
+				sb.WriteString("\n")
+			}
+		}
+		sb.WriteString("=====================================")
+		logger.LogDebug(c.Request.Context(), sb.String())
+
+		// --- wrap response writer to capture output ---
+		rbw := &responseBodyWriter{ResponseWriter: c.Writer, buf: &bytes.Buffer{}}
+		c.Writer = rbw
+
+		c.Next()
+
+		// --- response ---
+		var sb2 strings.Builder
+		sb2.WriteString("\n========== Inbound Response ==========\n")
+		sb2.WriteString(fmt.Sprintf("Status: %d\n", rbw.Status()))
+		sb2.WriteString("--- Body ---\n")
+		const maxRespBytes = 4 << 10 // 4 KB
+		respBytes := rbw.buf.Bytes()
+		if len(respBytes) > maxRespBytes {
+			sb2.Write(respBytes[:maxRespBytes])
+			sb2.WriteString(fmt.Sprintf("\n... (truncated, total %d bytes)", len(respBytes)))
+		} else {
+			sb2.Write(respBytes)
+		}
+		sb2.WriteString("\n======================================")
+		logger.LogDebug(c.Request.Context(), sb2.String())
+	}
+}

model/main.go

@@ -202,7 +202,7 @@ func InitDB() (err error) {
 			//_, _ = sqlDB.Exec("ALTER TABLE channels MODIFY model_mapping TEXT;") // TODO: delete this line when most users have upgraded
 		}
 		common.SysLog("database migration started")
-		err = migrateDB()
+		// err = migrateDB()
 		return err
 	} else {
 		common.FatalLog(err)
@@ -239,7 +239,7 @@ func InitLogDB() (err error) {
 			return nil
 		}
 		common.SysLog("database migration started")
-		err = migrateLOGDB()
+		// err = migrateLOGDB()
 		return err
 	} else {
 		common.FatalLog(err)

model/option.go

@@ -152,6 +152,8 @@ func InitOptionMap() {
 	common.OptionMap["ImageRatio"] = ratio_setting.ImageRatio2JSONString()
 	common.OptionMap["AudioRatio"] = ratio_setting.AudioRatio2JSONString()
 	common.OptionMap["AudioCompletionRatio"] = ratio_setting.AudioCompletionRatio2JSONString()
+	common.OptionMap["ContextTierRatio"] = ratio_setting.ContextTierRatio2JSONString()
+	common.OptionMap["AudioMinutePrice"] = ratio_setting.AudioMinutePrice2JSONString()
 	common.OptionMap["TopUpLink"] = common.TopUpLink
 	//common.OptionMap["ChatLink"] = common.ChatLink
 	//common.OptionMap["ChatLink2"] = common.ChatLink2
@@ -521,6 +523,10 @@ func updateOptionMap(key string, value string) (err error) {
 		err = ratio_setting.UpdateAudioRatioByJSONString(value)
 	case "AudioCompletionRatio":
 		err = ratio_setting.UpdateAudioCompletionRatioByJSONString(value)
+	case "ContextTierRatio":
+		err = ratio_setting.UpdateContextTierRatioByJSONString(value)
+	case "AudioMinutePrice":
+		err = ratio_setting.UpdateAudioMinutePriceByJSONString(value)
 	case "TopUpLink":
 		common.TopUpLink = value
 	//case "ChatLink":

relay/channel/api_request.go

@@ -292,10 +292,25 @@ func DoApiRequest(a Adaptor, c *gin.Context, info *common.RelayInfo, requestBody
 	if err != nil {
 		return nil, fmt.Errorf("get request url failed: %w", err)
 	}
+
+	var bodyBytes []byte
+	if requestBody != nil {
+		bodyBytes, err = io.ReadAll(requestBody)
+		if err != nil {
+			return nil, fmt.Errorf("read request body failed: %w", err)
+		}
+	}
+
 	if common2.DebugEnabled {
-		println("fullRequestURL:", fullRequestURL)
+		var sb strings.Builder
+		sb.WriteString("\n========== Upstream Request ==========\n")
+		sb.WriteString(fmt.Sprintf("URL: %s %s\n", c.Request.Method, fullRequestURL))
+		sb.WriteString(fmt.Sprintf("Body: %s\n", string(bodyBytes)))
+		sb.WriteString("======================================")
+		logger.LogDebug(c.Request.Context(), sb.String())
 	}
-	req, err := http.NewRequest(c.Request.Method, fullRequestURL, requestBody)
+
+	req, err := http.NewRequest(c.Request.Method, fullRequestURL, strings.NewReader(string(bodyBytes)))
 	if err != nil {
 		return nil, fmt.Errorf("new request failed: %w", err)
 	}
@@ -311,6 +326,25 @@ func DoApiRequest(a Adaptor, c *gin.Context, info *common.RelayInfo, requestBody
 		return nil, err
 	}
 	applyHeaderOverrideToRequest(req, headerOverride)
+
+	if common2.DebugEnabled {
+		var sb strings.Builder
+		sb.WriteString("\n========== Upstream Request Headers ==========\n")
+		for key, values := range req.Header {
+			for _, v := range values {
+				if strings.EqualFold(key, "Authorization") {
+					// mask the key, only show prefix
+					if len(v) > 12 {
+						v = v[:12] + "***"
+					}
+				}
+				sb.WriteString(fmt.Sprintf("%s: %s\n", key, v))
+			}
+		}
+		sb.WriteString("==============================================")
+		logger.LogDebug(c.Request.Context(), sb.String())
+	}
+
 	resp, err := doRequest(c, req, info)
 	if err != nil {
 		return nil, fmt.Errorf("do request failed: %w", err)