mirror of
https://github.com/router-for-me/CLIProxyAPI.git
synced 2026-11-17 07:08:01 +08:00
- Implement core Muse Code relay handler, origin resolution, header/query sanitization, credential selection/preparation, 401 refresh, and bounded failover in internal/client/musecode. - Register thin /muse-code routes, safe-mode proxy guarding, and request-ID logging prefixes in internal/api and internal/logging. - Isolate model-less credential-scoped cooldowns, preserve execution sequence ordering, and honor request-scoped error rules across sdk/cliproxy/auth. Closes: #7508
760 lines
28 KiB
Go
760 lines
28 KiB
Go
package api
|
|
|
|
import (
|
|
"bufio"
|
|
"context"
|
|
"fmt"
|
|
"io"
|
|
"net"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"strconv"
|
|
"strings"
|
|
"sync"
|
|
"sync/atomic"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/MoeForge/moego/ojson"
|
|
"github.com/gin-gonic/gin"
|
|
proxyconfig "github.com/router-for-me/CLIProxyAPI/v8/internal/config"
|
|
"github.com/router-for-me/CLIProxyAPI/v8/internal/home"
|
|
"github.com/router-for-me/CLIProxyAPI/v8/internal/registry"
|
|
"github.com/router-for-me/CLIProxyAPI/v8/internal/runtime/executor"
|
|
"github.com/router-for-me/CLIProxyAPI/v8/sdk/cliproxy/auth"
|
|
sdkconfig "github.com/router-for-me/CLIProxyAPI/v8/sdk/config"
|
|
"github.com/router-for-me/CLIProxyAPI/v8/sdk/pluginapi"
|
|
)
|
|
|
|
func registeredRouteEngine(t *testing.T, server *Server, method, path string) *gin.Engine {
|
|
t.Helper()
|
|
engine := gin.New()
|
|
found := false
|
|
for _, route := range server.engine.Routes() {
|
|
if route.Method == method && route.Path == path {
|
|
engine.Handle(method, path, route.HandlerFunc)
|
|
found = true
|
|
break
|
|
}
|
|
}
|
|
if !found {
|
|
t.Fatalf("route %s %s not registered on server engine", method, path)
|
|
}
|
|
return engine
|
|
}
|
|
|
|
func newReadyHomeCatalogClient(t *testing.T, initialPayload string) (*home.Client, func(string), func() string) {
|
|
t.Helper()
|
|
listener, errListen := net.Listen("tcp", "127.0.0.1:0")
|
|
if errListen != nil {
|
|
t.Fatalf("listen: %v", errListen)
|
|
}
|
|
|
|
var payloadVal atomic.Value
|
|
payloadVal.Store(initialPayload)
|
|
var lastModelsReq atomic.Value
|
|
lastModelsReq.Store("")
|
|
|
|
done := make(chan struct{})
|
|
var connections sync.WaitGroup
|
|
go func() {
|
|
defer close(done)
|
|
for {
|
|
conn, errAccept := listener.Accept()
|
|
if errAccept != nil {
|
|
return
|
|
}
|
|
connections.Add(1)
|
|
go func() {
|
|
defer connections.Done()
|
|
defer func() {
|
|
_ = conn.Close()
|
|
}()
|
|
reader := bufio.NewReader(conn)
|
|
for {
|
|
args, errRead := readRESPArrayOfBulkStrings(reader)
|
|
if errRead != nil || len(args) == 0 {
|
|
return
|
|
}
|
|
cmd := strings.ToUpper(string(args[0]))
|
|
var response string
|
|
switch cmd {
|
|
case "HELLO":
|
|
response = "-ERR unknown command 'hello'\r\n"
|
|
case "PING":
|
|
if len(args) >= 2 {
|
|
msg := string(args[1])
|
|
response = fmt.Sprintf("$%d\r\n%s\r\n", len(msg), msg)
|
|
} else {
|
|
response = "+PONG\r\n"
|
|
}
|
|
case "SUBSCRIBE":
|
|
ch := "config"
|
|
if len(args) >= 2 {
|
|
ch = string(args[1])
|
|
}
|
|
response = fmt.Sprintf("*3\r\n$9\r\nsubscribe\r\n$%d\r\n%s\r\n:1\r\n", len(ch), ch)
|
|
case "GET":
|
|
if len(args) == 2 && ojson.GetBytesNoCopy(args[1], "type").String() == "models" {
|
|
lastModelsReq.Store(string(args[1]))
|
|
p, _ := payloadVal.Load().(string)
|
|
response = fmt.Sprintf("$%d\r\n%s\r\n", len(p), p)
|
|
} else {
|
|
response = "$2\r\n{}\r\n"
|
|
}
|
|
default:
|
|
response = "+OK\r\n"
|
|
}
|
|
if _, errWrite := io.WriteString(conn, response); errWrite != nil {
|
|
return
|
|
}
|
|
}
|
|
}()
|
|
}
|
|
}()
|
|
|
|
host, portText, errSplit := net.SplitHostPort(listener.Addr().String())
|
|
if errSplit != nil {
|
|
t.Fatalf("split Home test address: %v", errSplit)
|
|
}
|
|
port, errAtoi := strconv.Atoi(portText)
|
|
if errAtoi != nil {
|
|
t.Fatalf("parse Home test port: %v", errAtoi)
|
|
}
|
|
|
|
client := home.New(proxyconfig.HomeConfig{Enabled: true, Host: host, Port: port, DisableClusterDiscovery: true})
|
|
subCtx, cancelSub := context.WithCancel(context.Background())
|
|
ready := make(chan struct{})
|
|
var readyOnce sync.Once
|
|
subDone := make(chan struct{})
|
|
go func() {
|
|
defer close(subDone)
|
|
_ = client.RunConfigSubscriberLifetime(subCtx, func([]byte) error {
|
|
return nil
|
|
}, func() {
|
|
readyOnce.Do(func() { close(ready) })
|
|
})
|
|
}()
|
|
|
|
t.Cleanup(func() {
|
|
cancelSub()
|
|
client.Close()
|
|
_ = listener.Close()
|
|
<-subDone
|
|
<-done
|
|
connections.Wait()
|
|
})
|
|
|
|
select {
|
|
case <-ready:
|
|
case <-time.After(3 * time.Second):
|
|
t.Fatal("ready Home catalog client did not establish heartbeat")
|
|
}
|
|
|
|
return client, func(next string) { payloadVal.Store(next) }, func() string {
|
|
v, _ := lastModelsReq.Load().(string)
|
|
return v
|
|
}
|
|
}
|
|
|
|
func parseAPIMuseCodeEntriesByID(t *testing.T, raw []byte) map[string]ojson.Result {
|
|
t.Helper()
|
|
root := ojson.ParseBytes(raw)
|
|
data := root.Get("data")
|
|
if !data.IsArray() {
|
|
t.Fatalf("expected data array in response, got %s", string(raw))
|
|
}
|
|
entries := make(map[string]ojson.Result)
|
|
data.ForEach(func(_, item ojson.Result) bool {
|
|
entries[item.Get("id").String()] = item
|
|
return true
|
|
})
|
|
return entries
|
|
}
|
|
|
|
func TestMuseCodeClientEndpointsRelayToMetaOrigin(t *testing.T) {
|
|
var seenMethod, seenPath, seenQuery, seenAuth, seenBody string
|
|
upstream := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
seenMethod = r.Method
|
|
seenPath = r.URL.Path
|
|
seenQuery = r.URL.RawQuery
|
|
seenAuth = r.Header.Get("Authorization")
|
|
raw, _ := io.ReadAll(r.Body)
|
|
seenBody = string(raw)
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(http.StatusOK)
|
|
_, _ = io.WriteString(w, `{"ok":true}`)
|
|
}))
|
|
defer upstream.Close()
|
|
|
|
server := newTestServer(t)
|
|
server.handlers.AuthManager.RegisterExecutor(executor.NewMetaExecutor(server.getConfig()))
|
|
cred := &auth.Auth{
|
|
ID: "meta-muse-code-relay",
|
|
Provider: "meta",
|
|
Status: auth.StatusActive,
|
|
Attributes: map[string]string{
|
|
"api_key": "meta-upstream-secret",
|
|
"base_url": upstream.URL + "/v1",
|
|
},
|
|
}
|
|
registry.GetGlobalRegistry().RegisterClient(cred.ID, "meta", []*registry.ModelInfo{{ID: "muse-wonder-full-1.0"}})
|
|
t.Cleanup(func() {
|
|
registry.GetGlobalRegistry().UnregisterClient(cred.ID)
|
|
})
|
|
if _, errRegister := server.handlers.AuthManager.Register(t.Context(), cred); errRegister != nil {
|
|
t.Fatalf("register Meta credential: %v", errRegister)
|
|
}
|
|
|
|
for _, tc := range []struct {
|
|
name string
|
|
method string
|
|
target string
|
|
body string
|
|
wantPath string
|
|
wantQuery string
|
|
}{
|
|
{
|
|
name: "config",
|
|
method: http.MethodGet,
|
|
target: "/muse-code/config?channel=public",
|
|
wantPath: "/muse-code/config",
|
|
wantQuery: "channel=public",
|
|
},
|
|
{
|
|
name: "search",
|
|
method: http.MethodPost,
|
|
target: "/muse-code/search",
|
|
body: `{"query":"golang"}`,
|
|
wantPath: "/muse-code/search",
|
|
},
|
|
{
|
|
name: "browser_open",
|
|
method: http.MethodPost,
|
|
target: "/muse-code/browser_open",
|
|
body: `{"url":"https://example.com"}`,
|
|
wantPath: "/muse-code/browser_open",
|
|
},
|
|
} {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
seenMethod, seenPath, seenQuery, seenAuth, seenBody = "", "", "", "", ""
|
|
req := httptest.NewRequest(tc.method, tc.target, strings.NewReader(tc.body))
|
|
req.Header.Set("Authorization", "Bearer test-key")
|
|
if tc.body != "" {
|
|
req.Header.Set("Content-Type", "application/json")
|
|
}
|
|
rec := httptest.NewRecorder()
|
|
server.engine.ServeHTTP(rec, req)
|
|
|
|
if rec.Code != http.StatusOK {
|
|
t.Fatalf("status = %d, want 200; body=%q", rec.Code, rec.Body.String())
|
|
}
|
|
if seenMethod != tc.method || seenPath != tc.wantPath || seenQuery != tc.wantQuery {
|
|
t.Fatalf("upstream got %s %s?%s, want %s %s?%s", seenMethod, seenPath, seenQuery, tc.method, tc.wantPath, tc.wantQuery)
|
|
}
|
|
if seenAuth != "Bearer meta-upstream-secret" {
|
|
t.Fatalf("upstream Authorization = %q, want Bearer meta-upstream-secret", seenAuth)
|
|
}
|
|
if tc.body != "" && seenBody != tc.body {
|
|
t.Fatalf("upstream body = %q, want %q", seenBody, tc.body)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestMuseCodeModelsUsesFullCPACatalogWithoutUpstreamRelay(t *testing.T) {
|
|
var upstreamCalls atomic.Int32
|
|
upstream := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
upstreamCalls.Add(1)
|
|
w.WriteHeader(http.StatusInternalServerError)
|
|
}))
|
|
defer upstream.Close()
|
|
|
|
server := newTestServer(t)
|
|
server.handlers.AuthManager.RegisterExecutor(executor.NewMetaExecutor(server.getConfig()))
|
|
cred := &auth.Auth{
|
|
ID: "meta-muse-code-models-local",
|
|
Provider: "meta",
|
|
Status: auth.StatusActive,
|
|
Attributes: map[string]string{
|
|
"api_key": "meta-upstream-secret",
|
|
"base_url": upstream.URL + "/v1",
|
|
},
|
|
}
|
|
registry.GetGlobalRegistry().RegisterClient(cred.ID, "meta", []*registry.ModelInfo{
|
|
{ID: "muse-wonder-1.0", DisplayName: "Muse Wonder 1.0", OwnedBy: "meta", Type: "meta", ContextLength: 1007997, MaxCompletionTokens: 128000, Thinking: ®istry.ThinkingSupport{Levels: []string{"minimal", "low", "medium", "high", "xhigh", "max"}}, SupportedInputModalities: []string{"text", "image", "video"}, SupportedOutputModalities: []string{"text"}},
|
|
{ID: "muse-spark-1.3", DisplayName: "Muse Spark 1.3", OwnedBy: "meta", Type: "meta", ContextLength: 1007997, MaxCompletionTokens: 128000, Thinking: ®istry.ThinkingSupport{Levels: []string{"minimal", "low", "medium", "high", "xhigh", "max"}}, SupportedInputModalities: []string{"text", "image", "video"}, SupportedOutputModalities: []string{"text"}},
|
|
{ID: "muse-image-1.0", DisplayName: "Muse Image 1.0", OwnedBy: "meta", Type: "meta", SupportedInputModalities: []string{"text", "image"}, SupportedOutputModalities: []string{"image"}},
|
|
})
|
|
registry.GetGlobalRegistry().RegisterClient("codex-muse-code-models-local", "codex", []*registry.ModelInfo{
|
|
{ID: "gpt-6.1-sol", DisplayName: "GPT 6.1 Sol", OwnedBy: "openai", Type: "codex", ContextLength: 500000, MaxCompletionTokens: 128000, Thinking: ®istry.ThinkingSupport{Levels: []string{"low", "medium", "high", "xhigh"}}, SupportedInputModalities: []string{"text", "image"}, SupportedOutputModalities: []string{"text"}},
|
|
})
|
|
registry.GetGlobalRegistry().RegisterClient("claude-muse-code-models-local", "claude", []*registry.ModelInfo{
|
|
{ID: "claude-sonnet-4-5-20250929", DisplayName: "Claude 4.5 Sonnet", OwnedBy: "anthropic", Type: "claude", ContextLength: 200000, MaxCompletionTokens: 64000, Thinking: ®istry.ThinkingSupport{Min: 1024, Max: 128000, ZeroAllowed: true}, SupportedInputModalities: []string{"text", "image"}, SupportedOutputModalities: []string{"text"}},
|
|
})
|
|
t.Cleanup(func() {
|
|
registry.GetGlobalRegistry().UnregisterClient(cred.ID)
|
|
registry.GetGlobalRegistry().UnregisterClient("codex-muse-code-models-local")
|
|
registry.GetGlobalRegistry().UnregisterClient("claude-muse-code-models-local")
|
|
})
|
|
if _, errRegister := server.handlers.AuthManager.Register(t.Context(), cred); errRegister != nil {
|
|
t.Fatalf("register Meta credential: %v", errRegister)
|
|
}
|
|
|
|
req := httptest.NewRequest(http.MethodGet, "/muse-code/models?channel=public", nil)
|
|
req.Header.Set("Authorization", "Bearer test-key")
|
|
rec := httptest.NewRecorder()
|
|
server.engine.ServeHTTP(rec, req)
|
|
|
|
if rec.Code != http.StatusOK {
|
|
t.Fatalf("status = %d, want 200; body=%s", rec.Code, rec.Body.String())
|
|
}
|
|
if upstreamCalls.Load() != 0 {
|
|
t.Fatalf("/muse-code/models must not call Meta upstream; calls=%d", upstreamCalls.Load())
|
|
}
|
|
if ojson.GetBytesNoCopy(rec.Body.Bytes(), "object").String() != "list" {
|
|
t.Fatalf("object = %q, want list", ojson.GetBytesNoCopy(rec.Body.Bytes(), "object").String())
|
|
}
|
|
|
|
entries := parseAPIMuseCodeEntriesByID(t, rec.Body.Bytes())
|
|
for _, wantID := range []string{"muse-wonder-1.0", "muse-spark-1.3", "muse-image-1.0", "gpt-6.1-sol", "claude-sonnet-4-5-20250929"} {
|
|
if _, ok := entries[wantID]; !ok {
|
|
t.Fatalf("missing expected model %q in /muse-code/models response: %s", wantID, rec.Body.String())
|
|
}
|
|
}
|
|
if got := entries["muse-wonder-1.0"].Get("metadata.muse-code.background_agent_model").String(); got != "muse-spark-1.3" {
|
|
t.Fatalf("muse-wonder-1.0 background_agent_model = %q, want muse-spark-1.3", got)
|
|
}
|
|
museImg := entries["muse-image-1.0"].Get("metadata.muse-code")
|
|
if !museImg.Get("is_hidden").Bool() || museImg.Get("tool_call").Bool() {
|
|
t.Fatalf("muse-image-1.0 expected hidden with tool_call=false: %s", museImg.Raw)
|
|
}
|
|
if len(entries["claude-sonnet-4-5-20250929"].Get("metadata.muse-code.variants").Map()) == 0 {
|
|
t.Fatalf("claude-sonnet-4-5-20250929 should advertise derived reasoning variants")
|
|
}
|
|
}
|
|
|
|
func TestHomeCodexBucketsAndPrecedenceForOAuthSettings(t *testing.T) {
|
|
cfg := &proxyconfig.Config{
|
|
OAuthSettings: map[string][]proxyconfig.OAuthModelSetting{
|
|
"codex": {
|
|
{Name: "shared-model", MaxContextLength: 524288},
|
|
{Name: "upstream-sol", Alias: "public-sol", MaxContextLength: 750000},
|
|
},
|
|
"claude": {
|
|
{Name: "shared-model", MaxContextLength: 200000},
|
|
{Name: "upstream-sol", Alias: "public-sol", MaxContextLength: 300000},
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tc := range []struct {
|
|
name string
|
|
entry homeModelEntry
|
|
wantLimit int
|
|
}{
|
|
{
|
|
name: "codex-free bucket matches codex OAuthSettings",
|
|
entry: homeModelEntry{
|
|
id: "shared-model",
|
|
providers: []string{"codex-free"},
|
|
},
|
|
wantLimit: 524288,
|
|
},
|
|
{
|
|
name: "codex-plus bucket matches codex OAuthSettings",
|
|
entry: homeModelEntry{
|
|
id: "shared-model",
|
|
providers: []string{"codex-plus"},
|
|
},
|
|
wantLimit: 524288,
|
|
},
|
|
{
|
|
name: "codex-team bucket matches codex OAuthSettings",
|
|
entry: homeModelEntry{
|
|
id: "shared-model",
|
|
providers: []string{"codex-team"},
|
|
},
|
|
wantLimit: 524288,
|
|
},
|
|
{
|
|
name: "codex-pro bucket matches codex OAuthSettings",
|
|
entry: homeModelEntry{
|
|
id: "shared-model",
|
|
providers: []string{"codex-pro"},
|
|
},
|
|
wantLimit: 524288,
|
|
},
|
|
{
|
|
name: "multi-provider claude + codex-free prefers codex",
|
|
entry: homeModelEntry{
|
|
id: "shared-model",
|
|
providers: []string{"claude", "codex-free"},
|
|
routes: []homeModelRoute{
|
|
{provider: "claude"},
|
|
{provider: "codex-free"},
|
|
},
|
|
},
|
|
wantLimit: 524288,
|
|
},
|
|
{
|
|
name: "multi-provider alias claude + codex-team prefers codex",
|
|
entry: homeModelEntry{
|
|
id: "public-sol",
|
|
metadataModelID: "upstream-sol",
|
|
modelName: "upstream-sol",
|
|
providers: []string{"claude", "codex-team"},
|
|
routes: []homeModelRoute{
|
|
{provider: "claude", metadataModelID: "upstream-sol", modelName: "upstream-sol"},
|
|
{provider: "codex-team", metadataModelID: "upstream-sol", modelName: "upstream-sol"},
|
|
},
|
|
},
|
|
wantLimit: 750000,
|
|
},
|
|
{
|
|
name: "claude-only entry uses claude setting",
|
|
entry: homeModelEntry{
|
|
id: "shared-model",
|
|
providers: []string{"claude"},
|
|
routes: []homeModelRoute{{provider: "claude"}},
|
|
},
|
|
wantLimit: 200000,
|
|
},
|
|
} {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
if got := resolveHomeModelMaxContextLength(tc.entry, cfg); got != tc.wantLimit {
|
|
t.Fatalf("resolveHomeModelMaxContextLength = %d, want %d", got, tc.wantLimit)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestMuseCodeModelsSupportsHomeModeOAuthSettingsHotReloadAndPluginInterceptor(t *testing.T) {
|
|
previousHome := home.Current()
|
|
home.ClearCurrent()
|
|
t.Cleanup(func() { home.SetCurrent(previousHome) })
|
|
|
|
localClientID := "local-only-muse-code-isolation"
|
|
registry.GetGlobalRegistry().RegisterClient(localClientID, "openai", []*registry.ModelInfo{{ID: "local-only-secret-model"}})
|
|
t.Cleanup(func() { registry.GetGlobalRegistry().UnregisterClient(localClientID) })
|
|
|
|
// 1. Real server.engine rejects Home request with 503 when Home heartbeat is absent, without leaking local models.
|
|
cfgNoHome := &proxyconfig.Config{
|
|
SDKConfig: sdkconfig.SDKConfig{APIKeys: []string{"test-key"}},
|
|
Home: proxyconfig.HomeConfig{Enabled: true},
|
|
}
|
|
serverNoHome := newTestServerWithConfig(t, cfgNoHome)
|
|
engineReq503 := httptest.NewRequest(http.MethodGet, "/muse-code/models", nil)
|
|
engineReq503.Header.Set("Authorization", "Bearer test-key")
|
|
engineRec503 := httptest.NewRecorder()
|
|
serverNoHome.engine.ServeHTTP(engineRec503, engineReq503)
|
|
if engineRec503.Code != http.StatusServiceUnavailable {
|
|
t.Fatalf("server.engine status without home heartbeat = %d, want 503", engineRec503.Code)
|
|
}
|
|
if strings.Contains(engineRec503.Body.String(), "local-only-secret-model") {
|
|
t.Fatalf("server.engine 503 leaked local-only model: %s", engineRec503.Body.String())
|
|
}
|
|
|
|
routeNoHome := registeredRouteEngine(t, serverNoHome, http.MethodGet, "/muse-code/models")
|
|
req503 := httptest.NewRequest(http.MethodGet, "/muse-code/models", nil)
|
|
req503.Header.Set("Authorization", "Bearer test-key")
|
|
rec503 := httptest.NewRecorder()
|
|
routeNoHome.ServeHTTP(rec503, req503)
|
|
if rec503.Code != http.StatusServiceUnavailable || !strings.Contains(rec503.Body.String(), "home control center unavailable") {
|
|
t.Fatalf("route handler without home client = %d %s, want 503 home control center unavailable", rec503.Code, rec503.Body.String())
|
|
}
|
|
|
|
// 2. Full server.engine middleware chain in healthy Home mode:
|
|
// - codex-free / codex-plus / codex-pro buckets match OAuthSettings["codex"]
|
|
// - cross-route identity isolation (claude id=gpt-6.1-sol name=claude-opus-4-6 + codex-pro id=gpt-6.1-sol name=gpt-6.1-sol -> 272000)
|
|
// - canonical upstream name enrichment without leaking internal fields
|
|
// - explicit empty supportedInputModalities: []
|
|
// - conservative multi-section merge
|
|
// - query parameter forwarding & plugin interceptor
|
|
homePayload := `{
|
|
"codex-free": [{
|
|
"id": "gpt-free-model",
|
|
"name": "gpt-free-model",
|
|
"owned_by": "openai",
|
|
"type": "codex",
|
|
"context_length": 128000,
|
|
"max_completion_tokens": 16384
|
|
}],
|
|
"codex-pro": [{
|
|
"id": "gpt-6.1-sol",
|
|
"name": "gpt-6.1-sol"
|
|
}],
|
|
"codex-plus": [{
|
|
"id": "gpt-plus-alias",
|
|
"name": "gpt-5.6-sol",
|
|
"display_name": "GPT Plus Alias"
|
|
}],
|
|
"claude": [{
|
|
"id": "gpt-6.1-sol",
|
|
"name": "claude-opus-4-6"
|
|
}, {
|
|
"id": "my-claude-alias",
|
|
"name": "claude-opus-4-6",
|
|
"display_name": "Aliased Claude"
|
|
}, {
|
|
"id": "muse-wonder-1.0",
|
|
"owned_by": "meta",
|
|
"type": "meta",
|
|
"supportedInputModalities": [],
|
|
"supportedOutputModalities": ["text"]
|
|
}, {
|
|
"id": "shared-home-model",
|
|
"owned_by": "anthropic",
|
|
"type": "claude",
|
|
"context_length": 400000,
|
|
"max_completion_tokens": 64000,
|
|
"thinking": {"levels": ["low", "medium", "high"]},
|
|
"supportedInputModalities": ["text", "image"],
|
|
"supportedOutputModalities": ["text"]
|
|
}],
|
|
"openai-compat": [{
|
|
"id": "shared-home-model",
|
|
"owned_by": "openai",
|
|
"type": "openai",
|
|
"context_length": 128000,
|
|
"max_completion_tokens": 16384,
|
|
"thinking": {"levels": ["medium", "high"]},
|
|
"supportedInputModalities": ["text"],
|
|
"supportedOutputModalities": ["text"]
|
|
}]
|
|
}`
|
|
homeClient, setHomePayload, getLastModelsReq := newReadyHomeCatalogClient(t, homePayload)
|
|
home.SetCurrent(homeClient)
|
|
|
|
cfgWithHome := &proxyconfig.Config{
|
|
SDKConfig: sdkconfig.SDKConfig{APIKeys: []string{"test-key"}},
|
|
Home: proxyconfig.HomeConfig{Enabled: true},
|
|
OAuthSettings: map[string][]proxyconfig.OAuthModelSetting{
|
|
"codex": {
|
|
{
|
|
Name: "gpt-free-model",
|
|
MaxContextLength: 600000,
|
|
},
|
|
{
|
|
Name: "gpt-5.6-sol",
|
|
MaxContextLength: 750000,
|
|
},
|
|
},
|
|
"claude": {
|
|
{
|
|
Name: "claude-opus-4-6",
|
|
MaxContextLength: 350000,
|
|
},
|
|
},
|
|
},
|
|
}
|
|
server := newTestServerWithConfig(t, cfgWithHome)
|
|
|
|
var intercepted bool
|
|
var capturedFormat string
|
|
server.handlers.SetPluginHost(&mockModelListInterceptorHost{
|
|
interceptResponse: func(_ context.Context, req pluginapi.ResponseInterceptRequest) pluginapi.ResponseInterceptResponse {
|
|
intercepted = true
|
|
capturedFormat = req.SourceFormat
|
|
doc := ojson.NewDoc(req.Body)
|
|
if errSet := doc.Set("muse_intercepted", true); errSet != nil {
|
|
t.Fatalf("set muse_intercepted via ojson.Doc: %v", errSet)
|
|
}
|
|
return pluginapi.ResponseInterceptResponse{
|
|
Headers: req.ResponseHeaders,
|
|
Body: doc.Bytes(),
|
|
}
|
|
},
|
|
})
|
|
|
|
// Unauthorized request still blocked by real auth middleware on server.engine even when Home is healthy.
|
|
unauthRec := httptest.NewRecorder()
|
|
unauthReq := httptest.NewRequest(http.MethodGet, "/muse-code/models", nil)
|
|
unauthReq.Header.Set("Authorization", "Bearer wrong-key")
|
|
server.engine.ServeHTTP(unauthRec, unauthReq)
|
|
if unauthRec.Code != http.StatusUnauthorized {
|
|
t.Fatalf("unauth Home request status = %d, want 401", unauthRec.Code)
|
|
}
|
|
|
|
// Authorized request flows through the full server.engine middleware chain!
|
|
req := httptest.NewRequest(http.MethodGet, "/muse-code/models?channel=public", nil)
|
|
req.Header.Set("Authorization", "Bearer test-key")
|
|
rec := httptest.NewRecorder()
|
|
server.engine.ServeHTTP(rec, req)
|
|
|
|
if rec.Code != http.StatusOK {
|
|
t.Fatalf("status = %d, want 200; body=%s", rec.Code, rec.Body.String())
|
|
}
|
|
if !intercepted || capturedFormat != "openai" {
|
|
t.Fatalf("interceptor not invoked cleanly: intercepted=%v format=%q", intercepted, capturedFormat)
|
|
}
|
|
if strings.Contains(rec.Body.String(), "local-only-secret-model") {
|
|
t.Fatalf("Home response leaked local-only model: %s", rec.Body.String())
|
|
}
|
|
if !ojson.GetBytesNoCopy(rec.Body.Bytes(), "muse_intercepted").Bool() {
|
|
t.Fatalf("response missing plugin interceptor marker: %s", rec.Body.String())
|
|
}
|
|
if lastReq := getLastModelsReq(); !strings.Contains(lastReq, `"channel":"public"`) {
|
|
t.Fatalf("Home GetModels did not receive forwarded query param: %s", lastReq)
|
|
}
|
|
|
|
entries := parseAPIMuseCodeEntriesByID(t, rec.Body.Bytes())
|
|
if len(entries) != 6 {
|
|
t.Fatalf("len(entries) = %d, want 6; body=%s", len(entries), rec.Body.String())
|
|
}
|
|
|
|
// codex-free bucket matches OAuthSettings["codex"].
|
|
if got := entries["gpt-free-model"].Get("metadata.muse-code.limit.context").Int(); got != 600000 {
|
|
t.Fatalf("codex-free gpt-free-model context = %d, want 600000", got)
|
|
}
|
|
// Cross-route identity isolation: claude (id=gpt-6.1-sol, name=claude-opus-4-6, 350k) +
|
|
// codex-pro (id=gpt-6.1-sol, name=gpt-6.1-sol, 272k) MUST cap context conservatively at 272000!
|
|
if got := entries["gpt-6.1-sol"].Get("metadata.muse-code.limit.context").Int(); got != 272000 {
|
|
t.Fatalf("cross-route Home gpt-6.1-sol context = %d, want 272000; entry=%s", got, entries["gpt-6.1-sol"].Raw)
|
|
}
|
|
// codex-plus + canonical name matches OAuthSettings["codex"] ("gpt-5.6-sol") and enriches static metadata.
|
|
plusAlias := entries["gpt-plus-alias"]
|
|
if plusAlias.Get("metadata.muse-code.limit.context").Int() != 750000 || !plusAlias.Get("metadata.muse-code.reasoning").Bool() {
|
|
t.Fatalf("codex-plus canonical name alias failed enrichment/settings: %s", plusAlias.Raw)
|
|
}
|
|
// claude canonical name ("claude-opus-4-6") enriches static metadata and matches OAuthSettings["claude"], without leaking internal keys.
|
|
claudeAlias := entries["my-claude-alias"]
|
|
if claudeAlias.Get("metadata.muse-code.limit.context").Int() != 350000 || !claudeAlias.Get("metadata.muse-code.variants.max").Exists() {
|
|
t.Fatalf("claude canonical name alias failed enrichment/settings: %s", claudeAlias.Raw)
|
|
}
|
|
if claudeAlias.Get("name").Exists() || claudeAlias.Get("MetadataModelID").Exists() {
|
|
t.Fatalf("public response must not expose internal canonical name or MetadataModelID: %s", claudeAlias.Raw)
|
|
}
|
|
// Explicit empty supportedInputModalities: [] in Home does not fall back to static attachment=true.
|
|
if entries["muse-wonder-1.0"].Get("metadata.muse-code.attachment").Bool() {
|
|
t.Fatalf("explicit empty supportedInputModalities in Home must keep attachment=false: %s", entries["muse-wonder-1.0"].Raw)
|
|
}
|
|
// Multi-section Home model merges conservatively across claude + openai-compat.
|
|
shared := entries["shared-home-model"].Get("metadata.muse-code")
|
|
if shared.Get("attachment").Bool() || shared.Get("limit.context").Int() != 128000 || shared.Get("limit.output").Int() != 16384 || shared.Get("variants.low").Exists() || !shared.Get("variants.medium").Exists() {
|
|
t.Fatalf("multi-section Home model did not merge conservatively: %s", shared.Raw)
|
|
}
|
|
|
|
// 3. Home error envelopes and empty Home catalog via full server.engine.
|
|
for _, tc := range []struct {
|
|
name string
|
|
payload string
|
|
wantStatus int
|
|
}{
|
|
{name: "no_credentials", payload: `{"error":{"type":"no_credentials","message":"Missing API key"}}`, wantStatus: http.StatusUnauthorized},
|
|
{name: "internal_error", payload: `{"error":{"type":"internal_error","message":"Home failed"}}`, wantStatus: http.StatusBadGateway},
|
|
{name: "malformed", payload: `{bad}`, wantStatus: http.StatusBadGateway},
|
|
} {
|
|
t.Run("home_error_"+tc.name, func(t *testing.T) {
|
|
setHomePayload(tc.payload)
|
|
errRec := httptest.NewRecorder()
|
|
errReq := httptest.NewRequest(http.MethodGet, "/muse-code/models", nil)
|
|
errReq.Header.Set("Authorization", "Bearer test-key")
|
|
server.engine.ServeHTTP(errRec, errReq)
|
|
if errRec.Code != tc.wantStatus {
|
|
t.Fatalf("%s status = %d, want %d; body=%s", tc.name, errRec.Code, tc.wantStatus, errRec.Body.String())
|
|
}
|
|
})
|
|
}
|
|
|
|
server.handlers.SetPluginHost(nil)
|
|
setHomePayload(`{"openai":[]}`)
|
|
recEmpty := httptest.NewRecorder()
|
|
emptyReq := httptest.NewRequest(http.MethodGet, "/muse-code/models", nil)
|
|
emptyReq.Header.Set("Authorization", "Bearer test-key")
|
|
server.engine.ServeHTTP(recEmpty, emptyReq)
|
|
if recEmpty.Code != http.StatusOK || strings.TrimSpace(recEmpty.Body.String()) != `{"object":"list","data":[]}` {
|
|
t.Fatalf("empty Home catalog got %d %s, want 200 {\"object\":\"list\",\"data\":[]}", recEmpty.Code, recEmpty.Body.String())
|
|
}
|
|
|
|
// 4. Config hot-reload toggling Home.Enabled from false -> true verified via full server.engine.
|
|
reloadServer := newTestServer(t)
|
|
|
|
recLocal := httptest.NewRecorder()
|
|
reqLocal := httptest.NewRequest(http.MethodGet, "/muse-code/models", nil)
|
|
reqLocal.Header.Set("Authorization", "Bearer test-key")
|
|
reloadServer.engine.ServeHTTP(recLocal, reqLocal)
|
|
if recLocal.Code != http.StatusOK || !strings.Contains(recLocal.Body.String(), "local-only-secret-model") {
|
|
t.Fatalf("expected local mode model before reload, got %d %s", recLocal.Code, recLocal.Body.String())
|
|
}
|
|
|
|
setHomePayload(`{"codex-team":[{"id":"reloaded-home-model"}]}`)
|
|
reloadCfg := reloadServer.getConfig().CloneForRuntime()
|
|
reloadCfg.Home.Enabled = true
|
|
reloadServer.UpdateClients(reloadCfg)
|
|
|
|
recReloaded := httptest.NewRecorder()
|
|
reqReloaded := httptest.NewRequest(http.MethodGet, "/muse-code/models", nil)
|
|
reqReloaded.Header.Set("Authorization", "Bearer test-key")
|
|
reloadServer.engine.ServeHTTP(recReloaded, reqReloaded)
|
|
if recReloaded.Code != http.StatusOK {
|
|
t.Fatalf("reloaded Home status = %d, want 200; body=%s", recReloaded.Code, recReloaded.Body.String())
|
|
}
|
|
if strings.Contains(recReloaded.Body.String(), "local-only-secret-model") || !strings.Contains(recReloaded.Body.String(), "reloaded-home-model") {
|
|
t.Fatalf("hot-reload to Home mode did not switch source cleanly: %s", recReloaded.Body.String())
|
|
}
|
|
}
|
|
|
|
func TestMuseCodeRoutesEnforceAuthSafeModeAndDisallowedPaths(t *testing.T) {
|
|
var upstreamCalls atomic.Int32
|
|
upstream := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
upstreamCalls.Add(1)
|
|
w.WriteHeader(http.StatusOK)
|
|
}))
|
|
defer upstream.Close()
|
|
|
|
// 1. Unknown client key returns 401; disallowed /muse-code/key returns 404.
|
|
server := newTestServer(t)
|
|
server.handlers.AuthManager.RegisterExecutor(executor.NewMetaExecutor(server.getConfig()))
|
|
cred := &auth.Auth{
|
|
ID: "meta-server-auth-test",
|
|
Provider: "meta",
|
|
Status: auth.StatusActive,
|
|
Attributes: map[string]string{
|
|
"api_key": "meta-secret",
|
|
"base_url": upstream.URL + "/v1",
|
|
},
|
|
}
|
|
registry.GetGlobalRegistry().RegisterClient(cred.ID, "meta", []*registry.ModelInfo{{ID: "muse-wonder-1.0"}})
|
|
t.Cleanup(func() {
|
|
registry.GetGlobalRegistry().UnregisterClient(cred.ID)
|
|
})
|
|
if _, errRegister := server.handlers.AuthManager.Register(t.Context(), cred); errRegister != nil {
|
|
t.Fatalf("register Meta credential: %v", errRegister)
|
|
}
|
|
|
|
unauthReq := httptest.NewRequest(http.MethodGet, "/muse-code/models", nil)
|
|
unauthReq.Header.Set("Authorization", "Bearer wrong-key")
|
|
unauthRec := httptest.NewRecorder()
|
|
server.engine.ServeHTTP(unauthRec, unauthReq)
|
|
if unauthRec.Code != http.StatusUnauthorized {
|
|
t.Fatalf("unknown client key status = %d, want 401", unauthRec.Code)
|
|
}
|
|
|
|
keyReq := httptest.NewRequest(http.MethodPost, "/muse-code/key", nil)
|
|
keyReq.Header.Set("Authorization", "Bearer test-key")
|
|
keyRec := httptest.NewRecorder()
|
|
server.engine.ServeHTTP(keyRec, keyReq)
|
|
if keyRec.Code != http.StatusNotFound {
|
|
t.Fatalf("disallowed /muse-code/key status = %d, want 404", keyRec.Code)
|
|
}
|
|
|
|
// 2. Example API key safe mode blocks /muse-code/models with 403.
|
|
safeCfg := &proxyconfig.Config{
|
|
SDKConfig: sdkconfig.SDKConfig{
|
|
APIKeys: []string{"your-api-key-1"},
|
|
},
|
|
}
|
|
safeServer := newTestServerWithConfig(t, safeCfg, WithExampleAPIKeySafeMode())
|
|
safeReq := httptest.NewRequest(http.MethodGet, "/muse-code/models", nil)
|
|
safeReq.Header.Set("Authorization", "Bearer your-api-key-1")
|
|
safeRec := httptest.NewRecorder()
|
|
safeServer.engine.ServeHTTP(safeRec, safeReq)
|
|
if safeRec.Code != http.StatusForbidden {
|
|
t.Fatalf("safe mode status = %d, want 403; body=%s", safeRec.Code, safeRec.Body.String())
|
|
}
|
|
if upstreamCalls.Load() != 0 {
|
|
t.Fatalf("upstream called %d times, want 0", upstreamCalls.Load())
|
|
}
|
|
}
|