mirror of
https://github.com/Wei-Shaw/sub2api.git
synced 2026-10-15 23:22:59 +08:00
shaw
d19265ddb2
composite 分组中 openai OAuth 账号与 deepseek API Key 账号同时显式映射同一 gpt 模型时，模型归属判为歧义、路由层不解析平台，请求落到默认 Anthropic GatewayHandler；handler 再按模型名前缀猜回 openai 并选中 OpenAI OAuth 账号， ChatGPT token 被发往 api.anthropic.com，上游 401 "Invalid bearer token" 经 failover 逐号打成临时不可调度，单请求即可扫空号池。 - 归属记录声明方是否含 OpenAI 网关族 OAuth / setup-token；当模型名兜底也 落在 OpenAI 网关族时判为配置错误，路由中间件与 WS 入口直接 400 拒绝并 提示配置显式路由。纯 API Key 歧义及 Anthropic/Antigravity/Gemini OAuth 歧义保持原行为。 - 模型归属改按配置计算（ListModelAvailabilityCandidates），不再随限流 / 临时不可调度在「唯一归属」与「歧义」之间翻转。 - Anthropic 请求构建前校验凭据：非 Anthropic 网关族的 OAuth 凭据不出站， 返回仅换号、不处罚账号的 failover；count_tokens 返回 404 不支持。 API Key 不受限（上游可能兼容多种协议格式）。
418 lines
14 KiB
Go
418 lines
14 KiB
Go
package routes
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"io"
|
|
"mime/multipart"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/Wei-Shaw/sub2api/internal/pkg/requestmodel"
|
|
servermiddleware "github.com/Wei-Shaw/sub2api/internal/server/middleware"
|
|
"github.com/Wei-Shaw/sub2api/internal/service"
|
|
"github.com/gin-gonic/gin"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
type compositeRouteRepoStub struct {
|
|
routes []service.CompositeModelRoute
|
|
}
|
|
|
|
func (s compositeRouteRepoStub) ListByGroup(ctx context.Context, groupID int64, includeDisabled bool) ([]service.CompositeModelRoute, error) {
|
|
routes := make([]service.CompositeModelRoute, 0, len(s.routes))
|
|
for _, route := range s.routes {
|
|
if route.GroupID != groupID {
|
|
continue
|
|
}
|
|
if !includeDisabled && !route.Enabled {
|
|
continue
|
|
}
|
|
routes = append(routes, route)
|
|
}
|
|
return routes, nil
|
|
}
|
|
|
|
func (s compositeRouteRepoStub) Create(ctx context.Context, route *service.CompositeModelRoute) error {
|
|
return nil
|
|
}
|
|
|
|
func (s compositeRouteRepoStub) Update(ctx context.Context, route *service.CompositeModelRoute) error {
|
|
return nil
|
|
}
|
|
|
|
func (s compositeRouteRepoStub) Delete(ctx context.Context, id int64) error {
|
|
return nil
|
|
}
|
|
|
|
func (s compositeRouteRepoStub) DeleteByGroup(ctx context.Context, groupID int64) error {
|
|
return nil
|
|
}
|
|
|
|
func TestCompositeTargetPlatformMiddlewareResolvesModelAndRestoresBody(t *testing.T) {
|
|
gin.SetMode(gin.TestMode)
|
|
router := gin.New()
|
|
router.Use(gin.HandlerFunc(servermiddleware.APIKeyAuthMiddleware(func(c *gin.Context) {
|
|
groupID := int64(1)
|
|
c.Set(string(servermiddleware.ContextKeyAPIKey), &service.APIKey{
|
|
GroupID: &groupID,
|
|
Group: &service.Group{Platform: service.PlatformComposite},
|
|
})
|
|
c.Next()
|
|
})))
|
|
router.Use(compositeTargetPlatformMiddleware(nil))
|
|
router.POST("/", func(c *gin.Context) {
|
|
platform, ok := service.ResolvedTargetPlatformFromContext(c.Request.Context())
|
|
require.True(t, ok)
|
|
require.Equal(t, service.PlatformOpenAI, platform)
|
|
|
|
body, err := io.ReadAll(c.Request.Body)
|
|
require.NoError(t, err)
|
|
require.JSONEq(t, `{"model":"gpt-5"}`, string(body))
|
|
c.Status(http.StatusNoContent)
|
|
})
|
|
|
|
req := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(`{"model":"gpt-5"}`))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
w := httptest.NewRecorder()
|
|
|
|
router.ServeHTTP(w, req)
|
|
|
|
require.Equal(t, http.StatusNoContent, w.Code)
|
|
}
|
|
|
|
func TestCompositeTargetPlatformMiddlewareUsesExplicitRouteAndRewritesBody(t *testing.T) {
|
|
gin.SetMode(gin.TestMode)
|
|
router := gin.New()
|
|
resolver := service.NewCompositeRouteResolver(compositeRouteRepoStub{
|
|
routes: []service.CompositeModelRoute{
|
|
{
|
|
ID: 1,
|
|
GroupID: 1,
|
|
PublicModel: "openrouter/gpt-5",
|
|
MatchType: service.CompositeRouteMatchExact,
|
|
TargetPlatform: service.PlatformOpenAI,
|
|
UpstreamModel: "gpt-5",
|
|
Endpoint: service.CompositeRouteEndpointAny,
|
|
Priority: 100,
|
|
Enabled: true,
|
|
},
|
|
},
|
|
})
|
|
router.Use(gin.HandlerFunc(servermiddleware.APIKeyAuthMiddleware(func(c *gin.Context) {
|
|
groupID := int64(1)
|
|
c.Set(string(servermiddleware.ContextKeyAPIKey), &service.APIKey{
|
|
GroupID: &groupID,
|
|
Group: &service.Group{ID: groupID, Platform: service.PlatformComposite},
|
|
})
|
|
c.Next()
|
|
})))
|
|
router.Use(compositeTargetPlatformMiddleware(resolver))
|
|
router.POST("/v1/chat/completions", func(c *gin.Context) {
|
|
platform, ok := service.ResolvedTargetPlatformFromContext(c.Request.Context())
|
|
require.True(t, ok)
|
|
require.Equal(t, service.PlatformOpenAI, platform)
|
|
|
|
upstreamModel, ok := service.ResolvedUpstreamModelFromContext(c.Request.Context())
|
|
require.True(t, ok)
|
|
require.Equal(t, "gpt-5", upstreamModel)
|
|
|
|
body, err := io.ReadAll(c.Request.Body)
|
|
require.NoError(t, err)
|
|
require.JSONEq(t, `{"model":"gpt-5","messages":[]}`, string(body))
|
|
c.Status(http.StatusNoContent)
|
|
})
|
|
|
|
req := httptest.NewRequest(http.MethodPost, "/v1/chat/completions", strings.NewReader(`{"model":"openrouter/gpt-5","messages":[]}`))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
w := httptest.NewRecorder()
|
|
|
|
router.ServeHTTP(w, req)
|
|
|
|
require.Equal(t, http.StatusNoContent, w.Code)
|
|
}
|
|
|
|
func TestCompositeTargetPlatformMiddlewareRewritesNestedLiveModel(t *testing.T) {
|
|
gin.SetMode(gin.TestMode)
|
|
router := gin.New()
|
|
resolver := service.NewCompositeRouteResolver(compositeRouteRepoStub{
|
|
routes: []service.CompositeModelRoute{
|
|
{
|
|
ID: 1,
|
|
GroupID: 1,
|
|
PublicModel: "live-alias",
|
|
MatchType: service.CompositeRouteMatchExact,
|
|
TargetPlatform: service.PlatformOpenAI,
|
|
UpstreamModel: "gpt-live",
|
|
Endpoint: service.CompositeRouteEndpointAny,
|
|
Priority: 100,
|
|
Enabled: true,
|
|
},
|
|
},
|
|
})
|
|
router.Use(gin.HandlerFunc(servermiddleware.APIKeyAuthMiddleware(func(c *gin.Context) {
|
|
groupID := int64(1)
|
|
c.Set(string(servermiddleware.ContextKeyAPIKey), &service.APIKey{
|
|
GroupID: &groupID,
|
|
Group: &service.Group{ID: groupID, Platform: service.PlatformComposite},
|
|
})
|
|
c.Next()
|
|
})))
|
|
router.Use(compositeTargetPlatformMiddleware(resolver))
|
|
router.POST("/backend-api/codex/realtime/calls", func(c *gin.Context) {
|
|
platform, ok := service.ResolvedTargetPlatformFromContext(c.Request.Context())
|
|
require.True(t, ok)
|
|
require.Equal(t, service.PlatformOpenAI, platform)
|
|
|
|
body, err := io.ReadAll(c.Request.Body)
|
|
require.NoError(t, err)
|
|
require.JSONEq(t, `{"session":{"model":"gpt-live"},"sdp":"v=0"}`, string(body))
|
|
c.Status(http.StatusNoContent)
|
|
})
|
|
|
|
req := httptest.NewRequest(
|
|
http.MethodPost,
|
|
"/backend-api/codex/realtime/calls",
|
|
strings.NewReader(`{"session":{"model":"live-alias"},"sdp":"v=0"}`),
|
|
)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
w := httptest.NewRecorder()
|
|
|
|
router.ServeHTTP(w, req)
|
|
|
|
require.Equal(t, http.StatusNoContent, w.Code)
|
|
}
|
|
|
|
// Scenario: 回归 —— openai OAuth 与 deepseek API Key 同时映射 gpt-6-astra 时，
|
|
// 请求必须在路由层被拒绝，不能落到默认 Anthropic handler 后再按模型名猜平台。
|
|
// 仅 API Key 的跨平台歧义保持原行为（放行且不解析平台）。
|
|
func TestCompositeTargetPlatformMiddlewareRejectsOnlyOAuthAmbiguousOwnership(t *testing.T) {
|
|
gin.SetMode(gin.TestMode)
|
|
for _, tc := range []struct {
|
|
name string
|
|
oauthClaimed bool
|
|
wantStatus int
|
|
}{
|
|
{name: "oauth claimant", oauthClaimed: true, wantStatus: http.StatusBadRequest},
|
|
{name: "apikey only", oauthClaimed: false, wantStatus: http.StatusNoContent},
|
|
} {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
resolver := service.NewCompositeRouteResolver(nil)
|
|
resolver.SetModelOwnershipResolver(func(context.Context, int64, string) (service.CompositeModelOwnership, error) {
|
|
return service.CompositeModelOwnership{Ambiguous: true, OpenAIGatewayOAuthClaimed: tc.oauthClaimed}, nil
|
|
})
|
|
router := gin.New()
|
|
router.Use(gin.HandlerFunc(servermiddleware.APIKeyAuthMiddleware(func(c *gin.Context) {
|
|
groupID := int64(8)
|
|
c.Set(string(servermiddleware.ContextKeyAPIKey), &service.APIKey{
|
|
GroupID: &groupID,
|
|
Group: &service.Group{ID: groupID, Platform: service.PlatformComposite},
|
|
})
|
|
c.Next()
|
|
})))
|
|
router.Use(compositeTargetPlatformMiddleware(resolver))
|
|
router.POST("/v1/responses", func(c *gin.Context) {
|
|
_, resolved := service.ResolvedTargetPlatformFromContext(c.Request.Context())
|
|
require.False(t, resolved)
|
|
c.Status(http.StatusNoContent)
|
|
})
|
|
|
|
req := httptest.NewRequest(http.MethodPost, "/v1/responses", strings.NewReader(`{"model":"gpt-6-astra"}`))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
w := httptest.NewRecorder()
|
|
router.ServeHTTP(w, req)
|
|
|
|
require.Equal(t, tc.wantStatus, w.Code)
|
|
if tc.oauthClaimed {
|
|
require.Contains(t, w.Body.String(), "explicit composite route")
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCompositeRequestModelFromMultipartLiveSession(t *testing.T) {
|
|
var body bytes.Buffer
|
|
writer := multipart.NewWriter(&body)
|
|
require.NoError(t, writer.WriteField("sdp", "v=0"))
|
|
require.NoError(t, writer.WriteField("session", `{"model":"live-alias"}`))
|
|
require.NoError(t, writer.Close())
|
|
|
|
require.Equal(t, "live-alias", requestmodel.FromBody(writer.FormDataContentType(), body.Bytes()))
|
|
}
|
|
|
|
func TestCompositeCodexControlPathsUseResponsesRoutes(t *testing.T) {
|
|
for _, path := range []string{
|
|
"/v1/alpha/search",
|
|
"/backend-api/codex/alpha/search",
|
|
"/v1/live",
|
|
"/backend-api/codex/realtime/calls",
|
|
} {
|
|
require.Equal(t, service.CompositeRouteEndpointResponses, compositeRouteEndpointForPath(path), "path=%s", path)
|
|
}
|
|
}
|
|
|
|
func TestCompositeTargetPlatformMiddlewareUsesExplicitRouteForMultipartImages(t *testing.T) {
|
|
gin.SetMode(gin.TestMode)
|
|
router := gin.New()
|
|
resolver := service.NewCompositeRouteResolver(compositeRouteRepoStub{
|
|
routes: []service.CompositeModelRoute{
|
|
{
|
|
ID: 1,
|
|
GroupID: 1,
|
|
PublicModel: "image-alias",
|
|
MatchType: service.CompositeRouteMatchExact,
|
|
TargetPlatform: service.PlatformOpenAI,
|
|
UpstreamModel: "gpt-image-1",
|
|
Endpoint: service.CompositeRouteEndpointImages,
|
|
Priority: 100,
|
|
Enabled: true,
|
|
},
|
|
},
|
|
})
|
|
router.Use(gin.HandlerFunc(servermiddleware.APIKeyAuthMiddleware(func(c *gin.Context) {
|
|
groupID := int64(1)
|
|
c.Set(string(servermiddleware.ContextKeyAPIKey), &service.APIKey{
|
|
GroupID: &groupID,
|
|
Group: &service.Group{ID: groupID, Platform: service.PlatformComposite},
|
|
})
|
|
c.Next()
|
|
})))
|
|
router.Use(compositeTargetPlatformMiddleware(resolver))
|
|
router.POST("/v1/images/edits", func(c *gin.Context) {
|
|
platform, ok := service.ResolvedTargetPlatformFromContext(c.Request.Context())
|
|
require.True(t, ok)
|
|
require.Equal(t, service.PlatformOpenAI, platform)
|
|
|
|
upstreamModel, ok := service.ResolvedUpstreamModelFromContext(c.Request.Context())
|
|
require.True(t, ok)
|
|
require.Equal(t, "gpt-image-1", upstreamModel)
|
|
|
|
publicModel, ok := service.RequestedPublicModelFromContext(c.Request.Context())
|
|
require.True(t, ok)
|
|
require.Equal(t, "image-alias", publicModel)
|
|
|
|
body, err := io.ReadAll(c.Request.Body)
|
|
require.NoError(t, err)
|
|
require.Contains(t, string(body), "image-alias")
|
|
c.Status(http.StatusNoContent)
|
|
})
|
|
|
|
var body bytes.Buffer
|
|
writer := multipart.NewWriter(&body)
|
|
require.NoError(t, writer.WriteField("model", "image-alias"))
|
|
require.NoError(t, writer.WriteField("prompt", "draw"))
|
|
require.NoError(t, writer.Close())
|
|
|
|
req := httptest.NewRequest(http.MethodPost, "/v1/images/edits", bytes.NewReader(body.Bytes()))
|
|
req.Header.Set("Content-Type", writer.FormDataContentType())
|
|
w := httptest.NewRecorder()
|
|
|
|
router.ServeHTTP(w, req)
|
|
|
|
require.Equal(t, http.StatusNoContent, w.Code)
|
|
}
|
|
|
|
func TestCompositeGeminiTargetPlatformMiddlewareUsesPathRoute(t *testing.T) {
|
|
gin.SetMode(gin.TestMode)
|
|
router := gin.New()
|
|
resolver := service.NewCompositeRouteResolver(compositeRouteRepoStub{
|
|
routes: []service.CompositeModelRoute{
|
|
{
|
|
ID: 1,
|
|
GroupID: 1,
|
|
PublicModel: "openrouter/gemini-pro",
|
|
MatchType: service.CompositeRouteMatchExact,
|
|
TargetPlatform: service.PlatformGemini,
|
|
UpstreamModel: "gemini-2.5-pro",
|
|
Endpoint: service.CompositeRouteEndpointGemini,
|
|
Priority: 100,
|
|
Enabled: true,
|
|
},
|
|
},
|
|
})
|
|
router.Use(gin.HandlerFunc(servermiddleware.APIKeyAuthMiddleware(func(c *gin.Context) {
|
|
groupID := int64(1)
|
|
c.Set(string(servermiddleware.ContextKeyAPIKey), &service.APIKey{
|
|
GroupID: &groupID,
|
|
Group: &service.Group{ID: groupID, Platform: service.PlatformComposite},
|
|
})
|
|
c.Next()
|
|
})))
|
|
router.Use(compositeGeminiTargetPlatformMiddleware(resolver))
|
|
router.POST("/v1beta/models/*modelAction", func(c *gin.Context) {
|
|
platform, ok := service.ResolvedTargetPlatformFromContext(c.Request.Context())
|
|
require.True(t, ok)
|
|
require.Equal(t, service.PlatformGemini, platform)
|
|
|
|
upstreamModel, ok := service.ResolvedUpstreamModelFromContext(c.Request.Context())
|
|
require.True(t, ok)
|
|
require.Equal(t, "gemini-2.5-pro", upstreamModel)
|
|
c.Status(http.StatusNoContent)
|
|
})
|
|
|
|
req := httptest.NewRequest(http.MethodPost, "/v1beta/models/openrouter/gemini-pro:generateContent", strings.NewReader(`{"contents":[]}`))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
w := httptest.NewRecorder()
|
|
|
|
router.ServeHTTP(w, req)
|
|
|
|
require.Equal(t, http.StatusNoContent, w.Code)
|
|
}
|
|
|
|
// Live 入口顶层 model 与 session.model 不一致时，合成路由必须按 session.model
|
|
// 分发与改写（与白名单准入、Live handler 一致），不得命中顶层别名的映射并把
|
|
// session 模型覆盖为别名上游。
|
|
func TestCompositeLiveRouteDispatchesBySessionModelNotTopLevelAlias(t *testing.T) {
|
|
gin.SetMode(gin.TestMode)
|
|
router := gin.New()
|
|
resolver := service.NewCompositeRouteResolver(compositeRouteRepoStub{
|
|
routes: []service.CompositeModelRoute{
|
|
{
|
|
ID: 1,
|
|
GroupID: 1,
|
|
PublicModel: "live-alias",
|
|
MatchType: service.CompositeRouteMatchExact,
|
|
TargetPlatform: service.PlatformOpenAI,
|
|
UpstreamModel: "gpt-alias-upstream",
|
|
Endpoint: service.CompositeRouteEndpointAny,
|
|
Priority: 100,
|
|
Enabled: true,
|
|
},
|
|
},
|
|
})
|
|
router.Use(gin.HandlerFunc(servermiddleware.APIKeyAuthMiddleware(func(c *gin.Context) {
|
|
groupID := int64(1)
|
|
c.Set(string(servermiddleware.ContextKeyAPIKey), &service.APIKey{
|
|
GroupID: &groupID,
|
|
Group: &service.Group{ID: groupID, Platform: service.PlatformComposite},
|
|
})
|
|
c.Next()
|
|
})))
|
|
router.Use(compositeTargetPlatformMiddleware(resolver))
|
|
router.POST("/backend-api/codex/realtime/calls", func(c *gin.Context) {
|
|
upstream, ok := service.ResolvedUpstreamModelFromContext(c.Request.Context())
|
|
require.True(t, ok)
|
|
require.Equal(t, "gpt-realtime-1", upstream,
|
|
"Live dispatch must resolve the session model, never the top-level alias upstream")
|
|
body, err := io.ReadAll(c.Request.Body)
|
|
require.NoError(t, err)
|
|
require.JSONEq(t, `{"model":"live-alias","session":{"model":"gpt-realtime-1"},"sdp":"v=0"}`, string(body),
|
|
"session.model must stay untouched when dispatch resolves by session model")
|
|
c.Status(http.StatusNoContent)
|
|
})
|
|
|
|
req := httptest.NewRequest(
|
|
http.MethodPost,
|
|
"/backend-api/codex/realtime/calls",
|
|
strings.NewReader(`{"model":"live-alias","session":{"model":"gpt-realtime-1"},"sdp":"v=0"}`),
|
|
)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
w := httptest.NewRecorder()
|
|
|
|
router.ServeHTTP(w, req)
|
|
|
|
require.Equal(t, http.StatusNoContent, w.Code)
|
|
}
|