shaw
8a95a46a69
Resolve conflicts with main: - service/grok_media.go: keep both post-response blocks — #4497's empty image-output failover (main) runs first for image endpoints, then this branch's video-status content-URL rewrite; the endpoint conditions are mutually exclusive - handler/openai_gateway_credential_failover_loop_test.go: mark the stub OAuth accounts media-eligible via the grok_media_eligible extra override, because this branch moved grok media failover coverage to the generation endpoint, which is now gated by #4540's paid-eligibility probe on main
345 lines
15 KiB
Go
345 lines
15 KiB
Go
package routes
|
|
|
|
import (
|
|
"net/http"
|
|
|
|
"github.com/Wei-Shaw/sub2api/internal/config"
|
|
"github.com/Wei-Shaw/sub2api/internal/handler"
|
|
"github.com/Wei-Shaw/sub2api/internal/server/middleware"
|
|
"github.com/Wei-Shaw/sub2api/internal/service"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
)
|
|
|
|
// RegisterGatewayRoutes 注册 API 网关路由（Claude/OpenAI/Gemini 兼容）
|
|
func RegisterGatewayRoutes(
|
|
r *gin.Engine,
|
|
h *handler.Handlers,
|
|
apiKeyAuth middleware.APIKeyAuthMiddleware,
|
|
apiKeyService *service.APIKeyService,
|
|
subscriptionService *service.SubscriptionService,
|
|
opsService *service.OpsService,
|
|
settingService *service.SettingService,
|
|
cfg *config.Config,
|
|
) {
|
|
bodyLimit := middleware.RequestBodyLimit(cfg.Gateway.MaxBodySize)
|
|
textBodyLimit := middleware.RequestBodyLimit(cfg.Gateway.TextMaxBodySize)
|
|
clientRequestID := middleware.ClientRequestID()
|
|
opsErrorLogger := handler.OpsErrorLoggerMiddleware(opsService)
|
|
endpointNorm := handler.InboundEndpointMiddleware()
|
|
|
|
// 未分组 Key 拦截中间件（按协议格式区分错误响应）
|
|
requireGroupAnthropic := middleware.RequireGroupAssignment(settingService, middleware.AnthropicErrorWriter)
|
|
requireGroupGoogle := middleware.RequireGroupAssignment(settingService, middleware.GoogleErrorWriter)
|
|
|
|
isOpenAIResponsesCompatibleGatewayPlatform := func(c *gin.Context) bool {
|
|
switch getGroupPlatform(c) {
|
|
case service.PlatformOpenAI, service.PlatformGrok:
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
isOpenAIGatewayPlatform := func(c *gin.Context) bool {
|
|
return getGroupPlatform(c) == service.PlatformOpenAI
|
|
}
|
|
modelsHandler := func(c *gin.Context) {
|
|
if isOpenAIGatewayPlatform(c) && c.Query("client_version") != "" {
|
|
h.OpenAIGateway.CodexModels(c)
|
|
return
|
|
}
|
|
h.Gateway.Models(c)
|
|
}
|
|
imagesHandler := func(c *gin.Context) {
|
|
switch getGroupPlatform(c) {
|
|
case service.PlatformOpenAI:
|
|
h.OpenAIGateway.Images(c)
|
|
case service.PlatformGrok:
|
|
h.OpenAIGateway.GrokImages(c)
|
|
default:
|
|
service.MarkOpsClientBusinessLimited(c, service.OpsClientBusinessLimitedReasonLocalFeatureGate)
|
|
c.JSON(http.StatusNotFound, gin.H{
|
|
"error": gin.H{
|
|
"type": "not_found_error",
|
|
"message": "Images API is not supported for this platform",
|
|
},
|
|
})
|
|
}
|
|
}
|
|
videoGenerationHandler := func(c *gin.Context) {
|
|
if getGroupPlatform(c) == service.PlatformGrok {
|
|
h.OpenAIGateway.GrokVideoGeneration(c)
|
|
return
|
|
}
|
|
service.MarkOpsClientBusinessLimited(c, service.OpsClientBusinessLimitedReasonLocalFeatureGate)
|
|
c.JSON(http.StatusNotFound, gin.H{
|
|
"error": gin.H{
|
|
"type": "not_found_error",
|
|
"message": "Videos API is not supported for this platform",
|
|
},
|
|
})
|
|
}
|
|
videoStatusHandler := func(c *gin.Context) {
|
|
if getGroupPlatform(c) == service.PlatformGrok {
|
|
h.OpenAIGateway.GrokVideoStatus(c)
|
|
return
|
|
}
|
|
service.MarkOpsClientBusinessLimited(c, service.OpsClientBusinessLimitedReasonLocalFeatureGate)
|
|
c.JSON(http.StatusNotFound, gin.H{
|
|
"error": gin.H{
|
|
"type": "not_found_error",
|
|
"message": "Videos API is not supported for this platform",
|
|
},
|
|
})
|
|
}
|
|
videoContentHandler := func(c *gin.Context) {
|
|
if getGroupPlatform(c) == service.PlatformGrok {
|
|
h.OpenAIGateway.GrokVideoContent(c)
|
|
return
|
|
}
|
|
service.MarkOpsClientBusinessLimited(c, service.OpsClientBusinessLimitedReasonLocalFeatureGate)
|
|
c.JSON(http.StatusNotFound, gin.H{
|
|
"error": gin.H{
|
|
"type": "not_found_error",
|
|
"message": "Videos API is not supported for this platform",
|
|
},
|
|
})
|
|
}
|
|
videoEditHandler := func(c *gin.Context) {
|
|
if getGroupPlatform(c) == service.PlatformGrok {
|
|
h.OpenAIGateway.GrokVideoEdit(c)
|
|
return
|
|
}
|
|
service.MarkOpsClientBusinessLimited(c, service.OpsClientBusinessLimitedReasonLocalFeatureGate)
|
|
c.JSON(http.StatusNotFound, gin.H{"error": gin.H{"type": "not_found_error", "message": "Videos API is not supported for this platform"}})
|
|
}
|
|
videoExtensionHandler := func(c *gin.Context) {
|
|
if getGroupPlatform(c) == service.PlatformGrok {
|
|
h.OpenAIGateway.GrokVideoExtension(c)
|
|
return
|
|
}
|
|
service.MarkOpsClientBusinessLimited(c, service.OpsClientBusinessLimitedReasonLocalFeatureGate)
|
|
c.JSON(http.StatusNotFound, gin.H{"error": gin.H{"type": "not_found_error", "message": "Videos API is not supported for this platform"}})
|
|
}
|
|
// API网关（Claude API兼容）
|
|
gateway := r.Group("/v1")
|
|
gateway.Use(bodyLimit)
|
|
gateway.Use(clientRequestID)
|
|
gateway.Use(opsErrorLogger)
|
|
gateway.Use(endpointNorm)
|
|
gateway.Use(gin.HandlerFunc(apiKeyAuth))
|
|
gateway.GET("/sub2api/billing", h.Gateway.KeyBillingInfo)
|
|
gateway.Use(requireGroupAnthropic)
|
|
{
|
|
// /v1/messages: auto-route based on group platform
|
|
gateway.POST("/messages", func(c *gin.Context) {
|
|
if isOpenAIResponsesCompatibleGatewayPlatform(c) {
|
|
h.OpenAIGateway.Messages(c)
|
|
return
|
|
}
|
|
h.Gateway.Messages(c)
|
|
})
|
|
// /v1/messages/count_tokens: OpenAI uses Anthropic-compat bridge; other
|
|
// OpenAI-compatible platforms keep the prior unsupported response.
|
|
gateway.POST("/messages/count_tokens", func(c *gin.Context) {
|
|
if isOpenAIGatewayPlatform(c) {
|
|
h.OpenAIGateway.CountTokens(c)
|
|
return
|
|
}
|
|
if isOpenAIResponsesCompatibleGatewayPlatform(c) {
|
|
service.MarkOpsClientBusinessLimited(c, service.OpsClientBusinessLimitedReasonLocalFeatureGate)
|
|
c.JSON(http.StatusNotFound, gin.H{
|
|
"type": "error",
|
|
"error": gin.H{
|
|
"type": "not_found_error",
|
|
"message": "Token counting is not supported for this platform",
|
|
},
|
|
})
|
|
return
|
|
}
|
|
h.Gateway.CountTokens(c)
|
|
})
|
|
// Codex CLI / Codex app refresh their model picker from the provider's
|
|
// /models endpoint with a client_version query and expect the ChatGPT
|
|
// Codex manifest format; other clients keep the OpenAI-style list.
|
|
gateway.GET("/models", modelsHandler)
|
|
gateway.GET("/usage", h.Gateway.Usage)
|
|
// OpenAI Responses API: auto-route based on group platform
|
|
gateway.POST("/responses", func(c *gin.Context) {
|
|
if isOpenAIResponsesCompatibleGatewayPlatform(c) {
|
|
h.OpenAIGateway.Responses(c)
|
|
return
|
|
}
|
|
h.Gateway.Responses(c)
|
|
})
|
|
gateway.POST("/responses/*subpath", func(c *gin.Context) {
|
|
if isOpenAIResponsesCompatibleGatewayPlatform(c) {
|
|
h.OpenAIGateway.Responses(c)
|
|
return
|
|
}
|
|
h.Gateway.Responses(c)
|
|
})
|
|
gateway.POST("/alpha/search", textBodyLimit, h.OpenAIGateway.AlphaSearch)
|
|
gateway.GET("/responses", func(c *gin.Context) {
|
|
h.OpenAIGateway.ResponsesWebSocket(c)
|
|
})
|
|
// OpenAI Chat Completions API: auto-route based on group platform
|
|
gateway.POST("/chat/completions", func(c *gin.Context) {
|
|
if isOpenAIResponsesCompatibleGatewayPlatform(c) {
|
|
h.OpenAIGateway.ChatCompletions(c)
|
|
return
|
|
}
|
|
h.Gateway.ChatCompletions(c)
|
|
})
|
|
gateway.POST("/embeddings", textBodyLimit, func(c *gin.Context) {
|
|
if getGroupPlatform(c) != service.PlatformOpenAI {
|
|
service.MarkOpsClientBusinessLimited(c, service.OpsClientBusinessLimitedReasonLocalFeatureGate)
|
|
c.JSON(http.StatusNotFound, gin.H{
|
|
"error": gin.H{
|
|
"type": "not_found_error",
|
|
"message": "Embeddings API is not supported for this platform",
|
|
},
|
|
})
|
|
return
|
|
}
|
|
h.OpenAIGateway.Embeddings(c)
|
|
})
|
|
gateway.POST("/images/generations", imagesHandler)
|
|
gateway.POST("/images/edits", imagesHandler)
|
|
gateway.POST("/images/generations/async", h.AsyncImage.Submit)
|
|
gateway.POST("/images/edits/async", h.AsyncImage.Submit)
|
|
gateway.GET("/images/tasks/:task_id", h.AsyncImage.Get)
|
|
gateway.POST("/images/batches", h.BatchImage.Submit)
|
|
gateway.GET("/images/batches", h.BatchImage.List)
|
|
gateway.GET("/images/batches/models", h.BatchImage.Models)
|
|
gateway.GET("/images/batches/:id", h.BatchImage.Get)
|
|
gateway.GET("/images/batches/:id/items", h.BatchImage.Items)
|
|
gateway.GET("/images/batches/:id/items/:custom_id/content", h.BatchImage.ItemContent)
|
|
gateway.GET("/images/batches/:id/download", h.BatchImage.Download)
|
|
gateway.POST("/images/batches/:id/cancel", h.BatchImage.Cancel)
|
|
gateway.DELETE("/images/batches/:id", h.BatchImage.DeleteRecord)
|
|
gateway.DELETE("/images/batches/:id/outputs", h.BatchImage.DeleteOutputs)
|
|
gateway.POST("/videos/generations", videoGenerationHandler)
|
|
gateway.POST("/videos/edits", videoEditHandler)
|
|
gateway.POST("/videos/extensions", videoExtensionHandler)
|
|
gateway.GET("/videos/:request_id", videoStatusHandler)
|
|
gateway.GET("/videos/:request_id/content", videoContentHandler)
|
|
}
|
|
|
|
// Gemini 原生 API 兼容层（Gemini SDK/CLI 直连）
|
|
gemini := r.Group("/v1beta")
|
|
gemini.Use(bodyLimit)
|
|
gemini.Use(clientRequestID)
|
|
gemini.Use(opsErrorLogger)
|
|
gemini.Use(endpointNorm)
|
|
gemini.Use(middleware.APIKeyAuthWithSubscriptionGoogle(apiKeyService, subscriptionService, cfg))
|
|
gemini.Use(requireGroupGoogle)
|
|
{
|
|
gemini.GET("/models", h.Gateway.GeminiV1BetaListModels)
|
|
gemini.GET("/models/:model", h.Gateway.GeminiV1BetaGetModel)
|
|
// Gin treats ":" as a param marker, but Gemini uses "{model}:{action}" in the same segment.
|
|
gemini.POST("/models/*modelAction", h.Gateway.GeminiV1BetaModels)
|
|
}
|
|
|
|
// OpenAI Responses API（不带v1前缀的别名）— auto-route based on group platform
|
|
responsesHandler := func(c *gin.Context) {
|
|
if isOpenAIResponsesCompatibleGatewayPlatform(c) {
|
|
h.OpenAIGateway.Responses(c)
|
|
return
|
|
}
|
|
h.Gateway.Responses(c)
|
|
}
|
|
r.POST("/responses", bodyLimit, clientRequestID, opsErrorLogger, endpointNorm, gin.HandlerFunc(apiKeyAuth), requireGroupAnthropic, responsesHandler)
|
|
r.POST("/responses/*subpath", bodyLimit, clientRequestID, opsErrorLogger, endpointNorm, gin.HandlerFunc(apiKeyAuth), requireGroupAnthropic, responsesHandler)
|
|
r.POST("/alpha/search", textBodyLimit, clientRequestID, opsErrorLogger, endpointNorm, gin.HandlerFunc(apiKeyAuth), requireGroupAnthropic, h.OpenAIGateway.AlphaSearch)
|
|
r.GET("/responses", bodyLimit, clientRequestID, opsErrorLogger, endpointNorm, gin.HandlerFunc(apiKeyAuth), requireGroupAnthropic, func(c *gin.Context) {
|
|
h.OpenAIGateway.ResponsesWebSocket(c)
|
|
})
|
|
r.GET("/models", bodyLimit, clientRequestID, opsErrorLogger, endpointNorm, gin.HandlerFunc(apiKeyAuth), requireGroupAnthropic, modelsHandler)
|
|
codexDirect := r.Group("/backend-api/codex")
|
|
codexDirect.Use(bodyLimit, clientRequestID, opsErrorLogger, endpointNorm, gin.HandlerFunc(apiKeyAuth), requireGroupAnthropic)
|
|
{
|
|
codexDirect.POST("/responses", responsesHandler)
|
|
codexDirect.POST("/responses/*subpath", responsesHandler)
|
|
codexDirect.POST("/alpha/search", textBodyLimit, h.OpenAIGateway.AlphaSearch)
|
|
codexDirect.GET("/responses", func(c *gin.Context) {
|
|
h.OpenAIGateway.ResponsesWebSocket(c)
|
|
})
|
|
codexDirect.GET("/models", h.OpenAIGateway.CodexModels)
|
|
}
|
|
// OpenAI Chat Completions API（不带v1前缀的别名）— auto-route based on group platform
|
|
r.POST("/chat/completions", bodyLimit, clientRequestID, opsErrorLogger, endpointNorm, gin.HandlerFunc(apiKeyAuth), requireGroupAnthropic, func(c *gin.Context) {
|
|
if isOpenAIResponsesCompatibleGatewayPlatform(c) {
|
|
h.OpenAIGateway.ChatCompletions(c)
|
|
return
|
|
}
|
|
h.Gateway.ChatCompletions(c)
|
|
})
|
|
r.POST("/embeddings", textBodyLimit, clientRequestID, opsErrorLogger, endpointNorm, gin.HandlerFunc(apiKeyAuth), requireGroupAnthropic, func(c *gin.Context) {
|
|
if getGroupPlatform(c) != service.PlatformOpenAI {
|
|
service.MarkOpsClientBusinessLimited(c, service.OpsClientBusinessLimitedReasonLocalFeatureGate)
|
|
c.JSON(http.StatusNotFound, gin.H{
|
|
"error": gin.H{
|
|
"type": "not_found_error",
|
|
"message": "Embeddings API is not supported for this platform",
|
|
},
|
|
})
|
|
return
|
|
}
|
|
h.OpenAIGateway.Embeddings(c)
|
|
})
|
|
r.POST("/images/generations", bodyLimit, clientRequestID, opsErrorLogger, endpointNorm, gin.HandlerFunc(apiKeyAuth), requireGroupAnthropic, imagesHandler)
|
|
r.POST("/images/edits", bodyLimit, clientRequestID, opsErrorLogger, endpointNorm, gin.HandlerFunc(apiKeyAuth), requireGroupAnthropic, imagesHandler)
|
|
r.POST("/images/generations/async", bodyLimit, clientRequestID, opsErrorLogger, endpointNorm, gin.HandlerFunc(apiKeyAuth), requireGroupAnthropic, h.AsyncImage.Submit)
|
|
r.POST("/images/edits/async", bodyLimit, clientRequestID, opsErrorLogger, endpointNorm, gin.HandlerFunc(apiKeyAuth), requireGroupAnthropic, h.AsyncImage.Submit)
|
|
r.GET("/images/tasks/:task_id", bodyLimit, clientRequestID, opsErrorLogger, endpointNorm, gin.HandlerFunc(apiKeyAuth), requireGroupAnthropic, h.AsyncImage.Get)
|
|
r.POST("/videos/generations", bodyLimit, clientRequestID, opsErrorLogger, endpointNorm, gin.HandlerFunc(apiKeyAuth), requireGroupAnthropic, videoGenerationHandler)
|
|
r.POST("/videos/edits", bodyLimit, clientRequestID, opsErrorLogger, endpointNorm, gin.HandlerFunc(apiKeyAuth), requireGroupAnthropic, videoEditHandler)
|
|
r.POST("/videos/extensions", bodyLimit, clientRequestID, opsErrorLogger, endpointNorm, gin.HandlerFunc(apiKeyAuth), requireGroupAnthropic, videoExtensionHandler)
|
|
r.GET("/videos/:request_id", bodyLimit, clientRequestID, opsErrorLogger, endpointNorm, gin.HandlerFunc(apiKeyAuth), requireGroupAnthropic, videoStatusHandler)
|
|
r.GET("/videos/:request_id/content", bodyLimit, clientRequestID, opsErrorLogger, endpointNorm, gin.HandlerFunc(apiKeyAuth), requireGroupAnthropic, videoContentHandler)
|
|
|
|
// Antigravity 模型列表
|
|
r.GET("/antigravity/models", gin.HandlerFunc(apiKeyAuth), requireGroupAnthropic, h.Gateway.AntigravityModels)
|
|
|
|
// Antigravity 专用路由（仅使用 antigravity 账户，不混合调度）
|
|
antigravityV1 := r.Group("/antigravity/v1")
|
|
antigravityV1.Use(bodyLimit)
|
|
antigravityV1.Use(clientRequestID)
|
|
antigravityV1.Use(opsErrorLogger)
|
|
antigravityV1.Use(endpointNorm)
|
|
antigravityV1.Use(middleware.ForcePlatform(service.PlatformAntigravity))
|
|
antigravityV1.Use(gin.HandlerFunc(apiKeyAuth))
|
|
antigravityV1.Use(requireGroupAnthropic)
|
|
{
|
|
antigravityV1.POST("/messages", h.Gateway.Messages)
|
|
antigravityV1.POST("/messages/count_tokens", h.Gateway.CountTokens)
|
|
antigravityV1.GET("/models", h.Gateway.AntigravityModels)
|
|
antigravityV1.GET("/usage", h.Gateway.Usage)
|
|
}
|
|
|
|
antigravityV1Beta := r.Group("/antigravity/v1beta")
|
|
antigravityV1Beta.Use(bodyLimit)
|
|
antigravityV1Beta.Use(clientRequestID)
|
|
antigravityV1Beta.Use(opsErrorLogger)
|
|
antigravityV1Beta.Use(endpointNorm)
|
|
antigravityV1Beta.Use(middleware.ForcePlatform(service.PlatformAntigravity))
|
|
antigravityV1Beta.Use(middleware.APIKeyAuthWithSubscriptionGoogle(apiKeyService, subscriptionService, cfg))
|
|
antigravityV1Beta.Use(requireGroupGoogle)
|
|
{
|
|
antigravityV1Beta.GET("/models", h.Gateway.GeminiV1BetaListModels)
|
|
antigravityV1Beta.GET("/models/:model", h.Gateway.GeminiV1BetaGetModel)
|
|
antigravityV1Beta.POST("/models/*modelAction", h.Gateway.GeminiV1BetaModels)
|
|
}
|
|
|
|
}
|
|
|
|
// getGroupPlatform extracts the group platform from the API Key stored in context.
|
|
func getGroupPlatform(c *gin.Context) string {
|
|
apiKey, ok := middleware.GetAPIKeyFromContext(c)
|
|
if !ok || apiKey.Group == nil {
|
|
return ""
|
|
}
|
|
return apiKey.Group.Platform
|
|
}
|