fix: align BigModel provider endpoints

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: ganisback

README.md

@@ -104,7 +104,7 @@ Supported providers include:
 | DeepSeek | - | `https://api.deepseek.com/v1` |
 | MiMo | Xiaomi | `https://api.xiaomimimo.com/v1` |
 | Kimi | Moonshot | `https://api.moonshot.cn/v1` |
-| BigModel | Zhipu/智谱AI | `https://open.bigmodel.cn/api/coding/paas/v4` |
+| BigModel | Zhipu/智谱AI | `https://open.bigmodel.cn/api/paas/v4` |
 | Qianfan | Baidu | `https://qianfan.baidubce.com/v2` |
 | MiniMax | - | `https://api.minimax.chat/v1` |
 | OpenRouter | - | `https://openrouter.ai/api/v1` |

internal/cli/launch_prepare_test.go

@@ -281,25 +281,34 @@ func TestPrepareCodexLaunchIncludesModelCatalog(t *testing.T) {
 		t.Fatalf("prepareCodexLaunch returned error: %v", err)
 	}
 
+	if len(prepared.Args) != 2 || prepared.Args[0] != "--model" || prepared.Args[1] != "Qwen/Qwen3.5-2B" {
+		t.Fatalf("prepared args = %#v, want only --model override", prepared.Args)
+	}
+	data, err := os.ReadFile(filepath.Join(home, ".codex", "config.toml"))
+	if err != nil {
+		t.Fatalf("read codex config: %v", err)
+	}
+	configText := string(data)
 	for _, want := range []string{
-		`model_provider="csghub_lite"`,
-		`model_providers.csghub_lite.name="OpenCSG"`,
-		`model_providers.csghub_lite.base_url=` + strconv.Quote(server.URL+"/v1"),
-		`model_providers.csghub_lite.supports_websockets=false`,
+		`model_provider = "csghub_lite"`,
+		`[model_providers.csghub_lite]`,
+		`name = "OpenCSG"`,
+		`base_url = ` + strconv.Quote(server.URL+"/v1"),
+		`supports_websockets = false`,
 	} {
-		if !hasConfigOverride(prepared.Args, want) {
-			t.Fatalf("missing Codex config override %q in args %#v", want, prepared.Args)
+		if !strings.Contains(configText, want) {
+			t.Fatalf("codex config missing %q:\n%s", want, configText)
 		}
 	}
-	catalogValue := configValue(prepared.Args, "model_catalog_json=")
+	catalogValue := configValueFromConfig(configText, "model_catalog_json")
 	if catalogValue == "" {
-		t.Fatalf("missing model_catalog_json config in args %#v", prepared.Args)
+		t.Fatalf("missing model_catalog_json config:\n%s", configText)
 	}
 	catalogPath, err := strconv.Unquote(catalogValue)
 	if err != nil {
 		t.Fatalf("unquote model_catalog_json %q: %v", catalogValue, err)
 	}
-	data, err := os.ReadFile(catalogPath)
+	data, err = os.ReadFile(catalogPath)
 	if err != nil {
 		t.Fatalf("read model catalog: %v", err)
 	}
@@ -319,10 +328,10 @@ func TestPrepareCodexLaunchIncludesModelCatalog(t *testing.T) {
 	if len(payload.Models) != 2 {
 		t.Fatalf("model catalog count = %d, want 2", len(payload.Models))
 	}
-	if payload.Models[0].Slug != "Qwen/Qwen3.5-2B" || payload.Models[0].DisplayName != "Qwen 3.5 2B" {
+	if payload.Models[0].Slug != "Qwen/Qwen3.5-2B" {
 		t.Fatalf("unexpected first model entry: %#v", payload.Models[0])
 	}
-	if payload.Models[1].Slug != "afrideva/Qwen2-0.5B-Instruct-GGUF:fh23aijhzx8g" || payload.Models[1].DisplayName != "Qwen2-0.5B-Instruct-GGUF" {
+	if payload.Models[1].Slug != "afrideva/Qwen2-0.5B-Instruct-GGUF:fh23aijhzx8g" {
 		t.Fatalf("unexpected second model entry: %#v", payload.Models[1])
 	}
 	if payload.Models[0].Visibility != "list" || payload.Models[1].Visibility != "list" {
@@ -772,6 +781,21 @@ func configValue(args []string, prefix string) string {
 	return ""
 }
 
+func configValueFromConfig(configText, key string) string {
+	for _, line := range strings.Split(configText, "\n") {
+		line = strings.TrimSpace(line)
+		if line == "" || strings.HasPrefix(line, "#") {
+			continue
+		}
+		before, after, ok := strings.Cut(line, "=")
+		if !ok || strings.TrimSpace(before) != key {
+			continue
+		}
+		return strings.TrimSpace(after)
+	}
+	return ""
+}
+
 func argValue(args []string, flag string) string {
 	for i := 0; i+1 < len(args); i++ {
 		if args[i] == flag {

internal/inference/openai.go

@@ -14,29 +14,58 @@ import (
 )
 
 type openAIEngine struct {
-	baseURL   string
-	modelName string
-	token     string
-	client    *http.Client
+	baseURL            string
+	chatCompletionsURL string
+	modelName          string
+	token              string
+	client             *http.Client
 }
 
 func NewOpenAIEngine(baseURL, modelName, token string) Engine {
+	baseURL = strings.TrimRight(baseURL, "/")
 	return &openAIEngine{
-		baseURL:   strings.TrimRight(baseURL, "/"),
-		modelName: modelName,
-		token:     strings.TrimSpace(token),
-		client:    &http.Client{Timeout: 0},
+		baseURL:            baseURL,
+		chatCompletionsURL: openAIChatCompletionsURL(baseURL),
+		modelName:          modelName,
+		token:              strings.TrimSpace(token),
+		client:             &http.Client{Timeout: 0},
 	}
 }
 
+func NewOpenAICompatibleEngine(baseURL, modelName, token string) Engine {
+	baseURL = strings.TrimRight(baseURL, "/")
+	return &openAIEngine{
+		baseURL:            baseURL,
+		chatCompletionsURL: openAICompatibleChatCompletionsURL(baseURL),
+		modelName:          modelName,
+		token:              strings.TrimSpace(token),
+		client:             &http.Client{Timeout: 0},
+	}
+}
+
+func openAIChatCompletionsURL(baseURL string) string {
+	return strings.TrimRight(baseURL, "/") + "/v1/chat/completions"
+}
+
+func openAICompatibleChatCompletionsURL(baseURL string) string {
+	return strings.TrimRight(baseURL, "/") + "/chat/completions"
+}
+
+func (e *openAIEngine) chatCompletionsEndpoint() string {
+	if strings.TrimSpace(e.chatCompletionsURL) != "" {
+		return e.chatCompletionsURL
+	}
+	return openAIChatCompletionsURL(e.baseURL)
+}
+
 func (e *openAIEngine) ChatCompletion(ctx context.Context, reqBody map[string]interface{}) (*http.Response, error) {
 	reqBody = sanitizeOpenAIRequestBody(e.modelName, reqBody)
 	body, err := json.Marshal(reqBody)
 	if err != nil {
 		return nil, fmt.Errorf("marshaling request: %w", err)
 	}
 
-	req, err := http.NewRequestWithContext(ctx, http.MethodPost, e.baseURL+"/v1/chat/completions", bytes.NewReader(body))
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, e.chatCompletionsEndpoint(), bytes.NewReader(body))
 	if err != nil {
 		return nil, fmt.Errorf("creating request: %w", err)
 	}
@@ -95,7 +124,7 @@ func (e *openAIEngine) Chat(ctx context.Context, messages []Message, opts Option
 		return "", fmt.Errorf("marshaling request: %w", err)
 	}
 
-	req, err := http.NewRequestWithContext(ctx, http.MethodPost, e.baseURL+"/v1/chat/completions", bytes.NewReader(body))
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, e.chatCompletionsEndpoint(), bytes.NewReader(body))
 	if err != nil {
 		return "", fmt.Errorf("creating request: %w", err)
 	}

internal/server/handlers_providers.go

@@ -19,7 +19,7 @@ func (s *Server) handleProvidersList(w http.ResponseWriter, r *http.Request) {
 		resp.Providers[i] = api.ThirdPartyProvider{
 			ID:       p.ID,
 			Name:     p.Name,
-			BaseURL:  p.BaseURL,
+			BaseURL:  normalizeThirdPartyProviderBaseURL(p),
 			Provider: p.Provider,
 			Enabled:  p.Enabled,
 			// APIKey is intentionally not returned for security
@@ -96,6 +96,7 @@ func (s *Server) handleProviderCreate(w http.ResponseWriter, r *http.Request) {
 		Provider: provider,
 		Enabled:  req.Enabled,
 	}
+	newProvider.BaseURL = normalizeThirdPartyProviderBaseURL(newProvider)
 	if _, err := validateThirdPartyProvider(r.Context(), newProvider); err != nil {
 		writeError(w, http.StatusBadRequest, "provider configuration is invalid: "+err.Error())
 		return
@@ -151,6 +152,7 @@ func (s *Server) handleProviderUpdate(w http.ResponseWriter, r *http.Request) {
 			if req.Enabled != nil {
 				candidate.Enabled = *req.Enabled
 			}
+			candidate.BaseURL = normalizeThirdPartyProviderBaseURL(candidate)
 			if _, err := validateThirdPartyProvider(r.Context(), candidate); err != nil {
 				writeError(w, http.StatusBadRequest, "provider configuration is invalid: "+err.Error())
 				return

internal/server/handlers_providers_test.go

@@ -228,6 +228,80 @@ func TestThirdPartyProviderEngineTrimsV1BaseURL(t *testing.T) {
 	}
 }
 
+func TestThirdPartyProviderEngineUsesCompatibleBaseURLPath(t *testing.T) {
+	home := t.TempDir()
+	t.Setenv("HOME", home)
+	t.Setenv("USERPROFILE", home)
+	config.ResetProviders()
+	t.Cleanup(config.ResetProviders)
+
+	var modelPath, chatPath string
+	apiServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/paas/v4/models":
+			modelPath = r.URL.Path
+			w.Header().Set("Content-Type", "application/json")
+			_, _ = fmt.Fprint(w, `{"data":[{"id":"glm-5.1"}]}`)
+		case "/api/paas/v4/chat/completions":
+			chatPath = r.URL.Path
+			w.Header().Set("Content-Type", "application/json")
+			_, _ = fmt.Fprint(w, `{"choices":[{"message":{"role":"assistant","content":"ok"}}]}`)
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	defer apiServer.Close()
+
+	if err := config.SaveProviders([]config.ThirdPartyProvider{{
+		ID:       "provider1",
+		Name:     "BigModel",
+		BaseURL:  apiServer.URL + "/api/paas/v4",
+		APIKey:   "secret",
+		Provider: "bigmodel",
+		Enabled:  true,
+	}}); err != nil {
+		t.Fatalf("save providers: %v", err)
+	}
+
+	models, err := listOpenAICompatibleProviderModels(context.Background(), config.GetProviders()[0])
+	if err != nil {
+		t.Fatalf("list models returned error: %v", err)
+	}
+	if len(models) != 1 || models[0].Model != "glm-5.1" {
+		t.Fatalf("models = %#v", models)
+	}
+
+	eng, err := newThirdPartyProviderEngine("provider:provider1", "glm-5.1")
+	if err != nil {
+		t.Fatalf("new engine: %v", err)
+	}
+	got, err := eng.Chat(context.Background(), nil, inference.DefaultOptions(), nil)
+	if err != nil {
+		t.Fatalf("chat returned error: %v", err)
+	}
+	if got != "ok" {
+		t.Fatalf("chat = %q, want ok", got)
+	}
+	if modelPath != "/api/paas/v4/models" {
+		t.Fatalf("model path = %q", modelPath)
+	}
+	if chatPath != "/api/paas/v4/chat/completions" {
+		t.Fatalf("chat path = %q", chatPath)
+	}
+}
+
+func TestBigModelLegacyPresetBaseURLNormalizesToOfficialPath(t *testing.T) {
+	provider := config.ThirdPartyProvider{
+		Name:     "BigModel",
+		BaseURL:  "https://open.bigmodel.cn/api/coding/paas/v4/",
+		Provider: "bigmodel",
+	}
+
+	if got := normalizeThirdPartyProviderBaseURL(provider); got != bigModelOfficialBaseURL {
+		t.Fatalf("base URL = %q, want %q", got, bigModelOfficialBaseURL)
+	}
+}
+
 func TestGetChatEnginePrefersThirdPartyWhenCloudLoginMissing(t *testing.T) {
 	home := t.TempDir()
 	t.Setenv("HOME", home)

internal/server/third_party_providers.go

@@ -17,6 +17,11 @@ import (
 )
 
 const thirdPartyProviderSourcePrefix = "provider:"
+const (
+	bigModelProviderType        = "bigmodel"
+	bigModelOfficialBaseURL     = "https://open.bigmodel.cn/api/paas/v4"
+	bigModelLegacyCodingBaseURL = "https://open.bigmodel.cn/api/coding/paas/v4"
+)
 
 func providerSource(id string) string {
 	return thirdPartyProviderSourcePrefix + strings.TrimSpace(id)
@@ -51,13 +56,13 @@ func (s *Server) listThirdPartyProviderModels(ctx context.Context) []api.ModelIn
 
 	// Use cached data if available and fresh (within 30 seconds).
 	// This avoids repeated API calls to third-party providers.
-		s.thirdPartyModelsCacheMu.Lock()
+	s.thirdPartyModelsCacheMu.Lock()
 	if s.thirdPartyModelsCache != nil && time.Since(s.thirdPartyModelsCacheAt) < 30*time.Second {
 		cache := s.thirdPartyModelsCache
 		s.thirdPartyModelsCacheMu.Unlock()
 		return cache
 	}
-		s.thirdPartyModelsCacheMu.Unlock()
+	s.thirdPartyModelsCacheMu.Unlock()
 
 	// Query all providers in parallel to reduce latency.
 	var mu sync.Mutex
@@ -95,7 +100,7 @@ func (s *Server) listThirdPartyProviderModels(ctx context.Context) []api.ModelIn
 }
 
 func listOpenAICompatibleProviderModels(ctx context.Context, provider config.ThirdPartyProvider) ([]api.ModelInfo, error) {
-	baseURL := strings.TrimRight(strings.TrimSpace(provider.BaseURL), "/")
+	baseURL := normalizeThirdPartyProviderBaseURL(provider)
 	if baseURL == "" || strings.TrimSpace(provider.APIKey) == "" {
 		return nil, nil
 	}
@@ -146,9 +151,13 @@ func listOpenAICompatibleProviderModels(ctx context.Context, provider config.Thi
 	return models, nil
 }
 
-func providerEngineBaseURL(baseURL string) string {
-	baseURL = strings.TrimRight(strings.TrimSpace(baseURL), "/")
-	return strings.TrimSuffix(baseURL, "/v1")
+func normalizeThirdPartyProviderBaseURL(provider config.ThirdPartyProvider) string {
+	baseURL := strings.TrimRight(strings.TrimSpace(provider.BaseURL), "/")
+	providerType := strings.TrimSpace(strings.ToLower(provider.Provider))
+	if providerType == bigModelProviderType && strings.EqualFold(baseURL, bigModelLegacyCodingBaseURL) {
+		return bigModelOfficialBaseURL
+	}
+	return baseURL
 }
 
 func validateThirdPartyProvider(ctx context.Context, provider config.ThirdPartyProvider) (int, error) {
@@ -177,10 +186,10 @@ func newThirdPartyProviderEngine(source, modelID string) (inference.Engine, erro
 	if !provider.Enabled {
 		return nil, inference.NewHTTPStatusError(http.StatusForbidden, "third-party provider is disabled")
 	}
-	baseURL := strings.TrimSpace(provider.BaseURL)
+	baseURL := normalizeThirdPartyProviderBaseURL(provider)
 	apiKey := strings.TrimSpace(provider.APIKey)
 	if baseURL == "" || apiKey == "" {
 		return nil, inference.NewHTTPStatusError(http.StatusBadRequest, "third-party provider is missing base URL or API key")
 	}
-	return inference.NewOpenAIEngine(providerEngineBaseURL(baseURL), modelID, apiKey), nil
+	return inference.NewOpenAICompatibleEngine(baseURL, modelID, apiKey), nil
 }

web/src/pages/Settings.tsx

@@ -76,7 +76,7 @@ const providerTypes = [
   { value: "deepseek", label: "DeepSeek", name: "DeepSeek", baseURL: "https://api.deepseek.com/v1" },
   { value: "mimo", label: "MiMo (Xiaomi)", name: "MiMo", baseURL: "https://api.xiaomimimo.com/v1" },
   { value: "kimi", label: "Kimi (Moonshot)", name: "Kimi", baseURL: "https://api.moonshot.cn/v1" },
-  { value: "bigmodel", label: "BigModel (Zhipu)", name: "BigModel", baseURL: "https://open.bigmodel.cn/api/coding/paas/v4" },
+  { value: "bigmodel", label: "BigModel (Zhipu)", name: "BigModel", baseURL: "https://open.bigmodel.cn/api/paas/v4" },
   { value: "qianfan", label: "Qianfan (Baidu)", name: "Qianfan", baseURL: "https://qianfan.baidubce.com/v2" },
   { value: "openrouter", label: "OpenRouter", name: "OpenRouter", baseURL: "https://openrouter.ai/api/v1" },
   { value: "other", label: "Other", name: "", baseURL: "" },