Refactor[Go Model Provider]: refactor baseURL and modelConfig (#15627)

### What problem does this PR solve?

As Title

### Type of change

- [x] Refactoring

internal/entity/models/tokenpony.go

@@ -29,32 +29,11 @@ import (
 )
 
 // TokenPonyModel implements ModelDriver for TokenPony. TokenPony is a
-// SaaS, OpenAI-compatible inference gateway hosting Qwen, DeepSeek,
-// Kimi, GLM, MiniMax, and Hunyuan families behind a single Bearer-token
-// API at https://ragflow.vip-api.tokenpony.cn/v1.
-//
-// Wire shape matches the OpenAI convention exactly:
-//   - POST /v1/chat/completions with {model, messages, stream, ...}
-//   - GET  /v1/models for the catalog
-//   - Authorization: Bearer <api-key> on every call
-//   - SSE response with `data:` lines and a [DONE] terminator
-//
-// Reasoning models surface chain-of-thought in `reasoning_content`
-// (OpenAI o-series shape), so the same handling as LongCat /
-// DeepSeek-R1 applies and there's no need for an inline <think>...
-// extractor like Novita's.
 type TokenPonyModel struct {
-	BaseURL    map[string]string
-	URLSuffix  URLSuffix
-	httpClient *http.Client
+	baseModel BaseModel
 }
 
 // NewTokenPonyModel creates a new TokenPony model instance.
-//
-// Same transport convention as the other Go drivers in this package:
-// clone http.DefaultTransport to keep ProxyFromEnvironment, DialContext,
-// HTTP/2, and TLS defaults, and only override the connection-pool
-// fields. No client-level Timeout so SSE streams aren't capped mid-flight.
 func NewTokenPonyModel(baseURL map[string]string, urlSuffix URLSuffix) *TokenPonyModel {
 	transport := http.DefaultTransport.(*http.Transport).Clone()
 	transport.MaxIdleConns = 100
@@ -64,52 +43,39 @@ func NewTokenPonyModel(baseURL map[string]string, urlSuffix URLSuffix) *TokenPon
 	transport.ResponseHeaderTimeout = 60 * time.Second
 
 	return &TokenPonyModel{
-		BaseURL:   baseURL,
-		URLSuffix: urlSuffix,
-		httpClient: &http.Client{
-			Transport: transport,
+		baseModel: BaseModel{
+			BaseURL:   baseURL,
+			URLSuffix: urlSuffix,
+			httpClient: &http.Client{
+				Transport: transport,
+			},
 		},
 	}
 }
 
 func (t *TokenPonyModel) NewInstance(baseURL map[string]string) ModelDriver {
-	return NewTokenPonyModel(baseURL, t.URLSuffix)
+	return NewTokenPonyModel(baseURL, t.baseModel.URLSuffix)
 }
 
 func (t *TokenPonyModel) Name() string {
 	return "tokenpony"
 }
 
-func (t *TokenPonyModel) baseURLForRegion(region string) (string, error) {
-	base, ok := t.BaseURL[region]
-	if !ok || base == "" {
-		return "", fmt.Errorf("tokenpony: no base URL configured for region %q", region)
-	}
-	return strings.TrimSuffix(base, "/"), nil
-}
-
-// ChatWithMessages sends a non-streaming chat request and returns the
-// full response. Forwards documented OpenAI-shaped parameters when the
-// caller supplies them; reasoning_content is surfaced separately so the
-// visible Answer is never polluted by chain-of-thought.
+// ChatWithMessages sends a non-streaming chat request
 func (t *TokenPonyModel) ChatWithMessages(modelName string, messages []Message, apiConfig *APIConfig, chatModelConfig *ChatConfig) (*ChatResponse, error) {
-	if apiConfig == nil || apiConfig.ApiKey == nil || *apiConfig.ApiKey == "" {
-		return nil, fmt.Errorf("api key is required")
+	if err := t.baseModel.APIConfigCheck(apiConfig); err != nil {
+		return nil, err
 	}
 	if len(messages) == 0 {
 		return nil, fmt.Errorf("messages is empty")
 	}
 
-	region := "default"
-	if apiConfig.Region != nil && *apiConfig.Region != "" {
-		region = *apiConfig.Region
-	}
-
-	baseURL, err := t.baseURLForRegion(region)
+	baseURL, err := t.baseModel.GetBaseURL(apiConfig)
 	if err != nil {
 		return nil, err
 	}
-	url := fmt.Sprintf("%s/%s", baseURL, t.URLSuffix.Chat)
+	baseURL = strings.TrimSuffix(baseURL, "/")
+	url := fmt.Sprintf("%s/%s", baseURL, t.baseModel.URLSuffix.Chat)
 
 	apiMessages := make([]map[string]interface{}, len(messages))
 	for i, msg := range messages {
@@ -155,7 +121,7 @@ func (t *TokenPonyModel) ChatWithMessages(modelName string, messages []Message,
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", *apiConfig.ApiKey))
 
-	resp, err := t.httpClient.Do(req)
+	resp, err := t.baseModel.httpClient.Do(req)
 	if err != nil {
 		return nil, fmt.Errorf("failed to send request: %w", err)
 	}
@@ -194,10 +160,6 @@ func (t *TokenPonyModel) ChatWithMessages(modelName string, messages []Message,
 		return nil, fmt.Errorf("invalid content format")
 	}
 
-	// Reasoning models (deepseek-r1 / kimi / glm-thinking) put
-	// chain-of-thought in a separate `reasoning_content` field with
-	// `content` already cleaned. Absent or non-string means no reasoning
-	// was emitted; leave it empty rather than synthesizing one.
 	reasonContent := ""
 	if r, ok := messageMap["reasoning_content"].(string); ok {
 		reasonContent = r
@@ -209,31 +171,25 @@ func (t *TokenPonyModel) ChatWithMessages(modelName string, messages []Message,
 	}, nil
 }
 
-// ChatStreamlyWithSender opens the SSE chat-completions endpoint and
-// forwards each delta through the supplied sender. Reasoning chunks go
-// to the sender's second argument, content chunks to the first; the
-// stream is terminated by either `[DONE]` or a delta with finish_reason.
+// ChatStreamlyWithSender opens the SSE chat-completions
 func (t *TokenPonyModel) ChatStreamlyWithSender(modelName string, messages []Message, apiConfig *APIConfig, chatModelConfig *ChatConfig, sender func(*string, *string) error) error {
+	if err := t.baseModel.APIConfigCheck(apiConfig); err != nil {
+		return err
+	}
+
 	if sender == nil {
 		return fmt.Errorf("sender is required")
 	}
 	if len(messages) == 0 {
 		return fmt.Errorf("messages is empty")
 	}
-	if apiConfig == nil || apiConfig.ApiKey == nil || *apiConfig.ApiKey == "" {
-		return fmt.Errorf("api key is required")
-	}
 
-	region := "default"
-	if apiConfig.Region != nil && *apiConfig.Region != "" {
-		region = *apiConfig.Region
-	}
-
-	baseURL, err := t.baseURLForRegion(region)
+	baseURL, err := t.baseModel.GetBaseURL(apiConfig)
 	if err != nil {
 		return err
 	}
-	url := fmt.Sprintf("%s/%s", baseURL, t.URLSuffix.Chat)
+	baseURL = strings.TrimSuffix(baseURL, "/")
+	url := fmt.Sprintf("%s/%s", baseURL, t.baseModel.URLSuffix.Chat)
 
 	apiMessages := make([]map[string]interface{}, len(messages))
 	for i, msg := range messages {
@@ -250,9 +206,6 @@ func (t *TokenPonyModel) ChatStreamlyWithSender(modelName string, messages []Mes
 	}
 
 	if chatModelConfig != nil {
-		// Guard against the caller asking for stream=false on a code path
-		// that only knows how to read SSE. Without this, a non-SSE JSON
-		// body would parse as zero chunks and look like a silent timeout.
 		if chatModelConfig.Stream != nil && !*chatModelConfig.Stream {
 			return fmt.Errorf("stream must be true in ChatStreamlyWithSender")
 		}
@@ -275,8 +228,6 @@ func (t *TokenPonyModel) ChatStreamlyWithSender(modelName string, messages []Mes
 		return fmt.Errorf("failed to marshal request: %w", err)
 	}
 
-	// SSE is long-lived; rely on the transport's ResponseHeaderTimeout
-	// to cap connection-establishment instead of a hard deadline.
 	req, err := http.NewRequestWithContext(context.Background(), "POST", url, bytes.NewBuffer(jsonData))
 	if err != nil {
 		return fmt.Errorf("failed to create request: %w", err)
@@ -284,7 +235,7 @@ func (t *TokenPonyModel) ChatStreamlyWithSender(modelName string, messages []Mes
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", *apiConfig.ApiKey))
 
-	resp, err := t.httpClient.Do(req)
+	resp, err := t.baseModel.httpClient.Do(req)
 	if err != nil {
 		return fmt.Errorf("failed to send request: %w", err)
 	}
@@ -311,15 +262,9 @@ func (t *TokenPonyModel) ChatStreamlyWithSender(modelName string, messages []Mes
 
 		var event map[string]interface{}
 		if err = json.Unmarshal([]byte(data), &event); err != nil {
-			// A malformed frame usually means a truncated event or an
-			// upstream incident. Surface it instead of silently producing
-			// partial output.
 			return fmt.Errorf("tokenpony: invalid SSE event: %w", err)
 		}
 
-		// TokenPony can emit a terminal `{"error": ...}` frame when the
-		// upstream model rejects mid-stream (rate limit, content policy).
-		// Surface it verbatim instead of falling through to "no choices".
 		if apiErr, ok := event["error"]; ok {
 			return fmt.Errorf("tokenpony: upstream stream error: %v", apiErr)
 		}
@@ -332,10 +277,7 @@ func (t *TokenPonyModel) ChatStreamlyWithSender(modelName string, messages []Mes
 		if !ok {
 			continue
 		}
-		// Reasoning first, content second — matches the wire ordering
-		// for reasoning models and lets UIs render the chain-of-thought
-		// before the visible token. A terminal frame may carry
-		// finish_reason without a delta, so don't skip when delta is absent.
+
 		if delta, ok := firstChoice["delta"].(map[string]interface{}); ok {
 			if r, ok := delta["reasoning_content"].(string); ok && r != "" {
 				rr := r
@@ -370,24 +312,17 @@ func (t *TokenPonyModel) ChatStreamlyWithSender(modelName string, messages []Mes
 	return nil
 }
 
-// ListModels returns the model ids visible to the API key by calling
-// /v1/models. Used by Add-Provider's connection check and by the UI's
-// model picker.
 func (t *TokenPonyModel) ListModels(apiConfig *APIConfig) ([]string, error) {
-	if apiConfig == nil || apiConfig.ApiKey == nil || *apiConfig.ApiKey == "" {
-		return nil, fmt.Errorf("api key is required")
+	if err := t.baseModel.APIConfigCheck(apiConfig); err != nil {
+		return nil, err
 	}
 
-	region := "default"
-	if apiConfig.Region != nil && *apiConfig.Region != "" {
-		region = *apiConfig.Region
-	}
-
-	baseURL, err := t.baseURLForRegion(region)
+	baseURL, err := t.baseModel.GetBaseURL(apiConfig)
 	if err != nil {
 		return nil, err
 	}
-	url := fmt.Sprintf("%s/%s", baseURL, t.URLSuffix.Models)
+	baseURL = strings.TrimSuffix(baseURL, "/")
+	url := fmt.Sprintf("%s/%s", baseURL, t.baseModel.URLSuffix.Models)
 
 	ctx, cancel := context.WithTimeout(context.Background(), nonStreamCallTimeout)
 	defer cancel()
@@ -398,7 +333,7 @@ func (t *TokenPonyModel) ListModels(apiConfig *APIConfig) ([]string, error) {
 	}
 	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", *apiConfig.ApiKey))
 
-	resp, err := t.httpClient.Do(req)
+	resp, err := t.baseModel.httpClient.Do(req)
 	if err != nil {
 		return nil, fmt.Errorf("failed to send request: %w", err)
 	}
@@ -437,17 +372,12 @@ func (t *TokenPonyModel) ListModels(apiConfig *APIConfig) ([]string, error) {
 	return models, nil
 }
 
-// CheckConnection verifies the API key by calling ListModels. The /v1/models
-// endpoint is the documented lightweight way to validate credentials on
-// OpenAI-compatible gateways without burning chat-completion quota.
+// CheckConnection verifies the API key by calling ListModels.
 func (t *TokenPonyModel) CheckConnection(apiConfig *APIConfig) error {
 	_, err := t.ListModels(apiConfig)
 	return err
 }
 
-// Embed is not implemented for TokenPony in this initial driver; the
-// factory entry only registers chat models. Mirrors how LongCat /
-// Astraflow landed chat-only.
 func (t *TokenPonyModel) Embed(modelName *string, texts []string, apiConfig *APIConfig, embeddingConfig *EmbeddingConfig) ([]EmbeddingData, error) {
 	return nil, fmt.Errorf("%s, no such method", t.Name())
 }